acts_as_replaceable 1.1.0

data/README.rdoc

@@ -0,0 +1,5 @@
+== ActsAsReplaceable
+
+Overloads the create_or_update_without_callbacks method to allow duplicate records to be replaced 
+without needing to always use find_or_create_by.
+

data/lib/acts_as_replaceable/acts_as_replaceable.rb

@@ -0,0 +1,115 @@
+module ActsAsReplaceable
+  module ActMethod
+    # If any before_save methods change the attributes,
+    # acts_as_replaceable will not function correctly.
+    #
+    # OPTIONS
+    # :match => what fields to match against when finding a duplicate
+    # :insensitive_match => what fields to do case insensitive matching on.
+    # :inherit => what attributes of the existing record overwrite our own attributes
+    def acts_as_replaceable(options = {})
+      include ActsAsReplaceable::InstanceMethods
+
+      options.symbolize_keys!
+      cattr_accessor :acts_as_replaceable_options
+      self.acts_as_replaceable_options = {}
+      self.acts_as_replaceable_options[:match] = ActsAsReplaceable::HelperMethods.sanitize_attribute_names(self, options[:match])
+      self.acts_as_replaceable_options[:insensitive_match] = ActsAsReplaceable::HelperMethods.sanitize_attribute_names(self, options[:insensitive_match])
+      self.acts_as_replaceable_options[:inherit] = ActsAsReplaceable::HelperMethods.sanitize_attribute_names(self, options[:inherit], options[:insensitive_match], :id, :created_at, :updated_at)
+    end
+  end
+
+  module HelperMethods
+    def self.sanitize_attribute_names(klass, *args)
+      # Intersect the proposed attributes with the column names so we don't start assigning attributes that don't exist. e.g. if the model doesn't have timestamps
+      klass.column_names & args.flatten.compact.collect(&:to_s)
+    end
+  end
+
+  module InstanceMethods
+    # Override the create or update method so we can run callbacks, but opt not to save if we don't need to
+    def create_record(*args)
+      find_and_replace
+      if @has_not_changed
+        logger.info "(acts_as_replaceable) Found unchanged #{self.class.to_s} ##{id} #{"- Name: #{name}" if respond_to?('name')}"
+      elsif @has_been_replaced
+        update_record(*args)
+        logger.info "(acts_as_replaceable) Updated existing #{self.class.to_s} ##{id} #{"- Name: #{name}" if respond_to?('name')}"
+      else
+        super
+        logger.info "(acts_as_replaceable) Created #{self.class.to_s} ##{id} #{"- Name: #{name}" if respond_to?('name')}"
+      end
+
+      return true
+    end
+
+    def find_and_replace
+      replace(find_duplicate)
+    end
+
+    private
+
+    def find_duplicate
+      records = self.class.where(match_conditions).where(insensitive_match_conditions)
+      if records.load.size > 1
+        raise "#{records.count} Duplicate #{self.class.model_name.pluralize} Present in Database:\n  #{self.inspect} == #{records.inspect}"
+      end
+
+      return records.first
+    end
+
+    def replace(other)
+      return unless other
+      inherit_attributes(other)
+      @has_been_replaced = true
+      define_singleton_method(:new_record?) { false }
+      define_singleton_method(:persisted?) { true }
+      @has_not_changed = !mark_changes(other)
+    end
+
+    # Inherit other's attributes for those in acts_as_replaceable_options[:inherit]
+    def inherit_attributes(other)
+      acts_as_replaceable_options[:inherit].each do |attrib|
+        self[attrib] = other[attrib]
+      end
+    end
+
+    def mark_changes(other)
+      attribs = self.attributes
+
+      # Copy attributes to other and see how it would change if we updated it
+      # Mark all self's attributes that have changed, so even if they are
+      # still default values, they will be saved to the database
+      attribs.each do |key, value|
+        other[key] = value
+      end
+
+      other.changed.each {|attribute| send("#{attribute}_will_change!") }
+
+      return other.changed?
+    end
+
+    # Search the incoming attributes for attributes that are in the replaceable conditions and use those to form an Find conditions
+    def match_conditions
+      output = {}
+      acts_as_replaceable_options[:match].each do |attribute_name|
+        output[attribute_name] = self[attribute_name]
+      end
+      return output
+    end
+
+    def insensitive_match_conditions
+      sql = []
+      binds = []
+      acts_as_replaceable_options[:insensitive_match].each do |attribute_name|
+        if value = self[attribute_name]
+          sql << "LOWER(#{attribute_name}) = ?"
+          binds << self[attribute_name].downcase
+        else
+          sql << "#{attribute_name} IS NULL"
+        end
+      end
+      return [sql.join(' AND ')] + binds
+    end
+  end
+end

data/lib/acts_as_replaceable.rb

@@ -0,0 +1,3 @@
+require 'acts_as_replaceable/acts_as_replaceable'
+
+ActiveRecord::Base.extend ActsAsReplaceable::ActMethod

data/spec/acts_as_replaceable_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe 'acts_as_dag' do
+  before(:each) do
+    [Material, Item, Person].each(&:destroy_all) # Because we're using sqlite3 and it doesn't support transactional specs (afaik)
+  end
+
+  describe "A saved record" do
+
+    it "should raise an exception if more than one duplicate exists in the database" do
+      insert_model(Material, :name => 'wood')
+      insert_model(Material, :name => 'wood')
+      lambda {Material.create! :name => 'wood'}.should raise_exception
+    end
+
+    it "should raise an exception when matching against multiple fields" do
+      insert_model(Item, :identification_number => '1234', :holding_institution_id => 1)
+      insert_model(Item, :identification_number => '1234', :holding_institution_id => 1)
+      lambda {Item.create! :identification_number => '1234', :holding_institution_id => 1}.should raise_exception
+    end
+    
+    it "should replace itself with an existing record by matching a single column" do
+      Material.create! :name => 'wood'
+      Material.create! :name => 'wood'
+      Material.where(:name => 'wood').count.should == 1
+    end
+
+    it "should replace itself with an existing record by matching multiple columns" do
+      Location.create! :country => 'Canada', :city => 'Vancouver'
+      Location.create! :country => 'Canada', :city => 'Vancouver'
+      Location.where(:country => 'Canada', :city => 'Vancouver').count.should == 1
+    end
+
+    it "should replace itself with an existing record by matching multiple columns and inheriting a column from the existing record" do
+      a = Item.create! :name => 'Stick', :identification_number => '1234', :holding_institution_id => 1, :collection_id => 2,  :fingerprint => 'asdf'
+      b = Item.create! :name => 'Stick', :identification_number => '1234', :holding_institution_id => 1, :collection_id => 2
+      Item.where(:identification_number => '1234', :holding_institution_id => 1, :collection_id => 2).count.should == 1
+      b.fingerprint.should == 'asdf'
+    end
+
+    it "should update the non-match, non-inherit fields of the existing record" do
+      a = Item.create! :name => 'Stick', :identification_number => '1234', :holding_institution_id => 1, :collection_id => 2,  :fingerprint => 'asdf'
+      b = Item.create! :name => 'Dip Stick', :identification_number => '1234', :holding_institution_id => 1, :collection_id => 2
+      c = Item.where(:identification_number => '1234', :holding_institution_id => 1, :collection_id => 2)
+      c.count.should == 1
+      c.first.name.should == 'Dip Stick'
+    end
+    
+    it "should correctly replace an existing record when a match value is nil" do
+      a = Item.create! :name => 'Stick', :identification_number => '1234', :holding_institution_id => 1
+      b = Item.create! :name => 'Dip Stick', :identification_number => '1234', :holding_institution_id => 1
+      Item.where(:identification_number => '1234', :holding_institution_id => 1).count.should == 1
+    end
+
+    it "should replace itself with an existing record by performing case-insensitive matching on multiple columns" do
+      Person.create! :first_name => 'John', :last_name => 'Doe'
+      Person.create! :first_name => 'joHn', :last_name => 'doE'
+      Person.where(:first_name => 'John', :last_name => 'Doe').count.should == 1
+
+      Person.create! :first_name => 'Alanson', :last_name => 'Skinner'
+      Person.create! :first_name => 'Alanson', :last_name => 'Skinner'
+      Person.where(:first_name => 'Alanson', :last_name => 'Skinner').count.should == 1
+    end
+    
+    it "should not replace an existing record with fields that were used to match" do
+      Person.create! :first_name => 'joHn', :last_name => 'doE'
+      Person.create! :first_name => 'John', :last_name => 'Doe'
+      Person.where(:first_name => 'joHn', :last_name => 'doE').count.should == 1
+      Person.where(:first_name => 'John', :last_name => 'Doe').count.should == 0
+    end
+
+    it "should correctly replace an existing record when an insensitive-match value is nil" do
+      a = Person.create! :first_name => 'John'
+      a = Person.create! :first_name => 'John'
+      Person.where(:first_name => 'John').count.should == 1
+    end
+
+    it "should inherit the id of the existing record" do
+      a = Material.create! :name => 'wood'
+      b = Material.create! :name => 'wood'
+      b.id.should == a.id
+    end
+
+    it "should not be a new_record? if it has replaced an existing record" do
+      a = Material.create! :name => 'wood'
+      b = Material.create! :name => 'wood'
+      b.new_record?.should be_false
+    end
+
+    it "should be persisted? if it has replaced an existing record" do
+      a = Material.create! :name => 'wood'
+      b = Material.create! :name => 'wood'
+      b.persisted?.should be_true
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,57 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+require 'active_record'
+require 'logger'
+require 'acts_as_replaceable'
+
+ActiveRecord::Base.logger = Logger.new(STDOUT)
+ActiveRecord::Base.logger.level = Logger::INFO
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :items, :force => true do |t|
+    t.integer :holding_institution_id
+    t.string :identification_number
+    t.integer :collection_id
+    t.string :name
+    t.string :fingerprint
+  end
+  
+  create_table :people, :force => true do |t|
+    t.string :first_name
+    t.string :last_name
+  end
+
+  create_table :materials, :force => true do |t|
+    t.string :name
+  end
+
+  create_table :locations, :force => true do |t|
+    t.string :country
+    t.string :city
+  end
+end
+
+
+class Material < ActiveRecord::Base
+  acts_as_replaceable :match => :name
+  validates_presence_of :name
+end
+
+class Location < ActiveRecord::Base
+  acts_as_replaceable :match => [:country, :city]
+  validates_presence_of :country, :city
+end
+
+class Item < ActiveRecord::Base
+  acts_as_replaceable :match => [:holding_institution_id, :identification_number, :collection_id], :inherit => :fingerprint
+  validates_presence_of :holding_institution_id, :identification_number
+end
+
+class Person < ActiveRecord::Base
+  acts_as_replaceable :insensitive_match => [:first_name, :last_name]
+  validates_presence_of :first_name
+end
+
+def insert_model(klass, attributes)
+  ActiveRecord::Base.connection.execute "INSERT INTO #{klass.quoted_table_name} (#{attributes.keys.join(",")}) VALUES (#{attributes.values.collect { |value| ActiveRecord::Base.connection.quote(value) }.join(",")})", 'Fixture Insert'
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: acts_as_replaceable
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Nicholas Jakobsen
+- Ryan Wallace
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: 
+email: technical@rrnpilot.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/acts_as_replaceable/acts_as_replaceable.rb
+- lib/acts_as_replaceable.rb
+- spec/acts_as_replaceable_spec.rb
+- spec/spec_helper.rb
+- README.rdoc
+homepage: http://github.com/rrn/acts_as_replaceable
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Overloads the create_or_update_without_callbacks method to allow duplicate
+  records to be replaced without needing to always use find_or_create_by.
+test_files: []