simple_params 1.1.2 → 1.2.0

data/lib/simple_params/errors.rb

@@ -4,18 +4,15 @@ module SimpleParams
   class Errors < ActiveModel::Errors
     attr_reader :base
 
-    def initialize(base, nested_hash_errors = {}, nested_array_errors = {})
+    def initialize(base, nested_classes = {})
       super(base)
       @base = base
-      @nested_hash_errors = symbolize_nested(nested_hash_errors)
-      @nested_array_errors = symbolize_nested(nested_array_errors)
+      @nested_classes = symbolize_nested(nested_classes)
     end
 
     def [](attribute)
-      if is_a_nested_hash_error_attribute?(attribute)
-        set(attribute.to_sym, @nested_hash_errors[attribute.to_sym])
-      elsif is_a_nested_array_error_attribute?(attribute)
-        set(attribute.to_sym, @nested_array_errors[attribute.to_sym])
+      if nested_attribute?(attribute)
+        set_nested(attribute)
       else
         get(attribute.to_sym) || set(attribute.to_sym, [])
       end
@@ -37,18 +34,22 @@ module SimpleParams
 
     def clear
       super
-      @nested_hash_errors.map { |attribute, errors| errors.clear }
+      @nested_classes.map do |attribute, klass| 
+        run_or_mapped_run(klass) { |k| k.errors.clear }
+      end
     end
 
     def empty?
       super &&
-      @nested_hash_errors.all? { |attribute, errors| errors.empty? }
+      @nested_classes.all? do |attribute, klass|
+        run_or_mapped_run(klass) { |k| k.errors.empty? }
+      end
     end
     alias_method :blank?, :empty? 
 
     def include?(attribute)
-      if is_a_nested_hash_error_attribute?(attribute)
-        !@nested_hash_errors[attribute.to_sym].empty?
+      if nested_attribute?(attribute)
+        !nested_class(attribute).errors.empty?
       else
         messages[attribute].present?
       end
@@ -58,39 +59,33 @@ module SimpleParams
 
     def values
       messages.values +
-      @nested_hash_errors.map do |attribute, errors|
-        errors.values
+      @nested_classes.map do |key, klass|
+        run_or_mapped_run(klass) { |k| k.errors.values }
       end
     end
 
     def full_messages
       parent_messages = map { |attribute, message| full_message(attribute, message) }
-      nested_messages = @nested_hash_errors.map do |attribute, errors|
-        unless errors.full_messages.nil?
-          errors.full_messages.map { |message| "#{attribute} " + message }
+      nested_messages = @nested_classes.map do |attribute, klass|
+        run_or_mapped_run(klass) do |k|
+          unless k.errors.full_messages.nil?
+            k.errors.full_messages.map { |message| "#{attribute} " + message }
+          end
         end
       end
       (parent_messages + nested_messages).flatten
     end
 
     def to_hash(full_messages = false)
-      messages = if full_messages
-        msgs = {}
-        self.messages.each do |attribute, array|
-          msgs[attribute] = array.map { |message| full_message(attribute, message) }
-        end
-        msgs
-      else
-        self.messages.dup
-      end
+      msgs = get_messages(self, full_messages)
 
-      @nested_hash_errors.map do |attribute, errors|
-        error_messages = nested_error_messages(attribute, full_messages)
-        unless errors.empty?
-          messages.merge!(attribute.to_sym => error_messages)
+      @nested_classes.map do |attribute, klass|
+        nested_msgs = run_or_mapped_run(klass) { |k| get_messages(k.errors, full_messages) }
+        unless empty_messages?(nested_msgs)
+          msgs.merge!(attribute.to_sym => nested_msgs)
         end
       end
-      messages
+      msgs
     end
 
     def to_s(full_messages = false)
@@ -99,35 +94,48 @@ module SimpleParams
     end
 
     private
-    def nested_error_messages(attribute, full_messages = false)
-      if is_a_nested_hash_error_attribute?(attribute)
-        errors = @nested_hash_errors[attribute.to_sym]
-        if full_messages          
-          errors.messages.each_with_object({}) do |(attr, array), messages|
-            messages[attr] = array.map { |message| errors.full_message(attr, message) }
-          end
-        else
-          errors.messages.dup
-        end
-      else
-        {}
-      end
+    def nested_class(key)
+      @nested_classes[key.to_sym]
+    end
+
+    def nested_attribute?(attribute)
+      @nested_classes.keys.include?(attribute.to_sym)
+    end
+
+    def set_nested(attribute)
+      klass = nested_class(attribute)
+      errors = run_or_mapped_run(klass) { |k| k.errors }
+      set(attribute.to_sym, errors)
     end
 
     def add_error_to_attribute(attribute, error)
-      if is_a_nested_hash_error_attribute?(attribute)
-        @nested_hash_errors[attribute.to_sym][:base] = error
+      if nested_attribute?(attribute)
+        @nested_classes[attribute].errors.add(:base, error)
       else
         self[attribute] << error
       end
     end
 
-    def is_a_nested_hash_error_attribute?(attribute)
-      @nested_hash_errors.keys.include?(attribute.to_sym)
+    def get_messages(object, full_messages = false)
+      if full_messages
+        object.messages.each_with_object({}) do |(attribute, array), messages|
+          messages[attribute] = array.map { |message| object.full_message(attribute, message) }
+        end
+      else
+        object.messages.dup
+      end
+    end
+
+    def empty_messages?(msgs)
+      msgs.nil? || msgs.empty? || (msgs.is_a?(Array) && msgs.all?(&:empty?))
     end
 
-    def is_a_nested_array_error_attribute?(attribute)
-      @nested_array_errors.keys.include?(attribute.to_sym)
+    def run_or_mapped_run(object, &block)
+      if object.is_a?(Array)
+        object.map { |obj| yield obj }
+      else
+        yield object
+      end
     end
 
     def symbolize_nested(nested)

data/lib/simple_params/nested_params.rb

@@ -0,0 +1,73 @@
+module SimpleParams
+  class NestedParams < Params
+    class << self
+      def type
+        options[:type]
+      end
+
+      def array?
+        type.to_sym == :array
+      end
+
+      def hash?
+        type.to_sym == :hash
+      end
+
+      def with_ids?
+        !!options[:with_ids]
+      end
+
+      def define_new_hash_class(parent, name, options, &block)
+        options = options.merge(type: :hash)
+        define_new_class(parent, name, options, &block)
+      end
+
+      def define_new_array_class(parent, name, options, &block)
+        options = options.merge(type: :array)
+        define_new_class(parent, name, options, &block)
+      end
+
+      private
+      def define_new_class(parent, name, options, &block)
+        klass_name = name.to_s.split('_').collect(&:capitalize).join
+        Class.new(self).tap do |klass|
+          parent.const_set(klass_name, klass)
+          extend ActiveModel::Naming
+          klass.class_eval(&block)
+          klass.class_eval("self.options = #{options}")
+        end
+      end
+    end
+
+    def initialize(params={}, parent = nil)
+      @parent = parent
+      super(params)
+    end
+
+    def id
+      @id
+    end
+
+    def set_accessors(params={})
+      if class_has_ids?
+        @id = params.keys.first
+        params = params.values.first
+      end
+
+      super(params)
+    end
+
+    private
+    def class_has_ids?
+      self.class.with_ids?
+    end
+
+    def hash_class?
+      self.class.hash?
+    end
+
+    def array_class?
+      self.class.array?
+    end
+  end
+end

data/lib/simple_params/params.rb

@@ -7,30 +7,15 @@ module SimpleParams
     include ActiveModel::Validations
     extend ActiveModel::Naming
     include SimpleParams::Validations
-
-    TYPES = [
-      :integer,
-      :string,
-      :decimal,
-      :datetime,
-      :date,
-      :time,
-      :float,
-      :boolean,
-      :array,
-      :hash,
-      :object
-    ]
+    include SimpleParams::HasAttributes
+    include SimpleParams::HasTypedParams
+    include SimpleParams::HashHelpers
+    include SimpleParams::DateTimeHelpers
+    include SimpleParams::RailsHelpers
+    include SimpleParams::StrictParams
 
     class << self
-
-      TYPES.each do |sym|
-        define_method("#{sym}_param") do |name, opts={}|
-          param(name, opts.merge(type: sym))
-        end
-      end
-
-      attr_accessor :strict_enforcement, :options
+      attr_accessor :options
 
       def model_name
         ActiveModel::Name.new(self)
@@ -40,200 +25,85 @@ module SimpleParams
         SimpleParams::ApiPieDoc.new(self).build
       end
 
-      def strict
-        @strict_enforcement = true
-      end
-
-      def allow_undefined_params
-        @strict_enforcement = false
-      end
-
       def param(name, opts={})
         define_attribute(name, opts)
         add_validations(name, opts)
       end
 
-      def nested_hash(name, opts={}, &block)
-        attr_accessor name
-        nested_class = define_nested_class(name, opts, &block)
-        @nested_hashes ||= {}
-        @nested_hashes[name.to_sym] = nested_class
+      def nested_classes
+        @nested_classes ||= {}
       end
-      alias_method :nested_param, :nested_hash
-      alias_method :nested, :nested_hash
 
       def nested_hashes
-        @nested_hashes ||= {}
+        nested_classes.select { |key, klass| klass.hash? }
       end
 
-      def nested_array(name, opts={}, &block)
-        attr_accessor name
-        nested_array_class = define_nested_class(name, opts, &block)
-        @nested_arrays ||= {}
-        @nested_arrays[name.to_sym] = nested_array_class
+      def nested_arrays
+        nested_classes.select { |key, klass| klass.array? }
       end
 
-      def nested_arrays
-        @nested_arrays ||= {}
+      def nested_hash(name, opts={}, &block)
+        klass = NestedParams.define_new_hash_class(self, name, opts, &block)
+        add_nested_class(name, klass)
       end
+      alias_method :nested_param, :nested_hash
+      alias_method :nested, :nested_hash
 
-      def defined_attributes
-        @define_attributes ||= {}
+      def nested_array(name, opts={}, &block)
+        klass = NestedParams.define_new_array_class(self, name, opts, &block)
+        add_nested_class(name, klass)
       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
+      def add_nested_class(name, klass)
+        @nested_classes ||= {}
+        @nested_classes[name.to_sym] = klass
+        define_nested_accessor(name, klass)
+        define_rails_helpers(name, klass)
       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)
+      def define_nested_accessor(name, klass)
+        define_method("#{name}") do
+          if instance_variable_defined?("@#{name}")
+            instance_variable_get("@#{name}")
           else
-            validations.merge!(presence: true)
+            init_value = klass.hash? ? klass.new({}, self) : []
+            instance_variable_set("@#{name}", init_value)
           end
-        else
-          if !optional && !has_default
-            validations.merge!(presence: true)
-          end
-        end
-        validates name, validations unless validations.empty?
-      end
-
-      def define_nested_class(name, options, &block)
-        klass_name = name.to_s.split('_').collect(&:capitalize).join
-        Class.new(Params).tap do |klass|
-          self.const_set(klass_name, klass)
-          extend ActiveModel::Naming
-          klass.class_eval(&block)
-          klass.class_eval("self.options = #{options}")
-        end
-      end
-
-      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))
+        define_method("#{name}=") do |initializer|
+          init_value = if initializer.is_a?(Array)
+            if klass.with_ids?
+              initializer.first.each_pair.inject([]) do |array, (key, val)|
+                array << klass.new({key => val}, self)
+              end
+            else
+              initializer.map { |val| klass.new(val, self) }
+            end
+          else
+            klass.new(initializer, self)
+          end
+          instance_variable_set("@#{name}", init_value)
         end
       end
     end
 
-    def initialize(params={}, parent = nil)
-      # Set default strict params
-      if self.class.strict_enforcement.nil?
-        self.class.strict_enforcement = true
-      end
+    attr_accessor :original_params
+    alias_method :original_hash, :original_params
+    alias_method :raw_params, :original_params
+
+    def initialize(params={})
+      set_strictness
 
-      @parent = parent
-      # Initializing Params
       @original_params = hash_to_symbolized_hash(params)
       define_attributes(@original_params)
 
-      # Nested Hashes
-      @nested_params = nested_hashes.keys
-
-      # Nested Arrays
-      @nested_arrays = nested_arrays.keys
-
       # Nested Classes
-      set_accessors(params)
-      initialize_nested_classes
-      initialize_nested_array_classes
-    end
+      @nested_classes = nested_classes.keys
 
-    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_hashes.keys + nested_arrays.keys).flatten
-    end
-
-    def original_params
-      @original_params ||= {}
+      set_accessors(params)
     end
-    alias_method :original_hash, :original_params
-    alias_method :raw_params, :original_params
 
     def to_hash
       hash = {}
@@ -256,115 +126,27 @@ module SimpleParams
     end
 
     def errors
-      nested_errors_hash = {}
-      @nested_params.each do |param|
-        nested_errors_hash[param.to_sym] = send(param).errors
-      end
-
-      nested_arrays_hash = {}
-      @nested_arrays.each do |array|
-        nested_arrays_hash[array.to_sym] = send(array).map(&:errors)
-      end
-
-      @errors ||= SimpleParams::Errors.new(self, nested_errors_hash, nested_arrays_hash)
-    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
+      nested_class_hash = {}
+      @nested_classes.each do |param|
+        nested_class_hash[param.to_sym] = send(param)
       end
-    end
 
-    def respond_to?(method_name, include_private = false)
-      if strict_enforcement?
-        super
-      else
-        @original_params.include?(method_name.to_sym) || super
-      end
+      @errors ||= SimpleParams::Errors.new(self, nested_class_hash)
     end
 
     private
-    def strict_enforcement?
-      self.class.strict_enforcement
-    end
-
     def set_accessors(params={})
       params.each do |attribute_name, value|
-        # Don't set accessors for nested classes
-        unless value.is_a?(Hash) 
-          send("#{attribute_name}=", value)
-        end
+        send("#{attribute_name}=", value)
       end
     end
 
-    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
-
     def defined_attributes
       self.class.defined_attributes
     end
 
-    def nested_hashes
-      self.class.nested_hashes
-    end
-
-    def nested_arrays
-      self.class.nested_arrays
-    end
-
-    def initialize_nested_classes
-      nested_hashes.each do |key, klass|
-        initialization_params = @original_params[key.to_sym] || {}
-        send("#{key}=", klass.new(initialization_params, self))
-      end
-    end
-
-    def initialize_nested_array_classes
-      nested_arrays.each do |key, klass|
-        initialization_params = @original_params[key.to_sym] || []
-        initialization_array = []
-        initialization_params.each do |initialization_param|
-          initialization_array << klass.new(initialization_param, self)
-        end
-        send("#{key}=", initialization_array)
-      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)
+    def nested_classes
+      self.class.nested_classes
     end
   end
 end