harmonize 0.0.2 → 0.0.3

data/Gemfile

@@ -1,13 +1,29 @@
 source "http://rubygems.org"
-
-gem 'rails', '3.0.9'
-gem 'hashie'
+gemspec
 
 group :development, :test, :console do
-  gem 'sqlite3'
+  #gem 'rails', '3.0.10'
+  #gem 'rails', '3.1.1'
+  #gem 'activerecord', '3.1.1', :require => 'active_record'
+  #gem 'activerecord', '3.0.10', :require => 'active_record'
+  #gem 'sqlite3'
+  gem 'mongoid'
+  gem 'bson_ext'
   gem 'rspec-rails', '~> 2'
-  gem 'ruby-debug19', :require => 'ruby-debug'
   gem 'capybara', '~> 1'
   gem 'database_cleaner'
-  gem 'factory_girl_rails'
+  gem 'factory_girl'
+  gem 'rake'
+end
+
+platform :mri_18 do
+  group :development do
+    gem 'ruby-debug'
+  end
+end
+
+platform :mri_19 do
+  group :development do
+    gem 'ruby-debug19', :require => 'ruby-debug' unless RUBY_VERSION == '1.9.3'
+  end
 end

data/README.md

@@ -32,7 +32,7 @@ Lets pretend we work for a company that has a large list of stores. This list of
       end
     end
 
-With our Store model wired up as above, we will get a new class method on our model called "harmonize\_default!". When we call harmonize\_default! harmonize will use the default strategy to harmonize the source records with the target records. In order to understand what actions are taken to bring the targets into harmony, we need to understand Harmonize::Strategies, but that is getting us ahead of ourselves. First lets look at how we configure harmonize.
+With our Store model wired up as above, we will get a new class method on our model called "harmonize\_default!". When we call harmonize\_default! harmonize will use the default strategy to harmonize the source records with the target records. In order to understand what actions are taken to bring the targets into harmony, we need to understand Harmonize::Strategies -- but we're getting ahead of ourselves. First, let's look at how to configure harmonize.
 
 ## Harmonize::Configuration
 
@@ -49,9 +49,9 @@ Each call to harmonize creates a Harmonize::Configuration instance that defines
       end
     end
 
-### Harmonizer::Configuration.harmonizer\_name
+### Harmonize::Configuration.harmonizer\_name
 
-harmonize uses the configured harmonize\_name as the name of the harmonizer being configured. Each harmonize\_name may only be used once. This allows the harmonize method to be called more than once per model. This option is used to name special methods used by harmonize. The harmonization method is named with the following convention: "harmonize\_#{harmonizer\_name}!".
+harmonize uses the configured harmonizer\_name as the name of the harmonizer being configured. Each harmonizer\_name may only be used once. This allows the harmonize method to be called more than once per model. This option is used to name special methods used by harmonize. The harmonization method is named with the following convention: "harmonize\_#{harmonizer\_name}!".
 
 The default setting is:
 
@@ -59,7 +59,7 @@ The default setting is:
 
 This setting can be any symbol.
 
-### Harmonizer::Configuration.key
+### Harmonize::Configuration.key
 
 harmonize uses the configured key to determine what attribute in the source data feed to use to find existing target records.
 
@@ -69,7 +69,7 @@ The default setting is:
 
 This setting can be any attribute that will be found in source records.
 
-### Harmonizer::Configuration.source
+### Harmonize::Configuration.source
 
 harmonize uses the configured source to gather the latest set of source records. This can be set to a lambda or any other callable object. The only requirement is that it returns a collection of hash like objects. By default this setting calls a method name with the following convention: "harmonize\_source\_#{harmonizer\_name}".
 
@@ -79,7 +79,7 @@ The default setting is:
 
 This setting can be any class method defined in the model that returns properly structured data.
 
-### Harmonizer::Configuration.target
+### Harmonize::Configuration.target
 
 harmonize uses the configured target to gather the latest set of target records. This can be set to a lambda or any other callable object. The only requirement is that it returns an ActiveRecord::Relation. Hint, all (named) scopes return ActiveRecord::Relation instances.
 
@@ -89,7 +89,7 @@ The default setting is:
 
 This setting can be any class method defined in the model that returns an ActiveRecord::Relation.
 
-### Harmonizer::Configuration.strategy
+### Harmonize::Configuration.strategy
 
 harmonize uses the configured strategy to determine which Harmonize::Strategies::Strategy subclass to use when harmonizing. harmonize uses this setting as well as the strategy\_arguments setting to create an instance of the Strategy subclass.
 
@@ -99,7 +99,7 @@ The default setting is:
 
 This setting can be any class that returns complies with the Strategy api.
 
-### Harmonizer::Configuration.target
+### Harmonize::Configuration.target
 
 harmonize uses the configured strategy\_arguments to determine which arguments to use when initializing the set Harmonize::Strategies::Strategy subclass.
 
@@ -158,11 +158,11 @@ Use, report bugs, fix them, and send pull requests!
 
 ## TODO
 
-*  Maybe move key from Configuration to a strategy\_argument as it is not a configuration option really, but a way to change stratgey behaviour.
+*  Maybe move key from Configuration to a strategy\_argument as it is not a configuration option really, but a way to change strategy behaviour.
 
 ## Contributors
 
-*  Bram Swenson <bram@craniumisjar.com>
+*  Bram Swenson <bram@craniumisajar.com>
 
 ## Notes
 

data/Rakefile

@@ -7,25 +7,19 @@ rescue LoadError
 end
 
 require 'rake'
+if defined?(Rails)
+  APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+  load    'rails/tasks/engine.rake'
+end
+
 require 'rspec/core'
 require 'rspec/core/rake_task'
 require 'bundler/gem_tasks'
 
-namespace :test do
-  RSpec::Core::RakeTask.new(:spec)
-  desc 'Setup the test database'
-  task :dbsetup do
-    results = %x(
-      cd spec/dummy &&
-      rm db/*.sqlite3 &&
-      RAILS_ENV=test rake db:migrate
-    )
-    puts "dbsetup: #{results}" unless results == ''
-  end
+RSpec::Core::RakeTask.new(:spec)
 
-  desc 'Setup the test database and run rspec'
-  task :run => %w( test:dbsetup test:spec )
+if defined?(ActiveRecord)
+  task :default => [ 'app:db:create', 'app:db:migrate', 'spec' ]
+else
+  task :default => [ 'spec' ]
 end
-
-task :default => 'test:run'
-

data/lib/harmonize.rb

@@ -2,8 +2,10 @@ require 'hashie/dash'
 require 'harmonize/errors'
 module Harmonize
   require 'harmonize/engine' if defined?(Rails) && Rails::VERSION::MAJOR == 3
+  require 'harmonize/models'
   autoload :Base,          'harmonize/base'
   autoload :Strategies,    'harmonize/strategies'
   autoload :Configuration, 'harmonize/configuration'
 end
-ActiveRecord::Base.send :include, Harmonize::Base if defined?(ActiveRecord::Base)
+::ActiveRecord::Base.send :include, ::Harmonize::Base if defined?(::ActiveRecord::Base)
+::Mongoid::Document.send  :include, ::Harmonize::Base if defined?(::Mongoid::Document)

data/lib/harmonize/base.rb

@@ -43,14 +43,14 @@ module Harmonize
 
         def create_harmonize_log(harmonizer_name)
           harmonizer = harmonizers[harmonizer_name]
-          Harmonize::Log.create!(
+          Harmonize::Log.create!({
             :start => DateTime.now,
             :class_name => self.class.name,
             :harmonizer_name => harmonizer_name,
             :key => harmonizer.key,
             :strategy => harmonizer.strategy.inspect,
-            :strategy_arguments => harmonizer.strategy_arguments.inspect,
-          )
+            :strategy_arguments => harmonizer.strategy_arguments.inspect
+          })
         end
 
         def harmonize_source_method(harmonizer_name, method_name = nil)
@@ -63,7 +63,13 @@ module Harmonize
           method_name ||= :scoped
           raise HarmonizerTargetUndefined.new(harmonizer_name.to_s) unless respond_to?(method_name)
           target_scope = send(method_name)
-          raise HarmonizerTargetInvalid.new(harmonizer_name.to_s) unless target_scope.is_a?(ActiveRecord::Relation)
+          if defined?(::ActiveRecord)
+            scope_base = ::ActiveRecord::Relation
+          end
+          if defined?(::Mongoid)
+            scope_base = ::Mongoid::Criteria
+          end
+          raise HarmonizerTargetInvalid.new(harmonizer_name.to_s) unless target_scope.is_a?(scope_base)
           target_scope
         end
 

data/lib/harmonize/engine.rb

@@ -1,4 +1,10 @@
 module Harmonize
   class Engine < ::Rails::Engine
+    load_path = File.expand_path("../..", __FILE__)
+    puts "LOAD PATH: #{load_path}"
+    config.autoload_paths << load_path
+    model_path = File.expand_path("../../models/active_record", __FILE__)
+    puts "MODEL PATH: #{model_path}"
+    paths["app/models"] << model_path
   end
 end

data/lib/harmonize/gemdata.rb

@@ -1,7 +1,7 @@
 module Harmonize
   module Gemdata
     Name    = 'harmonize'
-    Version = '0.0.2'
+    Version = '0.0.3'
     Authors = [ 'Bram Swenson' ]
     Email   = [ 'bram@craniumisajar.com' ]
     Summary = <<-END_SUMMARY

data/lib/harmonize/models.rb

@@ -0,0 +1,34 @@
+module Harmonize
+  puts "MODELS LOADING"
+  module Models
+    begin
+      require 'mongoid'
+      Harmonize::Models::Orm = ::Mongoid
+    rescue LoadError
+    end
+    begin
+      require 'active_record'
+      Harmonize::Models::Orm = ::ActiveRecord
+    rescue LoadError
+    end unless defined?(Harmonize::Models::Orm)
+    module ActiveRecord
+      autoload :Log,          'harmonize/models/active_record/log'
+      autoload :Modification, 'harmonize/models/active_record/modification'
+    end
+    module Mongoid
+      autoload :Log,          'harmonize/models/mongoid/log'
+      autoload :Modification, 'harmonize/models/mongoid/modification'
+    end
+  end
+  case Harmonize::Models::Orm.to_s
+  when 'ActiveRecord'
+    puts "LOADING ACTIVE RECORD MODELS"
+    Modification = Harmonize::Models::ActiveRecord::Modification unless defined?(Modification)
+    Log = Harmonize::Models::ActiveRecord::Log unless defined?(Log)
+  when 'Mongoid'
+    puts "LOADING MONGOID MODELS"
+    Modification = Harmonize::Models::Mongoid::Modification unless defined?(Modification)
+    Log = Harmonize::Models::Mongoid::Log unless defined?(Log)
+  end
+  puts "MODELS LOADED"
+end

data/lib/harmonize/models/active_record/log.rb

@@ -0,0 +1,21 @@
+module Harmonize
+  module Models
+    module ActiveRecord
+      class Log < ::ActiveRecord::Base
+        set_table_name :harmonize_logs
+
+        validates :key, :class_name, :harmonizer_name, :strategy, :strategy_arguments, :presence => true
+
+        ModificationOptions = { :class_name => "Harmonize::Models::ActiveRecord::Modification",
+                                :foreign_key => :harmonize_log_id }
+
+        has_many :modifications, ModificationOptions.merge(:inverse_of => :log, :dependent => :destroy)
+        has_many :created,       ModificationOptions.merge(:conditions => { :modification_type => 'create' })
+        has_many :updated,       ModificationOptions.merge(:conditions => { :modification_type => 'update' })
+        has_many :destroyed,     ModificationOptions.merge(:conditions => { :modification_type => 'destroy'})
+        has_many :errored,       ModificationOptions.merge(:conditions => { :modification_type => 'error'  })
+
+      end
+    end
+  end
+end

data/lib/harmonize/models/active_record/modification.rb

@@ -0,0 +1,22 @@
+module Harmonize
+  module Models
+    module ActiveRecord
+      class Modification < ::ActiveRecord::Base
+        set_table_name :harmonize_modifications
+
+        validates :harmonize_log_id, :modification_type, :presence => true
+        validates :modification_type, :inclusion => %w( create update destroy error )
+
+        serialize :instance_errors
+
+        belongs_to :log, :class_name => "Harmonize::Models::ActiveRecord::Log",
+                   :foreign_key => :harmonize_log_id, :inverse_of => :modifications
+
+        scope :created,   lambda { where(:modification_type => 'create') }
+        scope :updated,   lambda { where(:modification_type => 'update') }
+        scope :destroyed, lambda { where(:modification_type => 'destroy') }
+        scope :errored,   lambda { where(:modification_type => 'error') }
+      end
+    end
+  end
+end

data/lib/harmonize/models/mongoid/log.rb

@@ -0,0 +1,29 @@
+module Harmonize
+  module Models
+    module Mongoid
+      class Log
+        include ::Mongoid::Document
+        include ::Mongoid::Timestamps
+        store_in :harmonize_logs
+
+        field :key, :type => String
+        field :class_name, :type => String
+        field :harmonizer_name, :type => String
+        field :strategy, :type => String
+        field :strategy_arguments, :type => String
+        field :start, :type => DateTime
+        field :end, :type => DateTime
+
+        validates :key, :class_name, :harmonizer_name, :strategy, :strategy_arguments, :presence => true
+
+        ModificationOptions = { :class_name => "Harmonize::Models::Mongoid::Modification" }
+
+        has_many :modifications, ModificationOptions.merge(:inverse_of => :log, :dependent => :destroy)
+        def created; modifications.created; end
+        def updated; modifications.updated; end
+        def destroyed; modifications.destroyed; end
+        def errored; modifications.errored; end
+      end
+    end
+  end
+end

data/lib/harmonize/models/mongoid/modification.rb

@@ -0,0 +1,27 @@
+module Harmonize
+  module Models
+    module Mongoid
+      class Modification
+        include ::Mongoid::Document
+        include ::Mongoid::Timestamps
+
+        field :instance_id, :type => String
+        field :modification_type, :type => String
+        field :before_time, :type => DateTime
+        field :after_time, :type => DateTime
+        field :instance_errors, :type => String
+
+        validates :modification_type, :presence => true, :inclusion => %w( create update destroy error )
+
+        #serialize :instance_errors
+
+        belongs_to :log, :class_name => "Harmonize::Models::Mongoid::Log", :inverse_of => :modifications
+
+        scope :created,   lambda { where(:modification_type => 'create') }
+        scope :updated,   lambda { where(:modification_type => 'update') }
+        scope :destroyed, lambda { where(:modification_type => 'destroy') }
+        scope :errored,   lambda { where(:modification_type => 'error') }
+      end
+    end
+  end
+end

data/lib/harmonize/strategies/basic_crud_strategy.rb

@@ -2,84 +2,118 @@ module Harmonize
   module Strategies
 
     class BasicCrudStrategy < Strategy
-
       def harmonize!
-        touched_keys = create_and_update_targets
-        destroy_targets_not_found_in_source(touched_keys)
+        create_and_update_targets
+        destroy_targets_not_found_in_source
       end
 
       private
-
         def create_and_update_targets
-          sources.each.inject([]) do |keys, source|
-            target_instance = find_target_instance(harmonizer.key, source[harmonizer.key])
-            modification = initialize_modification(target_instance)
-            modification = harmonize_target_instance!(target_instance, source, modification)
-            modification.save! if modification
-            keys << source[harmonizer.key]
-          end
+          sources.each { |source| modify_target(source) }
         end
 
-        def destroy_targets_not_found_in_source(touched_keys)
-          # if we didn't get any touched_keys, destroy everything in targets scope
-          destroy_scope = touched_keys.empty? ? targets : targets.where("#{harmonizer.key} NOT IN (?)", touched_keys)
-          destroy_scope.find_each do |instance|
-            modification = harmonize_log.modifications.build(
-              :modification_type => 'destroy', :before_time => DateTime.now,
-              :instance_id => instance.id
-            )
-            instance.destroy
-            modification.update_attributes!(:after_time => DateTime.now)
-          end
+        def modify_target(source)
+          Modifier.modify(source, self)
         end
 
-        def find_target_instance(key, value)
-          target_relation = targets.where(key => value)
-          instance = target_relation.first rescue nil
-          instance ||= target_relation.build
-          instance
+        def destroy_targets_not_found_in_source
+          destroy_scope.all.each { |target| destroy_target(target) }
         end
 
-        def initialize_modification(instance)
-          unless instance.new_record?
-            harmonize_log.modifications.new(:modification_type => 'update', :before_time => DateTime.now)
-          else
-            harmonize_log.modifications.new(:modification_type => 'create', :before_time => DateTime.now)
-          end
+        def destroy_target(target)
+          Modifier.destroy(target, self)
         end
 
-        def harmonize_target_instance!(target_instance, source, modification)
-          target_instance, error_message = update_target_attributes(target_instance, source)
-          return false unless (target_instance.changed? or error_message)
-          target_instance, error_message = save_target(target_instance) unless error_message
-          if error_message
-            modification.attributes = { :modification_type => 'error', :instance_errors => error_message }
-          else
-            modification.attributes = { :after_time => DateTime.now, :instance_id => target_instance.id }
+        # if we didn't get any touched_keys, destroy everything in targets scope
+        def destroy_scope
+          return targets if source_keys.empty?
+          case Harmonize::Models::Orm.to_s
+          when 'ActiveRecord'
+            targets.where("#{harmonizer.key} NOT IN (?)", source_keys)
+          when 'Mongoid'
+            targets.not_in(harmonizer.key => source_keys)
           end
-          modification
         end
 
-        def update_target_attributes(target_instance, source)
-          error_message = false
-          begin
-            target_instance.attributes = source
-          rescue ActiveRecord::UnknownAttributeError => e
-            error_message = e.message
-          end
-          return target_instance, error_message
+        def source_keys
+          @source_keys ||= sources.map { |s| s[harmonizer.key] }
         end
 
-        def save_target(target_instance)
-          error_message = false
-          begin
-            unless target_instance.save
-              error_message = target_instance.errors.full_messages
+        class Modifier
+          def self.modify(source, strategy)
+            new(source, nil, strategy).modify
+          end
+
+          def self.destroy(target, strategy)
+            new(nil, target, strategy).destroy
+          end
+
+          def initialize(source, target, strategy)
+            @source     = source
+            @target     = target
+            @error      = nil # any error that occured during modification
+            @type       = nil # [ create, update, destroy ]
+            @targets    = strategy.targets
+            @log        = strategy.harmonize_log
+            @key        = strategy.harmonizer.key
+          end
+
+          def modify
+            log do
+              find_or_initialize_target
+              update_target_attributes
+              save_target
             end
-          rescue ActiveRecord::ActiveRecordError => e
-            error_message = e.message
           end
-          return target_instance, error_message
+
+          def destroy
+            log do
+              @type = 'destroy'
+              @target.destroy
+              @modified = true
+            end
+          end
+
+          def find_or_initialize_target
+            target_relation = @targets.where( @key => @source[@key] )
+            @target = target_relation.first || target_relation.build
+            @type   = @target.new_record? ? 'create' : 'update'
+          end
+
+          def update_target_attributes
+            @target.attributes = @source
+            @modified = @target.changed?
+          end
+
+          def save_target
+            unless @target.save
+              @error = @target.errors.full_messages
+            end
+          end
+
+          def log
+            @before = DateTime.now
+            yield
+            @after  = DateTime.now
+          rescue ActiveRecord::UnknownAttributeError, ActiveRecord::ActiveRecordError => e
+            @error = e.message
+          ensure
+            if @error
+              @type  = 'error'
+              @after = nil
+            end
+            create_log_entry if @modified || @error
+          end
+
+          def create_log_entry
+            @log.modifications.create(
+              :instance_id       => @target.id,
+              :modification_type => @type,
+              :instance_errors   => @error,
+              :before_time       => @before,
+              :after_time        => @after
+            )
+          end
         end
 
     end

metadata

@@ -1,88 +1,84 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: harmonize
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.0.3
   prerelease: 
-  version: 0.0.2
 platform: ruby
-authors: 
+authors:
 - Bram Swenson
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-06-27 00:00:00 -07:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2011-11-17 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: hashie
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &11797080 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *id001
-description: |
-  Bring entire sets of models into harmony with external sources.
+  version_requirements: *11797080
+description: ! 'Bring entire sets of models into harmony with external sources.
 
-email: 
+'
+email:
 - bram@craniumisajar.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- app/models/harmonize/log.rb
-- app/models/harmonize/modification.rb
-- lib/harmonize/base.rb
+files:
+- lib/harmonize/models.rb
 - lib/harmonize/configuration.rb
-- lib/harmonize/engine.rb
 - lib/harmonize/errors.rb
 - lib/harmonize/gemdata.rb
-- lib/harmonize/strategies/basic_crud_strategy.rb
 - lib/harmonize/strategies/strategy.rb
+- lib/harmonize/strategies/basic_crud_strategy.rb
+- lib/harmonize/engine.rb
+- lib/harmonize/base.rb
+- lib/harmonize/models/active_record/modification.rb
+- lib/harmonize/models/active_record/log.rb
+- lib/harmonize/models/mongoid/modification.rb
+- lib/harmonize/models/mongoid/log.rb
 - lib/harmonize/strategies.rb
 - lib/harmonize.rb
-- lib/rails/generators/harmonize/migration_generator.rb
 - lib/rails/generators/harmonize/templates/migration.rb
+- lib/rails/generators/harmonize/migration_generator.rb
 - MIT-LICENSE
 - Rakefile
 - Gemfile
 - README.md
-has_rdoc: true
 homepage: http://github.com/bramswenson/harmonize
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3057359512407760229
-      segments: 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
       - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+      hash: 4193351527517161227
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 4193351527517161227
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.6.1
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Bring entire sets of models into harmony with external sources.
 test_files: []
-

data/app/models/harmonize/log.rb

@@ -1,16 +0,0 @@
-module Harmonize
-  class Log < ActiveRecord::Base
-    set_table_name :harmonize_logs
-
-    validates :key, :class_name, :harmonizer_name, :strategy, :strategy_arguments, :presence => true
-
-    ModificationOptions = { :class_name => "Harmonize::Modification", :foreign_key => :harmonize_log_id }
-
-    has_many :modifications, ModificationOptions.merge(:inverse_of => :log, :dependent => :destroy)
-    has_many :created,       ModificationOptions.merge(:conditions => { :modification_type => 'create' })
-    has_many :updated,       ModificationOptions.merge(:conditions => { :modification_type => 'update' })
-    has_many :destroyed,     ModificationOptions.merge(:conditions => { :modification_type => 'destroy'})
-    has_many :errored,       ModificationOptions.merge(:conditions => { :modification_type => 'error'  })
-
-  end
-end

data/app/models/harmonize/modification.rb

@@ -1,18 +0,0 @@
-module Harmonize
-  class Modification < ActiveRecord::Base
-    set_table_name :harmonize_modifications
-
-    validates :harmonize_log_id, :modification_type, :presence => true
-    validates :modification_type, :inclusion => %w( create update destroy error )
-
-    serialize :instance_errors
-
-    belongs_to :log, :class_name => "Harmonize::Log",
-               :foreign_key => :harmonize_log_id, :inverse_of => :modifications
-
-    scope :created,   where(:modification_type => 'create')
-    scope :updated,   where(:modification_type => 'update')
-    scope :destroyed, where(:modification_type => 'destroy')
-    scope :errored,   where(:modification_type => 'error')
-  end
-end