seed-do 3.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 22380fbfaeb46273c0f58822bf8ce464131a64a044d71a6da6488cbcd4dd3ee3
+  data.tar.gz: 6ff8f43389b63701f3575f2556b167a3788e4c8d3f490383d14044a43c1905b5
+SHA512:
+  metadata.gz: 3125f1fad5c9f288ce3aa20a8542f43e28dc57725d4a621ac7aa8a1f1caa366e45f8e6f9498019c27bbf456032b281dfb4a89164d05876d4ad093bdfb658f504
+  data.tar.gz: 44d24c0b5551e13ce3f9c3223002999e6072426d5b73c399ba4d7850e9ee858b6cabd433a805393effc08db7eb068127edce8a5419312880fe65c1b11f392715

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008-2010 Michael Bleigh
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,182 @@
+# Seed Do
+
+This project is a fork of [seed-fu](https://github.com/mbleigh/seed-fu).
+
+Seed Do is an attempt to once and for all solve the problem of inserting and maintaining seed data in a database. It uses a variety of techniques gathered from various places around the web and combines them to create what is hopefully the most robust seed data system around.
+
+## Basic Example
+
+### In `db/fixtures/users.rb`
+
+```ruby
+User.seed do |s|
+  s.id    = 1
+  s.login = "jon"
+  s.email = "jon@example.com"
+  s.name  = "Jon"
+end
+
+User.seed do |s|
+  s.id    = 2
+  s.login = "emily"
+  s.email = "emily@example.com"
+  s.name  = "Emily"
+end
+```
+
+### To load the data:
+
+```ruby
+$ rake db:seed_do
+== Seed from /path/to/app/db/fixtures/users.rb
+ - User {:id=>1, :login=>"jon", :email=>"jon@example.com", :name=>"Jon"}
+ - User {:id=>2, :login=>"emily", :email=>"emily@example.com", :name=>"Emily"}
+```
+
+## Installation
+
+Just add `gem 'seed-do'` to your `Gemfile`
+
+## Migrating from seed-fu
+
+If you are migrating from seed-fu to seed-do, you'll need to make the following changes:
+
+1. Rename all occurrences of `SeedFu` to `SeedDo` in your code
+2. Update rake task references from `rake db:seed_fu` to `rake db:seed_do`
+
+For example:
+
+```ruby
+# Before
+SeedFu.seed
+rake db:seed_fu
+
+# After
+SeedDo.seed
+rake db:seed_do
+```
+
+Capistrano integration also needs to be updated:
+
+```ruby
+# Before
+require 'seed-fu/capistrano'
+# or for Capistrano3
+require 'seed-fu/capistrano3'
+
+# After
+require 'seed-do/capistrano'
+# or for Capistrano3
+require 'seed-do/capistrano3'
+```
+
+## Constraints
+
+Constraints are used to identify seeds, so that they can be updated if necessary. For example:
+
+```ruby
+Point.seed(:x, :y) do |s|
+  s.x = 4
+  s.y = 7
+  s.name = "Home"
+end
+```
+
+The first time this seed is loaded, a `Point` record will be created. Now suppose the name is changed:
+
+```ruby
+Point.seed(:x, :y) do |s|
+  s.x = 4
+  s.y = 7
+  s.name = "Work"
+end
+```
+
+When this is run, Seed Do will look for a `Point` based on the `:x` and `:y` constraints provided. It will see that a matching `Point` already exists and so update its attributes rather than create a new record.
+
+If you do not want seeds to be updated after they have been created, use `seed_once`:
+
+```ruby
+Point.seed_once(:x, :y) do |s|
+  s.x = 4
+  s.y = 7
+  s.name = "Home"
+end
+```
+
+The default constraint just checks the `id` of the record.
+
+## Where to put seed files
+
+By default, seed files are looked for in the following locations:
+
+- `#{Rails.root}/db/fixtures` and `#{Rails.root}/db/fixtures/#{Rails.env}` in a Rails app
+- `./db/fixtures` when loaded without Rails
+
+You can change these defaults by modifying the `SeedDo.fixture_paths` array.
+
+Seed files can be named whatever you like, and are loaded in alphabetical order.
+
+## Terser syntax
+
+When loading lots of records, the above block-based syntax can be quite verbose. You can use the following instead:
+
+```ruby
+User.seed(:id,
+  { :id => 1, :login => "jon",   :email => "jon@example.com",   :name => "Jon"   },
+  { :id => 2, :login => "emily", :email => "emily@example.com", :name => "Emily" }
+)
+```
+
+## Rake task
+
+Seed files can be run automatically using `rake db:seed_do`. There are two options which you can pass:
+
+- `rake db:seed_do FIXTURE_PATH=path/to/fixtures` -- Where to find the fixtures
+- `rake db:seed_do FILTER=users,articles` -- Only run seed files with a filename matching the `FILTER`
+
+You can also do a similar thing in your code by calling `SeedDo.seed(fixture_paths, filter)`.
+
+## Disable output
+
+To disable output from Seed Do, set `SeedDo.quiet = true`.
+
+## Handling large seed files
+
+Seed files can be huge.  To handle large files (over a million rows), try these tricks:
+
+- Gzip your fixtures.  Seed Do will read .rb.gz files happily.  `gzip -9` gives the   best compression, and with Seed Do's repetitive syntax, a 160M file can shrink to 16M.
+- Add lines reading `# BREAK EVAL` in your big fixtures, and Seed Do will avoid loading the whole file into memory.  If you use `SeedDo::Writer`, these breaks are built into your generated fixtures.
+- Load a single fixture at a time with the `FILTER` environment variable
+- If you don't need Seed Do's ability to update seed with new data, then you may find that [activerecord-import](https://github.com/zdennis/activerecord-import) is faster
+
+## Generating seed files
+
+If you need to programmatically generate seed files, for example to convert a CSV file into a seed file, then you can use [`SeedDo::Writer`](lib/seed-do/writer.rb).
+
+## Capistrano deployment
+
+SeedDo has included Capistrano [deploy script](lib/seed-do/capistrano.rb), you just need require that
+in `config/deploy.rb`:
+
+```ruby
+require 'seed-do/capistrano'
+
+# Trigger the task after update_code
+after 'deploy:update_code', 'db:seed_do'
+```
+
+If you use Capistrano3, you should require another file.
+
+```ruby
+require 'seed-do/capistrano3'
+
+# Trigger the task before publishing
+before 'deploy:publishing', 'db:seed_do'
+```
+
+## Original Author
+
+[Michael Bleigh](http://www.mbleigh.com/) is the original author
+
+Copyright © 2008-2010 Michael Bleigh, released under the MIT license

data/lib/seed-do/active_record_extension.rb

@@ -0,0 +1,65 @@
+module SeedDo
+  module ActiveRecordExtension
+    # Load some seed data. There are two ways to do this.
+    #
+    # Verbose syntax
+    # --------------
+    #
+    # This will seed a single record. The `:id` parameter ensures that if a record already exists
+    # in the database with the same id, then it will be updated with the name and age, rather
+    # than created from scratch.
+    #
+    #     Person.seed(:id) do |s|
+    #       s.id   = 1
+    #       s.name = "Jon"
+    #       s.age  = 21
+    #     end
+    #
+    # Note that `:id` is the default attribute used to identify a seed, so it need not be
+    # specified.
+    #
+    # Terse syntax
+    # ------------
+    #
+    # This is a more succinct way to load multiple records. Note that both `:x` and `:y` are being
+    # used to identify a seed here.
+    #
+    #     Point.seed(:x, :y,
+    #       { :x => 3, :y => 10, :name => "Home" },
+    #       { :x => 5, :y => 9,  :name => "Office" }
+    #     )
+    def seed(*args, &block)
+      SeedDo::Seeder.new(self, *parse_seed_do_args(args, block)).seed
+    end
+
+    # Has the same syntax as {#seed}, but if a record already exists with the same values for
+    # constraining attributes, it will not be updated.
+    #
+    # @example
+    #   Person.seed(:id, :id => 1, :name => "Jon") # => Record created
+    #   Person.seed(:id, :id => 1, :name => "Bob") # => Name changed
+    #   Person.seed_once(:id, :id => 1, :name => "Harry") # => Name *not* changed
+    def seed_once(*args, &block)
+      constraints, data = parse_seed_do_args(args, block)
+      SeedDo::Seeder.new(self, constraints, data, :insert_only => true).seed
+    end
+
+    private
+
+      def parse_seed_do_args(args, block)
+        if block.nil?
+          if args.last.is_a?(Array)
+            # Last arg is an array of data, so assume the rest of the args are constraints
+            data = args.pop
+            [args, data]
+          else
+            # Partition the args, assuming the first hash is the start of the data
+            args.partition { |arg| !arg.is_a?(Hash) }
+          end
+        else
+          # We have a block, so assume the args are all constraints
+          [args, [SeedDo::BlockHash.new(block).to_hash]]
+        end
+      end
+  end
+end

data/lib/seed-do/block_hash.rb

@@ -0,0 +1,21 @@
+module SeedDo
+  # @private
+  class BlockHash
+    def initialize(proc)
+      @hash = {}
+      proc.call(self)
+    end
+
+    def to_hash
+      @hash
+    end
+
+    def method_missing(method_name, *args, &block)
+      if method_name.to_s =~ /^(.*)=$/ && args.length == 1 && block.nil?
+        @hash[$1] = args.first
+      else
+        super
+      end
+    end
+  end
+end

data/lib/seed-do/capistrano.rb

@@ -0,0 +1,8 @@
+Capistrano::Configuration.instance.load do
+  namespace :db do
+    desc "Load seed data into database"
+    task :seed_do, :roles => :db, :only => { :primary => true } do
+      run "cd #{release_path} && bundle exec rake RAILS_ENV=#{rails_env} db:seed_do"
+    end
+  end
+end

data/lib/seed-do/capistrano3.rb

@@ -0,0 +1 @@
+load File.expand_path('../../tasks/seed_do_capistrano3.rake', __FILE__)

data/lib/seed-do/railtie.rb

@@ -0,0 +1,14 @@
+module SeedDo
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load "tasks/seed_do.rake"
+    end
+
+    initializer 'seed_do.set_fixture_paths' do
+      SeedDo.fixture_paths = [
+        Rails.root.join('db/fixtures').to_s,
+        Rails.root.join('db/fixtures/' + Rails.env).to_s
+      ]
+    end
+  end
+end

data/lib/seed-do/runner.rb

@@ -0,0 +1,73 @@
+require 'zlib'
+require 'active_support/core_ext/array/wrap'
+
+module SeedDo
+  # Runs seed files.
+  #
+  # It is not recommended to use this class directly. Instead, use {SeedDo.seed SeedDo.seed}, which creates
+  # an instead of {Runner} and calls {#run #run}.
+  #
+  # @see SeedDo.seed SeedDo.seed
+  class Runner
+    # @param [Array<String>] fixture_paths The paths where fixtures are located. Will use
+    #   `SeedDo.fixture_paths` if {nil}. If the argument is not an array, it will be wrapped by one.
+    # @param [Regexp] filter If given, only seed files with a file name matching this pattern will
+    #   be used
+    def initialize(fixture_paths = nil, filter = nil)
+      @fixture_paths = Array.wrap(fixture_paths || SeedDo.fixture_paths)
+      @filter        = filter
+    end
+
+    # Run the seed files.
+    def run
+      puts "\n== Filtering seed files against regexp: #{@filter.inspect}" if @filter && !SeedDo.quiet
+
+      filenames.each do |filename|
+        run_file(filename)
+      end
+    end
+
+    private
+
+      def run_file(filename)
+        puts "\n== Seed from #{filename}" unless SeedDo.quiet
+
+        ActiveRecord::Base.transaction do
+          open(filename) do |file|
+            chunked_ruby = ''
+            file.each_line do |line|
+              if line == "# BREAK EVAL\n"
+                eval(chunked_ruby)
+                chunked_ruby = ''
+              else
+                chunked_ruby << line
+              end
+            end
+            eval(chunked_ruby) unless chunked_ruby == ''
+          end
+        end
+      end
+
+      def open(filename)
+        if filename[-3..-1] == '.gz'
+          Zlib::GzipReader.open(filename) do |file|
+            yield file
+          end
+        else
+          File.open(filename) do |file|
+            yield file
+          end
+        end
+      end
+
+      def filenames
+        filenames = []
+        @fixture_paths.each do |path|
+          filenames += (Dir[File.join(path, '*.rb')] + Dir[File.join(path, '*.rb.gz')]).sort
+        end
+        filenames.uniq!
+        filenames = filenames.find_all { |filename| filename =~ @filter } if @filter
+        filenames
+      end
+  end
+end

data/lib/seed-do/seeder.rb

@@ -0,0 +1,109 @@
+require 'active_support/core_ext/hash/keys'
+
+module SeedDo
+  # Creates or updates seed records with data.
+  #
+  # It is not recommended to use this class directly. Instead, use `Model.seed`, and `Model.seed_once`,
+  # where `Model` is your Active Record model.
+  #
+  # @see ActiveRecordExtension
+  class Seeder
+    # @param [ActiveRecord::Base] model_class The model to be seeded
+    # @param [Array<Symbol>] constraints A list of attributes which identify a particular seed. If
+    #   a record with these attributes already exists then it will be updated rather than created.
+    # @param [Array<Hash>] data Each item in this array is a hash containing attributes for a
+    #   particular record.
+    # @param [Hash] options
+    # @option options [Boolean] :quiet (SeedDo.quiet) If true, output will be silenced
+    # @option options [Boolean] :insert_only (false) If true then existing records which match the
+    #   constraints will not be updated, even if the seed data has changed
+    def initialize(model_class, constraints, data, options = {})
+      @model_class = model_class
+      @constraints = constraints.to_a.empty? ? [:id] : constraints
+      @data        = data.to_a || []
+      @options     = options.symbolize_keys
+
+      @options[:quiet] ||= SeedDo.quiet
+
+      validate_constraints!
+      validate_data!
+    end
+
+    # Insert/update the records as appropriate. Validation is skipped while saving.
+    # @return [Array<ActiveRecord::Base>] The records which have been seeded
+    def seed
+      records = @model_class.transaction do
+        @data.map { |record_data| seed_record(record_data.symbolize_keys) }
+      end
+      update_id_sequence
+      records
+    end
+
+    private
+
+      def validate_constraints!
+        unknown_columns = @constraints.map(&:to_s) - @model_class.column_names
+        unless unknown_columns.empty?
+          raise(ArgumentError,
+            "Your seed constraints contained unknown columns: #{column_list(unknown_columns)}. " +
+            "Valid columns are: #{column_list(@model_class.column_names)}.")
+        end
+      end
+
+      def validate_data!
+        raise ArgumentError, "Seed data missing" if @data.empty?
+      end
+
+      def column_list(columns)
+        '`' + columns.join("`, `") + '`'
+      end
+
+      def seed_record(data)
+        record = find_or_initialize_record(data)
+        return if @options[:insert_only] && !record.new_record?
+
+        puts " - #{@model_class} #{data.inspect}" unless @options[:quiet]
+
+        # Rails 3 or Rails 4 + rails/protected_attributes
+        if record.class.respond_to?(:protected_attributes) && record.class.respond_to?(:accessible_attributes)
+          record.assign_attributes(data,  :without_protection => true)
+        # Rails 4 without rails/protected_attributes
+        else
+          record.assign_attributes(data)
+        end
+        record.save(:validate => false) || raise(ActiveRecord::RecordNotSaved, 'Record not saved!')
+        record
+      end
+
+      def find_or_initialize_record(data)
+        @model_class.where(constraint_conditions(data)).take ||
+        @model_class.new
+      end
+
+      def constraint_conditions(data)
+        Hash[@constraints.map { |c| [c, data[c.to_sym]] }]
+      end
+
+      def update_id_sequence
+        if @model_class.connection.adapter_name == "PostgreSQL" or @model_class.connection.adapter_name == "PostGIS"
+          return if @model_class.primary_key.nil? || @model_class.sequence_name.nil?
+
+          quoted_id       = @model_class.connection.quote_column_name(@model_class.primary_key)
+          sequence = @model_class.sequence_name
+
+          # TODO postgresql_version was made public in Rails 5.0.0, remove #send when support for earlier versions are dropped
+          if @model_class.connection.send(:postgresql_version) >= 100000
+            sql =<<-EOS
+              SELECT setval('#{sequence}', (SELECT GREATEST(MAX(#{quoted_id})+(SELECT seqincrement FROM pg_sequence WHERE seqrelid = '#{sequence}'::regclass), (SELECT seqmin FROM pg_sequence WHERE seqrelid = '#{sequence}'::regclass)) FROM #{@model_class.quoted_table_name}), false)
+            EOS
+          else
+            sql =<<-EOS
+              SELECT setval('#{sequence}', (SELECT GREATEST(MAX(#{quoted_id})+(SELECT increment_by FROM #{sequence}), (SELECT min_value FROM #{sequence})) FROM #{@model_class.quoted_table_name}), false)
+            EOS
+          end
+
+          @model_class.connection.execute sql
+        end
+      end
+  end
+end

data/lib/seed-do/version.rb

@@ -0,0 +1,3 @@
+module SeedDo
+  VERSION = '3.0.0'
+end

data/lib/seed-do/writer.rb

@@ -0,0 +1,132 @@
+module SeedDo
+  # {Writer} is used to programmatically generated seed files. For example, you might want to write
+  # a script which converts data in a CSV file to a valid Seed Do seed file, which can then be
+  # imported.
+  #
+  # @example Basic usage
+  #   SeedDo::Writer.write('path/to/file.rb', :class_name => 'Person', :constraints => [:first_name, :last_name]) do |writer|
+  #     writer.add(:first_name => 'Jon',   :last_name => 'Smith',    :age => 21)
+  #     writer.add(:first_name => 'Emily', :last_name => 'McDonald', :age => 24)
+  #   end
+  #
+  #   # Writes the following to the file:
+  #   #
+  #   # Person.seed(:first_name, :last_name,
+  #   #   {:first_name=>"Jon", :last_name=>"Smith", :age=>21},
+  #   #   {:first_name=>"Emily", :last_name=>"McDonald", :age=>24}
+  #   # )
+  class Writer
+    cattr_accessor :default_options
+    @@default_options = {
+      :chunk_size  => 100,
+      :constraints => [:id],
+      :seed_type   => :seed
+    }
+
+    # @param [Hash] options
+    # @option options [String] :class_name *Required* The name of the Active Record model to
+    #   generate seeds for
+    # @option options [Fixnum] :chunk_size (100) The number of seeds to write before generating a
+    #   `# BREAK EVAL` line. (Chunking reduces memory usage when loading seeds.)
+    # @option options [:seed, :seed_once] :seed_type (:seed) The method to use when generating
+    #   seeds. See {ActiveRecordExtension} for details.
+    # @option options [Array<Symbol>] :constraints ([:id]) The constraining attributes for the seeds
+    def initialize(options = {})
+      @options = self.class.default_options.merge(options)
+      raise ArgumentError, "missing option :class_name" unless @options[:class_name]
+    end
+
+    # Creates a new instance of {Writer} with the `options`, and then calls {#write} with the
+    # `io_or_filename` and `block`
+    def self.write(io_or_filename, options = {}, &block)
+      new(options).write(io_or_filename, &block)
+    end
+
+    # Writes the necessary headers and footers, and yields to a block within which the actual
+    # seed data should be writting using the `#<<` method.
+    #
+    # @param [IO] io_or_filename The IO to which writes will be made. (If an `IO` is given, it is
+    #   your responsibility to close it after writing.)
+    # @param [String] io_or_filename The filename of a file to make writes to. (Will be opened and
+    #   closed automatically.)
+    # @yield [self] make calls to `#<<` within the block
+    def write(io_or_filename, &block)
+      raise ArgumentError, "missing block" unless block_given?
+
+      if io_or_filename.respond_to?(:write)
+        write_to_io(io_or_filename, &block)
+      else
+        File.open(io_or_filename, 'w') do |file|
+          write_to_io(file, &block)
+        end
+      end
+    end
+
+    # Add a seed. Must be called within a block passed to {#write}.
+    # @param [Hash] seed The attributes for the seed
+    def <<(seed)
+      raise "You must add seeds inside a SeedDo::Writer#write block" unless @io
+
+      buffer = ''
+
+      if chunk_this_seed?
+        buffer << seed_footer
+        buffer << "# BREAK EVAL\n"
+        buffer << seed_header
+      end
+
+      buffer << ",\n"
+      buffer << '  ' + seed.inspect
+
+      @io.write(buffer)
+
+      @count += 1
+    end
+    alias_method :add, :<<
+
+    private
+
+      def write_to_io(io)
+        @io, @count = io, 0
+        @io.write(file_header)
+        @io.write(seed_header)
+        yield(self)
+        @io.write(seed_footer)
+        @io.write(file_footer)
+      ensure
+        @io, @count = nil, nil
+      end
+
+      def file_header
+        <<-END
+# DO NOT MODIFY THIS FILE, it was auto-generated.
+#
+# Date: #{Time.now}
+# Seeding #{@options[:class_name]}
+# Written with the command:
+#
+#   #{$0} #{$*.join}
+#
+        END
+      end
+
+      def file_footer
+        <<-END
+# End auto-generated file.
+        END
+      end
+
+      def seed_header
+        constraints = @options[:constraints] && @options[:constraints].map(&:inspect).join(', ')
+        "#{@options[:class_name]}.#{@options[:seed_type]}(#{constraints}"
+      end
+
+      def seed_footer
+        "\n)\n"
+      end
+
+      def chunk_this_seed?
+        @count != 0 && (@count % @options[:chunk_size]) == 0
+      end
+  end
+end

data/lib/seed-do.rb

@@ -0,0 +1,36 @@
+require 'active_record'
+require 'active_support/core_ext/module/attribute_accessors'
+require 'seed-do/railtie' if defined?(Rails) && Rails.version >= "3"
+
+module SeedDo
+  autoload :VERSION,               'seed-do/version'
+  autoload :Seeder,                'seed-do/seeder'
+  autoload :ActiveRecordExtension, 'seed-do/active_record_extension'
+  autoload :BlockHash,             'seed-do/block_hash'
+  autoload :Runner,                'seed-do/runner'
+  autoload :Writer,                'seed-do/writer'
+
+  mattr_accessor :quiet
+
+  # Set `SeedDo.quiet = true` to silence all output
+  @@quiet = false
+
+  mattr_accessor :fixture_paths
+
+  # Set this to be an array of paths to directories containing your seed files. If used as a Rails
+  # plugin, SeedDo will set to to contain `Rails.root/db/fixtures` and
+  # `Rails.root/db/fixtures/Rails.env`
+  @@fixture_paths = ['db/fixtures']
+
+  # Load seed data from files
+  # @param [Array] fixture_paths The paths to look for seed files in
+  # @param [Regexp] filter If given, only filenames matching this expression will be loaded
+  def self.seed(fixture_paths = SeedDo.fixture_paths, filter = nil)
+    Runner.new(fixture_paths, filter).run
+  end
+end
+
+# @public
+class ActiveRecord::Base
+  extend SeedDo::ActiveRecordExtension
+end

data/lib/tasks/seed_do.rake

@@ -0,0 +1,38 @@
+require 'seed-do'
+
+namespace :db do
+  desc <<-EOS
+    Loads seed data for the current environment. It will look for
+    ruby seed files in <RAILS_ROOT>/db/fixtures/ and
+    <RAILS_ROOT>/db/fixtures/<RAILS_ENV>/.
+
+    By default it will load any ruby files found. You can filter the files
+    loaded by passing in the FILTER environment variable with a comma-delimited
+    list of patterns to include. Any files not matching the pattern will
+    not be loaded.
+
+    You can also change the directory where seed files are looked for
+    with the FIXTURE_PATH environment variable.
+
+    Examples:
+      # default, to load all seed files for the current environment
+      rake db:seed_do
+
+      # to load seed files matching orders or customers
+      rake db:seed_do FILTER=orders,customers
+
+      # to load files from RAILS_ROOT/features/fixtures
+      rake db:seed_do FIXTURE_PATH=features/fixtures
+  EOS
+  task :seed_do => :environment do
+    if ENV["FILTER"]
+      filter = /#{ENV["FILTER"].gsub(/,/, "|")}/
+    end
+
+    if ENV["FIXTURE_PATH"]
+      fixture_paths = [ENV["FIXTURE_PATH"], ENV["FIXTURE_PATH"] + '/' + Rails.env]
+    end
+
+    SeedDo.seed(fixture_paths, filter)
+  end
+end

data/lib/tasks/seed_do_capistrano3.rake

@@ -0,0 +1,12 @@
+namespace :db do
+  desc 'Load seed data into database'
+  task :seed_do do
+    on roles(:db) do
+      within release_path do
+        with rails_env: fetch(:rails_env) do
+          execute :bundle, :exec, :rake, 'db:seed_do'
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: seed-do
+version: !ruby/object:Gem::Version
+  version: 3.0.0
+platform: ruby
+authors:
+- Shinichi Maeshima
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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'
+description: Seed Do is an attempt to once and for all solve the problem of inserting
+  and maintaining seed data in a database. It uses a variety of techniques gathered
+  from various places around the web and combines them to create what is hopefully
+  the most robust seed data system around.
+email:
+- netwillnet@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/seed-do.rb
+- lib/seed-do/active_record_extension.rb
+- lib/seed-do/block_hash.rb
+- lib/seed-do/capistrano.rb
+- lib/seed-do/capistrano3.rb
+- lib/seed-do/railtie.rb
+- lib/seed-do/runner.rb
+- lib/seed-do/seeder.rb
+- lib/seed-do/version.rb
+- lib/seed-do/writer.rb
+- lib/tasks/seed_do.rake
+- lib/tasks/seed_do_capistrano3.rake
+homepage: http://github.com/willnet/seed-do
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Easily manage seed data in your Active Record application
+test_files: []