fixation 0.1.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 43ab7505aeb50e8b8eb654cc0e5b49194a67666d
-  data.tar.gz: ec50e822fa5ce18a86a9e2421e456421bacb7217
+  metadata.gz: ca6857caa4389c5c93c2be0ad4ddcd79bdd6895b
+  data.tar.gz: 3130d2d5b400e597fb04c57fd80a8bb0449e8cc1
 SHA512:
-  metadata.gz: 55d2e7768eaef0e82ad0ab9d12d8ada5ec0d57995ddc2c0a63a89c5689f828a37c99c8afb898205015696296d56785c249feb0d9a9cf15a9acc9d2fd17cc0fb3
-  data.tar.gz: c33f684d567d9654e510dbcc3fa3484dfed8fbc30df56237cfa3b3638213f6f02db25cbaa3dd136a23fcd7414ee9d2893b53be213dc5aa6386c5c6a15b69dbff
+  metadata.gz: f589e251617bf4efcb8e6818c35b1e471a06f07ce0dfc605edfa8ed4eeb1f779f29205cd844d609bffdfc22052f331d8cc234ff5d1f9fc158d7ff55752659fba
+  data.tar.gz: db7f49521e7a588e71a0d672c168053eba47193b3ada05d9fbc34687465d898bf7aa0f984bcf635c37fdc2cff8f189782ff4a8db3d184f5b4eba2fd1621715f9

data/README.md

@@ -2,8 +2,7 @@
 
 This gem will precompile the SQL statements needed to clear and repopulate your test tables with fixtures when the app boots under spring, so that spec startup just needs to run a small number of multi-row SQL statements to prepare for run.  This takes around 1/10th the time as a normal fixture load.
 
-To avoid any problems when you change your model classes, Fixation avoids loading model classes when it reads your fixture files.  This creates some incompatibilities with normal ActiveRecord fixtures for certain use cases - see Limitations below.
-
+Like ActiveRecord's normal fixture implementation, Fixation will load the model classes in order to use metadata about associations and enums.  But since Fixation is run at the time spring starts, Fixation will then 'reload' rails (the same way spring does), so you can change your model classes and re-run tests without having to restart spring.
 
 ## Installation
 
@@ -23,39 +22,41 @@ Or install it yourself as:
 
 Then, make an initializer:
 
-    if ENV['PRELOAD_FIXTURES'].to_i > 0 && Rails.env.test?
-      Rails.application.config.after_initialize do
-        require 'spec/fixture_helper'
-        Fixation.build_fixtures
-      end
-    end
+```ruby
+if Rails.env.test? && Fixation.running_under_spring?
+  Rails.application.config.after_initialize do
+    Fixation.preload_for_spring
+  end
+end
+```
 
 And run `spring stop` so this gets picked up.
 
 Finally, open up your spec_helper.rb, and find the current `global_fixtures` setting:
 
-    config.global_fixtures = :all
+```ruby
+config.global_fixtures = :all
+```
 
 Change that to [] so that ActiveRecord doesn't load the fixtures again itself, and load the Fixation module:
 
-    config.global_fixtures = []
-    config.include Fixation.fixture_methods
+```ruby
+config.global_fixtures = []
+config.include Fixation.fixture_methods
+```
 
 ## Usage
 
-Add the PRECOMPILE_FIXTURES=1 option to your spring test commands:
+Simply use run your tests under spring.
 
-    PRECOMPILE_FIXTURES=1 bundle exec spring spec/models/my_spec.rb
+    bundle exec spring spec/models/my_spec.rb
 
 ## Limitations
 
-PRECOMPILE_FIXTURES is not on by default in our suggested initializer above, because you don't want it set when running rake tasks like `db:create` and `db:test:prepare` - the initializer above will asplode if you do.  This is one of the biggest drawbacks of this version of the gem.
+You'll need to run rake tasks like `db:create` and `db:test:prepare` the normal way (without spring), because if the database doesn't exist or the schema isn't loaded, the initializer above will asplode.
 
-Because Fixation wants to avoid loading your model classes when the app initializes, not all features of regular ActiveRecord fixtures are supported:
-* the fixture filenames must match the database table names directly - whereas ActiveRecord actually assumes the filenames are underscored versions of the model class names, and it uses that class's configured table name
-* when using the identify syntax to set association foreign keys, you must use the name that corresponds to the foreign key attribute (for example, `parent: sue` if you want to set the `parent_id` field to the appropriate value for the fixture called `sue`) - whereas ActiveRecord accepts the name of the association (`lead_carer: sue`) even if it uses a different foreign key name (`belongs_to :lead_carer, :foreign_key => :parent_id`)
+Not all features of regular ActiveRecord fixtures are supported:
 * HABTM support has not been implemented (does anyone use HABTM these days?)
-* enums are not known
 
 ## Contributing
 

data/lib/fixation.rb

@@ -14,6 +14,20 @@ module Fixation
       @table_name = table_name
       @connection = connection
       @now = now
+
+      @klass_name = @table_name.classify
+      begin
+        @klass = @klass_name.constantize
+        @klass = nil unless @klass < ActiveRecord::Base
+      rescue NameError
+        ActiveRecord::Base.logger.warn "couldn't load #{@klass_name} for fixture table #{table_name}: #{$!}"
+      end
+
+      if @klass
+        @primary_key = @klass.primary_key
+        @record_timestamps = @klass.record_timestamps
+        @inheritance_column = @klass.inheritance_column
+      end
     end
 
     def columns_hash
@@ -49,12 +63,8 @@ module Fixation
 
     def embellish_fixture(name, attributes, columns_hash)
       # populate the primary key column, if not already set
-      if columns_hash['id'] && !attributes.has_key?('id')
-        attributes['id'] = Fixation.identify(name, columns_hash['id'].type)
-      end
-
-      if columns_hash['uuid'] && !attributes.has_key?('uuid')
-        attributes['uuid'] = Fixation.identify(name, columns_hash['uuid'].type)
+      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
@@ -63,27 +73,50 @@ module Fixation
       end
 
       # populate any timestamp columns, if not already set
-      %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)
+      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 any association names into the identity column equivalent
+      # 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
-      nonexistant_columns.each do |column_name|
-        if columns_hash["#{column_name}_id"]
-          value = attributes.delete(column_name)
 
-          if columns_hash["#{column_name}_type"] && value.is_a?(String) && value.sub!(/\s*\(([^\)]*)\)\s*$/, "")
-            # support polymorphic belongs_to as "label (Type)"
-            attributes["#{column_name}_type"] = $1
+      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
 
-          attributes["#{column_name}_id"] = value ? Fixation.identify(value) : value
-        else
-          raise ActiveRecord::Fixture::FormatError, "No column named #{column_name} found in table #{table_name}"
+        nonexistant_columns.each do |column_name|
+          association = reflection_class._reflections[column_name.to_sym]
+
+          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
@@ -163,9 +196,11 @@ module Fixation
     end
 
     def apply_fixtures(connection = ActiveRecord::Base.connection)
-      @statements.each do |table_name, table_statements|
-        table_statements.each do |statement|
-          connection.execute(statement)
+      connection.transaction do
+        @statements.each do |table_name, table_statements|
+          table_statements.each do |statement|
+            connection.execute(statement)
+          end
         end
       end
     end
@@ -223,17 +258,13 @@ module Fixation
   cattr_accessor :paths
   self.paths = %w(test/fixtures spec/fixtures)
 
-  def self.build_fixtures
-    subclasses_before = ActiveRecord::Base.subclasses
+  def self.preload_for_spring
+    build_fixtures
+    unload_models!
+  end
 
+  def self.build_fixtures
     @fixtures = Fixtures.new
-
-    subclasses_after = ActiveRecord::Base.subclasses
-
-    unless subclasses_after.size == subclasses_before.size
-      new_subclasses = subclasses_after - subclasses_before
-      puts "warning: #{new_subclasses.to_sentence} #{new_subclasses.size == 1 ? 'was' : 'were'} auto-loaded while loading fixtures.  #{new_subclasses.size == 1 ? 'this class' : 'these classes'} may not reload properly."
-    end
   end
 
   def self.apply_fixtures
@@ -259,4 +290,20 @@ module Fixation
       ActiveRecord::FixtureSet.identify(label, column_type)
     end
   end
+
+  def self.running_under_spring?
+    defined?(Spring::Application)
+  end
+
+  # reloads Rails (using the code from Spring) in order to unload the model classes that get
+  # auto-loaded when we read the fixture definitions.
+  def self.unload_models!
+    # Rails 5.1 forward-compat. AD::R is deprecated to AS::R in Rails 5.
+    if defined? ActiveSupport::Reloader
+      Rails.application.reloader.reload!
+    else
+      ActionDispatch::Reloader.cleanup!
+      ActionDispatch::Reloader.prepare!
+    end
+  end
 end

data/lib/fixation/version.rb

@@ -1,3 +1,3 @@
 module Fixation
-  VERSION = "0.1.1"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fixation
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Will Bryant
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-03-24 00:00:00.000000000 Z
+date: 2016-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler