clone_kit 0.3.0

data/lib/clone_kit/rule.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module CloneKit
+  class Rule
+    def current_operation=(operation)
+      @shared_id_map = nil
+      @current_operation = operation
+    end
+
+    protected
+
+    attr_reader :current_operation
+
+    def operation_arguments
+      current_operation.arguments
+    end
+
+    def shared_id_map
+      @shared_id_map ||= CloneKit::SharedIdMap.new(current_operation.id)
+    end
+
+    def warn_event(message)
+      current_operation.warn(message)
+    end
+
+    def error_event(message)
+      current_operation.error(message)
+    end
+  end
+end

data/lib/clone_kit/rules/allow_only_mongoid_fields.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module CloneKit
+  module Rules
+    # The purpose of this rule is to only include attributes that are presently defined on the model
+    # (and its embedded models)
+    class AllowOnlyMongoidFields < CloneKit::Rule
+      def initialize(model_klass)
+        self.model_klass = model_klass
+      end
+
+      def fix(_old_id, attributes)
+        slice_allowed!(polymorphic_class(model_klass.to_s, attributes), attributes)
+      end
+
+      private
+
+      attr_accessor :model_klass
+
+      def slice_allowed!(klass, attributes)
+        return if attributes.nil?
+
+        attributes.slice!(*(klass.attribute_names + klass.embedded_relations.keys))
+
+        klass.embedded_relations.each do |name, metadata|
+          if metadata.macro == :embeds_many
+            Array.wrap(attributes[name]).each do |item|
+              slice_allowed!(polymorphic_class(metadata.class_name, item), item)
+            end
+          elsif !attributes[name].nil?
+            slice_allowed!(polymorphic_class(metadata.class_name, attributes[name]), attributes[name])
+          end
+        end
+      end
+
+      def polymorphic_class(class_name, item)
+        if item.key?("_type")
+          item["_type"]
+        else
+          class_name
+        end.constantize
+      end
+    end
+  end
+end

data/lib/clone_kit/rules/except.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module CloneKit
+  module Rules
+    class Except < CloneKit::Rule
+      def initialize(*attributes)
+        self.except_attributes = attributes
+      end
+
+      def fix(_old_id, attributes)
+        except_attributes.each do |key|
+          attributes.delete(key)
+        end
+      end
+
+      private
+
+      attr_accessor :except_attributes
+    end
+  end
+end

data/lib/clone_kit/rules/remap.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module CloneKit
+  module Rules
+    class Remap < CloneKit::Rule
+      def initialize(model_name, remap_hash = {})
+        self.remap_hash = remap_hash
+        self.model_name = model_name
+      end
+
+      def fix(_old_id, attributes)
+        remap_hash.each do |klass, remap_attributes|
+          Array.wrap(remap_attributes).each do |att|
+            next unless try?(attributes, att)
+
+            attributes[att] = if attributes[att].is_a?(Array)
+                                attributes[att].map { |id| remap(klass, id) unless id.blank? }.compact
+                              else
+                                remap(klass, attributes[att])
+                              end
+          end
+        end
+      end
+
+      protected
+
+      def remap(klass, old_id)
+        shared_id_map.lookup(klass, old_id)
+      rescue ArgumentError
+        error_event("#{model_name} missing remapped id for #{klass} #{old_id}")
+        nil
+      end
+
+      def try?(attributes, key)
+        attributes.key?(key) && !attributes[key].blank?
+      end
+
+      private
+
+      attr_accessor :remap_hash,
+                    :model_name
+    end
+  end
+end

data/lib/clone_kit/rules/safe_remap.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "clone_kit/rules/remap"
+
+module CloneKit
+  module Rules
+    class SafeRemap < Remap
+      def initialize(model_name, remap_hash = {}, safe_value = nil)
+        self.safe_value = safe_value
+        super(model_name, remap_hash)
+      end
+
+      protected
+
+      def remap(klass, old_id)
+        result = shared_id_map.lookup_safe(klass, old_id, safe_value)
+        warn_event("#{model_name} missing remapped id for #{klass}/#{old_id}") if result == safe_value
+        result
+      end
+
+      private
+
+      attr_accessor :safe_value
+    end
+  end
+end

data/lib/clone_kit/shared_id_map.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "redis"
+
+module CloneKit
+  class SharedIdMap
+    attr_reader :namespace
+
+    def initialize(namespace, redis: Redis.new)
+      self.namespace = namespace
+      self.redis = redis
+    end
+
+    def lookup(klass, original_id)
+      BSON::ObjectId.from_string(redis.hget(hash_key(klass), original_id.to_s))
+    rescue BSON::ObjectId::Invalid
+      raise ArgumentError, "No mapping found for #{klass}. This usually indicates a dependency has not be specified"
+    end
+
+    def lookup_safe(klass, original_id, default = nil)
+      val = redis.hget(hash_key(klass), original_id.to_s)
+      if val.blank?
+        default
+      else
+        BSON::ObjectId.from_string(val)
+      end
+    end
+
+    def insert(klass, original_id, new_id)
+      redis.hset(hash_key(klass), original_id.to_s, new_id.to_s)
+    end
+
+    def insert_many(klass, hash)
+      redis.pipelined do
+        hash.each do |k, v|
+          insert(klass, k, v)
+        end
+      end
+    end
+
+    def mapping(klass)
+      Hash[redis.hgetall(hash_key(klass)).map { |k, v| [k, v] }]
+    end
+
+    def hash_key(klass)
+      klass = klass.name if klass.is_a?(Class)
+      "clone_kit_id_map/#{namespace}/#{klass}"
+    end
+
+    private
+
+    attr_writer :namespace
+    attr_accessor :redis
+  end
+end

data/lib/clone_kit/specification.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "clone_kit/emitters/empty"
+require "clone_kit/cloners/no_op"
+
+module CloneKit
+  class SpecificationError < StandardError; end
+
+  class Specification
+    attr_accessor :model,
+                  :emitter,
+                  :cloner,
+                  :dependencies,
+                  :after_operation_block
+
+    EMPTY_EMITTER = Emitters::Empty.new
+    NO_OP_CLONER = Cloners::NoOp.new
+
+    def initialize(model, &block)
+      self.model = model
+      self.emitter = EMPTY_EMITTER
+      self.cloner = NO_OP_CLONER
+      self.dependencies = []
+      self.after_operation_block = -> (_op) {}
+
+      validate!
+
+      model.instance_exec(self, &block)
+
+      CloneKit.add_specification(self)
+    end
+
+    def after_operation(&block)
+      self.after_operation_block = block
+    end
+
+    private
+
+    def validate!
+      fail SpecificationError, "Model type not supported" unless mongoid_document?
+      fail SpecificationError, "Cannot clone embedded documents" if mongoid_embedded_document?
+    end
+
+    def mongoid_document?
+      defined?(Mongoid) && model < Mongoid::Document
+    end
+
+    def mongoid_embedded_document?
+      mongoid_document? && model.embedded?
+    end
+  end
+end

data/lib/clone_kit/strategies/synchronous.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module CloneKit
+  module Strategies
+    class Synchronous
+      def initialize(operation)
+        self.operation = operation
+      end
+
+      def all_batches_complete
+        # NOP
+      end
+
+      def clone_next_batch(model_specs, complete_handler)
+        model_specs.each do |spec|
+          spec.cloner.clone_ids(spec.emitter.scope(operation.arguments).pluck(:id), operation)
+        end
+
+        complete_handler.new.complete(
+          true,
+          "operation" => {
+            already_cloned: operation.already_cloned + model_specs.map(&:model).map(&:to_s),
+            id: operation.id,
+            arguments: operation.arguments,
+            strategy: CloneKit::Strategies::Synchronous
+          }
+        )
+      end
+
+      attr_accessor :operation
+    end
+  end
+end

data/lib/clone_kit/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module CloneKit
+  VERSION = "0.3.0"
+end

metadata

@@ -0,0 +1,227 @@
+--- !ruby/object:Gem::Specification
+name: clone_kit
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Brandon Croft
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-03-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.2
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.5.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.5.3
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: rspec-collection_matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fakeredis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Supports rules-based cloning, Mongoid, and distributed operations
+email:
+- brandon@kapost.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.kapost.yml"
+- ".rubocop.yml"
+- ".ruby-version"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- clone_kit.gemspec
+- lib/clone_kit.rb
+- lib/clone_kit/cloners/mongoid_merging_ruleset_cloner.rb
+- lib/clone_kit/cloners/mongoid_ruleset_cloner.rb
+- lib/clone_kit/cloners/no_op.rb
+- lib/clone_kit/decorators/embedded_cloner_decorator.rb
+- lib/clone_kit/emitters/empty.rb
+- lib/clone_kit/event_outlet.rb
+- lib/clone_kit/graph.rb
+- lib/clone_kit/merge_attributes_tool.rb
+- lib/clone_kit/operation.rb
+- lib/clone_kit/rule.rb
+- lib/clone_kit/rules/allow_only_mongoid_fields.rb
+- lib/clone_kit/rules/except.rb
+- lib/clone_kit/rules/remap.rb
+- lib/clone_kit/rules/safe_remap.rb
+- lib/clone_kit/shared_id_map.rb
+- lib/clone_kit/specification.rb
+- lib/clone_kit/strategies/synchronous.rb
+- lib/clone_kit/version.rb
+homepage: https://github.com/kapost/clone_kit
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: A toolkit to assist in complex cloning operations
+test_files: []