parametron 0.1.0 → 0.2.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    MjQ1MDg2ODZiNDM4ZDc5OWQ4NGViMmFiNzFiNjg2NjJkOWIwM2E1Yg==
-  data.tar.gz: !binary |-
-    NjZlYzJiMGU1YWRmNTU4NTJkMDFlODFlMjcwNDQ4M2ViZGFmZDVmZQ==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    NjY1YWQxM2U3YWY1NGM0N2U3ODk5YmQ4YmI0YTg3MmZkMTYyZjU4ZWJiM2Yx
-    OTFmZjU1Mzg5OWRlNTU1YjQwZjU4N2JhMTJlNmFmZmUwMDUyZmM4MWVlY2Y1
-    OTIzNTc5Y2JhNWNhMGQxODg4NDkyOTA2YjMyZjZkNzliNzYzMTA=
-  data.tar.gz: !binary |-
-    MWFhNzJkOGVjODcxOGVlMGYxZDE0YjNhNzYyODg3OTUxZDg0N2RiYWQ1ZjBl
-    N2Q1YjFhNjg4NzMxOWM0N2JlMWZkZDg1ODM1ZWYzZjVkOTQ4NjU4ZmI4OTk5
-    ZDlkZTE1MDAwMjA4MWQzMmZiNjI4NDU3NjgxYzljNGVjZmI5MjQ=
+SHA1:
+  metadata.gz: 76fe6f2be9dd10050ee5f0749f341d7fd839f5bc
+  data.tar.gz: a5594be4a8b3226ba320c8ade4a84e672a92dc97
+SHA512:
+  metadata.gz: ed8ad2f475604a05ee620885ca083463825fd26a0449f049e70146a14458764109bef90bf0f766fa9664e39b38c6c766755a35718f9194ba92ab7ad31e9d1024
+  data.tar.gz: 5f86ba4facefae42b5b95c5ee2e9039c794985c3df951ad7ecb0789a43015a6e23a0a7da7ec1eaf063bd429962b1e98f66b9123c8d739bcc2b14b709ab812a0d

data/README.md

@@ -29,6 +29,7 @@ Or install it yourself as:
           optional :title,  validator: ->(str){ str != "Moscow" }
           optional :number, validator: /\d+/, default: 42
           optional :gears,  default: ->(obj){ choose_by(obj) }
+          optional :weel_d, as: :weel_diameter
         end
 
         def fetch params

data/lib/parametron.rb

@@ -9,6 +9,10 @@ module Parametron
 
   module ClassMethods
     attr_reader :params_validator
+    # Declare known parameter keys
+    # opts [Hash]
+    #     :strict => false ; Raise exception on unknown key
+    #     :reject => true  ; Reject unknown keys
     def params_for(method_name, opts={}, &block)
       instance_eval do
         @_method_name     = method_name.to_sym
@@ -23,13 +27,22 @@ module Parametron
       original = instance_method(name.to_sym)
       remove_method(name.to_sym)
       define_method(name) do |params|
-        new_params = _validate!(_set_defaults!(params))
+        new_params = _rename_params!(_validate!(_set_defaults!(params)))
         original.bind(self).call(new_params)
       end
     end
   end
 
   private
+  def _rename_params!(params)
+    new_par = params.dup
+    _validators_list.each do |v|
+      next unless v.as
+      new_par[v.as] = new_par.delete(v.name.to_sym) || new_par.delete(v.name.to_str)
+    end
+    new_par
+  end
+
   def _set_defaults!(params)
     new_par = params.dup
     _validators_list.each do |v|

data/lib/parametron/params_validator.rb

@@ -3,7 +3,8 @@ class Parametron::ParamsValidator
   attr_accessor :required_vals, :optional_vals
 
   def initialize(opts)
-    @raise_on_excess = opts.fetch(:strict, false)
+    @reject_unexpected = opts.fetch(:reject, true)
+    @raise_on_excess   = opts.fetch(:strict, false)
     self.required_vals = []
     self.optional_vals = []
   end
@@ -11,15 +12,17 @@ class Parametron::ParamsValidator
   def optional(name, opts={})
     default   = opts.delete(:default)
     validator = opts.delete(:validator)
+    as        = opts.delete(:as)
     raise Parametron::ErrorMethodParams.new("Not available param: #{opts.inspect}") unless opts.empty?
-    self.optional_vals << OptionalParameter.new(name.to_s, default, validator)
+    self.optional_vals << OptionalParameter.new(name.to_s, default, validator, as)
   end
 
   def required(name, opts={})
     default   = opts.delete(:default)
     validator = opts.delete(:validator)
+    as        = opts.delete(:as)
     raise Parametron::ErrorMethodParams.new("Not available param: #{opts.inspect}") unless opts.empty?
-    self.required_vals << RequiredParameter.new(name.to_s, default, validator)
+    self.required_vals << RequiredParameter.new(name.to_s, default, validator, as)
   end
 
   def validate!(obj, params)
@@ -42,7 +45,10 @@ class Parametron::ParamsValidator
 
     params.each do |k, v|
       key = k.to_s
-      next unless valid_keys.include?(key)
+      unless valid_keys.include?(key)
+        params.delete(key) if @reject_unexpected
+        next
+      end
       validators.find{|val| val.name == key}.tap do |curr_val|
         unless curr_val.valid?(v)
           obj.validation_error_cause << [key, v]
@@ -66,11 +72,18 @@ class Parametron::ParamsValidator
     self.required_vals.map{|x| x.name.to_s}
   end
 
-  class GenericParameter < Struct.new(:name, :default, :validator)
+  class GenericParameter < Struct.new(:name, :default, :validator, :as)
+    def initialize(name, default, validator, as)
+      super
+      unless as.nil? || String===as || Symbol===as
+        raise ArgumentError.new("Parameter :as should be either String or Symbol!")
+      end
+    end
+
     def valid?(value)
       case self.validator
       when Regexp then value && !!self.validator.match(value.to_s)
-      when Proc then value && !!self.validator(value).call
+      when Proc   then value && !!self.validator(value).call
       else
         true
       end

data/lib/parametron/version.rb

@@ -1,3 +1,3 @@
 module Parametron
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/spec/parametron_spec.rb

@@ -2,207 +2,254 @@ require 'spec_helper'
 
 describe Parametron do
 
-  context 'Params' do
-    context '.params' do
-      it 'accepts params block' do
-        expect do
-          class Victim
-            include Parametron
-            params_for(:_) do; end
-          end
-        end.not_to raise_error
-      end
+  context '.params' do
+    it 'accepts params block' do
+      expect do
+        class Victim
+          include Parametron
+          params_for(:_) do; end
+        end
+      end.not_to raise_error
     end
+  end
 
-    context '.optional' do
-      it 'accepts optional params' do
-        expect do
-          class Victim
-            include Parametron
-            params_for(:_) do
-              optional :city, default: ''
-            end
+  context '.optional' do
+    it 'accepts optional params' do
+      expect do
+        class Victim
+          include Parametron
+          params_for(:_) do
+            optional :city, default: 'Krasnoyarsk', as: :name
           end
-        end.not_to raise_error
-      end
+        end
+      end.not_to raise_error
+    end
 
-      it 'accepts defaults and validator params' do
-        expect do
-          class Victim
-            include Parametron
-            params_for(:_) do
-              optional :city, default: '', validator: /\d+/
-            end
+    it 'accepts defaults and validator params' do
+      expect do
+        class Victim
+          include Parametron
+          params_for(:_) do
+            optional :name, default: '', validator: /\d+/
           end
-        end.not_to raise_error
-      end
+        end
+      end.not_to raise_error
+    end
 
-      it 'store params validator' do
+    it 'accepts rename :as params' do
+      expect do
         class Victim
           include Parametron
           params_for(:_) do
-            optional :city, default: '', validator: /\d+/
+            optional :city, default: '', validator: /\d+/, as: :capital
           end
         end
-        Victim.params_validator.should be_kind_of(Parametron::ParamsValidator)
-        Victim.params_validator.required_vals.should be_empty
-        Victim.params_validator.optional_vals.should have(1).items
-      end
+      end.not_to raise_error
+    end
 
-    end # context .optional
+    it 'store params validator' do
+      class Victim
+        include Parametron
+        params_for(:_) do
+          optional :city, default: '', validator: /\d+/
+        end
+      end
+      Victim.params_validator.should be_kind_of(Parametron::ParamsValidator)
+      Victim.params_validator.required_vals.should be_empty
+      Victim.params_validator.optional_vals.should have(1).items
+    end
 
+  end # context .optional
 
-    context '.required' do
-      it 'accepts required params' do
-        expect do
-          class Victim
-            include Parametron
-            params_for(:_) do
-              required :city, default: ''
-            end
-          end
-        end.not_to raise_error
-      end
 
-      it 'accepts defaults and validator params' do
-        expect do
-          class Victim
-            include Parametron
-            params_for(:_) do
-              required :city, default: '', validator: /\d+/
-            end
+  context '.required' do
+    it 'accepts required params' do
+      expect do
+        class Victim
+          include Parametron
+          params_for(:_) do
+            required :city, default: ''
           end
-        end.not_to raise_error
-      end
+        end
+      end.not_to raise_error
+    end
 
-      it 'store params validator' do
+    it 'accepts defaults and validator params' do
+      expect do
         class Victim
           include Parametron
           params_for(:_) do
             required :city, default: '', validator: /\d+/
           end
         end
-        Victim.params_validator.should be_kind_of(Parametron::ParamsValidator)
-        Victim.params_validator.optional_vals.should be_empty
-        Victim.params_validator.required_vals.should have(1).items
+      end.not_to raise_error
+    end
+
+    it 'store params validator' do
+      class Victim
+        include Parametron
+        params_for(:_) do
+          required :city, default: '', validator: /\d+/
+        end
       end
+      Victim.params_validator.should be_kind_of(Parametron::ParamsValidator)
+      Victim.params_validator.optional_vals.should be_empty
+      Victim.params_validator.required_vals.should have(1).items
+    end
 
-    end # context .required
+  end # context .required
 
 
-    context '.validate' do
-      class VictimStrict
-        include Parametron
-        params_for(:fetch, strict: true) do
-          required :city,  validator: /\w+/
-          required :year,  validator: /\d+/, default: 2012
-          optional :title, validator: /\w+/
-          optional :other, default: 'staff'
-        end
-        def fetch params
-        end
+  context '.validate' do
+    class VictimStrict
+      include Parametron
+      params_for(:fetch, strict: true) do
+        required :city,  validator: /\w+/
+        required :year,  validator: /\d+/, default: 2012
+        optional :title, validator: /\w+/
+        optional :other, default: 'staff'
+      end
+      def fetch params
       end
-      class VictimRelaxed
+    end
+    class VictimRelaxed
+      include Parametron
+      params_for(:fetch) do
+        required :city,  validator: /\w+/
+        required :year,  validator: /\d+/, default: 2012
+        optional :title, validator: /\w+/
+        optional :other, default: 'staff'
+      end
+      def fetch params
+      end
+    end
+
+    it 'reject unexpected params' do
+      class Victim
         include Parametron
         params_for(:fetch) do
-          required :city,  validator: /\w+/
-          required :year,  validator: /\d+/, default: 2012
-          optional :title, validator: /\w+/
-          optional :other, default: 'staff'
-        end
-        def fetch params
+          optional :city, default: 'Krasnoyarsk'
         end
+        def fetch(params);  params ; end
       end
+      v = Victim.new
+      expect do
+        v.fetch({'_'=>'Not needed'})
+      end.not_to raise_error
+      res = v.fetch({'_'=>'Not needed'})
+      res.should_not have_key('_')
+    end
+
+    subject{ VictimStrict.new }
 
+    it 'accepts valid params' do
+      expect do
+        subject.fetch({city: 'Moskow', year: '1917', title: 'Nothing', other: 'Not need'})
+      end.not_to raise_error
+    end
+
+    it 'raise error when required param absent' do
+      expect do
+        subject.fetch({year: 1917, title: 'Nothing', other: 'Not need'})
+      end.to raise_error(Parametron::RequiredParamError)
+      subject.validation_error_cause.should eql [["city"]]
+    end
+
+    it 'raise error on unknown param' do
+      expect do
+        subject.fetch({city: 'Moskow', year: '1917', title: 'Nothing', other: 'Not need', '_' => 22})
+      end.to raise_error(Parametron::ExcessParameter)
+    end
+
+    context "when strict" do
       subject{ VictimStrict.new }
 
-      it 'accepts valid params' do
+      it 'raise on unknown params' do
         expect do
-          subject.fetch({city: 'Moskow', year: '1917', title: 'Nothing', other: 'Not need'})
-        end.not_to raise_error
+          subject.fetch({city: 'Moskow', year: 1917, title: 'Nothing', other: 'Not need', invalid: 'Yes'})
+        end.to raise_error(Parametron::ExcessParameter)
+        subject.validation_error_cause.should eql [["invalid", "Yes"]]
       end
+    end # context strict
+
+    context "when not strict" do
+      subject{ VictimRelaxed.new }
 
-      it 'raise error when required param absent' do
+      it 'not raise on unknown params' do
         expect do
-          subject.fetch({year: 1917, title: 'Nothing', other: 'Not need'})
-        end.to raise_error(Parametron::RequiredParamError)
-        subject.validation_error_cause.should eql [["city"]]
+          subject.fetch({city: 'Moskow', year: 1917, title: 'Nothing', other: 'Not need', invalid: 'Yes'})
+        end.not_to raise_error
+        subject.validation_error_cause.should eql [["invalid", "Yes"]]
+      end
+    end # context not strict
+
+  end # context .validate
+
+  context 'setting defaults for parameters' do
+    class VictimHavingDefaults
+      include Parametron
+      params_for(:fetch, strict: true) do
+        required :city,  validator: /\w+/
+        required :year,  validator: /\d+/, default: '2012'
+        optional :title, validator: /\w+/
+        optional :other,                   default: 'staff'
       end
 
+      attr_reader :city, :year, :title, :other
 
-      context "when strict" do
-        subject{ VictimStrict.new }
-
-        it 'raise on unknown params' do
-          expect do
-            subject.fetch({city: 'Moskow', year: 1917, title: 'Nothing', other: 'Not need', invalid: 'Yes'})
-          end.to raise_error(Parametron::ExcessParameter)
-          subject.validation_error_cause.should eql [["invalid", "Yes"]]
-        end
-      end # context strict
-
-      context "when not strict" do
-        subject{ VictimRelaxed.new }
-
-        it 'not raise on unknown params' do
-          expect do
-            subject.fetch({city: 'Moskow', year: 1917, title: 'Nothing', other: 'Not need', invalid: 'Yes'})
-          end.not_to raise_error
-          subject.validation_error_cause.should eql [["invalid", "Yes"]]
-        end
-      end # context not strict
-
-    end # context .validate
+      def fetch params
+        @city = params[:city]
+        @year = params[:year]
+        @title= params[:title]
+        @other= params[:other]
+      end
+    end
 
-    context 'setting defaults for parameters' do
-      class VictimWithDef
-        include Parametron
-        params_for(:fetch, strict: true) do
-          required :city,  validator: /\w+/
-          required :year,  validator: /\d+/, default: '2012'
-          optional :title, validator: /\w+/
-          optional :other,                   default: 'staff'
-        end
-        attr_reader :city, :year, :title, :other
+    let(:par){{city: 'Krasn', title: 'No way'}}
+    let(:par_full){{city: 'Krasn', year: '2000', title: 'No way', other: 'KillAll'}}
 
-        def fetch params
-          @city = params[:city]
-          @year = params[:year]
-          @title= params[:title]
-          @other= params[:other]
-        end
-      end
+    it 'accepts params' do
+      expect do
+        obj = VictimHavingDefaults.new
+        obj.fetch(par)
+      end.not_to raise_error
+    end
 
-      let(:par){{city: 'Krasn', title: 'No way'}}
-      let(:par_full){{city: 'Krasn', year: '2000', title: 'No way', other: 'KillAll'}}
+    it 'set defaults' do
+      obj = VictimHavingDefaults.new
+      obj.fetch(par)
+      obj.city.should  eql par[:city]
+      obj.title.should eql par[:title]
+      obj.year.should  eql '2012'
+      obj.other.should eql 'staff'
+    end
 
-     it 'accepts params' do
-        expect do
-          @obj = VictimWithDef.new
-          @obj.fetch(par)
-        end.not_to raise_error
-      end
+    it 'given params have advantage over defaults' do
+      obj = VictimHavingDefaults.new
+      obj.fetch(par_full)
+      obj.city.should  eql par_full[:city]
+      obj.title.should eql par_full[:title]
+      obj.year.should  eql par_full[:year]
+      obj.other.should eql par_full[:other]
+    end
+  end
 
-      it 'set defaults' do
-        @obj = VictimWithDef.new
-        @obj.fetch(par)
-        @obj.city.should  eql par[:city]
-        @obj.title.should eql par[:title]
-        @obj.year.should  eql '2012'
-        @obj.other.should eql 'staff'
+  context 'renames the keys' do
+    class VictimWithRenames
+      include Parametron
+      params_for(:fetch, strict: true) do
+        required :year,  validator: /\d+/, default: '2012', as: :last_year
       end
 
-      it 'given params have advantage over defaults' do
-        @obj = VictimWithDef.new
-        @obj.fetch(par_full)
-        @obj.city.should  eql par_full[:city]
-        @obj.title.should eql par_full[:title]
-        @obj.year.should  eql par_full[:year]
-        @obj.other.should eql par_full[:other]
+      def fetch params
+        params
       end
     end
 
+    it 'renames parameter key' do
+      obj = VictimWithRenames.new
+      obj.fetch({year: 2013}).should eql({:last_year => 2013})
+    end
 
-  end # context Params
-
+  end
 end

metadata

@@ -1,57 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: parametron
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Yury Batenko
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-25 00:00:00.000000000 Z
+date: 2013-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.3'
+  type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.3'
-  type: :development
-  prerelease: false
-  name: bundler
 - !ruby/object:Gem::Dependency
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+  type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
-  prerelease: false
-  name: rake
 - !ruby/object:Gem::Dependency
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+  type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
-  prerelease: false
-  name: rspec
 description: DSL for method arguments validation
 email:
 - jurbat@gmail.com
@@ -82,12 +82,12 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '1.9'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []