reversible_data 0.1.0

data/lib/reversible_data.rb

@@ -0,0 +1,51 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'active_support'
+require 'active_record'
+
+module ReversibleData
+  
+  autoload :Table,         'reversible_data/table'
+  autoload :TableManager,  'reversible_data/table_manager'
+  autoload :ShouldaMacros, 'reversible_data/shoulda_macros'
+  
+  def self.add(name, opts = {}, &blk)
+    Table.new(name, opts, &blk)
+  end
+  
+  def self.[](name)
+    Table.known_models[name]
+  end
+  
+  def self.remove(name)
+    table = self[name]
+    table.down!
+    table.destroy
+  end
+  
+  def self.remove_all
+    Table.known_models.each_value do |t|
+      t.down!
+      t.destroy
+    end
+  end
+  
+  def self.manager_for(*tables)
+    TableManager.new(*tables)
+  end
+  
+  def self.in_memory!
+    if connected?
+      ActiveRecord::Base.connection.disconnect!
+      ActiveRecord::Base.remove_connection
+    end
+    ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+  end
+  
+  def self.connected?
+    ActiveRecord::Base.connection.active?
+  rescue ActiveRecord::ConnectionNotEstablished
+    false
+  end
+  
+end

data/lib/reversible_data/shoulda_macros.rb

@@ -0,0 +1,14 @@
+module ReversibleData
+  module ShouldaMacros
+    
+    def with_tables(*args, &blk)
+      table_manager = ReversibleData.manager_for(*args)
+      context '' do
+        setup { table_manager.up! }
+        context('', &blk)
+        teardown { table_manager.down! }
+      end
+    end
+    
+  end
+end

data/lib/reversible_data/table.rb

@@ -0,0 +1,96 @@
+module ReversibleData
+  class Table
+    
+    cattr_accessor :known_models
+    self.known_models = {}
+    
+    attr_accessor :name, :table_name, :model_name, :options
+    
+    def initialize(name, opts = {}, &blk)
+      @name             = name.to_s.underscore.to_sym
+      @table_name       = (opts[:table_name] || @name.to_s.tableize).to_s
+      @model_name       = (opts[:class_name] || @name.to_s.classify).to_s
+      @migrator         = blk
+      @model_definition = nil
+      default_options   = {:skip_model => Object.const_defined?(@model_name),
+                           :skip_table => (connected? && connection.table_exists?(@table_name))}
+      @options          = opts.reverse_merge(default_options)
+      @blueprint        = nil
+      self.known_models[@name] = self
+    end
+    
+    def skip_model?
+      !!@options[:skip_model]
+    end
+    
+    def skip_table?
+      !!@options[:skip_table]
+    end
+    
+    def up!
+      create_table
+      create_model
+    end
+    
+    def down!
+      remove_model
+      drop_table
+    end
+    
+    def drop_table
+      return if skip_table? || !connected?
+      connection.drop_table(@table_name) if connection.table_exists?(@table_name)
+    end
+    
+    def create_table(autodrop = true)
+      return if skip_table? || !connected?
+      drop_table if autodrop
+      return if connection.table_exists?(@table_name)
+      connection.create_table(table_name, &@migrator)
+    end
+    
+    def remove_model
+      return if skip_model?
+      if Object.const_defined?(@model_name)
+        silence_warnings { Object.send(:remove_const, @model_name) }
+      end
+    end
+    
+    def create_model(autoremove = true)
+      return if skip_model?
+      remove_model if autoremove
+      return if Object.const_defined?(@model_name)
+      @model = Class.new(ActiveRecord::Base)
+      @model.class_eval(&@model_definition) unless @model_definition.nil?
+      @model.blueprint(&@blueprint) unless @blueprint.nil? || !@model.respond_to?(:blueprint)
+      Object.const_set(@model_name, @model)
+    end
+    
+    def define_model(&blk)
+      @model_definition = blk unless blk.nil?
+    end
+    
+    def blueprint(&blk)
+      @blueprint = blk unless blk.nil?
+    end
+    
+    def clear_model_definition!
+      @model_definition = nil
+    end
+    
+    def destroy
+      self.known_models.delete(@name)
+    end
+    
+    protected
+    
+    def connection
+      ActiveRecord::Base.connection
+    end
+    
+    def connected?
+      ReversibleData.connected?
+    end
+    
+  end
+end

data/lib/reversible_data/table_manager.rb

@@ -0,0 +1,31 @@
+module ReversibleData
+  class TableManager
+    
+    attr_reader :managed_tables
+    
+    def initialize(*managed_tables)
+      @managed_tables = managed_tables.map { |n| n.to_sym }.freeze
+    end
+    
+    def up!
+      @managed_tables.each do |name|
+        table = table_for(name)
+        table.up! unless table.nil?
+      end
+    end
+    
+    def down!
+      @managed_tables.each do |name|
+        table = table_for(name)
+        table.down! unless table.nil?
+      end
+    end
+    
+    protected
+    
+    def table_for(name)
+      Table.known_models[name]
+    end
+    
+  end
+end

data/test/reversible_data_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+class ReversibleDataTest < Test::Unit::TestCase
+  
+  should 'have add as a shortcut to Table.new' do
+    mock(ReversibleData::Table).new(:awesome, {})
+    ReversibleData.add(:awesome)
+    mock(ReversibleData::Table).new(:rocket, :table_name => "awesomesauces")
+    ReversibleData.add(:rocket, :table_name => "awesomesauces")
+  end
+  
+  should 'have [] as a shortcut to find' do
+    mock(ReversibleData::Table.known_models)[:awesome]
+    ReversibleData[:awesome]
+  end
+  
+  should 'have remove to remove a specific table' do
+    ReversibleData.add(:awesome) { |t| t.string :name }
+    assert !ReversibleData[:awesome].nil?
+    ReversibleData.remove(:awesome)
+    assert ReversibleData[:awesome].nil?
+  end
+  
+  should 'let you remove all definitions with remove_all' do
+    ReversibleData.add(:awesome) { |t| t.string :name }
+    ReversibleData.add(:ninjas)  { |t| t.string :name }
+    assert !ReversibleData[:awesome].nil?
+    assert !ReversibleData[:ninjas].nil?
+    ReversibleData.remove_all
+    assert ReversibleData[:awesome].nil?
+    assert ReversibleData[:ninjas].nil?
+  end
+  
+  should 'let you create a Table Manager with manager_for' do
+    ReversibleData.add(:awesome) { |t| t.string :name }
+    ReversibleData.add(:ninjas)  { |t| t.string :name }
+    mock(ReversibleData::TableManager).new(:awesome, :ninjas)
+    ReversibleData.manager_for(:awesome, :ninjas)
+  end
+  
+  should 'let you establish an in-memory connection' do
+    assert !ReversibleData.connected?
+    ReversibleData.in_memory!
+    assert ReversibleData.connected?
+  end
+  
+end

data/test/table_manager_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+class TableManagerTest < Test::Unit::TestCase
+  context 'table managers in general' do
+    
+    setup do
+      @table_a = ReversibleData.add(:a) { |t| t.string :name }
+      @table_b = ReversibleData.add(:b) { |t| t.string :name }
+      @table_c = ReversibleData.add(:c) { |t| t.string :name }
+      @manager = ReversibleData::TableManager.new(:a, :b, :c)
+    end
+  
+    should 'let you create a manager for a set of tables' do
+      assert_equal [:a, :b, :c], @manager.managed_tables
+    end
+  
+    should 'let you run up! on all managed tables' do
+      [@table_a, @table_b, @table_c].each { |t| mock(t).up! }
+      @manager.up!
+    end
+  
+    should 'let you run down! on all managed tables' do
+      [@table_a, @table_b, @table_c].each { |t| mock(t).down! }
+      @manager.down!
+    end
+    
+  end
+end

data/test/table_test.rb

@@ -0,0 +1,140 @@
+require 'test_helper'
+
+class TableTest < Test::Unit::TestCase
+  context '' do
+    
+    setup    { ReversibleData.in_memory! }
+  
+    teardown { ReversibleData.remove_all }
+  
+    should 'automatically add it to a list of known models' do
+      table = ReversibleData::Table.new(:user) { |t| t.string :name }
+      assert_equal table, ReversibleData::Table.known_models[:user]
+    end
+  
+    should 'default the table name' do
+      table = ReversibleData::Table.new(:user) { |t| t.string :name }
+      assert_equal "users", table.table_name
+      table = ReversibleData::Table.new(:users) { |t| t.string :name }
+      assert_equal "users", table.table_name
+    end
+  
+    should 'default the model class name' do
+      table = ReversibleData::Table.new(:user) { |t| t.string :name }
+      assert_equal "User", table.model_name
+      table = ReversibleData::Table.new(:users) { |t| t.string :name }
+      assert_equal "User", table.model_name
+    end
+  
+    should 'let you override the table name' do
+      table = ReversibleData::Table.new(:user, :table_name => "awesomesauce") { |t| t.string :name }
+      assert_equal "awesomesauce", table.table_name
+    end
+  
+    should 'let you override the model class name' do
+      table = ReversibleData::Table.new(:user, :class_name => "Ninja") { |t| t.string :name }
+      assert_equal "Ninja", table.model_name
+    end
+  
+    should 'let you skip creating the model' do
+      table = ReversibleData::Table.new(:user, :skip_model => true) { |t| t.string :name }
+      table.create_model
+      assert !defined?(User)
+    end
+  
+    should 'let you skip creating the table' do
+      table = ReversibleData::Table.new(:user, :skip_table => true) { |t| t.string :name }
+      table.create_table
+      assert !ActiveRecord::Base.connection.table_exists?(:users)
+    end
+  
+    should 'let you create the table' do
+      table = ReversibleData::Table.new(:user) { |t| t.string :name }
+      table.create_table
+      assert ActiveRecord::Base.connection.table_exists?(:users)
+    end
+  
+    should 'let you drop the table' do
+      table = ReversibleData::Table.new(:user) { |t| t.string :name }
+      table.create_table
+      table.drop_table
+      assert !ActiveRecord::Base.connection.table_exists?(:users)
+    end
+  
+    should 'let you create the model' do
+      assert !defined?(::User)
+      table = ReversibleData::Table.new(:user) { |t| t.string :name }
+      table.create_model
+      assert defined?(::User)
+    end
+  
+    should 'let you remove the model' do
+      assert !defined?(::User)
+      table = ReversibleData::Table.new(:user) { |t| t.string :name }
+      table.create_model
+      table.remove_model
+      assert !defined?(::User)
+    end
+    
+    should 'let you call up! to create the table and the model' do
+      assert !defined?(::User)
+      assert !ActiveRecord::Base.connection.table_exists?(:users)
+      table = ReversibleData::Table.new(:user) { |t| t.string :name }
+      table.up!
+      assert defined?(::User)
+      assert ActiveRecord::Base.connection.table_exists?(:users)
+      assert User < ActiveRecord::Base
+    end
+    
+    should 'let you call down! to clean up' do
+      table = ReversibleData::Table.new(:user) { |t| t.string :name }
+      table.up!
+      assert ActiveRecord::Base.connection.table_exists?(:users)
+      assert User < ActiveRecord::Base
+      table.down!
+      assert !ActiveRecord::Base.connection.table_exists?(:users)
+      assert !defined?(::User)
+    end
+  
+    should 'default to skipping model if the constant exists' do
+      ::Awesome = true
+      table = ReversibleData::Table.new(:awesome)
+      assert table.skip_model?
+      Object.send(:remove_const, :Awesome)
+    end
+  
+    should 'default to skipping the table if connected and the table exists' do
+      ActiveRecord::Base.connection.create_table(:ninjas) { |t| t.string :name }
+      table = ReversibleData::Table.new(:ninja)
+      assert table.skip_table?
+      ActiveRecord::Base.connection.drop_table(:ninjas)
+    end
+  
+    should 'let you define a model block' do
+      table = ReversibleData::Table.new(:ninja)
+      table.define_model do
+        cattr_accessor :ninjariffic
+        self.ninjariffic = "felafel"
+      end
+      table.create_model
+      assert Ninja.respond_to?(:ninjariffic)
+      assert Ninja.respond_to?(:ninjariffic=)
+      assert_equal "felafel", Ninja.ninjariffic
+      table.remove_model
+    end
+  
+    should 'let not call the blueprint if none is specified' do
+      table = ReversibleData::Table.new(:user) { |t| t.string :name }
+      table.up!
+      assert !User.blueprint_called
+    end
+    
+    should 'call the blueprint if present' do
+      table = ReversibleData::Table.new(:user) { |t| t.string :name }
+      table.blueprint {}
+      table.up!
+      assert User.blueprint_called
+    end
+  
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'rr'
+require 'redgreen'
+require 'reversible_data'
+
+class Test::Unit::TestCase
+  include RR::Adapters::TestUnit
+end
+
+module MockBlueprints
+  
+  def blueprint(&blk)
+    # Use this as a kind of hacky way to ensure it is called.
+    self.blueprint_called = true
+  end
+  
+end
+
+ActiveRecord::Base.class_eval do
+  class_inheritable_accessor :blueprint_called
+  self.blueprint_called = false
+  extend MockBlueprints
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: reversible_data
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Darcy Laycock
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-25 00:00:00 +08:00
+default_executable: 
+dependencies: []
+
+description: 
+email: sutto@sutto.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/reversible_data/shoulda_macros.rb
+- lib/reversible_data/table.rb
+- lib/reversible_data/table_manager.rb
+- lib/reversible_data.rb
+- test/reversible_data_test.rb
+- test/table_manager_test.rb
+- test/table_test.rb
+- test/test_helper.rb
+has_rdoc: false
+homepage: http://sutto.net/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.2
+signing_key: 
+specification_version: 3
+summary: Reversible Data provides migration-like functionality for tests etc - All with temporary models.
+test_files: []
+