object_attorney 2.10.12 → 3.0.0

data/lib/object_attorney/association_reflection.rb

@@ -1,72 +0,0 @@
-module ObjectAttorney
-
-  class AssociationReflection < Reflection
-    attr_reader :related_reflection, :macro
-
-    def initialize(association, related_reflection, options)
-      super(association, options)
-      @macro = options[:macro] || macro_default(association)
-      @related_reflection = related_reflection
-    end
-
-    def primary_key
-      @primary_key ||= options[:primary_key] || :id
-    end
-
-    def foreign_key
-      @foreign_key ||= options[:foreign_key] || foreign_key_default
-    end
-
-    def set_relational_keys(origin, destination)
-      return nil if options[:standalone] == true
-      
-      if has_many? || has_one?
-        set_foreign_key(destination, primary_key_of(origin))
-      elsif belongs_to?
-        set_foreign_key(origin, primary_key_of(destination))
-      end
-    end
-
-    def set_foreign_key(object, id)
-      setter = "#{foreign_key}="
-      
-      if object.respond_to?(setter)
-        object.send(setter, id)
-      elsif object.respond_to?("send_to_representative")
-        object.send_to_representative(setter, id)
-      end
-    end
-
-    def primary_key_of(object)
-      object.send(primary_key)
-    end
-
-    def has_many?
-      macro == :has_many
-    end
-
-    def has_one?
-      macro == :has_one
-    end
-
-    def belongs_to?
-      macro == :belongs_to
-    end
-
-    private ################################# private
-
-    def macro_default(association)
-      Helpers.plural?(association) ? :has_many : :belongs_to
-    end
-
-    def foreign_key_default
-      if has_many? || has_one?
-        "#{related_reflection.single_name}_id"
-      elsif belongs_to?
-        "#{single_name}_id"
-      end.to_sym
-    end
-
-  end
-
-end

data/lib/object_attorney/attribute_assignment.rb

@@ -1,69 +0,0 @@
-module ObjectAttorney
-
-  module AttributeAssignment
-
-    def assign_attributes(attributes = {})
-      return if attributes.blank?
-
-      attributes.each do |name, value|
-        name, value = check_for_hidden_nested_attributes(name, value)
-        send("#{name}=", value) if allowed_attribute(name)
-      end
-
-      mark_for_destruction_if_necessary(self, attributes)
-    end
-
-    protected #################### PROTECTED METHODS DOWN BELOW ######################
-
-    def check_for_hidden_nested_attributes(name, value)
-      name_sym = name.to_sym
-
-      reflection = self.class.reflect_on_association(name_sym)
-
-      if reflection
-        if reflection.has_many? && value.is_a?(Array)
-          hash = {}
-          value.each_with_index do |_value, index|
-            hash[index.to_s] = _value
-          end
-          value = hash
-        end
-        name = "#{name}_attributes"
-      end
-
-      [name, value]
-    end
-
-    def parsing_arguments(attributes, object)
-      if !attributes.is_a?(Hash) && object.blank?
-        object = attributes
-        attributes = nil
-      end
-
-      attributes = {} if attributes.blank?
-
-      [attributes.symbolize_keys, object]
-    end
-
-    def allowed_attribute(attribute)
-      respond_to?("#{attribute}=")
-    end
-
-    def attributes_without_destroy(attributes)
-      return nil unless attributes.is_a?(Hash)
-
-      _attributes = attributes.dup
-      _attributes.delete("_destroy")
-      _attributes.delete(:_destroy)
-
-      _attributes.symbolize_keys
-    end
-
-    def attributes_order_destruction?(attributes)
-      _destroy = attributes["_destroy"] || attributes[:_destroy]
-      ["true", "1", true].include?(_destroy)
-    end
-
-  end
-
-end

data/lib/object_attorney/delegation.rb

@@ -1,48 +0,0 @@
-module ObjectAttorney
-
-  module Delegation
-
-    module MissingMethods
-
-      def method_missing(method, *args, &block)
-        represented_object.send(method, *args, &block)
-      end
-
-    end
-
-    def zuper_method(method_name, *args)
-      self.superclass.send(method_name, *args) if self.superclass.respond_to?(method_name)
-    end
-
-    def properties(*_properties)
-      _properties.each { |property| delegate_property(property) }
-    end
-
-    def getters(*_getters)
-      _getters.each { |getter| delegate_getter(getter) }
-    end
-
-    def setters(*_setters)
-      _setters.each { |getter| delegate_setter(getter) }
-    end
-
-    
-    protected ##################### PROTECTED #####################
-
-    def delegate_property(property)
-      delegate_getter(property)
-      delegate_setter(property)
-    end
-
-    def delegate_getter(getter)
-      delegate getter, to: :represented_object
-      add_attribute_key getter
-    end
-
-    def delegate_setter(setter)
-      delegate "#{setter}=", to: :represented_object
-    end
-
-  end
-
-end

data/lib/object_attorney/naming.rb

@@ -1,16 +0,0 @@
-module ObjectAttorney
-
-  module Naming
-
-    def model_name
-      @_model_name ||= begin
-        namespace = self.parents.detect do |n|
-          n.respond_to?(:use_relative_model_naming?) && n.use_relative_model_naming?
-        end
-        ActiveModel::Name.new(represented_object_class || self, namespace)
-      end
-    end
-
-  end
-
-end

data/lib/object_attorney/nested_objects.rb

@@ -1,311 +0,0 @@
-require "object_attorney/association_reflection"
-
-module ObjectAttorney
-  module NestedObjects
-
-    def initialize_nested_attributes
-      self.class.reflect_on_all_associations.each do |reflection|
-        self.instance_variable_set("@#{reflection.name}_attributes", {})
-      end
-    end
-
-    def mark_for_destruction
-      represented_object.respond_to?(:mark_for_destruction) && represented_object.mark_for_destruction
-
-      @marked_for_destruction = true
-    end
-
-    def marked_for_destruction?
-      if represented_object.respond_to?(:marked_for_destruction?) && represented_object.marked_for_destruction?
-        @marked_for_destruction = true
-      end
-
-      @marked_for_destruction
-    end
-
-    def mark_for_destruction_if_necessary(object, attributes)
-      return nil unless attributes.is_a?(Hash)
-
-      object.mark_for_destruction if attributes_order_destruction? attributes
-    end
-
-    def nested_objects(macro = nil)
-      nested_objects_list = []
-
-      self.class.reflect_on_all_associations(macro).each do |reflection|
-        [*self.send(reflection.name)].each do |nested_object|
-          nested_objects_list << [reflection, nested_object]
-        end
-      end
-
-      nested_objects_list
-    end
-
-    def reset_nested_objects(reflection_name = nil)
-      self.class.reflect_on_all_associations.each do |reflection|
-        next if !reflection_name.nil? && reflection_name != reflection.name
-
-        self.instance_variable_set("@#{reflection.name}_attributes", {})
-        self.instance_variable_set("@#{reflection.name}", nil)
-      end
-    end
-
-    protected #################### PROTECTED METHODS DOWN BELOW ######################
-
-    def save_or_destroy_nested_objects(save_method, association_macro)
-      nested_objects(association_macro).map do |reflection, nested_object|
-
-        populate_foreign_key(self, nested_object, reflection, :has_many)
-        populate_foreign_key(self, nested_object, reflection, :has_one)
-
-        saving_result = call_save_or_destroy(nested_object, save_method)
-
-        populate_foreign_key(self, nested_object, reflection, :belongs_to)
-
-        saving_result
-
-      end.all?
-    end
-
-    def validate_nested_objects
-      nested_objects.map { |reflection, nested_object| nested_object.valid? }.all?
-    end
-
-    def import_nested_objects_errors
-      nested_objects.each do |reflection, nested_object|
-        nested_object.errors.full_messages.each { |message| self.errors.add(reflection.name, message) }
-      end
-    end
-
-    def get_attributes_for_existing(nested_object_name, existing_nested_object)
-      attributes = send("#{nested_object_name}_attributes")
-
-      if attributes.present?
-        (attributes.values.select { |x| x[:id].to_i == existing_nested_object.id }.first || {}).symbolize_keys
-      else
-        {}
-      end
-    end
-
-    private #################### PRIVATE METHODS DOWN BELOW ######################
-
-    def populate_foreign_key(origin, destination, reflection, macro)
-      return nil if represented_object.blank? || Helpers.marked_for_destruction?(destination) || reflection.macro != macro
-
-      reflection.set_relational_keys(origin, destination)
-    end
-
-    def self.included(base)
-      base.extend(ClassMethods)
-
-      base.class_eval do
-        validate :validate_nested_objects
-      end
-    end
-
-    def nested_getter(nested_object_name)
-      nested_instance_variable = self.instance_variable_get("@#{nested_object_name}")
-
-      if nested_instance_variable.nil?
-        reflection = self.class.reflect_on_association(nested_object_name)
-
-        nested_instance_variable = reflection.has_many? ? get_existing_and_new_nested_objects(nested_object_name) : get_existing_or_new_nested_object(nested_object_name)
-
-        [*nested_instance_variable].each do |nested_object|
-          nested_object.extend(Validations) unless nested_object.respond_to?(:represented_object)
-        end
-
-        self.instance_variable_set("@#{nested_object_name}", nested_instance_variable)
-      end
-
-      nested_instance_variable
-    end
-
-    def get_existing_or_new_nested_object(nested_object_name)
-      nested_object = send("existing_#{nested_object_name}")
-      attributes = send("#{nested_object_name}_attributes")
-
-      if nested_object.present?
-        #return nested_object if (attributes["id"] || attributes[:id]).to_s != nested_object.id.to_s
-
-        nested_object.assign_attributes(attributes_without_destroy(attributes))
-        mark_for_destruction_if_necessary(nested_object, attributes)
-      elsif attributes.keys.present? && !attributes_order_destruction?(attributes)
-        nested_object = send("build_#{Helpers.singularize(nested_object_name)}", attributes_without_destroy(attributes))
-        mark_for_destruction_if_necessary(nested_object, attributes)
-      end
-
-      nested_object
-    end
-
-    def get_existing_and_new_nested_objects(nested_object_name)
-      existing_and_new_nested_objects = []
-
-      update_existing_nested_objects(existing_and_new_nested_objects, nested_object_name)
-      build_new_nested_objects(existing_and_new_nested_objects, nested_object_name)
-
-      existing_and_new_nested_objects
-    end
-
-    def update_existing_nested_objects(existing_and_new_nested_objects, nested_object_name)
-      send("existing_#{nested_object_name}").each do |existing_nested_object|
-        attributes = get_attributes_for_existing(nested_object_name, existing_nested_object)
-
-        mark_for_destruction_if_necessary(existing_nested_object, attributes)
-        existing_nested_object.assign_attributes(attributes_without_destroy(attributes))
-
-        existing_and_new_nested_objects << existing_nested_object
-      end
-    end
-
-    def build_new_nested_objects(existing_and_new_nested_objects, nested_object_name)
-      (send("#{nested_object_name}_attributes") || {}).values.each do |attributes|
-        next if attributes["id"].present? || attributes[:id].present? || attributes_order_destruction?(attributes)
-
-        new_nested_object = send("build_#{Helpers.singularize(nested_object_name)}", attributes_without_destroy(attributes))
-        next unless new_nested_object
-
-        mark_for_destruction_if_necessary(new_nested_object, attributes)
-        existing_and_new_nested_objects << new_nested_object
-      end
-    end
-
-    def build_nested_object(nested_object_name, attributes = {}, new_nested_object = nil)
-      attributes = attributes.symbolize_keys
-      reflection = self.class.reflect_on_association(nested_object_name)
-
-      return nil if reflection.options[:new_records] == false
-
-      if new_nested_object.present?
-        new_nested_object = assign_attributes_or_build_nested_object(reflection, attributes, new_nested_object)
-
-      elsif reflection.options[:standalone] == true || !can_represented_object_build_nested?(reflection, nested_object_name)
-        new_nested_object = reflection.klass.new(attributes)
-
-      else
-        new_nested_object = build_from_represented_object(reflection, nested_object_name)
-
-        new_nested_object = assign_attributes_or_build_nested_object(reflection, attributes, new_nested_object)
-      end
-
-      populate_foreign_key(self, new_nested_object, reflection, :has_many)
-      new_nested_object.extend(Validations) unless new_nested_object.respond_to?(:represented_object)
-
-      new_nested_object
-    end
-
-    def assign_attributes_or_build_nested_object(reflection, attributes, new_nested_object)
-      real_reflection_class = self.class.represented_object_reflect_on_association(reflection.name).try(:klass)
-
-      if reflection.klass == real_reflection_class
-        new_nested_object.assign_attributes(attributes)
-        new_nested_object
-      else
-        reflection.klass.respond_to?(:represents) ? reflection.klass.new(attributes, new_nested_object) : reflection.klass.new(attributes)
-      end
-    end
-
-    def can_represented_object_build_nested?(reflection, nested_object_name)
-      return false if represented_object.blank?
-
-      represented_object.respond_to?("build_#{nested_object_name}") || represented_object.send(nested_object_name).respond_to?(:build)
-    end
-
-    def build_from_represented_object(reflection, nested_object_name)
-      build_method = "build_#{nested_object_name}"
-
-      if represented_object.respond_to?(build_method)
-        represented_object.send(build_method)
-      else
-        represented_object.send(nested_object_name).build
-      end
-    end
-
-    def existing_nested_objects(nested_object_name)
-      nested_relection = self.class.reflect_on_association(nested_object_name)
-
-      return [] if nested_relection.options[:existing_records] == false
-
-      if nested_relection.options[:standalone] == true
-        return nested_relection.has_many? ? (nested_relection.klass.try(:all) || []) : nil
-      end
-
-      existing = represented_object.nil? ? (nested_relection.klass.try(:all) || []) : (represented_object.send(nested_object_name) || (nested_relection.has_many? ? [] : nil))
-
-      if represented_object.present?
-        if self.class.represented_object_class.respond_to?(:reflect_on_association)
-          existing = _existing_in_form_objects(existing, nested_relection) if nested_relection.klass != self.class.represented_object_class.reflect_on_association(nested_object_name).try(:klass)
-        else
-          existing = _existing_in_form_objects(existing, nested_relection)
-        end
-      end
-
-      existing
-    end
-
-    def _existing_in_form_objects(existing, nested_relection)
-      if existing.respond_to?(:map)
-        existing.map { |existing_nested_object| nested_relection.klass.new({}, existing_nested_object) }
-      elsif existing.present?
-        nested_relection.klass.new({}, existing)
-      else
-        nil
-      end
-    end
-
-    module ClassMethods
-
-      def has_many(nested_object_name, options = {})
-        accepts_nested_objects_overwrite_macro(nested_object_name, options, :has_many)
-      end
-
-      def has_one(nested_object_name, options = {})
-        accepts_nested_objects_overwrite_macro(nested_object_name, options, :has_one)
-      end
-
-      def belongs_to(nested_object_name, options = {})
-        accepts_nested_objects_overwrite_macro(nested_object_name, options, :belongs_to)
-      end
-
-      def accepts_nested_objects(nested_object_name, options = {})
-        options.symbolize_keys!
-        reflection = AssociationReflection.new(nested_object_name, represented_object_reflection, options)
-
-        self.instance_variable_set("@#{nested_object_name}_reflection", reflection)
-        self.instance_variable_set("@association_reflections", association_reflections.merge(nested_object_name => reflection))
-
-        self.send(:attr_accessor, "#{nested_object_name}_attributes".to_sym)
-
-        define_method(nested_object_name) { nested_getter(nested_object_name) }
-        define_method("build_#{reflection.single_name}") { |attributes = {}, nested_object = nil| build_nested_object(nested_object_name, attributes, nested_object) }
-        define_method("existing_#{nested_object_name}") { existing_nested_objects(nested_object_name) }
-      end
-
-      def association_reflections
-        self.instance_variable_get("@association_reflections") || zuper_method('association_reflections') || {}
-      end
-
-      def reflect_on_association(association)
-        self.instance_variable_get("@#{association}_reflection") || zuper_method('reflect_on_association', association)
-      end
-
-      def reflect_on_all_associations(macro = nil)
-        macro ? association_reflections.values.select { |reflection| reflection.macro == macro } : association_reflections.values
-      end
-
-      def reflections
-        association_reflections
-      end
-
-      private ############################### PRIVATE METHODS ###########################
-
-      def accepts_nested_objects_overwrite_macro(nested_object_name, options, macro)
-        default_options = { macro: macro }
-        options = options.is_a?(Hash) ? options.merge(default_options) : default_options
-        accepts_nested_objects(nested_object_name, options)
-      end
-
-    end
-
-  end
-end