parameter_chain 0.0.1

data/README.md

@@ -0,0 +1,74 @@
+## Parameter Chain
+
+Parameter Chain allows you to chain methods to specify parameters, e.g.
+
+```ruby
+instance.bar(123).baz(321)
+```
+
+Which would be equivalent to:
+
+```ruby
+instance.some_method(:bar => 123, :baz => 321)
+```
+
+Parameter Chain provides a great out-of-the-box interface for dealing with search, or querying an API:
+
+```ruby
+api = SomeApi.new(key)
+api.category(3).price('> 1000').brand(:apple)
+```
+
+Which would be equivalent to:
+
+```ruby
+api = SomeApi.new(key)
+api.search(:category => 3, :price => '> 1000', :brand => :apple)
+```
+
+## Setup
+
+```
+gem install parameter_chain
+```
+
+```ruby
+require 'parameter_chain'
+
+class MyClass
+  def my_method(params = {})
+    # Do something with params, e.g.
+    "Params: #{params.inspect}"
+  end
+  parameter_chain :my_method, :foo, :bar
+end
+
+instance = MyClass.new
+instance.foo(123).bar(321)
+#=> "Params: { :foo => 123, :bar => 321 }"
+```
+
+## Lazy Evaluation
+
+Parameter chains are evaluated lazily. When you call something on the end of your chain, it passes the parameters to the method and evaluates.
+
+If you're in IRB, the inspect method is called implicitly. This is why your chains look like hashes. You can verify this by running:
+
+```ruby
+instance.foo(123).bar(321).__class__
+#=> ParameterChain
+```
+
+## Coming Soon
+
+Chaining from class methods, e.g.
+
+```ruby
+MyClass.foo(123).bar(321)
+```
+
+## Contribution
+
+Feel free. No pull request is too small.
+
+Twitter: [@cpatuzzo](https://twitter.com/#!/cpatuzzo)

data/lib/parameter_chain.rb

@@ -0,0 +1,46 @@
+class ParameterChain
+  alias_method :__class__, :class
+
+  instance_methods.each do |method|
+    next if method == :object_id
+    next if method =~ /^__/ # Internal methods.
+
+    undef_method method
+  end
+
+  def initialize(object, callback, params)
+    @object = object
+    @callback = callback
+
+    @hash = {}
+    params.each do |param|
+      __class__.send(:define_method, param) do |arg|
+        @hash[param] = arg
+        self
+      end
+    end
+  end
+
+  def method_missing(method, *args)
+    @object.send(@callback, @hash).send(method, *args)
+  end
+
+  def self.for(klass, callback, params)
+    this = self # Store self for use in block scope.
+
+    params.each do |param|
+      klass.send(:define_method, param) do |arg|
+        chain = this.new(self, callback, params)
+        chain.__send__(param, arg)
+      end
+    end
+
+    nil
+  end
+end
+
+class Object
+  def self.parameter_chain(callback, *params)
+    ParameterChain.for(self, callback, params)
+  end
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: parameter_chain
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Christopher Patuzzo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2157132360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2157132360
+description: Chain methods to specify parameters
+email: chris@patuzzo.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/parameter_chain.rb
+homepage: https://github.com/cpatuzzo/parameter_chain
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Parameter Chain
+test_files: []
+has_rdoc: