named-parameters 0.0.18 → 0.0.19

data/RELEASENOTES

@@ -1,4 +1,12 @@
-0.0.18 [Dec 10, 201D]
+0.0.19 [Dec 11, 2010]
+- [INTERNAL] Will no longer require "bundler/setup" 
+  See: https://github.com/jurisgalang/named-parameters/issues#issue/2
+- [INTERNAL] Added necessary modifications to support Ruby 1.8.6
+  See: https://github.com/jurisgalang/named-parameters/issues#issue/4
+- [INTERNAL] Intercept method will no longer pass blocks to intercepted 
+  method (temporary)
+
+0.0.18 [Dec 10, 2010]
 - [INTERNAL] No longer relies on self.name to determine the current class' 
   name, because singleton method name in Class could also be overriden.
   See: [Issue #3](https://github.com/jurisgalang/named-parameters/issues#issue/3)

data/VERSION

@@ -1 +1 @@
-0.0.18
+0.0.19

data/lib/named-parameters.rb

@@ -1,6 +1,6 @@
 require "rubygems"
-require "bundler/setup"
 
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib')) if RUBY_VERSION =~ /^(1\.8\.6)/
 require 'named-parameters/module'
 
 # Extend object to automatically make it available for all

data/lib/named-parameters/module.rb

@@ -217,11 +217,27 @@ module NamedParameters
     def has_named_parameters method, spec, mode = :strict
       # ensure spec entries are initialized and the proper types
       [ :required, :optional, :oneof ].each{ |k| spec[k] ||= [] }
-      spec = Hash[ spec.map{ |k, v| 
+      
+      # assemble/normalize method spec; the following code should 
+      # just be:
+      # 
+      #   spec = Hash[ spec.map{ |k, v| 
+      #     v = [ v ] unless v.instance_of? Array
+      #     v.map!{ |entry| entry.instance_of?(Array) ? Hash[*entry] : entry }
+      #     [ k, v ] 
+      #   } ] 
+      # 
+      # but we have to play nice with ruby 1.8.6, so we'll have to be content
+      # with the ugliness for now...
+      pairs = spec.map{ |k, v| 
         v = [ v ] unless v.instance_of? Array
         v.map!{ |entry| entry.instance_of?(Array) ? Hash[*entry] : entry }
         [ k, v ]
-      } ]
+      }
+      spec = { }
+      pairs.each{ |x| spec[x[0]] = x[1] }
+      spec = Hash[ spec ] 
+
       spec[:mode] = mode
       method_specs[key_for(method)] = spec
       yield spec if block_given?
@@ -238,7 +254,7 @@ module NamedParameters
     #
     def requires *params, &block
       [ :'self.new', :initialize ].each do |method|
-        spec = method_specs[key_for method] || { }
+        spec = method_specs[key_for(method)] || { }
         spec.merge!(:required => params)
         has_named_parameters method, spec, :strict, &block
       end
@@ -255,7 +271,7 @@ module NamedParameters
     #
     def recognizes *params, &block
       [ :'self.new', :initialize ].each do |method|
-        spec = method_specs[key_for method] || { }
+        spec = method_specs[key_for(method)] || { }
         spec.merge!(:optional => params)
         has_named_parameters method, spec, :strict, &block
       end
@@ -297,10 +313,10 @@ module NamedParameters
     # add instrumentation for class methods
     def singleton_method_added name  # :nodoc:
       apply_method_spec :"self.#{name}" do
-        method = self.eigenclass.instance_method name
-        spec   = method_specs[key_for :"self.#{name}"]
+        method = self.metaclass.instance_method name
+        spec   = method_specs[key_for(:"self.#{name}")]
         owner  = "#{self}::"
-        eigenclass.instance_eval do
+        metaclass.instance_eval do
           intercept method, owner, name, spec
         end
       end
@@ -311,7 +327,7 @@ module NamedParameters
     def method_added name  # :nodoc:
       apply_method_spec name do
         method = instance_method name
-        spec   = method_specs[key_for name]
+        spec   = method_specs[key_for(name)]
         owner  = "#{self}#"
         intercept method, owner, name, spec
       end
@@ -331,7 +347,8 @@ module NamedParameters
     # insert parameter validation prior to executing the instrumented method
     def intercept method, owner, name, spec  # :nodoc:
       fullname = "#{owner}#{name}"
-      define_method name do |*args, &block|
+      #define_method name do |*args, &block|
+      define_method name do |*args|
         # locate the argument representing the named parameters value
         # for the method invocation
         params = args.last
@@ -352,7 +369,8 @@ module NamedParameters
         # inject the updated argument values for params into the arguments
         # before actually making method invocation
         args[args.length - 1] = params
-        method.bind(self).call(*args, &block)
+        #method.bind(self).call(*args, &block)
+        method.bind(self).call(*args)
       end
     end
     

data/lib/named-parameters/object.rb

@@ -1,8 +1,26 @@
-# Do the eigenclass thingy
+#
+# metaclass helpers from _why...
+#
 # See: http://www.ruby-forum.com/topic/77046
+# See: https://github.com/dannytatom/metaid
+# See: http://dannytatom.github.com/metaid/
+#
 class Object
-  protected
-  def eigenclass # :nodoc:
+  def metaclass # :nodoc:
     class << self; self; end  
-  end  
+  end
+  
+  def meta_eval &block
+    metaclass.instance_eval(&block)
+  end
+  
+  # adds methods to a metaclass
+  def meta_def name, &block
+    meta_eval { define_method name, &block }
+  end
+  
+  # defines an instance method within a class
+  def class_def name, &block
+    class_eval { define_method name, &block }
+  end
 end

data/named-parameters.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{named-parameters}
-  s.version = "0.0.18"
+  s.version = "0.0.19"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Juris Galang"]
-  s.date = %q{2010-12-10}
+  s.date = %q{2010-12-11}
   s.description = %q{This gem simulates named-parameters in Ruby. 
     It's a complement to the common Ruby idiom of using Hash args to emulate 
     the use of named parameters. }

data/spec/named-parameters_spec.rb

@@ -45,12 +45,12 @@ describe "NamedParameters" do
   end
   
   it "should allow declaration of has_named_parameters" do
-    Foo.should respond_to :has_named_parameters
+    Foo.should respond_to(:has_named_parameters)
   end
   
   it "should enforce named parameters for constructor" do
-    lambda{ Foo.new }.should raise_error ArgumentError
-    lambda{ Foo.new :w => :w }.should raise_error ArgumentError
+    lambda{ Foo.new }.should raise_error(ArgumentError)
+    lambda{ Foo.new :w => :w }.should raise_error(ArgumentError)
     lambda{ Foo.new :x => :x }.should_not raise_error
     lambda{ Foo.new :x => :x, :y => :y }.should_not raise_error
     lambda{ Foo.new :x => :x, :y => :y, :z => :z }.should_not raise_error
@@ -58,11 +58,11 @@ describe "NamedParameters" do
   
   it "should enforce named parameters for instrumented instance methods" do
     lambda{ @foo = Foo.new :x => :x, :y => :y, :z => :z }.should_not raise_error
-    lambda{ @foo.method_one :x }.should raise_error ArgumentError
-    lambda{ @foo.method_one :x, :y }.should raise_error ArgumentError
-    lambda{ @foo.method_one :x, :y, :x => :x, :y => :y, :z => :z, :w => :w }.should raise_error ArgumentError
-    lambda{ @foo.method_one :x => :x, :y => :y, :z => :z }.should raise_error ArgumentError
-    lambda{ @foo.method_one :x, :y, :w => :w }.should raise_error ArgumentError
+    lambda{ @foo.method_one :x }.should raise_error(ArgumentError)
+    lambda{ @foo.method_one :x, :y }.should raise_error(ArgumentError)
+    lambda{ @foo.method_one :x, :y, :x => :x, :y => :y, :z => :z, :w => :w }.should raise_error(ArgumentError)
+    lambda{ @foo.method_one :x => :x, :y => :y, :z => :z }.should raise_error(ArgumentError)
+    lambda{ @foo.method_one :x, :y, :w => :w }.should raise_error(ArgumentError)
     lambda{ @foo.method_one :x, :y, :x => :x }.should_not raise_error
     lambda{ @foo.method_one :x, :y, :x => :x, :y => :y }.should_not raise_error
     lambda{ @foo.method_one :x, :y, :x => :x, :y => :y, :z => :z }.should_not raise_error
@@ -70,73 +70,73 @@ describe "NamedParameters" do
   
   it "should not enforce named parameters for un-instrumented instance methods" do
     lambda{ @foo = Foo.new :x => :x, :y => :y, :z => :z }.should_not raise_error
-    lambda{ @foo.method_two :x }.should raise_error ArgumentError
-    lambda{ @foo.method_two :x, :y }.should_not raise_error ArgumentError
-    lambda{ @foo.method_two :x, :y, :w => :w }.should_not raise_error ArgumentError
+    lambda{ @foo.method_two :x }.should raise_error(ArgumentError)
+    lambda{ @foo.method_two :x, :y }.should_not raise_error(ArgumentError)
+    lambda{ @foo.method_two :x, :y, :w => :w }.should_not raise_error(ArgumentError)
   end
 
   it "should enforce named parameters for instrumented class methods" do
-    lambda{ Foo.method_three :x }.should raise_error ArgumentError
-    lambda{ Foo.method_three :x, :y }.should raise_error ArgumentError
-    lambda{ Foo.method_three :x, :y, :x => :x, :y => :y, :z => :z, :w => :w }.should raise_error ArgumentError
-    lambda{ Foo.method_three :x => :x, :y => :y, :z => :z }.should raise_error ArgumentError
-    lambda{ Foo.method_three :x, :y, :w => :w }.should raise_error ArgumentError
+    lambda{ Foo.method_three :x }.should raise_error(ArgumentError)
+    lambda{ Foo.method_three :x, :y }.should raise_error(ArgumentError)
+    lambda{ Foo.method_three :x, :y, :x => :x, :y => :y, :z => :z, :w => :w }.should raise_error(ArgumentError)
+    lambda{ Foo.method_three :x => :x, :y => :y, :z => :z }.should raise_error(ArgumentError)
+    lambda{ Foo.method_three :x, :y, :w => :w }.should raise_error(ArgumentError)
     lambda{ Foo.method_three :x, :y, :x => :x }.should_not raise_error
     lambda{ Foo.method_three :x, :y, :x => :x, :y => :y }.should_not raise_error
     lambda{ Foo.method_three :x, :y, :x => :x, :y => :y, :z => :z }.should_not raise_error
   end
 
   it "should not enforce named parameters for un-instrumented class methods" do
-    lambda{ Foo.method_four :x }.should raise_error ArgumentError
-    lambda{ Foo.method_four :x, :y }.should_not raise_error ArgumentError
-    lambda{ Foo.method_four :x, :y, :w => :w }.should_not raise_error ArgumentError
+    lambda{ Foo.method_four :x }.should raise_error(ArgumentError)
+    lambda{ Foo.method_four :x, :y }.should_not raise_error(ArgumentError)
+    lambda{ Foo.method_four :x, :y, :w => :w }.should_not raise_error(ArgumentError)
   end
   
   it "should require all :required parameters" do
     bar = Bar.new
-    lambda{ bar.method_with_one_required }.should raise_error ArgumentError
-    lambda{ bar.method_with_one_required :a => :a }.should raise_error ArgumentError
+    lambda{ bar.method_with_one_required }.should raise_error(ArgumentError)
+    lambda{ bar.method_with_one_required :a => :a }.should raise_error(ArgumentError)
     lambda{ bar.method_with_one_required :x => :x }.should_not raise_error
             
-    lambda{ bar.method_with_many_required }.should raise_error ArgumentError
-    lambda{ bar.method_with_many_required :x => :x }.should raise_error ArgumentError
+    lambda{ bar.method_with_many_required }.should raise_error(ArgumentError)
+    lambda{ bar.method_with_many_required :x => :x }.should raise_error(ArgumentError)
     lambda{ bar.method_with_many_required :x => :x, :y => :y }.should_not raise_error
   end
   
   it "should require one and only one of :oneof parameters" do
     bar = Bar.new
-    lambda{ bar.method_with_one_oneof }.should raise_error ArgumentError
-    lambda{ bar.method_with_one_oneof :a => :a }.should raise_error ArgumentError
+    lambda{ bar.method_with_one_oneof }.should raise_error(ArgumentError)
+    lambda{ bar.method_with_one_oneof :a => :a }.should raise_error(ArgumentError)
     lambda{ bar.method_with_one_oneof :x => :x }.should_not raise_error
             
-    lambda{ bar.method_with_many_oneof }.should raise_error ArgumentError
-    lambda{ bar.method_with_many_oneof :a => :a }.should raise_error ArgumentError
+    lambda{ bar.method_with_many_oneof }.should raise_error(ArgumentError)
+    lambda{ bar.method_with_many_oneof :a => :a }.should raise_error(ArgumentError)
     lambda{ bar.method_with_many_oneof :x => :x }.should_not raise_error
     lambda{ bar.method_with_many_oneof :y => :y }.should_not raise_error
-    lambda{ bar.method_with_many_oneof :x => :x, :y => :y }.should raise_error ArgumentError
+    lambda{ bar.method_with_many_oneof :x => :x, :y => :y }.should raise_error(ArgumentError)
   end
   
   it "should reject parameters not declared in :required, :optional, or :oneof" do
     bar = Bar.new
     lambda{ bar.method_with_one_optional }.should_not raise_error
     lambda{ bar.method_with_one_optional :x => :x }.should_not raise_error
-    lambda{ bar.method_with_one_optional :a => :a }.should raise_error ArgumentError
-    lambda{ bar.method_with_one_optional :x => :x, :y => :y }.should raise_error ArgumentError
+    lambda{ bar.method_with_one_optional :a => :a }.should raise_error(ArgumentError)
+    lambda{ bar.method_with_one_optional :x => :x, :y => :y }.should raise_error(ArgumentError)
             
     lambda{ bar.method_with_many_optional }.should_not raise_error
     lambda{ bar.method_with_many_optional :x => :x }.should_not raise_error
     lambda{ bar.method_with_many_optional :y => :y }.should_not raise_error
     lambda{ bar.method_with_many_optional :x => :x, :y => :y }.should_not raise_error
-    lambda{ bar.method_with_many_optional :x => :x, :y => :y, :z => :z }.should raise_error ArgumentError
+    lambda{ bar.method_with_many_optional :x => :x, :y => :y, :z => :z }.should raise_error(ArgumentError)
             
-    lambda{ bar.method_with_one_of_each_requirement }.should raise_error ArgumentError
-    lambda{ bar.method_with_one_of_each_requirement :w => :w }.should raise_error ArgumentError
+    lambda{ bar.method_with_one_of_each_requirement }.should raise_error(ArgumentError)
+    lambda{ bar.method_with_one_of_each_requirement :w => :w }.should raise_error(ArgumentError)
     lambda{ bar.method_with_one_of_each_requirement :w => :w, :x => :x }.should_not raise_error
     lambda{ bar.method_with_one_of_each_requirement :w => :w, :y => :y }.should_not raise_error
-    lambda{ bar.method_with_one_of_each_requirement :w => :w, :x => :x, :y => :y }.should raise_error ArgumentError
+    lambda{ bar.method_with_one_of_each_requirement :w => :w, :x => :x, :y => :y }.should raise_error(ArgumentError)
     lambda{ bar.method_with_one_of_each_requirement :w => :w, :x => :x, :z => :z }.should_not raise_error
     lambda{ bar.method_with_one_of_each_requirement :w => :w, :y => :y, :z => :z }.should_not raise_error
-    lambda{ bar.method_with_one_of_each_requirement :w => :w, :x => :x, :z => :z, :a => :a }.should raise_error ArgumentError
+    lambda{ bar.method_with_one_of_each_requirement :w => :w, :x => :x, :z => :z, :a => :a }.should raise_error(ArgumentError)
   end
   
   it "should be able to supply the default values for optional parameters" do
@@ -152,16 +152,16 @@ describe "NamedParameters" do
     end
     
     zoo = Zoo.new
-    zoo.method_with_one_optional_parameter.should eql 1
-    zoo.method_with_one_optional_parameter(:x => 2).should eql 2
+    zoo.method_with_one_optional_parameter.should eql(1)
+    zoo.method_with_one_optional_parameter(:x => 2).should eql(2)
   
-    zoo.method_with_many_optional_parameters.should eql 3
-    zoo.method_with_many_optional_parameters(:x => 2).should eql 4
-    zoo.method_with_many_optional_parameters(:x => 2, :y => 3).should eql 5
+    zoo.method_with_many_optional_parameters.should eql(3)
+    zoo.method_with_many_optional_parameters(:x => 2).should eql(4)
+    zoo.method_with_many_optional_parameters(:x => 2, :y => 3).should eql(5)
   
-    zoo.method_with_many_optional_parameters_too.should eql 3
-    zoo.method_with_many_optional_parameters_too(:x => 2).should eql 4
-    zoo.method_with_many_optional_parameters_too(:x => 2, :y => 3).should eql 5
+    zoo.method_with_many_optional_parameters_too.should eql(3)
+    zoo.method_with_many_optional_parameters_too(:x => 2).should eql(4)
+    zoo.method_with_many_optional_parameters_too(:x => 2, :y => 3).should eql(5)
   end
   
   it "should be able to instrument the class method new" do
@@ -172,9 +172,9 @@ describe "NamedParameters" do
       end
       def initialize opts = { }; end
     end
-    lambda { Quux.new }.should raise_error ArgumentError
-    lambda { Quux.new :y => :y }.should raise_error ArgumentError
-    lambda { Quux.new :x => :x, :y => :y }.should raise_error ArgumentError
+    lambda { Quux.new }.should raise_error(ArgumentError)
+    lambda { Quux.new :y => :y }.should raise_error(ArgumentError)
+    lambda { Quux.new :x => :x, :y => :y }.should raise_error(ArgumentError)
     lambda { Quux.new :x => :x }.should_not raise_error
   end
   
@@ -188,7 +188,7 @@ describe "NamedParameters" do
     lambda { Recognizes.new :x => :x }.should_not raise_error
     lambda { Recognizes.new :y => :y }.should_not raise_error
     lambda { Recognizes.new :x => :x, :y => :y }.should_not raise_error
-    lambda { Recognizes.new :z => :z }.should raise_error ArgumentError
+    lambda { Recognizes.new :z => :z }.should raise_error(ArgumentError)
   end
   
   it "should be able to specify required parameters using the recognizes method" do
@@ -197,9 +197,9 @@ describe "NamedParameters" do
       def self.new opts = { }; end
       def initialize opts = { }; end
     end
-    lambda { Required.new }.should raise_error ArgumentError
-    lambda { Required.new :x => :x }.should raise_error ArgumentError
-    lambda { Required.new :y => :y }.should raise_error ArgumentError
+    lambda { Required.new }.should raise_error(ArgumentError)
+    lambda { Required.new :x => :x }.should raise_error(ArgumentError)
+    lambda { Required.new :y => :y }.should raise_error(ArgumentError)
     lambda { Required.new :x => :x, :y => :y }.should_not raise_error
   end
   
@@ -223,8 +223,8 @@ describe "NamedParameters" do
     end
     
     o = DeclaredParameters.new(:x => :x, :y => :y)
-    o.parameters.should eql [ :a, :b, :c, :x, :y ]
-    DeclaredParameters.singleton(:w => :w, :a => :a).should eql [ :a, :b, :c, :w, :x, :y, :z ]
+    o.parameters.should eql([ :a, :b, :c, :x, :y ])
+    DeclaredParameters.singleton(:w => :w, :a => :a).should eql([ :a, :b, :c, :w, :x, :y, :z ])
   end
 
   it "should not return nil when declared_parameters is called on uninstrumented method" do
@@ -243,8 +243,8 @@ describe "NamedParameters" do
     end
     
     o = DeclaredParameters.new(:x => :x, :y => :y)
-    o.boogey.should eql []
-    DeclaredParameters.boogey(:w => :w, :a => :a).should eql [ :a, :b, :c, :w, :x, :y, :z ]
+    o.boogey.should eql([])
+    DeclaredParameters.boogey(:w => :w, :a => :a).should eql([ :a, :b, :c, :w, :x, :y, :z ])
   end
   
   it "should be able to get the list of declared parameters for specified methods" do
@@ -282,9 +282,9 @@ describe "NamedParameters" do
       end
     end
     o = DeclaredParameters.new(:x => 1, :y => 1)
-    DeclaredParameters.singleton_method_parameters.should eql [ :a, :b, :c, :w, :x, :y, :z ]
-    DeclaredParameters.instance_method_parameters.should eql [ :a, :b, :c, :w, :x, :y, :z ]
-    o.instance_method_parameters.should eql [ :a, :b, :c, :w, :x, :y, :z ]
-    o.singleton_method_parameters.should eql [ :a, :b, :c, :w, :x, :y, :z ]
+    DeclaredParameters.singleton_method_parameters.should eql([ :a, :b, :c, :w, :x, :y, :z ])
+    DeclaredParameters.instance_method_parameters.should eql([ :a, :b, :c, :w, :x, :y, :z ])
+    o.instance_method_parameters.should eql([ :a, :b, :c, :w, :x, :y, :z ])
+    o.singleton_method_parameters.should eql([ :a, :b, :c, :w, :x, :y, :z ])
   end
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 18
-  version: 0.0.18
+  - 19
+  version: 0.0.19
 platform: ruby
 authors: 
 - Juris Galang
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-10 00:00:00 -08:00
+date: 2010-12-11 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -128,7 +128,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 1882769076766233734
+      hash: 2045388278523135009
       segments: 
       - 0
       version: "0"