planter 0.0.7 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 42b61a78b5034eadac54f7e5a570073851b4a9a6fc20c4fae71a1e49fb8d3df1
-  data.tar.gz: c02538d3a776a89b221b135c4aa2d355a278df35e514d53872f200556bc720dd
+  metadata.gz: 9eab293e0cec74131351f8e1ff29919165da5e7eeb9cea2d305802f8cf5e1c8f
+  data.tar.gz: 6e06237482fb476e3a664fead3bfd64d15013f5570316964360161c9e05a25a4
 SHA512:
-  metadata.gz: 119f4f0a790efd00eb4e537734ab51e9416b5017f0891a07698d291b44604b2a81e7ea73d1a8893da1e3f4c24b4790a4a18a352388240d9ed9de32a1f19206b5
-  data.tar.gz: 3c066efbe8b1325bec3218de0840bf91688c6ed1da29e06446756603f370620d5a57af4afc57313fa42171ba977f1dab9cbe73a9578fcb3379e2433935c609b3
+  metadata.gz: 3d28919333f86c7e0d6be6e4a12a4dea558ec0d734ccb63457931af6c8070f71ff76a90c370d2e26a8500106dbb81585ca9685b829c2cf220cd770be229e274d
+  data.tar.gz: a40e5e9ae771224e486c8263d2194fc5de1256b6d6a0d9d880ef44aea01294160fbbe1f139b74a375f4adb3e6372e155700968de0d862918ad0662ce3a2fc80c

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
@@ -100,14 +140,14 @@ 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:
 
-```csv.erb
+```
 email,login_attempts
 <% count = 1 %>
 test2@example.com,<%= count += 1 %>
 test2@example.com,<%= count += 1 %>
 ```
 
-Running `rails db:seed` will now seed your `users` table.
+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
@@ -115,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
@@ -135,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
@@ -180,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,7 +2,88 @@
 
 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.
@@ -12,11 +93,10 @@ module Planter
 
     ##
     # 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
-    # +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
@@ -38,6 +118,8 @@ module Planter
     #
     # @kwarg [Symbol, String] csv_name
     #
+    # @kwarg [Symbol, String] unique_columns
+    #
     # @example
     #   require 'planter'
     #   class UsersSeeder < Planter::Seeder
@@ -46,7 +128,8 @@ module Planter
     #       model: 'User'
     #       parent_model: 'Person',
     #       association: :users,
-    #       csv_name: :awesome_users
+    #       csv_name: :awesome_users,
+    #       unique_columns %i[username email]
     #   end
     def self.seeding_method(
       method,
@@ -54,7 +137,8 @@ module Planter
       model: to_s.delete_suffix('Seeder').singularize,
       parent_model: nil,
       association: nil,
-      csv_name: nil
+      csv_name: nil,
+      unique_columns: nil
     )
       if !SEEDING_METHODS.include?(method.intern)
         raise ArgumentError, "Method must be one of #{SEEDING_METHODS.join(', ')}"
@@ -68,6 +152,11 @@ module Planter
       @parent_model = parent_model
       @association = @parent_model && (association || determine_association)
       @csv_file = determine_csv_filename(csv_name) if @seeding_method == :csv
+      @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 # :nodoc:
@@ -89,7 +178,7 @@ module Planter
       ).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)
+        return fname if ::File.file?(fname)
       end
 
       raise ArgumentError, "Couldn't find csv for #{@model}"
@@ -162,14 +251,23 @@ 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
+
     ##
     # 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
@@ -187,34 +285,47 @@ 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 :csv
-        contents = File.read(csv_file)
+        contents = ::File.read(csv_file)
         if csv_file.end_with?('.erb')
           contents = ERB.new(contents, trim_mode: '<>').result(binding)
         end
 
-        @data ||= ::CSV.parse(contents, headers: true).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:
+      return [rec, {}] unless unique_columns
+      u = unique_columns.each_with_object({}) { |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 = 7
+    PATCH = 11
 
     ##
     # Version as +[MAJOR, MINOR, PATCH]+

data/lib/planter.rb

@@ -8,68 +8,21 @@ 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_name+ 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 :csv, csv_name: '/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.
@@ -90,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 }
@@ -104,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.7
+  version: 0.0.11
 platform: ruby
 authors:
 - Evan Gray
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-24 00:00:00.000000000 Z
+date: 2021-08-30 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.