clone_kit 0.3.0

data/lib/clone_kit/cloners/mongoid_ruleset_cloner.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "clone_kit/rules/allow_only_mongoid_fields"
+require "clone_kit/decorators/embedded_cloner_decorator"
+
+module CloneKit
+  module Cloners
+    class MongoidRulesetCloner
+      attr_accessor :rules
+
+      def initialize(model_klass, rules: [])
+        self.model_klass = model_klass
+        self.rules = [
+          CloneKit::Rules::AllowOnlyMongoidFields.new(model_klass)
+        ] + rules
+      end
+
+      def clone_ids(ids, operation)
+        initialize_cloner(operation)
+
+        map = {}
+        result = []
+
+        each_existing_record(ids) do |attributes|
+          attributes = clone(attributes)
+          result << apply_rules_and_save(map, attributes)
+        end
+
+        CloneKit::SharedIdMap.new(operation.id).insert_many(model_klass, map)
+
+        result
+      end
+
+      protected
+
+      attr_accessor :model_klass,
+                    :current_operation
+
+      def clone(attributes)
+        attributes = attributes.deep_dup
+        clone_all_embedded_fields(attributes)
+        attributes
+      end
+
+      def clone_all_embedded_fields(attributes)
+        model_klass.embedded_relations.each do |name, metadata|
+          attributes[name] = clone_embedded_field(attributes[name], metadata)
+        end
+      end
+
+      def clone_embedded_field(item, metadata)
+        first_item = if item.is_a?(Array)
+                       item = item.compact
+                       item[0]
+                     else
+                       item
+                     end
+
+        return nil if first_item.nil?
+
+        cloner = MongoidRulesetCloner.new(polymorphic_class(metadata.class_name, first_item))
+        embedded_cloner = CloneKit::Decorators::EmbeddedClonerDecorator.new(cloner, records: Array.wrap(item))
+
+        embedded_attributes = embedded_cloner.clone_embedded(current_operation)
+
+        if metadata.macro == :embeds_many
+          embedded_attributes
+        else
+          embedded_attributes[0]
+        end
+      end
+
+      def apply_rules_and_save(mapping, attributes)
+        new_id = BSON::ObjectId.new
+        old_id = attributes["_id"]
+        mapping[attributes["_id"]] = new_id
+        attributes["_id"] = new_id
+
+        rules.each do |rule|
+          begin
+            rule.fix(old_id, attributes)
+          rescue StandardError => e
+            message = "Unhandled error when applying rule #{rule.class.name} to #{model_klass} #{new_id}: #{e.class}"
+            current_operation.error(message)
+          end
+        end
+
+        save_or_fail(attributes)
+        attributes
+      end
+
+      def save_or_fail(attributes)
+        document_klass = model_klass
+        document_klass = attributes["_type"].constantize if attributes.key?("_type")
+
+        model_that_we_wont_save = document_klass.new(attributes)
+
+        if model_that_we_wont_save.valid?
+          model_klass.collection.insert(attributes)
+        else
+          details = model_that_we_wont_save.errors.full_messages.to_sentence
+          id = attributes["_id"]
+          current_operation.error("#{model_klass} #{id} failed model validation and was not cloned: #{details}")
+        end
+      end
+
+      def each_existing_record(ids)
+        ids.each do |id|
+          record = model_klass.collection.find(_id: id).one
+          next if record.nil?
+
+          yield record
+        end
+      end
+
+      def initialize_cloner(operation)
+        @current_operation = operation
+
+        rules.each do |rule|
+          rule.current_operation = @current_operation
+        end
+      end
+
+      private
+
+      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/cloners/no_op.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module CloneKit
+  module Cloners
+    class NoOp
+      def clone_ids(_ids, _operation)
+        # NO_OP
+      end
+    end
+  end
+end

data/lib/clone_kit/decorators/embedded_cloner_decorator.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module CloneKit
+  module Decorators
+    class EmbeddedClonerDecorator < SimpleDelegator
+      attr_reader :records
+
+      def initialize(cloner, records:)
+        @records = records
+
+        cloner.define_singleton_method(:each_existing_record) do |ids, &block|
+          records.compact.select { |r| ids.include?(r["_id"]) }.each do |record|
+            block.call(record)
+          end
+        end
+
+        cloner.define_singleton_method(:save_or_fail) do |attributes|
+          # NOP
+        end
+
+        super(cloner)
+      end
+
+      def clone_embedded(operation)
+        clone_ids(records.compact.map { |r| r["_id"] }, operation)
+      end
+    end
+  end
+end

data/lib/clone_kit/emitters/empty.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module CloneKit
+  module Emitters
+    class Empty
+      def emit_all(_args)
+        []
+      end
+
+      def emit_each_range(_args, _page_size = 0)
+        # No yields
+      end
+    end
+  end
+end

data/lib/clone_kit/event_outlet.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module CloneKit
+  class EventOutlet
+    if defined?(Rails)
+      delegate :info, :warn, :error, to: :rails_logger
+    else
+      def info(message)
+        puts message
+      end
+
+      def warn(message)
+        puts message
+      end
+
+      def error(message)
+        puts message
+      end
+    end
+
+    private
+
+    def rails_logger
+      Rails.logger
+    end
+  end
+end

data/lib/clone_kit/graph.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "tsort"
+
+module CloneKit
+  class Graph
+    include TSort
+
+    def initialize
+      @vertices = {}
+    end
+
+    def nodes
+      tsort
+      @vertices
+    end
+
+    def include?(vertex)
+      @vertices.key?(vertex)
+    end
+
+    alias topological_sort tsort
+
+    def tsort_each_node(&block)
+      @vertices.each_key(&block)
+    end
+
+    def tsort_each_child(node, &block)
+      @vertices[node].each(&block)
+    end
+
+    def add_vertex(vertex, *neighbors)
+      existing = @vertices[vertex]
+
+      @vertices[vertex.to_s] = if existing.nil?
+                                 Array(neighbors).uniq
+                               else
+                                 (@vertices[vertex.to_s] + Array(neighbors)).uniq
+                               end
+
+      neighbors.each { |n| add_vertex(n) }
+    end
+  end
+end

data/lib/clone_kit/merge_attributes_tool.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module CloneKit
+  # Given an array of hashes representing records, this class is able to resolve
+  # values among them using a variety of strategies. The strategies all merge right-to-left,
+  # meaning that the last record is given precidence over the first.
+  #
+  # hashes
+  #   assigns to a target hash a list of hash attributes that are (deeply)
+  #   from the others
+  #
+  # arrays
+  #   assigns to a target hash a list of array attributes that are concatenated
+  #   and uniquified from the others
+  #
+  # cluster
+  #   assigns to a target hash a list of attributes that are copied from the first
+  #   record that returns true using the given block
+  #
+  # last
+  #   assigns to a target hash a list of attributes that are copied from the
+  #   last record
+  #
+  # any
+  #   assigns to a target hash a list of attributes from any other record where
+  #   that attribute is not blank.
+  #
+  # max/min
+  #   assigns to a target hash the maximum/minimum value from other records for each
+  #   from a list of attribute
+  #
+  class MergeAttributesTool
+    def initialize(mergeable)
+      self.mergeable = mergeable
+    end
+
+    def hashes(target, *attributes)
+      attributes.each do |att|
+        result = {}
+        mergeable.each do |m|
+          result = result.deep_merge(m[att])
+        end
+        target[att] = result
+      end
+    end
+
+    def arrays(target, *attributes)
+      attributes.each do |att|
+        new_val = mergeable.flat_map { |m| m[att] }.uniq
+        target[att] = new_val
+      end
+    end
+
+    def cluster(target, *attributes)
+      mergeable.reverse_each do |m|
+        next unless yield m
+
+        attributes.each do |att|
+          target[att] = m[att]
+        end
+        break
+      end
+    end
+
+    def last(target, *attributes)
+      attributes.each do |att|
+        target[att] = mergeable[-1][att]
+      end
+    end
+
+    def any(target, *attributes)
+      attributes.each do |att|
+        mergeable.reverse_each do |m|
+          val = m[att]
+          unless val.blank?
+            target[att] = val
+            break
+          end
+        end
+      end
+    end
+
+    def max(target, *attributes)
+      attributes.each do |att|
+        target[att] = mergeable.map { |m| m[att] }.compact.max
+      end
+    end
+
+    def min(target, *attributes)
+      attributes.each do |att|
+        target[att] = mergeable.map { |m| m[att] }.compact.min
+      end
+    end
+
+    private
+
+    attr_accessor :mergeable
+  end
+end

data/lib/clone_kit/operation.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require "securerandom"
+require "clone_kit/event_outlet"
+require "clone_kit/strategies/synchronous"
+
+module CloneKit
+  class Operation
+    extend Forwardable
+
+    attr_reader :id,
+                :arguments,
+                :already_cloned
+
+    def initialize(arguments: {},
+                   id: SecureRandom.uuid,
+                   already_cloned: [],
+                   strategy: Strategies::Synchronous,
+                   event_outlet: CloneKit::EventOutlet.new)
+      self.id = id
+      self.arguments = arguments
+      self.already_cloned = already_cloned
+      self.event_outlet = event_outlet
+      self.strategy = strategy.new(self)
+    end
+
+    def process
+      if next_batch.empty?
+        # Done!
+        after_process
+      elsif first_unspecified_model_dependency.present?
+        fail "A clone dependency was added for #{first_unspecified_model_dependency}, but it has no clone specification"
+      else
+        specs = next_batch.map { |model| CloneKit.spec[model] }
+        strategy.clone_next_batch(specs, BatchCompleteHandler)
+      end
+    end
+
+    def_delegators :event_outlet, :info, :warn, :error
+
+    private
+
+    attr_accessor :strategy,
+                  :event_outlet
+
+    attr_writer :id,
+                :arguments,
+                :already_cloned
+
+    def after_process
+      CloneKit.graph.nodes.each do |model, _|
+        CloneKit.spec[model].after_operation_block.call(self)
+      end
+
+      strategy.all_batches_complete
+    end
+
+    def next_batch
+      @next_batch ||= CloneKit.cloneable_models(already_cloned)
+    end
+
+    def first_unspecified_model_dependency
+      next_batch.detect { |model| CloneKit.spec[model].nil? }
+    end
+
+    class BatchCompleteHandler
+      def complete(success, options)
+        op = Operation.new(options.fetch("operation"))
+
+        if success
+          op.process
+        else
+          op.error(options.fetch("failure_message", "Unknown error"))
+        end
+      end
+    end
+  end
+end