simple_params 1.1.2 → 1.2.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZGYzNDdhM2YxYjQzNzI3NWEzOTlkMGRjNDA2M2NiN2NmZjA2ZGFjOQ==
+    NjYyNWJhNWU2ZmNkMGMxZWFjMmEzMjM3OWQyNWY0ZWZhNzY2N2ZhNw==
   data.tar.gz: !binary |-
-    OGM2ODA5ZWI2ZTVjMDFlY2EwMzhmY2Y2ODM0ZTY5MmY5YjFmYTA0MA==
+    NzllYWUzNDJjMDRkNTM5YzIwODMyYWRiYzhmOTU4M2NkNTczNGE0NA==
 SHA512:
   metadata.gz: !binary |-
-    YWQzNjllOTcyYjAxNDM5NWNhYmI0ZjM0ZmVlMjFlMGE4MWU0ZjIwMDIzNmFi
-    ZmNmZjY1NDYyMTg5MDYyYjhjZDI5ZjE0MDU5MmI2YjUwYzBjMjg3M2Q1NzVi
-    MzcxMDFlOWY3MDAwZjM1MGNhMGI3ZDJjZWFjOTg2YmYyMGVjYTE=
+    ZTNkMzU1YjhkMjdjNzg0MWFkZDhmNTUzYmU3OGVhZmNlOTBiYjM0NWRiMjRl
+    YWRiMTkzNTBiNjY3MDBiODAzOGUxYzk0MDY0YzJiNTUwNGRlNThmMTM0ODg0
+    MDc5MGU5MTgxNjQzMWY4ZjQ0MTc2OWQ5MTI3ZjUyNmVjM2ZiZTk=
   data.tar.gz: !binary |-
-    YTRmNmQ0YzdmMmRjYWNlOTU5ZGNmZDJjZWNjOTRkZDEyZGNkOGUzOGNjZTRk
-    MTAyMGE0ZjlmNWU2MDJjOGNjOGVkOTFhMjc4MjM2NGY3NmZhY2JlNzc3OWM5
-    MWJjZTgwNThjMTg3NjBmNzFjN2ViOGIzYTI5M2VlYzc5MTQzYjk=
+    N2ExNzhkZjk0MmM4YTM4ZWQ2YjYwZGVjZTJlMDBiNjVmMGVkYzE1NWVlMDA0
+    Y2IwMWFjNjAyMjE1MWE2MDk5ZDY4NWNlODAxMDEyOGNiZjgxMTJlYzg4ZWZk
+    ZTE5N2E2ZTFhZTcxZDY0OWJiZjViNzZiOGE0NTNjMTZmNWZlNzY=

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    simple_params (1.1.1)
+    simple_params (1.1.2)
       activemodel (>= 3.0, < 5.0)
       shoulda-matchers (~> 2.8)
       virtus (>= 1.0.0)

data/lib/simple_params/api_pie_doc/nested_attribute.rb

@@ -19,9 +19,16 @@ module SimpleParams
     end
 
     private
+    def nested_type
+      if options[:type].present? && options[:type].to_sym == :array
+        'Array'
+      else
+        'Hash'
+      end
+    end
 
     def nested_description
-      start = "param :#{name}, Hash, #{description}, #{requirement_description} do"
+      start = "param :#{name}, #{nested_type}, #{description}, #{requirement_description} do"
       attribute_descriptors = []
       attributes.each { |attribute| attribute_descriptors << attribute.to_s }
       finish = "end"

data/lib/simple_params/api_pie_doc.rb

@@ -2,22 +2,17 @@ module SimpleParams
   class ApiPieDoc
 
     attr_accessor :base_attributes,
-                  :nested_hashes,
-                  :nested_arrays,
+                  :nested_classes,
                   :nested_attributes,
-                  :nested_array_attributes,
                   :docs
 
     def initialize(simple_params)
       self.base_attributes = simple_params.defined_attributes
-      self.nested_hashes = simple_params.nested_hashes
-      self.nested_arrays = simple_params.nested_arrays
+      self.nested_classes = simple_params.nested_classes
       self.nested_attributes = []
-      self.nested_array_attributes = []
       self.docs = []
 
-      build_nested_attributes
-      build_nested_array_attributes
+      build_nested_classes
     end
 
     def build
@@ -25,12 +20,8 @@ module SimpleParams
         docs << Attribute.new(attribute).to_s
       end
 
-      nested_attributes.each do |nested_attribute|
-        docs << NestedAttribute.new(nested_attribute).to_s
-      end
-
-      nested_array_attributes.each do |nested_attribute|
-        docs << NestedArray.new(nested_attribute).to_s
+      nested_attributes.each do |nested_class|
+        docs << NestedAttribute.new(nested_class).to_s
       end
 
       docs.join("\n")
@@ -38,16 +29,10 @@ module SimpleParams
 
     private
 
-    def build_nested_attributes
-      nested_hashes.each do |name, parameter_set|
+    def build_nested_classes
+      nested_classes.each do |name, parameter_set|
         nested_attributes << { name => parameter_set.defined_attributes, options: parameter_set.options }
       end
     end
-
-    def build_nested_array_attributes
-      nested_arrays.each do |name, parameter_set|
-        nested_array_attributes << { name => parameter_set.defined_attributes, options: parameter_set.options }
-      end
-    end
   end
 end

data/lib/simple_params/attribute.rb

@@ -3,12 +3,8 @@ require "virtus"
 
 module SimpleParams
   class Attribute
-    attr_reader :parent
-    attr_reader :name
-    attr_reader :type
-    attr_reader :default
-    attr_reader :validations
-    attr_reader :formatter
+    attr_reader :parent, :name, :type, :default, 
+      :validations, :formatter
 
     def initialize(parent, name, opts={})
       @parent = parent

data/lib/simple_params/concerns/date_time_helpers.rb

@@ -0,0 +1,68 @@
+module SimpleParams
+  module DateTimeHelpers
+    extend ActiveSupport::Concern
+
+    included do
+    end
+
+    module ClassMethods
+      def define_date_helper_methods(name)
+        define_method("#{name}(3i)=") do |day|
+          attribute = send("#{name}_attribute")
+          value = attribute.send("value") || Date.today
+          attribute.send("value=", Date.new(value.year, value.month, day.to_i))
+        end
+
+        define_method("#{name}(2i)=") do |month|
+          attribute = send("#{name}_attribute")
+          value = attribute.send("value") || Date.today
+          attribute.send("value=", Date.new(value.year, month.to_i, value.day))
+        end
+
+        define_method("#{name}(1i)=") do |year|
+          attribute = send("#{name}_attribute")
+          value = attribute.send("value") || Date.today
+          attribute.send("value=", Date.new(year.to_i, value.month, value.day))
+        end
+      end
+
+      def define_datetime_helper_methods(name)
+        define_method("#{name}(6i)=") do |sec|
+          attribute = send("#{name}_attribute")
+          value = attribute.send("value") || Time.now.utc
+          attribute.send("value=", Time.new(value.year, value.month, value.day, value.hour, value.min, sec.to_i, value.utc_offset))
+        end
+
+        define_method("#{name}(5i)=") do |minute|
+          attribute = send("#{name}_attribute")
+          value = attribute.send("value") || Time.now.utc
+          attribute.send("value=", Time.new(value.year, value.month, value.day, value.hour, minute.to_i, value.sec, value.utc_offset))
+        end
+
+        define_method("#{name}(4i)=") do |hour|
+          attribute = send("#{name}_attribute")
+          value = attribute.send("value") || Time.now.utc
+          attribute.send("value=", Time.new(value.year, value.month, value.day, hour.to_i, value.min, value.sec, value.utc_offset))
+        end
+
+        define_method("#{name}(3i)=") do |day|
+          attribute = send("#{name}_attribute")
+          value = attribute.send("value") || Time.now.utc
+          attribute.send("value=", Time.new(value.year, value.month, day.to_i, value.hour, value.min, value.sec, value.utc_offset))
+        end
+
+        define_method("#{name}(2i)=") do |month|
+          attribute = send("#{name}_attribute")
+          value = attribute.send("value") || Time.now.utc
+          attribute.send("value=", Time.new(value.year, month.to_i, value.day, value.hour, value.min, value.sec, value.utc_offset))
+        end
+
+        define_method("#{name}(1i)=") do |year|
+          attribute = send("#{name}_attribute")
+          value = attribute.send("value") || Time.now.utc
+          attribute.send("value=", Time.new(year.to_i, value.month, value.day, value.hour, value.min, value.sec, value.utc_offset))
+        end
+      end
+    end
+  end
+end

data/lib/simple_params/concerns/has_attributes.rb

@@ -0,0 +1,68 @@
+module SimpleParams
+  module HasAttributes
+    extend ActiveSupport::Concern
+    included do
+      def define_attributes(params)
+        self.class.defined_attributes.each_pair do |key, opts|
+          send("#{key}_attribute=", Attribute.new(self, key, opts))
+        end
+      end
+
+      def attributes
+        (defined_attributes.keys + nested_classes.keys).flatten
+      end
+    end
+
+    module ClassMethods
+      def defined_attributes
+        @define_attributes ||= {}
+      end
+
+      private
+      def define_attribute(name, opts = {})
+        opts[:type] ||= :string
+        defined_attributes[name.to_sym] = opts
+        attr_accessor "#{name}_attribute"
+
+        define_method("#{name}") do
+          attribute = send("#{name}_attribute")
+          attribute.send("value")
+        end
+
+        define_method("raw_#{name}") do
+          attribute = send("#{name}_attribute")
+          attribute.send("raw_value")
+        end
+
+        define_method("#{name}=") do |val|
+          attribute = send("#{name}_attribute")
+          attribute.send("value=", val)
+        end
+
+        if [Date, 'Date', :date].include?(opts[:type])
+          define_date_helper_methods(name)
+        elsif [DateTime, 'DateTime', :datetime, Time, 'Time', :time].include?(opts[:type])
+          define_datetime_helper_methods(name)
+        end
+      end
+
+      def add_validations(name, opts = {})
+        validations = opts[:validations] || {}
+        has_default = opts.has_key?(:default) # checking has_key? because :default may be nil
+        optional = opts[:optional]
+        if !validations.empty?
+          if optional || has_default
+            validations.merge!(allow_nil: true)
+          else
+            validations.merge!(presence: true)
+          end
+        else
+          if !optional && !has_default
+            validations.merge!(presence: true)
+          end
+        end
+        validates name, validations unless validations.empty?
+      end
+    end
+  end
+end

data/lib/simple_params/concerns/has_typed_params.rb

@@ -0,0 +1,30 @@
+module SimpleParams
+  module HasTypedParams
+    extend ActiveSupport::Concern
+
+    TYPES = [
+      :integer,
+      :string,
+      :decimal,
+      :datetime,
+      :date,
+      :time,
+      :float,
+      :boolean,
+      :array,
+      :hash,
+      :object
+    ]
+
+    included do
+    end
+
+    module ClassMethods
+      TYPES.each do |sym|
+        define_method("#{sym}_param") do |name, opts={}|
+          param(name, opts.merge(type: sym))
+        end
+      end
+    end
+  end
+end

data/lib/simple_params/concerns/hash_helpers.rb

@@ -0,0 +1,27 @@
+module SimpleParams
+  module HashHelpers
+    extend ActiveSupport::Concern
+
+    included do
+
+      private
+      def hash_to_symbolized_hash(hash)
+        hash.inject({}){|result, (key, value)|
+          new_key = case key
+                    when String then key.to_sym
+                    else key
+                    end
+          new_value = case value
+                      when Hash then hash_to_symbolized_hash(value)
+                      else value
+                      end
+          result[new_key] = new_value
+          result
+        }
+      end
+    end
+
+    module ClassMethods
+    end
+  end
+end

data/lib/simple_params/concerns/rails_helpers.rb

@@ -0,0 +1,33 @@
+require 'active_support/core_ext/string'
+
+module SimpleParams
+  module RailsHelpers
+    extend ActiveSupport::Concern
+    included do
+      # Required for ActiveModel
+      def persisted?; false end
+    end
+
+    module ClassMethods
+      def define_rails_helpers(name, klass)
+        # E.g. if we have a nested_class named :phones, then we need:
+        #  - a method called :phones_attributes that also sets :phones
+        #  - a method called :build_phone
+
+        define_method("#{name}_attributes=") do |value|
+          send("#{name}=", value)
+        end
+
+        singular_key = singularized_key(name)
+        define_method("build_#{singular_key}") do |value={}|
+          klass.new(value, self)
+        end
+      end
+
+      private
+      def singularized_key(key)
+        key.to_s.singularize
+      end
+    end
+  end
+end

data/lib/simple_params/concerns/strict_params.rb

@@ -0,0 +1,68 @@
+module SimpleParams
+  module StrictParams
+    extend ActiveSupport::Concern
+
+    included do
+      def set_strictness
+        if self.class.strict_enforcement.nil?
+          self.class.strict_enforcement = true
+        end
+      end
+
+      # Overriding this method to allow for non-strict enforcement!
+      def method_missing(method_name, *arguments, &block)
+        if strict_enforcement?
+          raise SimpleParamsError, "parameter #{method_name} is not defined."
+        else
+          if @original_params.include?(method_name.to_sym)
+            value = @original_params[method_name.to_sym]
+            if value.is_a?(Hash)
+              define_anonymous_class(method_name, value)
+            else
+              Attribute.new(self, method_name).value = value
+            end
+          end
+        end
+      end
+
+      def respond_to?(method_name, include_private = false)
+        if strict_enforcement?
+          super
+        else
+          @original_params.include?(method_name.to_sym) || super
+        end
+      end
+
+      def define_anonymous_class(name, hash)
+        klass_name = name.to_s.split('_').collect(&:capitalize).join
+        anonymous_klass = Class.new(Params).tap do |klass|
+          if self.class.const_defined?(klass_name)
+            begin
+              self.class.send(:remove_const, klass_name)
+            rescue NameError
+            end
+          end
+          self.class.const_set(klass_name, klass)
+        end
+        anonymous_klass.allow_undefined_params
+        anonymous_klass.new(hash)
+      end
+
+      def strict_enforcement?
+        self.class.strict_enforcement
+      end
+    end
+
+    module ClassMethods
+      attr_accessor :strict_enforcement
+
+      def strict
+        @strict_enforcement = true
+      end
+
+      def allow_undefined_params
+        @strict_enforcement = false
+      end
+    end
+  end
+end

data/lib/simple_params/concerns/validations.rb

@@ -0,0 +1,41 @@
+require "active_model"
+
+module SimpleParams
+  module Validations
+    extend ActiveModel::Validations
+
+    def valid?(context = nil)
+      current_context, self.validation_context = validation_context, context
+      errors.clear
+      run_validations!
+
+      # Make sure that nested classes are also valid
+      nested_classes_valid? && errors.empty?
+    ensure
+      self.validation_context = current_context
+    end
+
+    def validate!
+      unless valid?
+        raise SimpleParamsError, self.errors.to_hash.to_s
+      end
+    end
+
+    private
+    def nested_classes_valid?
+      nested_classes.map do |key, array|
+        nested_class_valid?(send("#{key}") )
+      end.all?
+    end
+
+    def nested_class_valid?(nested_class)
+      if nested_class.is_a?(Array)
+        # Have to map? & THEN all?, or else it won't
+        #  necessarily call valid? on every object
+        nested_class.map(&:valid?).all?
+      else
+        nested_class.valid?
+      end
+    end
+  end
+end