airblade-acts-as-importable 1.0.0

data/.gitignore

@@ -0,0 +1,2 @@
+spec/debug.log
+pkg/

data/Gemfile

@@ -0,0 +1 @@
+gemspec

data/README.textile

@@ -0,0 +1,5 @@
+h1. Acts as Importable
+
+See my article "Importing Legacy Data in Rails":http://openmonkey.com/articles/2009/05/importing-legacy-data-in-rails for an introduction and documentation.
+
+Copyright (c) 2009 Tim Riley, released under the MIT license

data/Rakefile

@@ -0,0 +1,25 @@
+require 'rake'
+require 'spec/rake/spectask'
+require 'rake/rdoctask'
+
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc 'Test the acts_as_importable plugin'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.libs << 'lib'
+  t.pattern = 'spec/**/*_spec.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the acts_as_audited plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = 'acts_as_importable'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/airblade-acts-as-importable.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "lib/version"
+
+Gem::Specification.new do |s|
+  s.name        = "airblade-acts-as-importable"
+  s.version     = AMC::Acts::Importable::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Tim Riley, Andrew Stewart']
+  s.email       = ['boss@airbladesoftware.com']
+  s.homepage    = ''
+  s.summary     = ''
+  s.description = s.summary
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'activerecord', '~> 3.0'
+
+  #s.add_development_dependency '', ''
+end

data/init.rb

@@ -0,0 +1,4 @@
+$:.unshift "#{File.dirname(__FILE__)}/lib"
+require 'core_extensions'
+require 'acts_as_importable'
+ActiveRecord::Base.class_eval { include AMC::Acts::Importable }

data/lib/acts_as_importable.rb

@@ -0,0 +1,82 @@
+module AMC
+  module Acts
+    module Importable
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        def acts_as_importable(options = {})
+          # Store the import target class with the legacy class
+          write_inheritable_attribute :importable_to, options[:to]
+
+          # Don't extend or include twice. This will allow acts_as_importable to be called multiple times.
+          # eg. once in a parent class and once again in the child class, where it can override some options.
+          extend  AMC::Acts::Importable::SingletonMethods unless self.methods.include?('import') && self.methods.include?('import_all')
+          include AMC::Acts::Importable::InstanceMethods unless self.included_modules.include?(AMC::Acts::Importable::InstanceMethods)
+        end
+
+      end # ClassMethods
+
+      module SingletonMethods
+        def import(id)
+          find(id).import
+        end
+
+        def import_all(*args)
+          all(*args).each do |legacy_model|
+            legacy_model.import
+          end
+        end
+
+        # This requires a numeric primary key for the legacy tables
+        def import_all_in_batches
+          each do |legacy_model|
+            legacy_model.import
+          end
+        end
+
+        def lookup(id)
+          lookup_class = read_inheritable_attribute(:importable_to) || "#{self.to_s.split('::').last}"
+          lookups[id] ||= Kernel.const_get(lookup_class).first(:conditions => {:legacy_id => id, :legacy_class => self.to_s}).try(:id__)
+        end
+
+        def flush_lookups!
+          @lookups = {}
+        end
+
+        private
+
+        def lookups
+          @lookups ||= {}
+        end
+
+      end # SingletonMethods
+
+      module InstanceMethods
+
+        def import
+          returning to_model do |new_model|
+            if new_model
+              new_model.legacy_id     = self.id         if new_model.respond_to?(:"legacy_id=")
+              new_model.legacy_class  = self.class.to_s if new_model.respond_to?(:"legacy_class=")
+
+              if !new_model.save
+                p new_model.errors
+                # TODO log an error that the model failed to save
+                # TODO remove the raise once we're out of the development cycle
+                raise
+              end
+            end
+          end
+        end
+      end # InstanceMethods
+
+    end
+  end
+end
+
+require 'core_extensions'
+ActiveRecord::Base.class_eval { include AMC::Acts::Importable }

data/lib/core_extensions.rb

@@ -0,0 +1,18 @@
+# See http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/212639
+# And http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/210633 for alternative [:id] notation
+class ActiveRecord::Base
+  alias_method :id__, :id if method_defined? :id
+end
+
+
+# From http://weblog.jamisbuck.org/2007/4/6/faking-cursors-in-activerecord
+class <<ActiveRecord::Base
+  def each(limit=1000)
+    rows = find(:all, :conditions => ["#{primary_key} > ?", 0], :limit => limit)
+    while rows.any?
+      rows.each { |record| yield record }
+      rows = find(:all, :conditions => ["#{primary_key} > ?", rows.last.id], :limit => limit)
+    end
+    self
+  end
+end

data/lib/version.rb

@@ -0,0 +1,7 @@
+module AMC
+  module Acts
+    module Importable
+      VERSION = '1.0.0'
+    end
+  end
+end

data/spec/acts_as_importable_spec.rb

@@ -0,0 +1,117 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe AMC::Acts::Importable do
+  
+  it "should include instance methods" do
+    Legacy::Thing.new.should be_kind_of(AMC::Acts::Importable::InstanceMethods)
+  end
+  
+  it "should extend singleton methods" do
+    Legacy::Thing.should be_kind_of(AMC::Acts::Importable::SingletonMethods)
+  end
+  
+  describe "importing from an instance of a single model" do
+    before(:each) do
+      @legacy_thing = create_legacy_thing
+    end
+    
+    it "should build the new model using the legacy model's to_model method" do
+      @legacy_thing.should_receive(:to_model)
+      @legacy_thing.import
+    end
+    
+    it "should assign the legacy model's ID to the legacy_id attribute in the new model" do
+      new_model = @legacy_thing.import
+      new_model.legacy_id.should == @legacy_thing.id
+    end
+    
+    it "should assign the legacy model's class name to the legacy_class attribute of the new model" do
+      new_model = @legacy_thing.import
+      new_model.legacy_class.should == @legacy_thing.class.to_s
+    end
+    
+    it "should save the new model" do
+      new_model = @legacy_thing.import
+      new_model.should_not be_new_record
+    end
+  end
+  
+  describe "importing a single model" do
+    before(:each) do
+      @legacy_thing = mock(Legacy::Thing, :import => nil)
+      Legacy::Thing.stub!(:find).and_return(@legacy_thing)
+    end
+    
+    it "should find the legacy model" do
+      Legacy::Thing.should_receive(:find).with(123)
+      Legacy::Thing.import(123)
+    end
+    
+    it "should import the legacy model" do
+      @legacy_thing.should_receive(:import)
+      Legacy::Thing.import(123)
+    end
+  end
+  
+  describe "importing all models" do
+    before(:each) do
+      @legacy_thing_1 = mock(Legacy::Thing, :import => nil)
+      @legacy_thing_2 = mock(Legacy::Thing, :import => nil)
+      Legacy::Thing.stub!(:all).and_return([@legacy_thing_1, @legacy_thing_2])
+    end
+    
+    it "should find all legacy models" do
+      Legacy::Thing.should_receive(:all)
+      Legacy::Thing.import_all
+    end
+    
+    it "should import each of the legacy models" do
+      @legacy_thing_1.should_receive(:import)
+      @legacy_thing_2.should_receive(:import)
+      Legacy::Thing.import_all
+    end
+  end
+  
+  describe "looking up legcy IDs for already imported models" do
+    before(:all) do
+      @legacy_thing   = create_legacy_thing
+      @imported_thing = @legacy_thing.import
+    end
+    
+    before(:each) do
+      Legacy::Thing.flush_lookups!
+    end
+    
+    it "should attempt to find the imported model by legacy_id" do
+      Thing.should_receive(:first).with(:conditions => {:legacy_id => 123, :legacy_class => 'Legacy::Thing'})
+      Legacy::Thing.lookup(123)
+    end
+    
+    it "should return the ID of the imported model with a matching legacy_id" do
+      Legacy::Thing.lookup(@legacy_thing.id).should == @imported_thing.id
+    end
+    
+    it "should memoize the mapping from the legacy_id to the imported model's ID" do
+      Thing.should_receive(:first).and_return(@imported_thing)
+      Legacy::Thing.lookup(@legacy_thing.id).inspect
+      Thing.should_not_receive(:find_by_legacy_id)
+      Legacy::Thing.lookup(@legacy_thing.id).inspect
+    end
+  end
+  
+  describe "looking up legacy IDs for already imported models when importing to a model with a different class name to the legacy model" do
+    before(:all) do
+      @other_legacy_thing = create_other_legacy_thing
+    end
+    
+    before(:each) do
+      Legacy::Thing.flush_lookups!
+    end
+    
+    it "should attempt to find the imported model with the specified class name by legacy_id" do
+      Thing.should_receive(:first).with(:conditions => {:legacy_id => 123, :legacy_class => 'Legacy::OtherThing'})
+      Legacy::OtherThing.lookup(123)
+    end
+  end
+  
+end

data/spec/database.yml

@@ -0,0 +1,21 @@
+sqlite:
+  :adapter: sqlite
+  :dbfile: acts_as_importable_plugin.sqlite.db
+sqlite3mem:
+  :adapter: sqlite3
+  :dbfile: ":memory:"
+sqlite3:
+  :adapter: sqlite3
+  :dbfile: acts_as_importable_plugin.sqlite3.db
+postgresql:
+  :adapter: postgresql
+  :username: postgres
+  :password: postgres
+  :database: acts_as_importable_plugin_test
+  :min_messages: ERROR
+mysql:
+  :adapter: mysql
+  :host: localhost
+  :username: rails
+  :password:
+  :database: acts_as_importable_plugin_test

data/spec/schema.rb

@@ -0,0 +1,13 @@
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :legacy_things, :force => true do |t|
+    t.string  :legacy_name
+    t.string  :legacy_description
+  end
+  
+  create_table :things, :force => true do |t|
+    t.string  :name
+    t.string  :description
+    t.integer :legacy_id
+    t.string  :legacy_class
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--format progress
+--loadby mtime
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,50 @@
+ENV['RAILS_ENV'] = 'test'
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'rubygems'
+require 'active_record'
+require File.dirname(__FILE__) + '/../init.rb'
+
+require 'spec'
+
+config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
+ActiveRecord::Base.establish_connection(config[ENV['DB'] || 'sqlite3mem'])
+
+ActiveRecord::Migration.verbose = false
+load(File.dirname(__FILE__) + "/schema.rb")
+
+class Thing < ActiveRecord::Base
+end
+
+module Legacy
+  class Thing < ActiveRecord::Base
+    set_table_name 'legacy_things'
+    
+    acts_as_importable
+  
+    def to_model
+      ::Thing.new do |t|
+        t.name        = self.legacy_name
+        t.description = self.legacy_description
+      end
+    end
+  end
+  
+  class OtherThing < Thing
+    set_table_name 'legacy_things'
+    
+    acts_as_importable :to => 'Thing'
+  end
+end
+
+Spec::Runner.configure do |config|
+  
+  def create_legacy_thing(attrs = {})
+    Legacy::Thing.create({:legacy_name => 'Grandfather Clock', :legacy_description => 'Tick tock'}.merge(attrs))
+  end
+  
+  def create_other_legacy_thing(attrs = {})
+    Legacy::OtherThing.create({:legacy_name => 'Grandfather Clock', :legacy_description => 'Tick tock'}.merge(attrs))
+  end
+end

data/tasks/acts_as_importable_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :acts_as_importable do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification 
+name: airblade-acts-as-importable
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Tim Riley, Andrew Stewart
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-02 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        version: "3.0"
+  type: :runtime
+  version_requirements: *id001
+description: ""
+email: 
+- boss@airbladesoftware.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.textile
+- Rakefile
+- airblade-acts-as-importable.gemspec
+- init.rb
+- lib/acts_as_importable.rb
+- lib/core_extensions.rb
+- lib/version.rb
+- spec/acts_as_importable_spec.rb
+- spec/database.yml
+- spec/schema.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- tasks/acts_as_importable_tasks.rake
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: ""
+test_files: 
+- spec/acts_as_importable_spec.rb
+- spec/database.yml
+- spec/schema.rb
+- spec/spec.opts
+- spec/spec_helper.rb