dirty_seed 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ff36072911914eaea5004a422959980277fc11681483fd84d82cdb89d5677b9
-  data.tar.gz: 2b0f743b67520ea7b5c535a4eaa55a349388bc01be02985d5e4a4a3bfe8996e8
+  metadata.gz: 98dffcdecbd3fa5934529401fbac06a25cb883f853896cb6f93c13cf3cfce9f5
+  data.tar.gz: bd502b06f80ea7d2f7003f13dc260138e2bad1b5dc64f318c043ced8e9ed4fc9
 SHA512:
-  metadata.gz: 7b5c5620e630a0803ea2337482e2bf9579164c39976602493373f01eab4285418533b3ec226bcb5611b0acfb2f44ce4fab012d30d205876851911b28d31d3095
-  data.tar.gz: 00a6422b95a9e8b0712d070c618f00dffa217d26704944d35c1250db3c54b0b05e262f69f8f77d282d39ef4419ae65d84d06b02ef9772ac8aa5fc87c00788d47
+  metadata.gz: 685799e510fd74e13965b1ba4da70b2db9a4b170e4cbf4b6e411e757877593bafedd87153257645dc7084f198d3c226ac9bce0e131359ec1b90e5c85ecd4c2c6
+  data.tar.gz: f3285cdea256685d2b1d163f2277dd33434d60b4e9bb2695c157e01717a253085cf60d517ec98aa0b13732f36f87ac5d3fe59f7e3b155f0966ec6fe2aa81ed50

data/README.md

@@ -7,7 +7,7 @@
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'dirty_seed', '~> 0.2.0'
+gem 'dirty_seed', '~> 0.2.1'
 ```
 
 And then execute:
@@ -35,7 +35,7 @@ $ rake dirty_seed:seed COUNT=42
 
 Instance that cannot be saved are simply ignored.
 
-For each model, the number of created created records and the recurrent errors are printed out:
+For each model, the number of created records and the recurrent errors are printed out:
 
 ```bash
 rake dirty_seed:seed COUNT=15
@@ -76,7 +76,7 @@ end
 
 A value is assigned for each attribute, depending on its type.
 
-Special types (`hstore`, `json`, `jsonb`, `array`...) are currently ignored (no value assignment).
+Special types like `json`, `jsonb` and `array` are treated.
 
 For instance, given the following schema:
 
@@ -93,6 +93,8 @@ create_table 'things' do |t|
   t.string 'a_string'
   t.text 'a_text'
   t.time 'a_time'
+  t.json 'a_json'
+  t.text[] 'an_array'
 end
 ```
 
@@ -100,7 +102,6 @@ end
 
 ```ruby
 {
-  id: 1,
   a_binary: '13',
   a_boolean: false,
   a_date: Wed, '02 Dec 2020',
@@ -110,7 +111,9 @@ end
   a_float: 28.825997012616263,
   a_string: 'Maxime eum ratione ab quod nihil.',
   a_text: 'Autem non in est dolore.',
-  a_time: 'Sat, 01 Jan 2000 09:31:22 UTC +00:00'
+  a_time: 'Sat, 01 Jan 2000 09:31:22 UTC +00:00',
+  a_json: { 'Autem': 'Dolore', 'Lorem': 'Nihil' },
+  an_array: ['Autem', 'Dolore', 'Nihil'],
 }
 ```
 
@@ -169,7 +172,6 @@ end
 
 ```ruby
 {
-  :id => 1,
   :thing_id => 42,
   :notifiable_type => 'User',
   :notifiable_id => 6,
@@ -187,14 +189,21 @@ For attributes requiring validations, assigned value is adapted.
 
 Currently, the following validations are treated:
 
-- `uniqueness`
 - `absence`
+- `format: { with: regex }` 
 - `inclusion: { in: [x, y] }`
+- `length: { minimum: x }`
+- `length: { maximum: x }`
+- `length: { in: x..y }`
+- `length: { is: x }`
 - `numericality: { greater_than: x }`
 - `numericality: { greater_than_or_equal_to: x }`
 - `numericality: { lesser_than: x }`
 - `numericality: { lesser_than_or_equal_to: x }`
 - `numericality: { in: x..y }`
+- `uniqueness`
+
+Attribute with an `enum` are treated too.
 
 Custom validations are not inspected.
 
@@ -226,7 +235,6 @@ end
 
 ```ruby
 {
-  id: 1,
   first_name: 'Emory',
   last_name: 'Franecki',
   address: '843 Schneider Squares, Port Olenmouth, TN 12657',
@@ -270,16 +278,14 @@ The current attribute names treated this way are:
 - `username`
 - `uuid`
 
-More meanings will be added soon and will extend the mechanism to other formats (e.g. an `age` integer).
-
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 
 ## Next features and improvements
 
-* Add specs to validate specific errors rescue.
+* Add specs to validate all specific errors rescue.
 * Manage validations on dates and times.
 * Detect more meaningful attributes.
-* Detect more protected attributes (to ignore).
+* Detect more protected attributes (attributes to ignore).
 * Add a configuration system to define how to seed: excluded models, default values, faker method...

data/lib/dirty_seed/data_model.rb

@@ -24,10 +24,10 @@ module DirtySeed
     # @param verbose [Boolean] true if logs should be outputed
     # @return [void]
     def seed(count, verbose: false)
-      logger.verbose! if verbose
+      logger.verbose = verbose
       # check if ApplicationRecord is defined first (or raise error)
       ::ApplicationRecord && seeders.each { |seeder| seeder.seed(count) }
-      print_logs
+      logger.summary(seeders)
     end
 
     # Creates and returns a seeder for each model
@@ -53,12 +53,5 @@ module DirtySeed
     def active_record_models
       ::ApplicationRecord.descendants.reject(&:abstract_class)
     end
-
-    # Prints logs in the console
-    # @return [void]
-    def print_logs
-      logger.break_line
-      seeders.each { |seeder| logger.seeder_data(seeder) }
-    end
   end
 end

data/lib/dirty_seed/logger.rb

@@ -6,73 +6,57 @@ module DirtySeed
   class Logger
     include Singleton
 
-    # Sets verbose to true
-    # @return [void]
-    def verbose!
-      @verbose = true
-    end
+    attr_accessor :verbose
 
     # Outputs before seeding a model
     # @param model [DirtySeed::Model]
     # @return [void]
-    def seed(model)
-      verbose && puts("Seeding #{model.name.underscore.pluralize}")
+    def seed_model_message(model)
+      return unless verbose
+
+      puts('')
+      puts("Seeding #{model.name.underscore.pluralize}")
+      print('> ')
     end
 
-    # Outputs the start of a new line
-    # @return [void]
-    def start_line
-      verbose && print('> ')
+    # Cleans the message before output (remove linebreak and truncate)
+    # @param message [String]
+    # @return string
+    def clean(message)
+      base = message.tr("\n", "\t")
+      # #truncate is defined in ActiveSupport and then could be undefined
+      base.respond_to?(:truncate) ? base.truncate(150) : base.slice(150)
     end
 
     # Outputs a success message
     # @return [void]
     def success
-      verbose && print("\e[#{green}m.\e[0m")
+      verbose && print("\e[32m.\e[0m")
     end
 
     # Outputs a fail message
     # @return [void]
-    def fail
-      verbose && print("\e[#{red}mx\e[0m")
-    end
-
-    # Outputs an error message
-    # @return [void]
-    def error
-      verbose && print("\e[#{red}m!\e[0m")
+    def failure
+      verbose && print("\e[31mx\e[0m")
     end
 
-    # Outputs a line break
+    # Outputs an abort message
     # @return [void]
-    def break_line
-      verbose && puts('')
+    def abort
+      verbose && print("\e[31m | too many errors -> abort\e[0m")
     end
 
     # Outputs seeder data
     # @return [void]
-    def seeder_data(seeder)
+    def summary(seeders)
       return unless verbose
 
-      puts seeder.model.name
-      puts "  \e[#{green}mseeded: #{seeder.score}\e[0m"
-      puts "  \e[#{red}merrors: #{seeder.error_list}\e[0m" if seeder.errors.any?
-    end
-
-    private
-
-    attr_reader :verbose
-
-    # Returns color code for green
-    # @return [Integer]
-    def green
-      32
-    end
-
-    # Returns color code for red
-    # @return [Integer]
-    def red
-      31
+      puts ''
+      seeders.each do |seeder|
+        puts seeder.model.name
+        puts "  \e[32mseeded: #{seeder.records.count}\e[0m"
+        puts "  \e[31merrors: #{seeder.errors.join(', ')}\e[0m" if seeder.errors.any?
+      end
     end
   end
 end

data/lib/dirty_seed/seeder.rb

@@ -3,42 +3,32 @@
 module DirtySeed
   # Represents an Active Record model
   class Seeder
-    attr_reader :model, :instances, :errors
+    attr_reader :model, :records, :errors
 
-    # Initializes an instance
+    # Initializes an record
     # @param model [DirtySeed::Model]
     # @return [DirtySeed::Seeder]
     def initialize(model)
       @model = model
-      @instances = []
+      @records = []
       @errors = []
     end
 
     # Creates records
     # @param count [Integer]
     # @return [Array<Object>]
-    def seed(count)
-      logger.seed(model)
-      @count = count
+    def seed(qty = 1)
+      self.quantity = qty
+      logger.seed_model_message(model)
       create_records
-      @errors.uniq!
-      instances
-    end
-
-    # Returns the number of successfully seeded records
-    # @return [Integer]
-    def score
-      instances.count
-    end
-
-    # Returns the errors as list
-    # @return [String]
-    def error_list
-      errors.join(', ')
+      records
     end
 
     private
 
+    attr_accessor :successive_errors, :quantity
+    attr_writer :errors
+
     # Returns the logger
     # @return [DirtySeed::Logger]
     def logger
@@ -47,42 +37,80 @@ module DirtySeed
 
     # Creates records
     # @return [void]
+    # @note To take advantage of the faker uniqueness system, all params needs to be defined
+    #   Then all records can be created with these params
+    #   In other words: do not justcreate record one after the other
     def create_records
-      logger.start_line
-      data = params_collection
-      @count.times do |i|
-        instance = model.new(data[i])
-        save(instance)
-      # rescue from errors on initialize
-      rescue StandardError => e
-        @errors << e.message
-        logger.error
+      self.successive_errors = 0
+      params_collection.each do |params|
+        break if exceeded_successive_errors?
+
+        record = initialize_record(params)
+        record && save(record)
       end
-      logger.break_line
     end
 
-    # Tries to save instance in database
-    #   Populates instances and errors and log message
+    # Is the successive errors maximum reached?
+    # @return [Boolean]
+    # @note The purpose is to stop trying to seed if to many errors happen
+    def exceeded_successive_errors?
+      return false if successive_errors < 3
+
+      logger.abort
+      true
+    end
+
+    # Initialize a record
+    # @param params [Hash] params to pass to #new
+    # @return [Object] instance of model
+    def initialize_record(params)
+      model.new(params)
+      # rescue from errors on initialize
+    rescue StandardError => e
+      add_standard_error(e)
+    end
+
+    # Tries to save record in database
+    #   Populates records and errors and log message
     # @return [void]
-    def save(instance)
-      if instance.save
+    def save(record)
+      if record.save
+        records << record
+        self.successive_errors = 0
         logger.success
-        @instances << instance
       else
-        logger.fail
-        @errors.concat(instance.errors.full_messages)
+        add_record_errors(record)
       end
     # rescue from errors on save
     rescue StandardError => e
-      @errors << e.message
-      logger.error
+      add_standard_error(e)
+    end
+
+    # Adds record errors
+    # @param record [Object] instance of model
+    # @return [void]
+    def add_record_errors(record)
+      self.errors |= record.errors.full_messages
+      self.successive_errors = successive_errors + 1
+      logger.failure
+    end
+
+    # Adds standard error
+    # @param error [Error] error inheriting from StandardError
+    # @return [void]
+    def add_standard_error(error)
+      self.errors |= [logger.clean(error.message)]
+      self.successive_errors = successive_errors + 1
+      logger.failure
     end
 
     # Generate records params
     # @return [Array<Hash>] where Hash is params for one record
+    # @note If model has no attributes and no associations, return empty hashes
     def params_collection
       data = Hash[attributes_collection + associations_collection]
-      data.values.transpose.map { |vs| data.keys.zip(vs).to_h }
+      data = data.values.transpose.map { |vs| data.keys.zip(vs).to_h }
+      data.any? ? data : Array.new(quantity, {})
     end
 
     # Generate attributes params
@@ -96,7 +124,7 @@ module DirtySeed
     def attributes_collection
       model.attributes.map do |attribute|
         Faker::UniqueGenerator.clear
-        [attribute.name, Array.new(@count) { attribute.value }]
+        [attribute.name, Array.new(quantity) { attribute.value }]
       end
     end
 
@@ -110,7 +138,7 @@ module DirtySeed
     #   ]
     def associations_collection
       model.associations.map do |association|
-        [association.name, Array.new(@count) { association.value }]
+        [association.name, Array.new(quantity) { association.value }]
       end
     end
   end

data/lib/dirty_seed/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module DirtySeed
-  VERSION = '0.2.0'
+  VERSION = '0.2.1'
   public_constant :VERSION
 end

data/spec/dummy/app/models/alfa.rb

@@ -4,10 +4,20 @@ class Alfa < ApplicationRecord
   has_many :julietts
 
   after_initialize do |alfa|
-    raise StandardError if alfa.a_string == '39763e57-f8a0-483a-8b26-cc670de8cbfd'
+    raise StandardError, dirty_message('initialize') if alfa.a_string == '39763e57-f8a0-483a-8b26-cc670de8cbfd'
   end
 
   before_save do |alfa|
-    raise StandardError if alfa.a_string == '5ecb793c-e0fd-4315-b60d-66f34c1c17e3'
+    raise StandardError, dirty_message('save') if alfa.a_string == '5ecb793c-e0fd-4315-b60d-66f34c1c17e3'
+  end
+
+  def dirty_message(action)
+    <<~DIRTY
+      a dirty message on #{action}
+      taking several
+      lines and with a lot of
+      characters
+      #{Faker::Lorem.paragraph_by_chars(number: 500, supplemental: false)}
+    DIRTY
   end
 end