named_parameter 0.0.1

data/Gemfile

@@ -0,0 +1,11 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.0"
+end

data/README

@@ -0,0 +1,55 @@
+# Named Parameter `v0.0.1`
+
+## Description
+That you ever dream with named parameter in Ruby? Well, you doesn't have to pray to
+Ruby's 2.0 have this, just install this gem and have fun!
+
+## How it works
+Just extend the module NamedParameter in your class/module and use the method 'named'
+before define your method, when you call it, use a hash that's key is the parameter
+name. See this example:
+
+    class People
+      extend NamedParameter
+      
+      named def say(phrase)
+        puts "People says: #{phrase}"
+      end
+    end
+    
+    People.new.say phrase: "Awesome!"
+
+Or maybe you want to define an optional parameter, no problem!
+
+    class People
+      extend NamedParameter
+      
+      named def say(phrase="I'm mute")
+        puts "People says: #{phrase}"
+      end
+    end
+    
+    People.new.say
+
+Multiple arguments? Of course!
+
+    class Point
+      extend NamedParameter
+      
+      named def move_to(x,y,z=0)
+        puts "Moving to [#{x},#{y},#{z}]"
+      end
+    end
+    
+    Point.new.move_to(y: 30,x: 50)
+
+## Use in production?
+**You (maybe)**:"Oh! Magic! I'll use in my production projects!"
+**Me**: Wait! Before use this in production, you have to know that gem
+use the [method_added callback](http://ruby-doc.org/core/classes/Module.html#M000460), so if you want to use named parameter
+and this callback in the same class, you have to use [around alias spell](https://gist.github.com/534772#file_around_alias.rb).
+
+## How Install
+Install the gem:
+
+    gem install named_parameter

data/Rakefile

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.version = "0.0.1"
+  gem.name = "named_parameter"
+  gem.homepage = "http://github.com/hugolnx/named_parameter"
+  gem.license = "MIT"
+  gem.summary = %Q{Allows named parameter in ruby}
+  gem.description = %Q{Allows named parameter in ruby}
+  gem.email = "hugolnx@gmail.com"
+  gem.authors = ["Hugo Roque (a.k.a HugoLnx)"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new

data/lib/named_parameter/error.rb

@@ -0,0 +1,19 @@
+module NamedParameter
+  class Error
+    attr_reader :named_method
+    attr_reader :argument_name
+    attr_reader :backtrace
+
+    def initialize(named_method,argument_name,full_backtrace)
+      @named_method = named_method
+      @argument_name = argument_name
+      @backtrace = clean_backtrace(full_backtrace)
+    end
+
+  private
+
+    def clean_backtrace(backtrace)
+      backtrace[2..-1]
+    end
+  end
+end

data/lib/named_parameter/errors/required_parameters.rb

@@ -0,0 +1,26 @@
+module NamedParameter::Errors
+  class RequiredParameters
+    def self.all_when(named_method,options)
+      args = options[:called_with]
+      named_method.required_parameters.collect do |parameter_name|
+        unless args.has_key?(parameter_name) || args.has_key?(parameter_name.to_sym)
+          error = NamedParameter::Error.new(named_method,parameter_name,caller)
+          RequiredParameters.new(error)
+        end
+      end.compact
+    end
+
+    def initialize(error)
+      @error = error
+    end
+
+    def raise_args
+      [error_message,@error.backtrace]
+    end
+
+  private
+    def error_message
+    "undeclared parameter named '#{@error.argument_name}' for '#{@error.named_method.method.name}' method"
+    end
+  end
+end

data/lib/named_parameter/errors/undefined_parameters.rb

@@ -0,0 +1,34 @@
+module NamedParameter::Errors
+  class UndefinedParameters
+    class << self
+      def all_when(named_method,options)
+        args = options[:called_with]
+        args.collect do |arg|
+          unless match?(named_method, arg)
+            error = NamedParameter::Error.new(named_method, arg.first, caller)
+            UndefinedParameters.new(error)
+          end
+        end.compact
+      end
+
+    private
+      def match?(named_method,arg)
+        arg_name = arg.first
+        named_method.have_a_parameter_like? arg_name
+      end
+    end
+
+    def initialize(error)
+      @error = error
+    end
+
+    def raise_args
+      [error_message,@error.backtrace]
+    end
+
+  private
+    def error_message
+      "no parameter named '#{@error.argument_name}' for '#{@error.named_method.method.name}' method"
+    end
+  end
+end

data/lib/named_parameter/errors.rb

@@ -0,0 +1,2 @@
+require 'named_parameter/errors/undefined_parameters'
+require 'named_parameter/errors/required_parameters'

data/lib/named_parameter/named_method.rb

@@ -0,0 +1,37 @@
+module NamedParameter
+  class NamedMethod
+    attr_accessor :method
+
+    def initialize(method)
+      method.owner.instance_eval do
+        alias_method :"___original_#{method.name}___",method.name.to_sym
+      end
+      @method = method
+    end
+
+    def name_of_original
+      :"___original_#{@method.name}___"
+    end
+
+    def errors_when_called_with(args={})
+      errors = []
+      errors += Errors::UndefinedParameters.all_when self, 
+                                                    :called_with => args
+      errors += Errors::RequiredParameters.all_when self, 
+                                                    :called_with => args
+      errors
+    end
+
+    def required_parameters
+      @method.parameters.collect do |parameter| 
+        parameter.last if parameter.first == :req
+      end.compact
+    end
+
+    def have_a_parameter_like?(arg_name)
+      @method.parameters.any? do |method_parameter|
+        method_parameter[1].to_s == arg_name.to_s
+      end
+    end
+  end
+end

data/lib/named_parameter/named_method_transmuter.rb

@@ -0,0 +1,23 @@
+module NamedParameter
+  class NamedMethodTransmuter
+    def self.transmute(method)
+      named_method = NamedMethod.new(method)
+
+      method.owner.instance_eval do
+        define_method (method.name) do |options={}|
+          errors = named_method.errors_when_called_with options
+          raise ArgumentError,*errors.first.raise_args unless errors.empty?
+
+          original_parameters = []
+          method.parameters.each do |parameter|
+            parameter_name = parameter.last
+            original_parameters << options[parameter_name]
+          end
+
+          original_named_method = method(named_method.name_of_original)
+          original_named_method.call(*original_parameters.compact)
+        end
+      end
+    end
+  end
+end

data/lib/named_parameter/named_parameter.rb

@@ -0,0 +1,10 @@
+module NamedParameter
+  def named(def_return)
+    method = self.instance_method(@last_method_added)
+    NamedParameter::NamedMethodTransmuter.transmute method
+  end
+
+  def method_added(method_name)
+    @last_method_added = method_name
+  end
+end

data/lib/named_parameter/parameters.rb

@@ -0,0 +1,15 @@
+class Parameters
+  include Enumerable
+
+  attr_reader :entries
+
+  def initialize(parameters_array)
+    @entries = parameters_array.collect do |parameter_array| 
+      Parameter.new(parameter_array
+    end
+  end
+
+  def each(&block)
+    @entries.each(&block)
+  end
+end

data/lib/named_parameter.rb

@@ -0,0 +1,5 @@
+require 'named_parameter/named_method'
+require 'named_parameter/named_method_transmuter'
+require 'named_parameter/errors'
+require 'named_parameter/error'
+require 'named_parameter/named_parameter'

data/named_parameter.gemspec

@@ -0,0 +1,65 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{named_parameter}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Hugo Roque (a.k.a HugoLnx)"]
+  s.date = %q{2011-05-12}
+  s.description = %q{Allows named parameter in ruby}
+  s.email = %q{hugolnx@gmail.com}
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    "Gemfile",
+    "README",
+    "Rakefile",
+    "lib/.named_parameter.rb.swo",
+    "lib/named_parameter.rb",
+    "lib/named_parameter/error.rb",
+    "lib/named_parameter/errors.rb",
+    "lib/named_parameter/errors/required_parameters.rb",
+    "lib/named_parameter/errors/undefined_parameters.rb",
+    "lib/named_parameter/named_method.rb",
+    "lib/named_parameter/named_method_transmuter.rb",
+    "lib/named_parameter/named_parameter.rb",
+    "lib/named_parameter/parameters.rb",
+    "named_parameter.gemspec",
+    "spec/features/collective_named_methods_feature_spec.rb",
+    "spec/features/individual_named_method_feature_spec.rb",
+    "spec/interfaces/errors_interface.rb",
+    "spec/spec_helper.rb",
+    "spec/support/interface_helper.rb",
+    "spec/unit/error_spec.rb",
+    "spec/unit/errors/required_parameters_spec.rb",
+    "spec/unit/errors/undefined_parameters_spec.rb",
+    "spec/unit/named_method_spec.rb",
+    "spec/unit/named_method_transmuter_spec.rb"
+  ]
+  s.homepage = %q{http://github.com/hugolnx/named_parameter}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{Allows named parameter in ruby}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.0"])
+    else
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.0"])
+    end
+  else
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.0"])
+  end
+end
+

data/spec/features/collective_named_methods_feature_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe "collective named method feature" do
+  before :each do
+    pending "Collective named methods don't is supported yet"
+  end
+
+  describe "named method" do
+      it "should be called with a hash like parameter" do
+        phrase = @test.say phrase: "Hi!"
+        phrase.should be == "Hi!"
+      end
+
+    describe "parameter" do
+      it "should can be optional" do
+        @test.optional_say.should be == "I'm mute"
+      end
+
+      context "multiple" do
+        it "should can have any order" do
+          @test.move_to(y: 2, x:1).should be == [1,2]
+        end
+
+        it "should can be optional" do
+          @test.three_params_first_optional(y:10,z:20).should be == [:x,10,20]
+          @test.three_params_middle_optional(z:20,x:10).should be == [10,:y,20]
+          @test.three_params_last_optional(x:20,y:10).should be == [20,10,:z]
+          @test.three_params_first_2_optionals(z:10).should be == [:x,:y,10]
+          @test.three_params_last_2_optionals(x:10).should be == [10,:y,:z]
+        end
+      end
+
+      context "after reopen class" do
+        it "should be a no named method" do
+          pending :bug
+          @test.after_opened_say("hello").should be == "hello"
+        end
+      end
+
+      context "ArgumentError when" do
+        it "called but not defined" do
+          lambda{@test.say(phrase: "hi!",undefined: "hugo")}.should raise_error ArgumentError, /'undefined'[\w\s]*'say'/
+          lambda{@test.say(undefined: "hugo")}.should raise_error ArgumentError
+        end
+
+        it "required but not called" do
+          lambda {@test.say}.should raise_error ArgumentError
+        end
+      end
+
+    end
+  end
+
+  describe "no named method" do
+    it "should be call with normal parameters" do
+      phrase = @test.no_named_say "Hi!"
+      phrase.should be == "Hi!"
+    end
+  end
+end

data/spec/features/individual_named_method_feature_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+describe "individual named method feature" do
+  describe "becomes possible:" do
+    describe 'Named Parameter' do
+      specify %q{
+        class People
+          extend NamedParameter
+
+          named def say(phrase)
+            phrase
+          end
+        end
+
+        People.new.say phrase: "Hi!"
+          # => "Hi!"
+      } do
+        class People
+          extend NamedParameter
+
+          named def say(phrase)
+            phrase
+          end
+        end
+
+        phrase = People.new.say phrase: "Hi!"
+        phrase.should be == "Hi!"
+      end
+    end
+
+    describe 'Optional Named Parameter' do
+      specify %q{
+        class People
+          extend NamedParameter
+
+          named def say(phrase="I'm mute")
+            phrase
+          end
+        end
+
+        People.new.say
+          # => "I'm mute"
+      } do
+        class People
+          extend NamedParameter
+
+          named def say(phrase="I'm mute")
+            phrase
+          end
+        end
+
+        phrase = People.new.say
+        phrase.should be == "I'm mute"
+      end
+    end
+
+    describe 'Multiple Named Parameter (in any order)' do
+      specify %q{
+        class Point
+          extend NamedParameter
+
+          named def move_to(x,y)
+            [x,y]
+          end
+        end
+
+        Point.new.move_to x: 1,y: 2
+          # => [1,2]
+
+        Point.new.move_to y: 2, x: 1
+          # => [1,2]
+      } do
+        class Point
+          extend NamedParameter
+
+          named def move_to(x,y)
+            [x,y]
+          end
+        end
+
+        position = Point.new.move_to x: 1,y: 2
+        position.should be == [1,2]
+
+        position = Point.new.move_to y: 2, x: 1
+        position.should be == [1,2]
+      end
+    end
+
+    describe 'ArgumentError when given undefined args' do
+      specify %q{
+        class People
+          extend NamedParameter
+          named def say(phrase)
+          end
+        end
+
+        People.new.say phrase: "hi!",undefined: "test"
+          #=> ArgumentError
+      } do
+        class People
+          named def say(phrase)
+          end
+        end
+
+        lambda{People.new.say(phrase: "hi!",undefined: "hugo")}.should raise_error ArgumentError, /'undefined'[\w\s]*'say'/
+      end
+    end
+
+    describe 'ArgumentError when not given required args' do
+      specify %q{
+        class People
+          extend NamedParameter
+          named def say(phrase)
+          end
+        end
+
+        People.new.say
+          #=> ArgumentError
+      } do
+        class People
+          extend NamedParameter
+          named def say(phrase)
+          end
+        end
+
+        lambda {People.new.say}.should raise_error ArgumentError, /'phrase'[\w\s]*'say'/
+      end
+    end
+  end
+
+  describe "no named method" do
+    it "can be called with normal parameters" do
+      class People
+        def no_named_say(phrase)
+          phrase
+        end
+      end
+
+      phrase = People.new.no_named_say "Hi!"
+      phrase.should be == "Hi!"
+    end
+  end
+end

data/spec/interfaces/errors_interface.rb

@@ -0,0 +1,9 @@
+specify ".new(error)" do
+  described_class.should respond_to(:new)
+                        .with(1)
+end
+
+specify ".match?(method,arg)" do
+  described_class.should respond_to(:match?)
+                        .with(2)
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'named_parameter'
+require 'support/interface_helper'

data/spec/support/interface_helper.rb

@@ -0,0 +1,17 @@
+here = File.dirname(__FILE__)
+
+interfaces_paths = Dir[File.join(here,'../interfaces/*_interface.rb')]
+
+interfaces_paths.each do |interface_path|
+  interface_filename = File.basename(interface_path)[/^[^.]+/]
+  method_name = "respect_#{interface_filename}"
+  context_description = method_name.gsub(/_./){|a| a.sub('_',' ').upcase}
+
+  RSpec::Core::ExampleGroup.singleton_class.instance_eval do
+    define_method method_name do
+      context context_description  do
+        eval File.read(interface_path)
+      end
+    end
+  end
+end

data/spec/unit/error_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+module NamedParameter
+  describe Error do
+    describe '#initialize(named_method,argument,full_backtrace)' do
+      describe 'initialize instance variables' do
+        before :each do
+          @named_method = stub :named_method
+          @argument_name = []
+          @full_backtrace = []
+          @error = Error.new(@named_method,@argument_name,@full_backtrace)
+        end
+
+        specify '@named_method its equal to named_method' do
+          @error.instance_variable_get(:@named_method).should be == @named_method
+        end
+
+        specify '@argument_name its equal to argument_name' do
+          @error.instance_variable_get(:@argument_name).should be == @argument_name
+        end
+
+        specify '@backtrace its equal to full_backtrace without two first slots' do
+          full_backtrace = [1,2,3]
+          error = Error.new(@named_method,@argument_name,full_backtrace)
+          error.instance_variable_get(:@backtrace).should be == [3]
+        end
+      end
+    end
+  end
+end

data/spec/unit/errors/required_parameters_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+module NamedParameter::Errors
+  describe RequiredParameters do
+    describe '#initialize(error)' do
+      describe 'initialize instance variables' do
+        specify '@error its equal to error' do
+          specific_error = RequiredParameters.new :error
+          specific_error.instance_variable_get(:@error).should be == :error
+        end
+      end
+    end
+
+    describe '#raise_args' do
+      before :each do
+        # prevention from dependencies
+        @error = stub(:error).as_null_object
+          @error.stub_chain('named_method.method.name')
+      end
+
+      let :instance do
+        RequiredParameters.new @error
+      end
+
+      describe 'return' do
+        let :the_return do
+          instance.raise_args
+        end
+
+        it 'is an array of 2 elements' do
+          the_return.should be_an Array
+          the_return.should have(2).elements
+        end
+
+
+        describe 'first element' do
+          let :first_element do
+            the_return.first
+          end
+
+          it 'is a String of the error message' do
+            first_element.should be_a String
+          end
+
+          it 'include the name of argument envolved in the error' do
+            @error.stub :argument_name => 'arg_name'
+            first_element.should include 'arg_name'
+          end
+
+          it 'include the name of method envolved in the error' do
+            @error.stub_chain('named_method.method.name').and_return('method_name')
+            first_element.should include 'method_name'
+          end
+        end
+
+
+        describe 'second element' do
+          let :second_element do
+            the_return[1]
+          end
+
+          it 'is an Array of backtrace' do
+            backtrace = [:backtrace]
+            @error.stub(:backtrace).and_return(backtrace)
+            second_element.should be == backtrace
+          end
+        end
+      end
+
+
+
+      describe 'integrations' do
+        after :each do
+          instance.raise_args
+        end
+
+        specify '@error.argument_name' do
+          @error.should_receive :argument_name
+        end
+
+        specify '@error.named_method' do
+          @error.should_receive :named_method
+        end
+      end
+    end
+
+    describe '.all_when(named_method,{called_with:arg})' do
+      describe 'return' do
+        before :each do
+          @named_method = stub(:named_method, 
+                               :parameters => [[:req,:param1]],
+                               :required_parameters => [:param1],
+                               :have_a_parameter_like? => false)
+          @args = {:arg_name => :value}
+        end
+
+        let :the_return do
+          RequiredParameters.all_when(@named_method,:called_with => @args)
+        end
+        
+        it 'is an Array' do
+          the_return.should be_an Array
+        end
+
+        context 'given some required parameter wasn\'t passed' do
+          it 'have one element' do
+            @args = {}
+            the_return.should have(1).element
+          end
+        end
+
+        context 'given all required parameters was passed' do
+          it 'is empty' do
+            @args = {:param1 => 'value1'}
+            the_return.should be_empty
+          end
+        end
+      end
+
+      describe 'integrations' do
+        specify "named_method.required_parameters" do
+          named_method = stub(:named_method)
+          named_method.should_receive(:required_parameters)
+                      .and_return([])
+          RequiredParameters.all_when(named_method,:called_with => [])
+        end
+      end
+    end
+  end
+end

data/spec/unit/errors/undefined_parameters_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+module NamedParameter::Errors
+  describe UndefinedParameters do
+    describe '#initialize(error)' do
+      describe 'initialize instance variables' do
+        specify '@error its equal to error' do
+          specific_error = UndefinedParameters.new :error
+          specific_error.instance_variable_get(:@error).should be == :error
+        end
+      end
+    end
+
+    describe '#raise_args' do
+      before :each do
+        # prevention from dependencies
+        @error = stub(:error).as_null_object
+        @error.stub_chain('named_method.method.name')
+      end
+
+      let :instance do
+        UndefinedParameters.new @error
+      end
+
+      describe 'return' do
+        let :the_return do
+          instance.raise_args
+        end
+
+        it 'is an array of 2 elements' do
+          the_return.should be_an Array
+          the_return.should have(2).elements
+        end
+
+
+        describe 'first element' do
+          let :first_element do
+            the_return.first
+          end
+
+          it 'is a String of the error message' do
+            first_element.should be_a String
+          end
+
+          it 'include the name of argument envolved in the error' do
+            @error.stub :argument_name => 'arg_name'
+            first_element.should include 'arg_name'
+          end
+
+          it 'include the name of method envolved in the error' do
+              @error.stub_chain('named_method.method.name').and_return('method_name')
+            first_element.should include 'method_name'
+          end
+        end
+
+
+        describe 'second element' do
+          let :second_element do
+            the_return[1]
+          end
+
+          it 'is an Array of backtrace' do
+            backtrace = [:backtrace]
+            @error.stub(:backtrace).and_return(backtrace)
+            second_element.should be == backtrace
+          end
+        end
+      end
+
+
+
+      describe 'integrations' do
+        after :each do
+          instance.raise_args
+        end
+
+        specify '@error.argument_name' do
+          @error.should_receive :argument_name
+        end
+
+        specify '@error.named_method' do
+          @error.should_receive :named_method
+        end
+      end
+    end
+
+    describe '.all_when(named_method,{called_with:args})' do
+      describe 'return' do
+        before :each do
+          @named_method = stub(:named_method, 
+                               :parameters => [[:req,:param1]],
+                               :have_a_parameter_like? => false)
+          @args = {:arg_name => :value}
+        end
+
+        let :the_return do
+          UndefinedParameters.all_when(@named_method,:called_with => @args)
+        end
+        
+        it 'is an Array' do
+          the_return.should be_an Array
+        end
+
+        context 'given some arg does not exist in method parameters' do
+          it 'have one element' do
+            @named_method.stub!(:have_a_parameter_like? => false)
+            the_return.should have(1).element
+          end
+        end
+
+        context 'given all arguments exist in method parameters' do
+          it 'is empty' do
+            @named_method.stub!(:have_a_parameter_like? => true)
+            the_return.should be == []
+          end
+        end
+      end
+
+      describe 'integrations' do
+        specify "named_method.have_a_parameter_like?(arg)" do
+          named_method = stub(:named_method)
+          args = {:arg_name => :value}
+          named_method.should_receive(:have_a_parameter_like?)
+                      .with(:arg_name)
+          UndefinedParameters.all_when(named_method,:called_with => args)
+        end
+      end
+    end
+  end
+end

data/spec/unit/named_method_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+module NamedParameter
+  describe NamedMethod do
+    before :each do
+      @method = stub(:method).as_null_object
+      @named_method = NamedMethod.new @method
+    end
+
+    before :all do
+      class Klass
+        def method1
+        end
+        def method2(required_parameter,not_required_parameter="optional")
+        end
+      end
+      @instance = Klass.new
+    end
+
+    describe "#initialize(method)" do
+      it "create an alias to method" do
+        method = @instance.method(:method1)
+        NamedMethod.new method
+        @instance.should respond_to :"___original_method1___"
+      end
+    end
+
+    describe "#name_of_original" do
+      it "is the name of original method" do
+        method = @instance.method(:method1)
+        named_method = NamedMethod.new(method)
+        named_method.name_of_original.should be == :___original_method1___
+      end
+    end
+
+    describe "#required_parameters" do
+      it "is an array with all required parameters" do
+        method = @instance.method(:method2)
+        named_method = NamedMethod.new(method)
+        named_method.required_parameters.should be == [:required_parameter]
+      end
+    end
+
+    describe "#have_a_parameter_like?(arg_name)" do
+      context 'given have a parameter named arg_name' do
+        it "is true" do
+          method = @instance.method(:method2)
+          named_method = NamedMethod.new(method)
+          the_return = named_method.have_a_parameter_like?(:required_parameter)
+          the_return.should be_true
+        end
+      end
+    end
+
+    describe "#errors_when_called_with(parameters)" do
+      before :each do
+        Errors::RequiredParameters.stub!(:all_when).and_return([])
+        Errors::UndefinedParameters.stub!(:all_when).and_return([])
+        method = @instance.method(:method1)
+        @named_method = NamedMethod.new(method)
+      end
+
+      describe "integrations" do
+        it "Errors::UndefinedParameters.all_when(method,{called_with:args})" do
+          Errors::UndefinedParameters.should_receive(:all_when)
+                                     .and_return([])
+          @named_method.errors_when_called_with(:args)
+        end
+
+        it "Errors::RequiredParameters.all_when(method,{called_with:args})" do
+          Errors::RequiredParameters.should_receive(:all_when)
+                                    .and_return([])
+          @named_method.errors_when_called_with(:args)
+        end
+      end
+    end
+  end
+end

data/spec/unit/named_method_transmuter_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+module NamedParameter
+  describe NamedMethodTransmuter do
+    before :each do
+      @klass = Class.new do
+        def method1
+        end
+
+        def method2(param1)
+          param1
+        end
+      end
+      @instance = @klass.new
+    end
+
+    describe ".transmute(method)" do
+      describe "integrations" do
+        it "NamedMethod.new(method)" do
+          method = @klass.instance_method(:method1)
+          NamedMethod.should_receive(:new).with(method)
+          NamedMethodTransmuter.transmute method
+        end
+      end
+
+      it "override old method to a mirror that receive hash" do
+        method = @instance.method(:method2)
+        NamedMethodTransmuter.transmute method
+        @instance.should be_respond_to(:method2, param1: "teste")
+      end
+
+      describe "mirror method" do
+        describe "integrations" do
+          specify "NamedMethod#name_of_original(parameters)" do
+            method = @klass.instance_method(:method1)
+            named_method = NamedMethod.new(method)
+            NamedMethod.stub!(:new => named_method)
+            @instance.stub_chain(:method,:call)
+            NamedMethodTransmuter.transmute method
+            named_method.should_receive(:name_of_original)
+            @instance.method1
+          end
+
+          specify "NamedMethod#errors_when_called_with(args)" do
+            NamedMethod.method_defined?(:errors_when_called_with).should be_true
+            method = @klass.instance_method(:method1)
+            named_method = NamedMethod.new(method)
+            NamedMethod.stub!(:new => named_method)
+            NamedMethodTransmuter.transmute method
+            named_method.should_receive(:errors_when_called_with)
+                        .and_return([])
+            @instance.method1
+          end
+
+          specify "Errors::SomeError#raise_args" do
+            method = @klass.instance_method(:method1)
+            errors = stub(:errors)
+            NamedMethod.stub_chain(:new,:errors_when_called_with)
+                       .and_return(errors)
+            error = stub(:error)
+            errors.stub!(:first)
+                  .and_return(error)
+            errors.stub!(:empty?)
+                  .and_return(false)
+            NamedMethodTransmuter.transmute method
+            error.should_receive(:raise_args)
+                 .and_return([])
+            lambda{@instance.method1}.should raise_error ArgumentError
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification 
+name: named_parameter
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Hugo Roque (a.k.a HugoLnx)
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-12 00:00:00 -03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *id002
+description: Allows named parameter in ruby
+email: hugolnx@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- Gemfile
+- README
+- Rakefile
+- lib/.named_parameter.rb.swo
+- lib/named_parameter.rb
+- lib/named_parameter/error.rb
+- lib/named_parameter/errors.rb
+- lib/named_parameter/errors/required_parameters.rb
+- lib/named_parameter/errors/undefined_parameters.rb
+- lib/named_parameter/named_method.rb
+- lib/named_parameter/named_method_transmuter.rb
+- lib/named_parameter/named_parameter.rb
+- lib/named_parameter/parameters.rb
+- named_parameter.gemspec
+- spec/features/collective_named_methods_feature_spec.rb
+- spec/features/individual_named_method_feature_spec.rb
+- spec/interfaces/errors_interface.rb
+- spec/spec_helper.rb
+- spec/support/interface_helper.rb
+- spec/unit/error_spec.rb
+- spec/unit/errors/required_parameters_spec.rb
+- spec/unit/errors/undefined_parameters_spec.rb
+- spec/unit/named_method_spec.rb
+- spec/unit/named_method_transmuter_spec.rb
+has_rdoc: true
+homepage: http://github.com/hugolnx/named_parameter
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 270356975
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Allows named parameter in ruby
+test_files: []
+