molo 0.5.0 → 0.6.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    Molo (0.4.0)
+    molo (0.5.0)
       activerecord (~> 3.0.3)
       rake (~> 0.8)
 
@@ -28,6 +28,6 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  Molo!
   activerecord (~> 3.0.3)
+  molo!
   rake (~> 0.8)

data/Molo.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{molo}
-  s.version = "0.5.0"
+  s.version = "0.6.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Joel Moss", "Todd Huss", "Michael Grosser"]
-  s.date = %q{2010-12-13}
+  s.date = %q{2010-12-14}
   s.email = %q{joel@developwithstyle.com}
   s.extra_rdoc_files = [
     "README.markdown"
@@ -27,7 +27,19 @@ Gem::Specification.new do |s|
      "vendor/migration_helpers/MIT-LICENSE",
      "vendor/migration_helpers/README.markdown",
      "vendor/migration_helpers/init.rb",
-     "vendor/migration_helpers/lib/migration_helper.rb"
+     "vendor/migration_helpers/lib/migration_helper.rb",
+     "vendor/yaml_db/init.rb",
+     "vendor/yaml_db/lib/csv_db.rb",
+     "vendor/yaml_db/lib/serialization_helper.rb",
+     "vendor/yaml_db/lib/yaml_db.rb",
+     "vendor/yaml_db/spec/base.rb",
+     "vendor/yaml_db/spec/serialization_helper_base_spec.rb",
+     "vendor/yaml_db/spec/serialization_helper_dump_spec.rb",
+     "vendor/yaml_db/spec/serialization_helper_load_spec.rb",
+     "vendor/yaml_db/spec/serialization_utils_spec.rb",
+     "vendor/yaml_db/spec/yaml_dump_spec.rb",
+     "vendor/yaml_db/spec/yaml_load_spec.rb",
+     "vendor/yaml_db/spec/yaml_utils_spec.rb"
   ]
   s.homepage = %q{http://codaset.com/joelmoss/molo}
   s.rdoc_options = ["--charset=UTF-8"]

data/VERSION

@@ -1 +1 @@
-0.5.0
+0.6.0

data/lib/tasks/molo.rb

@@ -33,10 +33,11 @@ class MigratorTasks < ::Rake::TaskLib
     namespace :db do
       task :ar_init do
         require 'active_record'
-        ENV[@env] ||= @default_env
-
         require 'erb'
+        require 'yaml_db'
         
+        ENV[@env] ||= @default_env
+
         if @config.is_a?(Hash)
           ActiveRecord::Base.configurations = @config
         else
@@ -171,7 +172,7 @@ class MigratorTasks < ::Rake::TaskLib
         puts "Current version: #{ActiveRecord::Migrator.current_version}"
       end
   
-      desc "Raises an error if there are pending migrations"
+      # desc "Raises an error if there are pending migrations"
       task :abort_if_pending_migrations => :ar_init do
         @migrations.each do |path|
           pending_migrations = ActiveRecord::Migrator.new(:up, path).pending_migrations
@@ -204,6 +205,50 @@ class MigratorTasks < ::Rake::TaskLib
         end
       end
 
+    	desc "Dump schema and data to db/schema.rb and db/data.yml"
+    	task(:dump => [ "db:schema:dump", "db:data:dump" ])
+
+    	desc "Load schema and data from db/schema.rb and db/data.yml"
+    	task(:load => [ "db:schema:load", "db:data:load" ])
+
+    	namespace :data do
+    		def db_dump_data_file (extension = "yml")
+    		  "#{dump_dir}/data.#{extension}"
+        end
+            
+        def dump_dir(dir = "")
+          "#{base}/db#{dir}"
+        end
+
+    		desc "Dump contents of database to db/data.extension (defaults to yaml)"
+    		task :dump => :ar_init do
+          format_class = ENV['class'] || "YamlDb::Helper"
+          helper = format_class.constantize
+    			SerializationHelper::Base.new(helper).dump db_dump_data_file helper.extension
+    		end
+
+    		desc "Dump contents of database to db/data/tablename.extension (defaults to yaml)"
+    		task :dump_dir => :ar_init do
+          format_class = ENV['class'] || "YamlDb::Helper"
+          dir = ENV['dir'] || "data"
+          SerializationHelper::Base.new(format_class.constantize).dump_to_dir dump_dir("/#{dir}")
+    		end
+
+    		desc "Load contents of db/data.extension (defaults to yaml) into database"
+    		task :load => :ar_init do
+          format_class = ENV['class'] || "YamlDb::Helper"
+          helper = format_class.constantize
+    			SerializationHelper::Base.new(helper).load(db_dump_data_file helper.extension)
+    		end
+
+    		desc "Load contents of db/data/* into database"
+    		task :load_dir  => :ar_init do
+          dir = ENV['dir'] || "data"
+          format_class = ENV['class'] || "YamlDb::Helper"
+    	    SerializationHelper::Base.new(format_class.constantize).load_from_dir dump_dir("/#{dir}")
+    		end
+    	end
+
       namespace :test do
         desc "Recreate the test database from the current schema.rb"
         task :load => ['db:ar_init', 'db:test:purge'] do

data/vendor/yaml_db/init.rb

@@ -0,0 +1 @@
+require "yaml_db"

data/vendor/yaml_db/lib/csv_db.rb

@@ -0,0 +1,78 @@
+#require 'FasterCSV'
+module CsvDb
+  module Helper
+    def self.loader
+      Load
+    end
+
+    def self.dumper
+      Dump
+    end
+
+    def self.extension
+      "csv"
+    end
+  end
+
+  class Load < SerializationHelper::Load
+    def self.load_documents(io, truncate = true)
+      tables = {}
+      curr_table = nil
+      io.each do |line|
+        if /BEGIN_CSV_TABLE_DECLARATION(.+)END_CSV_TABLE_DECLARATION/ =~ line
+          curr_table = $1
+          tables[curr_table] = {}
+        else
+          if tables[curr_table]["columns"]
+            tables[curr_table]["records"] << FasterCSV.parse(line)[0]
+          else
+            tables[curr_table]["columns"] = FasterCSV.parse(line)[0]
+            tables[curr_table]["records"] = []
+          end
+        end
+      end
+
+      tables.each_pair do |table_name, contents|
+        load_table(table_name, contents, truncate)
+      end
+    end
+  end
+
+  class Dump < SerializationHelper::Dump
+
+    def self.before_table(io,table)
+      io.write "BEGIN_CSV_TABLE_DECLARATION#{table}END_CSV_TABLE_DECLARATION\n"
+    end
+
+    def self.dump(io)
+      tables.each do |table|
+        before_table(io, table)
+        dump_table(io, table)
+        after_table(io, table)
+      end
+    end
+
+    def self.after_table(io,table)
+      io.write ""
+    end
+
+    def self.dump_table_columns(io, table)
+      io.write(table_column_names(table).to_csv)
+    end
+
+    def self.dump_table_records(io, table)
+
+      column_names = table_column_names(table)
+
+      each_table_page(table) do |records|
+        rows = SerializationHelper::Utils.unhash_records(records, column_names)
+        records.each do |record|
+          io.write(record.to_csv)
+        end
+      end
+    end
+    
+  end
+
+
+end

data/vendor/yaml_db/lib/serialization_helper.rb

@@ -0,0 +1,195 @@
+module SerializationHelper
+
+  class Base
+    attr_reader :extension
+
+    def initialize(helper)
+      @dumper = helper.dumper
+      @loader = helper.loader
+      @extension = helper.extension
+    end
+
+    def dump(filename)
+      disable_logger
+      @dumper.dump(File.new(filename, "w"))
+      reenable_logger
+    end
+
+    def dump_to_dir(dirname)
+      Dir.mkdir(dirname)
+      tables = @dumper.tables
+      tables.each do |table|
+        io = File.new "#{dirname}/#{table}.#{@extension}", "w"
+        @dumper.before_table(io, table)
+        @dumper.dump_table io, table
+        @dumper.after_table(io, table)         
+      end
+    end
+
+    def load(filename, truncate = true)
+      disable_logger
+      @loader.load(File.new(filename, "r"), truncate)
+      reenable_logger
+    end
+
+    def load_from_dir(dirname, truncate = true)
+      Dir.entries(dirname).each do |filename|
+        if filename =~ /^[.]/
+          next
+        end
+        @loader.load(File.new("#{dirname}/#{filename}", "r"), truncate)
+      end   
+    end
+
+    def disable_logger
+      @@old_logger = ActiveRecord::Base.logger
+      ActiveRecord::Base.logger = nil
+    end
+
+    def reenable_logger
+      ActiveRecord::Base.logger = @@old_logger
+    end
+  end
+  
+  class Load
+    def self.load(io, truncate = true)
+      ActiveRecord::Base.connection.transaction do
+        load_documents(io, truncate)
+      end
+    end
+
+    def self.truncate_table(table)
+      begin
+        ActiveRecord::Base.connection.execute("TRUNCATE #{SerializationHelper::Utils.quote_table(table)}")
+      rescue Exception
+        ActiveRecord::Base.connection.execute("DELETE FROM #{SerializationHelper::Utils.quote_table(table)}")
+      end
+    end
+
+    def self.load_table(table, data, truncate = true)
+      column_names = data['columns']
+      if truncate
+        truncate_table(table)
+      end
+      load_records(table, column_names, data['records'])
+      reset_pk_sequence!(table)
+    end
+
+    def self.load_records(table, column_names, records)
+      if column_names.nil?
+        return
+      end
+      columns = column_names.map{|cn| ActiveRecord::Base.connection.columns(table).detect{|c| c.name == cn}}
+      quoted_column_names = column_names.map { |column| ActiveRecord::Base.connection.quote_column_name(column) }.join(',')
+      quoted_table_name = SerializationHelper::Utils.quote_table(table)
+      records.each do |record|
+        quoted_values = record.zip(columns).map{|c| ActiveRecord::Base.connection.quote(c.first, c.last)}.join(',')
+        ActiveRecord::Base.connection.execute("INSERT INTO #{quoted_table_name} (#{quoted_column_names}) VALUES (#{quoted_values})")
+      end
+    end
+
+    def self.reset_pk_sequence!(table_name)
+      if ActiveRecord::Base.connection.respond_to?(:reset_pk_sequence!)
+        ActiveRecord::Base.connection.reset_pk_sequence!(table_name)
+      end
+    end    
+
+      
+  end
+
+  module Utils
+
+    def self.unhash(hash, keys)
+      keys.map { |key| hash[key] }
+    end
+
+    def self.unhash_records(records, keys)
+      records.each_with_index do |record, index|
+        records[index] = unhash(record, keys)
+      end
+
+      records
+    end
+
+    def self.convert_booleans(records, columns)
+      records.each do |record|
+        columns.each do |column|
+          next if is_boolean(record[column])
+          record[column] = (record[column] == 't' or record[column] == '1')
+        end
+      end
+      records
+    end
+
+    def self.boolean_columns(table)
+      columns = ActiveRecord::Base.connection.columns(table).reject { |c| silence_warnings { c.type != :boolean } }
+      columns.map { |c| c.name }
+    end
+
+    def self.is_boolean(value)
+      value.kind_of?(TrueClass) or value.kind_of?(FalseClass)
+    end
+
+    def self.quote_table(table)
+      ActiveRecord::Base.connection.quote_table_name(table)
+    end
+
+  end
+
+  class Dump
+    def self.before_table(io, table)
+
+    end
+
+    def self.dump(io)
+      tables.each do |table|
+        before_table(io, table)
+        dump_table(io, table)
+        after_table(io, table)
+      end
+    end
+
+    def self.after_table(io, table)
+
+    end
+
+    def self.tables
+      ActiveRecord::Base.connection.tables.reject { |table| ['schema_info', 'schema_migrations'].include?(table) }
+    end
+
+    def self.dump_table(io, table)
+      return if table_record_count(table).zero?
+
+      dump_table_columns(io, table)
+      dump_table_records(io, table)
+    end
+
+    def self.table_column_names(table)
+      ActiveRecord::Base.connection.columns(table).map { |c| c.name }
+    end
+
+
+    def self.each_table_page(table, records_per_page=1000)
+      total_count = table_record_count(table)
+      pages = (total_count.to_f / records_per_page).ceil - 1
+      id = table_column_names(table).first
+      boolean_columns = SerializationHelper::Utils.boolean_columns(table)
+      quoted_table_name = SerializationHelper::Utils.quote_table(table)
+
+      (0..pages).to_a.each do |page|
+        sql = ActiveRecord::Base.connection.add_limit_offset!("SELECT * FROM #{quoted_table_name} ORDER BY #{id}",
+                                                              :limit => records_per_page, :offset => records_per_page * page
+        )
+        records = ActiveRecord::Base.connection.select_all(sql)
+        records = SerializationHelper::Utils.convert_booleans(records, boolean_columns)
+        yield records
+      end
+    end
+
+    def self.table_record_count(table)
+      ActiveRecord::Base.connection.select_one("SELECT COUNT(*) FROM #{SerializationHelper::Utils.quote_table(table)}").values.first.to_i
+    end
+
+  end
+
+end

data/vendor/yaml_db/lib/yaml_db.rb

@@ -0,0 +1,66 @@
+require 'yaml'
+require 'serialization_helper'
+require 'active_support/core_ext/kernel/reporting'
+
+module YamlDb
+  module Helper
+    def self.loader
+      YamlDb::Load 
+    end
+
+    def self.dumper
+      YamlDb::Dump
+    end
+
+    def self.extension
+      "yml"
+    end
+  end
+
+
+  module Utils
+    def self.chunk_records(records)
+      yaml = [ records ].to_yaml
+      yaml.sub!("--- \n", "")
+      yaml.sub!('- - -', '  - -')
+      yaml
+    end
+
+  end
+
+  class Dump < SerializationHelper::Dump
+ 
+    def self.dump_table_columns(io, table)
+      io.write("\n")
+      io.write({ table => { 'columns' => table_column_names(table) } }.to_yaml)
+    end
+
+    def self.dump_table_records(io, table)
+      table_record_header(io)
+
+      column_names = table_column_names(table)
+
+      each_table_page(table) do |records|
+        rows = SerializationHelper::Utils.unhash_records(records, column_names)
+        io.write(YamlDb::Utils.chunk_records(records))
+      end
+    end
+
+    def self.table_record_header(io)
+      io.write("  records: \n")
+    end
+
+  end
+
+  class Load < SerializationHelper::Load
+    def self.load_documents(io, truncate = true) 
+        YAML.load_documents(io) do |ydoc|
+          ydoc.keys.each do |table_name|
+            next if ydoc[table_name].nil?
+            load_table(table_name, ydoc[table_name], truncate)
+          end
+        end
+    end
+  end
+
+end

data/vendor/yaml_db/spec/base.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'spec'
+require 'spec/autorun'
+require 'yaml_db'
+
+Spec::Runner.configure do |config|
+  
+end

data/vendor/yaml_db/spec/serialization_helper_base_spec.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/base'
+
+describe SerializationHelper::Base do
+
+	before do
+        @io = StringIO.new
+		silence_warnings { ActiveRecord::Base = mock('ActiveRecord::Base', :null_object => true) }
+		ActiveRecord::Base.connection = mock('connection')
+		ActiveRecord::Base.connection.stub!(:tables).and_return([ 'mytable', 'schema_info', 'schema_migrations' ])
+    end
+
+    def stub_helper!
+        @helper = mock("MyHelper")
+        @dumper = mock("MyDumper");
+        @loader = mock("MyLoader");
+        @helper.stub!(:dumper).and_return(@dumper)
+        @helper.stub!(:loader).and_return(@loader)
+        @helper.stub!(:extension).and_return("yml")
+        @dumper.stub!(:tables).and_return([ActiveRecord::Base.connection.tables[0]])
+        @dumper.stub!(:before_table).and_return(nil)
+        @dumper.stub!(:after_table).and_return(nil)
+    end
+
+    context "for multi-file dumps" do
+      before do
+        File.should_receive(:new).once.with("dir_name/mytable.yml", "w").and_return(@io)
+        Dir.should_receive(:mkdir).once.with("dir_name")
+        stub_helper!
+        @dumper.should_receive(:dump_table).once.with(@io, "mytable")
+      end
+
+      it "should create the number of files that there are tables" do
+         SerializationHelper::Base.new(@helper).dump_to_dir "dir_name"
+      end   
+
+    end
+
+    context "for multi-file loads" do
+
+      before do
+        stub_helper!
+        @loader.should_receive(:load).once.with(@io, true)
+        File.should_receive(:new).once.with("dir_name/mytable.yml", "r").and_return(@io)
+        Dir.stub!(:entries).and_return(["mytable.yml"])
+      end
+
+      it "should insert into then umber of tables that there are files" do
+        SerializationHelper::Base.new(@helper).load_from_dir "dir_name"        
+      end
+
+    end
+
+end

data/vendor/yaml_db/spec/serialization_helper_dump_spec.rb

@@ -0,0 +1,65 @@
+require File.dirname(__FILE__) + '/base'
+
+describe SerializationHelper::Dump do
+
+	before do
+		silence_warnings { ActiveRecord::Base = mock('ActiveRecord::Base', :null_object => true) }
+		ActiveRecord::Base.connection = mock('connection')
+		ActiveRecord::Base.connection.stub!(:tables).and_return([ 'mytable', 'schema_info', 'schema_migrations' ])
+		ActiveRecord::Base.connection.stub!(:columns).with('mytable').and_return([ mock('a',:name => 'a'), mock('b', :name => 'b') ])
+		ActiveRecord::Base.connection.stub!(:select_one).and_return({"count"=>"2"})
+		ActiveRecord::Base.connection.stub!(:select_all).and_return([ { 'a' => 1, 'b' => 2 }, { 'a' => 3, 'b' => 4 } ])
+		SerializationHelper::Utils.stub!(:quote_table).with('mytable').and_return('mytable')
+	end
+
+	before(:each) do   
+	  File.stub!(:new).with('dump.yml', 'w').and_return(StringIO.new)
+	  @io = StringIO.new
+	end
+
+	it "should return a list of column names" do
+		SerializationHelper::Dump.table_column_names('mytable').should == [ 'a', 'b' ]
+	end
+
+	it "should return a list of tables without the rails schema table" do
+		SerializationHelper::Dump.tables.should == ['mytable']
+	end
+
+	it "should return the total number of records in a table" do
+		SerializationHelper::Dump.table_record_count('mytable').should == 2
+	end
+
+	it "should return all records from the database and return them when there is only 1 page" do
+		SerializationHelper::Dump.each_table_page('mytable') do |records|
+			records.should == [ { 'a' => 1, 'b' => 2 }, { 'a' => 3, 'b' => 4 } ]
+		end
+	end
+
+	it "should paginate records from the database and return them" do
+		ActiveRecord::Base.connection.stub!(:select_all).and_return([ { 'a' => 1, 'b' => 2 } ], [ { 'a' => 3, 'b' => 4 } ])
+
+		records = [ ]
+		SerializationHelper::Dump.each_table_page('mytable', 1) do |page|
+			page.size.should == 1
+			records.concat(page)
+		end
+
+		records.should == [ { 'a' => 1, 'b' => 2 }, { 'a' => 3, 'b' => 4 } ]
+	end
+
+	it "should dump a table's contents to yaml" do
+		SerializationHelper::Dump.should_receive(:dump_table_columns)
+		SerializationHelper::Dump.should_receive(:dump_table_records)
+		SerializationHelper::Dump.dump_table(@io, 'mytable')
+	end
+
+	it "should not dump a table's contents when the record count is zero" do
+		SerializationHelper::Dump.stub!(:table_record_count).with('mytable').and_return(0)
+		SerializationHelper::Dump.should_not_receive(:dump_table_columns)
+		SerializationHelper::Dump.should_not_receive(:dump_table_records)
+		SerializationHelper::Dump.dump_table(@io, 'mytable')
+    end
+
+
+
+end

data/vendor/yaml_db/spec/serialization_helper_load_spec.rb

@@ -0,0 +1,77 @@
+require File.dirname(__FILE__) + '/base'
+
+describe SerializationHelper::Load do
+	before do
+		SerializationHelper::Utils.stub!(:quote_table).with('mytable').and_return('mytable')
+
+		silence_warnings { ActiveRecord::Base = mock('ActiveRecord::Base', :null_object => true) }
+		ActiveRecord::Base.connection = mock('connection')
+		ActiveRecord::Base.connection.stub!(:transaction).and_yield
+		@io = StringIO.new
+	end
+
+  	it "should truncate the table" do
+		ActiveRecord::Base.connection.stub!(:execute).with("TRUNCATE mytable").and_return(true)
+		ActiveRecord::Base.connection.should_not_receive(:execute).with("DELETE FROM mytable")
+		SerializationHelper::Load.truncate_table('mytable')
+	end
+
+	it "should delete the table if truncate throws an exception" do
+		ActiveRecord::Base.connection.should_receive(:execute).with("TRUNCATE mytable").and_raise()
+		ActiveRecord::Base.connection.should_receive(:execute).with("DELETE FROM mytable").and_return(true)
+		SerializationHelper::Load.truncate_table('mytable')
+	end
+
+
+	it "should call reset pk sequence if the connection adapter is postgres" do
+		ActiveRecord::Base.connection.should_receive(:respond_to?).with(:reset_pk_sequence!).and_return(true)
+		ActiveRecord::Base.connection.should_receive(:reset_pk_sequence!).with('mytable')
+		SerializationHelper::Load.reset_pk_sequence!('mytable')
+	end
+
+	it "should not call reset pk sequence for other adapters" do
+		ActiveRecord::Base.connection.should_receive(:respond_to?).with(:reset_pk_sequence!).and_return(false)
+		ActiveRecord::Base.connection.should_not_receive(:reset_pk_sequence!)
+		SerializationHelper::Load.reset_pk_sequence!('mytable')
+	end
+
+    it "should insert records into a table" do
+        mca = mock('a',:name => 'a')
+        mcb = mock('b', :name => 'b')
+        ActiveRecord::Base.connection.stub!(:columns).with('mytable').and_return([mca , mcb ])
+        ActiveRecord::Base.connection.stub!(:quote_column_name).with('a').and_return('a')
+        ActiveRecord::Base.connection.stub!(:quote_column_name).with('b').and_return('b')
+        ActiveRecord::Base.connection.stub!(:quote).with(1, mca).and_return("'1'")
+        ActiveRecord::Base.connection.stub!(:quote).with(2, mcb).and_return("'2'")
+        ActiveRecord::Base.connection.stub!(:quote).with(3, mca).and_return("'3'")
+        ActiveRecord::Base.connection.stub!(:quote).with(4, mcb).and_return("'4'")
+        ActiveRecord::Base.connection.should_receive(:execute).with("INSERT INTO mytable (a,b) VALUES ('1','2')")
+        ActiveRecord::Base.connection.should_receive(:execute).with("INSERT INTO mytable (a,b) VALUES ('3','4')")
+
+        SerializationHelper::Load.load_records('mytable', ['a', 'b'], [[1, 2], [3, 4]])
+    end
+
+    it "should quote column names that correspond to sql keywords" do
+        mca = mock('a',:name => 'a')
+        mccount = mock('count', :name => 'count')
+        ActiveRecord::Base.connection.stub!(:columns).with('mytable').and_return([mca , mccount ])
+        ActiveRecord::Base.connection.stub!(:quote_column_name).with('a').and_return('a')
+        ActiveRecord::Base.connection.stub!(:quote_column_name).with('count').and_return('"count"')
+        ActiveRecord::Base.connection.stub!(:quote).with(1, mca).and_return("'1'")
+        ActiveRecord::Base.connection.stub!(:quote).with(2, mccount).and_return("'2'")
+        ActiveRecord::Base.connection.stub!(:quote).with(3, mca).and_return("'3'")
+        ActiveRecord::Base.connection.stub!(:quote).with(4, mccount).and_return("'4'")
+        ActiveRecord::Base.connection.should_receive(:execute).with("INSERT INTO mytable (a,\"count\") VALUES ('1','2')")
+        ActiveRecord::Base.connection.should_receive(:execute).with("INSERT INTO mytable (a,\"count\") VALUES ('3','4')")
+
+        SerializationHelper::Load.load_records('mytable', ['a', 'count'], [[1, 2], [3, 4]])
+    end
+
+  	it "should truncate the table and then load the records into the table" do
+		SerializationHelper::Load.should_receive(:truncate_table).with('mytable')
+		SerializationHelper::Load.should_receive(:load_records).with('mytable', ['a', 'b'], [[1, 2], [3, 4]])
+		SerializationHelper::Load.should_receive(:reset_pk_sequence!).with('mytable')
+
+		SerializationHelper::Load.load_table('mytable', { 'columns' => [ 'a', 'b' ], 'records' => [[1, 2], [3, 4]] })
+	end
+end

data/vendor/yaml_db/spec/serialization_utils_spec.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + '/base'
+
+describe SerializationHelper::Utils, " convert records utility method" do
+	before do
+		silence_warnings { ActiveRecord::Base = mock('ActiveRecord::Base', :null_object => true) }
+		ActiveRecord::Base.connection = mock('connection')
+	end
+
+	it "returns an array of hash values using an array of ordered keys" do
+		SerializationHelper::Utils.unhash({ 'a' => 1, 'b' => 2 }, [ 'b', 'a' ]).should == [ 2, 1 ]
+    end
+
+	it "should unhash each hash an array using an array of ordered keys" do
+		SerializationHelper::Utils.unhash_records([ { 'a' => 1, 'b' => 2 }, { 'a' => 3, 'b' => 4 } ], [ 'b', 'a' ]).should == [ [ 2, 1 ], [ 4, 3 ] ]
+	end
+
+	it "should return true if it is a boolean type" do
+		SerializationHelper::Utils.is_boolean(true).should == true
+		SerializationHelper::Utils.is_boolean('true').should_not == true
+	end
+
+	it "should return an array of boolean columns" do
+		ActiveRecord::Base.connection.stub!(:columns).with('mytable').and_return([ mock('a',:name => 'a',:type => :string), mock('b', :name => 'b',:type => :boolean) ])
+		SerializationHelper::Utils.boolean_columns('mytable').should == ['b']
+	end
+
+	it "should quote the table name" do
+		ActiveRecord::Base.connection.should_receive(:quote_table_name).with('values').and_return('`values`')
+		SerializationHelper::Utils.quote_table('values').should == '`values`'
+	end
+end

data/vendor/yaml_db/spec/yaml_dump_spec.rb

@@ -0,0 +1,55 @@
+require File.dirname(__FILE__) + '/base'
+
+describe YamlDb::Dump do
+
+	before do
+		silence_warnings { ActiveRecord::Base = mock('ActiveRecord::Base', :null_object => true) }
+		ActiveRecord::Base.connection = mock('connection')
+		ActiveRecord::Base.connection.stub!(:tables).and_return([ 'mytable', 'schema_info', 'schema_migrations' ])
+		ActiveRecord::Base.connection.stub!(:columns).with('mytable').and_return([ mock('a',:name => 'a'), mock('b', :name => 'b') ])
+		ActiveRecord::Base.connection.stub!(:select_one).and_return({"count"=>"2"})
+		ActiveRecord::Base.connection.stub!(:select_all).and_return([ { 'a' => 1, 'b' => 2 }, { 'a' => 3, 'b' => 4 } ])
+		YamlDb::Utils.stub!(:quote_table).with('mytable').and_return('mytable')
+	end
+
+	before(:each) do   
+	  File.stub!(:new).with('dump.yml', 'w').and_return(StringIO.new)
+	  @io = StringIO.new
+	end
+
+	it "should return a formatted string" do
+		YamlDb::Dump.table_record_header(@io)
+		@io.rewind
+		@io.read.should == "  records: \n"
+	end
+
+
+	it "should return a yaml string that contains a table header and column names" do
+		YamlDb::Dump.stub!(:table_column_names).with('mytable').and_return([ 'a', 'b' ])
+		YamlDb::Dump.dump_table_columns(@io, 'mytable')
+		@io.rewind
+		@io.read.should == <<EOYAML
+
+--- 
+mytable: 
+  columns: 
+  - a
+  - b
+EOYAML
+	end
+
+	it "should return dump the records for a table in yaml to a given io stream" do
+		YamlDb::Dump.dump_table_records(@io, 'mytable')
+		@io.rewind
+		@io.read.should == <<EOYAML
+  records: 
+  - - 1
+    - 2
+  - - 3
+    - 4
+EOYAML
+	end
+
+
+
+end

data/vendor/yaml_db/spec/yaml_load_spec.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/base'
+require 'active_support/core_ext/kernel/debugger'
+
+describe YamlDb::Load do
+	before do
+		SerializationHelper::Utils.stub!(:quote_table).with('mytable').and_return('mytable')
+
+		silence_warnings { ActiveRecord::Base = mock('ActiveRecord::Base', :null_object => true) }
+		ActiveRecord::Base.connection = mock('connection')
+		ActiveRecord::Base.connection.stub!(:transaction).and_yield
+	end
+
+	before(:each) do
+		@io = StringIO.new
+    end
+    
+
+	it "should call load structure for each document in the file" do
+		YAML.should_receive(:load_documents).with(@io).and_yield({ 'mytable' => { 
+					'columns' => [ 'a', 'b' ], 
+					'records' => [[1, 2], [3, 4]] 
+				} } )
+		YamlDb::Load.should_receive(:load_table).with('mytable', { 'columns' => [ 'a', 'b' ], 'records' => [[1, 2], [3, 4]] },true)
+		YamlDb::Load.load(@io)
+	end
+
+	it "should not call load structure when the document in the file contains no records" do
+		YAML.should_receive(:load_documents).with(@io).and_yield({ 'mytable' => nil })
+		YamlDb::Load.should_not_receive(:load_table)
+		YamlDb::Load.load(@io)
+	end
+
+end

data/vendor/yaml_db/spec/yaml_utils_spec.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/base'
+
+describe YamlDb::Utils, " convert records utility method" do
+
+	it "turns an array with one record into a yaml chunk" do
+		YamlDb::Utils.chunk_records([ %w(a b) ]).should == <<EOYAML
+  - - a
+    - b
+EOYAML
+	end
+
+	it "turns an array with two records into a yaml chunk" do
+		YamlDb::Utils.chunk_records([ %w(a b), %w(x y) ]).should == <<EOYAML
+  - - a
+    - b
+  - - x
+    - y
+EOYAML
+	end
+
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: molo
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 7
   prerelease: false
   segments: 
   - 0
-  - 5
+  - 6
   - 0
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors: 
 - Joel Moss
@@ -17,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-13 00:00:00 +00:00
+date: 2010-12-14 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -73,6 +73,18 @@ files:
 - vendor/migration_helpers/README.markdown
 - vendor/migration_helpers/init.rb
 - vendor/migration_helpers/lib/migration_helper.rb
+- vendor/yaml_db/init.rb
+- vendor/yaml_db/lib/csv_db.rb
+- vendor/yaml_db/lib/serialization_helper.rb
+- vendor/yaml_db/lib/yaml_db.rb
+- vendor/yaml_db/spec/base.rb
+- vendor/yaml_db/spec/serialization_helper_base_spec.rb
+- vendor/yaml_db/spec/serialization_helper_dump_spec.rb
+- vendor/yaml_db/spec/serialization_helper_load_spec.rb
+- vendor/yaml_db/spec/serialization_utils_spec.rb
+- vendor/yaml_db/spec/yaml_dump_spec.rb
+- vendor/yaml_db/spec/yaml_load_spec.rb
+- vendor/yaml_db/spec/yaml_utils_spec.rb
 has_rdoc: true
 homepage: http://codaset.com/joelmoss/molo
 licenses: []