dirty_seed 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b389f96d3fa98b9ba404fc38fc0cca7979a8b1ce107a685cb77bbd77bea16ab
-  data.tar.gz: bd5ed8df6a78e30d72178d41160f64bc5de7f4c2ebfb86a49126f5ba88720f68
+  metadata.gz: 2baeb1ee3088a3897bfee64a68299f83d45fe2ccb3799d71ca2ccb67d22f2400
+  data.tar.gz: 859d9c16b0f5283c9127697cb67e700aefda31e777e7ad0e9275fdae5b2c9abd
 SHA512:
-  metadata.gz: 9d3dab43a6ecd4e38f6fadb3f6f283fdfc137a6c7d48882735c66d3cda97a547eb6f126e1d8d81571f991bb34c23ed26894a53e1422e546199f33805af86e391
-  data.tar.gz: 6717f972b7753d24475174c17f94fbea72af36a4ce32ca9b58f0e807f04212671b74e4d126c1c1fd9877240438badbcf7ab084f692ad54c86400e0ff27ecf568
+  metadata.gz: ecef53529af9c66e515e121cbd89ad053555b0f4a554d6a5d331939d8c4238ac7e194d6f3f806cee560b95deef03c5769bf73fffc3a5c7d329c732f3d8af8e00
+  data.tar.gz: b649f5b9c119bc63c95a635b74692b3b83e3d86115193fb329c94c3f52b9aef1fffcaab697ec8facc790687721444fd8446eeff7c6712cf75513713e63f93051

data/README.md

@@ -7,7 +7,7 @@
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'dirty_seed', '~> 0.1.7'
+gem 'dirty_seed', '~> 0.1.8'
 ```
 
 And then execute:
@@ -244,7 +244,10 @@ The current attribute names treated this way are:
 
 - `address`
 - `city`
+- `color`
+- `colour`
 - `country`
+- `currency`
 - `description`
 - `email`
 - `first_name`
@@ -281,6 +284,5 @@ The gem is available as open source under the terms of the [MIT License](https:/
 * Detect more "special" attributes to ignore.
 * Use instance errors to adjust values and eventually match custom validations.
 * Add a configuration system to define how to seed: models to skip, default values, etc.
-* Increase performances.
 
 

data/lib/dirty_seed.rb

@@ -1,24 +1,28 @@
 # frozen_string_literal: true
 
+require 'faker'
+
 require_relative 'dirty_seed/engine'
 require_relative 'dirty_seed/exceptions'
 
 module DirtySeed
+  autoload :Association, 'dirty_seed/association'
+  autoload :Attribute, 'dirty_seed/attribute'
   autoload :DataModel, 'dirty_seed/data_model'
-  autoload :DirtyAssociation, 'dirty_seed/dirty_association'
-  autoload :DirtyAttribute, 'dirty_seed/dirty_attribute'
-  autoload :DirtyModel, 'dirty_seed/dirty_model'
+  autoload :Model, 'dirty_seed/model'
   autoload :MethodMissingHelper, 'dirty_seed/method_missing_helper'
   autoload :Sorter, 'dirty_seed/sorter'
 
   module Assigners
-    autoload :DirtyAssigner, 'dirty_seed/assigners/dirty_assigner'
-    autoload :DirtyBoolean, 'dirty_seed/assigners/dirty_boolean'
-    autoload :DirtyDate, 'dirty_seed/assigners/dirty_date'
-    autoload :DirtyFloat, 'dirty_seed/assigners/dirty_float'
-    autoload :DirtyInteger, 'dirty_seed/assigners/dirty_integer'
-    autoload :DirtyNumber, 'dirty_seed/assigners/dirty_number'
-    autoload :DirtyString, 'dirty_seed/assigners/dirty_string'
-    autoload :DirtyTime, 'dirty_seed/assigners/dirty_time'
+    autoload :Assigner, 'dirty_seed/assigners/assigner'
+    autoload :Base, 'dirty_seed/assigners/base'
+    autoload :Boolean, 'dirty_seed/assigners/boolean'
+    autoload :Date, 'dirty_seed/assigners/date'
+    autoload :Float, 'dirty_seed/assigners/float'
+    autoload :Integer, 'dirty_seed/assigners/integer'
+    autoload :MinMaxHelper, 'dirty_seed/assigners/min_max_helper'
+    autoload :Number, 'dirty_seed/assigners/number'
+    autoload :String, 'dirty_seed/assigners/string'
+    autoload :Time, 'dirty_seed/assigners/time'
   end
 end

data/lib/dirty_seed/assigners/assigner.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'regexp-examples'
+
+module DirtySeed
+  module Assigners
+    # Draws a value matching validators
+    class Assigner
+      attr_reader :attribute
+
+      delegate :name, :type, :validators, to: :attribute
+
+      # Initializes an instance
+      # @param attribute [DirtySeed::Attribute]
+      # @return [DirtySeed::Assigners::Assigner]
+      def initialize(attribute)
+        @attribute = attribute
+      end
+
+      private
+
+      # Returns true if the value should be unique
+      # @return [Boolean]
+      def unique?
+        @unique ||=
+          validators.any? do |validator|
+            validator.is_a? ActiveRecord::Validations::UniquenessValidator
+          end
+      end
+
+      # Returns the regex pattern if value should respect a format
+      # e.g. `validates :email, format: { with: /\w{10}@(hotmail|gmail)\.com/ }`
+      # @return [Array<>]
+      def regex
+        regex_validator =
+          validators.find do |validator|
+            validator.is_a? ActiveModel::Validations::FormatValidator
+          end
+        regex_validator&.options&.dig(:with)
+      end
+
+      # Returns a value matching the requirements
+      # @param category [Symbol] fake category
+      # @param method [Symbol] fake method
+      # @param options [Hash] options used by faker
+      # @return [Object]
+      def faker_value(category:, method:, options: nil)
+        if options
+          faker_method(category).public_send(method, options)
+        else
+          faker_method(category).public_send(method)
+        end
+      rescue Faker::UniqueGenerator::RetryLimitExceeded
+        nil
+      end
+
+      # Returns a faker method
+      # @param category [Symbol] fake category
+      # @return [Faker::?]
+      def faker_method(category)
+        @faker_method ||= define_faker_method(category)
+      end
+
+      # Returns a faker method
+      # @param category [Symbol] fake category
+      # @return [Faker::?]
+      def define_faker_method(category)
+        action = "::Faker::#{category}".constantize
+        unique? ? action.unique : action
+      end
+    end
+  end
+end

data/lib/dirty_seed/assigners/base.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module DirtySeed
+  module Assigners
+    # Draws a value matching validators
+    class Base < Assigner
+      SPECIFIC_TYPES = %i[float integer string].freeze
+      private_constant :SPECIFIC_TYPES
+
+      # Returns a value depending on validators and attribute type
+      #   It firstly check if value can be set relying to validators
+      #   If not, it delegates to an assigner adapted to the attribute type
+      # @return [<?>] depends on attribute
+      def value
+        return if absent?
+        return inclusion_options.sample if inclusion_options.is_a? Array
+        return rand(inclusion_options) if inclusion_options.is_a? Range
+
+        try_specific || adapted_assigner&.value
+      end
+
+      private
+
+      # Returns true if value should be absent
+      # Returns [Boolean]
+      def absent?
+        validators.any? do |validator|
+          validator.is_a? ActiveRecord::Validations::AbsenceValidator
+        end
+      end
+
+      # Returns the inclusion options if value should be included in options
+      # e.g. `validates :status, inclusion: { in: %w[todo done aborted] }`
+      # @return [Array<>]
+      def inclusion_options
+        inclusion_validator =
+          validators.find do |validator|
+            validator.is_a? ActiveModel::Validations::InclusionValidator
+          end
+        inclusion_validator&.options&.dig(:in)
+      end
+
+      # If attribute name is listed in meaningful attributes
+      #   Then rely on faker
+      #   And validate it matches type and other validations
+      # @return [<?>] depends on attribute
+      def try_specific
+        return unless specific_options
+        return unless specific_options[:types].include? type.to_s
+
+        try = faker_value(specific_options.except(:types))
+        return if regex && !regex.match?(try)
+
+        try
+      end
+
+      # Returns the specific options if the attribute name is specific
+      # @return [Hash, nil]
+      def specific_options
+        @specific_options ||= specific_attributes[name]
+      end
+
+      # 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 the adapted assigner depending on type
+      # @return [DirtySeed::Assigners::<?>]
+      def adapted_assigner
+        @adapted_assigner ||=
+          "DirtySeed::Assigners::#{attribute.type.capitalize}".constantize.new(attribute)
+        # If attribute type is not currently handled (json, array...) return nil
+      rescue NameError
+        nil
+      end
+    end
+  end
+end

data/lib/dirty_seed/assigners/{dirty_boolean.rb → boolean.rb}

@@ -3,10 +3,10 @@
 module DirtySeed
   module Assigners
     # Draws a value matching validators
-    class DirtyBoolean < DirtyAssigner
+    class Boolean < Assigner
       # Returns a boolean
       # @return [Boolean]
-      def define_value
+      def value
         [true, false].sample
       end
     end

data/lib/dirty_seed/assigners/{dirty_date.rb → date.rb}

@@ -3,10 +3,10 @@
 module DirtySeed
   module Assigners
     # Draws a value matching validators
-    class DirtyDate < DirtyAssigner
+    class Date < Assigner
       # Returns a date matching all validators
       # @return [Date]
-      def define_value
+      def value
         faker_value(
           category: :Date,
           method: :between,

data/lib/dirty_seed/assigners/fakers.yml

@@ -1,80 +1,143 @@
 address:
   category: Address
   method: full_address
+  types:
+    - string
 city:
   category: Address
   method: city
+  types:
+    - string
+color:
+  category: Color
+  method: hex_color
+  types:
+    - string
+colour:
+  category: Color
+  method: hex_color
+  types:
+    - string
 country:
   category: Address
   method: country
+  types:
+    - string
+currency:
+  category: currency
+  method: code
+  types:
+    - string
 description:
   category: Lorem
   method: paragraph
+  types:
+    - string
   options:
     sentence_count: 2
     random_sentences_to_add: 4
 email:
   category: Internet
   method: email
+  types:
+    - string
   options:
     domain: example
 first_name:
   category: Name
   method: first_name
+  types:
+    - string
 firstname:
   category: Name
   method: first_name
+  types:
+    - string
 last_name:
   category: Name
   method: last_name
+  types:
+    - string
 lastname:
   category: Name
   method: last_name
+  types:
+    - string
 lat:
   category: Address
   method: latitude
+  types:
+    - float
 latitude:
   category: Address
   method: latitude
+  types:
+    - float
 lng:
   category: Address
   method: longitude
+  types:
+    - float
 locale:
   category: Address
   method: country_code
+  types:
+    - string
 longitude:
   category: Address
   method: longitude
+  types:
+    - float
 middlename:
   category: Name
   method: middle_name
+  types:
+    - string
 middle_name:
   category: Name
   method: middle_name
+  types:
+    - string
 password:
   category: Internet
   method: password
+  types:
+    - string
 phone:
   category: PhoneNumber
   method: phone_number
+  types:
+    - string
 phone_number:
   category: PhoneNumber
   method: phone_number
+  types:
+    - string
 reference:
   category: Internet
   method: uuid
+  types:
+    - string
 title:
   category: Lorem
   method: sentence
+  types:
+    - string
   options:
     word_count: 3
     random_words_to_add: 4
 user_name:
   category: Internet
   method: username
+  types:
+    - string
 username:
   category: Internet
   method: username
+  types:
+    - string
 uuid:
   category: Internet
-  method: uuid
+  method: uuid
+  types:
+    - string

data/lib/dirty_seed/assigners/float.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module DirtySeed
+  module Assigners
+    # Draws an Float matching validators
+    class Float < Assigner
+      include MinMaxHelper
+
+      # Returns an value matching all validators
+      # @return [Float]
+      def value
+        # binding.pry
+        faker_value(
+          category: :Number,
+          method: :between,
+          options: { from: min, to: max }
+        )
+      end
+    end
+  end
+end

data/lib/dirty_seed/assigners/integer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module DirtySeed
+  module Assigners
+    # Draws an integer matching validators
+    class Integer < Assigner
+      include MinMaxHelper
+
+      # Returns an value matching all validators
+      # @return [Integer]
+      def value
+        faker_value(
+          category: :Number,
+          method: :between,
+          options: { from: min, to: max }
+        )
+      end
+    end
+  end
+end