form_obj 0.5.0 → 1.0.0

data/Rakefile

@@ -1,13 +1,10 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
-require "rspec/core/rake_task"
 
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
   t.libs << "lib"
   t.test_files = FileList["test/**/*_test.rb"]
 end
-RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
-# task :default => :test
+task :default => :test

data/bundle_update.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+
+set -e
+
+rubies=()
+versions=false
+while read -r line; do
+  if [[ $line == "rvm:" ]]
+  then
+    versions=true
+  elif $versions && [[ $line == -* ]]
+  then
+    rubies+=(${line:2})
+  elif [[ ${line:0:1} != "#" ]]
+  then
+    versions=false
+  fi
+done < ".travis.yml"
+
+for i in "${rubies[@]}"
+do
+  echo "====================================================="
+  echo "$i: Start appraisal update"
+  echo "====================================================="
+  rvm $i exec bundle
+  rvm $i exec appraisal update
+done

data/form_obj.gemspec

@@ -39,7 +39,6 @@ well as serialized to a hash which reflects a model. ActiveModel::Errors could b
 
   spec.add_development_dependency "bundler", "~> 1.16"
   spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "minitest", "~> 5.0"
   spec.add_development_dependency "actionpack", ">= 3.2"
   spec.add_development_dependency "appraisal"

data/lib/form_obj/form/array.rb

@@ -13,24 +13,48 @@ module FormObj
         each(&:mark_for_destruction)
       end
 
+      def marked_for_destruction
+        select(&:marked_for_destruction?)
+      end
+
       private
 
-      # items_to_add - array of hashes of new attribute values
-      # items_to_update - hash where key is the item to update and value is a hash of new attribute values
-      def items_for_destruction(items_to_add:, items_to_update:)
-        items_to_update.select { |item, attr_values| attr_values[:_destroy] }.keys
+      # Should return hash with 3 keys: :create, :update, :destroy
+      # In default implementation:
+      # :create - array of hashes of new attribute values
+      # :update - hash where key is the item to update and value is a hash of new attribute values
+      # :destroy - array of items to be destroyed
+      def define_items_for_CUD(items)
+        to_be_created = []
+        to_be_updated = {}
+        to_be_destroyed = []
+
+        items.each do |item_hash|
+          item_hash = HashWithIndifferentAccess.new(item_hash)
+          _destroy = item_hash.delete(:_destroy)
+          item = find_by_primary_key(primary_key(item_hash))
+          if item
+            if _destroy
+              to_be_destroyed << item
+            else
+              to_be_updated[item] = item_hash
+            end
+          elsif !_destroy
+            to_be_created << item_hash
+          end
+        end
+
+        { create: to_be_created, update: to_be_updated, destroy: to_be_destroyed }
+      end
+
+      # Do not do resort since update_attributes parameter may have not full list of items
+      def resort_items_after_CUD!(items)
       end
 
       # items - array of items to be destroyed
       def destroy_items(items)
         items.each(&:mark_for_destruction)
       end
-
-      # items - hash where key is the item to update and value is a hash of new attribute values
-      # params - additional params for :update_attributes method
-      def update_items(items, params)
-        items.each_pair { |item, attr_values| item.update_attributes(attr_values, params) unless attr_values.delete(:_destroy) }
-      end
     end
   end
 end

data/lib/form_obj/form.rb

@@ -74,5 +74,9 @@ module FormObj
       @persisted = false unless _get_attribute_value(attribute) === value
       super
     end
+
+    def inner_inspect
+      "#{super}#{marked_for_destruction? ? ' marked_for_destruction' : ''}"
+    end
   end
 end

data/lib/form_obj/model_mapper/array.rb

@@ -15,26 +15,28 @@ module FormObj
       end
 
       def sync_to_models(models)
-        model_array = models[:default]
-        ids_exists = []
-        items_to_add = []
+        items = define_models_for_CUD(models)
 
-        self.each do |item|
-          if model = find_model(model_array, id = item.primary_key)
-            item.sync_to_models(models.merge(default: model))
-            ids_exists << id
-          else
-            items_to_add << item
-          end
-        end
+        sync_destruction_to_models(models, items[:destroy])
+        sync_update_to_models(models, items[:update])
+        sync_creation_to_models(models, items[:create])
+      end
 
-        ids_to_remove = model_array.map { |m| model_primary_key.read_from_model(m) } - ids_exists
-        delete_models(model_array, ids_to_remove)
+      def model_primary_key
+        self.item_class.model_primary_key
+      end
 
-        items_to_add.each do |item|
-          model_array << model = model_attribute.create_model
-          item.sync_to_models(models.merge(default: model))
-        end
+      def to_models_hash(models)
+        self.each { |item| models[:default] << item.to_models_hash(models.merge(default: {}))[:default] }
+        models
+      end
+
+      private
+
+      attr_reader :model_attribute
+
+      def iterate_through_models_to_load_them(models, *args, &block)
+        models.each { |model| block.call(model) }
       end
 
       def find_model(model_array, id)
@@ -45,29 +47,46 @@ module FormObj
         end
       end
 
-      def delete_models(model_array, ids_to_delete)
-        if model_array.respond_to?(:destroy_all)
-          model_array.destroy_all(model_primary_key.name => ids_to_delete)
-        else
-          model_array.delete_if { |m| ids_to_delete.include?(model_primary_key.read_from_model(m)) }
+      # Should return hash with 3 keys: :create, :update, :destroy
+      # In default implementation:
+      # :create - array of form objects to be added
+      # :update - hash where key is a model to be updated and value is a form object
+      # :destroy - array of models to be marked for deletion
+      def define_models_for_CUD(models)
+        to_be_created = []
+        to_be_updated = {}
+        to_be_destroyed = select(&:marked_for_destruction?).map(&:primary_key)
+
+        reject(&:marked_for_destruction?).each do |form_object|
+          if model = find_model(models[:default], form_object.primary_key)
+            to_be_updated[model] = form_object
+          else
+            to_be_created << form_object
+          end
         end
-      end
 
-      def model_primary_key
-        self.item_class.model_primary_key
+        { create: to_be_created, update: to_be_updated, destroy: to_be_destroyed }
       end
 
-      def to_models_hash(models)
-        self.each { |item| models[:default] << item.to_models_hash(models.merge(default: {}))[:default] }
-        models
+      def sync_destruction_to_models(models, ids_to_destroy)
+        if models[:default].respond_to? :where
+          models[:default].where(model_primary_key.name => ids_to_destroy).each(&:mark_for_destruction)
+        else
+          models[:default].delete_if { |model| ids_to_destroy.include? model_primary_key.read_from_model(model) }
+        end
       end
 
-      private
-
-      attr_reader :model_attribute
+      def sync_update_to_models(models, items_to_update)
+        items_to_update.each_pair do |model, form_object|
+          form_object.sync_to_models(models.merge(default: model))
+        end
+      end
 
-      def iterate_through_models_to_load_them(models, *args, &block)
-        models.each { |model| block.call(model) }
+      def sync_creation_to_models(models, form_objects_to_create)
+        form_objects_to_create.each do |form_object|
+          models[:default] << model = model_attribute.create_model
+          form_object.sync_to_models(models.merge(default: model))
+        end
       end
     end
   end

data/lib/form_obj/model_mapper/attribute.rb

@@ -5,8 +5,19 @@ module FormObj
     class Attribute < FormObj::Form::Attribute
       attr_reader :model_attribute
 
-      def initialize(name, array: false, class: nil, default: nil, model_hash: false, model: :default, model_attribute: nil, model_class: nil, model_nesting: true, parent:, primary_key: nil, &block)
-        @model_attribute = ModelAttribute.new(model: model, names: model_attribute, classes: model_class, default_name: name, nesting: model_nesting, array: array, hash: model_hash, subform: binding.local_variable_get(:class) || block_given?)
+      def initialize(name, array: false, class: nil, default: nil, model_hash: false, model: :default, model_attribute: nil, model_class: nil, model_nesting: true, parent:, primary_key: nil, read_from_model: true, write_to_model: true, &block)
+        @model_attribute = ModelAttribute.new(
+            array: array,
+            classes: model_class,
+            default_name: name,
+            hash: model_hash,
+            model: model,
+            names: model_attribute,
+            nesting: model_nesting,
+            read_from_model: read_from_model,
+            subform: binding.local_variable_get(:class) || block_given?,
+            write_to_model: write_to_model,
+        )
 
         if block_given?
           new_block = Proc.new do

data/lib/form_obj/model_mapper/model_attribute/item.rb

@@ -1,4 +1,5 @@
 require 'active_support/inflector'
+require 'active_support/core_ext/object/try'
 
 module FormObj
   module ModelMapper

data/lib/form_obj/model_mapper/model_attribute.rb

@@ -6,8 +6,9 @@ module FormObj
     class ModelAttribute
       attr_reader :model
 
-      def initialize(names:, classes:, default_name:, array:, hash:, subform:, model:, nesting:)
-        @read_from_model = @write_to_model = !(names === false)
+      def initialize(array:, classes:, default_name:, hash:, model:, names:, nesting:, read_from_model:, subform:, write_to_model:)
+        @read_from_model = read_from_model && !(names === false)
+        @write_to_model = write_to_model && !(names === false)
 
         @nesting = nesting
         @model = model
@@ -18,7 +19,7 @@ module FormObj
 
         if classes.size > 0
           if (subform && (names.size != classes.size)) || (!subform && (names.size != classes.size + 1))
-            raise "Since the :model_attribute size is #{names.size} the :model_class size should be #{names.size - subform ? 0 : 1} in terms of nested items but it was #{classes.size}" unless names.size == classes.size
+            raise "Since the :model_attribute size is #{names.size} the :model_class size should be #{names.size - (subform ? 0 : 1)} in terms of nested items but it was #{classes.size}" unless names.size == classes.size
           end
         end
 

data/lib/form_obj/model_mapper.rb

@@ -25,7 +25,15 @@ module FormObj
       end
 
       def model_primary_key
-        ModelMapper::ModelPrimaryKey.new(self._attributes.find(self.primary_key).model_attribute)
+        ModelMapper::ModelPrimaryKey.new(_attributes.find(primary_key).model_attribute)
+      end
+
+      def load_from_model(*args)
+        new.load_from_model(*args)
+      end
+
+      def load_from_models(*args)
+        new.load_from_models(*args)
       end
     end
 

data/lib/form_obj/struct/array.rb

@@ -16,26 +16,14 @@ module FormObj
         self.map(&:to_hash)
       end
 
-      def update_attributes(vals, raise_if_not_found:)
-        items_to_add = []
-        items_to_update = {}
+      def update_attributes(items, raise_if_not_found:)
+        items_for_CUD = define_items_for_CUD(items)
 
-        vals.each do |val|
-          val = HashWithIndifferentAccess.new(val)
-          item = find_by_primary_key(primary_key(val))
-          if item
-            items_to_update[item] = val
-          else
-            items_to_add << val
-          end
-        end
-        items_to_destroy = items_for_destruction(items_to_add: items_to_add, items_to_update: items_to_update)
-
-        destroy_items(items_to_destroy)
-        update_items(items_to_update, raise_if_not_found: raise_if_not_found)
-        build_items(items_to_add, raise_if_not_found: raise_if_not_found)
+        destroy_items(items_for_CUD[:destroy])
+        update_items(items_for_CUD[:update], raise_if_not_found: raise_if_not_found)
+        build_items(items_for_CUD[:create], raise_if_not_found: raise_if_not_found)
 
-        sort! { |a, b| (vals.index { |val| primary_key(val) == a.primary_key } || -1) <=> (vals.index { |val| primary_key(val) == b.primary_key } || -1) }
+        resort_items_after_CUD!(items)
       end
 
       private
@@ -48,14 +36,33 @@ module FormObj
         find { |item| item.primary_key == id }
       end
 
-      def build_item(hash, raise_if_not_found:)
-        item_class.new(hash, raise_if_not_found: raise_if_not_found)
+      # Should return hash with 3 keys: :create, :update, :destroy
+      # In default implementation:
+      # :create - array of hashes of new attribute values
+      # :update - hash where key is the item to update and value is a hash of new attribute values
+      # :destroy - array of items to be destroyed
+      def define_items_for_CUD(items)
+        to_be_created = []
+        to_be_updated = {}
+
+        items.each do |item_hash|
+          item_hash = HashWithIndifferentAccess.new(item_hash)
+          item = find_by_primary_key(primary_key(item_hash))
+          if item
+            to_be_updated[item] = item_hash
+          else
+            to_be_created << item_hash
+          end
+        end
+        to_be_destroyed = self - to_be_updated.keys
+
+        { create: to_be_created, update: to_be_updated, destroy: to_be_destroyed }
       end
 
-      # items_to_add - array of hashes of new attribute values
-      # items_to_update - hash where key is the item to update and value is a hash of new attribute values
-      def items_for_destruction(items_to_add:, items_to_update:)
-        self - items_to_update.keys
+      # Resort items so they will be in the same order as in the update_attributes parameter
+      # items - hash received by update_attributes
+      def resort_items_after_CUD!(items)
+        sort! { |a, b| (items.index { |val| primary_key(val) == a.primary_key } || -1) <=> (items.index { |val| primary_key(val) == b.primary_key } || -1) }
       end
 
       # items - array of items to be destroyed
@@ -74,6 +81,10 @@ module FormObj
       def build_items(items, params)
         items.each { |item| self << build_item(item, params) }
       end
+
+      def build_item(hash, raise_if_not_found:)
+        item_class.new(hash, raise_if_not_found: raise_if_not_found)
+      end
     end
   end
 end

data/lib/form_obj/struct/attribute.rb

@@ -22,6 +22,10 @@ module FormObj
             parent.primary_key = name.to_sym
           end
         end
+
+        if @array && @nested_class._attributes.find(@nested_class.primary_key).nil?
+          raise FormObj::NonexistentPrimaryKeyError.new("#{@nested_class.inspect} has no attribute :#{@nested_class.primary_key} which is specified/defaulted as primary key")
+        end
       end
 
       def subform?
@@ -65,15 +69,15 @@ module FormObj
 
           if @nested_class
             if @array
-              raise FormObj::WrongDefaultValueClass unless value.is_a? ::Array
+              raise FormObj::WrongDefaultValueClassError unless value.is_a? ::Array
               value = create_array(value.map do |val|
                 val = create_nested(val) if val.is_a?(::Hash)
-                raise FormObj::WrongDefaultValueClass if val.class != @nested_class
+                raise FormObj::WrongDefaultValueClassError if val.class != @nested_class
                 val
               end)
             else
               value = create_nested(value) if value.is_a? ::Hash
-              raise FormObj::WrongDefaultValueClass if value.class != @nested_class
+              raise FormObj::WrongDefaultValueClassError if value.class != @nested_class
             end
           end
 

data/lib/form_obj/struct.rb

@@ -6,7 +6,8 @@ require "active_support/core_ext/hash/indifferent_access"
 
 module FormObj
   class UnknownAttributeError < RuntimeError; end
-  class WrongDefaultValueClass < RuntimeError; end
+  class WrongDefaultValueClassError < RuntimeError; end
+  class NonexistentPrimaryKeyError < NameError; end
 
   class Struct
     class_attribute :_attributes, instance_predicate: false, instance_reader: false, instance_writer: false
@@ -37,7 +38,7 @@ module FormObj
       end
 
       def attributes
-        self._attributes.map(&:name)
+        _attributes.map(&:name)
       end
 
       def inspect
@@ -72,17 +73,17 @@ module FormObj
       send("#{self.class.primary_key}=", val)
     end
 
-    def update_attributes(new_attrs, raise_if_not_found: true)
-      new_attrs = HashWithIndifferentAccess.new(new_attrs) unless new_attrs.is_a? HashWithIndifferentAccess
-      new_attrs.each_pair do |new_attr, new_val|
-        attr = self.class._attributes.find(new_attr)
+    def update_attributes(attrs, raise_if_not_found: true)
+      attrs = HashWithIndifferentAccess.new(attrs) unless attrs.is_a? HashWithIndifferentAccess
+      attrs.each_pair do |attr_name, attr_value|
+        attr = self.class._attributes.find(attr_name)
         if attr.nil?
-          raise UnknownAttributeError.new(new_attr) if raise_if_not_found
+          raise UnknownAttributeError.new(attr_name) if raise_if_not_found
         else
           if attr.subform?
-            self.send(new_attr).update_attributes(new_val, raise_if_not_found: raise_if_not_found)
+            read_attribute(attr).update_attributes(attr_value, raise_if_not_found: raise_if_not_found)
           else
-            update_attribute(attr, new_val)
+            update_attribute(attr, attr_value)
           end
         end
       end
@@ -95,11 +96,16 @@ module FormObj
     end
 
     def inspect
-      "#<#{self.class.name} #{self.class._attributes.map { |attribute| "#{attribute.name}: #{read_attribute(attribute).inspect}"}.join(', ')}>"
+      "#<#{inner_inspect}>"
     end
 
     private
 
+    def inner_inspect
+      attributes = self.class._attributes.map { |attribute| "#{attribute.name}: #{read_attribute(attribute).inspect}"}.join(', ')
+      "#{self.class.name}#{attributes.size > 0 ? " #{attributes}" : ''}"
+    end
+
     def update_attribute(attribute, new_value)
       write_attribute(attribute, new_value)
     end

data/lib/form_obj/version.rb

@@ -1,3 +1,3 @@
 module FormObj
-  VERSION = "0.5.0"
+  VERSION = "1.0.0"
 end

data/run_tests.sh

@@ -23,7 +23,6 @@ do
   echo "$i: Start Test"
   echo "====================================================="
   rvm $i exec bundle exec appraisal rake test
-  rvm $i exec bundle exec appraisal rake spec
   echo "====================================================="
   echo "$i: End Test"
   echo "====================================================="

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: form_obj
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Alexander Koltun
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-06-14 00:00:00.000000000 Z
+date: 2018-07-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: typed_array
@@ -80,20 +80,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -148,7 +134,6 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
-- ".rspec"
 - ".travis.yml"
 - Appraisals
 - CHANGELOG.md
@@ -160,6 +145,7 @@ files:
 - bin/console
 - bin/setup
 - bundle_install.sh
+- bundle_update.sh
 - form_obj.gemspec
 - gemfiles/3.2.gemfile
 - gemfiles/4.1.gemfile
@@ -206,7 +192,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: Simple but powerful form object compatible with Rails form builders.

data/.rspec

@@ -1,3 +0,0 @@
---format documentation
---color
---require spec_helper