named-parameters 0.0.20 → 0.0.21

data/RELEASENOTES

@@ -1,3 +1,9 @@
+0.0.21 [Dec 16, 2010]
+- [INTERNAL] Improved syntax handling
+- [INTERNAL] Reorganized tests
+- [INTERNAL] Support added for multi-line requires and recognizes clause
+- [INTERNAL] "Safe" names for privates
+
 0.0.20 [Dec 12, 2010]
 - [INTERNAL] Modified implementation for #intercept so that it works for Ruby 
   1.8.6, 1.8.7, and 1.9.2

data/VERSION

@@ -1 +1 @@
-0.0.20
+0.0.21

data/lib/named-parameters/module.rb

@@ -44,15 +44,15 @@ module NamedParameters
   #
   def declared_parameters type = [ :required, :optional, :oneof ]
     klazz  = self.instance_of?(Class) ? self : self.class
-    specs  = klazz.send :method_specs
+    specs  = klazz.send :__method_specs
     method = if block_given?
       yield # insane-fucker! :-)
     else
-      caller = calling_method
+      caller = __calling_method
       self.instance_of?(Class) ? :"self.#{caller}" : caller
     end
 
-    return [] unless spec = specs[klazz.send(:key_for, method)]
+    return [] unless spec = specs[klazz.send(:__key_for, method)]
 
     mapper = lambda{ |entry| entry.instance_of?(Hash) ? entry.keys.first : entry }
     sorter = lambda{ |x, y| x.to_s <=> y.to_s }
@@ -112,7 +112,7 @@ module NamedParameters
   #   as parameter to the method.
   #
   def filter_parameters options, filter = nil
-    caller = calling_method
+    caller = __calling_method
     method = self.instance_of?(Class) ? :"self.#{caller}" : caller
     filter ||= declared_parameters { method } 
     options.reject{ |key, value| !filter.include?(key) }
@@ -125,12 +125,12 @@ module NamedParameters
 
   private
   # returns the name of the current method
-  def current_method # :nodoc:
+  def __current_method # :nodoc:
     caller[0][/`([^']*)'/, 1].to_sym
   end
 
   # returns the name of the calling method
-  def calling_method # :nodoc:
+  def __calling_method # :nodoc:
     caller[1][/`([^']*)'/, 1].to_sym
   end
     
@@ -138,10 +138,10 @@ module NamedParameters
   # (based on the defined spec) when an instrumented method is invoked.
   #
   def self.validate_method_specs name, params, spec  # :nodoc:
-    mapper   = lambda{ |n| n.instance_of?(Hash) ? n.keys.first : n }
-    optional = spec[:optional].map &mapper
-    required = spec[:required].map &mapper
-    oneof    = spec[:oneof].map &mapper
+    mapper   = lambda{ |n| n.instance_of?(Hash) ? n.keys : n }
+    optional = spec[:optional].map(&mapper).flatten
+    required = spec[:required].map(&mapper).flatten
+    oneof    = spec[:oneof].map(&mapper).flatten
     
     # determine what keys are allowed, unless mode is :permissive
     # in which case we don't care unless its listed as required or oneof
@@ -187,14 +187,6 @@ module NamedParameters
   module ClassMethods
     ALIAS_PREFIX = :__intercepted__
 
-    def aliased name # :nodoc:
-      :"#{ALIAS_PREFIX}#{name}"
-    end
-    
-    def unaliased name  # :nodoc:
-      name.gsub(/^#{ALIAS_PREFIX}/, '')
-    end
-    
     # Declares that `method` will enforce named parameters behavior as 
     # described in `spec`; a method declared with `:required` and/or 
     # `:optional` parameters will raise an `ArgumentError` if it is invoked 
@@ -236,20 +228,22 @@ module NamedParameters
       #     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 }
+        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
+      __method_specs[__key_for(method)] = spec
       yield spec if block_given?
     end
     
@@ -263,9 +257,12 @@ module NamedParameters
     #   parameters.
     #
     def requires *params, &block
+      #raise ArgumentError, \
+      #  "You must specify at least one parameter when declaring a requiring clause" \
+      #  if params.empty?
       [ :'self.new', :initialize ].each do |method|
-        spec = method_specs[key_for(method)] || { }
-        spec.merge!(:required => params)
+        spec = __method_specs[__key_for(method)] || { }
+        spec.merge!(:required => Array(spec[:required]) + params)
         has_named_parameters method, spec, :strict, &block
       end
     end
@@ -280,9 +277,12 @@ module NamedParameters
     #   parameters.
     #
     def recognizes *params, &block
+      #raise ArgumentError, \
+      #  "You must specify at least one parameter when declaring a recognizes clause" \
+      #  if params.empty?
       [ :'self.new', :initialize ].each do |method|
-        spec = method_specs[key_for(method)] || { }
-        spec.merge!(:optional => params)
+        spec = __method_specs[__key_for(method)] || { }
+        spec.merge!(:optional => Array(spec[:optional]) + params)
         has_named_parameters method, spec, :strict, &block
       end
     end
@@ -322,14 +322,12 @@ module NamedParameters
     
     # add instrumentation for class methods
     def singleton_method_added name  # :nodoc:
-      apply_method_spec :"self.#{name}" do
-        self.metaclass.send :alias_method, aliased(name), name
-        #method = self.metaclass.instance_method name
+      __apply_method_spec :"self.#{name}" do
+        self.metaclass.send :alias_method, __aliased(name), name
         owner = "#{self}::"
-        spec  = method_specs[key_for(:"self.#{name}")]
+        spec  = __method_specs[__key_for(:"self.#{name}")]
         metaclass.instance_eval do
-          #intercept method, owner, name, spec
-          intercept owner, name, spec
+          __intercept owner, name, spec
         end
       end
       super
@@ -337,66 +335,44 @@ module NamedParameters
     
     # add instrumentation for instance methods
     def method_added name  # :nodoc:
-      apply_method_spec name do
-        alias_method aliased(name), name
-        #method = instance_method name
+      __apply_method_spec name do
+        alias_method __aliased(name), name
         owner = "#{self}#"
-        spec  = method_specs[key_for(name)]
-        #intercept method, owner, name, spec
-        intercept owner, name, spec
+        spec  = __method_specs[__key_for(name)]
+        __intercept owner, name, spec
       end
       super
     end
 
     private
+    def __aliased name # :nodoc:
+      :"#{ALIAS_PREFIX}#{name}"
+    end
+    
+    def __unaliased name  # :nodoc:
+      name.gsub(/^#{ALIAS_PREFIX}/, '')
+    end
+
     # apply instrumentation to method
-    def apply_method_spec method  # :nodoc:
-      if method_specs.include? key_for(method) and !instrumenting?
-        @instrumenting = true
+    def __apply_method_spec method  # :nodoc:
+      if __method_specs.include? __key_for(method) and !__instrumenting?
+        @__instrumenting = true
         yield method
-        @instrumenting = false
+        @__instrumenting = false
       end
     end
-    
-    ## 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|
-    #    # locate the argument representing the named parameters value
-    #    # for the method invocation
-    #    params = args.last
-    #    args << (params = { }) unless params.instance_of? Hash
-    #
-    #    # merge the declared default values for params into the arguments
-    #    # used when the method is invoked
-    #    defaults = { }
-    #    spec.each do |k, v|
-    #      next if k == :mode
-    #      v.each{ |entry| defaults.merge! entry if entry.instance_of? Hash }
-    #    end
-    #    params = defaults.merge params
-    #    
-    #    # validate the parameters against the spec
-    #    NamedParameters::validate_method_specs fullname, params, spec
-    #    
-    #    # 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)
-    #  end
-    #end
 
     # insert parameter validation prior to executing the instrumented method
-    def intercept owner, name, spec  # :nodoc:
+    def __intercept owner, name, spec  # :nodoc:
       class_eval(<<-CODE, __FILE__, __LINE__)
         def #{name}(*args, &block)
           # compute the fully-qualified name of the method
           # this is used when reporting argument errors
           fullname = "#{owner}#{name}"
-          
+
           # locate the argument representing the named parameters value
           # for the method invocation
-          params   = args.last
+          params = args.last
           args << (params = { }) unless params.instance_of? Hash
           
           # merge the declared default values for params into the arguments
@@ -405,7 +381,7 @@ module NamedParameters
           defaults = { }
           spec.each do |k, v|
             next if k == :mode
-            v.each{ |entry| defaults.merge!(entry) if entry.instance_of? Hash }
+            v.each{ |entry| entry.instance_of?(Hash) ? defaults.merge!(entry) : entry }
           end
           params = defaults.merge(params)
           
@@ -419,51 +395,27 @@ module NamedParameters
           send method, *args, &block
         end
       CODE
-      
-      #define_method name do |*args, &block|
-      #  # locate the argument representing the named parameters value
-      #  # for the method invocation
-      #  params = args.last
-      #  args << (params = { }) unless params.instance_of? Hash
-      #
-      #  # merge the declared default values for params into the arguments
-      #  # used when the method is invoked
-      #  defaults = { }
-      #  spec.each do |k, v|
-      #    next if k == :mode
-      #    v.each{ |entry| defaults.merge! entry if entry.instance_of? Hash }
-      #  end
-      #  params = defaults.merge params
-      #  
-      #  # validate the parameters against the spec
-      #  NamedParameters::validate_method_specs fullname, params, spec
-      #  
-      #  # 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)
-      #end
     end
     
     # initialize specs table as needed 
-    def method_specs  # :nodoc:
-      @method_specs ||= { }
+    def __method_specs  # :nodoc:
+      @__method_specs ||= { }
     end
     
-    def key_for method
+    def __key_for method
       type = method.to_s =~ /^self\./ ? :singleton : :instance
       name = method.to_s.sub(/^self\./, '')
-      :"#{self}::#{type}.#{unaliased name}"
+      :"#{self}::#{type}.#{__unaliased name}"
     end
     
     # check if in the process of instrumenting a method
-    def instrumenting?  # :nodoc:
-      @instrumenting
+    def __instrumenting?  # :nodoc:
+      @__instrumenting
     end
     
-    # initialize the @instrumenting instance variable (housekeeping)
+    # initialize the @__instrumenting instance variable (housekeeping)
     def self.extended base  # :nodoc:
-      base.instance_variable_set(:@instrumenting, false)
+      base.instance_variable_set(:@__instrumenting, false)
     end
   end
 end

data/named-parameters.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{named-parameters}
-  s.version = "0.0.20"
+  s.version = "0.0.21"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Juris Galang"]
-  s.date = %q{2010-12-12}
+  s.date = %q{2010-12-16}
   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. }
@@ -32,7 +32,10 @@ Gem::Specification.new do |s|
     "lib/named-parameters/module.rb",
     "lib/named-parameters/object.rb",
     "named-parameters.gemspec",
-    "spec/named-parameters_spec.rb",
+    "spec/has_named_parameters_spec.rb",
+    "spec/legacy_spec.rb",
+    "spec/recognizes_spec.rb",
+    "spec/requires_spec.rb",
     "spec/spec_helper.rb"
   ]
   s.homepage = %q{http://github.com/jurisgalang/named-parameters}
@@ -41,7 +44,10 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.7}
   s.summary = %q{Poor man's named-parameters in Ruby}
   s.test_files = [
-    "spec/named-parameters_spec.rb",
+    "spec/has_named_parameters_spec.rb",
+    "spec/legacy_spec.rb",
+    "spec/recognizes_spec.rb",
+    "spec/requires_spec.rb",
     "spec/spec_helper.rb"
   ]
 

data/spec/has_named_parameters_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "NamedParameters::has_named_parameters" do
+  it "should allow declaration of the has_named_parameters clause" do
+    class Hnp0; end
+    Hnp0.should respond_to(:has_named_parameters)
+  end
+
+  it "shouldn't complain if there are not declared parameters" do
+    class Hnp1
+      def initialize opts = { }; end
+      def method1 opts = { }; end
+      def self.method1 opts = { }; end
+    end
+    lambda { Hnp1.method1 }.should_not raise_error
+    lambda { @hasnamedparameters = Hnp1.new }.should_not raise_error
+    lambda { @hasnamedparameters.method1 }.should_not raise_error
+  end
+end

data/spec/{named-parameters_spec.rb → legacy_spec.rb}

@@ -3,7 +3,7 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 # TODO: reorganize the tests for clarity
 # TODO: need separate spec for the NamedParameters.validate_specs method
 # TODO: factor out specs for required, recognizes, and has_named_parameters
-describe "NamedParameters" do
+describe "NamedParameters::legacy" do
   before :all do
     class Foo
       has_named_parameters :initialize, :required => :x, :optional => [ :y, :z ]

data/spec/recognizes_spec.rb

@@ -0,0 +1,160 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "NamedParameters::recognizes" do
+  it "should allow declaration of the recognizes clause" do
+    class Recognizes; end
+    Recognizes.should respond_to(:recognizes)
+  end
+  
+  #it "complains if you don't declare a parameter when using the clause" do
+  #  lambda { 
+  #    class Recognizes0
+  #      recognizes
+  #      def initialize opts = {}; end
+  #    end
+  #  }.should raise_error(ArgumentError)
+  #end
+  
+  it "doesn't complain if you pass it an optional parameter" do
+    class Recognizes1
+      recognizes :bar
+      def initialize opts = {}; end
+    end
+    lambda { Recognizes1.new :bar => :bar }.should_not raise_error(ArgumentError)
+  end
+
+  it "doesn't complain if you don't pass it an optional parameter" do
+    class Recognizes2
+      recognizes :bar
+      def initialize opts = {}; end
+    end
+    lambda { Recognizes2.new }.should_not raise_error(ArgumentError)
+  end
+
+  it "complains if you pass it an undeclared parameter" do
+    class Recognizes3
+      recognizes :bar
+      def initialize opts = {}; end
+    end
+    lambda { Recognizes3.new :foo => :foo }.should raise_error(ArgumentError)
+    lambda { Recognizes3.new :foo => :foo, :bar => :bar }.should raise_error(ArgumentError)
+  end
+
+  it "allows more than one optional parameters" do
+    class Recognizes4
+      recognizes :foo, :bar, :baz
+      def initialize opts = {}; end
+    end
+    lambda { Recognizes4.new :foo => :foo }.should_not raise_error(ArgumentError)
+    lambda { Recognizes4.new :bar => :bar }.should_not raise_error(ArgumentError)
+    lambda { Recognizes4.new :baz => :baz }.should_not raise_error(ArgumentError)
+    lambda { Recognizes4.new :foo => :foo, :bar => :bar }.should_not raise_error(ArgumentError)
+    lambda { Recognizes4.new :bar => :bar, :baz => :baz }.should_not raise_error(ArgumentError)
+    lambda { Recognizes4.new :foo => :foo, :bar => :bar, :baz => :baz }.should_not raise_error(ArgumentError)
+  end
+
+  it "allows you to specify default values for optional parameters" do
+    class Recognizes5
+      recognizes :foo => :foo
+      def initialize opts = {}
+        @foo = opts[:foo]
+      end
+    end
+    recognizes = Recognizes5.new
+    recognizes.instance_variable_get(:@foo).should eql(:foo)
+  end
+
+  it "allows you to override default values for optional parameters" do
+    class Recognizes6
+      recognizes :foo => :foo
+      def initialize opts = {}
+        @foo = opts[:foo]
+      end
+    end
+    recognizes = Recognizes6.new :foo => :bar
+    recognizes.instance_variable_get(:@foo).should eql(:bar)
+  end
+  
+  it "allows you to declare parameters and default values as Array pairs" do
+    class Recognizes7
+      recognizes [ :foo, :foo ], [ :bar, :bar ]
+      def initialize opts = {}
+        @foo = opts[:foo]
+        @bar = opts[:bar]
+      end
+    end
+    recognizes = Recognizes7.new
+    recognizes.instance_variable_get(:@foo).should eql(:foo)
+    recognizes.instance_variable_get(:@bar).should eql(:bar)
+  end
+
+  it "allows you to declare parameters and default values as KV pairs" do
+    class Recognizes8
+      recognizes :foo => :foo, :bar => :bar
+      def initialize opts = {}
+        @foo = opts[:foo]
+        @bar = opts[:bar]
+      end
+    end
+    recognizes = Recognizes8.new
+    recognizes.instance_variable_get(:@foo).should eql(:foo)
+    recognizes.instance_variable_get(:@bar).should eql(:bar)
+  end
+
+  it "allows you to declare parameters and default values as Array and KV pairs" do
+    class Recognizes9
+      recognizes [ :foo, :foo ], { :bar => :bar }
+      def initialize opts = {}
+        @foo = opts[:foo]
+        @bar = opts[:bar]
+      end
+    end
+    recognizes = Recognizes9.new
+    recognizes.instance_variable_get(:@foo).should eql(:foo)
+    recognizes.instance_variable_get(:@bar).should eql(:bar)
+  end
+
+  it "allows you to declare parameters with and without default values" do
+    class Recognizes10
+      recognizes :foo, [ :bar, :bar ], :zoo, { :baz => :baz }, :quux
+      def initialize opts = {}
+        @foo  = opts[:foo]
+        @bar  = opts[:bar]
+        @baz  = opts[:baz]
+        @zoo  = opts[:zoo]
+        @quux = opts[:quux]
+      end
+    end
+    recognizes = Recognizes10.new(:foo => :foo, :zoo => :zoo, :quux => :quux)
+    recognizes.instance_variable_get(:@foo).should  eql(:foo)
+    recognizes.instance_variable_get(:@bar).should  eql(:bar)
+    recognizes.instance_variable_get(:@baz).should  eql(:baz)
+    recognizes.instance_variable_get(:@zoo).should  eql(:zoo)
+    recognizes.instance_variable_get(:@quux).should eql(:quux)
+  end
+
+  it "allows you to declare multiple requires clause and treat it as one" do
+    class Recognizes11
+      recognizes :foo
+      recognizes [ :bar, :bar ]
+      recognizes :baz => :baz
+      def initialize opts = { }
+        @foo = opts[:foo]
+        @bar = opts[:bar]
+        @baz = opts[:baz]
+      end
+    end
+    lambda { Recognizes11.new :foo => :foo, :bar => :bar, :baz => :baz }.should_not raise_error(ArgumentError)
+    lambda { Recognizes11.new :quux => :quux }.should raise_error(ArgumentError)
+    
+    recognizes = Recognizes11.new
+    recognizes.instance_variable_get(:@foo).should be_nil
+    recognizes.instance_variable_get(:@bar).should eql(:bar)
+    recognizes.instance_variable_get(:@baz).should eql(:baz)
+
+    recognizes = Recognizes11.new :foo => :foo
+    recognizes.instance_variable_get(:@foo).should eql(:foo)
+    recognizes.instance_variable_get(:@bar).should eql(:bar)
+    recognizes.instance_variable_get(:@baz).should eql(:baz)
+  end
+end

data/spec/requires_spec.rb

@@ -0,0 +1,73 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "NamedParameters::requires" do
+  it "should allow declaration of the requires clause" do
+    class Requires; end
+    Requires.should respond_to(:requires)
+  end
+  
+  #it "complains if you don't declare a parameter when using the clause" do
+  #  lambda { 
+  #    class Requires0
+  #      requires
+  #      def initialize opts = {}; end
+  #    end
+  #  }.should raise_error(ArgumentError)
+  #end
+
+  it "complains if you don't pass it a required parameter" do
+    class Requires1
+      requires :bar
+      def initialize opts = {}; end
+    end
+    lambda { Requires1.new }.should raise_error(ArgumentError)
+  end
+
+  it "doesn't complain if you pass it a required parameter" do
+    class Requires2
+      requires :bar
+      def initialize opts = {}; end
+    end
+    lambda { Requires2.new :bar => :bar }.should_not raise_error(ArgumentError)
+  end
+
+  it "complains if you pass it an undeclared parameter" do
+    class Requires3
+      requires :bar
+      def initialize opts = {}; end
+    end
+    lambda { Requires3.new :foo => :foo }.should raise_error(ArgumentError)
+    lambda { Requires3.new :foo => :foo, :bar => :bar }.should raise_error(ArgumentError)
+  end
+  
+  it "allows more than one required parameters" do
+    class Requires4
+      requires :foo, :bar, :baz
+      def initialize opts = {}; end
+    end
+    lambda { Requires4.new :foo => :foo, :bar => :bar, :baz => :baz }.should_not raise_error(ArgumentError)
+  end
+
+  it "complains if not all of the required parameters was passed" do
+    class Requires5
+      requires :foo, :bar, :baz
+      def initialize opts = {}; end
+    end
+    lambda { Requires5.new :foo => :foo }.should raise_error(ArgumentError)
+    lambda { Requires5.new :foo => :foo, :bar => :bar }.should raise_error(ArgumentError)
+    lambda { Requires5.new :bar => :bar, :baz => :baz }.should raise_error(ArgumentError)
+  end
+
+  it "allows you to declare multiple requires clause and treat it as one" do
+    class Requires6
+      requires :foo
+      requires :bar
+      requires :baz
+      def initialize opts = {}; end
+    end
+    lambda { Requires6.new :foo => :foo, :bar => :bar, :baz => :baz }.should_not raise_error(ArgumentError)
+    lambda { Requires6.new :foo => :foo }.should raise_error(ArgumentError)
+    lambda { Requires6.new :foo => :foo, :bar => :bar }.should raise_error(ArgumentError)
+    lambda { Requires6.new :bar => :bar, :baz => :baz }.should raise_error(ArgumentError)
+  end
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 20
-  version: 0.0.20
+  - 21
+  version: 0.0.21
 platform: ruby
 authors: 
 - Juris Galang
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-12 00:00:00 -08:00
+date: 2010-12-16 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -111,7 +111,10 @@ files:
 - lib/named-parameters/module.rb
 - lib/named-parameters/object.rb
 - named-parameters.gemspec
-- spec/named-parameters_spec.rb
+- spec/has_named_parameters_spec.rb
+- spec/legacy_spec.rb
+- spec/recognizes_spec.rb
+- spec/requires_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/jurisgalang/named-parameters
@@ -128,7 +131,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -1934925740006837865
+      hash: 1437560030022288609
       segments: 
       - 0
       version: "0"
@@ -148,5 +151,8 @@ signing_key:
 specification_version: 3
 summary: Poor man's named-parameters in Ruby
 test_files: 
-- spec/named-parameters_spec.rb
+- spec/has_named_parameters_spec.rb
+- spec/legacy_spec.rb
+- spec/recognizes_spec.rb
+- spec/requires_spec.rb
 - spec/spec_helper.rb