be9-dataset 1.3.3

data/lib/dataset/collection.rb

@@ -0,0 +1,19 @@
+require 'set'
+
+module Dataset
+  class Collection < Array # :nodoc:
+    def initialize(parent)
+      concat parent
+    end
+    
+    def <<(dataset)
+      super
+      uniq!
+      self
+    end
+    
+    def subset?(other)
+      Set.new(self).subset?(Set.new(other))
+    end
+  end
+end

data/lib/dataset/database/base.rb

@@ -0,0 +1,43 @@
+require 'fileutils'
+
+module Dataset
+  module Database # :nodoc:
+    
+    # Provides Dataset a way to clear, dump and load databases.
+    class Base
+      include FileUtils
+      
+      def clear
+        connection = ActiveRecord::Base.connection
+        ActiveRecord::Base.silence do
+          connection.tables.each do |table_name|
+            connection.delete "DELETE FROM #{connection.quote_table_name(table_name)}",
+              "Dataset::Database#clear" unless table_name == ActiveRecord::Migrator.schema_migrations_table_name
+          end
+        end
+      end
+      
+      def record_heirarchy(record_class)
+        base_class = record_class.base_class
+        record_heirarchies[base_class] ||= Dataset::Record::Heirarchy.new(base_class)
+      end
+      
+      def record_meta(record_class)
+        record_metas[record_class] ||= begin
+          heirarchy = record_heirarchy(record_class)
+          heirarchy.update(record_class)
+          Dataset::Record::Meta.new(heirarchy, record_class)
+        end
+      end
+      
+      protected
+        def record_metas
+          @record_metas ||= Hash.new
+        end
+        
+        def record_heirarchies
+          @record_heirarchies ||= Hash.new
+        end
+    end
+  end
+end

data/lib/dataset/database/mysql.rb

@@ -0,0 +1,34 @@
+module Dataset
+  module Database # :nodoc:
+    
+    # The interface to a mySQL database, this will capture by creating a dump
+    # file and restore by loading one of the same.
+    #
+    class Mysql < Base
+      def initialize(database_spec, storage_path)
+        @database = database_spec[:database]
+        @username = database_spec[:username]
+        @password = database_spec[:password]
+        @storage_path = storage_path
+        FileUtils.mkdir_p(@storage_path)
+      end
+      
+      def capture(datasets)
+        return if datasets.nil? || datasets.empty?
+        `mysqldump -u #{@username} --password=#{@password} --compact --extended-insert --no-create-db --add-drop-table --quick --quote-names #{@database} > #{storage_path(datasets)}`
+      end
+      
+      def restore(datasets)
+        store = storage_path(datasets)
+        if File.file?(store)
+          `mysql -u #{@username} --password=#{@password} --database=#{@database} < #{store}`
+          true
+        end
+      end
+      
+      def storage_path(datasets)
+        "#{@storage_path}/#{datasets.collect {|c| c.__id__}.join('_')}.sql"
+      end
+    end
+  end
+end

data/lib/dataset/database/postgresql.rb

@@ -0,0 +1,34 @@
+module Dataset
+  module Database # :nodoc:
+    
+    # The interface to a PostgreSQL database, this will capture by creating a dump
+    # file and restore by loading one of the same.
+    #
+    class Postgresql < Base
+      def initialize(database_spec, storage_path)
+        @database = database_spec[:database]
+        @username = database_spec[:username]
+        @password = database_spec[:password]
+        @storage_path = storage_path
+        FileUtils.mkdir_p(@storage_path)
+      end
+      
+      def capture(datasets)
+        return if datasets.nil? || datasets.empty?
+        `pg_dump -c #{@database} > #{storage_path(datasets)}`
+      end
+      
+      def restore(datasets)
+        store = storage_path(datasets)
+        if File.file?(store)
+          `psql -U #{@username} -p #{@password} -e #{@database} < #{store}`
+          true
+        end
+      end
+      
+      def storage_path(datasets)
+        "#{@storage_path}/#{datasets.collect {|c| c.__id__}.join('_')}.sql"
+      end
+    end
+  end
+end

data/lib/dataset/database/sqlite3.rb

@@ -0,0 +1,32 @@
+module Dataset
+  module Database # :nodoc:
+    
+    # The interface to a sqlite3 database, this will capture by copying the db
+    # file and restore by replacing and reconnecting to one of the same.
+    #
+    class Sqlite3 < Base
+      def initialize(database_spec, storage_path)
+        @database_path, @storage_path = database_spec[:database], storage_path
+        FileUtils.mkdir_p(@storage_path)
+      end
+      
+      def capture(datasets)
+        return if datasets.nil? || datasets.empty?
+        cp @database_path, storage_path(datasets)
+      end
+      
+      def restore(datasets)
+        store = storage_path(datasets)
+        if File.file?(store)
+          mv store, @database_path
+          ActiveRecord::Base.establish_connection 'test'
+          true
+        end
+      end
+      
+      def storage_path(datasets)
+        "#{@storage_path}/#{datasets.collect {|c| c.__id__}.join('_')}.sqlite3.db"
+      end
+    end
+  end
+end

data/lib/dataset/extensions/cucumber.rb

@@ -0,0 +1,20 @@
+module Dataset
+  module Extensions # :nodoc:
+
+    module CucumberWorld # :nodoc:
+      def dataset(*datasets, &block)
+        add_dataset(*datasets, &block)
+
+        load = nil
+        $__cucumber_toplevel.Before do
+          load = dataset_session.load_datasets_for(self.class)
+          extend_from_dataset_load(load)
+        end
+        # Makes sure the datasets are reloaded after each scenario
+        Cucumber::Rails.use_transactional_fixtures
+      end
+    end
+
+  end
+end
+Cucumber::Rails::World.extend Dataset::Extensions::CucumberWorld

data/lib/dataset/extensions/rspec.rb

@@ -0,0 +1,21 @@
+module Dataset
+  module Extensions # :nodoc:
+    
+    module RSpecExampleGroup # :nodoc:
+      def dataset(*datasets, &block)
+        add_dataset(*datasets, &block)
+        
+        load = nil
+        before(:all) do
+          load = dataset_session.load_datasets_for(self.class)
+          extend_from_dataset_load(load)
+        end
+        before(:each) do
+          extend_from_dataset_load(load)
+        end
+      end
+    end
+    
+  end
+end
+Spec::Example::ExampleGroup.extend Dataset::Extensions::RSpecExampleGroup

data/lib/dataset/extensions/test_unit.rb

@@ -0,0 +1,60 @@
+module Dataset
+  class TestSuite # :nodoc:
+    def initialize(suite, test_class)
+      @suite = suite
+      @test_class = test_class
+    end
+    
+    def dataset_session
+      @test_class.dataset_session
+    end
+    
+    def run(result, &progress_block)
+      if dataset_session
+        load = dataset_session.load_datasets_for(@test_class)
+        @suite.tests.each { |e| e.extend_from_dataset_load(load) }
+      end
+      @suite.run(result, &progress_block)
+    end
+    
+    def method_missing(method_symbol, *args)
+      @suite.send(method_symbol, *args)
+    end
+  end
+  
+  module Extensions # :nodoc:
+    
+    module TestUnitTestCase # :nodoc:
+      def self.extended(test_case)
+        class << test_case
+          alias_method_chain :suite, :dataset
+        end
+      end
+      
+      def suite_with_dataset
+        Dataset::TestSuite.new(suite_without_dataset, self)
+      end
+      
+      def dataset(*datasets, &block)
+        add_dataset(*datasets, &block)
+        
+        # Unfortunately, if we have rspec loaded, TestCase has it's suite method
+        # modified for the test/unit runners, but uses a different mechanism to
+        # collect tests if the rspec runners are used.
+        if included_modules.find {|m| m.name =~ /ExampleMethods\Z/}
+          load = nil
+          before(:all) do
+            load = dataset_session.load_datasets_for(self.class)
+            extend_from_dataset_load(load)
+          end
+          before(:each) do
+            extend_from_dataset_load(load)
+          end
+        end
+      end
+    end
+    
+  end
+end
+
+Test::Unit::TestCase.extend Dataset::Extensions::TestUnitTestCase

data/lib/dataset/instance_methods.rb

@@ -0,0 +1,10 @@
+module Dataset
+  module InstanceMethods # :nodoc:
+    def extend_from_dataset_load(load)
+      load.dataset_binding.install_block_variables(self)
+      self.extend load.dataset_binding.record_methods
+      self.extend load.dataset_binding.model_finders
+      self.extend load.helper_methods
+    end
+  end
+end

data/lib/dataset/load.rb

@@ -0,0 +1,47 @@
+module Dataset
+  class Load # :nodoc:
+    attr_reader :datasets, :dataset_binding, :helper_methods
+    
+    def initialize(datasets, parent_binding)
+      @datasets = datasets
+      @dataset_binding = SessionBinding.new(parent_binding)
+      @helper_methods = Module.new
+    end
+    
+    def execute(loaded_datasets, dataset_resolver)
+      (datasets - loaded_datasets).each do |dataset|
+        instance = dataset.new
+        instance.extend dataset_binding.record_methods
+        instance.extend dataset_binding.model_finders
+        used_datasets(dataset, dataset_resolver).each do |ds|
+          next unless ds.helper_methods
+          instance.extend ds.helper_methods
+          helper_methods.module_eval do
+            include ds.helper_methods
+          end
+        end
+        instance.load
+      end
+    end
+    
+    def used_datasets(dataset, dataset_resolver, collector = [])
+      dataset.used_datasets.each do |used|
+        ds = dataset_resolver.resolve(used)
+        used_datasets(ds, dataset_resolver, collector)
+        collector << ds
+      end if dataset.used_datasets
+      collector << dataset
+      collector.uniq
+    end
+  end
+  
+  class Reload # :nodoc:
+    attr_reader :dataset_binding, :load
+    delegate :datasets, :helper_methods, :to => :load
+    
+    def initialize(load)
+      @load = load
+      @dataset_binding = SessionBinding.new(@load.dataset_binding)
+    end
+  end
+end

data/lib/dataset/record/fixture.rb

@@ -0,0 +1,73 @@
+require 'active_record/fixtures'
+
+module Dataset
+  module Record # :nodoc:
+    
+    class Fixture # :nodoc:
+      attr_reader :meta, :symbolic_name, :session_binding
+      
+      def initialize(meta, attributes, symbolic_name, session_binding)
+        @meta            = meta
+        @attributes      = attributes.stringify_keys
+        @symbolic_name   = symbolic_name || object_id
+        @session_binding = session_binding
+        
+        install_default_attributes!
+      end
+      
+      def create
+        record_class.connection.insert_fixture to_fixture, meta.table_name
+        id
+      end
+      
+      def id
+        @attributes['id']
+      end
+      
+      def record_class
+        meta.record_class
+      end
+      
+      def to_fixture
+        ::Fixture.new(to_hash, meta.class_name)
+      end
+      
+      def to_hash
+        hash = @attributes.dup
+        hash[meta.inheritance_column] = meta.sti_name if meta.inheriting_record?
+        record_class.reflections.each do |name, reflection|
+          name = name.to_s
+          add_reflection_attributes(hash, name, reflection) if hash[name]
+        end
+        hash
+      end
+      
+      def install_default_attributes!
+        @attributes['id'] ||= symbolic_name.to_s.hash.abs
+        install_timestamps!
+      end
+      
+      def install_timestamps!
+        meta.timestamp_columns.each do |column|
+          @attributes[column.name] = now(column) unless @attributes.key?(column.name)
+        end
+      end
+      
+      def now(column)
+        (ActiveRecord::Base.default_timezone == :utc ? Time.now.utc : Time.now).to_s(:db)
+      end
+      
+      private
+        def add_reflection_attributes(hash, name, reflection)
+          value = hash.delete(name)
+          case value
+          when Symbol
+            hash[reflection.primary_key_name] = session_binding.find_id(reflection.klass, value)
+          else
+            hash[reflection.primary_key_name] = value
+          end
+        end
+    end
+    
+  end
+end

data/lib/dataset/record/heirarchy.rb

@@ -0,0 +1,65 @@
+module Dataset
+  module Record # :nodoc:
+    
+    class Heirarchy # :nodoc:
+      attr_reader :base_class, :class_name, :columns, :table_name
+      
+      delegate :inheritance_column, :to => :base_class
+      
+      def initialize(base_class)
+        @base_class = base_class
+        @class_name = base_class.name
+        @table_name = base_class.table_name
+        @columns    = base_class.columns
+      end
+      
+      def id_cache_key
+        @id_cache_key ||= table_name
+      end
+      
+      def id_finder_names
+        @id_finder_names ||= [id_finder_name(base_class)]
+      end
+      
+      def model_finder_names
+        @model_finder_names ||= [model_finder_name(base_class)]
+      end
+      
+      def to_s
+        "#<Heirarchy: #{table_name}>"
+      end
+      
+      def update(record_class)
+        record_class.ancestors.each do |c|
+          finder_name = model_finder_name(c)
+          unless model_finder_names.include?(finder_name)
+            model_finder_names << finder_name
+            id_finder_names << id_finder_name(c)
+          end
+        end
+      end
+      
+      def finder_name(klass)
+        klass.name.underscore.gsub('/', '_').sub(/^(\w)_/, '\1').gsub(/_(\w)_/, '_\1')
+      end
+      
+      def id_finder_name(klass)
+        "#{finder_name(klass)}_id".to_sym
+      end
+      
+      def model_finder_name(klass)
+        finder_name(klass).pluralize.to_sym
+      end
+      
+      def timestamp_columns
+         @timestamp_columns ||= begin
+           timestamps = %w(created_at created_on updated_at updated_on)
+           columns.select do |column|
+             timestamps.include?(column.name)
+           end
+         end
+      end
+    end
+    
+  end
+end