clowne 0.0.1 → 0.1.0.beta1

data/lib/clowne/adapters/base/finalize.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Adapters
+    class Base
+      module Finalize # :nodoc: all
+        def self.call(source, record, declaration, params:)
+          declaration.block.call(source, record, params)
+          record
+        end
+      end
+    end
+  end
+end
+
+Clowne::Adapters::Base.register_resolver(
+  :finalize, Clowne::Adapters::Base::Finalize,
+  after: :nullify
+)

data/lib/clowne/adapters/base/nullify.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Adapters
+    class Base
+      module Nullify # :nodoc: all
+        def self.call(_source, record, declaration, **_options)
+          declaration.attributes.each do |attr|
+            record.__send__("#{attr}=", nil)
+          end
+
+          record
+        end
+      end
+    end
+  end
+end
+
+Clowne::Adapters::Base.register_resolver(:nullify, Clowne::Adapters::Base::Nullify)

data/lib/clowne/adapters/registry.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Adapters
+    class Registry # :nodoc: all
+      attr_reader :actions, :mapping
+
+      def initialize
+        @actions = []
+        @mapping = {}
+      end
+
+      def insert_after(after, action)
+        validate_uniq!(action)
+
+        after_index = actions.find_index(after)
+
+        raise "Plan action not found: #{after}" if after_index.nil?
+
+        actions.insert(after_index + 1, action)
+      end
+
+      def insert_before(before, action)
+        validate_uniq!(action)
+
+        before_index = actions.find_index(before)
+
+        raise "Plan action not found: #{before}" if before_index.nil?
+
+        actions.insert(before_index, action)
+      end
+
+      def append(action)
+        validate_uniq!(action)
+        actions.push action
+      end
+
+      def prepend(action)
+        validate_uniq!(action)
+        actions.unshift action
+      end
+
+      def dup
+        self.class.new.tap do |duped|
+          actions.each { |act| duped.append(act) }
+          duped.mapping = mapping.dup
+        end
+      end
+
+      protected
+
+      attr_writer :mapping
+
+      private
+
+      def validate_uniq!(action)
+        raise "Plan action already registered: #{action}" if actions.include?(action)
+      end
+    end
+  end
+end

data/lib/clowne/cloner.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'clowne/planner'
+require 'clowne/dsl'
+
+module Clowne # :nodoc: all
+  class UnprocessableSourceError < StandardError; end
+  class ConfigurationError < StandardError; end
+
+  class Cloner
+    extend Clowne::DSL
+
+    class << self
+      def inherited(subclass)
+        subclass.adapter(adapter) unless self == Clowne::Cloner
+        subclass.declarations = declarations.dup
+
+        return if traits.nil?
+
+        traits.each do |name, trait|
+          subclass.traits[name] = trait.dup
+        end
+      end
+
+      def declarations
+        return @declarations if instance_variable_defined?(:@declarations)
+        @declarations = []
+      end
+
+      def traits
+        return @traits if instance_variable_defined?(:@traits)
+        @traits = {}
+      end
+
+      def register_trait(name, block)
+        @traits ||= {}
+        @traits[name] ||= Declarations::Trait.new
+        @traits[name].extend_with(block)
+      end
+
+      # rubocop: disable Metrics/AbcSize, Metrics/MethodLength
+      # rubocop: disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def call(object, **options)
+        raise(UnprocessableSourceError, 'Nil is not cloneable object') if object.nil?
+
+        raise(ConfigurationError, 'Adapter is not defined') if adapter.nil?
+
+        traits = options.delete(:traits)
+
+        traits = Array(traits) unless traits.nil?
+
+        plan =
+          if traits.nil? || traits.empty?
+            default_plan
+          else
+            plan_with_traits(traits)
+          end
+
+        plan = Clowne::Planner.enhance(plan, Proc.new) if block_given?
+
+        adapter.clone(object, plan, params: options)
+      end
+
+      # rubocop: enable Metrics/AbcSize, Metrics/MethodLength
+      # rubocop: enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      def default_plan
+        return @default_plan if instance_variable_defined?(:@default_plan)
+        @default_plan = Clowne::Planner.compile(self)
+      end
+
+      def plan_with_traits(ids)
+        # Cache plans for combinations of traits
+        traits_id = ids.map(&:to_s).join(':')
+        return traits_plans[traits_id] if traits_plans.key?(traits_id)
+        traits_plans[traits_id] = Clowne::Planner.compile(
+          self, traits: ids
+        )
+      end
+
+      protected
+
+      attr_writer :declarations
+
+      private
+
+      def traits_plans
+        return @traits_plans if instance_variable_defined?(:@traits_plans)
+        @traits_plans = {}
+      end
+    end
+  end
+end

data/lib/clowne/declarations.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'clowne/dsl'
+require 'clowne/plan'
+
+module Clowne
+  module Declarations # :nodoc:
+    module_function
+
+    def add(id, declaration = nil)
+      declaration = Proc.new if block_given?
+
+      if declaration.is_a?(Class)
+        DSL.send(:define_method, id) do |*args, &block|
+          declarations.push declaration.new(*args, &block)
+        end
+      elsif declaration.is_a?(Proc)
+        DSL.send(:define_method, id, &declaration)
+      else
+        raise ArgumentError, "Unsupported declaration type: #{declaration.class}"
+      end
+    end
+  end
+end
+
+require 'clowne/declarations/exclude_association'
+require 'clowne/declarations/finalize'
+require 'clowne/declarations/include_association'
+require 'clowne/declarations/nullify'
+require 'clowne/declarations/trait'

data/lib/clowne/declarations/exclude_association.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Declarations
+    class ExcludeAssociation # :nodoc: all
+      attr_accessor :name
+
+      def initialize(name)
+        @name = name.to_sym
+      end
+
+      def compile(plan)
+        plan.remove_from(:association, name)
+      end
+    end
+  end
+end
+
+Clowne::Declarations.add :exclude_association, Clowne::Declarations::ExcludeAssociation
+Clowne::Declarations.add :exclude_associations do |*names|
+  names.each do |name|
+    declarations.push Clowne::Declarations::ExcludeAssociation.new(name)
+  end
+end

data/lib/clowne/declarations/finalize.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Declarations
+    class Finalize # :nodoc: all
+      attr_reader :block
+
+      def initialize
+        raise ArgumentError, 'Block is required for finalize' unless block_given?
+        @block = Proc.new
+      end
+
+      def compile(plan)
+        plan.add(:finalize, self)
+      end
+    end
+  end
+end
+
+Clowne::Declarations.add :finalize, Clowne::Declarations::Finalize

data/lib/clowne/declarations/include_association.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'clowne/ext/string_constantize'
+
+module Clowne
+  module Declarations
+    class IncludeAssociation # :nodoc: all
+      using Clowne::Ext::StringConstantize
+
+      attr_accessor :name, :scope, :options
+
+      def initialize(name, scope = nil, **options)
+        @name = name.to_sym
+        @scope = scope
+        @options = options
+      end
+
+      def compile(plan)
+        plan.add_to(:association, name, self)
+      end
+
+      def clone_with
+        return @clone_with if instance_variable_defined?(:@clone_with)
+        @clone_with =
+          case options[:clone_with]
+          when String, Symbol
+            options[:clone_with].to_s.constantize
+          else
+            options[:clone_with]
+          end
+      end
+
+      def traits
+        options[:traits]
+      end
+    end
+  end
+end
+
+Clowne::Declarations.add :include_association, Clowne::Declarations::IncludeAssociation
+Clowne::Declarations.add :include_associations do |*names|
+  names.each do |name|
+    declarations.push Clowne::Declarations::IncludeAssociation.new(name)
+  end
+end

data/lib/clowne/declarations/nullify.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Declarations
+    class Nullify # :nodoc: all
+      attr_reader :attributes
+
+      def initialize(*attributes)
+        raise ArgumentError, 'At least one attribute required' if attributes.empty?
+        @attributes = attributes
+      end
+
+      def compile(plan)
+        plan.add(:nullify, self)
+      end
+    end
+  end
+end
+
+Clowne::Declarations.add :nullify, Clowne::Declarations::Nullify

data/lib/clowne/declarations/trait.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Declarations
+    class Trait # :nodoc: all
+      def initialize
+        @blocks = []
+      end
+
+      def extend_with(block)
+        @blocks << block
+      end
+
+      def compiled
+        return @compiled if instance_variable_defined?(:@compiled)
+        @compiled = compile
+      end
+
+      def dup
+        self.class.new.tap do |duped|
+          blocks.each { |b| duped.extend_with(b) }
+        end
+      end
+
+      private
+
+      attr_reader :blocks
+
+      def compile
+        anonymous_cloner = Class.new(Clowne::Cloner)
+
+        blocks.each do |block|
+          anonymous_cloner.instance_eval(&block)
+        end
+
+        anonymous_cloner.declarations
+      end
+    end
+  end
+end
+
+Clowne::Declarations.add :trait do |name, &block|
+  register_trait name, block
+end

data/lib/clowne/dsl.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Clowne
+  module DSL # :nodoc: all
+    def adapter(adapter = nil)
+      if adapter.nil?
+        return @_adapter if instance_variable_defined?(:@_adapter)
+        @_adapter = Clowne.default_adapter
+      else
+        @_adapter = Clowne.resolve_adapter(adapter)
+      end
+    end
+  end
+end

data/lib/clowne/ext/string_constantize.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Ext
+    # Add simple constantize method to String
+    module StringConstantize
+      refine String do
+        def constantize
+          names = split('::')
+
+          Object.const_get(self) if names.empty?
+
+          # Remove the first blank element in case of '::ClassName' notation.
+          names.shift if names.size > 1 && names.first.empty?
+
+          names.inject(Object) do |constant, name|
+            constant.const_get(name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/clowne/plan.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Clowne
+  class Plan # :nodoc: all
+    class TwoPhaseSet
+      def initialize
+        @added = {}
+        @removed = []
+      end
+
+      def []=(k, v)
+        return if @removed.include?(k)
+        @added[k] = v
+      end
+
+      def delete(k)
+        return if @removed.include?(k)
+        @removed << k
+        @added.delete(k)
+      end
+
+      def values
+        @added.values
+      end
+    end
+
+    def initialize(registry)
+      @registry = registry
+      @data = {}
+    end
+
+    def add(type, declaration)
+      data[type] = [] unless data.key?(type)
+      data[type] << declaration
+    end
+
+    def add_to(type, id, declaration)
+      data[type] = TwoPhaseSet.new unless data.key?(type)
+      data[type][id] = declaration
+    end
+
+    def set(type, declaration)
+      data[type] = declaration
+    end
+
+    def get(type)
+      data[type]
+    end
+
+    def remove(type)
+      data.delete(type)
+    end
+
+    def remove_from(type, id)
+      return unless data[type]
+      data[type].delete(id)
+    end
+
+    def declarations
+      registry.actions.flat_map do |type|
+        value = data[type]
+        next if value.nil?
+        value = value.values if value.is_a?(TwoPhaseSet)
+        value = Array(value)
+        value.map { |v| [type, v] }
+      end.compact
+    end
+
+    def dup
+      self.class.new(registry).tap do |duped|
+        data.each do |k, v|
+          duped.set(k, v.dup)
+        end
+      end
+    end
+
+    private
+
+    attr_reader :data, :registry
+  end
+end