planter 0.0.12 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37c19399e25198fe0545690d5b5568c5bd91b4736258af3d8664c36abe882889
-  data.tar.gz: a399b54a606d7c0e98d49f0bad5abff1fc4726d96eab3573c82d1dc649b83b1e
+  metadata.gz: b346415e35c538e46222ced2131792a27f778fafe169143116c6908ddca88aac
+  data.tar.gz: ed3952a7fd92566b2acb31e0fee881549675f40aa579ebe9115db2f86f302eb0
 SHA512:
-  metadata.gz: 6275a47f463227b86374e327781edd92bbd9cdf9399bafa68c6c4cb3316ae812cf081509a26e81e04101f9cd4af43396f2c008477741f00f475ea09436353ba8
-  data.tar.gz: 1a5a27d9253b78ae0c1c0526c1f8dcb977a428ec5c62cb4239f5542413e1f5020c68d8ee0d356ded4c1f3094c7f449f03fefb72180250388de81f8c44c2c6a63
+  metadata.gz: d07501dd0544476e04b768277d870f035626f6c00218a9f248e6fe6f7dcae833757162b688a269066bc8daa5dae1d2fb6f20db7c45273245da60f900cde80f3f
+  data.tar.gz: '09e7ba1054d15f7aa68aedaac7915fdda444eac1bff9630402e5f5999f872283e978b5e60b9581310cdd2bbc9ea4688d73b3fd7d6c8781b802b8bb21cee7fb8c'

data/README.md

@@ -60,7 +60,7 @@ Planter.configure do |config|
   ]
 
   ##
-  # The directory where the seeder files are kept.
+  # The directory where the seeders are kept.
   # config.seeders_directory = 'db/seeds'
 
   ##
@@ -68,7 +68,12 @@ Planter.configure do |config|
   # config.csv_files_directory = 'db/seed_files'
 
   ##
-  # The default trim mode for ERB.
+  # The default trim mode for ERB. Valid modes are:
+  # '%'  enables Ruby code processing for lines beginning with %
+  # '<>' omit newline for lines starting with <% and ending in %>
+  # '>'  omit newline for lines ending in %>
+  # '-'  omit blank lines ending in -%>
+  # I recommend reading the help documentation for ERB::new()
   # config.erb_trim_mode = nil
 end
 ```
@@ -202,13 +207,16 @@ 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
-`AddressesSeeder` that uses the `parent_model` option, as seen below.
+`AddressesSeeder` that uses the `parent` option, as seen below. This option
+should be the name of the `belongs_to` association in your model. The primary
+key, foreign key, and model name of the parent will all be determined by
+reflecting on the association.
 
 ```ruby
 require 'faker'
 
 class AddressesSeeder < Planter::Seeder
-  seeding_method :data_array, parent_model: 'User'
+  seeding_method :data_array, parent: :user
 
   def data
     [{
@@ -222,9 +230,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`
-option.
+records *for each record of the parent model*.
 
 ### Custom seeds
 To write your own custom seeds, just overload the `seed` method and do whatever
@@ -257,4 +263,4 @@ Request.
 I do these projects for fun, and I enjoy knowing that they're helpful to people.
 Consider starring [the repository](https://github.com/evanthegrayt/planter)
 if you like it! If you love it, follow me [on
-Github](https://github.com/evanthegrayt)!
+GitHub](https://github.com/evanthegrayt)!

data/lib/generators/planter/initializer_generator.rb

@@ -19,7 +19,7 @@ module Planter
             ]
 
             ##
-            # The directory where the seeder files are kept.
+            # The directory where the seeders are kept.
             # config.seeders_directory = 'db/seeds'
 
             ##
@@ -27,7 +27,12 @@ module Planter
             # config.csv_files_directory = 'db/seed_files'
 
             ##
-            # The default trim mode for ERB.
+            # The default trim mode for ERB. Valid modes are:
+            # '%'  enables Ruby code processing for lines beginning with %
+            # '<>' omit newline for lines starting with <% and ending in %>
+            # '>'  omit newline for lines ending in %>
+            # '-'  omit blank lines ending in -%>
+            # I recommend reading the help documentation for ERB::new()
             # config.erb_trim_mode = nil
           end
         EOF

data/lib/generators/planter/seeder_generator.rb

@@ -3,7 +3,7 @@ module Planter
     class SeederGenerator < Rails::Generators::Base
       argument :seeder, required: true
 
-      desc "This generator creates a seeder file at #{::Planter.config.seeders_directory}"
+      desc "Creates a seeder file at #{::Planter.config.seeders_directory}"
 
       def generate_seeders
         seeder == 'ALL' ? tables.each { |t| generate(t) } : generate(seeder)

data/lib/planter/seeder.rb

@@ -2,13 +2,13 @@
 
 module Planter
   ##
-  # 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.
+  # Class that seeders should inherit from. Seeders 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
@@ -26,7 +26,7 @@ module Planter
   # 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
+  # attribute, so the most you have to do is 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.
@@ -38,15 +38,17 @@ module Planter
   #     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+.
+  # In both of the above methods, you can specify a +parent+ association, which
+  # is the +belongs_to+ association name in your model, which, when specified,
+  # records will be created for each record in the parent table. For example,
+  # if we're seeding the users table, and the model is +User+, which belongs to
+  # +Person+, then doing the following will create a user record for each
+  # record in the Person table. Note that nothing is automatically done to
+  # prevent any validation errors; you must do this on your own, mostly likely
+  # using +Faker+ or a similar library.
   #   require 'planter'
   #   class UsersSeeder < Planter::Seeder
-  #     seeding_method :data_array, parent_model: 'Person', association: :users
+  #     seeding_method :data_array, parent: :person
   #     def data
   #       [{foo: 'bar', baz: 'bar'}]
   #     end
@@ -54,9 +56,8 @@ module Planter
   #
   # 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.
+  # this attribute is set alongside +parent+, +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
@@ -102,121 +103,24 @@ module Planter
     attr_reader :data
 
     ##
-    # If your class is going to use the inherited +seed+ method, you must tell
-    # it which +seeding_method+ to use. The argument to this method must be
-    # included in the +SEEDING_METHODS+ array.
-    #
-    # @param [Symbol] seeding_method
-    #
-    # @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
-    #
-    # @kwarg [String] erb_trim_mode
+    # What trim mode should ERB use?
     #
-    # @example
-    #   require 'planter'
-    #   class UsersSeeder < Planter::Seeder
-    #     seeding_method :csv,
-    #       number_of_records: 2,
-    #       model: 'User'
-    #       parent_model: 'Person',
-    #       association: :users,
-    #       csv_name: :awesome_users,
-    #       unique_columns %i[username email],
-    #       erb_trim_mode: '<>'
-    #   end
-    def self.seeding_method(
-      method,
-      number_of_records: 1,
-      model: nil,
-      parent_model: nil,
-      association: nil,
-      csv_name: nil,
-      unique_columns: nil,
-      erb_trim_mode: nil
-    )
-      if !SEEDING_METHODS.include?(method.intern)
-        raise ArgumentError, "Method must be one of #{SEEDING_METHODS.join(', ')}"
-      elsif association && !parent_model
-        raise ArgumentError, "Must specify :parent_model with :association"
-      end
-
-      @seeding_method = method
-      @number_of_records = number_of_records
-      @model = model || to_s.delete_suffix('Seeder').singularize
-      @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 || Planter.config.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 # :nodoc:
-      associations =
-        @parent_model.constantize.reflect_on_all_associations.map(&:name)
-      table = to_s.delete_suffix('Seeder').underscore.split('/').last
-
-      [table, table.singularize].map(&:intern).each do |t|
-        return t if associations.include?(t)
-      end
-
-      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.
-    def seed
-      validate_attributes
-
-      parent_model ? create_records_from_parent : create_records
-    end
-
-    protected
+    # @return [String]
+    class_attribute :erb_trim_mode
 
     ##
-    # The seeding method specified.
+    # 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 [Symbol]
-    def seeding_method
-      @seeding_method ||= self.class.instance_variable_get('@seeding_method')
-    end
+    # @return [Array]
+    class_attribute :unique_columns
 
     ##
     # The model for the table being seeded. If the model name you need is
     # different, change via +seeding_method+.
     #
     # @return [String]
-    def model
-      @model ||= self.class.instance_variable_get('@model')
-    end
+    class_attribute :model
 
     ##
     # The model of the parent. When provided with +association+, records in the
@@ -224,18 +128,7 @@ module Planter
     # class must set this attribute via +seeding_method+.
     #
     # @return [String]
-    def parent_model
-      @parent_model ||= self.class.instance_variable_get('@parent_model')
-    end
-
-    ##
-    # When using +parent_model+, the association name. Your class can set this
-    # attribute via +seeding_method+.
-    #
-    # @return [Symbol]
-    def association
-      @association ||= self.class.instance_variable_get('@association')
-    end
+    class_attribute :parent
 
     ##
     # The number of records to create from each record in the +data+ array. If
@@ -243,82 +136,132 @@ module Planter
     # +seeding_method+.
     #
     # @return [Integer]
-    def number_of_records
-      @number_of_records ||=
-        self.class.instance_variable_get('@number_of_records')
-    end
+    class_attribute :number_of_records
 
     ##
     # The csv file corresponding to the model.
     #
     # @return [String]
-    def csv_file
-      @csv_file ||= self.class.instance_variable_get('@csv_file')
-    end
+    class_attribute :csv_file
 
     ##
-    # 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.
+    # The seeding method specified.
     #
-    # @return [Array]
-    def unique_columns
-      @unique_columns ||= self.class.instance_variable_get('@unique_columns')
-    end
+    # @return [Symbol]
+    class_attribute :seed_method
 
     ##
-    # What trim mode should ERB use?
-    #
-    # @return [String]
-    def erb_trim_mode
-      @erb_trim_mode ||= self.class.instance_variable_get('@erb_trim_mode')
-    end
+    # Access the metaclass so we can define public and private class methods.
+    class << self
+      ##
+      # If your class is going to use the inherited +seed+ method, you must tell
+      # it which +seeding_method+ to use. The argument to this method must be
+      # included in the +SEEDING_METHODS+ array.
+      #
+      # @param [Symbol] seed_method
+      #
+      # @kwarg [Integer] number_of_records
+      #
+      # @kwarg [String] model
+      #
+      # @kwarg [String] parent
+      #
+      # @kwarg [Symbol, String] parent
+      #
+      # @kwarg [Symbol, String] csv_name
+      #
+      # @kwarg [Symbol, String] unique_columns
+      #
+      # @kwarg [String] erb_trim_mode
+      #
+      # @example
+      #   require 'planter'
+      #   class UsersSeeder < Planter::Seeder
+      #     seeding_method :csv,
+      #       number_of_records: 2,
+      #       model: 'User'
+      #       parent: :person,
+      #       csv_name: :awesome_users,
+      #       unique_columns %i[username email],
+      #       erb_trim_mode: '<>'
+      #   end
+      def seeding_method(
+        seed_method,
+        number_of_records: 1,
+        model: nil,
+        parent: nil,
+        csv_name: nil,
+        unique_columns: nil,
+        erb_trim_mode: nil
+      )
+        if !SEEDING_METHODS.include?(seed_method.intern)
+          raise ArgumentError, "Method must be: #{SEEDING_METHODS.join(', ')}"
+        end
 
-    ##
-    # Creates records from the +data+ attribute.
-    def create_records
-      data.each do |rec|
-        number_of_records.times do
-          rec.transform_values { |value| value == 'NULL' ? nil : value }
-          unique, attrs = split_record(rec)
-          model.constantize.where(unique).first_or_create!(attrs)
+        self.seed_method = seed_method
+        self.number_of_records = number_of_records
+        self.model = model || to_s.delete_suffix('Seeder').singularize
+        self.parent = parent
+        self.csv_file = determine_csv_filename(csv_name) if seed_method == :csv
+        self.erb_trim_mode = erb_trim_mode || Planter.config.erb_trim_mode
+        self.unique_columns =
+          case unique_columns
+          when String, Symbol then [unique_columns.intern]
+          when Array then unique_columns.map(&:intern)
+          end
+      end
+
+      private
+
+      def 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
     end
 
     ##
-    # Create records from the +data+ attribute for each record in the
-    # +parent_table+, via the specified +association+.
-    def create_records_from_parent
-      parent_model.constantize.all.each do |assoc_rec|
-        number_of_records.times do
-          data.each { |rec| send(create_method, assoc_rec, association, rec) }
-        end
-      end
+    # The default seed method. To use this method, your class must provide a
+    # valid +seeding_method+, and not implement its own +seed+ method.
+    def seed
+      validate_attributes
+
+      parent ? create_records_from_parent : create_records
     end
 
-    private
+    protected
 
-    def create_method # :nodoc:
-      parent_model.constantize.reflect_on_association(
-        association
-      ).macro.to_s.include?('many') ? :create_has_many : :create_has_one
+    ##
+    # Creates records from the +data+ attribute.
+    def create_records
+      data.each { |record| create_record(record) }
     end
 
-    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)
+    ##
+    # Create records from the +data+ attribute for each record in the +parent+.
+    def create_records_from_parent
+      parent_model.constantize.pluck(primary_key).each do |parent_id|
+        data.each { |record| create_record(record, parent_id: parent_id) }
+      end
     end
 
-    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)
+    def create_record(record, parent_id: nil)
+      number_of_records.times do
+        unique, attrs = split_record(record)
+        model.constantize.where(
+          unique.tap { |u| u[foreign_key] = parent_id if parent_id }
+        ).first_or_create!(attrs)
       end
     end
 
     def validate_attributes # :nodoc:
-      case seeding_method.intern
+      case seed_method.intern
       when :csv
         contents = ::File.read(csv_file)
         if csv_file.end_with?('.erb')
@@ -337,8 +280,29 @@ module Planter
 
     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
+
+    def association_options
+      @association_options ||=
+        model.constantize.reflect_on_association(parent).options
+    end
+
+    def primary_key
+      @primary_key ||=
+        association_options.fetch(:primary_key, :id)
+    end
+
+    def foreign_key
+      @foreign_key ||=
+        association_options.fetch(:foreign_key, "#{parent}_id")
+    end
+
+    def parent_model
+      @parent_model ||=
+        association_options.fetch(:class_name, parent.to_s.classify)
+    end
   end
 end

data/lib/planter/version.rb

@@ -15,13 +15,13 @@ module Planter
     # Minor version.
     #
     # @return [Integer]
-    MINOR = 0
+    MINOR = 1
 
     ##
     # Patch version.
     #
     # @return [Integer]
-    PATCH = 12
+    PATCH = 1
 
     ##
     # Version as +[MAJOR, MINOR, PATCH]+

data/lib/planter.rb

@@ -67,7 +67,7 @@ module Planter
   #   Planter.seed
   def self.seed
     seeders = ENV['SEEDERS']&.split(',') || config.seeders&.map(&:to_s)
-    raise RuntimeError, 'No seeders specified' unless seeders&.any?
+    raise RuntimeError, 'No seeders specified' if seeders.blank?
 
     seeders.each do |s|
       require Rails.root.join(config.seeders_directory, "#{s}_seeder.rb").to_s

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: planter
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.1.1
 platform: ruby
 authors:
 - Evan Gray
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-11-15 00:00:00.000000000 Z
+date: 2021-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -16,20 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 6.1.3
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 6.1.3.1
+        version: 6.1.4.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 6.1.3
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 6.1.3.1
+        version: 6.1.4.4
 description: Create a seeder for each table in your database, and easily seed from
   CSV or custom methods
 email: