named_seeds 1.1.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2dd15c25329b3392795fb29d32abaac3a1066b4c
-  data.tar.gz: f8ccffe2fe567906116a45ec4f7c1cf1235b7f62
+  metadata.gz: ecc617dea1b86fbaaea2fe3a16c381ba67d26e84
+  data.tar.gz: ba2a23916011c5572f70dd1c1b22a5dc1fe947ff
 SHA512:
-  metadata.gz: 35a1cb0ee44477f9c052fc64c7808a08a1c2f2c349ec561e41a4c616b6c6175cb52015288d297daecb6b8538c83d937400059fcb84d4fc6587b1ce81f0020768
-  data.tar.gz: 8c8e10690ce1ff0f79dec55754a19b6e1e3212de56854b207dac944a84ac786d0180cbcd155c7ef7cf2284dff90d19d8506028fe388df5094e22108f36a8e756
+  metadata.gz: dab6ede0737548ebb3e27246c9812e5117daa2e6166617f31050d8d1943e15bd6b5759e99ff0012909bdfc30937d1dd1b6b986f2d477c62493b3a0b466252817
+  data.tar.gz: 489d186ee125e43b2a8a56a0cc7125bd0bb1e7f0d9758e3fa7ed61b37873b2db8d41b6306edf9a2e330ab4e81954eec645af8411fde3ac6986e0133656116b54

data/.gitignore

@@ -2,6 +2,7 @@
 *.rbc
 .bundle
 .config
+.ruby-version
 .yardoc
 Gemfile.lock
 InstalledFiles
@@ -15,3 +16,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+gemfiles/*

data/.travis.yml

@@ -0,0 +1,14 @@
+sudo: false
+cache: bundler
+rvm:
+  - 2.0.0
+  - 2.1.5
+  - 2.2.1
+install:
+  - gem install bundler
+  - bundle --version
+  - bundle install
+before_script:
+  - bundle exec appraisal install
+script:
+  - bundle exec appraisal rake test

data/Appraisals

@@ -0,0 +1,12 @@
+
+appraise 'rails40' do
+  gem 'rails', '~> 4.0.0'
+end
+
+appraise 'rails41' do
+  gem 'rails', '~> 4.1.0'
+end
+
+appraise 'rails42' do
+  gem 'rails', '~> 4.2.0'
+end

data/Gemfile

@@ -1,2 +1,5 @@
 source 'https://rubygems.org'
 gemspec
+
+gem 'terminal-notifier-guard' if RbConfig::CONFIG["host_os"] =~ /darwin/
+

data/Guardfile

@@ -0,0 +1,18 @@
+clearing :on
+notification :terminal_notifier if defined?(TerminalNotifier)
+
+guard :minitest, {
+  all_on_start: true,
+  autorun: false,
+  include: ['lib', 'test'],
+  test_folders: ['test'],
+  test_file_patterns: ["*_test.rb"]
+} do
+  if ENV['TEST_FILES']
+    ENV['TEST_FILES'].split(',').map(&:strip).each do |file|
+      watch(%r{.*}) { file }
+    end
+  else
+    watch(%r{.*}) { 'test' }
+  end
+end

data/README.md

@@ -1,28 +1,24 @@
-# NamedSeeds
 
-**Almost Ready for Rails 4.2.0.beta2**
+<img width="502" height="298" alt="NamedSeeds - When it comes to fast tests... you reap what you sow!" src="https://cloud.githubusercontent.com/assets/2381/6770492/c7093fa6-d097-11e4-9e1f-6f90a857f8d3.png" />
 
-* [Various Issues With 4.2.0.beta2 DB Setup/Testing](https://github.com/rails/rails/issues/17170)
-* [The `test:prepare` Task Might Be Useless Now?](https://github.com/rails/rails/issues/17171)
+<hr>
 
-**Make your tests fast by augmenting them with transactional fixtures powered by your favorite factory library!**
+**Make your tests fast by augmenting them with transactional fixtures
+powered by your favorite factory library!**
 
-We all know that ActiveRecord::Fixtures are hard to maintain and are disconnected from the models that save your data. But Rails did get something right with transactional tests and easy helper methods to access fixtures by name. NamedSeeds aims to be a drop-in replacement for Rails fixtures or an enhancement to RSpec and Cucumber while using any object generator of your choice!
+We all know that ActiveRecord's fixtures are hard to maintain, and more importantly, disconnected from the models that create your data. This disconnect can lead to invalid or incomplete representations of your objects as your application grows. But Rails did get something right. Fixtures combined with transactional tests are a huge performance win while providing [canned references among your team](http://martinfowler.com/bliki/ObjectMother.html) via helper methods that find fixtures using a unique name. The NamedSeeds gem aims to replace YAML fixtures by providing a slim identification layer to be used in conjunction with your factory library of choice. For example, [FactoryGirl](https://github.com/thoughtbot/factory_girl).
 
-The idea is to leverage your tests' existing factories to generate fixtures that will be populated before testing starts and to use a database transaction strategy around each test. In this way you have a populated story that can be accessed via convienient helper methods like `users(:admin)` which in turn yields much faster test runs. Database fixtures, even those seeded by factories, are not a panacea and we highly suggested that you continue to use factories in your tests when it makes sense to do so. For those that think this is mad or have FUD to share, please see my blog articles:
+The idea is to leverage your tests' existing factories to generate fixtures that will be populated before testing starts and to use a database transaction strategy around each test. In this way you have a curated set of personas that can be accessed via convenient helper methods like `users(:admin)` which in turn yields much faster test runs. **NamedSeeds fixtures also become your seed data for Rails' development environment.** This consistency between development and testing is a huge win for on-boarding new team members. Lastly, database fixtures, even those seeded by factories, are not a panacea and we recommend that you continue to use factories in your tests for edge cases when it makes sense to do so.
 
-* Inprogress...
-* Inprogress...
+NamedSeeds is best when your factories follow two key principals:
 
-
-## Versions
-
-The current master branch is for Rails v4.2.0 and up and follows v1.1 major version. Please use our `1-0-stable` branch for Rails v3.1 to v4.1.
+* Leveraging your models for most business logic.
+* Creation of "valid garbage" with no/minimal args while allowing idempotency via explicit args.
 
 
 ## Installation
 
-Add the named_seeds gem to your Rails' Gemfile in both the development and test group as shown below. This is needed as the NamedSeeds gem exposes rake tasks needed in both environments.
+Add the gem to your Rails' Gemfile in both the development and test group as shown below. This is needed since the NamedSeeds gem has integrations in both environments.
 
 ```ruby
 group :development, :test do
@@ -30,109 +26,188 @@ group :development, :test do
 end
 ```
 
-That's it! The NamedSeeds gem will hook into the Rails test cycle to make sure your factoried fixtures (and any engine seeds) are populated after your test schema is created and before your test suite runs.
 
-## Usage
+## Quick Start
 
-NamedSeeds requires that you create a `db/test/seeds.rb` file. The contents of this file can be anything you want. We recommend using a factory library like [FactoryGirl](https://github.com/thoughtbot/factory_girl) or [Machinist](https://github.com/notahat/machinist).
+NamedSeeds only requires that you customize the Rails `db/seeds.rb` file. The contents of this file can be anything you want! We recommend using a factory library like [FactoryGirl](https://github.com/thoughtbot/factory_girl) or [Machinist](https://github.com/notahat/machinist).
 
 ```ruby
 require 'factory_girl'
+include FactoryGirl::Syntax::Methods
 FactoryGirl.find_definitions rescue false
+FactoryGirl.lint
+
+@bob = create :user, id: NamedSeeds.identify(:bob), email: 'bob@test.com'
+```
+
+In this example we have given our Bob user an explicit primary key using the identify method of NamedSeeds. This ensures we have a handle on Bob in our tests. For this happen, make the following changes to your Rails `test_helper.rb` file.
+
+```ruby
+ENV["RAILS_ENV"] = "test"
+require File.expand_path('../../config/environment', __FILE__)
+require 'rails/test_help'
+NamedSeeds.load_seed
 
-@bob = FactoryGirl.create :user, id: NamedSeeds.identify(:bob), email: 'bob@test.com'
+class ActiveSupport::TestCase
+
+  named_seeds :users
+
+end
 ```
 
-Use the `NamedSeeds.identify` method to give a name to the identity used for this record. You will be able to find this record using that name later on.
+Here we have added `NamedSeeds.load_seed` after our requires. This ensures our test database is properly seeded. We have also added a `named_seeds :users` declaration that creates a test helper method that can find any persona with a matching identity. The method name follows ActiveRecord model/table name conventions. So in this case we expect to find a `User` model. An example of what our unit test for Bob might look like with the new `users` fixture helper would be:
 
+```ruby
+require 'test_helper'
 
-#### Integration Notes
+class UserTest < ActiveSupport::TestCase
 
-The NamedSeeds gem will hook into ActiveRecord's `db:setup` task. This means that new developers can checkout your code and run the normal Rails setup process and see a fully populated development database that has the same seed/fixtures story used by your tests. For example:
+  tests "should work" do
+    user = users(:bob)
+    assert_equal 'bob@test.com', user.email
+  end
 
+end
 ```
+
+This test is very contrived and is only meant to illustrate the `users(:bob)` test helper which closely mimics ActiveRecord's fixture helpers.
+
+
+## Detailed Usage
+
+#### Development Benefits
+
+NamedSeeds hooks into the `db:setup` process. In this way, the same fixture story seeded in your test environment is the same in development. For example, if you are on-boarding a new developer and bootstrapping their environment.
+
+```shell
 $ bundle
-$ rake db:create:all
-$ rake db:setup
+$ rake db:create:all db:setup
 ```
 
-If you need to force a reload of your development environment's data, just use Rails conventions. For example, the `db:reset` task calls setup, so NamedSeeds will hook in at the right place.
+Your local development database will now contain all fixtures created in db/seeds. As you fixtures grow, re-create your development environment with confidence.
 
+
+```shell
+$ bundle
+$ rake db:drop:all db:create:all db:setup
 ```
-$ rake db:reset
+
+#### The NamedSeeds::DSL
+
+If you do not like typing `NamedSeeds.identify(:persona)` over and over again in your seeds file, you can include the `NamedSeeds::DSL` at the top. This will give you direct scope to the `identify` method which is also succinctly aliased to just `id` if you want.
+
+```ruby
+include NamedSeeds::DSL
+
+id(:ruby)       # => 207281424
+id(:sapphire_2) # => 1066363776
 ```
 
-Likewise, if you wanted to reset your test database and pre-populate it with named seeds/fixtures you can run the following:
+#### UUID Identifiers
+
+By default identities boil down to a consistent integer whose values are less than 2^30. These are great for typical primary or foreign keys. Now that Rails supports UUID keys in both models and ActiveRecord fixtures, so does the NamedSeeds gem. The identity method can use an optional second parameter to denote the SQL type when seeding your database.
 
+```ruby
+id(:ken, :uuid) # => '4f156606-8cb3-509e-a177-956ca0a22015'
 ```
-$ spring stop && rake db:test:prepare
+
+So if our `User` model did use a UUID column type, our seed file might look like this.
+
+```ruby
+@bob = create :user, id: NamedSeeds.identify(:bob), email: 'bob@test.com'
 ```
 
-#### Rails
+#### String Identifier
 
-By default, Rails' ActiveSupport::TestCase has set the `use_transactional_fixtures` to true. So all you need to do is declare which tables have NamedSeeds keys.
+If your model uses strings for primary keys or what is known as "natural" keys, then NamedSeeds can still work for you. First, create your seed data without the identity helper. For example, below we are seeding US states in a contrived lookup table.
 
 ```ruby
-class ActiveSupport::TestCase
-  named_seeds :users, :posts
-end
+# In db/seeds.rb file.
+create :state, id: 'VA', name: 'Virginia'
+create :state, id: 'WA', name: 'Washington'
 ```
 
-Now you can use both the `users` and `posts` helper methods to find any named identity from your seed file.
+Here the primary key of the `State` model is a string column. You have two options to generate test helpers for these objects. Note that none are technically needed since the identities are known and not random integers.
 
 ```ruby
-require 'test_helper'
-class UserTest < ActiveSupport::TestCase
-  setup { @user = users(:bob) }
-  tests "should work" do
-    assert_equal 'bob@test.com', @user.posts
-  end
-end
+named_seeds :states, identities: {virginia: 'VA', washington: 'WA'}
+states(:virginia) # => #<State id: 'VA'... >
+
+named_seeds :states, identities: :natural
+states('VA')      # => #<State id: 'VA'... >
+
 ```
 
-#### RSpec
+By passing an identities hash to `named_seeds` you can customize the name of the key used in finders. The first line would generate a method that allows you to find states using the longer identities key values. This is great if your natural keys do not necessarily speak to the persona/object under test. If you wanted to use the natural key string values, you can just pass `:natural` to the identities option.
+
+#### Setting Fixture Classes
 
-Coming soon...
+If your test helper name can not infer the class name, just use the `:class` option when declaring seeds in your test helper.
 
-#### Cucumber
+```ruby
+named_seeds :users, class: Legacy::User
+```
 
-Coming soon...
+#### Moving From ActiveRecord Fixtures
 
+Unlike ActiveRecord fixtures, NamedSeeds does not support loading fixtures per test case. Since the entire fixture story is loaded before the test suite runs. NamedSeeds is much more akin to `fixtures(:all)` and the `named_seeds` method is more about creating test helper methods to access named fixtures. Lastly, NamedSeeds has no notion of instantiated fixtures.
+
+#### Using DatabaseCleaner
+
+Rails 4 (maybe starting in 4.1) now has a new test database synchronization strategy. No longer is your entire development schema cloned when you run your tests. This saves time when running tests but it also adds a potential gotcha when using db/seeds.rb with the NamedSeeds gem. We recommend using the DatabaseCleaner gem and cleaning your DB at the top of your seed file.
+
+```ruby
+# In your Gemfile.
+group :development, :test do
+  gem 'named_seeds'
+  gem 'database_cleaner'
+end
+
+# Top of db/seeds.rb file.
+require 'database_cleaner'
+DatabaseCleaner.clean_with :truncation
+DatabaseCleaner.clean
+```
 
 
 ## Configurations
 
-NamedSeeds is a `Rails::Railtie` that exposes a few `config` options. So open up the `config/environments/development.rb` **(yes in development.rb)** and use the `config.named_seeds` options below. NOTE: I have found that sometimes I need to add some configurations to `config/environments/test.rb` too.
+#### Other Rails::Engine And Seed Loaders
 
-* *app_load_seed* - Load your Rails application's db/seeds.rb file into the test database. This is done before db/test/seeds.rb is loaded. Default is `true` but may people use this file incorrectly vs standard lookup tables.
-* *engines_with_load_seed* - Some Rails engines provide a load seed hook. If you want NamedSeed to call the engine's seed method into your tests database, push the engine constant to this array. Any object responding to `load_seed` sould work here too. Default is an empty array.
+Rails::Engines are a great way to distribute shared functionality. Rails exposes a hook called `load_seed` that an engine can implement. These are great for seeding tables that an engine's models may need. You can tell NamedSeeds to use any object that responds to `load_seed` and each will be called after `db/seeds.rb` is loaded. For example:
 
 ```ruby
-My::Application.configure do
-  config.named_seeds.app_load_seed = false
-  config.named_seeds.engines_with_load_seed += [GeoData::Engine, OurLookupTables]
+# In config/initializers/named_seeds.rb
+
+if defined?(NamedSeeds)
+  Rails.application.config.named_seeds.engines_with_load_seed = [
+    GeoData::Engine,
+    OurLookupTables
+  ]
+  end
 end
 ```
 
-NamedSeeds relies on ActiveRecord's `ActiveRecord::Migration.maintain_test_schema!` setting. We do not want to get into the business of coupling too much with the internals of Rails and hance assume this is true.
 
+## Versions
 
-## Todo
+The current master branch is for Rails v4.0.0 and up and. Please use our `1-0-stable` branch for Rails v3.x.
 
-Show Rails implementation using ActiveSupport::TestCase or RSpec.
 
-Show examples with these 3 factory libraries.
+## Contributing
 
-* https://github.com/thoughtbot/factory_girl
-* https://github.com/paulelliott/fabrication
-* https://github.com/notahat/machinist
+We use the [Appraisal](https://github.com/thoughtbot/appraisal) gem from Thoughtbot to help us test different versions of Rails. The `rake appraisal test` command actually runs our test suite against all Rails versions in our `Appraisal` file. So after cloning the repo, running the following commands.
 
-Set up a dummy_application in test.
+```shell
+$ bundle install
+$ bundle exec appraisal install
+$ bundle exec appraisal rake test
+```
+
+If you want to run the tests for a specific Rails version, use one of the appraisal names found in our `Appraisals` file. For example, the following will run our tests suite for Rails 4.1.x.
 
-How are we different from:
+```shell
+$ bundle exec appraisal rails41 rake test
+```
 
-* https://github.com/mbleigh/seed-fu
-* https://github.com/sevenwire/bootstrapper/
-* https://github.com/franciscotufro/environmental_seeder
 
-Talk about http://railscasts.com/episodes/179-seed-data

data/TODO.md

@@ -0,0 +1,23 @@
+## Alternative Solutions
+
+There are no absolutes, especially when it comes to software. That said, we think NamedSeeds is the best way to use fixtures. It encourages... (good factoies)
+
+Everyone loves their own brand :poop:
+
+
+* Seedbank gives your Rails seed data a little structure.
+  https://github.com/james2m/seedbank
+
+
+* Relational seeding for Rails apps
+  https://github.com/vigetlabs/sprig
+* Rails 4 task to dump (parts) of your database to db/seeds.rb
+  https://github.com/rroblak/seed_dump
+* Allows composing fixture sets
+  https://github.com/optoro/composable_fixtures
+* Advanced seed data handling for Rails, combining the best practices of several methods together.
+  https://github.com/mbleigh/seed-fu
+* Auto generate factories from data
+  https://github.com/markburns/to_factory
+
+

data/lib/named_seeds.rb

@@ -1,7 +1,22 @@
 require 'rails'
 require 'active_record'
 require 'named_seeds/version'
-require 'named_seeds/identity'
-require 'named_seeds/read'
 require 'named_seeds/railtie'
-require 'named_seeds/active_support'
+require 'named_seeds/uuid'
+require 'named_seeds/dsl'
+require 'named_seeds/identity'
+require 'named_seeds/rails'
+
+module NamedSeeds
+
+  extend DSL
+
+  def self.load_seed
+    Railtie.load_seed
+  end
+
+  def self.reset_cache
+    Identity.reset_cache
+  end
+
+end

data/lib/named_seeds/dsl.rb

@@ -0,0 +1,24 @@
+require 'zlib'
+
+module NamedSeeds
+  module DSL
+
+    MAX_ID = 2 ** 30 - 1
+
+    # Copy of ActiveRecord::Fixtures.identify method.
+    # Returns a consistent, platform-independent identifier for +label+.
+    # Integer identifiers are values less than 2^30.
+    # UUIDs are RFC 4122 version 5 SHA-1 hashes.
+    #
+    def identify(label, column_type = :integer)
+      if column_type == :uuid
+        NamedSeeds.uuid_v5(label)
+      else
+        Zlib.crc32(label.to_s) % MAX_ID
+      end
+    end
+    alias_method :id, :identify
+
+  end
+end
+

data/lib/named_seeds/identity.rb

@@ -1,11 +1,70 @@
-require 'zlib'
+require 'active_record/fixtures'
 
 module NamedSeeds
-  
-  # A direct copy of ActiveRecord::Fixtures.identify.
-  # Returns a consistent, platform-independent identifier for +label+ that are positive integers less than 2^32.
-  def self.identify(label)
-    Zlib.crc32(label.to_s) % (2 ** 30 - 1)
+
+  class FixtureClassNotFound < ActiveRecord::FixtureClassNotFound
+  end
+
+  class Identity
+
+    @@all_cached = Hash.new
+
+    class << self
+
+      def reset_cache
+        @@all_cached.clear
+      end
+
+      def named(name, options)
+        @@all_cached[name] ||= new(name, options)
+      end
+
+    end
+
+    def initialize(name, options={})
+      @name = name
+      @options = options
+      @fixtures = {}
+    end
+
+    def find(*identities)
+      fixtures = identities.map { |identity| model_find(identity) }
+      fixtures.many? ? fixtures : fixtures.first
+    end
+
+    def identities
+      @options[:identities] || @options[:ids]
+    end
+
+
+    private
+
+    def model_find(identity)
+      @fixtures[identity.to_s] ||= model_class.unscoped { model_class.find model_id(identity) }
+    end
+
+    def model_class
+      return @model_class if defined?(@model_class)
+      @model_class = (@options[:class] || @options[:klass]) || @name.to_s.classify.safe_constantize
+      raise FixtureClassNotFound, "No class found for named_seed #{@name.inspect}. Use :class option." unless @model_class
+      @model_class
+    end
+
+    def model_id(identity)
+      case identities
+      when NilClass then NamedSeeds.identify(identity, model_primary_key_type)
+      when Hash     then identities[identity]
+      when :natural then identity
+      end
+    end
+
+    def model_primary_key_type
+      type     = model_class.column_types[model_class.primary_key].type
+      sql_type = model_class.columns_hash[model_class.primary_key].sql_type
+      return :uuid if ['uuid', 'guid', 'uniqueidentifier'].include?(sql_type)
+      type ? type.to_sym : :id
+    end
+
   end
 
-end  
+end

data/lib/named_seeds/rails.rb

@@ -0,0 +1,27 @@
+require 'active_support/concern'
+require 'active_support/test_case'
+
+module NamedSeeds
+  module TestHelper
+
+    extend ActiveSupport::Concern
+
+    def after_teardown
+      super
+      NamedSeeds.reset_cache
+    end
+
+    module ClassMethods
+
+      def named_seeds(name, options={})
+        define_method(name) do |*identities|
+          Identity.named(name, options).find(*identities)
+        end
+      end
+
+    end
+
+  end
+end
+
+ActiveSupport::TestCase.send :include, NamedSeeds::TestHelper

data/lib/named_seeds/railtie.rb

@@ -1,44 +1,26 @@
+require 'active_record/tasks/database_tasks'
+
 module NamedSeeds
   class Railtie < Rails::Railtie
 
     config.named_seeds = ActiveSupport::OrderedOptions.new
-    config.named_seeds.app_load_seed          = true
     config.named_seeds.engines_with_load_seed = []
 
     config.before_initialize do |app|
-      Rails.application.paths.add 'db/test/seeds', with: 'db/test/seeds.rb'
-    end
-
-    rake_tasks do
-      load "named_seeds/railties/databases.rake"
-    end
-
-    def setup
-      load test_seed_file if test_seed_file
+      ActiveRecord::Tasks::DatabaseTasks.seed_loader = NamedSeeds::Railtie
     end
 
-    def prepare
-      return unless test_seed_file
-      load_all_seeds
-      setup
+    def load_seed
+      Rails.application.load_seed
+      engines_load_seed
     end
 
 
     protected
 
-    def load_all_seeds
-      ActiveRecord::Tasks::DatabaseTasks.load_seed if config.named_seeds.app_load_seed
+    def engines_load_seed
       config.named_seeds.engines_with_load_seed.each { |engine| engine.load_seed }
     end
 
-    def test_seed_file
-      Rails.application.paths["db/test/seeds"].existent.first
-    end
-
   end
-
-  def self.prepare
-    NamedSeeds::Railtie.prepare
-  end
-
 end

data/lib/named_seeds/uuid.rb

@@ -0,0 +1,18 @@
+require 'securerandom'
+
+module NamedSeeds
+
+  # Copy of ActiveSupport's Digest::UUID extension for v5 UUIDs.
+  # Needed to maintain backward compatibility with Rails 4.0 and 4.1.
+  #
+  def self.uuid_v5(name)
+    hash = Digest::SHA1.new
+    hash.update("k\xA7\xB8\x12\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8")
+    hash.update(name.to_s)
+    ary = hash.digest.unpack('NnnnnN')
+    ary[2] = (ary[2] & 0x0FFF) | (5 << 12)
+    ary[3] = (ary[3] & 0x3FFF) | 0x8000
+    "%08x-%04x-%04x-%04x-%04x%08x" % ary
+  end
+
+end

data/lib/named_seeds/version.rb

@@ -1,3 +1,19 @@
 module NamedSeeds
-  VERSION = "1.1.0"
+
+  module VERSION
+    MAJOR = 2
+    MINOR = 0
+    TINY  = 0
+    PRE   = nil
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+
+  def self.version
+    Gem::Version.new VERSION::STRING
+  end
+
+  def self.version_string
+    VERSION::STRING
+  end
+
 end

data/named_seeds.gemspec

@@ -2,20 +2,23 @@
 $:.push File.expand_path("../lib", __FILE__)
 require "named_seeds/version"
 
-Gem::Specification.new do |gem|
-  gem.name          = "named_seeds"
-  gem.version       = NamedSeeds::VERSION
-  gem.authors       = ["Ken Collins"]
-  gem.email         = ["ken@metaskills.net"]
-  gem.summary       = %q|Replace ActiveRecord::Fixtures With #{your_factory_lib}.|
-  gem.description   = %q|Make you tests fast by augmenting them with transactional fixtures powered by your favorite factory library!|
-  gem.homepage      = "http://github.com/metaskills/named_seeds"
-  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  gem.files         = `git ls-files`.split("\n")
-  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  gem.require_paths = ["lib"]
-  gem.add_runtime_dependency     'rails', '~> 4.2.0.beta2'
-  gem.add_development_dependency 'sqlite3'
-  gem.add_development_dependency 'rake'
-  gem.add_development_dependency 'minitest'
+Gem::Specification.new do |spec|
+  spec.name          = "named_seeds"
+  spec.version       = NamedSeeds.version_string
+  spec.authors       = ["Ken Collins"]
+  spec.email         = ["ken@metaskills.net"]
+  spec.summary       = %q|Replace ActiveRecord::Fixtures With #{your_factory_lib}.|
+  spec.description   = %q|Make you tests fast by augmenting them with transactional fixtures powered by your favorite factory library!|
+  spec.homepage      = "http://github.com/metaskills/named_seeds"
+  spec.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  spec.files         = `git ls-files`.split("\n")
+  spec.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  spec.require_paths = ["lib"]
+  spec.add_runtime_dependency     'rails', '>= 4.0'
+  spec.add_development_dependency 'appraisal'
+  spec.add_development_dependency 'guard'
+  spec.add_development_dependency 'guard-minitest'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'sqlite3'
 end

data/test/cases/dsl_test.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+
+class DslTest < NamedSeeds::TestCase
+
+  module T ; extend NamedSeeds::DSL ; end
+
+  def test_includes_all_methods
+    assert_equal 207281424, T.identify(:ruby)
+    assert_equal 207281424, T.id(:ruby)
+  end
+
+
+end

data/test/cases/identify_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+class IdentifyTest < NamedSeeds::TestCase
+
+  def test_works_on_strings
+    assert_equal     id('foo'), id('foo')
+    assert_not_equal id('FOO'), id('foo')
+  end
+
+  def test_works_on_symbols
+    assert_equal id('foo'), id(:foo)
+  end
+
+  def test_identifies_consistently
+    assert_equal 207281424,  id(:ruby)
+    assert_equal 1066363776, id(:sapphire_2)
+  end
+
+  def test_can_generate_uuid_identities
+    assert_match '4f156606-8cb3-509e-a177-956ca0a22015', id(:ken, :uuid)
+  end
+
+end

data/test/cases/named_seeds_test.rb

@@ -0,0 +1,73 @@
+require 'test_helper'
+
+class NamedSeedsTest < NamedSeeds::TestCase
+
+  named_seeds :users
+  named_seeds :posts
+  named_seeds :states, identities: {virginia: 'VA', washington: 'WA'}
+  named_seeds :enterprise_objects
+
+  named_seeds :natural_id_states, identities: :natural, class: State
+  named_seeds :classy_users, class: User
+  named_seeds :no_model_class
+
+
+  def test_generated_method_that_can_find_a_record
+    assert_equal @@ken, users(:ken)
+  end
+
+  def test_not_found_is_just_plain_active_record_exceptions
+    assert_raise(ActiveRecord::RecordNotFound) { users(:not_found) }
+  end
+
+  def test_can_pass_multiple_names_to_fixture_accessor
+    assert_equal [@@ken, @@john], users(:ken, :john)
+    assert_equal [@@virginia, @@washington], states(:virginia, :washington)
+    assert_equal [@@virginia, @@washington], natural_id_states('VA', 'WA')
+  end
+
+  def test_can_find_string_primary_keys_using_identities_hash_option
+    assert_equal @@virginia, states(:virginia)
+  end
+
+  def test_can_find_string_primary_keys_using_identities_natural_option
+    assert_equal @@virginia, natural_id_states('VA')
+  end
+
+  def test_caches_fixture_lookups
+    assert_equal users(:ken).object_id, users(:ken).object_id
+  end
+
+  def test_can_reset_the_fixture_lookup_cache
+    ken1 = users(:ken)
+    NamedSeeds.reset_cache
+    ken2 = users(:ken)
+    assert_not_equal ken1.object_id, ken2.object_id
+  end
+
+  def test_can_define_a_bad_named_seed_with_no_model_and_lazily_see_an_exception
+    assert_raise(NamedSeeds::FixtureClassNotFound) { no_model_class(:name) }
+  end
+
+  def test_named_seeds_fixtur_class_not_found_subclasses_activerecords
+    assert NamedSeeds::FixtureClassNotFound < ActiveRecord::FixtureClassNotFound
+  end
+
+  def test_can_find_named_seed_with_uuid_primary_key
+    assert_equal @@enterprising_ken, enterprise_objects(:ken)
+  end unless TESTING_RAILS_40
+
+end
+
+module SomeNamespace
+  class User ; def self.find(id) ; self.new ; end ; end
+  class NamespacedActiveSupportTest < NamedSeeds::TestCase
+
+    named_seeds :users
+
+    def test_generated_method_finds_proper_constant
+      assert_equal @@ken, users(:ken)
+    end
+
+  end
+end

data/test/support/active_record.rb

@@ -1,14 +1,48 @@
 require 'active_record/base'
 
+TESTING_RAILS_40 = Gem::Dependency.new('rails', '~> 4.0.0') =~ Gem::Dependency.new('rails', Rails::VERSION::STRING)
+TESTING_RAILS_41 = Gem::Dependency.new('rails', '~> 4.1.0') =~ Gem::Dependency.new('rails', Rails::VERSION::STRING)
+TESTING_RAILS_42 = Gem::Dependency.new('rails', '~> 4.2.0') =~ Gem::Dependency.new('rails', Rails::VERSION::STRING)
+
 ActiveRecord::Base.logger = nil
 ActiveRecord::Base.establish_connection adapter: 'sqlite3', database: ':memory:'
 
 ActiveRecord::Base.class_eval do
-  silence(:stdout) do
+  connection.instance_eval do
 
-    connection.create_table :users, force: true do |t|
+    create_table :users, force: true do |t|
       t.string :name, :email
     end
 
+    create_table :posts, id: false, force: true do |t|
+      t.primary_key :id, :uuid, default: nil
+      t.string :title, :body
+      t.references :user
+    end
+
+    create_table :states, id: false, force: true do |t|
+      t.primary_key :abbr, :string, default: nil
+      t.string :name
+    end
+
+    create_table :enterprise_objects, id: :uuid, primary_key: :id, force: true do |t|
+      t.string :name
+    end unless TESTING_RAILS_40
+
   end
 end
+
+class User < ActiveRecord::Base
+  has_many :posts
+end
+
+class Post < ActiveRecord::Base
+end
+
+class State < ActiveRecord::Base
+  self.primary_key = :abbr
+end
+
+class EnterpriseObject < ActiveRecord::Base
+  self.primary_key = :id
+end

data/test/test_helper.rb

@@ -1,15 +1,47 @@
 require 'rubygems'
-require "bundler/setup"
-Bundler.require
+require 'bundler' ; Bundler.require :development, :test
 require 'named_seeds'
-require 'minitest/autorun'
 require 'support/active_record'
+require 'active_support/test_case'
+require 'active_support/testing/autorun'
 
-ActiveSupport.test_order = :random
+ActiveSupport.test_order = :random if ActiveSupport.respond_to?(:test_order)
 
 module NamedSeeds
-  class Spec < MiniTest::Spec
+  class TestCase < ActiveSupport::TestCase
 
+    class << self
+
+      def id(*args)
+        NamedSeeds.identify(*args)
+      end
+
+      def create_user(id, attributes={})
+        ::User.create!(attributes) { |x| x.id = id }
+      end
+
+      def create_state(id, attributes={})
+        ::State.create!(attributes) { |x| x.abbr = id }
+      end
+
+      def create_enterprise_object(id, attributes={})
+        ::EnterpriseObject.create!(attributes) { |x| x.id = id }
+      end
+
+    end
+
+    @@ken  = create_user 155397742, name: 'Ken Collins', email: 'ken@metaskills.net'
+    @@john = create_user 830138774, name: 'John Hall', email: 'john.hall@example.com'
+
+    @@virginia   = create_state 'VA', name: 'Virginia'
+    @@washington = create_state 'WA', name: 'Washington'
+
+    @@enterprising_ken = create_enterprise_object '4f156606-8cb3-509e-a177-956ca0a22015', name: 'Ken Collins' unless TESTING_RAILS_40
+
+
+    private
+
+    def id(*args) ; self.class.id(*args) ; end
 
   end
 end

metadata

@@ -1,31 +1,73 @@
 --- !ruby/object:Gem::Specification
 name: named_seeds
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Ken Collins
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-27 00:00:00.000000000 Z
+date: 2015-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.0.beta2
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.0.beta2
+        version: '4.0'
 - !ruby/object:Gem::Dependency
-  name: sqlite3
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -53,7 +95,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -75,22 +117,27 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".travis.yml"
+- Appraisals
 - CHANGELOG.md
 - Gemfile
+- Guardfile
 - LICENSE
 - README.md
 - Rakefile
+- TODO.md
 - lib/named_seeds.rb
-- lib/named_seeds/active_support.rb
+- lib/named_seeds/dsl.rb
 - lib/named_seeds/identity.rb
+- lib/named_seeds/rails.rb
 - lib/named_seeds/railtie.rb
-- lib/named_seeds/railties/databases.rake
-- lib/named_seeds/read.rb
+- lib/named_seeds/uuid.rb
 - lib/named_seeds/version.rb
 - named_seeds.gemspec
-- test/cases/base_test.rb
+- test/cases/dsl_test.rb
+- test/cases/identify_test.rb
+- test/cases/named_seeds_test.rb
 - test/support/active_record.rb
-- test/support/models.rb
 - test/test_helper.rb
 homepage: http://github.com/metaskills/named_seeds
 licenses: []
@@ -116,7 +163,8 @@ signing_key:
 specification_version: 4
 summary: 'Replace ActiveRecord::Fixtures With #{your_factory_lib}.'
 test_files:
-- test/cases/base_test.rb
+- test/cases/dsl_test.rb
+- test/cases/identify_test.rb
+- test/cases/named_seeds_test.rb
 - test/support/active_record.rb
-- test/support/models.rb
 - test/test_helper.rb

data/lib/named_seeds/active_support.rb

@@ -1,4 +0,0 @@
-require 'active_support/test_case'
-
-ActiveSupport::TestCase.send :include, NamedSeeds::Read
-

data/lib/named_seeds/railties/databases.rake

@@ -1,14 +0,0 @@
-namespace :named_seeds do
-
-  task :setup => :environment do
-    NamedSeeds::Railtie.setup
-  end
-
-  task :prepare do
-    NamedSeeds::Railtie.prepare
-  end
-
-end
-
-Rake::Task['db:setup'].enhance { Rake::Task['named_seeds:setup'].invoke }
-Rake::Task['db:test:prepare'].enhance { Rake::Task['named_seeds:prepare'].invoke }

data/lib/named_seeds/read.rb

@@ -1,50 +0,0 @@
-require 'active_support/concern'
-
-module NamedSeeds
-  module Read
-    
-    extend ActiveSupport::Concern
-    
-    module ClassMethods
-
-      def named_seeds(name, options = {})
-        klass = options[:klass] || name.to_s.classify.constantize
-        identities = options[:identities]
-        case identities
-        when Hash
-          define_method(name) do |*fixnames|
-            objs = fixnames.map do |fixname|
-              id = identities[fixname.to_sym]
-              find_named_seed name, klass, id, fixname
-            end
-            fixnames.one? ? objs.first : objs
-          end
-        else
-          define_method(name) do |*fixnames|
-            objs = fixnames.map do |fixname|
-              id = NamedSeeds.identify(fixname)
-              find_named_seed name, klass, id, fixname
-            end
-            fixnames.one? ? objs.first : objs
-          end
-        end
-      end
-        
-    end
-
-    protected
-    
-    def find_named_seed(name, klass, id, fixname)
-      begin
-        klass.find(id)
-      rescue ActiveRecord::RecordNotFound => e
-        nsfinder = :"#{name}_#{fixname}"
-        raise e unless respond_to?(nsfinder)
-        send(nsfinder)
-      end
-    end
-    
-  
-  end
-end
-

data/test/cases/base_test.rb

@@ -1,23 +0,0 @@
-require 'test_helper'
-
-class BaseTest < NamedSeeds::Spec
-  
-  describe 'identifiy' do
-    
-    it 'works on strings' do
-      NamedSeeds.identify('foo').must_equal NamedSeeds.identify('foo')
-      NamedSeeds.identify('foo').wont_equal NamedSeeds.identify('FOO')
-    end
-    
-    it 'works on symbols' do
-      NamedSeeds.identify(:foo).must_equal NamedSeeds.identify(:foo)
-    end
-    
-    it 'identifies consistently' do
-      NamedSeeds.identify(:ruby).must_equal 207281424
-      NamedSeeds.identify(:sapphire_2).must_equal 1066363776
-    end
-    
-  end
-  
-end

data/test/support/models.rb

@@ -1,4 +0,0 @@
-
-class User < ActiveRecord::Base
-  
-end