fixation 1.3.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9030fd3deb6fe90db7f3386081d6f54022986bae
-  data.tar.gz: c4ee3f55efd5e72710339bed2ec9c2a35381372d
+  metadata.gz: c574bc684d8f4b914fc2ecb3189c06eb603d0b47
+  data.tar.gz: 4c5ddf419b00ccb17f45d825c7c5681a3ffb328c
 SHA512:
-  metadata.gz: bccd15f8df0a0562de2d1582c6a1fad9eb9aaea1465884c4878704ddb1ae4458ff985aeb8af745cbf70780b825be03529addef6ab172a80c5f5d5d37885e6b3d
-  data.tar.gz: 28532d1a859500bfba29ead7aa8a09053d90ef11699ac68609a0769b0bf89b9659b069755283718c89962ec9ca32602d15d46fb11a20668f278f382f4c4610be
+  metadata.gz: 89541e134b63e0f395304f60aa5191d444a7e65becfcc6d6a296afa0905ef6ef8cd0362a5798258855ddd4d5ce9aabbb5d8ae2669f53ec1fde34111316afbcf2
+  data.tar.gz: 9e8f2cc7f32d14b7151024cb22f570a32bc7661863114bbb341c9e29646f899531d76d3cb0ef63334695f346ba81abcfa0af9077a6d2b527002df0839e1d3847

data/README.md

@@ -76,6 +76,16 @@ if Rails.env.test? && Fixation.running_under_spring?
 end
 ```
 
+## Auto-clearing other tables
+
+By default Fixation will only reset those tables that have a fixture file, like Rails.  Optionally, you can tell it to clear all other tables so that you don't need to make empty fixture files.
+
+```ruby
+if Rails.env.test?
+  Fixation.clear_other_tables = true
+end
+```
+
 
 ## Contributing
 

data/lib/fixation.rb

@@ -3,263 +3,25 @@ require 'yaml'
 require 'set'
 require 'active_support/dependencies'
 require 'active_record/errors'
-require "fixation/version"
+require_relative "fixation/version"
+require_relative "fixation/fixture_table"
+require_relative "fixation/fixtures"
 
 module Fixation
-  class FixtureTable
-    attr_reader :filename, :class_name, :table_name, :connection, :now
-
-    def initialize(filename, basename, connection, now)
-      @filename = filename
-      @connection = connection
-      @now = now
-
-      @class_name = basename.classify
-      begin
-        @klass = @class_name.constantize
-        @klass = nil unless @klass < ActiveRecord::Base
-      rescue NameError
-        ActiveRecord::Base.logger.warn "couldn't load #{class_name} for fixture table #{table_name}: #{$!}"
-      end
-
-      if @klass
-        @table_name = @klass.table_name
-        @primary_key = @klass.primary_key
-        @record_timestamps = @klass.record_timestamps
-        @inheritance_column = @klass.inheritance_column
-      else
-        @table_name = basename.gsub('/', '_')
-      end
-    end
-
-    def columns_hash
-      @columns_hash ||= connection.columns(table_name).index_by(&:name)
-    end
-
-    def content
-      template = File.read(filename)
-      render_context = ActiveRecord::FixtureSet::RenderContext.create_subclass.new.get_binding
-      ERB.new(template).result(render_context)
-    end
-
-    def parsed_rows
-      result = YAML.load(content)
-      result ||= {} # for completely empty files
-
-      unless (result.is_a?(Hash) || result.is_a?(YAML::Omap)) && result.all? { |name, attributes| name.is_a?(String) && attributes.is_a?(Hash) }
-        raise ActiveRecord::Fixture::FormatError, "#{filename} needs to contain a hash of fixtures"
-      end
-
-      result.delete('DEFAULTS')
-      result
-    rescue ArgumentError, Psych::SyntaxError => error
-      # we use exactly the same error class and message as ActiveRecord::FixtureSet in case anyone was depending on it
-      raise ActiveRecord::Fixture::FormatError, "a YAML error occurred parsing #{filename}. Please note that YAML must be consistently indented using spaces. Tabs are not allowed. Please have a look at http://www.yaml.org/faq.html\nThe exact error was:\n  #{error.class}: #{error}", error.backtrace
-    end
-
-    def embellished_rows
-      @embellished_rows ||= parsed_rows.each do |name, attributes|
-        embellish_fixture(name, attributes, columns_hash)
-      end
-    end
-
-    def embellish_fixture(name, attributes, columns_hash)
-      # populate the primary key column, if not already set
-      if @primary_key && columns_hash[@primary_key] && !attributes.has_key?(@primary_key)
-        attributes[@primary_key] = Fixation.identify(name, columns_hash[@primary_key].type)
-      end
-
-      # substitute $LABEL into all string values
-      attributes.each do |column_name, value|
-        attributes[column_name] = value.gsub("$LABEL", name) if value.is_a?(String)
-      end
-
-      # populate any timestamp columns, if not already set
-      if @record_timestamps
-        %w(created_at updated_at).each do |column_name|
-          attributes[column_name] = now if columns_hash[column_name] && !attributes.has_key?(column_name)
-        end
-        %w(created_at updated_at).each do |column_name|
-          attributes[column_name] = now.to_date if columns_hash[column_name] && !attributes.has_key?(column_name)
-        end
-      end
-
-      # convert enum names to values
-      @klass.defined_enums.each do |name, values|
-        attributes[name] = values.fetch(attributes[name], attributes[name]) if attributes.has_key?(name)
-      end if @klass.respond_to?(:defined_enums)
-
-      # convert any association names into the identity column equivalent - following code from activerecord's fixtures.rb
-      nonexistant_columns = attributes.keys - columns_hash.keys
-
-      if @klass && nonexistant_columns.present?
-        # If STI is used, find the correct subclass for association reflection
-        reflection_class =
-          if attributes.include?(@inheritance_column)
-            attributes[@inheritance_column].constantize rescue @klass
-          else
-            @klass
-          end
-
-        nonexistant_columns.each do |column_name|
-          association = reflection_class.reflect_on_association(column_name)
-
-          if association.nil?
-            raise ActiveRecord::Fixture::FormatError, "No column named #{column_name} found in table #{table_name}"
-          elsif association.macro != :belongs_to
-            raise ActiveRecord::Fixture::FormatError, "Association #{column_name} in table #{table_name} has type #{association.macro}, which is not currently supported"
-          else
-            value = attributes.delete(column_name)
-
-            if association.options[:polymorphic] && value.is_a?(String) && value.sub!(/\s*\(([^\)]*)\)\s*$/, "")
-              # support polymorphic belongs_to as "label (Type)"
-              attributes[association.foreign_type] = $1
-            end
-
-            fk_name = (association.options[:foreign_key] || "#{association.name}_id").to_s
-            attributes[fk_name] = value ? ActiveRecord::FixtureSet.identify(value) : value
-          end
-        end
-      end
-    end
-
-    def fixture_ids
-      embellished_rows.each_with_object({}) do |(name, attributes), ids|
-        ids[name] = attributes['id'] || attributes['uuid']
-      end
-    end
-
-    def statements
-      statements = ["DELETE FROM #{connection.quote_table_name table_name}"]
-
-      unless embellished_rows.empty?
-        # first figure out what columns we have to insert into; we're going to need to use the same names for
-        # all rows so we can use the multi-line INSERT syntax
-        columns_to_include = Set.new
-        embellished_rows.each do |name, attributes|
-          attributes.each do |column_name, value|
-            raise ActiveRecord::Fixture::FormatError, "No column named #{column_name.inspect} found in table #{table_name.inspect} (attribute on fixture #{name.inspect})" unless columns_hash[column_name]
-            columns_to_include.add(columns_hash[column_name])
-          end
-        end
-
-        # now build the INSERT statement
-        quoted_column_names = columns_to_include.collect { |column| connection.quote_column_name(column.name) }.join(', ')
-        statements <<
-          "INSERT INTO #{connection.quote_table_name table_name} (#{quoted_column_names}) VALUES " +
-          embellished_rows.collect do |name, attributes|
-            '(' + columns_to_include.collect do |column|
-              if attributes.has_key?(column.name)
-                quote_value(column, attributes[column.name])
-              else
-                column.default_function || quote_value(column, column.default)
-              end
-            end.join(', ') + ')'
-          end.join(', ')
-      end
-
-      statements
-    end
-
-    def quote_value(column, value)
-      connection.quote(value)
-    rescue TypeError
-      connection.quote(YAML.dump(value))
-    end
-  end
-
-  class Fixtures
-    def initialize
-      @class_names = {}
-      @fixture_ids = {}
-      @statements = {}
-
-      compile_fixture_files
-    end
-
-    def compile_fixture_files(connection = ActiveRecord::Base.connection)
-      puts "#{Time.now} building fixtures" if Fixation.trace
-
-      now = ActiveRecord::Base.default_timezone == :utc ? Time.now.utc : Time.now
-      Fixation.paths.each do |path|
-        Dir["#{path}/{**,*}/*.yml"].each do |pathname|
-          basename = pathname[path.size + 1..-5]
-          compile_fixture_file(pathname, basename, connection, now) if ::File.file?(pathname)
-        end
-      end
-
-      puts "#{Time.now} built fixtures for #{@fixture_ids.size} tables" if Fixation.trace
-    end
-
-    def compile_fixture_file(filename, basename, connection, now)
-      fixture_table = FixtureTable.new(filename, basename, connection, now)
-      fixture_name = basename.gsub('/', '_')
-      @fixture_ids[fixture_name] = fixture_table.fixture_ids
-      @statements[fixture_name] = fixture_table.statements
-      @class_names[fixture_name] = fixture_table.class_name
-    end
-
-    def apply_fixtures(connection = ActiveRecord::Base.connection)
-      connection.transaction do
-        @statements.each do |table_name, table_statements|
-          table_statements.each do |statement|
-            connection.execute(statement)
-          end
-        end
-      end
-    end
-
-    def fixture_methods
-      fixture_ids = @fixture_ids
-      class_names = @class_names
-
-      methods = Module.new do
-        def setup_fixtures(config = ActiveRecord::Base)
-          if run_in_transaction?
-            @@fixated_fixtures_applied ||= false
-            unless @@fixated_fixtures_applied
-              puts "#{Time.now} applying fixtures" if Fixation.trace
-              Fixation.apply_fixtures
-              @@fixated_fixtures_applied = true
-              puts "#{Time.now} applied fixtures" if Fixation.trace
-            end
-          else
-            @@fixated_fixtures_applied = false
-          end
-          super
-        end
-
-        fixture_ids.each do |fixture_name, fixtures|
-          begin
-            klass = class_names[fixture_name].constantize
-          rescue NameError
-            next
-          end
-
-          define_method(fixture_name) do |*fixture_names|
-            force_reload = fixture_names.pop if fixture_names.last == true || fixture_names.last == :reload
-
-            @fixture_cache[fixture_name] ||= {}
+  # The list of paths to look in to find .yml fixture files.
+  cattr_accessor :paths
+  self.paths = %w(test/fixtures spec/fixtures)
 
-            instances = fixture_names.map do |name|
-              id = fixtures[name.to_s]
-              raise StandardError, "No fixture named '#{name}' found for fixture set '#{fixture_name}'" if id.nil?
+  # Set to true to clear any tables found in the database that do *not* have a fixture file.
+  cattr_accessor :clear_other_tables
 
-              @fixture_cache[fixture_name].delete(name) if force_reload
-              @fixture_cache[fixture_name][name] ||= klass.find(id)
-            end
-
-            instances.size == 1 ? instances.first : instances
-          end
-          private fixture_name
-        end
-      end
-    end
-  end
+  # Set to the list of tables you don't want to clear (if clear_other_tables is turned on).
+  # Defaults to just schema_migrations.
+  cattr_accessor :tables_not_to_clear
+  self.tables_not_to_clear = %w(schema_migrations)
 
+  # Set to true to log some debugging information to stdout.
   cattr_accessor :trace
-  cattr_accessor :paths
-  self.paths = %w(test/fixtures spec/fixtures)
 
   def self.build_fixtures
     @fixtures = Fixtures.new

data/lib/fixation/fixture_table.rb

@@ -0,0 +1,163 @@
+module Fixation
+  class FixtureTable
+    attr_reader :filename, :class_name, :table_name, :connection, :now
+
+    def initialize(filename, basename, connection, now)
+      @filename = filename
+      @connection = connection
+      @now = now
+
+      @class_name = basename.classify
+      begin
+        @klass = @class_name.constantize
+        @klass = nil unless @klass < ActiveRecord::Base
+      rescue NameError
+        ActiveRecord::Base.logger.warn "couldn't load #{class_name} for fixture table #{table_name}: #{$!}"
+      end
+
+      if @klass
+        @table_name = @klass.table_name
+        @primary_key = @klass.primary_key
+        @record_timestamps = @klass.record_timestamps
+        @inheritance_column = @klass.inheritance_column
+      else
+        @table_name = basename.gsub('/', '_')
+      end
+    end
+
+    def columns_hash
+      @columns_hash ||= connection.columns(table_name).index_by(&:name)
+    end
+
+    def content
+      template = File.read(filename)
+      render_context = ActiveRecord::FixtureSet::RenderContext.create_subclass.new.get_binding
+      ERB.new(template).result(render_context)
+    end
+
+    def parsed_rows
+      result = YAML.load(content)
+      result ||= {} # for completely empty files
+
+      unless (result.is_a?(Hash) || result.is_a?(YAML::Omap)) && result.all? { |name, attributes| name.is_a?(String) && attributes.is_a?(Hash) }
+        raise ActiveRecord::Fixture::FormatError, "#{filename} needs to contain a hash of fixtures"
+      end
+
+      result.delete('DEFAULTS')
+      result
+    rescue ArgumentError, Psych::SyntaxError => error
+      # we use exactly the same error class and message as ActiveRecord::FixtureSet in case anyone was depending on it
+      raise ActiveRecord::Fixture::FormatError, "a YAML error occurred parsing #{filename}. Please note that YAML must be consistently indented using spaces. Tabs are not allowed. Please have a look at http://www.yaml.org/faq.html\nThe exact error was:\n  #{error.class}: #{error}", error.backtrace
+    end
+
+    def embellished_rows
+      @embellished_rows ||= parsed_rows.each do |name, attributes|
+        embellish_fixture(name, attributes, columns_hash)
+      end
+    end
+
+    def embellish_fixture(name, attributes, columns_hash)
+      # populate the primary key column, if not already set
+      if @primary_key && columns_hash[@primary_key] && !attributes.has_key?(@primary_key)
+        attributes[@primary_key] = Fixation.identify(name, columns_hash[@primary_key].type)
+      end
+
+      # substitute $LABEL into all string values
+      attributes.each do |column_name, value|
+        attributes[column_name] = value.gsub("$LABEL", name) if value.is_a?(String)
+      end
+
+      # populate any timestamp columns, if not already set
+      if @record_timestamps
+        %w(created_at updated_at).each do |column_name|
+          attributes[column_name] = now if columns_hash[column_name] && !attributes.has_key?(column_name)
+        end
+        %w(created_at updated_at).each do |column_name|
+          attributes[column_name] = now.to_date if columns_hash[column_name] && !attributes.has_key?(column_name)
+        end
+      end
+
+      # convert enum names to values
+      @klass.defined_enums.each do |name, values|
+        attributes[name] = values.fetch(attributes[name], attributes[name]) if attributes.has_key?(name)
+      end if @klass.respond_to?(:defined_enums)
+
+      # convert any association names into the identity column equivalent - following code from activerecord's fixtures.rb
+      nonexistant_columns = attributes.keys - columns_hash.keys
+
+      if @klass && nonexistant_columns.present?
+        # If STI is used, find the correct subclass for association reflection
+        reflection_class =
+          if attributes.include?(@inheritance_column)
+            attributes[@inheritance_column].constantize rescue @klass
+          else
+            @klass
+          end
+
+        nonexistant_columns.each do |column_name|
+          association = reflection_class.reflect_on_association(column_name)
+
+          if association.nil?
+            raise ActiveRecord::Fixture::FormatError, "No column named #{column_name} found in table #{table_name}"
+          elsif association.macro != :belongs_to
+            raise ActiveRecord::Fixture::FormatError, "Association #{column_name} in table #{table_name} has type #{association.macro}, which is not currently supported"
+          else
+            value = attributes.delete(column_name)
+
+            if association.options[:polymorphic] && value.is_a?(String) && value.sub!(/\s*\(([^\)]*)\)\s*$/, "")
+              # support polymorphic belongs_to as "label (Type)"
+              attributes[association.foreign_type] = $1
+            end
+
+            fk_name = (association.options[:foreign_key] || "#{association.name}_id").to_s
+            attributes[fk_name] = value ? ActiveRecord::FixtureSet.identify(value) : value
+          end
+        end
+      end
+    end
+
+    def fixture_ids
+      embellished_rows.each_with_object({}) do |(name, attributes), ids|
+        ids[name] = attributes['id'] || attributes['uuid']
+      end
+    end
+
+    def statements
+      statements = ["DELETE FROM #{connection.quote_table_name table_name}"]
+
+      unless embellished_rows.empty?
+        # first figure out what columns we have to insert into; we're going to need to use the same names for
+        # all rows so we can use the multi-line INSERT syntax
+        columns_to_include = Set.new
+        embellished_rows.each do |name, attributes|
+          attributes.each do |column_name, value|
+            raise ActiveRecord::Fixture::FormatError, "No column named #{column_name.inspect} found in table #{table_name.inspect} (attribute on fixture #{name.inspect})" unless columns_hash[column_name]
+            columns_to_include.add(columns_hash[column_name])
+          end
+        end
+
+        # now build the INSERT statement
+        quoted_column_names = columns_to_include.collect { |column| connection.quote_column_name(column.name) }.join(', ')
+        statements <<
+          "INSERT INTO #{connection.quote_table_name table_name} (#{quoted_column_names}) VALUES " +
+          embellished_rows.collect do |name, attributes|
+            '(' + columns_to_include.collect do |column|
+              if attributes.has_key?(column.name)
+                quote_value(column, attributes[column.name])
+              else
+                column.default_function || quote_value(column, column.default)
+              end
+            end.join(', ') + ')'
+          end.join(', ')
+      end
+
+      statements
+    end
+
+    def quote_value(column, value)
+      connection.quote(value)
+    rescue TypeError
+      connection.quote(YAML.dump(value))
+    end
+  end
+end

data/lib/fixation/fixtures.rb

@@ -0,0 +1,103 @@
+module Fixation
+  class Fixtures
+    def initialize
+      @class_names = {}
+      @fixture_ids = {}
+      @statements = {}
+
+      compile_fixture_files
+    end
+
+    def compile_fixture_files(connection = ActiveRecord::Base.connection)
+      puts "#{Time.now} building fixtures" if Fixation.trace
+
+      now = ActiveRecord::Base.default_timezone == :utc ? Time.now.utc : Time.now
+      Fixation.paths.each do |path|
+        Dir["#{path}/{**,*}/*.yml"].each do |pathname|
+          basename = pathname[path.size + 1..-5]
+          compile_fixture_file(pathname, basename, connection, now) if ::File.file?(pathname)
+        end
+      end
+
+      puts "#{Time.now} built fixtures for #{@fixture_ids.size} tables" if Fixation.trace
+    end
+
+    def compile_fixture_file(filename, basename, connection, now)
+      fixture_table = FixtureTable.new(filename, basename, connection, now)
+      fixture_name = basename.gsub('/', '_')
+      @fixture_ids[fixture_name] = fixture_table.fixture_ids
+      @statements[fixture_name] = fixture_table.statements
+      @class_names[fixture_name] = fixture_table.class_name
+    end
+
+    def apply_fixtures(connection = ActiveRecord::Base.connection)
+      connection.disable_referential_integrity do
+        connection.transaction do
+          apply_fixture_statements(connection)
+          clear_other_tables(connection) if Fixation.clear_other_tables
+        end
+      end
+    end
+
+    def apply_fixture_statements(connection)
+      @statements.each do |table_name, table_statements|
+        table_statements.each do |statement|
+          connection.execute(statement)
+        end
+      end
+    end
+
+    def clear_other_tables(connection)
+      (connection.tables - Fixation.tables_not_to_clear - @statements.keys).each do |table_name|
+        connection.execute("DELETE FROM #{connection.quote_table_name table_name}")
+      end
+    end
+
+    def fixture_methods
+      fixture_ids = @fixture_ids
+      class_names = @class_names
+
+      methods = Module.new do
+        def setup_fixtures(config = ActiveRecord::Base)
+          if run_in_transaction?
+            @@fixated_fixtures_applied ||= false
+            unless @@fixated_fixtures_applied
+              puts "#{Time.now} applying fixtures" if Fixation.trace
+              Fixation.apply_fixtures
+              @@fixated_fixtures_applied = true
+              puts "#{Time.now} applied fixtures" if Fixation.trace
+            end
+          else
+            @@fixated_fixtures_applied = false
+          end
+          super
+        end
+
+        fixture_ids.each do |fixture_name, fixtures|
+          begin
+            klass = class_names[fixture_name].constantize
+          rescue NameError
+            next
+          end
+
+          define_method(fixture_name) do |*fixture_names|
+            force_reload = fixture_names.pop if fixture_names.last == true || fixture_names.last == :reload
+
+            @fixture_cache[fixture_name] ||= {}
+
+            instances = fixture_names.map do |name|
+              id = fixtures[name.to_s]
+              raise StandardError, "No fixture named '#{name}' found for fixture set '#{fixture_name}'" if id.nil?
+
+              @fixture_cache[fixture_name].delete(name) if force_reload
+              @fixture_cache[fixture_name][name] ||= klass.find(id)
+            end
+
+            instances.size == 1 ? instances.first : instances
+          end
+          private fixture_name
+        end
+      end
+    end
+  end
+end

data/lib/fixation/version.rb

@@ -1,3 +1,3 @@
 module Fixation
-  VERSION = "1.3.0"
+  VERSION = "2.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fixation
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Will Bryant
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-07-20 00:00:00.000000000 Z
+date: 2016-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -57,6 +57,8 @@ files:
 - bin/setup
 - fixation.gemspec
 - lib/fixation.rb
+- lib/fixation/fixture_table.rb
+- lib/fixation/fixtures.rb
 - lib/fixation/version.rb
 homepage: https://github.com/willbryant/fixation
 licenses:
@@ -78,7 +80,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.5
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: 10x faster fixture startup under spring.