copyable 0.0.1

data/lib/copyable/saver.rb

@@ -0,0 +1,19 @@
+module Copyable
+  class Saver
+
+    # this is the algorithm for saving the new record
+    def self.save!(new_model, skip_validations)
+      unless skip_validations
+        ModelHooks.reenable!(new_model.class) # we must re-enable or validation does not work
+        if !new_model.valid?(:create)
+          ModelHooks.disable!(new_model.class)
+          raise(ActiveRecord::RecordInvalid.new(new_model))
+        else
+          ModelHooks.disable!(new_model.class)
+        end
+      end
+      new_model.save!
+    end
+
+  end
+end

data/lib/copyable/single_copy_enforcer.rb

@@ -0,0 +1,68 @@
+# When we call some_model.create_copy! and we wish to copy the associated
+# has_many models, we could end up copying a complex tree of models since
+# create_copy! will be called on each associated model.
+#
+# Consider a data model where an owner can have many vehicles and a vehicle
+# can have many amenities.  If an owner has a car with two amenities, the
+# models may look like this:
+#
+#                     +-------------+
+#                     |    OWNER    |
+#                     +------^------+
+#                            |
+#                            |
+#                            |
+#                     +------+------+
+#                     |   VEHICLE   |
+#                     +--^-------^--+
+#                        |       |
+#                        |       |
+#                        |       |
+#             +--+-------+-+   +-+-------+--+
+#             |  AMENITY   |   |  AMENITY   |
+#             +------------+   +------------+
+#
+# If we call owner.create_copy!, and the copyable declaration of the Owner
+# class and the Vehicle class instruct us to make copies of the associated
+# models, we will end up with a new owner model, which has a new vehicle model,
+# which has two new amenity models.  The whole tree structure gets copied.
+#
+# Now here's a twist.  Consider the data model is not well normalized in that
+# even though an amenity belongs to a vehicle which belongs to an owner,
+# there is a redundant belongs to relationship between an amenity and an owner.
+# So an owner can know his amenities through his vehicles or directly:
+#
+#                     +-------------+
+#                +---->    OWNER    <----+
+#                |    +------^------+    |
+#                |           |           |
+#                |           |           |
+#                |           |           |
+#                |    +------+------+    |
+#                |    |   VEHICLE   |    |
+#                |    +--^-------^--+    |
+#                |       |       |       |
+#                |       |       |       |
+#                |       |       |       |
+#             +--+-------+-+   +-+-------+--+
+#             |  AMENITY   |   |  AMENITY   |
+#             +------------+   +------------+
+#
+# Now, a copying algorithm that treats this as a "tree" and simply walks through
+# the associations will end up creating too many amenity records because it
+# will copy the amenities belonging to the owner and then the amenities
+# belonging to the vehicle (which are the same amenities).
+#
+# Therefore, we need a way to keep track of records we have already duplicated
+# so that we don't duplicate them again in the database.  The CopyRegistry
+# class keeps track of what we've already copied, and the SingleCopyEnforcer
+# simply tells us whether we can go ahead and duplicate a record in the
+# database (because it hasn't been duplicated yet).
+
+module Copyable
+  class SingleCopyEnforcer
+    def self.can_copy?(record)
+      !CopyRegistry.already_copied?(record: record)
+    end
+  end
+end

data/lib/copyable/syntax_checking/association_checker.rb

@@ -0,0 +1,41 @@
+module Copyable
+  class AssociationChecker < Copyable::CompletenessChecker
+
+    def associations(associations)
+      @associations = associations.keys.map(&:to_s)
+    end
+
+    private
+
+    def expected_entries
+      all_associations = model_class.reflect_on_all_associations
+      required_associations = all_associations.select do |ass|
+        (ass.macro != :belongs_to) && ass.options[:through].blank?
+      end
+      required_associations.map(&:name).map(&:to_s)
+    end
+
+    def provided_entries
+      @associations
+    end
+
+    def missing_entries_found(missing_entries)
+      message = "The following associations were not listed "
+      message << "in copyable's associations in the model '#{model_class.name}':\n"
+      missing_entries.each {|ass| message << "  association: #{ass}\n" }
+      message << "Basically, if you just added a new association to this model, you need to update "
+      message << "the copyable declaration to instruct it how to deal with copying the associated models.\n"
+      raise AssociationError.new(message)
+    end
+
+    def extra_entries_found(extra_entries)
+      message = "The following associations were listed in copyable's associations in the model '#{model_class.name}' "
+      message << "but are either (1) not actually associations on this model or "
+      message << "(2) an association that does not need to be listed "
+      message << "(belongs to, has many through, or has one through):\n"
+      extra_entries.each {|ass| message << "  association: #{ass}\n" }
+      raise AssociationError.new(message)
+    end
+
+  end
+end

data/lib/copyable/syntax_checking/column_checker.rb

@@ -0,0 +1,43 @@
+module Copyable
+  class ColumnChecker < Copyable::CompletenessChecker
+
+    def columns(columns)
+      @columns = columns.keys.map(&:to_s)
+    end
+
+    private
+
+    def columns_to_skip
+      ['id', 'created_at', 'updated_at', 'created_on', 'updated_on']
+    end
+
+    def expected_entries
+      columns_in_database = model_class.column_names
+      columns_in_database -= columns_to_skip
+      columns_in_database
+    end
+
+    def provided_entries
+      @columns
+    end
+
+    def missing_entries_found(missing_entries)
+      message = "The following columns were found in the database table '#{model_class.table_name}' "
+      message << "but not found in copyable's columns in the model '#{model_class.name}':\n"
+      missing_entries.each {|c| message << "  column: #{c}\n" }
+      message << "Basically, if you just added columns to this database table, you need to update "
+      message << "the copyable declaration to instruct it how to copy the new columns.\n"
+      raise ColumnError.new(message)
+    end
+
+    def extra_entries_found(extra_entries)
+      message = "The following columns were found in copyable's columns in the model '#{model_class.name}' "
+      message << "but not found in the database table '#{model_class.table_name}':\n"
+      extra_entries.each {|c| message << "  column: #{c}\n" }
+      message << "Note that the #{columns_to_skip.join(', ')} columns are handled "
+      message << "automatically and should not be listed.\n"
+      raise ColumnError.new(message)
+    end
+
+  end
+end

data/lib/copyable/syntax_checking/completeness_checker.rb

@@ -0,0 +1,27 @@
+module Copyable
+  class CompletenessChecker
+
+    include DeclarationStubber
+
+    def initialize(model_class)
+      @model_class = model_class
+    end
+
+    # an algorithm for ensuring that the expected entries are listed
+    # in a declaration -- no more, and no less
+    def verify!(block)
+      self.instance_eval(&block)
+      expected = Set.new(expected_entries)
+      provided = Set.new(provided_entries)
+      missing_entries = expected - provided
+      extra_entries = provided - expected
+      missing_entries_found(missing_entries) if missing_entries.any?
+      extra_entries_found(extra_entries) if extra_entries.any?
+    end
+
+    private
+
+    def model_class; @model_class; end
+
+  end
+end

data/lib/copyable/syntax_checking/declaration_checker.rb

@@ -0,0 +1,26 @@
+module Copyable
+  class DeclarationChecker
+
+    def verify!(declaration_block)
+      @declarations_that_were_called = []
+      self.instance_eval(&declaration_block)
+
+      Copyable::Declarations::ALL.each do |declaration|
+        if declaration.required? && !@declarations_that_were_called.include?(declaration.method_name)
+          message = "The copyable declaration must include #{declaration.name}."
+          raise DeclarationError.new(message)
+        end
+      end
+    end
+
+    def method_missing(method_name, *args, &block)
+      method = method_name.to_s
+      if Copyable::Declarations.include?(method)
+        @declarations_that_were_called << method
+      else
+        raise DeclarationError.new("Unknown declaration '#{method}' in copyable.")
+      end
+    end
+
+  end
+end

data/lib/copyable/syntax_checking/declaration_stubber.rb

@@ -0,0 +1,18 @@
+module Copyable
+  module DeclarationStubber
+
+    # This creates dummy methods for each declaration, which is useful
+    # if you are creating a class that merely wants to check that
+    # a particular declaration is called correctly.  It's useful to
+    # have the other declarations that you don't care about available
+    # as stubs.
+    def self.included(klass)
+      Declarations::ALL.each do |decl|
+        klass.send(:define_method, decl.method_name) do |*args|
+          # intentionally empty
+        end
+      end
+    end
+
+  end
+end

data/lib/copyable/syntax_checking/syntax_checker.rb

@@ -0,0 +1,15 @@
+module Copyable
+  class SyntaxChecker
+
+    def self.check!(model_class, declaration_block)
+      raise CopyableError.new("You must pass copyable a block") if declaration_block.nil?
+      declaration_checker = DeclarationChecker.new
+      declaration_checker.verify!(declaration_block)
+      column_checker = ColumnChecker.new(model_class)
+      column_checker.verify!(declaration_block)
+      association_checker = AssociationChecker.new(model_class)
+      association_checker.verify!(declaration_block)
+    end
+
+  end
+end

data/lib/copyable/version.rb

@@ -0,0 +1,3 @@
+module Copyable
+  VERSION = "0.0.1"
+end

data/lib/tasks/copyable.rake

@@ -0,0 +1,55 @@
+# This is just a quick-and-dirty convenience task that will output a
+# default copyable declaration based on the columns and associations
+# of a given model.  It saves you some typing when adding a new
+# copyable declaration to a model.
+#
+#   $ rake copyable model=ModelClassName
+#
+desc "generate a copyable declaration for a model"
+task :copyable => :environment do
+
+  if ENV['model'].blank?
+    puts "Usage:  rake copyable model=ModelClassName"
+    exit
+  end
+
+  begin
+    model_class = ENV['model'].constantize
+  rescue NameError
+    puts "Error: unknown model '#{ENV['model']}'"
+    puts "aborting"
+    exit
+  end
+
+  puts
+  puts "copyable do"
+  puts "  disable_all_callbacks_and_observers_except_validate"
+  puts "  columns({"
+
+  columns = model_class.column_names - ['id', 'created_at', 'updated_at', 'created_on', 'updated_on']
+  max_length = columns.map(&:length).max
+  columns.sort.each do |column|
+    column += ":"
+    column = column.ljust(max_length+1)
+    puts "    #{column}  :copy,"
+  end
+
+  puts "  })"
+  puts "  associations({"
+
+  all_associations = model_class.reflect_on_all_associations
+  required_associations = all_associations.select do |ass|
+    (ass.macro != :belongs_to) && ass.options[:through].blank?
+  end
+  associations = required_associations.map(&:name).map(&:to_s)
+  max_length = associations.map(&:length).max
+  associations.sort.each do |ass|
+    ass += ":"
+    ass = ass.ljust(max_length+1)
+    puts "    #{ass}  :copy,"
+  end
+
+  puts "  })"
+  puts "end"
+  puts
+end

data/spec/config_spec.rb

@@ -0,0 +1,132 @@
+require_relative 'helper/copyable_spec_helper'
+
+describe 'Copyable.config' do
+  it 'should be defined' do
+    expect(Copyable).to respond_to(:config)
+  end
+
+  describe 'suppress_schema_errors' do
+    it 'should default to false' do
+      expect(Copyable.config.suppress_schema_errors).to be_falsey
+    end
+
+    it 'should be changeable' do
+      Copyable.config.suppress_schema_errors = true
+      expect(Copyable.config.suppress_schema_errors).to be_truthy
+      Copyable.config.suppress_schema_errors = false
+    end
+
+    context 'when set to true' do
+      before(:each) do
+        Copyable.config.suppress_schema_errors = true
+      end
+
+      after(:each) do
+        Copyable.config.suppress_schema_errors = false
+      end
+
+      context 'when missing columns' do
+        before(:each) do
+          @model_definition = lambda do
+            undefine_copyable_in CopyableCoin
+            class CopyableCoin < ActiveRecord::Base
+              copyable do
+                disable_all_callbacks_and_observers_except_validate
+                columns({
+                  kind:  :copy,
+                })
+                associations({
+                })
+              end
+            end
+          end
+        end
+
+        it 'should not throw an error' do
+          expect(@model_definition).to_not raise_error
+        end
+      end
+
+      context 'with unknown columns' do
+        before(:each) do
+          @model_definition = lambda do
+            undefine_copyable_in CopyableCoin
+            class CopyableCoin < ActiveRecord::Base
+              copyable do
+                disable_all_callbacks_and_observers_except_validate
+                columns({
+                  what_is_this_column_doing_here:  :copy,
+                  kind:                            :copy,
+                  year:                            :copy,
+                })
+                associations({
+                })
+              end
+            end
+          end
+        end
+
+        it 'should not throw an error' do
+          expect(@model_definition).to_not raise_error
+        end
+      end
+
+      context 'when missing associations' do
+        before(:each) do
+          @model_definition = lambda do
+            class CopyablePet < ActiveRecord::Base
+              copyable do
+                disable_all_callbacks_and_observers_except_validate
+                columns({
+                  name:        :copy,
+                  kind:        :copy,
+                  birth_year:  :copy,
+                })
+                associations({
+                  # MISSING copyable_toys:                    :copy,
+                  copyable_pet_tag:                 :copy,
+                  copyable_pet_profile:             :copy,
+                  copyable_pet_foods:               :copy,
+                  copyable_pet_sitting_patronages:  :copy,
+                })
+              end
+            end
+          end
+        end
+
+        it 'should not throw an error' do
+          expect(@model_definition).to_not raise_error
+        end
+      end
+
+      context 'with unknown associations' do
+        before(:each) do
+          @model_definition = lambda do
+            class CopyablePet < ActiveRecord::Base
+              copyable do
+                disable_all_callbacks_and_observers_except_validate
+                columns({
+                  name:        :copy,
+                  kind:        :copy,
+                  birth_year:  :copy,
+                })
+                associations({
+                  this_assoc_should_not_be_here:    :copy,
+                  copyable_toys:                    :copy,
+                  copyable_pet_tag:                 :copy,
+                  copyable_pet_profile:             :copy,
+                  copyable_pet_foods:               :copy,
+                  copyable_pet_sitting_patronages:  :copy,
+                })
+              end
+            end
+          end
+        end
+
+        it 'should not throw an error' do
+          expect(@model_definition).to_not raise_error
+        end
+      end
+    end
+  end
+end