clowne 0.1.0 → 1.3.0

data/docs/traits.md

@@ -1,7 +1,4 @@
----
-id: traits
-title: Traits
----
+# Traits
 
 Traits allow you to group cloner declarations together and then apply them (like in [`factory_bot`](https://github.com/thoughtbot/factory_bot)):
 

data/gemfiles/activerecord42.gemfile

@@ -1,7 +1,9 @@
-source 'https://rubygems.org'
+# frozen_string_literal: true
 
-gem 'activerecord', '~> 4.2'
-gem 'sequel', '>= 5.0'
-gem 'sqlite3'
+source "https://rubygems.org"
 
-gemspec path: '..'
+gem "activerecord", "~> 4.2"
+gem "sequel", ">= 5.0"
+gem "sqlite3", "~> 1.3.13"
+
+gemspec path: ".."

data/gemfiles/jruby.gemfile

@@ -1,8 +1,10 @@
-source 'https://rubygems.org'
+# frozen_string_literal: true
 
-gem 'activerecord-jdbcsqlite3-adapter', '~> 50.0'
-gem 'jdbc-sqlite3'
-gem 'activerecord', '~> 5.0.0'
-gem 'sequel', '>= 5.0'
+source "https://rubygems.org"
 
-gemspec path: '..'
+gem "activerecord-jdbcsqlite3-adapter", "~> 50.0"
+gem "jdbc-sqlite3"
+gem "activerecord", "~> 5.0.0"
+gem "sequel", ">= 5.0"
+
+gemspec path: ".."

data/gemfiles/railsmaster.gemfile

@@ -1,8 +1,10 @@
-source 'https://rubygems.org'
+# frozen_string_literal: true
 
-gem 'arel', github: 'rails/arel'
-gem 'rails', github: 'rails/rails'
-gem 'sequel', github: 'jeremyevans/sequel'
-gem 'sqlite3'
+source "https://rubygems.org"
 
-gemspec path: '..'
+gem "arel", github: "rails/arel"
+gem "rails", github: "rails/rails"
+gem "sequel", github: "jeremyevans/sequel"
+gem "sqlite3"
+
+gemspec path: ".."

data/lib/clowne.rb

@@ -1,19 +1,21 @@
 # frozen_string_literal: true
 
-require 'clowne/version'
-require 'clowne/declarations'
-require 'clowne/cloner'
+require "clowne/version"
+require "clowne/declarations"
+require "clowne/cloner"
 
-require 'clowne/adapters/base'
+require "clowne/adapters/base"
 
 # Declarative models cloning
 module Clowne
   # List of built-in adapters
+  # rubocop:disable Layout/AlignHash
   ADAPTERS = {
-    base:          'Base',
-    active_record: 'ActiveRecord',
-    sequel:        'Sequel'
+    base:          "Base",
+    active_record: "ActiveRecord",
+    sequel:        "Sequel",
   }.freeze
+  # rubocop:enable Layout/AlignHash
 
   class << self
     attr_reader :default_adapter, :raise_on_override
@@ -29,6 +31,7 @@ module Clowne
       elsif adapter.is_a?(Symbol)
         adapter_class = ADAPTERS[adapter]
         raise "Unknown adapter: #{adapter}" if adapter_class.nil?
+
         Clowne::Adapters.const_get(adapter_class).new
       else
         adapter
@@ -37,5 +40,5 @@ module Clowne
   end
 end
 
-require 'clowne/adapters/active_record' if defined?(::ActiveRecord)
-require 'clowne/adapters/sequel' if defined?(::Sequel)
+require "clowne/adapters/active_record" if defined?(::ActiveRecord)
+require "clowne/adapters/sequel" if defined?(::Sequel)

data/lib/clowne/adapters/active_record.rb

@@ -1,12 +1,11 @@
 # frozen_string_literal: true
 
-require 'clowne/ext/orm_ext'
+require "clowne/ext/orm_ext"
 
 module Clowne
   module Adapters
     # Cloning adapter for ActiveRecord
-    class ActiveRecord < Base
-    end
+    class ActiveRecord < Base; end
   end
 end
 
@@ -14,5 +13,5 @@ ActiveSupport.on_load(:active_record) do
   ::ActiveRecord::Base.extend Clowne::Ext::ORMExt
 end
 
-require 'clowne/adapters/active_record/associations'
-require 'clowne/adapters/active_record/association'
+require "clowne/adapters/active_record/associations"
+require "clowne/adapters/active_record/resolvers/association"

data/lib/clowne/adapters/active_record/associations.rb

@@ -1,19 +1,21 @@
 # frozen_string_literal: true
 
-require 'clowne/adapters/active_record/associations/base'
-require 'clowne/adapters/active_record/associations/noop'
-require 'clowne/adapters/active_record/associations/has_one'
-require 'clowne/adapters/active_record/associations/has_many'
-require 'clowne/adapters/active_record/associations/has_and_belongs_to_many'
+require "clowne/adapters/active_record/associations/base"
+require "clowne/adapters/active_record/associations/noop"
+require "clowne/adapters/active_record/associations/belongs_to"
+require "clowne/adapters/active_record/associations/has_one"
+require "clowne/adapters/active_record/associations/has_many"
+require "clowne/adapters/active_record/associations/has_and_belongs_to_many"
 
 module Clowne
   module Adapters # :nodoc: all
     class ActiveRecord
       module Associations
         AR_2_CLONER = {
+          belongs_to: BelongsTo,
           has_one: HasOne,
           has_many: HasMany,
-          has_and_belongs_to_many: HABTM
+          has_and_belongs_to_many: HABTM,
         }.freeze
 
         # Returns an association cloner class for reflection

data/lib/clowne/adapters/active_record/associations/base.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'clowne/adapters/base/association'
+require "clowne/adapters/base/association"
 
 module Clowne
   module Adapters # :nodoc: all
@@ -9,10 +9,6 @@ module Clowne
         class Base < Base::Association
           private
 
-          def clone_record(record)
-            record.dup
-          end
-
           def init_scope
             association
           end

data/lib/clowne/adapters/active_record/associations/belongs_to.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Adapters # :nodoc: all
+    class ActiveRecord
+      module Associations
+        class BelongsTo < Base
+          # rubocop: disable Metrics/MethodLength
+          def call(record)
+            child = association
+            return record unless child
+
+            unless declaration.scope.nil?
+              warn(
+                "[Clowne] Belongs to association does not support scopes " \
+                "(#{@association_name} for #{@source.class})"
+              )
+            end
+
+            child_clone = clone_one(child)
+            record.__send__(:"#{association_name}=", child_clone)
+            record
+          end
+          # rubocop: enable Metrics/MethodLength
+        end
+      end
+    end
+  end
+end

data/lib/clowne/adapters/active_record/associations/has_one.rb

@@ -9,9 +9,10 @@ module Clowne
           def call(record)
             child = association
             return record unless child
-            unless scope.nil?
+
+            unless declaration.scope.nil?
               warn(
-                '[Clowne] Has one association does not support scopes ' \
+                "[Clowne] Has one association does not support scopes " \
                 "(#{@association_name} for #{@source.class})"
               )
             end

data/lib/clowne/adapters/active_record/dsl.rb

@@ -6,8 +6,8 @@ module Clowne
     module ActiveRecordDSL
       module InstanceMethods # :nodoc:
         # Shortcut to call class's cloner call with self
-        def clowne(*args, &block)
-          self.class.cloner_class.call(self, *args, &block)
+        def clowne(**args, &block)
+          self.class.cloner_class.call(self, **args, &block)
         end
       end
 

data/lib/clowne/adapters/active_record/resolvers/association.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Adapters # :nodoc: all
+    class ActiveRecord
+      module Resolvers
+        class UnknownAssociation < StandardError; end
+
+        class Association
+          class << self
+            # rubocop: disable Metrics/ParameterLists
+            def call(source, record, declaration, adapter:, params:, **_options)
+              reflection = source.class.reflections[declaration.name.to_s]
+
+              if reflection.nil?
+                raise UnknownAssociation,
+                  "Association #{declaration.name} couldn't be found for #{source.class}"
+              end
+
+              cloner_class = Associations.cloner_for(reflection)
+
+              cloner_class.new(reflection, source, declaration, adapter, params).call(record)
+
+              record
+            end
+            # rubocop: enable Metrics/ParameterLists
+          end
+        end
+      end
+    end
+  end
+end
+
+Clowne::Adapters::ActiveRecord.register_resolver(
+  :association,
+  Clowne::Adapters::ActiveRecord::Resolvers::Association,
+  before: :nullify
+)

data/lib/clowne/adapters/base.rb

@@ -1,47 +1,36 @@
 # frozen_string_literal: true
 
-require 'clowne/adapters/registry'
+require "clowne/adapters/registry"
+
+require "clowne/resolvers/init_as"
+require "clowne/resolvers/nullify"
+require "clowne/resolvers/finalize"
+require "clowne/resolvers/after_persist"
+require "clowne/resolvers/after_clone"
 
 module Clowne
   module Adapters
     # ORM-independant adapter (just calls #dup).
     # Works with nullify/finalize.
     class Base
-      class << self
-        attr_reader :registry
-
-        def inherited(subclass)
-          # Duplicate registry
-          subclass.registry = registry.dup
-        end
-
-        def resolver_for(type)
-          registry.mapping[type] || raise("Uknown resolver #{type} for #{self}")
-        end
+      include Clowne::Adapters::Registry::Container
 
-        def register_resolver(type, resolver, after: nil, before: nil, prepend: nil)
-          registry.mapping[type] = resolver
-
-          if prepend
-            registry.unshift type
-          elsif after
-            registry.insert_after after, type
-          elsif before
-            registry.insert_before before, type
-          else
-            registry.append type
+      class << self
+        # Duplicate record and remember record <-> clone relationship in operation
+        # Cab be overrided in special adapter
+        # +record+:: Instance of record (ActiveRecord or Sequel)
+        def dup_record(record)
+          record.dup.tap do |clone|
+            operation = operation_class.current
+            operation.add_mapping(record, clone)
           end
         end
 
-        protected
-
-        attr_writer :registry
-      end
-
-      self.registry = Registry.new
-
-      def registry
-        self.class.registry
+        # Operation class which  using for cloning
+        # Cab be overrided in special adapter
+        def operation_class
+          Clowne::Utils::Operation
+        end
       end
 
       # Using a plan make full duplicate of record
@@ -50,19 +39,13 @@ module Clowne
       # +params+:: Custom params hash
       def clone(source, plan, params: {})
         declarations = plan.declarations
-        declarations.inject(init_record(dup_source(source))) do |record, (type, declaration)|
+        init_record = init_record(self.class.dup_record(source))
+
+        declarations.inject(init_record) do |record, (type, declaration)|
           resolver_for(type).call(source, record, declaration, params: params, adapter: self)
         end
       end
 
-      def resolver_for(type)
-        self.class.resolver_for(type)
-      end
-
-      def dup_source(source)
-        source.dup
-      end
-
       def init_record(record)
         # Override in custom adapters
         record
@@ -71,6 +54,28 @@ module Clowne
   end
 end
 
-require 'clowne/adapters/base/init_as'
-require 'clowne/adapters/base/nullify'
-require 'clowne/adapters/base/finalize'
+Clowne::Adapters::Base.register_resolver(
+  :init_as,
+  Clowne::Resolvers::InitAs,
+  prepend: true
+)
+
+Clowne::Adapters::Base.register_resolver(
+  :nullify,
+  Clowne::Resolvers::Nullify
+)
+
+Clowne::Adapters::Base.register_resolver(
+  :finalize, Clowne::Resolvers::Finalize,
+  after: :nullify
+)
+
+Clowne::Adapters::Base.register_resolver(
+  :after_clone, Clowne::Resolvers::AfterClone,
+  after: :finalize
+)
+
+Clowne::Adapters::Base.register_resolver(
+  :after_persist, Clowne::Resolvers::AfterPersist,
+  after: :after_clone
+)

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

@@ -9,16 +9,15 @@ module Clowne
         # +source+:: Instance of cloned object (ex: User.new(posts: posts))
         # +declaration+:: = Relation description
         #                   (ex: Clowne::Declarations::IncludeAssociation.new(:posts))
+        # +adapter+:: Clowne adapter
         # +params+:: = Instance of Hash
-        def initialize(reflection, source, declaration, params)
+        def initialize(reflection, source, declaration, adapter, params)
           @source = source
-          @scope = declaration.scope
-          @clone_with = declaration.clone_with
+          @declaration = declaration
+          @adapter = adapter
           @params = params
           @association_name = declaration.name.to_s
           @reflection = reflection
-          @cloner_options = params
-          @cloner_options.merge!(traits: declaration.traits) if declaration.traits
         end
 
         def call(_record)
@@ -31,24 +30,24 @@ module Clowne
 
         def clone_one(child)
           cloner = cloner_for(child)
-          cloner ? cloner.call(child, cloner_options) : clone_record(child)
+          cloner ? cloner.call(child, **cloner_options) : dup_record(child)
         end
 
         def with_scope
-          base_scope = init_scope
+          scope = declaration.scope
           if scope.is_a?(Symbol)
-            base_scope.__send__(scope)
+            init_scope.__send__(scope)
           elsif scope.is_a?(Proc)
-            base_scope.instance_exec(params, &scope) || base_scope
+            init_scope.instance_exec(params, &scope) || init_scope
           else
-            base_scope
+            init_scope
           end.to_a
         end
 
         private
 
-        def clone_record(_record)
-          raise NotImplementedError
+        def dup_record(record)
+          adapter.class.dup_record(record)
         end
 
         def init_scope
@@ -56,13 +55,23 @@ module Clowne
         end
 
         def cloner_for(child)
-          return clone_with if clone_with
+          return declaration.clone_with if declaration.clone_with
 
           return child.class.cloner_class if child.class.respond_to?(:cloner_class)
         end
 
-        attr_reader :source, :scope, :clone_with, :params, :association_name,
-                    :reflection, :cloner_options
+        def cloner_options
+          return @_cloner_options if defined?(@_cloner_options)
+
+          @_cloner_options = declaration.params_proxy.permit(
+            params: params, parent: source
+          ).tap do |options|
+            options[:adapter] = adapter
+            options.merge!(traits: declaration.traits) if declaration.traits
+          end
+        end
+
+        attr_reader :source, :declaration, :adapter, :params, :association_name, :reflection
       end
     end
   end