clowne 0.1.0.pre1 → 1.2.0

data/docs/traits.md

@@ -0,0 +1,25 @@
+# Traits
+
+Traits allow you to group cloner declarations together and then apply them (like in [`factory_bot`](https://github.com/thoughtbot/factory_bot)):
+
+```ruby
+class UserCloner < Clowne::Cloner
+  trait :with_posts do
+    include_association :posts
+  end
+
+  trait :with_profile do
+    include_association :profile
+  end
+
+  trait :nullify_name do
+    nullify :name
+  end
+end
+
+UserCloner.call(user, traits: %i[with_posts with_profile nullify_name])
+# or
+UserCloner.call(user, traits: :nullify_name)
+# or
+# ...
+```

data/gemfiles/activerecord42.gemfile

@@ -1,6 +1,9 @@
-source 'https://rubygems.org'
+# frozen_string_literal: true
 
-gem 'activerecord', '~> 4.2'
-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,6 +1,10 @@
-source 'https://rubygems.org'
+# frozen_string_literal: true
 
-gem 'activerecord-jdbcsqlite3-adapter', '~> 50.0'
-gem 'activerecord', '~> 5.0.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,7 +1,10 @@
-source 'https://rubygems.org'
+# frozen_string_literal: true
 
-gem 'arel', github: 'rails/arel'
-gem 'rails', github: 'rails/rails'
-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,18 +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'
+    base:          "Base",
+    active_record: "ActiveRecord",
+    sequel:        "Sequel",
   }.freeze
+  # rubocop:enable Layout/AlignHash
 
   class << self
     attr_reader :default_adapter, :raise_on_override
@@ -28,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
@@ -36,4 +40,5 @@ module Clowne
   end
 end
 
-require 'clowne/adapters/active_record' if defined?(::ActiveRecord)
+require "clowne/adapters/active_record" if defined?(::ActiveRecord)
+require "clowne/adapters/sequel" if defined?(::Sequel)

data/lib/clowne/adapters/active_record.rb

@@ -1,27 +1,17 @@
 # frozen_string_literal: true
 
+require "clowne/ext/orm_ext"
+
 module Clowne
   module Adapters
     # Cloning adapter for ActiveRecord
-    class ActiveRecord < Base
-      # Adds #cloner_class method to ActiveRecord::Base
-      module ActiveRecordExt
-        def cloner_class
-          return @_clowne_cloner if instance_variable_defined?(:@_clowne_cloner)
-
-          cloner = "#{name}Cloner".safe_constantize
-          return @_clowne_cloner = cloner if cloner && cloner <= Clowne::Cloner
-
-          @_clowne_cloner = superclass.cloner_class if superclass.respond_to?(:cloner_class)
-        end
-      end
-    end
+    class ActiveRecord < Base; end
   end
 end
 
 ActiveSupport.on_load(:active_record) do
-  ::ActiveRecord::Base.extend Clowne::Adapters::ActiveRecord::ActiveRecordExt
+  ::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,61 +1,17 @@
 # frozen_string_literal: true
 
+require "clowne/adapters/base/association"
+
 module Clowne
   module Adapters # :nodoc: all
     class ActiveRecord
       module Associations
-        class Base
-          # Params:
-          # +reflection+:: Association eflection object
-          # +source+:: Instance of cloned object (ex: User.new(posts: posts))
-          # +declaration+:: = Relation description
-          #                   (ex: Clowne::Declarations::IncludeAssociation.new(:posts))
-          # +params+:: = Instance of Clowne::Params
-          def initialize(reflection, source, declaration, params)
-            @source = source
-            @scope = declaration.scope
-            @clone_with = declaration.clone_with
-            @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)
-            raise NotImplementedError
-          end
-
-          def association
-            @_association ||= source.__send__(association_name)
-          end
-
-          def clone_one(child)
-            cloner = cloner_for(child)
-            cloner ? cloner.call(child, cloner_options) : child.dup
-          end
-
-          def with_scope
-            base_scope = association
-            if scope.is_a?(Symbol)
-              base_scope.__send__(scope)
-            elsif scope.is_a?(Proc)
-              base_scope.instance_exec(params, &scope) || base_scope
-            else
-              base_scope
-            end
-          end
-
+        class Base < Base::Association
           private
 
-          def cloner_for(child)
-            return clone_with if clone_with
-
-            return child.class.cloner_class if child.class.respond_to?(:cloner_class)
+          def init_scope
+            association
           end
-
-          attr_reader :source, :scope, :clone_with, :params, :association_name,
-                      :reflection, :cloner_options
         end
       end
     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

@@ -5,10 +5,17 @@ module Clowne
     class ActiveRecord
       module Associations
         class HasOne < Base
+          # rubocop: disable Metrics/MethodLength
           def call(record)
             child = association
             return record unless child
-            warn '[Clowne] Has one association does not support scopes' unless scope.nil?
+
+            unless declaration.scope.nil?
+              warn(
+                "[Clowne] Has one association does not support scopes " \
+                "(#{@association_name} for #{@source.class})"
+              )
+            end
 
             child_clone = clone_one(child)
             child_clone[:"#{reflection.foreign_key}"] = nil
@@ -16,6 +23,7 @@ module Clowne
 
             record
           end
+          # rubocop: enable Metrics/MethodLength
         end
       end
     end

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

@@ -6,7 +6,10 @@ module Clowne
       module Associations
         class Noop < Base
           def call(record)
-            warn("[Clowne] Reflection #{reflection.class.name} is not supported")
+            warn(
+              "[Clowne] Reflection #{reflection.class.name} is not supported "\
+              "(#{@association_name} for #{@source.class})"
+            )
             record
           end
         end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Adapters
+    # Extend ActiveRecord with Clowne DSL and methods
+    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)
+        end
+      end
+
+      module ClassMethods # :nodoc:
+        def clowne_config(options = {}, &block)
+          if options.delete(:inherit) != false && superclass.respond_to?(:cloner_class)
+            parent_cloner = superclass.cloner_class
+          end
+
+          parent_cloner ||= Clowne::Cloner
+          cloner = instance_variable_set(:@_clowne_cloner, Class.new(parent_cloner))
+          cloner.adapter :active_record
+          cloner.instance_exec(&block)
+        end
+      end
+    end
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  ::ActiveRecord::Base.extend Clowne::Adapters::ActiveRecordDSL::ClassMethods
+  ::ActiveRecord::Base.include Clowne::Adapters::ActiveRecordDSL::InstanceMethods
+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,45 +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
-
-        def register_resolver(type, resolver, after: nil, before: nil)
-          registry.mapping[type] = resolver
+      include Clowne::Adapters::Registry::Container
 
-          if 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
@@ -48,22 +39,43 @@ module Clowne
       # +params+:: Custom params hash
       def clone(source, plan, params: {})
         declarations = plan.declarations
-        declarations.inject(clone_record(source)) do |record, (type, declaration)|
-          resolver_for(type).call(source, record, declaration, params: params)
-        end
-      end
+        init_record = init_record(self.class.dup_record(source))
 
-      def resolver_for(type)
-        self.class.resolver_for(type)
+        declarations.inject(init_record) do |record, (type, declaration)|
+          resolver_for(type).call(source, record, declaration, params: params, adapter: self)
+        end
       end
 
-      # Return #dup if any
-      def clone_record(source)
-        source.dup
+      def init_record(record)
+        # Override in custom adapters
+        record
       end
     end
   end
 end
 
-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
+)