dirty_seed 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a892d4bb8402a4a51882d9b1b0917903a5a2a1ecfced0a29c05c4c68d9b47ada
-  data.tar.gz: 65d335ed1f25ac5ef2ef71c92be56186a85ffb7bedff6512ad5541816879ed05
+  metadata.gz: 8eac8a564716c1859fb212114a00596eb82d80f335204e224feca8356d34901b
+  data.tar.gz: 6211c5a287f117be9078c1ad4e88f7a8a2bd4d781f8921bcff840dcc5a033a0a
 SHA512:
-  metadata.gz: 52d3672671bba02cdbc421b6c0033c6732d52c05cb66ccf35fc79573b964b8762e13c12f965d10c2ab25eaeedc2a1b3405171eb7fc7ef77490002125289557ec
-  data.tar.gz: cefb338d2283c36e005b8b7b45352d4cfad5bfd940bd83b44e8678e5936d597cb54d8120156b0400837c7f370ed08ac113d88366b8a5153fe41270697f0ec59b
+  metadata.gz: dab9f9eae8cd32e59142cada451d8ba38dfec944c06726b7da82f968c39a6a3e77521879633b8496fe7086cba6acf32c626e0784aa4fe007842aae3f5c6b8373
+  data.tar.gz: 36504d9781746ee02493ef3a4092356eee9a93295fc5ddef9624e99a0b30d8a47fceee18593099d5a09994e33fe4d3ce9499b24c0ea07fa6a3d679eece304da3

data/README.md

@@ -2,7 +2,20 @@
 
 # DirtySeed
 
-Populate the database with records matching associations and validations, in order to quickly test application.
+:seedling: Populate the database with records matching associations and validations in order to quickly test the application rendering.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'dirty_seed', '~> 0.1.6'
+```
+
+And then execute:
+```bash
+$ bundle
+```
 
 ## Usage
 
@@ -13,32 +26,253 @@ To seed dirty data, run:
 $ rake dirty_seed:seed
 ```
 
-This will try to create instances for each of your models inheriting from `ApplicationRecord`.
+This will create records for each model inheriting from `ApplicationRecord`.
 
-If the instance cannot be saved, it is simply ignored.
+Instance that cannot be saved ar simply ignored.
 
-Number of instances created and recurrent errors will be outputed.
+For each model, the number of created created records and the recurrent errors are logged:
 
-## Installation
+```bash
+rake dirty_seed:seed
+User
+  created: 15
+Article
+  created: 9
+  errors: Title should match a specific regex
+```
 
-Add this line to your application's Gemfile:
+### Database population
+
+For each model inheriting from `ApplicationRecord`, 15 records are created.
+
+Models are sorted by their dependency to each others (through a `belongs_to` association) to ensure that some records exist before seeding an instance that requires one.
+
+For instance, given the following models, the order of seeding will be `User`, `Article` and `Notification`:
 
 ```ruby
-gem 'dirty_seed', git: 'https://github.com/BigBigDoudou/dirty_seed'
+# app/models/article
+class Article
+  belongs_to :user
+  has_many :notifications, as: :notifiable
+end
+
+class User
+  has_many :articles
+  has_many :notifications, as: :notifiable
+end
+
+class Notification
+  belongs_to :notifiable, polymorphic: true
+end
 ```
 
-And then execute:
-```bash
-$ bundle
+### Value assignment
+
+A value is assigned for each attribute, depending on its type.
+
+Special types (`hstore`, `json`, `jsonb`, `array`...) are currently ignored (no value assignment).
+
+For instance, given the following schema:
+
+```ruby
+# db/schema.rb
+create_table 'things' do |t|
+  t.binary 'a_binary'
+  t.boolean 'a_boolean'
+  t.date 'a_date'
+  t.datetime 'a_datetime'
+  t.decimal 'a_decimal'
+  t.integer 'an_integer'
+  t.float 'a_float'
+  t.string 'a_string'
+  t.text 'a_text'
+  t.time 'a_time'
+end
+```
+
+...then a dirty seeded `thing` looks like:
+
+```ruby
+{
+  id: 1,
+  a_binary: '13',
+  a_boolean: false,
+  a_date: Wed, '02 Dec 2020',
+  a_datetime: 'Sun, 08 Nov 2020 03:01:34 UTC +00:00',
+  a_decimal: 19.8812490973183,
+  an_integer: 6,
+  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'
+}
+```
+
+### Ignored attributes
+
+Some "special" attributes are not getting a value because:
+- Rails assigns it (STI type...);
+- or the RDBMS (PostgreSQL, SQLite...) assigns it;
+- or it is used in specific cases (authentication...).
+
+These attributes are currently:
+
+- `id`
+- `created_at`
+- `updated_at`
+- `type` (for STI)
+- `encrypted_password` (authentication usage)
+- `reset_password_token` (authentication usage)
+- `reset_password_sent_at` (authentication usage)
+- `remember_created_at` (authentication usage)
+
+### Associations
+
+For attributes related to an association, an instance matching the `belongs_to` is assigned.
+
+Polymorphic associations work too and only an instance of a model that `has_one` or `has_many` of this association can be assigned.
+
+For instance, given the following schema:
+
+```ruby
+# schema.rb
+create_table :notifications do |t|
+  t.references :thing
+  t.references :notifiable, polymorphic: true, null: false
+  t.references :foo, null: false, foreign_key: { to_table: :things }
+end
+```
+
+...and the models:
+
+```ruby
+# app/models/notification.rb
+class Notification < ApplicationRecord
+  belongs_to :notifiable, polymorphic: true
+  belongs_to :thing
+  belongs_to :bar, class_name: 'Thing', foreign_key: :foo_id
+end
+
+# app/models/user.rb
+class User < ApplicationRecord
+  has_many :notifications, as: :notifiable
+end
 ```
 
+...then a dirty seeded `notification` looks like:
+
+```ruby
+{
+  :id => 1,
+  :thing_id => 42,
+  :notifiable_type => 'User',
+  :notifiable_id => 6,
+  :foo_id => 75
+}
+
+notification.notifiable.class # User
+notification.thing.class # Thing
+notification.bar.class # Thing
+```
+
+### Validations
+
+For attributes requiring validations, assigned value is adapted.
+
+Currently, only the following validations are treated:
+
+- `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 }`
+
+Much more validations will be treated soon: `uniqueness`, `absence`, `inclusion`, `exclusion`, `length`...
+
+Custom validations are not inspected.
+
+### Meaning detection
+
+Some string attribute meanings are guessed by name: `email`, `first_name`, `latitude`...
+
+Values are then built with the `faker` gem.
+
+For instance, given the following schema:
+
+```ruby
+# db/schema.rb
+create_table "users" do |t|
+  t.string "first_name"
+  t.string "last_name"
+  t.string "address"
+  t.string "city"
+  t.string "country"
+  t.string "email"
+  t.string "password"
+  t.string "phone"
+  t.string "username"
+  # ...
+end
+```
+
+...then a dirty seeded `user` looks like:
+
+```ruby
+{
+  id: 1,
+  first_name: 'Emory',
+  last_name: 'Franecki',
+  address: '843 Schneider Squares, Port Olenmouth, TN 12657',
+  city: 'Torpshire',
+  country: 'United Arab Emirates',
+  email: 'scottie_friesen@example.net',
+  password: 'ZkUtNtFg4L',
+  phone: '(814) 382-6102 x036',
+  username: 'ernestine_rau',
+  # ...
+}
+```
+
+The current attribute names treated this way are:
+
+- `address`
+- `city`
+- `country`
+- `description`
+- `email`
+- `first_name`
+- `firstname`
+- `last_name`
+- `lastname`
+- `lat`
+- `latitute`
+- `lng`
+- `locale`
+- `longitude`
+- `middlename`
+- `middle_name`
+- `password`
+- `phone`
+- `phone_number`
+- `reference`
+- `title`
+- `user_name`
+- `username`
+- `uuid`
+
+More meanings will be added 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
 
+* Add a configuration system to define how to seed: number of instances, models to skip, default values, etc.
 * Assign values for more data types (json, array, etc.).
+* Detect more "special" attributes to ignore.
 * Integrate more validations (uniqueness, inclusion, length, absence, etc.).
-* Use instance errors to adjust values.
-* Add a configuration system to define how to seed: number of instances, models to skip, default values, etc.
+* Detect more meanings and extend it to other formats.
+* Use instance errors to adjust values and eventually match custom validations.
+
+

data/lib/dirty_seed/assigners/dirty_boolean.rb

@@ -2,7 +2,7 @@
 
 module DirtySeed
   module Assigners
-    # Draws a boolean value matching validators
+    # Draws a value matching validators
     class DirtyBoolean < DirtyAssigner
       # Returns a boolean
       # @return [Boolean]

data/lib/dirty_seed/assigners/dirty_date.rb

@@ -2,7 +2,7 @@
 
 module DirtySeed
   module Assigners
-    # Draws a Date matching validators
+    # Draws a value matching validators
     class DirtyDate < DirtyAssigner
       # Returns a date matching all validators
       # @return [Date]

data/lib/dirty_seed/assigners/dirty_float.rb

@@ -4,7 +4,7 @@ module DirtySeed
   module Assigners
     # Draws an Float matching validators
     class DirtyFloat < DirtyAssigner
-      # Returns a float matching all validators
+      # Returns a value matching all validators
       # @return [Float]
       def value
         integer + decimals
@@ -12,13 +12,13 @@ module DirtySeed
 
       private
 
-      # Returns an Integer matching all validators
+      # Returns a value matching all validators
       # @return [Integer]
       def integer
         DirtySeed::Assigners::DirtyInteger.new(dirty_attribute, 0).value
       end
 
-      # Returns a Float between 0 and 1
+      # Returns a value between 0 and 1
       # @return [Float]
       def decimals
         rand(0..Float(1))

data/lib/dirty_seed/assigners/dirty_integer.rb

@@ -6,7 +6,7 @@ module DirtySeed
     class DirtyInteger < DirtyAssigner
       attr_reader :min, :max
 
-      # Returns an integer matching all validators
+      # Returns an value matching all validators
       # @return [Integer]
       def value
         define_min_and_max
@@ -31,7 +31,7 @@ module DirtySeed
         end
       end
 
-      # Returns a random integer
+      # Returns a random value
       # @return [Integer]
       def random
         rand(sequence..42)
@@ -64,7 +64,7 @@ module DirtySeed
         @max = max_for(validator) if @max.nil? || max_for(validator) < @max
       end
 
-      # Returns an integer representing the minimal acceptable value
+      # Returns an value representing the minimal acceptable value
       # @param validator [ActiveModel::Validations::EachValidator]
       # @return [Integer]
       def min_for(validator)
@@ -73,7 +73,7 @@ module DirtySeed
           validator.options[:in]&.min
       end
 
-      # Returns an integer representing the maximal acceptable value
+      # Returns an value representing the maximal acceptable value
       # @param validator [ActiveModel::Validations::EachValidator]
       # @return [Integer]
       def max_for(validator)

data/lib/dirty_seed/assigners/dirty_string.rb

@@ -4,41 +4,46 @@ module DirtySeed
   module Assigners
     # Draws a String matching validators
     class DirtyString < DirtyAssigner
-      SPECIFIC_ATTRIBUTES = {
-        address: -> { Faker::Address.unique.full_address },
-        city: -> { Faker::Address.unique.city },
-        country: -> { Faker::Address.unique.country },
-        description: -> { Faker::Lorem.unique.paragraph(sentence_count: 2, random_sentences_to_add: 4) },
-        email: -> { Faker::Internet.unique.email(domain: 'example') },
-        first_name: -> { ::Faker::Name.unique.first_name },
-        firstname: -> { ::Faker::Name.unique.first_name },
-        last_name: -> { ::Faker::Name.unique.last_name },
-        lastname: -> { ::Faker::Name.unique.last_name },
-        lat: -> { Faker::Address.unique.latitude },
-        latitutde: -> { Faker::Address.unique.latitude },
-        lng: -> { Faker::Address.unique.longitude },
-        locale: -> { Faker::Address.unique.country_code },
-        longitude: -> { Faker::Address.unique.longitude },
-        middlename: -> { ::Faker::Name.unique.middle_name },
-        middle_name: -> { ::Faker::Name.unique.middle_name },
-        password: -> { ::Faker::Internet.unique.password },
-        phone: -> { Faker::PhoneNumber.unique.phone_number },
-        phone_number: -> { Faker::PhoneNumber.unique.phone_number },
-        reference: -> { Faker::Internet.unique.uuid },
-        title: -> { Faker::Lorem.unique.sentence(word_count: 3, random_words_to_add: 4) },
-        username: -> { Faker::Internet.unique.username }
-      }.freeze
-      private_constant :SPECIFIC_ATTRIBUTES
-
-      # Returns a string matching all validators
+      # Returns a value matching all validators
       # @return [String]
       # @note First try to guess attribute meaning by its name and use Faker to return a coherent value
       def value
-        SPECIFIC_ATTRIBUTES[dirty_attribute.name]&.call || default
+        specific = specific_attributes[dirty_attribute.name]
+        return faker_value(specific) if specific
+
+        default
       end
 
       private
 
+      # Returns specific attributes
+      # @return [Hash]
+      # @example
+      #   { address: { category: 'Address', method: 'full_address' } }
+      def specific_attributes
+        YAML.safe_load(
+          File.read(
+            DirtySeed::Engine.root.join('lib', 'dirty_seed', 'assigners', 'fakers.yml')
+          )
+        ).deep_symbolize_keys
+      end
+
+      # Returns a value matching the requirements
+      # @param category [Symbol] fake category
+      # @param method [Symbol] fake method
+      # @param unique [Boolean] should the value be unique
+      # @param options [Hash] options used by faker
+      # @return [String]
+      def faker_value(category:, method:, unique: false, options: nil)
+        action = "::Faker::#{category}".constantize
+        action = action.unique if unique
+        if options
+          action.public_send(method, options)
+        else
+          action.public_send(method)
+        end
+      end
+
       # Returns a standard string
       # @return [String]
       def default