planter 0.0.6 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95ab85b49c50ea3b7ee077d4225083884558ae89c6fa5b2ea4e9410284f890eb
-  data.tar.gz: 2fd36b19ab5064d681323eb5f7e73a95cf710b7af8a587031c84b7175610cfbe
+  metadata.gz: 259e8d195e480b9b5f16d67ee729d822f9c67131650997d2c95958f1356d76ab
+  data.tar.gz: f2722663f8f1628268208dd0e35da17507a62b339e0dc45004ba16c59f0879b5
 SHA512:
-  metadata.gz: fa74216b4529bcb3d21ccd697574c175ad7dd641d477921108ff9949e1ab9a9537cf6f4847b6e2aaadeb91e8aecedc6afec243c72250d9b77cce1da0e4926580
-  data.tar.gz: 9b9cb5dd5a29b8a66c8cd9a6c49d5192c1395a5d935a98628928f65babcd709c2a6480ed356bf2f575e0710856a214025efdf91942acf3fe034a39a1369f302a
+  metadata.gz: 3598c5503a8fef0db359b9ba6bcbd29e22ca3566e6f9ec0ebf0daa9a23961a227cad94478178b700d7b696b638fed51ea9bb61c5a71fb7a1874eb0765c6334ec
+  data.tar.gz: 92d6beec3c0c16fb9dd03d3b26fe6aadf94e28298f058795508c18863e6e41c0f3034c254eb995804d59f211c14bbdc1565848260026b0cf4c2e87f9bd1f7f6e

data/README.md

@@ -7,23 +7,24 @@
 
 Seeds for Rails applications can get complicated fast, and Rails doesn't provide
 much for assisting with this process. This plugin seeks to rectify that by
-providing easy ways to seed specific tables by hooking into the existing `rails
-db:seed` task.
+providing easy ways to seed specific tables.
 
 Features include:
 
 - Seed tables from CSV files, an array of hashes, or custom methods.
-- Call specific seeders with `rails db:seed SEEDERS=users,addresses`.
+- Call specific seeders with `rails planter:seed SEEDERS=users,addresses`.
 - Control the number of records being created.
 - Seed associations.
 
 You can view the documentation [here](https://evanthegrayt.github.io/planter/).
 
 ## Installation
-Add this line to your application's Gemfile:
+Add the following line to your application's Gemfile. Because this plugin is
+currently a pre-release version, it's recommended to lock it to a specific
+version, as breaking changes may occur, even at the patch level.
 
 ```ruby
-gem 'planter'
+gem 'planter', '0.0.10'
 ```
 
 And then execute:
@@ -41,30 +42,69 @@ $ gem install planter
 ## Usage
 Let's assume you'd like to seed your `users` table.
 
-To get started, simply add the following to your `db/seeds.rb` file. Note that
-the `config.seeders` should be an array of the seeders to use. They should be in
-the correct order to successfully seed the tables when considering associations.
+To get started, run `rails generate planter:initializer`, which will create
+`config/initializers/planter.rb` with the following contents.
 
 ```ruby
 require 'planter'
 
 Planter.configure do |config|
-  config.seeders = %i[ users ]
+  ##
+  # The list of seeders. These files are stored in the
+  # config.seeders_directory, which can be changed below. When a new
+  # seeder is generated, it will be appended to the bottom of this
+  # list. If the order is incorrect, you'll need to adjust it.
+  # Just be sure to keep the ending bracket on its own line, or the
+  # generator won't know where to put new elements.
+  config.seeders = %i[
+  ]
+
+  ##
+  # The directory where the seeder files are kept.
+  # config.seeders_directory = 'db/seeds'
+
+  ##
+  # The directory where CSVs are kept.
+  # config.csv_files_directory = 'db/seed_files'
 end
+```
+
+By default, a `planter:seed` task is provided for seeding your application. This
+allows you to use `db:seed` for other purposes. If you want Planter to hook
+into the existing `db:seed` task, simply add the following to `db/seeds.rb`.
 
+```ruby
 Planter.seed
 ```
 
-Then, create a directory called `db/seeds`, and create a file called
-`db/seeds/users_seeder.rb`. In that file, create the following class. Note the
-name of the seeder is the name of the table, plus `Seeder`, and it inherits from
-`Planter::Seeder`.
+To create a users seeder, run `rails generate planter:seeder users`. Usually,
+seeders seed a specific table, so it's recommended to name your seeders after
+the table. If you don't, you'll need to manually specify a few things. More on
+that later. This will create a file named `db/seeds/users_seeder.rb` (the
+directory will be created if it doesn't exist) with the following contents.
 
 ```ruby
 class UsersSeeder < Planter::Seeder
+  # TODO: Choose a seeding_method. For example:
+  # seeding_method :csv
+
+  # For now, we overload the seed method so no exception will be raised.
+  def seed
+  end
 end
 ```
 
+This also adds `users` to the `config.seeders` array in our initializer. A few
+things to note.
+
+- The seeder will always be appended at the end of the array. If this is not the
+correct order, you'll need to adjust the array manually.
+- When adjusting the array, always keep the closing bracket on its own line, or
+the generator won't know where to put the new seeders.
+
+If you want to generate a seeder for every table currently in your database, run
+`rails generate planter:seeder ALL`.
+
 You then need to choose a seeding method, of which there are currently three.
 
 ### Seeding from CSV
@@ -72,7 +112,7 @@ To seed from CSV, you simply need to add the following to your seeder class.
 
 ```ruby
 class UsersSeeder < Planter::Seeder
-  seeding_method :standard_csv
+  seeding_method :csv
 end
 ```
 
@@ -86,16 +126,28 @@ test1@example.com,test1
 test2@example.com,test2
 ```
 
-If the CSV files are not located in the project, you can specify a `:csv_file`
-option. Note that the value must be a full path.
+If the CSV file is named differently than the seeder, you can specify the
+`:csv_name` option. Note that the value should not include the file extension.
 
 ```ruby
 class UsersSeeder < Planter::Seeder
-  seeding_method :standard_csv, csv_file: '/home/me/users.csv'
+  seeding_method :csv, csv_name: :people
 end
 ```
 
-Running `rails db:seed` will now seed your `users` table.
+`ERB` can be used in the CSV files if you name it with `.erb` at the end of the
+file name. For example, `users.csv.erb`. Note that lines starting with `<%` and
+ending with `%>` will not be considered rows, so you can use `ERB` rows to set
+values. For example:
+
+```
+email,login_attempts
+<% count = 1 %>
+test2@example.com,<%= count += 1 %>
+test2@example.com,<%= count += 1 %>
+```
+
+Running `rails planter:seed` will now seed your `users` table.
 
 ## Seeding from a data array
 If you need dynamic seeds, you can add something similar to the following to
@@ -103,7 +155,7 @@ your seeder class. In this example, we'll use
 [faker](https://github.com/faker-ruby/faker).
 
 ```ruby
-require 'faker' # You should really just require this in `db/seeds.rb`.
+require 'faker' # You could just require this in `db/seeds.rb`.
 
 class UsersSeeder < Planter::Seeder
   seeding_method :data_array, number_of_records: 10
@@ -123,7 +175,7 @@ ten elements to create ten records. It's also worth noting that setting an
 instance variable called `@data` from an `initialize` method would also work, as
 the `Planter::Seeder` parent class automatically provides `attr_reader :data`.
 
-Running `rails db:seed` should now seed your `users` table.
+Running `rails planter:seed` should now seed your `users` table.
 
 You can also seed children records for every existing record of a parent model.
 For example, to seed an address for every user, you'd need to create an
@@ -148,7 +200,7 @@ end
 
 Note that specifying `number_of_records` in this instance will create that many
 records *for each record of the parent model*. You can also specify the
-association if it's different from the table name, using the `assocation:`
+association if it's different from the table name, using the `:assocation`
 option.
 
 ### Custom seeds
@@ -168,26 +220,6 @@ class UsersSeeder < Planter::Seeder
 end
 ```
 
-## Customization
-You can change the directories of both the seeder files and the csv files. In
-your `configure` block in `db/seeds.rb`, you can add the following. Note that,
-in both instances, the path should be relative to `Rails.root`.
-
-```ruby
-require 'planter'
-
-Planter.configure do |config|
-  config.seeders_directory = 'db/seeder_classes'
-  config.csv_files_directory = 'db/csvs'
-  config.seeders = %i[
-    users
-    addresses
-  ]
-end
-
-Planter.seed
-```
-
 ## License
 The gem is available as open source under the terms of the [MIT
 License](https://opensource.org/licenses/MIT).

data/lib/generators/planter/initializer_generator.rb

@@ -0,0 +1,33 @@
+module Planter
+  module Generators
+    class InitializerGenerator < Rails::Generators::Base
+      desc 'Genrates an initializer for Planter at config/initializers/planter.rb'
+
+      def create_initializer_file
+        create_file 'config/initializers/planter.rb', <<~EOF
+          require 'planter'
+
+          Planter.configure do |config|
+            ##
+            # The list of seeders. These files are stored in the
+            # config.seeders_directory, which can be changed below. When a new
+            # seeder is generated, it will be appended to the bottom of this
+            # list. If the order is incorrect, you'll need to adjust it.
+            # Just be sure to keep the ending bracket on its own line, or the
+            # generator won't know where to put new elements.
+            config.seeders = %i[
+            ]
+
+            ##
+            # The directory where the seeder files are kept.
+            # config.seeders_directory = 'db/seeds'
+
+            ##
+            # The directory where CSVs are kept.
+            # config.csv_files_directory = 'db/seed_files'
+          end
+        EOF
+      end
+    end
+  end
+end

data/lib/generators/planter/seeder_generator.rb

@@ -0,0 +1,40 @@
+module Planter
+  module Generators
+    class SeederGenerator < Rails::Generators::Base
+      argument :seeder, required: true
+
+      desc "This generator creates a seeder file at #{::Planter.config.seeders_directory}"
+
+      def generate_seeders
+        seeder == 'ALL' ? tables.each { |t| generate(t) } : generate(seeder)
+      end
+
+      private
+
+      def generate(seeder)
+        empty_directory ::Planter.config.seeders_directory
+
+        create_file "#{::Planter.config.seeders_directory}/#{seeder}_seeder.rb", <<~EOF
+          class #{seeder.camelize}Seeder < Planter::Seeder
+            # TODO: Choose a seeding_method. For example:
+            # seeding_method :csv
+
+            # For now, we overload the seed method so no exception will be raised.
+            def seed
+            end
+          end
+        EOF
+
+        inject_into_file 'config/initializers/planter.rb',
+          "    #{seeder}\n",
+          before: /^\s*\]\s*$/
+      end
+
+      def tables
+        @tables ||= ActiveRecord::Base.connection.tables.reject do |table|
+          %w[ar_internal_metadata schema_migrations].include?(table)
+        end
+      end
+    end
+  end
+end

data/lib/planter/railtie.rb

@@ -2,5 +2,13 @@
 
 module Planter
   class Railtie < ::Rails::Railtie # :nodoc:
+    rake_tasks do
+      load File.join(
+        File.expand_path(File.dirname(__FILE__)),
+        '..',
+        'tasks',
+        'planter_tasks.rake'
+      )
+    end
   end
 end

data/lib/planter/seeder.rb

@@ -2,21 +2,101 @@
 
 module Planter
   ##
-  # The class your seeder files should inherit from.
+  # Class that seeders should inherit from. Seeder files should be in
+  # +db/seeds+, and named +TABLE_seeder.rb+, where +TABLE+ is the name of the
+  # table being seeded (I.E. +users_seeder.rb+). If your seeder is named
+  # differently than the table, you'll need to specify the table with the
+  # +model+ option. The seeder's class name should be the same as the file
+  # name, but camelized. So, +UsersSeeder+. The directory where the seeder
+  # files are located can be changed via an initializer.
+  #
+  # The most basic way to seed is to have a CSV file with the same name as the
+  # table in +db/seed_files/+. So, +users.csv+. This CSV should have the
+  # table's column names as header. To seed using this method, your class
+  # should look like the following. Note that +:csv_name+ and +:model+ are only
+  # required if your seeder or csv are named differently than the table being
+  # seeded. The directory where the seed files are kept can be changed via an
+  # initializer.
+  #   # db/seeds/users_seeder.rb
+  #   require 'planter'
+  #   class UsersSeeder < Planter::Seeder
+  #     seeding_method :csv, csv_name: :users, model: 'User'
+  #   end
+  #
+  # Another way to seed is to create records from a data array. To do this,
+  # your class must implement a +data+ attribute or method, which is an array
+  # of hashes. Note that this class already provides the +attr_reader+ for this
+  # attribute, so the most you have to do it create instance variables in your
+  # constructor. If if you want your data to be different for each new record
+  # (via Faker, +Array#sample+, etc.), you'll probably want to supply a method
+  # called data that returns an array of new data each time.
+  #   require 'planter'
+  #   class UsersSeeder < Planter::Seeder
+  #     seeding_method :data_array
+  #     def data
+  #       [{foo: 'bar', baz: 'bar'}]
+  #     end
+  #   end
+  #
+  # In both of the above methods, you can specify +parent_model+ and
+  # +association+. If specified, records will be created via that parent
+  # model's association. If +association+ is not provided, it will be assumed
+  # to be the model name, pluralized and snake-cased (implying a +has_many+
+  # relationship).  For example, if we're seeding the users table, and the
+  # model is +User+, the association will default to +users+.
+  #   require 'planter'
+  #   class UsersSeeder < Planter::Seeder
+  #     seeding_method :data_array, parent_model: 'Person', association: :users
+  #     def data
+  #       [{foo: 'bar', baz: 'bar'}]
+  #     end
+  #   end
+  #
+  # You can also set +number_of_records+ to determine how many times each
+  # record in the +data+ array will get created. The default is 1. Note that if
+  # this attribute is set alongside +parent_model+ and +association+,
+  # +number_of_records+ will be how many records will be created for each
+  # record in the parent table.
+  #   require 'planter'
+  #   class UsersSeeder < Planter::Seeder
+  #     seeding_method :data_array, number_of_records: 5
+  #     def data
+  #       [{foo: 'bar', baz: 'bar'}]
+  #     end
+  #   end
+  #
+  # By default, all fields are used to look up the record. If it already
+  # exists, it is not re-created. If you have specific fields that a record
+  # should be looked-up by, you can pass the +unique_columns+ option. This will
+  # attempt to look up the record by those fields only, and if one doesn't
+  # exist, one will be created with the rest of the attributes. An example of
+  # when this would be useful is with Devise; you can't pass +password+ in the
+  # create method, so specifying +unique_columns+ on everything except
+  # +password+ allows it to be passed as an attribute to the +first_or_create+
+  # call.
+  #   require 'planter'
+  #   class UsersSeeder < Planter::Seeder
+  #     seeding_method :data_array, unique_columns: %i[username email]
+  #     def data
+  #       [{username: 'foo', email: 'bar', password: 'Example'}]
+  #     end
+  #   end
+  #
+  # If you need to seed a different way, put your own custom +seed+ method in
+  # your seeder class and do whatever needs to be done.
   class Seeder
     ##
     # The allowed seeding methods.
     #
     # @return [Array]
-    SEEDING_METHODS = %i[standard_csv data_array].freeze
+    SEEDING_METHODS = %i[csv data_array].freeze
 
     ##
     # Array of hashes used to create records. Your class must set this
-    # attribute when using +data_hash+ seeding method, although it's probably
+    # attribute when using +data_array+ seeding method, although it's probably
     # more likely that you'll want to define a method that returns a new set of
-    # data each time (via +Faker+, +Array#sample+, etc.). When using
-    # +standard_csv+, +data+ will be set to the data within the csv. You can
-    # override this.
+    # data each time (via +Faker+, +Array#sample+, etc.). When using +csv+,
+    # +data+ will be set to the data within the csv. You can override this.
     #
     # @return [Array]
     attr_reader :data
@@ -28,40 +108,60 @@ module Planter
     #
     # @param [Symbol] seeding_method
     #
-    # @param [Hash] options
+    # @kwarg [Integer] number_of_records
+    #
+    # @kwarg [String] model
+    #
+    # @kwarg [String] parent_model
+    #
+    # @kwarg [Symbol, String] association
+    #
+    # @kwarg [Symbol, String] csv_name
+    #
+    # @kwarg [Symbol, String] unique_columns
     #
     # @example
     #   require 'planter'
     #   class UsersSeeder < Planter::Seeder
-    #     seeding_method :data_array,
+    #     seeding_method :csv,
+    #       number_of_records: 2,
     #       model: 'User'
     #       parent_model: 'Person',
     #       association: :users,
-    #       number_of_records: 2
+    #       csv_name: :awesome_users,
+    #       unique_columns %i[username email]
     #   end
-    def self.seeding_method(method, **options)
+    def self.seeding_method(
+      method,
+      number_of_records: 1,
+      model: to_s.delete_suffix('Seeder').singularize,
+      parent_model: nil,
+      association: nil,
+      csv_name: nil,
+      erb_trim_mode: nil,
+      unique_columns: nil
+    )
       if !SEEDING_METHODS.include?(method.intern)
         raise ArgumentError, "Method must be one of #{SEEDING_METHODS.join(', ')}"
-      elsif options[:association] && !options[:parent_model]
+      elsif association && !parent_model
         raise ArgumentError, "Must specify :parent_model with :association"
       end
 
       @seeding_method = method
-      @number_of_records = options.fetch(:number_of_records, 1)
-      @model = options.fetch(:model, to_s.delete_suffix('Seeder').singularize)
-      @parent_model = options[:parent_model]
-      @association = @parent_model && options.fetch(:association) do
-        determine_association(options)
-      end
-      return unless @seeding_method == :standard_csv
-
-      @csv_file = options.fetch(:csv_file, Rails.root.join(
-        Planter.config.csv_files_directory,
-        "#{to_s.delete_suffix('Seeder').underscore}.csv"
-      ).to_s)
+      @number_of_records = number_of_records
+      @model = model
+      @parent_model = parent_model
+      @association = @parent_model && (association || determine_association)
+      @csv_file = determine_csv_filename(csv_name) if @seeding_method == :csv
+      @erb_trim_mode = erb_trim_mode
+      @unique_columns =
+        case unique_columns
+        when String, Symbol then [unique_columns.intern]
+        when Array then unique_columns.map(&:intern)
+        end
     end
 
-    def self.determine_association(options) # :nodoc:
+    def self.determine_association # :nodoc:
       associations =
         @parent_model.constantize.reflect_on_all_associations.map(&:name)
       table = to_s.delete_suffix('Seeder').underscore.split('/').last
@@ -70,10 +170,23 @@ module Planter
         return t if associations.include?(t)
       end
 
-      raise ArgumentError, 'Could not determine association name'
+      raise ArgumentError, "Couldn't determine association name"
     end
     private_class_method :determine_association
 
+    def self.determine_csv_filename(csv_name) # :nodoc:
+      file = (
+        csv_name || "#{to_s.delete_suffix('Seeder').underscore}"
+      ).to_s + '.csv'
+      [file, "#{file}.erb"].each do |f|
+        fname = Rails.root.join(Planter.config.csv_files_directory, f).to_s
+        return fname if ::File.file?(fname)
+      end
+
+      raise ArgumentError, "Couldn't find csv for #{@model}"
+    end
+    private_class_method :determine_csv_filename
+
     ##
     # The default seed method. To use this method, your class must provide a
     # valid +seeding_method+, and not implement its own +seed+ method.
@@ -140,14 +253,31 @@ module Planter
       @csv_file ||= self.class.instance_variable_get('@csv_file')
     end
 
+    ##
+    # When creating a record, the fields that will be used to look up the
+    # record. If it already exists, a new one will not be created.
+    #
+    # @return [Array]
+    def unique_columns
+      @unique_columns ||= self.class.instance_variable_get('@unique_columns')
+    end
+
+    ##
+    # Trim mode for ERB when parsing CSVs.
+    #
+    # @return [String, nil]
+    def erb_trim_mode
+      @erb_trim_mode ||= self.class.instance_variable_get('@erb_trim_mode')
+    end
+
     ##
     # Creates records from the +data+ attribute.
     def create_records
       data.each do |rec|
         number_of_records.times do
-          model.constantize.where(
-            rec.transform_values { |value| value == 'NULL' ? nil : value }
-          ).first_or_create!
+          rec.transform_values { |value| value == 'NULL' ? nil : value }
+          unique, attrs = split_record(rec)
+          model.constantize.where(unique).first_or_create!(attrs)
         end
       end
     end
@@ -165,31 +295,52 @@ module Planter
 
     private
 
-    def create_method
+    def create_method # :nodoc:
       parent_model.constantize.reflect_on_association(
         association
       ).macro.to_s.include?('many') ? :create_has_many : :create_has_one
     end
 
-    def create_has_many(assoc_rec, association, rec)
-      assoc_rec.public_send(association).where(rec).first_or_create!
+    def create_has_many(assoc_rec, association, rec) # :nodoc:
+      unique, attrs = split_record(rec)
+      assoc_rec.public_send(association).where(unique).first_or_create!(attrs)
     end
 
-    def create_has_one(assoc_rec, association, rec)
-      assoc_rec.public_send("create_#{association}", rec)
+    def create_has_one(assoc_rec, association, rec) # :nodoc:
+      if assoc_rec.public_send(association)
+        assoc_rec.public_send(association).update_attributes(rec)
+      else
+        assoc_rec.public_send("create_#{association}", rec)
+      end
     end
 
     def validate_attributes # :nodoc:
       case seeding_method.intern
-      when :standard_csv
-        raise "#{csv_file} does not exist" unless ::File.file?(csv_file)
+      when :csv
+        contents = ::File.read(csv_file)
+        if csv_file.end_with?('.erb')
+          contents = ERB.new(contents, trim_mode: erb_trim_mode).result(binding)
+        end
 
-        @data ||= ::CSV.table(csv_file).map(&:to_hash)
+        @data ||= ::CSV.parse(
+          contents, headers: true, header_converters: :symbol
+        ).map(&:to_hash)
       when :data_array
         raise "Must define '@data'" if public_send(:data).nil?
       else
         raise("Must set 'seeding_method'")
       end
     end
+
+    def split_record(rec) # :nodoc:
+      u = {}
+      model.constantize.reflect_on_all_associations.map(&:name).each do |a|
+        u[a] = rec.delete(a) if rec.key?(a)
+      end
+      return [u, rec] unless unique_columns
+
+      unique_columns.each { |c, h| h[c] = rec.delete(c) }
+      [u, rec]
+    end
   end
 end

data/lib/planter/version.rb

@@ -21,7 +21,7 @@ module Planter
     # Patch version.
     #
     # @return [Integer]
-    PATCH = 6
+    PATCH = 10
 
     ##
     # Version as +[MAJOR, MINOR, PATCH]+

data/lib/planter.rb

@@ -1,74 +1,28 @@
 # frozen_string_literal: true
 
 require 'csv'
+require 'erb'
 require 'planter/version'
 require 'planter/railtie'
 require 'planter/config'
 require 'planter/seeder'
 
 ##
-# Class that seeders should inherit from. Seeder files should be in +db/seeds+,
-# and named +TABLE_seeder.rb+, where +TABLE+ is the name of the table being
-# seeded (I.E. +users_seeder.rb+). The seeder's class name should be the same
-# as the file name, but camelized. So, +UsersSeeder+. The directory where the
-# seeder files are located can be changed via an initializer.
+# The main module for the plugin. It nicely wraps the +Planter::Config+ class
+# so that you can customize the plugin via an initializer or in the
+# +db/seeds.rb+ file. This is how you'll specify your list of seeders to use,
+# along with customizing the +seeders_directory+ and +csv_files_directory+.
 #
-# The most basic way to seed is to have a CSV file with the same name as the
-# table in +db/seed_files/+. So, +users.csv+. This CSV should have the table's
-# column names as header. To seed using this method, your class should look
-# like the following. Note that +:csv_file+ is not required; it defaults to the
-# table name with a +csv+ file extension. The directory where the seed files
-# are kept can be changed via an initializer.
-#   # db/seeds/users_seeder.rb
-#   require 'planter'
-#   class UsersSeeder < Planter::Seeder
-#     seeding_method :standard_csv, csv_file: '/home/me/users.csv'
+#   Planter.configure do |config|
+#     config.seeders = %i[users]
+#     config.seeders_directory = 'db/seeds'
+#     config.csv_files_directory = 'db/seed_files'
 #   end
 #
-# Another way to seed is to create records from a data array. To do this, your
-# class must implement a +data+ attribute or method, which is an array of
-# hashes. Note that this class already provides the +attr_reader+ for this
-# attribute, so the most you have to do it create instance variables in your
-# constructor. If if you want your data to be different for each new record
-# (via Faker, +Array#sample+, etc.), you'll probably want to supply a method
-# called data that returns an array of new data each time.
-#   require 'planter'
-#   class UsersSeeder < Planter::Seeder
-#     seeding_method :data_array
-#     def data
-#       [{foo: 'bar', baz: 'bar'}]
-#     end
-#   end
-#
-# In both of the above methods, you can specify +parent_model+ and
-# +association+. If specified, records will be created via that parent model's
-# association. If +association+ is not provided, it will be assumed to be the
-# model name, pluralized and snake-cased (implying a +has_many+ relationship).
-# For example, if we're seeding the users table, and the model is +User+, the
-# association will default to +users+.
-#   require 'planter'
-#   class UsersSeeder < Planter::Seeder
-#     seeding_method :data_array, parent_model: 'Person', association: :users
-#     def data
-#       [{foo: 'bar', baz: 'bar'}]
-#     end
-#   end
+# To then seed your application, simply call the +seed+ method from your
+# +db/seeds.rb+ file (or wherever you need to call it from).
 #
-# You can also set +number_of_records+ to determine how many times each record
-# in the +data+ array will get created. The default is 1. Note that if this
-# attribute is set alongside +parent_model+ and +association+,
-# +number_of_records+ will be how many records will be created for each record
-# in the parent table.
-#   require 'planter'
-#   class UsersSeeder < Planter::Seeder
-#     seeding_method :data_array, number_of_records: 5
-#     def data
-#       [{foo: 'bar', baz: 'bar'}]
-#     end
-#   end
-#
-# If you need to seed a different way, put your own custom +seed+ method in
-# your seeder class and do whatever needs to be done.
+#   Planter.seed
 module Planter
   ##
   # The seeder configuration.
@@ -89,13 +43,14 @@ module Planter
   ##
   # Quick way of configuring the directories via an initializer.
   #
-  # @return [self]
+  # @return [Planter::Config]
   #
   # @example
-  #   Planter.configure do |app_seeder|
-  #     app_seeder.seeders = %i[users]
-  #     app_seeder.seeders_directory = 'db/seeds'
-  #     app_seeder.csv_files_directory = 'db/seed_files'
+  #   require 'planter'
+  #   Planter.configure do |config|
+  #     config.seeders = %i[users]
+  #     config.seeders_directory = 'db/seeds'
+  #     config.csv_files_directory = 'db/seed_files'
   #   end
   def self.configure
     config.tap { |c| yield c }
@@ -103,20 +58,21 @@ module Planter
 
   ##
   # This is the method to call from your +db/seeds.rb+. It callse the seeders
-  # listed in +Planter.config.seeders+. To call specific seeders at
-  # runtime, you can set the +SEEDERS+ environmental variable to a
-  # comma-separated list of seeders.
+  # listed in +Planter.config.seeders+. To call specific seeders at runtime,
+  # you can set the +SEEDERS+ environmental variable to a comma-separated list
+  # of seeders, like +rails db:seed SEEDERS=users,accounts+.
   #
   # @example
-  #   rails db:seed SEEDERS=users,accounts
+  #   # db/seeds.rb, assuming your +configure+ block is in an initializer.
+  #   Planter.seed
   def self.seed
     seeders = ENV['SEEDERS']&.split(',') || config.seeders&.map(&:to_s)
-    raise RuntimeError, 'No seeders specified; nothing to do' unless seeders&.any?
+    raise RuntimeError, 'No seeders specified' unless seeders&.any?
 
-    seeders.each do |table|
-      require Rails.root.join(config.seeders_directory, "#{table}_seeder.rb").to_s
-      puts "Seeding #{table}" unless config.quiet
-      "#{table.camelize}Seeder".constantize.new.seed
+    seeders.each do |s|
+      require Rails.root.join(config.seeders_directory, "#{s}_seeder.rb").to_s
+      puts "Seeding #{s}" unless config.quiet
+      "#{s.camelize}Seeder".constantize.new.seed
     end
   end
 end

data/lib/tasks/planter_tasks.rake

@@ -1,4 +1,13 @@
-# desc "Explaining what the task does"
-# task :planter do
-#   # Task goes here
-# end
+require 'planter'
+
+namespace :planter do
+  desc 'Seed application. Use this to keep planter separate from db:seed'
+  task seed: :environment do
+    Planter.configure do |config|
+      # NOTE: the seed method already looks for ENV['SEEDERS']
+      ENV['SEEDERS_DIRECTORY'] && config.seeders_directory = ENV['SEEDERS_DIRECTORY']
+      ENV['CSV_FILES_DIRECTORY'] && config.csv_files_directory = ENV['CSV_FILES_DIRECTORY']
+    end
+    Planter.seed
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: planter
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.10
 platform: ruby
 authors:
 - Evan Gray
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-23 00:00:00.000000000 Z
+date: 2021-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -41,6 +41,8 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- lib/generators/planter/initializer_generator.rb
+- lib/generators/planter/seeder_generator.rb
 - lib/planter.rb
 - lib/planter/config.rb
 - lib/planter/railtie.rb
@@ -70,7 +72,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.2.22
 signing_key: 
 specification_version: 4
 summary: Framework for seeding rails applications.