object_attorney 2.10.12 → 3.0.0

data/lib/object_attorney/orm_handlers/smooth_operator.rb

@@ -1,69 +0,0 @@
-module ObjectAttorney
-  module OrmHandlers
-
-    module SmoothOperator
-
-      def save(options = {})
-        save_or_! { submit(options) }
-      end
-
-      def save!(options = {})
-        save_or_! { submit!(options) }
-      end
-
-      def submit(options = {})
-        submit_or_!(:save, options)
-      end
-
-      def submit!(options = {})
-        submit_or_!(:save!, options)
-      end
-
-      def destroy(options = {})
-        return true if represented_object.blank?
-        represented_object.destroy(options).ok?
-      end
-
-      def call_save_or_destroy(object, save_method, options = {})
-        if object == self || object == represented_object
-          represented_object.present? ? represented_object.send(save_method, options).ok? : true
-        else
-          save_method = :destroy if Helpers.marked_for_destruction?(object)
-          object.send(save_method, options).ok?
-        end
-      end
-
-      protected #################### PROTECTED METHODS DOWN BELOW ######################
-
-      def submit_or_!(save_method, options = {})
-        save_result = save_or_destroy_nested_objects(save_method, :belongs_to, options)
-        save_result = save_or_destroy_represented_object(save_method, options) if save_result
-        save_result = save_or_destroy_nested_objects(save_method, :has_many, options) if save_result
-        save_result = save_or_destroy_nested_objects(save_method, :has_one, options) if save_result
-        save_result
-      end
-
-      def save_or_destroy_represented_object(save_method, options = {})
-        return true if represented_object.blank?
-        call_save_or_destroy(represented_object, save_method, options)
-      end
-      
-      def save_or_destroy_nested_objects(save_method, association_macro, options = {})
-        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, options)
-
-          populate_foreign_key(nested_object, self, reflection, :belongs_to)
-
-          saving_result
-
-        end.all?
-      end
-
-    end
-
-  end
-end

data/lib/object_attorney/record.rb

@@ -1,117 +0,0 @@
-module ObjectAttorney
-  
-  module Record
-
-    def id
-      represented_object.try(:id)
-    end
-  
-    def new_record?
-      Helpers.try_or_return(represented_object, :new_record?, true)
-    end
-
-    def persisted?
-      Helpers.try_or_return(represented_object, :persisted?, false)
-    end
-
-    def save
-      save_or_! { submit }
-    end
-
-    def save!(save_method = :save!)
-      save_or_! { submit! }
-    end
-
-    def submit
-      submit_or_!(:save)
-    end
-
-    def submit!
-      submit_or_!(:save!)
-    end
-
-    def destroy
-      return true if represented_object.blank?
-      represented_object.destroy
-    end
-
-    def call_save_or_destroy(object, save_method)
-      if object == self
-        represented_object.present? ? represented_object.send(save_method) : true
-      else
-        save_method = :destroy if Helpers.marked_for_destruction?(object)
-        object.send(save_method)
-      end
-    end
-
-    def clear_nested_imposed_errors
-      nested_objects.each do |reflection, nested_object|
-        nested_object.clear_imposed_errors
-
-        nested_object.clear_nested_imposed_errors if nested_object.respond_to?(:clear_nested_imposed_errors)
-      end
-    end
-
-    def populate_nested_imposed_errors
-      nested_objects.each do |reflection, nested_object|
-        next if Helpers.marked_for_destruction?(nested_object)
-        
-        nested_object.populate_imposed_errors
-        
-        nested_object.populate_nested_imposed_errors if nested_object.respond_to?(:populate_nested_imposed_errors)
-      end
-    end
-
-    protected #################### PROTECTED METHODS DOWN BELOW ######################
-
-    def save_or_!
-      clear_imposed_errors
-      clear_nested_imposed_errors
-      
-      before_save
-
-      save_result = valid? ? yield : false
-      
-      populate_imposed_errors
-      populate_nested_imposed_errors
-
-      after_save if valid? && save_result
-
-      save_result
-    end
-
-    def before_save; end
-    def after_save; end
-
-    def submit_or_!(save_method)
-      save_result = save_or_destroy_nested_objects(save_method, :belongs_to)
-      save_result = save_or_destroy_represented_object(save_method)
-      save_result = save_or_destroy_nested_objects(save_method, :has_many) if save_result
-      save_result = save_or_destroy_nested_objects(save_method, :has_one) if save_result
-      save_result
-    end
-
-    def save_or_destroy_represented_object(save_method)
-      return true if represented_object.blank?
-      call_save_or_destroy(represented_object, save_method)
-    end
-    
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    module ClassMethods
-
-      def all(*args)
-        if represented_object_class.respond_to?(:all)
-          represented_object_class.all(*args).map { |represented_object| self.new({}, represented_object) }
-        else
-          []
-        end
-      end
-
-    end
-
-  end
-  
-end

data/lib/object_attorney/reflection.rb

@@ -1,40 +0,0 @@
-module ObjectAttorney
-
-  class Reflection
-    attr_reader :name, :klass, :options
-
-    def initialize(class_name, options)
-      options = options.is_a?(Hash) ? options : {}
-
-      @name, @options = class_name, options
-
-      @klass = options[:class_name] || klass_default(@name)
-
-      if options.include?(:class_name) && options[:class_name].nil?
-        @klass = nil
-      elsif @klass.is_a?(String)
-        @klass = @klass.constantize
-      end
-    end
-
-    def single_name
-      @single_name ||= options[:single_name] || Helpers.singularize(name)
-    end
-
-    def plural_name
-      @plural_name ||= options[:plural_name] || name.to_s.pluralize
-    end
-
-    private ################################# private
-
-    def klass_default(class_name)
-      if Helpers.plural?(class_name)
-        class_name.to_s.singularize.camelize
-      else
-        class_name.to_s.camelize
-      end
-    end
-
-  end
-
-end

data/lib/object_attorney/representation.rb

@@ -1,93 +0,0 @@
-module ObjectAttorney
-
-  module Representation
-
-    def read_attribute_for_serialization(attribute)
-      respond_to?(attribute) ? send(attribute) : nil
-    end
-
-    def send_to_representative(method_name, *args)
-      return false if represented_object.blank?
-
-      represented_object.send(method_name, *args)
-    end
-
-    def represented_object
-      @represented_object ||= self.class.represented_object_class.try(:new)
-    end
-
-    protected #################### PROTECTED METHODS DOWN BELOW ######################
-
-    def validate_represented_object
-      represented_object_valid = Helpers.try_or_return(represented_object, :valid?, true)
-
-      load_errors_from represented_object.errors unless represented_object_valid
-
-      nested_valid = add_errors_entry_if_nested_invalid
-
-      represented_object_valid && nested_valid
-    end
-
-    private #################### PRIVATE METHODS DOWN BELOW ######################
-
-    def add_errors_entry_if_nested_invalid
-      nested_vs_invalid = {}
-
-      nested_objects.each do |reflection, nested_object|
-        if Helpers.has_errors_method?(nested_object) && !nested_object.errors.empty? && !nested_vs_invalid.include?(reflection.name)
-          message = errors.send(:normalize_message, reflection.name, :invalid, {})
-
-          if !errors.messages[reflection.name].try(:include?, message)
-            nested_vs_invalid[reflection.name] = message
-          end
-        end
-      end
-
-      load_errors_from nested_vs_invalid
-
-      nested_vs_invalid.empty?
-    end
-
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    module ClassMethods
-
-      def table_name
-        self.instance_variable_get("@table_name") || represented_object_class.try(:table_name)
-      end
-
-      attr_writer :table_name
-
-      def represents(represented_object_name, options = {})
-        self.instance_variable_set("@represented_object_reflection", Reflection.new(represented_object_name, options))
-
-        define_method(represented_object_name) { represented_object }
-
-        properties(*options[:properties]) if options.include?(:properties)
-        getters(*options[:getters]) if options.include?(:getters)
-        setters(*options[:setters]) if options.include?(:setters)
-
-        class_eval { include Delegation::MissingMethods } if options[:delegate_missing_methods]
-      end
-
-      def represented_object_reflection
-        self.instance_variable_get("@represented_object_reflection") || zuper_method('represented_object_reflection')
-      end
-
-      def represented_object_class
-        represented_object_reflection.try(:klass)
-      end
-
-      def represented_object_reflect_on_association(association)
-        return nil if represented_object_class.nil? || !represented_object_class.respond_to?(:reflect_on_association)
-
-        represented_object_class.reflect_on_association(association)
-      end
-
-    end
-
-  end
-
-end

data/lib/object_attorney/serialization.rb

@@ -1,43 +0,0 @@
-module ObjectAttorney
-
-  module Serialization
-
-    def attributes
-      self.class.attributes_keys.reduce({}) do |data, getter|
-        data[getter.to_s] = send(getter)
-        data
-      end
-    end
-
-    def to_hash(options = {})
-      serializable_hash(options)
-    end
-
-    def to_json(options = {})
-      serializable_hash(options).to_json
-    end
-
-    def self.included(base)
-      base.class_eval { include ActiveModel::Serialization }
-      base.extend(ClassMethods)
-    end
-
-    module ClassMethods
-      
-      def attributes_keys
-        return @attributes_keys if defined?(@attributes_keys)
-
-        @attributes_keys = zuper_method(:attributes_keys)
-        
-        @attributes_keys ||= represented_object_class.present? && represented_object_class.method_defined?(:id) ? [:id] : []
-      end
-
-      def add_attribute_key(*getters)
-        attributes_keys.push(*getters) unless attributes_keys.include?(getters)
-      end
-
-    end
-
-  end
-
-end

data/lib/object_attorney/translation.rb

@@ -1,25 +0,0 @@
-module ObjectAttorney
-
-  module Translation
-
-    def human_attribute_name(attribute_key_name, options = {})
-      no_translation = "-- no translation --"
-      
-      defaults = ["object_attorney.attributes.#{represented_object_class.to_s.underscore}.#{attribute_key_name}".to_sym]
-      defaults << options[:default] if options[:default]
-      defaults.flatten!
-      defaults << no_translation
-      options[:count] ||= 1
-      
-      translation = I18n.translate(defaults.shift, options.merge(default: defaults))
-
-      if translation == no_translation && represented_object_class.respond_to?(:human_attribute_name)
-        translation = represented_object_class.human_attribute_name(attribute_key_name, options)
-      end
-
-      translation
-    end
-
-  end
-
-end

data/lib/object_attorney/validations.rb

@@ -1,46 +0,0 @@
-module ObjectAttorney
-  module Validations
-
-    def valid?(context = nil)
-      return true if override_validations? || !Helpers.has_errors_method?(self)
-
-      context ||= (new_record? ? :create : :update)
-      output = super(context)
-
-      load_errors_from imposed_errors
-
-      errors.empty? && output
-    end
-    
-    def override_validations?
-      Helpers.marked_for_destruction?(self)
-    end
-
-    def clear_imposed_errors
-      @imposed_errors = {}
-    end
-
-    def populate_imposed_errors
-      if respond_to?(:represented_object)
-        represented_object.errors.each { |key, value| imposed_errors[key] = value } if Helpers.has_errors_method?(represented_object)
-      else
-        errors.each { |key, value| imposed_errors[key] = value } if Helpers.has_errors_method?(self)
-      end
-    end
-
-    def imposed_errors
-      @imposed_errors ||= {}
-    end
-
-    private #################### PRIVATE METHODS DOWN BELOW ######################
-
-    def load_errors_from(errors)
-      errors.each do |key, value|
-        [*value].each do |_value|
-          self.errors.add(key, _value) unless self.errors.added?(key, _value)
-        end
-      end
-    end
-
-  end
-end

data/not_used/nested_uniqueness_validator.rb

@@ -1,33 +0,0 @@
-module ActiveModel
-
-  module Validations
-
-    class NestedUniquenessValidator < EachValidator
-      def validate_each(record, attr_name, value)
-        uniq_value, existing_objects, first_element = options[:uniq_value], [], nil
-
-        record.send(attr_name).each do |object|
-          next if Helpers.marked_for_destruction?(object)
-
-          first_element = object if first_element.nil?
-
-          if existing_objects.include?(object.send(uniq_value))
-            object.errors.add(uniq_value, :taken)
-            record.errors.add(attr_name, :taken)
-          else
-            existing_objects << object.send(uniq_value)
-          end
-        end
-
-      end
-    end
-
-    module HelperMethods
-      
-      def validates_nested_uniqueness(*attr_names)
-        validates_with NestedUniquenessValidator, _merge_attributes(attr_names)
-      end
-
-    end
-  end
-end