seed-fu-discourse 2.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a80f7da73d20fcbc8d6388437e4581ec8b247b1e
+  data.tar.gz: beea3fef73d7dd503ee18e0713ef758767bed09e
+SHA512:
+  metadata.gz: bc9b5fbb3f30e4426c2600858f93a1dd40f57aafd285d44ee22d5314eaf93929e863cbfd81df07f1424975ca1dd5b3d47d7323484ba52dd5b1b6a1745e19eba6
+  data.tar.gz: ab52d4e1cdf368d7d5efd73550e23cd05c48a72df61119a9b97dc40352a1104b147dfddf34aff0c4a6fb696d4156575d6510964361fb195cd7cf1ee62f0d51cc

data/CHANGELOG.md

@@ -0,0 +1,63 @@
+Unreleased
+----------
+
+Features:
+
+* Rails 4.0.X support added. (by @tkhr, @DanielWright)
+
+Version 2.1.0
+-------------
+
+Features:
+
+* Deprecations removed
+
+* Rails 3.1 support added, Rails 3.0 support removed (please use 2.0.X line with 3.0)
+
+Version 2.0.1
+-------------
+
+Bug fixes:
+
+* Update the primary key sequence in PostgreSQL tables after seeding data. This ensures that id conflicts do not occur when records are subsequently added to the table.
+
+* Raise ActiveRecord::RecordNotSaved if any of the saves fail (but they won't fail due to validation since saves are done without validation, so this guards against callbacks failing etc.)
+
+Version 2.0.0
+-------------
+
+Features:
+
+* Depends only on Active Record, not the whole of Rails
+
+* The `Model.seed_many` syntax is now supported by `Model.seed`, and `Model.seed_many` is deprecated
+
+* `Model.seed` supports adding multiple records without an explicit array argument. I.e. the following are equivalent:
+
+      Model.seed([
+        { :name => "Jon" },
+        { :name => "Emily" }
+      ])
+
+      Model.seed(
+        { :name => "Jon" },
+        { :name => "Emily }
+      )
+
+* A side-effect of the above is another option for single seeds:
+
+      Model.seed(:name => "Jon")
+
+* The `SEED` option to `rake db:seed_fu` is deprecated, and replaced by `FILTER` which works the same way.
+
+* Added `SeedFu.quiet` boolean option, set to `true` if you don't want any output from Seed Fu.
+
+* Added `SeedFu.fixture_paths`. Set to an array of paths to look for seed files in. Defaults to `["db/fixtures"]` in general, or `["#{Rails.root}/db/fixtures", "#{Rails.root}/db/fixtures/#{Rails.env}"]` when Seed Fu is installed as a Rails plugin.
+
+* Added `SeedFu.seed` method which is basically a method equivalent of running `rake db:seed_fu` (the rake task now just basically called `SeedFu.seed`)
+
+* Simplified and changed the `SeedFu::Writer` API, see docs for details
+
+Bug fixes:
+
+* Fix Rails 3 deprecation warnings and make seed-fu fully compatible with being installed as a gem

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,158 @@
+Seed Fu
+=======
+
+Seed Fu 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.
+
+Warning: API Changes
+--------------------
+
+Version 2.0.0 of Seed Fu introduced API changes. `Seed::Writer` was been completely overhauled and will require you to update your scripts. Some other deprecations were introduced, and support is fully removed in version 2.1.0. Please see the [CHANGELOG](CHANGELOG.md) for details.
+
+The API documentation is available in full at [http://rubydoc.info/github/mbleigh/seed-fu/master/frames](http://rubydoc.info/github/mbleigh/seed-fu/master/frames).
+
+Basic Example
+-------------
+
+### In `db/fixtures/users.rb`
+
+    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:
+
+    $ rake db:seed_fu
+    == 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
+------------
+
+### Rails 4.0
+
+The current latest version isn't compatible with Rails 4.0.
+You will have to use the HEAD of this repo.
+
+    gem 'seed-fu', github: 'mbleigh/seed-fu'
+
+### Rails 3.1
+
+Just add `gem 'seed-fu', '~> 2.1.0'` to your `Gemfile`
+
+Seed Fu depends on Active Record, but doesn't have to be used with a full Rails app. Simply load and require the `seed-fu` gem and you're set.
+
+### Rails 3.0
+
+The current version is not backwards compatible with Rails 3.0. Please use `gem 'seed-fu', '~> 2.0.0'`.
+
+### Rails 2.3
+
+The current version is not backwards compatible with Rails 2.3. Please use `gem 'seed-fu', '~> 1.2.0'`.
+
+Constraints
+-----------
+
+Constraints are used to identify seeds, so that they can be updated if necessary. For example:
+
+    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:
+
+    Point.seed(:x, :y) do |s|
+      s.x = 4
+      s.y = 7
+      s.name = "Work"
+    end
+
+When this is run, Seed Fu 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`:
+
+    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 `SeedFu.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:
+
+    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_fu`. There are two options which you can pass:
+
+* `rake db:seed_fu FIXTURE_PATH=path/to/fixtures` -- Where to find the fixtures
+* `rake db:seed_fu 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 `SeedFu.seed(fixture_paths, filter)`.
+
+Disable output
+--------------
+
+To disable output from Seed Fu, set `SeedFu.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 Fu will read .rb.gz files happily.  `gzip -9` gives the   best compression, and with Seed Fu's repetitive syntax, a 160M file can shrink to 16M.
+* Add lines reading `# BREAK EVAL` in your big fixtures, and Seed Fu will avoid loading the whole file into memory.  If you use `SeedFu::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 Fu'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 [`SeedFu::Writer`](../SeedFu/Writer).
+
+Bugs / Feature requests
+-----------------------
+
+Please report them on [Github Issues](https://github.com/mbleigh/seed-fu/issues).
+
+Contributors
+------------
+
+* [Michael Bleigh](http://www.mbleigh.com/) is the original author
+* [Jon Leighton](http://jonathanleighton.com/) is the current maintainer
+* Thanks to [Matthew Beale](https://github.com/mixonic) for his great work in adding the writer, making it faster and better.
+
+Copyright © 2008-2010 Michael Bleigh, released under the MIT license

data/lib/seed-fu.rb

@@ -0,0 +1,36 @@
+require 'active_record'
+require 'active_support/core_ext/module/attribute_accessors'
+require 'seed-fu/railtie' if defined?(Rails) && Rails.version >= "3"
+
+module SeedFu
+  autoload :VERSION,               'seed-fu/version'
+  autoload :Seeder,                'seed-fu/seeder'
+  autoload :ActiveRecordExtension, 'seed-fu/active_record_extension'
+  autoload :BlockHash,             'seed-fu/block_hash'
+  autoload :Runner,                'seed-fu/runner'
+  autoload :Writer,                'seed-fu/writer'
+
+  mattr_accessor :quiet
+
+  # Set `SeedFu.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, SeedFu 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 = SeedFu.fixture_paths, filter = nil)
+    Runner.new(fixture_paths, filter).run
+  end
+end
+
+# @public
+class ActiveRecord::Base
+  extend SeedFu::ActiveRecordExtension
+end

data/lib/seed-fu/active_record_extension.rb

@@ -0,0 +1,65 @@
+module SeedFu
+  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)
+      SeedFu::Seeder.new(self, *parse_seed_fu_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(:id, :id => 1, :name => "Harry") # => Name *not* changed
+    def seed_once(*args, &block)
+      constraints, data = parse_seed_fu_args(args, block)
+      SeedFu::Seeder.new(self, constraints, data, :insert_only => true).seed
+    end
+
+    private
+
+      def parse_seed_fu_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, [SeedFu::BlockHash.new(block).to_hash]]
+        end
+      end
+  end
+end

data/lib/seed-fu/block_hash.rb

@@ -0,0 +1,21 @@
+module SeedFu
+  # @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-fu/railtie.rb

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

data/lib/seed-fu/runner.rb

@@ -0,0 +1,73 @@
+require 'zlib'
+require 'active_support/core_ext/array/wrap'
+
+module SeedFu
+  # Runs seed files.
+  #
+  # It is not recommended to use this class directly. Instead, use {SeedFu.seed SeedFu.seed}, which creates
+  # an instead of {Runner} and calls {#run #run}.
+  #
+  # @see SeedFu.seed SeedFu.seed
+  class Runner
+    # @param [Array<String>] fixture_paths The paths where fixtures are located. Will use
+    #   `SeedFu.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 || SeedFu.fixture_paths)
+      @filter        = filter
+    end
+
+    # Run the seed files.
+    def run
+      puts "\n== Filtering seed files against regexp: #{@filter.inspect}" if @filter && !SeedFu.quiet
+
+      filenames.each do |filename|
+        run_file(filename)
+      end
+    end
+
+    private
+
+      def run_file(filename)
+        puts "\n== Seed from #{filename}" unless SeedFu.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-fu/seeder.rb

@@ -0,0 +1,104 @@
+require 'active_support/core_ext/hash/keys'
+
+module SeedFu
+  # 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 (SeedFu.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] ||= SeedFu.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
+      end
+
+      def find_or_initialize_record(data)
+        @model_class.where(constraint_conditions(data)).first ||
+        @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"
+          quoted_sequence = "'" + @model_class.sequence_name + "'"
+          next_id = (@model_class.maximum(:id) || 0) + 1
+
+          # nothing to repair, the id sequence starts at 1
+          if(next_id > 1)
+            @model_class.connection.execute(
+              "SELECT pg_catalog.setval(" +
+                "#{quoted_sequence}," +
+                " #{next_id}" +
+              ");"
+            )
+          end
+        end
+      end
+  end
+end

data/lib/seed-fu/version.rb

@@ -0,0 +1,4 @@
+module SeedFu
+  # The current version of Seed Fu
+  VERSION = '2.2.0'
+end

data/lib/seed-fu/writer.rb

@@ -0,0 +1,132 @@
+module SeedFu
+  # {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 Fu seed file, which can then be
+  # imported.
+  #
+  # @example Basic usage
+  #   SeedFu::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 SeedFu::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/tasks/seed_fu.rake

@@ -0,0 +1,38 @@
+require 'seed-fu'
+
+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
+
+      # to load seed files matching orders or customers
+      rake db:seed FILTER=orders,customers
+
+      # to load files from RAILS_ROOT/features/fixtures
+      rake db:seed FIXTURE_PATH=features/fixtures
+  EOS
+  task :seed_fu => :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
+
+    SeedFu.seed(fixture_paths, filter)
+  end
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: seed-fu-discourse
+version: !ruby/object:Gem::Version
+  version: 2.2.0
+platform: ruby
+authors:
+- Michael Bleigh
+- Jon Leighton
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  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: mysql2
+  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: sqlite3
+  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 Fu 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:
+- michael@intridea.com
+- j@jonathanleighton.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/seed-fu.rb
+- lib/tasks/seed_fu.rake
+- lib/seed-fu/railtie.rb
+- lib/seed-fu/writer.rb
+- lib/seed-fu/runner.rb
+- lib/seed-fu/block_hash.rb
+- lib/seed-fu/seeder.rb
+- lib/seed-fu/active_record_extension.rb
+- lib/seed-fu/version.rb
+- LICENSE
+- README.md
+- CHANGELOG.md
+homepage: http://github.com/mbleigh/seed-fu
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Easily manage seed data in your Active Record application
+test_files: []