clowne 0.0.1 → 0.1.0.beta1

data/Rakefile

@@ -1,10 +1,8 @@
-require "bundler/gem_tasks"
-require "rake/testtask"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
 
-Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
-  t.test_files = FileList["test/**/*_test.rb"]
-end
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new
 
-task :default => :test
+task default: [:rubocop, :spec]

data/clowne.gemspec

@@ -1,27 +1,28 @@
-# coding: utf-8
-lib = File.expand_path("../lib", __FILE__)
+lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "clowne/version"
+require 'clowne/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "clowne"
+  spec.name          = 'clowne'
   spec.version       = Clowne::VERSION
-  spec.authors       = ["Vladimir Dementyev"]
-  spec.email         = ["dementiev.vm@gmail.com"]
+  spec.authors       = ['Vladimir Dementyev', 'Sverchkov Nikolay']
+  spec.email         = ['palkan@evilmartians.com', 'ssnikolay@gmail.com']
 
-  spec.summary       = "Declarative models cloning"
-  spec.description   = "Declarative models cloning"
-  spec.homepage      = "https://github.com/palkan/clowne"
-  spec.license       = "MIT"
+  spec.summary       = 'A flexible gem for cloning your models.'
+  spec.description   = 'A flexible gem for cloning your models.'
+  spec.homepage      = 'https://github.com/palkan/clowne'
+  spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^(test|spec|features)/})
   end
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 1.15"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency 'bundler', '~> 1.14'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'factory_bot', '~> 4.8'
+  spec.add_development_dependency 'rubocop', '~> 0.51'
 end

data/gemfiles/activerecord42.gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem 'activerecord', '~> 4.2'
+gem 'sqlite3'
+
+gemspec path: '..'

data/gemfiles/jruby.gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem 'activerecord-jdbcsqlite3-adapter', '~> 50.0'
+gem 'activerecord', '~> 5.0.0'
+
+gemspec path: '..'

data/gemfiles/railsmaster.gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gem 'arel', github: 'rails/arel'
+gem 'rails', github: 'rails/rails'
+gem 'sqlite3'
+
+gemspec path: '..'

data/lib/clowne.rb

@@ -1,5 +1,39 @@
-require "clowne/version"
+# frozen_string_literal: true
 
+require 'clowne/version'
+require 'clowne/declarations'
+require 'clowne/cloner'
+
+require 'clowne/adapters/base'
+
+# Declarative models cloning
 module Clowne
-  # Your code goes here...
+  # List of built-in adapters
+  ADAPTERS = {
+    base:          'Base',
+    active_record: 'ActiveRecord'
+  }.freeze
+
+  class << self
+    attr_reader :default_adapter, :raise_on_override
+
+    # Set default adapters for all cloners
+    def default_adapter=(adapter)
+      @default_adapter = resolve_adapter(adapter)
+    end
+
+    def resolve_adapter(adapter)
+      if adapter.is_a?(Class)
+        adapter.new
+      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
+      end
+    end
+  end
 end
+
+require 'clowne/adapters/active_record' if defined?(::ActiveRecord)

data/lib/clowne/adapters/active_record.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+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
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  ::ActiveRecord::Base.extend Clowne::Adapters::ActiveRecord::ActiveRecordExt
+end
+
+require 'clowne/adapters/active_record/associations'
+require 'clowne/adapters/active_record/association'

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Adapters # :nodoc: all
+    class ActiveRecord
+      class UnknownAssociation < StandardError; end
+
+      class Association
+        class << self
+          def call(source, record, declaration, params:)
+            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, params).call(record)
+
+            record
+          end
+        end
+      end
+    end
+  end
+end
+
+Clowne::Adapters::ActiveRecord.register_resolver(
+  :association,
+  Clowne::Adapters::ActiveRecord::Association,
+  before: :nullify
+)

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

@@ -0,0 +1,30 @@
+# 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'
+
+module Clowne
+  module Adapters # :nodoc: all
+    class ActiveRecord
+      module Associations
+        AR_2_CLONER = {
+          has_one: HasOne,
+          has_many: HasMany,
+          has_and_belongs_to_many: HABTM
+        }.freeze
+
+        # Returns an association cloner class for reflection
+        def self.cloner_for(reflection)
+          if reflection.is_a?(::ActiveRecord::Reflection::ThroughReflection)
+            Noop
+          else
+            AR_2_CLONER.fetch(reflection.macro, Noop)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+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
+
+          private
+
+          def cloner_for(child)
+            return clone_with if 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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Adapters # :nodoc: all
+    class ActiveRecord
+      module Associations
+        class HABTM < Base
+          def call(record)
+            with_scope.each do |child|
+              child_clone = clone_one(child)
+              record.__send__(association_name) << child_clone
+            end
+
+            record
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Adapters # :nodoc: all
+    class ActiveRecord
+      module Associations
+        class HasMany < Base
+          def call(record)
+            with_scope.each do |child|
+              child_clone = clone_one(child)
+              child_clone[:"#{reflection.foreign_key}"] = nil
+              record.__send__(association_name) << child_clone
+            end
+
+            record
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Adapters # :nodoc: all
+    class ActiveRecord
+      module Associations
+        class HasOne < Base
+          # rubocop: disable Metrics/MethodLength
+          def call(record)
+            child = association
+            return record unless child
+            unless 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
+            record.__send__(:"#{association_name}=", child_clone)
+
+            record
+          end
+          # rubocop: enable Metrics/MethodLength
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Adapters # :nodoc: all
+    class ActiveRecord
+      module Associations
+        class Noop < Base
+          def call(record)
+            warn(
+              "[Clowne] Reflection #{reflection.class.name} is not supported "\
+              "(#{@association_name} for #{@source.class})"
+            )
+            record
+          end
+        end
+      end
+    end
+  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)
+          self.class.cloner_class.call(self, *args)
+        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/base.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'clowne/adapters/registry'
+
+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
+
+          if after
+            registry.insert_after after, type
+          elsif before
+            registry.insert_before before, type
+          else
+            registry.append type
+          end
+        end
+
+        protected
+
+        attr_writer :registry
+      end
+
+      self.registry = Registry.new
+
+      def registry
+        self.class.registry
+      end
+
+      # Using a plan make full duplicate of record
+      # +source+:: Instance of cloned object (ex: User.new(posts: posts))
+      # +plan+:: Array of Declarations
+      # +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
+
+      def resolver_for(type)
+        self.class.resolver_for(type)
+      end
+
+      # Return #dup if any
+      def clone_record(source)
+        source.dup
+      end
+    end
+  end
+end
+
+require 'clowne/adapters/base/nullify'
+require 'clowne/adapters/base/finalize'