stark_parameters 0.1.2 → 0.1.3

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZGUzNzI0OWE3OGRhNTRkOWJmYjg3NzU4NDAxY2I3OGU1NDI5MGEzNg==
+    NzM2YTU1MzI1YzAyNzZhYzVlOWVhMThiN2NlNGVkOGNiNTdmMjgyMQ==
   data.tar.gz: !binary |-
-    NTE3ZTc5ODAwNzE1ZTM5YzBkMDgwOTI2Nzc1ZTJiNTZiYTRiZTY3OQ==
+    NWQ0MzljZGIxYTMzMzBlNTI2ZjY3YWIwM2Y3NjY2NWIzN2JjY2JjNg==
 SHA512:
   metadata.gz: !binary |-
-    NzIwMGQ2ZDI2Zjk4YTc1ZmI2MDZhY2U0M2ViZmIwNmNhMGIwY2ZjYjgyMTdm
-    ZGM3NTc1NWY0NTlhYzAyNmZkODljZTliN2VhMzQzYzYxNjMzMDdkNDMxN2Ez
-    ZDI2MDc2NzllNzY4ZjExNzc1OTUzZWI2ZWY0OTg3ZmIzZDIxODQ=
+    M2Y1NmZiZjgyZjQyNjZlZDJiNDIxZTU0ODk5MzFhY2EwNDRlMDc5NzNiOTU0
+    NmJhNjdjZTlmYmE0MDNjOTM2ZWZiNWQyNDNjNGU4M2U3ZmI4MDUwZGQwYjA4
+    ZmMzMmNiM2Y2N2M2YjYyMDFiOWNlMDM2ZDYwZjEwMWUxMDZmNjM=
   data.tar.gz: !binary |-
-    MjRkMjQwOWQ4NzdiN2VhOTc2MzgzZjAxNTRjYjhhYzYxMzhmZGJmZDdlYjE2
-    NDk5ZmJhMjExOTliMGJiMmNkZmM5YWYwZGE0ZWI4ZGY1MzI5OTQzODI4YjYx
-    NGNkOTBkZDY0MDhjNWQxMzQ4NjUxM2JmOTA2MTdiYzI5Mjk1NzU=
+    ZjcwNzRkNGUwNTAwNjdhMTFhMzI3ODUwYzhmYTJjY2QxNjYxYTRlNmQxYTY3
+    ZGQ1MDk2MmVhYmE4ZGQwM2QyZWJmNWZlYzUwOThiYzYxNDZiMjE0MzUwZTcz
+    YTFlYjhiOTI5ZmZkN2EzOTlhNWJmNjFkOGQ3ODU1ZjljNDEwN2M=

data/lib/stark_parameters/version.rb

@@ -1,3 +1,3 @@
 module StarkParameters
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/lib/stark_parameters.rb

@@ -12,56 +12,67 @@ module StarkParameters
     klass.aliases = {}
   end
 
+  attr_reader :params
+
   def initialize(*params)
-    @params = params.each_with_object(make_strong_parameter({})) do |p, hash|
-      hash.merge!(make_strong_parameter(p))
+    @params = params.reduce(make_strong_parameter({})) do |hash, param|
+      hash.merge(make_strong_parameter(param))
     end
   end
 
   def params
-    make_strong_parameter(permitted_params.merge(required_params)).permit!
+    all_params = permitted_params.merge(required_params)
+    make_strong_parameter(all_params).permit!
   end
 
   private
 
   def permitted_params
     self.class.permitted_params.each_with_object({}) do |permitted_param, hash|
-      param_key = permitted_param.is_a?(Hash) ? permitted_param.keys.first : permitted_param
-      permitted_value = @params.permit(permitted_param).values.first
-      hash[(self.class.aliases[param_key] || param_key).to_s] = permitted_value unless permitted_value.nil?
+      permitted_key = permitted_param.is_a?(Hash) ? permitted_param.keys.first : permitted_param
+      name = self.class.aliases[permitted_key] || permitted_key
+      permitted_value = respond_to?(name) ? send(name) : @params.permit(permitted_param)[name]
+      hash[name] = permitted_value unless permitted_value.nil?
     end
   end
 
   def required_params
-    presence_required_params = self.class.presence_required_params.each_with_object({}) do |required_params, hash|
-      param_key = require_one(required_params)
-      hash[(self.class.aliases[param_key] || param_key).to_s] = @params[param_key]
-    end
-    presence_optional_params =  self.class.presence_optional_params.each_with_object({}) do |required_params, hash|
-      param_key = require_one(required_params, true)
-      hash[(self.class.aliases[param_key] || param_key).to_s] = @params[param_key]
-    end
     presence_required_params.merge(presence_optional_params)
   end
 
+  def presence_optional_params
+    collect_required_params(self.class.presence_optional_params, true)
+  end
+
+  def presence_required_params
+    collect_required_params(self.class.presence_required_params, false)
+  end
+
+  def collect_required_params(keys, allow_nil)
+    keys.each_with_object({}) do |required_params, hash|
+      required_key = require_one(required_params, allow_nil)
+
+      key = self.class.aliases[required_key] || required_key
+      value = respond_to?(key) ? send(key) : @params[required_key]
+      hash[key] = value
+    end
+  end
 
   def make_strong_parameter(hash)
     return hash if hash.is_a? ActionController::Parameters
     ActionController::Parameters.new(hash)
   end
 
-  def require_one(to_require, allow_nil = false)
-    present_param = to_require.detect {|p| @params.include?(p) && (allow_nil || !@params[p].nil?) }
-    unless present_param && value_presence_valid(present_param, allow_nil)
+  def require_one(to_require, allow_nil)
+    present_param = to_require.detect{|k| respond_to?(k)} ||
+              to_require.detect {|k| @params.include?(k) && (allow_nil || @params[k]) }
+
+    unless present_param
       raise ActionController::ParameterMissing.new(to_require.join(" or "))
     end
     present_param
   end
 
-  def value_presence_valid(present_param, allow_nil)
-    allow_nil ? true : !@params.stringify_keys[present_param.to_s].nil?
-  end
-
   module ClassMethods
     attr_accessor :permitted_params, :presence_required_params, :presence_optional_params, :aliases
 
@@ -78,14 +89,9 @@ module StarkParameters
     end
 
     def permit(permitted_param, options = {})
+      permitted_key = permitted_param.is_a?(Hash) ? permitted_param.keys.first : permitted_param
       if new_name = options[:as]
-        param_key = if permitted_param.is_a? Hash
-          permitted_param.keys.first
-        else
-          permitted_param
-        end
-
-        @aliases[param_key] = new_name
+        @aliases[permitted_key] = new_name
       end
       @permitted_params.push permitted_param
     end

data/spec/lib/stark_parameters_spec.rb

@@ -8,7 +8,6 @@ describe StarkParameters do
       require :name
       require :id
       require :email, as: :login
-      permit  author: [:id, :name]
       permit  :password, as: :pword
       permit  :awesome
       require [:last_name, :surname]
@@ -21,8 +20,7 @@ describe StarkParameters do
       "name" => "Ryan",
       "email" => "ryan@6wunderkinder.com",
       "password" => "fdsafdsa",
-      "surname" => "Levick",
-      "author" => { "id" => 1, "name" => "Steve" }
+      "surname" => "Levick"
     }
   end
 
@@ -33,7 +31,6 @@ describe StarkParameters do
 
     it { expect(validator.params.to_hash).to include("name" => "Ryan") }
     it { expect(validator.params.to_hash).to include("surname" => "Levick") }
-    it { expect(validator.params.to_hash).to include("author" => { "id" => 1, "name" => "Steve" }) }
     it { expect(validator.params.to_hash).to include("login" => "ryan@6wunderkinder.com") }
     it { expect(validator.params.to_hash.keys).to_not include("email") }
 
@@ -74,11 +71,31 @@ describe StarkParameters do
     end
   end
 
+  context "nested permitted params" do
+    let(:test_klass) do
+      Class.new do
+        include StarkParameters
+
+        permit author: [:name, :surname]
+      end
+    end
+    let(:params) {{"author" => {"name" => "Ryan", "surname" => "Levick", "age" => 25}} }
+
+    it { expect(validator.params.to_hash).to include("author" => {"name"  => "Ryan", "surname" => "Levick"}) }
+  end
+
   context "when permitted param is missing" do
-    let(:params) { full_params.except("author")  }
+    let(:test_klass) do
+      Class.new do
+        include StarkParameters
 
-    it { expect{ validator.params }.to_not raise_error }
-    it { expect(validator.params.to_hash.keys).to_not include("author") }
+        permit :name
+        permit :age
+      end
+    end
+    let(:params) {{ "surname" => "Levick", "age" => 25 }}
+
+    it { expect(validator.params.to_hash).to include({"age" => 25}) }
   end
 
   context "when permitted param is false" do
@@ -89,8 +106,25 @@ describe StarkParameters do
   end
 
   context "with multiple params" do
-    let(:validator) { test_klass.new(full_params.except("name"), {"name" => "Ryan"}) }
+    let(:validator) { test_klass.new(full_params.except("name"), {"name" => "Steve"}) }
 
-    it { expect(validator.params.to_hash).to include("name" => "Ryan") }
+    it { expect(validator.params.to_hash).to include("name" => "Steve") }
+  end
+
+  context "with default values provided by methods" do
+    let(:test_klass) do
+      Class.new do
+        include StarkParameters
+
+        require :foo
+
+        def foo
+          "bar"
+        end
+      end
+    end
+
+    let(:validator) { test_klass.new({}) }
+    it { expect(validator.params.to_hash).to include("foo" => "bar") }
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stark_parameters
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - rylev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-24 00:00:00.000000000 Z
+date: 2014-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack