clowne 0.1.0.pre1 → 1.2.0

data/lib/clowne/dsl.rb

@@ -5,10 +5,19 @@ module Clowne
     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
+
+    private
+
+    def current_adapter(user_adapter)
+      return adapter if user_adapter.nil?
+
+      Clowne.resolve_adapter(user_adapter)
+    end
   end
 end

data/lib/clowne/ext/lambda_as_proc.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Ext
+    # Add to_proc method for lambda
+    module LambdaAsProc
+      refine Proc do
+        def to_proc
+          return self unless lambda?
+
+          this = self
+          proc { |*args| this.call(*args.take(this.arity)) }
+        end
+      end
+    end
+  end
+end

data/lib/clowne/ext/orm_ext.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "clowne/ext/string_constantize"
+
+module Clowne
+  module Ext
+    # Adds #cloner_class method to ORM base model
+    module ORMExt
+      using Clowne::Ext::StringConstantize
+
+      def cloner_class
+        return @_clowne_cloner if instance_variable_defined?(:@_clowne_cloner)
+
+        cloner = "#{name}Cloner".constantize
+        return @_clowne_cloner = cloner if cloner && cloner <= Clowne::Cloner
+
+        @_clowne_cloner = superclass.cloner_class if superclass.respond_to?(:cloner_class)
+      end
+    end
+  end
+end

data/lib/clowne/ext/record_key.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Ext
+    module RecordKey # :nodoc: all
+      def key(record)
+        id = record.respond_to?(:id) && record.id ? record.id : record.__id__
+        [record.class.name, id].join("#")
+      end
+    end
+  end
+end

data/lib/clowne/ext/string_constantize.rb

@@ -6,15 +6,21 @@ module Clowne
     module StringConstantize
       refine String do
         def constantize
-          names = split('::')
+          names = split("::")
 
-          Object.const_get(self) if names.empty?
+          return nil 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)
+          begin
+            names.inject(Object) do |constant, name|
+              constant.const_get(name)
+            end
+          # rescue instead of const_defined? allow us to use
+          # Rails const autoloading (aka patched const_get)
+          rescue NameError
+            nil
           end
         end
       end

data/lib/clowne/ext/yield_self_then.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Ext # :nodoc: all
+    # Add yield_self and then if missing
+    module YieldSelfThen
+      module Ext
+        unless nil.respond_to?(:yield_self)
+          def yield_self
+            yield self
+          end
+        end
+
+        alias then yield_self
+      end
+
+      # See https://github.com/jruby/jruby/issues/5220
+      ::Object.include(Ext) if RUBY_PLATFORM.match?(/java/i)
+
+      refine Object do
+        include Ext
+      end
+    end
+  end
+end

data/lib/clowne/planner.rb

@@ -1,30 +1,50 @@
 # frozen_string_literal: true
 
-require 'clowne/plan'
+require "clowne/utils/plan"
 
 module Clowne
   class Planner # :nodoc: all
     class << self
-      # Params:
-      # +cloner+:: Cloner object
-      # +init_plan+:: Init plan
-      # +traits+:: List of traits if any
-      def compile(cloner, traits: nil)
+      # Compile plan for cloner with traits
+      def compile(adapter, cloner, traits: nil)
         declarations = cloner.declarations.dup
 
         declarations += compile_traits(cloner, traits) unless traits.nil?
 
-        declarations.each_with_object(Plan.new(cloner.adapter.registry)) do |declaration, plan|
+        declarations.each_with_object(
+          Utils::Plan.new(adapter.registry)
+        ) do |declaration, plan|
           declaration.compile(plan)
         end
       end
 
+      # Extend previously compiled plan with an arbitrary block
+      # NOTE: It doesn't modify the plan itself but return a copy
+      def enhance(plan, block)
+        trait = Clowne::Declarations::Trait.new.tap { |t| t.extend_with(block) }
+
+        trait.compiled.each_with_object(plan.dup) do |declaration, new_plan|
+          declaration.compile(new_plan)
+        end
+      end
+
+      def filter_declarations(plan, only)
+        return plan if only.nil?
+
+        plan.dup.tap do |new_plan|
+          new_plan.declarations.reject! do |(type, declaration)|
+            !only.key?(type) || !declaration.matches?(only[type])
+          end
+        end
+      end
+
       private
 
       def compile_traits(cloner, traits)
         traits.map do |id|
           trait = cloner.traits[id]
           raise ConfigurationError, "Trait not found: #{id}" if trait.nil?
+
           trait.compiled
         end.flatten
       end

data/lib/clowne/resolvers/after_clone.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Clowne
+  class Resolvers
+    module AfterClone # :nodoc: all
+      def self.call(source, record, declaration, params:, **_options)
+        operation = Clowne::Utils::Operation.current
+        operation.add_after_clone(
+          proc do
+            declaration.block.call(source, record, params)
+          end
+        )
+        record
+      end
+    end
+  end
+end

data/lib/clowne/resolvers/after_persist.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Clowne
+  class Resolvers
+    module AfterPersist # :nodoc: all
+      def self.call(source, record, declaration, params:, **_options)
+        operation = Clowne::Utils::Operation.current
+        params ||= {}
+        operation.add_after_persist(
+          proc do
+            declaration.block.call(source, record, params.merge(mapper: operation.mapper))
+          end
+        )
+        record
+      end
+    end
+  end
+end

data/lib/clowne/resolvers/finalize.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Clowne
+  class Resolvers
+    module Finalize # :nodoc: all
+      def self.call(source, record, declaration, params:, **_options)
+        declaration.block.call(source, record, params)
+        record
+      end
+    end
+  end
+end

data/lib/clowne/resolvers/init_as.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Clowne
+  class Resolvers
+    module InitAs # :nodoc: all
+      # rubocop: disable Metrics/ParameterLists
+      def self.call(source, _record, declaration, params:, adapter:, **_options)
+        adapter.init_record(declaration.block.call(source, **params))
+      end
+      # rubocop: enable Metrics/ParameterLists
+    end
+  end
+end

data/lib/clowne/resolvers/nullify.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Clowne
+  class Resolvers
+    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

data/lib/clowne/rspec.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "clowne/rspec/helpers"
+require "clowne/rspec/clone_associations"
+require "clowne/rspec/clone_association"

data/lib/clowne/rspec/clone_association.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Clowne
+  module RSpec
+    module Matchers # :nodoc: all
+      class CloneAssociation < ::RSpec::Matchers::BuiltIn::BaseMatcher
+        include Clowne::RSpec::Helpers
+
+        AVAILABLE_PARAMS = %i[
+          traits
+          clone_with
+          params
+          scope
+        ].freeze
+
+        attr_reader :expected_params
+
+        def initialize(name, options)
+          @expected = name
+          extract_options! options
+        end
+
+        # rubocop: disable Metrics/AbcSize
+        def match(expected, _actual)
+          @actual = plan.declarations
+            .find { |key, decl| key == :association && decl.name == expected }
+
+          return false if @actual.nil?
+
+          @actual = actual.last
+
+          AVAILABLE_PARAMS.each do |param|
+            if expected_params[param] != UNDEFINED
+              return false if expected_params[param] != actual.send(param)
+            end
+          end
+
+          true
+        end
+        # rubocop: enable Metrics/AbcSize
+
+        def does_not_match?(*)
+          raise "This matcher doesn't support negation"
+        end
+
+        def failure_message
+          if @actual.nil?
+            "expected to include association #{expected}, but none found"
+          else
+            params_failure_message
+          end
+        end
+
+        private
+
+        def extract_options!(options)
+          @expected_params = {}
+
+          AVAILABLE_PARAMS.each do |param|
+            expected_params[param] = options.fetch(param, UNDEFINED)
+          end
+
+          raise ArgumentError, "Lambda scope is not supported" if
+            expected_params[:scope].is_a?(Proc)
+
+          raise ArgumentError, "Lambda params is not supported" if
+            expected_params[:params].is_a?(Proc)
+        end
+
+        def params_failure_message
+          "expected :#{@expected} association " \
+          "to have options #{formatted_expected_params}, " \
+          "but got #{formatted_actual_params}"
+        end
+
+        def formatted_expected_params
+          ::RSpec::Support::ObjectFormatter.format(
+            expected_params.reject { |_, v| v == UNDEFINED }
+          )
+        end
+
+        def formatted_actual_params
+          actual_params = AVAILABLE_PARAMS.each_with_object({}) do |key, acc|
+            acc[key] = actual.send(key)
+          end
+          ::RSpec::Support::ObjectFormatter.format(actual_params)
+        end
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include(Module.new do
+    def clone_association(expected, **options)
+      Clowne::RSpec::Matchers::CloneAssociation.new(expected, options)
+    end
+  end, type: :cloner)
+end

data/lib/clowne/rspec/clone_associations.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Clowne
+  module RSpec
+    module Matchers # :nodoc: all
+      # `clone_associations` matcher is just an extension of `contain_exactly` matcher
+      class CloneAssociations < ::RSpec::Matchers::BuiltIn::ContainExactly
+        include Clowne::RSpec::Helpers
+
+        def convert_actual_to_an_array
+          @actual = plan.declarations
+            .select { |key, _| key == :association }
+            .map { |_, decl| decl.name }
+        end
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include(Module.new do
+    def clone_associations(*expected)
+      Clowne::RSpec::Matchers::CloneAssociations.new(expected)
+    end
+  end, type: :cloner)
+end

data/lib/clowne/rspec/helpers.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Clowne
+  module RSpec
+    module Helpers # :nodoc: all
+      attr_reader :cloner
+
+      def with_traits(*traits)
+        @traits = traits
+        self
+      end
+
+      def matches?(actual)
+        raise ArgumentError, non_cloner_message unless actual <= ::Clowne::Cloner
+
+        @cloner = actual
+        super
+      end
+
+      def plan
+        @plan ||=
+          if @traits.nil?
+            cloner.default_plan
+          else
+            cloner.plan_with_traits(@traits)
+          end
+      end
+
+      def non_cloner_message
+        "expected a cloner to be passed to `expect(...)`, " \
+        "but got #{actual_formatted}"
+      end
+    end
+  end
+end

data/lib/clowne/utils/clone_mapper.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "clowne/ext/record_key"
+
+module Clowne
+  module Utils
+    class CloneMapper # :nodoc: all
+      def initialize
+        @store = {}
+      end
+
+      def add(origin, clone)
+        @store[origin] ||= clone
+      end
+
+      def clone_of(origin)
+        @store[origin]
+      end
+
+      def origin_of(clone)
+        origin, _clone = @store.rassoc(clone)
+        origin
+      end
+    end
+  end
+end