form_obj 0.1.0 → 0.2.0

data/form_obj.gemspec

@@ -33,8 +33,9 @@ well as serialized to a hash which reflects a model. ActiveModel::Errors could b
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "typed_array", ">= 1.0.0"
-  spec.add_runtime_dependency "activemodel", ">= 3.2"
+  spec.add_dependency "tree_struct", ">= 1.0.2"
+  spec.add_dependency "activemodel", ">= 3.2"
+  spec.add_dependency "activesupport", ">= 3.2"
 
   spec.add_development_dependency "bundler", "~> 1.16"
   spec.add_development_dependency "rake", "~> 10.0"

data/lib/form_obj/array.rb

@@ -1,28 +1,13 @@
-require 'typed_array'
-
-class FormObj
-  class Array < TypedArray
-    def initialize(klass, hash: false, model_class: nil)
-      @item_hash = hash
-      @model_class = model_class
-      super(klass)
-    end
-
-    def item_hash?
-      @item_hash
-    end
-
-    def create
-      self << (item = item_class.new({}, hash: @item_hash))
-      item
-    end
+require 'tree_struct'
 
+module FormObj
+  class Array < ::TreeStruct::Array
     def update_attributes(vals)
       ids_exists = []
       items_to_add = []
 
-      vals.map(&:with_indifferent_access).each do |val|
-        id = val[item_class.primary_key]
+      vals.each do |val|
+        id = primary_key(val)
         item = self.find { |i| i.primary_key == id }
         if item
           item.update_attributes(val)
@@ -39,58 +24,13 @@ class FormObj
         self.create.update_attributes(item)
       end
 
-      sort! { |a, b| vals.index { |val| val[item_class.primary_key] == a.primary_key } <=> vals.index { |val| val[item_class.primary_key] == b.primary_key } }
+      sort! { |a, b| vals.index { |val| primary_key(val) == a.primary_key } <=> vals.index { |val| primary_key(val) == b.primary_key } }
     end
 
-    def save_to_models(models)
-      model_primary_key = self.item_class.model_primary_key
-      default_models = models[:default]
-      ids_exists = []
-      items_to_add = []
-
-      self.each do |item|
-        id = item.primary_key
-        model = if default_models.respond_to?("find_by_#{model_primary_key}")
-                  default_models.send("find_by_#{model_primary_key}", id)
-                elsif @item_hash
-                  default_models.find { |m| (m.key?(model_primary_key.to_sym) ? m[model_primary_key.to_sym] : m[model_primary_key.to_s]) == id }
-                else
-                  default_models.find { |m| m.send(model_primary_key) == id }
-                end
-        if model
-          item.save_to_models(models.merge(default: model))
-          ids_exists << id
-        else
-          items_to_add << item
-        end
-      end
-
-      ids_to_remove = if @item_hash
-                        default_models.map { |m| m.key?(model_primary_key.to_sym) ? m[model_primary_key.to_sym] : m[model_primary_key.to_s] }
-                      else
-                        default_models.map(&(model_primary_key.to_sym))
-                      end - ids_exists
-      if default_models.respond_to?(:destroy_all)
-        default_models.destroy_all(model_primary_key => ids_to_remove)
-      elsif @item_hash
-        default_models.delete_if { |m| ids_to_remove.include? (m.key?(model_primary_key.to_sym) ? m[model_primary_key.to_sym] : m[model_primary_key.to_s]) }
-      else
-        default_models.delete_if { |m| ids_to_remove.include? m.send(model_primary_key) }
-      end
-
-      items_to_add.each do |item|
-        default_models << model = (@model_class.is_a?(String) ? @model_class.constantize : @model_class).new
-        item.save_to_models(models.merge(default: model))
-      end
-    end
-
-    def to_hash
-      self.map(&:to_hash)
-    end
+    private
 
-    def export_to_model_hash(models)
-      self.each { |item| models[:default] << item.export_to_model_hash(models.merge(default: {}))[:default] }
-      models
+    def primary_key(hash)
+      hash.key?(item_class.primary_key.to_sym) ? hash[item_class.primary_key.to_sym] : hash[item_class.primary_key.to_s]
     end
   end
 end

data/lib/form_obj/attribute.rb

@@ -1,25 +1,19 @@
-class FormObj
-  class Attribute
-    attr_reader :name, :subform, :model, :model_attributes, :model_class
+require 'tree_struct'
 
-    def initialize(name, subform = false, model: :default, model_attribute: nil, model_class: nil, hash: false, array: false)
-      @subform = subform
-      @array = array
-      @hash = hash
+module FormObj
+  class Attribute < ::TreeStruct::Attribute
+    def initialize(name, array: false, class: nil, default: nil, parent:, primary_key: nil, &block)
+      super(name, array: array, class: binding.local_variable_get(:class), default: default, parent: parent, &block)
 
-      @model_attributes = model_attribute === false ? [] : (model_attribute || name).to_s.split('.')
-      @name = name.to_s.start_with?(':') ? name.to_s[1..-1] : name.to_s
+      @nested_class.instance_variable_set(:@model_name, ActiveModel::Name.new(@nested_class, nil, name.to_s)) if !@nested_class && block_given?
 
-      @model = model
-      @model_class = model_class.is_a?(Enumerable) ? model_class : [model_class || (hash ? Hash : name.to_s.camelize)]
-    end
-
-    def hash?
-      @hash
-    end
-
-    def array?
-      @array
+      if primary_key
+        if @nested_class
+          @nested_class.primary_key = primary_key
+        else
+          parent.primary_key = name.to_sym
+        end
+      end
     end
   end
 end

data/lib/form_obj/attributes.rb

@@ -0,0 +1,13 @@
+require 'tree_struct'
+
+module FormObj
+  class Attributes < ::TreeStruct::Attributes
+    def find(name)
+      @items.find { |item| item.name == name.to_sym }
+    end
+
+    def each(&block)
+      @items.each(&block)
+    end
+  end
+end

data/lib/form_obj/form.rb

@@ -0,0 +1,92 @@
+require 'tree_struct'
+require 'form_obj/attributes'
+require 'form_obj/attribute'
+require 'form_obj/array'
+require 'active_model'
+
+module FormObj
+  class UnknownAttributeError < RuntimeError; end
+
+  class Form < ::TreeStruct
+    extend ::ActiveModel::Naming
+    extend ::ActiveModel::Translation
+
+    include ::ActiveModel::Conversion
+    include ::ActiveModel::Validations
+
+    private
+    self._attributes = Attributes.new
+
+    public
+
+    def self.array_class
+      Array
+    end
+
+    def self.nested_class
+      ::TreeStruct
+    end
+
+    def self.attribute_class
+      Attribute
+    end
+
+    attr_accessor :persisted
+    attr_reader :errors
+
+    class_attribute :primary_key, instance_predicate: false, instance_reader: false, instance_writer: false
+    self.primary_key = :id
+
+    def self.nested_class
+      ::FormObj::Form
+    end
+
+    def self.model_name
+      @model_name || super
+    end
+
+    def initialize()
+      @errors = ActiveModel::Errors.new(self)
+      @persisted = false
+    end
+
+    def persisted?
+      @persisted
+    end
+
+    def _set_attribute_value(attribute, value)
+      @persisted = false
+      super
+    end
+
+    def primary_key
+      send(self.class.primary_key)
+    end
+
+    def primary_key=(val)
+      send("#{self.class.primary_key}=", val)
+    end
+
+    def update_attributes(new_attrs, raise_if_not_found: true)
+      new_attrs.each_pair do |new_attr, new_val|
+        attr = self.class._attributes.find(new_attr)
+        if attr.nil?
+          raise UnknownAttributeError.new(new_attr) if raise_if_not_found
+        else
+          if attr.subform?
+            self.send(new_attr).update_attributes(new_val)
+          else
+            self.send("#{new_attr}=", new_val)
+          end
+        end
+      end
+
+      self
+    end
+
+    def saved
+      @persisted = true
+      self
+    end
+  end
+end

data/lib/form_obj/mappable/array.rb

@@ -0,0 +1,66 @@
+module FormObj
+  module Mappable
+    class Array < FormObj::Array
+      def initialize(item_class, model_attribute:)
+        @model_attribute = model_attribute
+        super(item_class)
+      end
+
+      def load_from_models(models)
+        clear
+        (models[:default] || []).each do |model|
+          create.load_from_models(models.merge(default: model))
+        end
+        self
+      end
+
+      def save_to_models(models)
+        model_array = models[:default]
+        ids_exists = []
+        items_to_add = []
+
+        self.each do |item|
+          if model = find_model(model_array, id = item.primary_key)
+            item.save_to_models(models.merge(default: model))
+            ids_exists << id
+          else
+            items_to_add << item
+          end
+        end
+
+        ids_to_remove = model_array.map { |m| model_primary_key.read_from_model(m) } - ids_exists
+        delete_models(model_array, ids_to_remove)
+
+        items_to_add.each do |item|
+          model_array << model = @model_attribute.create_model # || model_array.create_model
+          item.save_to_models(models.merge(default: model))
+        end
+      end
+
+      def find_model(model_array, id)
+        if model_array.respond_to?("find_by_#{model_primary_key.name}")
+          model_array.send("find_by_#{model_primary_key.name}", id)
+        else
+          model_array.find { |m| model_primary_key.read_from_model(m) == id }
+        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)) }
+        end
+      end
+
+      def model_primary_key
+        self.item_class.model_primary_key
+      end
+
+      def to_models_hash(models)
+        self.each { |item| models[:default] << item.to_models_hash(models.merge(default: {}))[:default] }
+        models
+      end
+    end
+  end
+end

data/lib/form_obj/mappable/attribute.rb

@@ -0,0 +1,35 @@
+require 'form_obj/mappable/model_attribute'
+
+module FormObj
+  module Mappable
+    class Attribute < FormObj::Attribute
+      attr_reader :model_attribute
+
+      def initialize(name, array: false, class: nil, default: nil, hash: false, model: :default, model_attribute: nil, model_class: nil, parent:, primary_key: nil, &block)
+        @hash = hash
+        @model_attribute = ModelAttribute.new(model: model, names: model_attribute, classes: model_class, default_name: name, array: array, hash: hash, subform: binding.local_variable_get(:class) || block_given?)
+
+        if block_given?
+          new_block = Proc.new do
+            include FormObj::Mappable
+            class_eval &block
+          end
+        end
+        super(name, array: array, class: binding.local_variable_get(:class), default: default, parent: parent, primary_key: primary_key, &new_block)
+
+        @nested_class = Class.new(@nested_class) if binding.local_variable_get(:class)
+        @nested_class.hash = hash if @nested_class
+      end
+
+      def array?
+        @array
+      end
+
+      private
+
+      def create_array
+        @parent.array_class.new(@nested_class, model_attribute: @model_attribute)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+require 'active_support/inflector'
+
+module FormObj
+  module Mappable
+    class ModelAttribute
+      private
+
+      class Item
+        attr_accessor :hash
+        attr_reader :hash_item, :name
+
+        def initialize(name:, klass:, hash:, array:)
+          @array = array
+          @hash = hash
+          @hash_item = name[0] == ':'
+          @name = (name[0] == ':' ? name[1..-1] : name).to_sym
+          @klass = klass || @name.to_s.classify
+        end
+
+        def hash_item=(value)
+          @hash_item ||= value
+        end
+
+        def create_model
+          if @hash
+            {}
+          else
+            (@klass.is_a?(String) ? @klass.constantize : @klass).try(:new)
+          end
+        end
+
+        def create_array
+          []
+        end
+
+        def read_from_model(model, create_nested_model_if_nil: false)
+          return nil if model.nil?
+
+          result = if @hash_item
+                     model[hash_attribute_name(model, @name)]
+                   else
+                     model.send(@name)
+                   end
+
+          if result.nil? && create_nested_model_if_nil
+            result = @array ? create_array : create_model
+            write_to_model(model, result)
+          end
+
+          result
+        end
+
+        def write_to_model(model, value)
+          if @hash_item
+            model[hash_attribute_name(model, @name)] = value
+          else
+            model.send("#{@name}=", value)
+          end
+        end
+
+        def to_hash(value)
+          { @name => value }
+        end
+
+        def read_errors_from_model(model)
+          @hash_item ? [] : model.errors[@name]
+        end
+
+        private
+
+        def hash_attribute_name(model, name)
+          model.key?(name.to_s) && !model.key?(name.to_sym) ? name.to_s : name.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/form_obj/mappable/model_attribute.rb

@@ -0,0 +1,93 @@
+require 'active_support/inflector'
+require 'form_obj/mappable/model_attribute/item'
+
+module FormObj
+  module Mappable
+    class ModelAttribute
+      attr_reader :model
+
+      def initialize(names:, classes:, default_name:, array:, hash:, subform:, model:)
+        @read_from_model = @write_to_model = !(names === false)
+
+        @model = model
+        @array = array
+
+        names = (names || default_name).to_s.split('.') unless names.is_a? ::Enumerable
+        classes = classes.nil? ? [] : [classes] unless classes.is_a? ::Enumerable
+
+        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
+          end
+        end
+
+        @items = names.zip(classes, [hash], names[0..-2].map{nil} + [array]).map { |item| Item.new(name: item[0], klass: item[1], hash: item[2], array: item[3]) }
+
+        @items.inject do |prev, item|
+          prev.hash = true if item.hash_item
+          item
+        end
+      end
+
+      def last_name
+        @items.last.name
+      end
+
+      def hash_item=(value)
+        @items[0].hash_item = value
+      end
+
+      def create_model
+        raise 'Creation available only for array attributes' unless @array
+        @items.last.create_model
+      end
+
+      def read_from_model?
+        @read_from_model
+      end
+
+      def read_from_model(model, create_nested_model_if_nil: false)
+        @items.reduce(model) { |last_model, item| item.read_from_model(last_model, create_nested_model_if_nil: create_nested_model_if_nil) }
+      end
+
+      def read_from_models(models, create_nested_model_if_nil: false)
+        read_from_model(models[@model], create_nested_model_if_nil: create_nested_model_if_nil)
+      end
+
+      def write_to_model?
+        @write_to_model
+      end
+
+      def write_to_model(model, value)
+        model = @items[0..-2].reduce(model) { |last_model, item| item.read_from_model(last_model, create_nested_model_if_nil: true) } if @items.size > 1
+        @items.last.write_to_model(model, value)
+      end
+
+      def write_to_models(models, value)
+        write_to_model(models[@model], value)
+      end
+
+      def validate_primary_key!
+        if @items.size > 1
+          raise PrimaryKeyMappingError.new('Primary key should not be mapped to nested model')
+        elsif @items.size == 0
+          raise PrimaryKeyMappingError.new('Primary key should not be mapped to non-mapped attribute')
+        end
+      end
+
+      def to_model_hash(value)
+        @items.reverse.reduce(value) { |value, item| item.to_hash(value) }
+      end
+
+      def read_errors_from_model(model)
+        @items.last.try(:read_errors_from_model,
+                        @items[0..-2].reduce(model) { |last_model, item| item.read_from_model(last_model, create_nested_model_if_nil: false) }
+        )
+      end
+
+      def read_errors_from_models(models)
+        read_errors_from_model(models[@model])
+      end
+    end
+  end
+end

data/lib/form_obj/mappable/model_primary_key.rb

@@ -0,0 +1,17 @@
+module FormObj
+  module Mappable
+    class ModelPrimaryKey
+      def initialize(model_attribute)
+        @model_attribute = model_attribute
+      end
+
+      def name
+        @model_attribute.last_name
+      end
+
+      def read_from_model(model)
+        @model_attribute.read_from_model(model, create_nested_model_if_nil: false)
+      end
+    end
+  end
+end

data/lib/form_obj/mappable.rb

@@ -0,0 +1,124 @@
+require 'form_obj/mappable/attribute'
+require 'form_obj/mappable/array'
+require 'form_obj/mappable/model_primary_key'
+
+module FormObj
+  module Mappable
+    class PrimaryKeyMappingError < RuntimeError; end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def attribute_class
+        Mappable::Attribute
+      end
+
+      def array_class
+        Mappable::Array
+      end
+
+      def hash=(value)
+        _attributes.each { |attribute| attribute.model_attribute.hash_item = value }
+      end
+
+      def model_primary_key
+        Mappable::ModelPrimaryKey.new(self._attributes.find(self.primary_key).model_attribute)
+      end
+    end
+
+    def load_from_model(model)
+      load_from_models(default: model)
+    end
+
+    def load_from_models(models)
+      self.class._attributes.each { |attribute| load_attribute_from_model(attribute, models) }
+      self.persisted = true
+      self
+    end
+
+    def save_to_model(model)
+      save_to_models(default: model)
+    end
+
+    def save_to_models(models)
+      self.class._attributes.each { |attribute | save_attribute_to_model(attribute, models) }
+      self.persisted = true
+      self
+    end
+
+    def primary_key=(val)
+      self.class._attributes.find(self.class.primary_key).validate_primary_key!
+      super
+    end
+
+    def to_model_hash(model = :default)
+      to_models_hash[model]
+    end
+
+    def to_models_hash(models = {})
+      self.class._attributes.each do |attribute|
+        val = if attribute.subform?
+                if attribute.array?
+                  []
+                else
+                  attribute.model_attribute.write_to_model? ? {} : (models[attribute.model_attribute.model] ||= {})
+                end
+              else
+                send(attribute.name)
+              end
+
+        value = if attribute.subform? && !attribute.model_attribute.write_to_model?
+                  attribute.array? ? { self: val } : {}
+                elsif attribute.subform? || attribute.model_attribute.write_to_model?
+                  attribute.model_attribute.to_model_hash(val)
+                end
+
+        (models[attribute.model_attribute.model] ||= {}).merge!(value) if attribute.subform? || attribute.model_attribute.write_to_model?
+        send(attribute.name).to_models_hash(models.merge(default: val)) if attribute.subform?
+      end
+      models
+    end
+
+    def copy_errors_from_model(model)
+      copy_errors_from_models(default: model)
+    end
+
+    def copy_errors_from_models(models)
+      self.class._attributes.each do |attribute|
+        if attribute.subform?
+        elsif attribute.model_attribute.write_to_model? # Use :write_to_model? instead of :read_to_model? because validation errors appears after writing to model
+          @errors[attribute.name].push(*attribute.model_attribute.read_errors_from_models(models))
+        end
+      end
+      self
+    end
+
+    private
+
+    def load_attribute_from_model(attribute, models)
+      if attribute.subform?
+        if attribute.model_attribute.read_from_model?
+          self.send(attribute.name).load_from_models(models.merge(default: attribute.model_attribute.read_from_models(models)))
+        else
+          self.send(attribute.name).load_from_models(models.merge(default: models[attribute.model_attribute.model]))
+        end
+      elsif attribute.model_attribute.read_from_model?
+        self.send("#{attribute.name}=", attribute.model_attribute.read_from_models(models))
+      end
+    end
+
+    def save_attribute_to_model(attribute, models)
+      if attribute.subform?
+        if attribute.model_attribute.write_to_model?
+          self.send(attribute.name).save_to_models(models.merge(default: attribute.model_attribute.read_from_models(models, create_nested_model_if_nil: true)))
+        else
+          self.send(attribute.name).save_to_models(models.merge(default: models[attribute.model_attribute.model]))
+        end
+      elsif attribute.model_attribute.write_to_model?
+        attribute.model_attribute.write_to_models(models, self.send(attribute.name))
+      end
+    end
+  end
+end

data/lib/form_obj/version.rb

@@ -1,3 +1,3 @@
-class FormObj
-  VERSION = "0.1.0"
+module FormObj
+  VERSION = "0.2.0"
 end