From: Pito Salas <rps@...>
Date: 2009-01-24T23:08:07+09:00
Subject: Help me understand this technique from an open source app?

n the code at the bottom (from HTTParty), the module is included in
some other class ("O"), and among the effects is that (for example)
the method default_params becomes available in "O". I don't understand
the technique. Given that the module is used as a mixin, then if I
wanted to have that method, I could just define it under module
HTTParty with a normal def. Moreover, the following doesn't work:

class Parent
 include HTTParty

 def my_method
     default_params :x => "X"
 end
end

class Child < Parent
 def other
    my_method
 end
end

There's some sophisticated meta programming going on. Any help
understanding it would be greatly appreciated!

Pito

=============from HTTParty==============
module HTTParty
 AllowedFormats = {:xml => 'text/xml', :json => 'application/json',
:html => 'text/html'}

 def self.included(base)
  base.extend ClassMethods
  base.send :include, ModuleLevelInheritableAttributes
  base.send(:mattr_inheritable, :default_options)
  base.instance_variable_set("@default_options", {})
 end

 module ClassMethods
  def default_options
    @default_options
  end

  def http_proxy(addr=nil, port = nil)
    default_options[:http_proxyaddr] = addr
    default_options[:http_proxyport] = port
  end

  def base_uri(uri=nil)
    return default_options[:base_uri] unless uri
    default_options[:base_uri] = HTTParty.normalize_base_uri(uri)
  end

  def basic_auth(u, p)
    default_options[:basic_auth] = {:username => u, :password => p}
  end

  def default_params(h={})
    raise ArgumentError, 'Default params must be a hash' unless
h.is_a?(Hash)
    default_options[:default_params] ||= {}
    default_options[:default_params].merge!(h)
  end

  def headers(h={})
    raise ArgumentError, 'Headers must be a hash' unless h.is_a?
(Hash)
    default_options[:headers] ||= {}
    default_options[:headers].merge!(h)
  end

  def format(f)
    raise UnsupportedFormat, "Must be one of:
#{AllowedFormats.keys.join(', ')}" unless AllowedFormats.key?(f)
    default_options[:format] = f
  end

  def get(path, options={})
    perform_request Net::HTTP::Get, path, options
  end

  def post(path, options={})
    perform_request Net::HTTP::Post, path, options
  end

  def put(path, options={})
    perform_request Net::HTTP::Put, path, options
  end

  def delete(path, options={})
    perform_request Net::HTTP::Delete, path, options
  end

  private
    def perform_request(http_method, path, options) #:nodoc:
      Request.new(http_method, path,
default_options.dup.merge(options)).perform
    end
 end
-- 
Posted via http://www.ruby-forum.com/.