amoeba 1.2.1 → 3.2.0

data/lib/amoeba/class_methods.rb

@@ -0,0 +1,28 @@
+module Amoeba
+  module ClassMethods
+    def amoeba(&block)
+      @config_block ||= block if block_given?
+
+      @config ||= Amoeba::Config.new(self)
+      @config.instance_eval(&block) if block_given?
+      @config
+    end
+
+    def fresh_amoeba(&block)
+      @config_block = block if block_given?
+
+      @config = Amoeba::Config.new(self)
+      @config.instance_eval(&block) if block_given?
+      @config
+    end
+
+    def reset_amoeba(&block)
+      @config_block = block if block_given?
+      @config = Amoeba::Config.new(self)
+    end
+
+    def amoeba_block
+      @config_block
+    end
+  end
+end

data/lib/amoeba/cloner.rb

@@ -0,0 +1,172 @@
+require 'forwardable'
+
+module Amoeba
+  class Cloner
+    extend Forwardable
+
+    attr_reader :new_object, :old_object, :object_klass
+
+    def_delegators :old_object, :_parent_amoeba, :_amoeba_settings,
+                   :_parent_amoeba_settings
+
+    def_delegators :object_klass, :amoeba, :fresh_amoeba, :reset_amoeba
+
+    def initialize(object, options = {})
+      @old_object = object
+      @options    = options
+      @object_klass = @old_object.class
+      inherit_parent_settings
+      @new_object = object.__send__(amoeba.dup_method)
+    end
+
+    def run
+      process_overrides
+      apply if amoeba.enabled
+      after_apply if amoeba.do_preproc
+      @new_object
+    end
+
+    private
+
+    def parenting_style
+      amoeba.upbringing ? amoeba.upbringing : _parent_amoeba.parenting
+    end
+
+    def inherit_strict_parent_settings
+      fresh_amoeba(&_parent_amoeba_settings)
+    end
+
+    def inherit_relaxed_parent_settings
+      amoeba(&_parent_amoeba_settings)
+    end
+
+    def inherit_submissive_parent_settings
+      reset_amoeba(&_amoeba_settings)
+      amoeba(&_parent_amoeba_settings)
+      amoeba(&_amoeba_settings)
+    end
+
+    def inherit_parent_settings
+      return if !_parent_amoeba.inherit
+      return unless %w(strict relaxed submissive).include?(parenting_style.to_s)
+      __send__("inherit_#{parenting_style}_parent_settings".to_sym)
+    end
+
+    def apply_clones
+      amoeba.clones.each do |clone_field|
+        exclude_clone_if_has_many_through(clone_field)
+      end
+    end
+
+    def exclude_clone_if_has_many_through(clone_field)
+      association = @object_klass.reflect_on_association(clone_field)
+
+      # if this is a has many through and we're gonna deep
+      # copy the child records, exclude the regular join
+      # table from copying so we don't end up with the new
+      # and old children on the copy
+      return unless association.macro == :has_many ||
+                    association.is_a?(::ActiveRecord::Reflection::ThroughReflection)
+      amoeba.exclude_association(association.options[:through])
+    end
+
+    def follow_only_includes
+      amoeba.includes.each do |include, options|
+        next if options[:if] && !@old_object.send(options[:if])
+        follow_association(include, @object_klass.reflect_on_association(include))
+      end
+    end
+
+    def follow_all_except_excludes
+      @object_klass.reflections.each do |name, association|
+        exclude = amoeba.excludes[name.to_sym]
+        next if exclude && (exclude.blank? || @old_object.send(exclude[:if]))
+        follow_association(name, association)
+      end
+    end
+
+    def follow_all
+      @object_klass.reflections.each do |name, association|
+        follow_association(name, association)
+      end
+    end
+
+    def apply_associations
+      if amoeba.includes.present?
+        follow_only_includes
+      elsif amoeba.excludes.present?
+        follow_all_except_excludes
+      else
+        follow_all
+      end
+    end
+
+    def apply
+      apply_clones
+      apply_associations
+    end
+
+    def follow_association(relation_name, association)
+      return unless amoeba.known_macros.include?(association.macro.to_sym)
+      follow_klass = ::Amoeba::Macros.list[association.macro.to_sym]
+      follow_klass.new(self).follow(relation_name, association) if follow_klass
+    end
+
+    def process_overrides
+      amoeba.overrides.each do |block|
+        block.call(@old_object, @new_object)
+      end
+    end
+
+    def process_null_fields
+      # nullify any fields the user has configured
+      amoeba.null_fields.each do |field_key|
+        @new_object[field_key] = nil
+      end
+    end
+
+    def process_coercions
+      # prepend any extra strings to indicate uniqueness of the new record(s)
+      amoeba.coercions.each do |field, coercion|
+        @new_object[field] = coercion.to_s
+      end
+    end
+
+    def process_prefixes
+      # prepend any extra strings to indicate uniqueness of the new record(s)
+      amoeba.prefixes.each do |field, prefix|
+        @new_object[field] = "#{prefix}#{@new_object[field]}"
+      end
+    end
+
+    def process_suffixes
+      # postpend any extra strings to indicate uniqueness of the new record(s)
+      amoeba.suffixes.each do |field, suffix|
+        @new_object[field] = "#{@new_object[field]}#{suffix}"
+      end
+    end
+
+    def process_regexes
+      # regex any fields that need changing
+      amoeba.regexes.each do |field, action|
+        @new_object[field].gsub!(action[:replace], action[:with])
+      end
+    end
+
+    def process_customizations
+      # prepend any extra strings to indicate uniqueness of the new record(s)
+      amoeba.customizations.each do |block|
+        block.call(@old_object, @new_object)
+      end
+    end
+
+    def after_apply
+      process_null_fields
+      process_coercions
+      process_prefixes
+      process_suffixes
+      process_regexes
+      process_customizations
+    end
+  end
+end

data/lib/amoeba/config.rb

@@ -0,0 +1,182 @@
+module Amoeba
+  class Config
+    DEFAULTS = {
+      enabled:        false,
+      inherit:        false,
+      do_preproc:     false,
+      parenting:      false,
+      raised:         false,
+      dup_method:     :dup,
+      remap_method:   nil,
+      includes:       {},
+      excludes:       {},
+      clones:         [],
+      customizations: [],
+      overrides:      [],
+      null_fields:    [],
+      coercions:      {},
+      prefixes:       {},
+      suffixes:       {},
+      regexes:        {},
+      known_macros:   [:has_one, :has_many, :has_and_belongs_to_many]
+    }
+
+    # ActiveRecord 3.x have different implementation of deep_dup
+    if ::ActiveRecord::VERSION::MAJOR == 3
+      DEFAULTS.instance_eval do
+        def deep_dup
+          each_with_object(dup) do |(key, value), hash|
+            hash[key.deep_dup] = value.deep_dup
+          end
+        end
+      end
+      Object.class_eval do
+        def deep_dup
+          duplicable? ? dup : self
+        end
+      end
+    end
+
+    DEFAULTS.freeze
+
+    DEFAULTS.each do |key, value|
+      value.freeze if value.is_a?(Array) || value.is_a?(Hash)
+      class_eval <<-EOS, __FILE__, __LINE__ + 1
+        def #{key}          # def enabled
+          @config[:#{key}]  #   @config[:enabled]
+        end                 # end
+      EOS
+    end
+
+    def initialize(klass)
+      @klass  = klass
+      @config = self.class::DEFAULTS.deep_dup
+    end
+
+    alias_method :upbringing, :raised
+
+    def enable
+      @config[:enabled] = true
+    end
+
+    def disable
+      @config[:enabled] = false
+    end
+
+    def raised(style = :submissive)
+      @config[:raised] = style
+    end
+
+    def propagate(style = :submissive)
+      @config[:parenting] ||= style
+      @config[:inherit] = true
+    end
+
+    def push_value_to_array(value, key)
+      res = @config[key]
+      if value.is_a?(::Array)
+        res = value
+      elsif value
+        res << value
+      end
+      @config[key] = res.uniq
+    end
+
+    def push_array_value_to_hash(value, config_key)
+      @config[config_key] = {}
+
+      value.each do |definition|
+        definition.each do |key, val|
+          fill_hash_value_for(config_key, key, val)
+        end
+      end
+    end
+
+    def push_value_to_hash(value, config_key)
+      if value.is_a?(Array)
+        push_array_value_to_hash(value, config_key)
+      else
+        value.each do |key, val|
+          fill_hash_value_for(config_key, key, val)
+        end
+      end
+      @config[config_key]
+    end
+
+    def fill_hash_value_for(config_key, key, val)
+      @config[config_key][key] = val if val || (!val.nil? && config_key == :coercions)
+    end
+
+    def include_association(value = nil, options = {})
+      enable
+      @config[:excludes] = {}
+      value = value.is_a?(Array) ? Hash[value.map! { |v| [v, options] }] : { value => options }
+      push_value_to_hash(value, :includes)
+    end
+
+    def include_associations(*values)
+      values.flatten.each { |v| include_association(v) }
+    end
+
+    # TODO: remove this method in v3.0.0
+    def include_field(value = nil)
+      warn 'include_field is deprecated and will be removed in version 3.0.0; please use include_association instead'
+      include_association(value)
+    end
+
+    def exclude_association(value = nil, options = {})
+      enable
+      @config[:includes] = {}
+      value = value.is_a?(Array) ? Hash[value.map! { |v| [v, options] }] : { value => options }
+      push_value_to_hash(value, :excludes)
+    end
+
+    def exclude_associations(*values)
+      values.flatten.each { |v| exclude_association(v) }
+    end
+
+    # TODO: remove this method in v3.0.0
+    def exclude_field(value = nil)
+      warn 'exclude_field is deprecated and will be removed in version 3.0.0; please use exclude_association instead'
+      exclude_association(value)
+    end
+
+    def clone(value = nil)
+      enable
+      push_value_to_array(value, :clones)
+    end
+
+    def recognize(value = nil)
+      enable
+      push_value_to_array(value, :known_macros)
+    end
+
+    { override: 'overrides', customize: 'customizations',
+      nullify: 'null_fields' }.each do |method, key|
+      class_eval <<-EOS, __FILE__, __LINE__ + 1
+        def #{method}(value = nil)             # def override(value = nil)
+          @config[:do_preproc] = true          #   @config[:do_preproc] = true
+          push_value_to_array(value, :#{key})  #   push_value_to_array(value, :overrides)
+        end                                    # end
+      EOS
+    end
+
+    { set: 'coercions', prepend: 'prefixes',
+      append: 'suffixes', regex:   'regexes' }.each do |method, key|
+      class_eval <<-EOS, __FILE__, __LINE__ + 1
+        def #{method}(value = nil)            # def set(value = nil)
+          @config[:do_preproc] = true         #   @config[:do_preproc] = true
+          push_value_to_hash(value, :#{key})  #   push_value_to_hash(value, :coercions)
+        end                                   # end
+      EOS
+    end
+
+    def through(value)
+      @config[:dup_method] = value.to_sym
+    end
+
+    def remapper(value)
+      @config[:remap_method] = value.to_sym
+    end
+  end
+end

data/lib/amoeba/instance_methods.rb

@@ -0,0 +1,37 @@
+module Amoeba
+  module InstanceMethods
+    def _parent_amoeba
+      if _first_superclass_with_amoeba.respond_to?(:amoeba)
+        _first_superclass_with_amoeba.amoeba
+      else
+        false
+      end
+    end
+
+    def _first_superclass_with_amoeba
+      return @_first_superclass_with_amoeba unless @_first_superclass_with_amoeba.nil?
+      klass = self.class
+      while klass.superclass < ::ActiveRecord::Base
+        klass = klass.superclass
+        break if klass.respond_to?(:amoeba) && klass.amoeba.enabled
+      end
+      @_first_superclass_with_amoeba = klass
+    end
+
+    def _amoeba_settings
+      self.class.amoeba_block
+    end
+
+    def _parent_amoeba_settings
+      if _first_superclass_with_amoeba.respond_to?(:amoeba_block)
+        _first_superclass_with_amoeba.amoeba_block
+      else
+        false
+      end
+    end
+
+    def amoeba_dup(options = {})
+      ::Amoeba::Cloner.new(self, options).run
+    end
+  end
+end

data/lib/amoeba/macros.rb

@@ -0,0 +1,14 @@
+module Amoeba
+  module Macros
+    extend self
+    def list
+      @list ||= {}
+    end
+
+    def add(klass)
+      @list ||= {}
+      key = klass.name.demodulize.underscore.to_sym
+      @list[key] = klass
+    end
+  end
+end

data/lib/amoeba/macros/base.rb

@@ -0,0 +1,26 @@
+module Amoeba
+  module Macros
+    class Base
+      def initialize(cloner)
+        @cloner     = cloner
+        @old_object = cloner.old_object
+        @new_object = cloner.new_object
+      end
+
+      def follow(_relation_name, _association)
+        fail "#{self.class.name} doesn't implement `follow`!"
+      end
+
+      class << self
+        def inherited(klass)
+          ::Amoeba::Macros.add(klass)
+        end
+      end
+
+      def remapped_relation_name(name)
+        return name unless @cloner.amoeba.remap_method
+        @old_object.__send__(@cloner.amoeba.remap_method, name.to_sym) || name
+      end
+    end
+  end
+end