slim_form_object 2.1.2 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25c66a76b49d989ba6a6c9062d350e75a2ead10bbf4e956c5ee4ae7eff1ce5e8
-  data.tar.gz: 3716afd6b47bc40d0ceb0f132666e5a43ea927f80d07d2c93f0c1e958aafb1e5
+  metadata.gz: 5f9ec59874945c8a7ee3c6abb9fb4fd58999d9fd5ade2e950957e4cdd5ceff95
+  data.tar.gz: d1b79735bb67d58cce0982f6e91be53599226c0b7d9835f52791f2c6140ef33f
 SHA512:
-  metadata.gz: d71453875860516f9fe15c1be2fd55fec2c1dd7621f25be306ab2593b60475732a6d796f69bd19e0318dcb535163fd54e68415e95d08722741bd0cc259f2c607
-  data.tar.gz: d9874d69bef44a949ba1c11fe21956c8c1107384dce2175e5a270d4488111bed08a7c6c1fa23e21231b93623083ca95e40227c8fa03cfa963a8943723ad08e98
+  metadata.gz: f1889239d73747ed8812c5e10d20494cf876d434500b3576f8143035155e622cb33a6d8f39d8f12ae006e6289ae41feb2fd0006b40978ad5e2463db0f89ad705
+  data.tar.gz: dc5e445500ca32ef4b761d1721f9037fd258d682d0a51c6963d703615c430a08e5d2d4d46f6380a2b260ef2e3958f6e0f97f9e7cb6241009cbac5e53c6029e11

data/lib/slim_form_object/assign.rb

@@ -2,148 +2,116 @@ module SlimFormObject
   class Assign
     include ::HelperMethods
 
-    attr_reader :form_object, :params, :data_for_save, :base_module, :validator
+    attr_reader :form_object, :params, :data_for_assign
+    attr_accessor :data_objects_arr
 
     def initialize(form_object)
-      @form_object                 = form_object
-      @base_module                 = form_object.class.base_module
-      @params                      = form_object.params
-      @validator                   = Validator.new(form_object)
-      @data_for_save               = []
+      @form_object                     = form_object
+      @params                          = form_object.params
+      @structure                       = form_object.data_structure
+      @data_for_assign                 = []
+      @data_objects_arr                = []
     end
 
-    def apply_parameters
-      make_all_objects_with_attributes
-      clear_nil_objects
+    def apply_parameters_and_make_objects
+      parse_params
+      @data_objects_arr = make_data_objects(data_for_assign)
+      associate_all_objects(data_objects_arr)
 
-      data_for_save
-    end
-
-    def associate_objects
-      associate_all_nested_objects(data_for_save)
-      associate_all_main_objects(data_for_save)
-
-      data_for_save
+      data_objects_arr
     end
 
     private
 
-    def clear_nil_objects
-      arr_ids_nil_object = []
-      find_ids_nil_object(arr_ids_nil_object, data_for_save)
-      delete_hash_nil_objects(arr_ids_nil_object, data_for_save)
-    end
-
-    def delete_hash_nil_objects(ids_arr, nested_array)
-      nested_array.select!{|e| !ids_arr.include?(e.object_id)}
-      nested_array.each do |hash|
-        delete_hash_nil_objects(ids_arr, hash[:nested])
+    # data_for_assign format
+    # 
+    # [
+    #   { :model      => Product(id: integer, category_id: integer, brand_id: integer), 
+    #     :attributes => {:id=>"3871", :category_id=>"1", :brand_id=>"1"}, 
+    #     :nested     => [ 
+    #                      { :model      => FiltersProduct(id: integer, product_id: integer, filter_id: integer, value_id: integer), 
+    #                        :attributes => {:id=>"", :product_id=>"111", filter_id: "222", value_id: "333"}, 
+    #                        :nested     => []
+    #                      }
+    #                    ]
+    #   }
+    # ]
+    def make_hash_objects_and_nested_objects(key_params, value_params)
+      model      = get_class_of(key_params)
+      attributes = {}
+      nested     = []
+
+      value_params.each do |key, value|
+        if is_nested?(value)
+          if value.is_a?(Array)
+            value.each { |hash_params| nested << make_hash_objects_and_nested_objects(key, hash_params) }
+          elsif value.is_a?(ActionController::Parameters)
+            value.each { |index, hash_params| nested << make_hash_objects_and_nested_objects(key, hash_params) }
+          else
+            nested << make_hash_objects_and_nested_objects(key, value)
+          end
+        else
+          element = {key.to_sym => value}
+          attributes.merge!(element)
+        end
       end
+
+      {model: model, attributes: attributes, nested: nested}
     end
 
-    def find_ids_nil_object(ids_arr, nested_array)
-      nested_array.each do |hash|
-        ids_arr << hash.object_id if !validator.save_if_object_is_empty?(hash[:essence][:object])
-        find_ids_nil_object(ids_arr, hash[:nested])
+    def parse_params
+      params.each do |main_model_name, attributes|
+        data_for_assign << make_hash_objects_and_nested_objects(main_model_name, attributes)
       end
     end
 
-    def associate_all_nested_objects(nested_array, object=nil)
-      nested_array.each do |hash|
-        to_bind_models(object, hash[:essence][:object]) if object and validator.allow_to_associate_objects?(object, hash[:essence][:object])
-        associate_all_nested_objects(hash[:nested], hash[:essence][:object])
+    def is_nested?(value)
+      def nested?(e)
+        e.class == ActionController::Parameters or e.class == Hash
       end
-    end
 
-    def associate_all_main_objects(data_for_save)
-      objects = Array.new(data_for_save)
-      while object = objects.delete( objects[0] )
-        object_1 = object[:essence][:object]
-        objects.each do |hash|
-          object_2 = hash[:essence][:object]
-          next if !object_1.new_record? and !object_2.new_record?
-          to_bind_models(object_1, object_2) 
-        end
+      return true if nested?(value)
+
+      if value.class == Array
+        value.select{ |e| nested?(e) }.size == value.size
       end
     end
 
-    def make_all_objects_with_attributes
-      params.each do |main_model_name, hash|
-        assign_objects_attributes(main_model_name, hash, data_for_save, :main)
+    def make_data_objects(data_for_assign)
+      data_for_assign.map do |data|
+        data_object        = DataObject.new(name: snake(data[:model]), attributes: data[:attributes], form_object: form_object)
+        data_object.nested = make_data_objects(data[:nested])
+        data_object
       end
     end
 
-    def nested(model_name, nested_array, result_array)
-      nested_array.each do |nested_object|
-        assign_objects_attributes(model_name, nested_object, result_array, :nested)
+    def associate_objects(data_objects)
+      objects = Array.new(data_objects)
+      while data_object_1 = objects.delete( objects[0] )
+        associate_all_objects(data_object_1.nested)
+        objects.each do |data_object_2|
+          data_object_1.associate_with(data_object_2.associated_object)
+        end
       end
     end
 
-    def is_nested?(value)
-      return false unless value.class == Array
-      value.select{ |e| e.class == ActionController::Parameters or e.class == Hash }.size == value.size
-    end
+    def associate_all_objects(objects)
+      associate_objects(objects)
 
-    def assign_objects_attributes(model_name, hash, result_array, type)
-      object_hash          = {}
-      object               = type == :main ? form_object.send(model_name.to_sym) : get_class_of(model_name, base_module).new
-      object_hash[:nested] = []
-      object_attrs         = {}
-      hash.each do |key, val|
-        if is_nested?(val)
-          nested(key, val, object_hash[:nested])
-        else
-          object_attrs.merge!({"#{key}": val})
+      objects.each do |data_object|
+        data_object.nested.each do |nested_data_object|  
+          data_object.associate_with(nested_data_object.associated_object)
         end
       end
-      object.assign_attributes(object_attrs)
-      object_hash[:essence] = {model: model_name, object: object}
-      result_array << object_hash
     end
 
-    # PARAMS FORMAT
-    # { 
-    #   "user"=> { 
-    #     "email"=>"kjbkj@bk.ddd", 
-    #     "password"=>"dsmndvvs", 
-    #     "password_confirmation"=>"jvdjshvd", 
-    #     "address_user"=> [
-    #       {
-    #         "first_name"=>"dsdsd", 
-    #         "last_name"=>"kjhkjbk", 
-    #         "order"=> [
-    #           {
-    #             "created_at"=>"kjkjb", 
-    #             "updated_at"=>"kjbkjb"
-    #           }
-    #         ]
-    #       }
-    #     ]
-    #   }
-    # }
+    def clean_data_objects_arr(objects)
+      objects.select! do |data_object|
+        clean_data_objects_arr(data_object.nested)
+        data_object.save_if_nil_or_empty?
+      end
+    end
 
-    # make_all_objects_with_attributes() EXAMPLE @data_for_save FORMAT
-    #
-    # [
-    #   {
-    #     essence: {model: 'user', object: WoodShop::User.new(attributes)},
-    #     nested: [
-    #       {
-    #         essence: {model: 'address_user', object: WoodShop::AddressUser.new(attributes)},
-    #         nested: [
-    #           {
-    #             essence: {model: 'image', object: WoodShop::Image.new(attributes)},
-    #             nested: []
-    #           },
-    #           {
-    #             essence: {model: 'image', object: WoodShop::Image.new(attributes)},
-    #             nested: []
-    #           }
-    #         ] 
-    #       }
-    #     ]
-    #   }
-    # ]
   end
 end
 

data/lib/slim_form_object/data_object.rb

@@ -0,0 +1,73 @@
+module SlimFormObject
+  class DataObject
+    include ::HelperMethods
+
+    attr_reader :name, :model, :attributes, :object, :associated_object, :form_object
+    attr_accessor :nested
+
+    def initialize(name: nil, attributes: {}, form_object: nil)
+      @name              = name
+      @model             = get_class_of(name)
+      @attributes        = attributes
+      @form_object       = form_object
+      @object            = make_object
+      @associated_object = assign_attributes_for(make_object)
+      assign_attributes!
+    end
+
+    def associate_with(other_object, stage: nil)
+      case stage
+      when 1
+        obj = object
+      when 2
+        obj = object
+      else
+        obj = associated_object  
+      end
+
+      return obj if (stage != 2 and !obj.new_record? and !other_object.new_record?)
+
+      to_bind_models(obj, other_object)
+    end
+
+    def save_if_nil_or_empty?
+      save_if_empty? and save_if_nil?
+    end
+
+    def save_if_empty?
+      !form_object.not_save_if_empty_arr.include?(model) or !empty_attributes?
+    end
+
+    def save_if_nil?
+      !form_object.not_save_if_nil_arr.include?(model) or !nil_attributes?
+    end
+
+    private
+
+    def empty_attributes?
+      return false if nil_attributes?
+      attributes.each { |key, value| return false if value&.to_s&.strip != '' }
+      true
+    end
+
+    def nil_attributes?
+      attributes.empty?
+    end
+
+    def assign_attributes!
+      assign_attributes_for(object)
+    end
+
+    def assign_attributes_for(obj)
+      obj.assign_attributes(attributes)
+      obj
+    end
+
+    def make_object
+      attributes[:id].to_i > 0 ? model.find(attributes[:id]) : model.new
+    end
+  end
+end
+
+
+

data/lib/slim_form_object/form_helpers/extension_actionview.rb

@@ -1,3 +1,9 @@
+def const_exists?(const_name)
+  return true if Module.const_get(const_name)
+rescue NameError
+  return false
+end
+
 module HelperMethods
 
   private
@@ -14,51 +20,16 @@ module HelperMethods
     /^([^-]+)-([^-]+)(\([\s\S]+\))$/
   end
 
-  def sfo_collection_ads_regexp
-    /_ids$/
-  end
-
-  def sfo_form_attribute?(object)
-    object.class.ancestors[1] == SlimFormObject::Base if object
-  end
-
-  def sfo_attr?(method)
-    sfo_single_attr?(method)
-  end
-
-  def sfo_single_attr?(method)
-    method.to_s[sfo_single_attr_regexp] ? true : false
-  end
-
   def sfo_date_attr?(tag_name)
     tag_name.to_s[sfo_date_attr_regexp] ? true : false
   end
 
-  def sfo_collection_ads_attr?(tag_name)
-    tag_name.to_s[sfo_collection_ads_regexp] ? true : false
-  end
-
-  def sfo_get_tag_name(object_name, method, multiple, options)
-    model_name, attr_name = apply_expression_text(method)
-    if options[:sfo_nested]
-      "#{object_name}[#{model_name}][][#{attr_name}]#{"[]" if multiple}"
-    else
-      "#{object_name}[#{model_name}][#{attr_name}]#{"[]" if multiple}"
-    end
-  end
-
-  def sfo_get_method_name(method)
-    if sfo_single_attr?(method) and !sfo_collection_ads_attr?(method)
-      model_name, attr_name = apply_expression_text(method)
-      method = "#{model_name}_#{attr_name}"
-    end
-
-    method
-  end
-
   def sfo_get_date_tag_name(prefix, tag_name, options)
-    model_name, attr_name, date_type = apply_expression_date(tag_name)
-    if options[:sfo_nested]
+    # model_name, attr_name, date_type = apply_expression_date(tag_name)
+    attr_name, date_type = apply_expression_text(tag_name)
+    model_name = options[:sfo_model]
+
+    if options[:sfo_model]
       "#{prefix}[#{model_name}][][#{attr_name}#{date_type}]"
     else
       "#{prefix}[#{model_name}][#{attr_name}#{date_type}]"
@@ -83,145 +54,33 @@ module HelperMethods
   end
 end
 
-module ActionView
-  module Helpers
-    # EXTENSIONS
 
-    class DateTimeSelector
-      include HelperMethods
+if const_exists?('ActionView::Helpers')
 
-      def input_name_from_type(type)
-        prefix = @options[:prefix] || ActionView::Helpers::DateTimeSelector::DEFAULT_PREFIX
-        prefix += "[#{@options[:index]}]" if @options.has_key?(:index)
-
-        field_name = @options[:field_name] || type
-        if @options[:include_position]
-          field_name += "(#{ActionView::Helpers::DateTimeSelector::POSITION[type]}i)"
-        end
-        options = self.instance_variable_get(:@options)
-        return sfo_get_date_tag_name(prefix, field_name, options) if sfo_date_attr?(field_name)
-
-        @options[:discard_type] ? prefix : "#{prefix}[#{field_name}]"
-
-      end
-    end
+  module ActionView
+    module Helpers
+      # EXTENSIONS
 
-    module Tags
-      class Base
+      class DateTimeSelector
         include HelperMethods
 
-        private
-        
-        # TODO: Find a better way to solve this issue!
-        # This patch is needed since this Rails commit:
-        # https://github.com/rails/rails/commit/c1a118a
-        if defined? ::ActiveRecord
-          if ::ActiveRecord::VERSION::STRING < '5.2'
-            def value(object)
-              method_name = @options[:sfo_nested] ? apply_expression_text(@method_name)[1] : sfo_get_method_name(@method_name)
-              object.send method_name if object # use send instead of public_send
-            end
-          else # rails/rails#29791
-            def value
-              method_name = @options[:sfo_nested] ? apply_expression_text(@method_name)[1] : sfo_get_method_name(@method_name)
-              if @allow_method_names_outside_object
-                object.send method_name if object && object.respond_to?(@method_name, true)
-              else
-                object.send method_name if object
-              end
-            end
-          end
-        end
-
-        def tag_name(multiple = false, index = nil)
-          options = self.instance_variable_get(:@options)
-          return sfo_get_tag_name(@object_name, sanitized_method_name, multiple, options) if sfo_attr?(sanitized_method_name)
-
-          if index
-            "#{@object_name}[#{index}][#{sanitized_method_name}]#{"[]" if multiple}"
-          else
-            "#{@object_name}[#{sanitized_method_name}]#{"[]" if multiple}"
-          end
-        end
-      end
-    end
-
-    class FormBuilder
-      include HelperMethods
-
-      def initialize(object_name, object, template, options)
-        @nested_child_index = {}
-        @object_name, @object, @template, @options = object_name, object, template, options
-        @default_options = @options ? @options.slice(:index, :namespace, :skip_default_ids, :allow_method_names_outside_object) : {}
-        @default_options.merge!( {sfo_nested: options[:sfo_nested], sfo_main: options[:sfo_main]} )
-        if ::ActionView::VERSION::STRING > '5.2'
-          @default_html_options = @default_options.except(:skip_default_ids, :allow_method_names_outside_object)
-        end
-        convert_to_legacy_options(@options)
-
-        if @object_name.to_s.match(/\[\]$/)
-          if (object ||= @template.instance_variable_get("@#{Regexp.last_match.pre_match}")) && object.respond_to?(:to_param)
-            @auto_index = object.to_param
-          else
-            raise ArgumentError, "object[] naming but object param and @object var don't exist or don't respond to to_param: #{object.inspect}"
-          end
-        end
-
-        @multipart = nil
-        @index = options[:index] || options[:child_index]
-      end
+        def input_name_from_type(type)
+          prefix = @options[:prefix] || ActionView::Helpers::DateTimeSelector::DEFAULT_PREFIX
+          prefix += "[#{@options[:index]}]" if @options.has_key?(:index)
 
-      def fields_for(record_name, record_object = nil, fields_options = {}, &block)
-        fields_options, record_object = record_object, nil if record_object.is_a?(Hash) && record_object.extractable_options?
-        fields_options[:builder] ||= options[:builder]
-        fields_options[:namespace] = options[:namespace]
-        fields_options[:parent_builder] = self
-        self.options[:sfo_nested] ? fields_options.merge!({sfo_main: false}) : fields_options.merge!({sfo_main: true})
-
-        case record_name
-        when String, Symbol
-          if nested_attributes_association?(record_name)
-            return fields_for_with_nested_attributes(record_name, record_object, fields_options, block)
+          field_name = @options[:field_name] || type
+          if @options[:include_position]
+            field_name += "(#{ActionView::Helpers::DateTimeSelector::POSITION[type]}i)"
           end
-        else
-          record_object = record_name.is_a?(Array) ? record_name.last : record_name
-          record_name   = model_name_from_record_or_class(record_object).param_key
-        end
-
-        object_name = @object_name
-        index = if options.has_key?(:index)
-          options[:index]
-        elsif defined?(@auto_index)
-          object_name = object_name.to_s.sub(/\[\]$/, "")
-          @auto_index
-        end
+          options = self.instance_variable_get(:@options)
+          return sfo_get_date_tag_name(prefix, field_name, options) if sfo_date_attr?(field_name)
 
-        record_name = if index
-          "#{object_name}[#{index}][#{record_name}]"
-        elsif record_name.to_s.end_with?("[]")
-          record_name = record_name.to_s.sub(/(.*)\[\]$/, "[\\1][#{record_object.id}]")
-          "#{object_name}#{record_name}"
-        else
-          "#{object_name}[#{record_name}]"
-        end
-        fields_options[:child_index] = index
+          @options[:discard_type] ? prefix : "#{prefix}[#{field_name}]"
 
-        if fields_options[:sfo_nested]
-          record_object = object if !record_object
-          record_name   = record_name + '[][]' unless fields_options[:sfo_main]
         end
-        @template.fields_for(record_name, record_object, fields_options, &block)
       end
-    end
 
-    module FormHelper
-      include HelperMethods
-
-      # def fields_for(record_name, record_object = nil, options = {}, &block)
-      #   builder = instantiate_builder(record_name, record_object, options)
-      #   capture(builder, &block)
-      # end
+      
     end
-
   end
-end
+end

data/lib/slim_form_object/helpers.rb

@@ -3,21 +3,21 @@ module HelperMethods
     method( snake(model.to_s).to_sym ).call
   end
 
-  def get_class_of(snake_model_name, base_modulenil)
+  def get_class_of(snake_model_name, base_module=nil)
     pref = base_module ? (base_module.to_s + '::') : ''
-    Object.const_get( pref + snake_model_name.to_s.split('_').map(&:capitalize).join )
+    Module.const_get( pref + snake_model_name.to_s.split('_').map(&:capitalize).join )
   rescue
     nil
   end
 
   def to_bind_models(object_1, object_2)
-    if object_2.new_record?
-      assignment_to_each_other(object_2, object_1)
-    else
+    if object_1.new_record?
       assignment_to_each_other(object_1, object_2)
+      object_1
+    else
+      assignment_to_each_other(object_2, object_1)
+      object_2
     end
-
-    object_1
   end
 
   def assignment_to_each_other(object_1, object_2)

data/lib/slim_form_object/processing.rb

@@ -4,7 +4,7 @@ module SlimFormObject
     include ::HelperMethods
     extend  ::HelperMethods
 
-    attr_accessor :params, :data_for_save
+    attr_accessor :params, :data_objects_arr
 
     class << self
       attr_accessor :base_module
@@ -13,20 +13,50 @@ module SlimFormObject
         define_method(:model_name) { ActiveModel::Name.new(self, nil, name) }
       end
 
-      def init_single_models(*args)
-        define_array_of_models(:array_of_all_models, args)
+      # data_structure
+      def input_data_structure(**structure)
+        instance_eval do
+          define_method(:data_structure) { structure }
+        end
+        
+        define_array_of_models(:array_of_all_models, get_main_models_from_structure(structure))
       end
-      alias_method :init_models, :init_single_models
 
+      # array_models_which_not_save_if_empty
       def not_save_empty_object_for(*args)
         args.each { |model| raise "#{model.to_s} - type is not a Class" if model.class != Class }
-        self.instance_eval do
-          define_method(:array_models_which_not_save_if_empty) { args }
+        instance_eval do
+          define_method(:not_save_if_empty_arr) { args }
+        end
+      end
+
+      def not_save_nil_object_for(*args)
+        args.each { |model| raise "#{model.to_s} - type is not a Class" if model.class != Class }
+        instance_eval do
+          define_method(:not_save_if_nil_arr) { args }
+        end
+      end
+
+      # CALLBACKS
+      %w(allow_to_save_object allow_to_associate_objects before_save_form after_save_form before_validation_form after_validation_form).each do |method_name|
+        define_method("#{method_name}".to_sym) do |&block|
+          instance_eval do
+            define_method("#{method_name}_block".to_sym) { block }
+          end if block
+        end
+      end
+      # END CALLBACKS
+
+      private
+
+      def get_main_models_from_structure(structure)
+        structure.keys.map do |main_model_name|
+          get_class_of(main_model_name)
         end
       end
 
       def define_array_of_models(name, args)
-        self.instance_eval do
+        instance_eval do
           define_method(name) { args }
         end
         make_methods_for_objects_of(args)
@@ -45,22 +75,12 @@ module SlimFormObject
           end
         end
       end
-
-      # CALLBACKS
-      %w(allow_to_save_object allow_to_associate_objects before_save_form after_save_form before_validation_form after_validation_form).each do |method_name|
-        define_method("#{method_name}".to_sym) do |&block|
-          self.instance_eval do
-            define_method("#{method_name}_block".to_sym) { block }
-          end if block
-        end
-      end
-      # END CALLBACKS
     end
 
     def method_missing(name, *args, &block)
       if name[/_ids$/]
         model_name, attr_name = get_model_and_method_names(name)
-        return self.send(model_name.to_sym).send(attr_name.to_sym)
+        return send(model_name.to_sym).send(attr_name.to_sym)
       end
       super(name, args, block)
     end
@@ -91,6 +111,11 @@ module SlimFormObject
       Validator.new(self).validate_form_object
     end
 
+    def permit_params(params)
+      return {} if params.empty?
+      params.require(snake(model_name.name).gsub(/_+/, '_')).permit(data_structure)
+    end
+
     private
 
     def require_extensions
@@ -98,9 +123,8 @@ module SlimFormObject
     end
 
     def apply
-      assign             = Assign.new(self)
-      self.data_for_save = assign.apply_parameters
-      self.data_for_save = assign.associate_objects
+      assign                = Assign.new(self)
+      self.data_objects_arr = assign.apply_parameters_and_make_objects
     end
 
     def get_or_add_default_objects
@@ -114,14 +138,16 @@ module SlimFormObject
     end
     
     def default_settings
-      define_singleton_method(:array_models_which_not_save_if_empty) { [] } unless respond_to?(:array_models_which_not_save_if_empty)
+      define_singleton_method(:not_save_if_empty_arr)            { [] } unless respond_to?(:not_save_if_empty_arr)
+      define_singleton_method(:not_save_if_nil_arr)              { [] } unless respond_to?(:not_save_if_nil_arr)
       define_singleton_method(:allow_to_associate_objects_block) { Proc.new { true } } unless respond_to?(:allow_to_associate_objects_block)
-      define_singleton_method(:allow_to_save_object_block) { Proc.new { true } } unless respond_to?(:allow_to_save_object_block)
-      define_singleton_method(:before_save_form_block) { Proc.new {} } unless respond_to?(:before_save_form_block)
-      define_singleton_method(:after_save_form_block) { Proc.new {} } unless respond_to?(:after_save_form_block)
-      define_singleton_method(:before_validation_form_block) { Proc.new {} } unless respond_to?(:before_validation_form_block)
-      define_singleton_method(:after_validation_form_block) { Proc.new {} } unless respond_to?(:after_validation_form_block)
+      define_singleton_method(:allow_to_save_object_block)       { Proc.new { true } } unless respond_to?(:allow_to_save_object_block)
+      define_singleton_method(:before_save_form_block)           { Proc.new {} } unless respond_to?(:before_save_form_block)
+      define_singleton_method(:after_save_form_block)            { Proc.new {} } unless respond_to?(:after_save_form_block)
+      define_singleton_method(:before_validation_form_block)     { Proc.new {} } unless respond_to?(:before_validation_form_block)
+      define_singleton_method(:after_validation_form_block)      { Proc.new {} } unless respond_to?(:after_validation_form_block)
     end
+
   end
 end
 

data/lib/slim_form_object/saver.rb

@@ -2,19 +2,18 @@ module SlimFormObject
   class Saver
     include ::HelperMethods
 
-    attr_reader :form_object, :params, :validator, :base_module, :data_for_save
+    attr_reader :form_object, :params, :validator, :data_objects_arr
 
     def initialize(form_object)
-      @form_object           = form_object
-      @base_module           = form_object.class.base_module
-      @params                = form_object.params
-      @data_for_save         = form_object.data_for_save
-      @validator             = Validator.new(form_object)
+      @form_object                     = form_object
+      @params                          = form_object.params
+      @data_objects_arr                = form_object.data_objects_arr
+      @validator                       = Validator.new(form_object)
     end
 
     def save
       if form_object.valid?
-        save_all
+        _save
         return true
       end
       false
@@ -24,52 +23,69 @@ module SlimFormObject
 
     def save!
       if form_object.valid?
-        save_all
+        _save
       end
       true
     end
 
     private
 
-    def save_all
+    def _save
       ActiveRecord::Base.transaction do
         form_object.before_save_form_block.call(form_object)
-        save_main_objects
-        save_nested_objects
+        stage_1(data_objects_arr)
+        stage_2(data_objects_arr)
+        stage_3(data_objects_arr)
         form_object.after_save_form_block.call(form_object)
       end
     end
 
-    def save_main_objects
-      objects = Array.new(data_for_save)
-      while object = objects.delete( objects[0] )
-        object_1 = object[:essence][:object]
-        objects.each{ |hash| save_objects(object_1, hash[:essence][:object]) }
-        save_last_model_if_not_associations(object_1)
+    # association per parent with all nested objects
+    def stage_1(objects)
+      objects.each do |data_object|
+        data_object.nested.each do |nested_data_object|
+          data_object.associate_with(nested_data_object.object, stage: 1)
+        end
+        stage_1(data_object.nested)
+      end
+    end
+
+    # save all objects
+    def stage_2(objects)
+      objects.each do |data_object|
+        stage_2(data_object.nested)
+        save_object(data_object.object)
+      end
+    end
+
+    # associate and save between a nested objects
+    def stage_3(objects)
+      associate_and_save_objects(objects)
+
+      objects.each do |data_object|
+        stage_3(data_object.nested)
       end
     end
 
-    def save_nested_objects
-      data_for_save.each do |main_object|
-        main_object[:nested].each do |object|
-          save_object(object[:essence][:object])
+    def associate_and_save_objects(data_objects)
+      objects = Array.new(data_objects)
+      while data_object_1 = objects.delete( objects[0] )
+        objects.each do |data_object_2|
+          obj = data_object_1.associate_with(data_object_2.object, stage: 2)
+          save_object(obj)
         end
       end
     end
 
-    def save_objects(object_1, object_2)
-      object_for_save = to_bind_models(object_1, object_2)
-      save_object(object_for_save)
+    def allow_to_save(object_of_model)
+      object_of_model.valid? and object_of_model.changed? and validator.allow_to_save_object?(object_of_model)
     end
 
     def save_object(object_of_model)
-      object_of_model.save! if validator.allow_to_save_object?(object_of_model)
+      if allow_to_save(object_of_model)
+          object_of_model.save!
+      end
     end
 
-    def save_last_model_if_not_associations(object_1)
-      association_trigger = false
-      data_for_save.each { |hash| association_trigger = true if get_reflection(object_1.class, hash[:essence][:object].class) }
-      save_object(object_1) unless association_trigger
-    end
   end
 end

data/lib/slim_form_object/validator.rb

@@ -2,26 +2,22 @@ module SlimFormObject
   class Validator
     include ::HelperMethods
 
-    attr_reader :form_object, :params, :array_models_which_not_save_if_empty, :base_module, :data_for_save
+    attr_reader :form_object, :params, :not_save_if_empty_arr, :not_save_if_nil_arr, :data_objects_arr
 
     def initialize(form_object)
       @form_object                          = form_object
-      @base_module                          = form_object.class.base_module
       @params                               = form_object.params
-      @data_for_save                        = form_object.data_for_save
-      @array_models_which_not_save_if_empty = form_object.array_models_which_not_save_if_empty
+      @data_objects_arr                     = form_object.data_objects_arr
+      @not_save_if_empty_arr                = form_object.not_save_if_empty_arr
+      @not_save_if_nil_arr                  = form_object.not_save_if_nil_arr
     end
 
     def validate_form_object
       form_object.before_validation_form_block.call(form_object)
-      validation_objects(data_for_save)
+      validation_objects(data_objects_arr)
       form_object.after_validation_form_block.call(form_object)
     end
 
-    def save_if_object_is_empty?(object)
-      !(all_attributes_is_nil?(object) and array_models_which_not_save_if_empty.include?(object.class))
-    end
-
     def allow_to_save_object?(object)
       form_object.allow_to_save_object_block.call(object)
     end
@@ -32,18 +28,11 @@ module SlimFormObject
 
     private
 
-    def validation_objects(nested_array)
-      nested_array.each do |hash|
-        set_errors( snake(hash[:essence][:object].class), hash[:essence][:object].errors ) unless hash[:essence][:object].valid?
-        validation_objects(hash[:nested])
-      end
-    end
-
-    def all_attributes_is_nil?(object)
-      object.class.column_names.each do |attr_name|
-        return false if object.send(attr_name.to_sym) != nil
+    def validation_objects(objects)
+      objects.each do |data_object|
+        set_errors( snake(data_object.model), data_object.associated_object.errors ) unless data_object.associated_object.valid?
+        validation_objects(data_object.nested)
       end
-      true
     end
 
     def set_errors(object_name, object_errors)

data/lib/slim_form_object/version.rb

@@ -1,3 +1,3 @@
 module SlimFormObject
-  VERSION = "2.1.2"
+  VERSION = "3.0.0"
 end

data/lib/slim_form_object.rb

@@ -4,6 +4,7 @@ require "slim_form_object/validator"
 require "slim_form_object/processing"
 require "slim_form_object/assign"
 require "slim_form_object/saver"
+require "slim_form_object/data_object"
 
 module SlimFormObject
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: slim_form_object
 version: !ruby/object:Gem::Version
-  version: 2.1.2
+  version: 3.0.0
 platform: ruby
 authors:
 - woodcrust
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-08 00:00:00.000000000 Z
+date: 2019-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -24,20 +24,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 4.0.0
-- !ruby/object:Gem::Dependency
-  name: actionview
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 4.0.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 4.0.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -162,6 +148,7 @@ files:
 - bin/slim_form_object
 - lib/slim_form_object.rb
 - lib/slim_form_object/assign.rb
+- lib/slim_form_object/data_object.rb
 - lib/slim_form_object/form_helpers/extension_actionview.rb
 - lib/slim_form_object/helpers.rb
 - lib/slim_form_object/processing.rb