slim_form_object 0.5.23 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c790c09a7f14bba8e6919633cf1e42b329b28e09
-  data.tar.gz: 9a56d7be9abf5a89d75a0e1528e3f5379d1e7f93
+  metadata.gz: eead85525874b4ad6ac4fea0f9bdace9f2cc5f90
+  data.tar.gz: e382a9c9eabfcdf5744647916a6f9d68dc1e06bd
 SHA512:
-  metadata.gz: 41588b2e3ee7615fa00c64d8bf6358f28c7ba77775247a02af54e0ce87fee09f943bbce12832677b18a3d80b87a1f2c59bb95d0c18726df11e8b3dfac82824ca
-  data.tar.gz: 0b2adebf258a068570ab894e0e27babe9888ce33389db897b4704a98801dee89c3fac6a5dfdcff80fd7e3908fcac6b253dd4fc839f43d72e25dd89b18b68502d
+  metadata.gz: 65fc388efca69511b521c7c4589fdf0828f3f8ef5a6e4f4693b8bb78fc53370752e1563f1ef2692066c38b34b15d5cce7bc184d28fb7b1c4fbd9a5c356908346
+  data.tar.gz: c97e749fe60e6cf20a813aa9ff77ff24f68352122d863592c71d4a1cc96b06eb6eeb4146aa92353e9a7b8bb7801a7d66d50cbb4e9a8498ef7c2a8a96d9ec0203

data/lib/slim_form_object.rb

@@ -1,7 +1,10 @@
 require "slim_form_object/version"
+require "slim_form_object/form_helpers/extension_actionview"
 require "slim_form_object/helpers"
+require "slim_form_object/validator"
 require "slim_form_object/processing"
+require "slim_form_object/assign"
+require "slim_form_object/saver"
 
 module SlimFormObject
-
 end

data/lib/slim_form_object/assign.rb

@@ -0,0 +1,89 @@
+module SlimFormObject
+  class Assign
+    include ::HelperMethods
+
+    attr_reader :form_object, :params, :array_all_objects_for_save, :not_save_this_model, :result_hash_updated_objects
+
+    def initialize(form_object)
+      @form_object                  = form_object
+      @params                       = form_object.params
+      @array_all_objects_for_save   = form_object.array_all_objects_for_save
+      @not_save_this_model          = form_object.not_save_this_model
+      @result_hash_updated_objects  = {objects: [], nested_objects: {}}
+    end
+
+    def apply_parameters
+      filter_not_save_objects
+      update_objects_attributes
+      make_nested_objects
+
+      result_hash_updated_objects
+    end
+
+    def filter_not_save_objects
+      array_all_objects_for_save.reject do |object|
+        not_save_this_model.include?(object.class)
+      end
+    end
+
+    # STANDART OBJECTS
+
+    def update_objects_attributes
+      array_all_objects_for_save.each do |object|
+        object.assign_attributes(hash_params_of_object(object))
+      end
+
+      result_hash_updated_objects[:objects] = array_all_objects_for_save
+    end
+
+
+    def hash_params_of_object(object)
+      if force_permit(params[snake(object.class.to_s)])
+        params[snake(object.class.to_s)]
+      else
+        {}
+      end
+    end
+
+    def force_permit(params)
+      return nil if params.class != ActionController::Parameters
+      params.instance_variable_set(:@permitted, true)
+      params
+    end
+
+    # NESTED OBJECTS
+    # example params
+    # 
+    #                     "sfo-multiple"=>{
+    # snake_model_name      "category_vacancy"=>{
+    # snake_object_name        "specialty_vacancy"=>[ 
+    # parameters                  {"name"=>"4", "category_vacancy_id"=>"12"}, {"name"=>"6", "category_vacancy_id"=>"14"} ]}} 
+    #
+    def make_nested_objects
+      params.keys.each do |key|
+        if key == 'sfo-multiple'
+          params[key].keys.each do |snake_model_name|
+            result_hash_updated_objects[:nested_objects][snake_model_name.to_sym] ||= []
+
+            params[key][snake_model_name].keys.each do |snake_object_name|
+              params[key][snake_model_name][snake_object_name].each do |parameters|
+                object = get_class_of_snake_model_name(snake_object_name).new
+                object.assign_attributes(force_permit(parameters))
+                result_hash_updated_objects[:nested_objects][snake_model_name.to_sym] << object
+              end
+            end
+          end
+        end
+      end
+    end
+
+  end
+end
+
+
+
+
+
+
+
+

data/lib/slim_form_object/form_helpers/extension_actionview.rb

@@ -0,0 +1,161 @@
+module ActionView
+  module Helpers
+    module HelperMethods
+      def sfo_fields_for(name, object = nil, form_options: {}, options: {}, &block)
+        object = get_class_of_snake_model_name(name.to_s).new unless object
+
+        if options[:sfo_form]
+          form_object_class = get_class_of_snake_model_name(name.to_s)
+          name = "slim_form_object_#{name}"
+          object = form_object_class.new(form_options)
+        end
+
+        fields_for(name, object, options, &block)
+      end
+
+      private
+
+      def get_class_of_snake_model_name(snake_model_name)
+        Object.const_get( snake_model_name.split('_').map(&:capitalize).join )
+      end
+
+      def sfo_single_attr_regexp
+        /^([^-]+)-([^-]+)$/
+      end
+
+      def sfo_multiple_attr_regexp
+        /sfo-multiple/
+      end
+
+      def sfo_date_attr_regexp
+        /^([^-]+)-([^-]+)(\([\s\S]+\))$/
+      end
+
+      def sfo_form_attribute?(object)
+        object.class.ancestors[1] == SlimFormObject::Base if object
+      end
+
+      def sfo_attr?(method)
+        sfo_single_attr?(method) or sfo_multiple_attr?(method)
+      end
+
+      def sfo_single_attr?(method)
+        method.to_s[sfo_single_attr_regexp] ? true : false
+      end
+
+      def sfo_multiple_attr?(string)
+        string.to_s[sfo_multiple_attr_regexp] ? true : false
+      end
+
+      def sfo_date_attr?(tag_name)
+        tag_name.to_s[sfo_date_attr_regexp] ? true : false
+      end
+
+      def sfo_get_tag_name(object_name, method, multiple)
+        if sfo_multiple_attr?(object_name)
+          method.to_s[sfo_single_attr_regexp]
+          model_name = $1
+          attr_name  = $2
+          tag_name   = "#{object_name}[#{model_name}][][#{attr_name}]#{"[]" if multiple}"
+        elsif sfo_single_attr?(method)
+          method.to_s[sfo_single_attr_regexp]
+          model_name = $1
+          attr_name  = $2
+          tag_name   = "#{object_name}[#{model_name}][#{attr_name}]#{"[]" if multiple}"
+        end
+
+        tag_name
+      end
+
+      def sfo_get_method_name(method)
+        if sfo_single_attr?(method)
+          method.to_s[sfo_single_attr_regexp]
+          model_name = $1
+          attr_name  = $2
+          method     = "#{model_name}_#{attr_name}"
+        end
+
+        method
+      end
+
+      def sfo_get_date_tag_name(prefix, tag_name)
+        if sfo_multiple_attr?(prefix)
+          tag_name[sfo_date_attr_regexp]
+          model_name = $1
+          attr_name  = $2
+          date_type  = $3
+          tag_name   = "#{prefix}[#{model_name}][][#{attr_name}#{date_type}]"
+        elsif tag_name[sfo_date_attr_regexp]
+          model_name = $1
+          attr_name  = $2
+          date_type  = $3
+          tag_name   = "#{prefix}[#{model_name}][#{attr_name}#{date_type}]"
+        end
+
+        tag_name
+      end
+    end
+
+    class DateTimeSelector
+      include HelperMethods
+
+      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
+
+        return sfo_get_date_tag_name(prefix, field_name) if sfo_date_attr?(field_name)
+
+        @options[:discard_type] ? prefix : "#{prefix}[#{field_name}]"
+
+      end
+    end
+
+    module Tags
+      class Base
+        include HelperMethods
+
+        private
+
+        def value(object)
+          method_name = sfo_get_method_name(@method_name)
+          object.public_send method_name if object
+        end
+
+        def tag_name(multiple = false, index = nil)
+          return sfo_get_tag_name(@object_name, sanitized_method_name, multiple) 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
+    end
+
+    module FormHelper
+      include HelperMethods
+
+      def fields_for(record_name, record_object = nil, options = {}, &block)
+        if options[:sfo_multiple]
+          record_name[/^([\s\S]+)(\[[\s\S]+\])/]
+          part_1 = $1
+          part_2 = $2
+          record_name = "#{part_1}[sfo-multiple]#{part_2}"
+        end
+        builder = instantiate_builder(record_name, record_object, options)
+        capture(builder, &block)
+      end
+    end
+
+  end
+end

data/lib/slim_form_object/helpers.rb

@@ -1,5 +1,6 @@
 module HelperMethods
   def snake(string)
+    string = string.to_s
     string.gsub!(/((\w)([A-Z]))/,'\2_\3')
     class_name_if_module(string.downcase)
   end
@@ -8,4 +9,12 @@ module HelperMethods
     return $1 if string =~ /^.+::(.+)$/
     string
   end
+
+  def get_self_object(model)
+    method( snake(model.to_s).to_sym ).call
+  end
+
+  def get_class_of_snake_model_name(snake_model_name)
+    Object.const_get( snake_model_name.to_s.split('_').map(&:capitalize).join )
+  end
 end

data/lib/slim_form_object/processing.rb

@@ -1,163 +1,117 @@
+require 'byebug'
+
 module SlimFormObject
+  class Base
+    include ActiveModel::Model
+    include ::HelperMethods
+    extend  ::HelperMethods
 
-  def self.included(base)
-    base.include ActiveModel::Model
-    base.include HelperMethods
-    base.extend  ClassMethods
-    base.extend  HelperMethods
-  end
+    attr_accessor :params, :array_objects_for_save, :hash_objects_for_save
 
-  module ClassMethods
+    class << self
 
-    def init_models(*args)
-      self.instance_eval do
-        define_method(:array_of_models) { args }
+      def set_model_name(name)
+        define_method(:model_name) { ActiveModel::Name.new(self, nil, name) }
       end
-      add_attributes(args)
-    end
 
-    def add_attributes(models)
-      #attr_accessor for models and env params
-      attr_accessor :params
-      models.each{ |model| attr_accessor snake(model.to_s).to_sym }
-
-      #delegate attributes of models
-      models.each do |model|
-        model.column_names.each do |attr|
-          delegate attr.to_sym, "#{attr}=".to_sym,
-                   to: snake(model.to_s).to_sym,
-                   prefix: snake(model.to_s).to_sym
+      def init_single_models(*args)
+        define_array_of_models(:array_of_all_models, args)
+      end
+      alias_method :init_models, :init_single_models
+
+      def not_save_this_model(*args)
+        self.instance_eval do
+          define_method(:not_validate_this_models) { args }
         end
       end
-    end
 
-    def set_model_name(name)
-      define_method(:model_name) { ActiveModel::Name.new(self, nil, name) }
-    end
-  end
+      def force_save_if_all_attr_is_nil(*args)
+        self.instance_eval do
+          define_method(:force_save_if_all_attr_is_nil) { args }
+        end
+      end
 
-  def submit
-    @array_of_models ||= array_of_models.reject do |model| 
-      array_of_models_without_validates.include?(model) if self.respond_to?(:array_of_models_without_validates)
-    end
-    update_attributes
-    update_attributes_for_collection
-    self
-  end
+      def define_array_of_models(name, args)
+        self.instance_eval do
+          define_method(name) { args }
+        end
+        make_methods_for_objects_of(args)
+      end
 
-  alias_method :apply_parameters, :submit
+      def make_methods_for_objects_of(models)
+        models.each{ |model| attr_accessor snake(model.to_s).to_sym }
+
+        delegate_models_attributes(models)
+      end
 
-  def save
-    if valid?
-      models = Array.new(@array_of_models)
-      while model1 = models.delete( models[0] )
-        models.each{ |model2| save_models(model1, model2) }
+      def delegate_models_attributes(models)
+        models.each do |model|
+          model.column_names.each do |attr|
+            delegate attr.to_sym, "#{attr}=".to_sym, to: snake(model.to_s).to_sym, prefix: true
+          end
+        end
       end
-      return true
     end
-    false
-  end
 
-  def not_validate(*args)
-    define_singleton_method(:array_of_models_without_validates) { args }
-  end
+    def initialize(params: {})
+      self.params = params
+      get_or_add_default_objects
+    end
+
+    def get_or_add_default_objects
+      array_of_all_models.map do |model|
+        if get_self_object(model) == nil
+          method( "#{snake(model.to_s)}=" ).call(model.new)
+        else
+          get_self_object(model)
+        end
+      end
+    end
+    # INIT END
 
-  private
 
-  def save_models(model1, model2)
-    self_object_of_model1 = method( snake(model1.to_s) ).call
-    self_object_of_model2 = method( snake(model2.to_s) ).call
-    association           = get_association(model1, model2)
+    def apply_parameters
+      check_array_settings_with_settings
+      apply      
+    end
+    alias_method :submit, :apply_parameters
 
-    if    association == :belongs_to or association == :has_one
-      self_object_of_model1.send( "#{snake(model2.to_s)}=", self_object_of_model2 )
-      self_object_of_model1.save!
-    elsif association == :has_many   or association == :has_and_belongs_to_many
-      self_object_of_model1.method("#{model2.table_name}").call << self_object_of_model2
-      self_object_of_model1.save!
+    def save
+      Saver.new(self).save
     end
-  end
 
-  def validation_models
-    @array_of_models.each do |model|
-      set_errors( method(snake(model.to_s)).call.errors ) unless method( snake(model.to_s) ).call.valid?
+    def validation_models
+      Validator.new(self).validate_form_object
     end
-  end
 
-  def set_errors(model_errors)
-    model_errors.each do |attribute, message|
-      errors.add(attribute, message)
+    # POMOGAY
+
+    def apply
+      assign                 = Assign.new(self)
+      @hash_objects_for_save = assign.apply_parameters
+    end
+    
+    def check_array_settings_with_settings
+      define_singleton_method(:not_save_this_model) { [] } unless respond_to?(:not_validate_this_model)
+      define_singleton_method(:force_save_if_all_attr_is_nil) { [] } unless respond_to?(:force_save_if_all_attr_is_nil)
     end
-  end
 
-  def update_attributes
-    @array_of_models.each do |model|
-      model_attributes = make_attributes_of_model(model)
-      method( snake(model.to_s) ).call.assign_attributes( get_attributes_for_update(model_attributes, model) )
+    def set_errors(object_errors)
+      object_errors.each do |attribute, message|
+        errors.add(attribute, message)
+      end
     end
-  end
 
-  def update_attributes_for_collection
-    @array_of_models.each do |model|
-      assign_attributes_for_collection(model)
+    def array_all_objects_for_save
+      array_objects_for_save ||= get_or_add_default_objects
     end
-  end
 
-  def keys_of_collections
-    @keys ||= []
-    params.keys.each do |key|
-      @array_of_models.each do |model|
-        self_object_of_model = method( snake(model.to_s) ).call
-        method_name          = key.to_s[/#{snake(model.to_s)}_(.*)/, 1]
-        @keys << method_name if self_object_of_model.respond_to? method_name.to_s
-      end if key[/^.+_ids$/]
-    end if @keys.empty?
-    @keys
   end
+end
 
-  def exist_any_errors_without_collections?
-    keys_of_collections.each do |method_name|
-      @array_of_models.each do |model|
-        name_of_model          = method_name.to_s[/^(.+)_ids$/, 1]
-        name_of_constant_model = name_of_model.split('_').map(&:capitalize).join
-        name_of_key_error      = Object.const_get(name_of_constant_model).table_name
-        errors.messages.delete(name_of_key_error.to_sym)
-      end
-    end unless valid?
-    errors.messages.empty?
-  end
 
-  def assign_attributes_for_collection(model)
-    self_object_of_model = method( snake(model.to_s) ).call
 
-    keys_of_collections.each do |method_name|
-      if self_object_of_model.respond_to? method_name
-        old_attribute = self_object_of_model.method( method_name ).call
-        unless self_object_of_model.update_attributes( {method_name.to_s => params["#{snake(model.to_s)}_#{method_name}".to_sym]} )
-          set_errors(self_object_of_model.errors)
-          self_object_of_model.update_attributes( {method_name.to_s => old_attribute} )
-        end if exist_any_errors_without_collections?
-      end
-    end
-  end
 
-  def make_attributes_of_model(model)
-    model_attributes = []
-    model.column_names.each do |name|
-      model_attributes << "#{snake(model.to_s)}_#{name}"
-    end
-    model_attributes
-  end
 
-  def get_attributes_for_update(model_attributes, model)
-    update_attributes = {}
-    hash_attributes   = params.slice(*model_attributes)
-    hash_attributes.each{ |attr, val| update_attributes[attr.gsub(/#{snake(model.to_s)}_(.*)/, '\1')] = val }
-    update_attributes
-  end
 
-  def get_association(class1, class2)
-    class1.reflections.slice(snake(class2.to_s), class2.table_name).values.first&.macro
-  end
 
-end

data/lib/slim_form_object/saver.rb

@@ -0,0 +1,81 @@
+module SlimFormObject
+  class Saver
+    include ::HelperMethods
+
+    attr_reader :form_object, :params, :validator, :hash_objects_for_save
+
+    def initialize(form_object)
+      @form_object            = form_object
+      @params                 = form_object.params
+      @hash_objects_for_save  = form_object.hash_objects_for_save
+      @validator              = Validator.new(form_object)
+    end
+
+    def save
+      if form_object.valid?
+        ActiveRecord::Base.transaction do
+          save_main_objects
+          save_nested_objects
+        end
+        return true
+      end
+      false
+    rescue
+      # p "ERROR"
+      false
+    end
+
+    def save_main_objects
+      objects = Array.new(hash_objects_for_save[:objects])
+      while object_1 = objects.delete( objects[0] )
+        objects.each{ |object_2| save_objects(object_1, object_2) }
+        save_last_model_if_not_associations(object_1)
+      end
+    end
+
+    def save_nested_objects
+      hash_objects_for_save[:objects].each do |object_1|
+        next unless hash_objects_for_save[:nested_objects].include?( snake(object_1.class).to_sym )
+        hash_objects_for_save[:nested_objects][snake(object_1.class).to_sym].each do |object_2|
+          save_objects(object_1, object_2)
+        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)
+    end
+
+    def to_bind_models(object_1, object_2)
+      association = get_association(object_1.class, object_2.class)
+
+      if    association == :belongs_to or association == :has_one
+        object_1.send( "#{snake(object_2.class.to_s)}=", object_2 )
+      elsif association == :has_many   or association == :has_and_belongs_to_many
+        object_1.method("#{object_2.class.table_name}").call << object_2
+      end
+
+      object_1
+    end
+
+    def save_object(object_of_model)
+      if validator.valid_model_for_save?(object_of_model.class)
+        object_of_model.save!  
+      end
+    end
+
+    def save_last_model_if_not_associations(object_1)
+      association_trigger  = false
+      hash_objects_for_save[:objects].each { |object_2| association_trigger = true if get_association(object_1.class, object_2.class) }
+      object_1.save unless association_trigger
+    rescue
+      object_1.class.find(object_1.id).update!(object_1.attributes)
+    end
+
+    def get_association(class1, class2)
+      class1.reflections.slice(snake(class2.to_s), class2.table_name).values.first&.macro
+    end
+
+  end
+end

data/lib/slim_form_object/tmp.rb

@@ -0,0 +1,297 @@
+
+
+
+
+
+
+
+
+# require 'byebug'
+
+# module SlimFormObject
+#   class Base
+#     attr_accessor :params
+
+#     def self.init_models(*args)
+#       self.instance_eval do
+#         define_method(:array_of_single_models) { args }
+#       end
+#       add_attributes(args)
+#     end
+
+#     alias_method :init_single_models, :init_models
+
+#     def self.init_multiple_models(*args)
+#       self.instance_eval do
+#         define_method(:array_multiple_models) { args }
+#       end
+#       add_attributes(args)
+#     end
+
+#     def self.add_attributes(models)
+#       #acessors for model objects
+#       models.each{ |model| attr_accessor snake(model.to_s).to_sym }
+
+#       #delegate attributes of models
+#       models.each do |model|
+#         model.column_names.each do |attr|
+#           delegate attr.to_sym, "#{attr}=".to_sym, to:     snake(model.to_s).to_sym,
+#                                                    prefix: true
+#         end
+#       end
+#     end
+
+#     def self.set_model_name(name)
+#       define_method(:model_name) { ActiveModel::Name.new(self, nil, name) }
+#     end
+#     # def initializer
+
+#     # end
+#   end
+
+#   def self.included(base)
+#     # define_properties(base)
+
+#     base.include ActiveModel::Model
+#     base.include HelperMethods
+#     base.extend  ClassMethods
+#     base.extend  HelperMethods
+#   end
+
+#   # def self.define_properties(form_object_klass)
+#   #   class << form_object_klass
+#   #     #attr_accessor for models and env params
+#   #     # attr_accessor :params
+
+#   #     # byebug
+
+#   #     # def params=(val)
+#   #     #   @params = val
+#   #     # end
+
+#   #     # def params
+#   #     #   @params
+#   #     # end
+#   #   end
+#   # end
+
+#   # module ClassMethods
+
+#   #   def init_models(*args)
+#   #     self.instance_eval do
+#   #       define_method(:array_of_single_models) { args }
+#   #     end
+#   #     add_attributes(args)
+#   #   end
+
+#   #   alias_method :init_single_models, :init_models
+
+#   #   def init_multiple_models(*args)
+#   #     self.instance_eval do
+#   #       define_method(:array_multiple_models) { args }
+#   #     end
+#   #     add_attributes(args)
+#   #   end
+
+#   #   def add_attributes(models)
+#   #     #acessors for model objects
+#   #     models.each{ |model| attr_accessor snake(model.to_s).to_sym }
+
+#   #     #delegate attributes of models
+#   #     models.each do |model|
+#   #       model.column_names.each do |attr|
+#   #         delegate attr.to_sym, "#{attr}=".to_sym, to:     snake(model.to_s).to_sym,
+#   #                                                  prefix: true
+#   #       end
+#   #     end
+#   #   end
+
+#   #   def set_model_name(name)
+#   #     define_method(:model_name) { ActiveModel::Name.new(self, nil, name) }
+#   #   end
+#   # end
+
+#   def submit
+#     @array_of_single_models ||= array_of_single_models.reject do |model| 
+#       array_of_single_models_without_validates.include?(model) if self.respond_to?(:array_of_single_models_without_validates)
+#     end
+#     update_attributes
+#     update_attributes_for_collection
+#     self
+#   end
+
+#   alias_method :apply_parameters, :submit
+
+#   def save
+#     if valid?
+#       models = Array.new(@array_of_single_models)
+#       while model1 = models.delete( models[0] )
+#         models.each{ |model2| save_models(model1, model2) }
+#         save_last_model_if_not_associations(model1) if models.empty?
+#       end
+#       return true
+#     end
+#     false
+#   end
+
+#   def not_validate(*args)
+#     define_singleton_method(:array_of_single_models_without_validates) { args }
+#   end
+
+#   private
+
+#   def save_models(model_1, model_2)
+#     self_object_of_model_for_save = nil
+#     byebug
+#     if both_model_attributes_exist?(model_1, model_2)
+#       # byebug
+#       self_object_of_model_for_save = to_bind_models(model_1, model_2)
+#       save_model(self_object_of_model_for_save)
+#     else
+#       get_self_objects_of_model(model_1, model_2).each do |object|
+#         save_model(object)
+#       end
+#     end
+#   end
+
+#   def to_bind_models(model_1, model_2)
+#     self_object_of_model_1, self_object_of_model_2 = get_self_objects_of_model(model_1, model_2)
+#     association                                    = get_association(model_1, model_2)
+
+#     if    association == :belongs_to or association == :has_one
+#       self_object_of_model_1.send( "#{snake(model_2.to_s)}=", self_object_of_model_2 )
+#     elsif association == :has_many   or association == :has_and_belongs_to_many
+#       self_object_of_model_1.method("#{model_2.table_name}").call << self_object_of_model_2
+#     end
+
+#     self_object_of_model_1
+#   end
+
+#   def valid_model_for_save?(model)
+#     ( (attributes_is_present?(model) and method( snake(model.to_s) ).call.id != nil) or (method( snake(model.to_s) ).call.id == nil and !all_attributes_is_empty?(model)) )
+#   end
+
+#   def attributes_is_present?(model)
+#     (make_attributes_of_model(model) & params.keys).present?
+#   end
+
+#   def both_model_attributes_exist?(model_1, model_2)
+#     valid_model_for_save?(model_1) and valid_model_for_save?(model_2)
+#   end
+
+#   def save_model(self_object_of_model)
+#     if valid_model_for_save?(self_object_of_model.class)
+#       self_object_of_model.save!  
+#     end
+#   end
+
+#   def all_attributes_is_empty?(model)
+#     is_empty = true
+#     array_symbols_of_attributes = (make_attributes_of_model(model) & params.keys).map { |attr| attr.to_sym }
+#     params.slice(*array_symbols_of_attributes).values.each do |value|
+#       is_empty = false unless value == ""
+#     end
+#     is_empty
+#   end
+
+#   def get_self_objects_of_model(model_1, model_2)
+#     [ method( snake(model_1.to_s) ).call, method( snake(model_2.to_s) ).call ]
+#   end
+
+#   def save_last_model_if_not_associations(model)
+#     association_trigger  = false
+#     self_object_of_model = method( snake(model.to_s) ).call
+#     @array_of_single_models.each { |model2| association_trigger = true if get_association(model, model2) }
+#     self_object_of_model.save unless association_trigger
+#   rescue
+#     self_object_of_model.class.find(self_object_of_model.id).update!(self_object_of_model.attributes)
+#   end
+
+#   def validation_models
+#     @array_of_single_models.each do |model|
+#       next unless valid_model_for_save?(model)
+#       set_errors( method(snake(model.to_s)).call.errors ) unless method( snake(model.to_s) ).call.valid?
+#     end
+#   end
+
+#   def set_errors(model_errors)
+#     model_errors.each do |attribute, message|
+#       errors.add(attribute, message)
+#     end
+#   end
+
+#   def update_attributes
+#     @array_of_single_models.each do |model|
+#       model_attributes = make_attributes_of_model(model)
+#       method( snake(model.to_s) ).call.assign_attributes( get_attributes_for_update(model_attributes, model) )
+#     end
+#   end
+
+#   def update_attributes_for_collection
+#     @array_of_single_models.each do |model|
+#       assign_attributes_for_collection(model)
+#     end
+#   end
+
+#   def keys_of_collections
+#     @keys ||= []
+#     params.keys.each do |key|
+#       @array_of_single_models.each do |model|
+#         self_object_of_model = method( snake(model.to_s) ).call
+#         method_name          = key.to_s[/#{snake(model.to_s)}_(.*)/, 1]
+#         @keys << method_name if self_object_of_model.respond_to? method_name.to_s
+#       end if key[/^.+_ids$/]
+#     end if @keys.empty?
+#     @keys
+#   end
+
+#   def exist_any_errors_without_collections?
+#     keys_of_collections.each do |method_name|
+#       @array_of_single_models.each do |model|
+#         name_of_model          = method_name.to_s[/^(.+)_ids$/, 1]
+#         name_of_constant_model = name_of_model.split('_').map(&:capitalize).join
+#         name_of_key_error      = Object.const_get(name_of_constant_model).table_name
+#         errors.messages.delete(name_of_key_error.to_sym)
+#       end
+#     end unless valid?
+#     errors.messages.empty?
+#   end
+
+#   def assign_attributes_for_collection(model)
+#     self_object_of_model = method( snake(model.to_s) ).call
+
+#     keys_of_collections.each do |method_name|
+#       if self_object_of_model.respond_to? method_name
+#         old_attribute = self_object_of_model.method( method_name ).call
+#         unless self_object_of_model.update_attributes( {method_name.to_s => params["#{snake(model.to_s)}_#{method_name}".to_sym]} )
+#           set_errors(self_object_of_model.errors)
+#           self_object_of_model.update_attributes( {method_name.to_s => old_attribute} )
+#         end if exist_any_errors_without_collections?
+#       end
+#     end
+#   end
+
+#   def make_attributes_of_model(model)
+#     model_attributes = []
+#     model.column_names.each do |name|
+#       model_attributes << "#{snake(model.to_s)}_#{name}"
+#     end
+#     model_attributes
+#   end
+
+#   def get_attributes_for_update(model_attributes, model)
+#     attributes_for_update = {}
+#     hash_attributes   = params.slice(*model_attributes)
+#     hash_attributes.each{ |attr, val| attributes_for_update[attr.gsub(/#{snake(model.to_s)}_(.*)/, '\1')] = val }
+#     attributes_for_update
+#   end
+
+#   def get_association(class1, class2)
+#     class1.reflections.slice(snake(class2.to_s), class2.table_name).values.first&.macro
+#   end
+
+
+#   # get attributes
+#   # .gsub(/^\[|\]$|"/, '').split(', ')
+
+# end

data/lib/slim_form_object/validator.rb

@@ -0,0 +1,55 @@
+module SlimFormObject
+  class Validator
+    include ::HelperMethods
+
+    attr_reader   :form_object, :params, :hash_objects_for_save
+
+    def initialize(form_object)
+      @form_object            = form_object
+      @params                 = form_object.params
+      @hash_objects_for_save  = form_object.hash_objects_for_save
+    end
+
+    def validate_form_object
+      filter_nil_objects
+
+      hash_objects_for_save[:objects].each do |object|
+        next if all_attributes_is_nil?(object)
+        form_object.set_errors( object.errors ) unless object.valid?
+      end
+
+      hash_objects_for_save[:nested_objects].keys.each do |snake_model_name|
+        hash_objects_for_save[:nested_objects][snake_model_name].each do |object|
+          form_object.set_errors( object.errors ) unless object.valid?
+        end
+      end
+    end
+
+    def filter_nil_objects
+      hash_objects_for_save[:objects].reject! do |object|
+        all_attributes_is_nil?(object)
+      end
+    end
+
+    def valid_model_for_save?(object)
+      # ( (attributes_is_present?(object) and object.id != nil) or (object.id == nil and !all_attributes_is_empty?(object)) )
+      true
+    end
+
+    def both_model_attributes_exist?(object_1, object_2)
+      # valid_model_for_save?(object_1) and valid_model_for_save?(object_2)
+      !(all_attributes_is_nil?(object_1) and all_attributes_is_nil?(object_2))
+    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
+      end
+      true
+    end
+
+  end
+end
+
+
+

data/lib/slim_form_object/version.rb

@@ -1,3 +1,3 @@
 module SlimFormObject
-  VERSION = "0.5.23"
+  VERSION = "1.0.1"
 end

data/spec/db/migrate/001_create_model_one.rb

@@ -1,5 +1,5 @@
 
-class CreateModelOne < ActiveRecord::Migration
+class CreateModelOne < ActiveRecord::Migration[5.0]
   def self.up
     create_table :test_one_models do |t|
       t.string :title

data/spec/db/migrate/002_create_model_two.rb

@@ -1,5 +1,5 @@
 
-class CreateModelTwo < ActiveRecord::Migration
+class CreateModelTwo < ActiveRecord::Migration[5.0]
   def self.up
     create_table :test_two_models do |t|
       t.string  :title

data/spec/db/migrate/003_create_model_three.rb

@@ -1,5 +1,5 @@
 
-class CreateModelThree < ActiveRecord::Migration
+class CreateModelThree < ActiveRecord::Migration[5.0]
   def self.up
     create_table :test_three_models do |t|
       t.string  :title

data/spec/db/migrate/004_create_model_four.rb

@@ -1,5 +1,5 @@
 
-class CreateModelFour < ActiveRecord::Migration
+class CreateModelFour < ActiveRecord::Migration[5.0]
   def self.up
     create_table :test_four_models do |t|
       t.string :title

data/spec/db/migrate/005_create_model_one_four.rb

@@ -1,5 +1,5 @@
 
-class CreateModelOneFour < ActiveRecord::Migration
+class CreateModelOneFour < ActiveRecord::Migration[5.0]
   def self.up
     create_table :test_one_four_models do |t|
       t.integer :test_one_model_id

data/spec/db/migrate/006_create_model_two_three.rb

@@ -1,5 +1,5 @@
 
-class CreateModelTwoThree < ActiveRecord::Migration
+class CreateModelTwoThree < ActiveRecord::Migration[5.0]
   def self.up
     create_table :test_three_model_test_two_models do |t|
       t.integer :test_three_model_id

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: slim_form_object
 version: !ruby/object:Gem::Version
-  version: 0.5.23
+  version: 1.0.1
 platform: ruby
 authors:
 - woodcrust
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-23 00:00:00.000000000 Z
+date: 2017-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -16,14 +16,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: 5.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: 5.0.0
+- !ruby/object:Gem::Dependency
+  name: actionview
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -147,8 +161,13 @@ extra_rdoc_files: []
 files:
 - bin/slim_form_object
 - lib/slim_form_object.rb
+- lib/slim_form_object/assign.rb
+- lib/slim_form_object/form_helpers/extension_actionview.rb
 - lib/slim_form_object/helpers.rb
 - lib/slim_form_object/processing.rb
+- lib/slim_form_object/saver.rb
+- lib/slim_form_object/tmp.rb
+- lib/slim_form_object/validator.rb
 - lib/slim_form_object/version.rb
 - spec/db/database.yml
 - spec/db/database.yml.travis