dirty_seed 0.1.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e9767e646a1b92174c3a4428716ba9fc4214cf882d7f60f938b6d1545113695d
+  data.tar.gz: 7eae0d2328c0e848d81579a2d054a380c38e773025e4c9cd04fefab20e780c8d
+SHA512:
+  metadata.gz: 48f999e45dc0138d58d39533fe1f4d5c275d6f9ba810fc4eef10040780ec5b30272509ab9b4bb1c9b8edf4d8836adf41e69ae2add9f98a1ee5cb44a24485958a
+  data.tar.gz: 63921534da52c1bc42fae353ac1c6a38d2af20cac8213d7c31c9e849b7d86f933e729cddde4b65a5d8d49411b4344bae8acb3e1bba313ea74c75095b8937fc23

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2020 Edouard Piron
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,44 @@
+> **Work in progress!**
+
+# DirtySeed
+
+Populate the database with records matching associations and validations, in order to quickly test application.
+
+## Usage
+
+Once you've installed the gem, you can use the dedicated task.
+
+To seed dirty data, run:
+```bash
+$ rake dirty_seed:seed
+```
+
+This will try to create instances for each of your models inheriting from `ApplicationRecord`.
+
+If the instance cannot be saved, it is simply ignored.
+
+Number of instances created and recurrent errors will be outputed.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'dirty_seed', git: 'https://github.com/BigBigDoudou/dirty_seed'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Next features
+
+* Assign values for more data types (json, array, etc.).
+* 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.

data/Rakefile

@@ -0,0 +1,22 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'DirtySeed'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path('spec/dummy/Rakefile', __dir__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'

data/lib/dirty_seed.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'dirty_seed/engine'
+require_relative 'dirty_seed/exceptions'
+
+module DirtySeed
+  autoload :MethodMissingHelper, 'dirty_seed/method_missing_helper'
+  autoload :DataModel, 'dirty_seed/data_model'
+  autoload :DirtyModel, 'dirty_seed/dirty_model'
+  autoload :DirtyAssociation, 'dirty_seed/dirty_association'
+  autoload :DirtyAttribute, 'dirty_seed/dirty_attribute'
+  autoload :Sorter, 'dirty_seed/sorter'
+
+  module Assigners
+    autoload :DirtyAssigner, 'dirty_seed/assigners/dirty_assigner'
+    autoload :DirtyBoolean, 'dirty_seed/assigners/dirty_boolean'
+    autoload :DirtyInteger, 'dirty_seed/assigners/dirty_integer'
+    autoload :DirtyFloat, 'dirty_seed/assigners/dirty_float'
+    autoload :DirtyString, 'dirty_seed/assigners/dirty_string'
+    autoload :DirtyDate, 'dirty_seed/assigners/dirty_date'
+    autoload :DirtyTime, 'dirty_seed/assigners/dirty_time'
+  end
+end

data/lib/dirty_seed/assigners/dirty_assigner.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'faker'
+
+module DirtySeed
+  module Assigners
+    # Draws a value matching validators
+    class DirtyAssigner
+      attr_reader :dirty_attribute, :sequence
+
+      # Initializes an instance
+      # @param attribute [DirtySeed::DirtyAttribute]
+      # @param sequence [Integer]
+      # @return [DirtySeed::Assigners::DirtyAssigner]
+      def initialize(dirty_attribute, sequence)
+        @dirty_attribute = dirty_attribute
+        @sequence = sequence
+      end
+
+      # Returns an validators related to the current attribute
+      # @return [Array<ActiveModel::Validations::EachValidators>]
+      def validators
+        dirty_attribute.validators
+      end
+
+      # Returns a random value depending on the attribute type
+      # @return [void]
+      # @note This method should be overrided
+      def value; end
+    end
+  end
+end

data/lib/dirty_seed/assigners/dirty_boolean.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module DirtySeed
+  module Assigners
+    # Draws a boolean value matching validators
+    class DirtyBoolean < DirtyAssigner
+      # Returns a boolean
+      # @return [Boolean]
+      def value
+        [true, false].sample
+      end
+    end
+  end
+end

data/lib/dirty_seed/assigners/dirty_date.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module DirtySeed
+  module Assigners
+    # Draws a Date matching validators
+    class DirtyDate < DirtyAssigner
+      # Returns a date matching all validators
+      # @return [Date]
+      def value
+        ::Faker::Date.between(from: 42.days.ago, to: 42.days.from_now)
+      end
+    end
+  end
+end

data/lib/dirty_seed/assigners/dirty_float.rb

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

data/lib/dirty_seed/assigners/dirty_integer.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module DirtySeed
+  module Assigners
+    # Draws an integer matching validators
+    class DirtyInteger < DirtyAssigner
+      attr_reader :min, :max
+
+      # Returns an integer matching all validators
+      # @return [Integer]
+      def value
+        define_min_and_max
+        adjust_values
+        rand(min..max)
+      end
+
+      private
+
+      # Sets @min and @max if not already set
+      # @return [void]
+      def adjust_values
+        return if @min && @max
+
+        if @min
+          @max = @min + random
+        elsif @max
+          @min = @max - random
+        else
+          @min = 0
+          @max = random
+        end
+      end
+
+      # Returns a random integer
+      # @return [Integer]
+      def random
+        rand(sequence..42)
+      end
+
+      # Defines @min and @max based on each validator
+      # @return [void]
+      def define_min_and_max
+        validators.each do |validator|
+          adjust_min!(validator)
+          adjust_max!(validator)
+        end
+      end
+
+      # Sets or updates @min so it matches validator
+      # @param validator [ActiveModel::Validations::EachValidator]
+      # @return [Integer, nil]
+      def adjust_min!(validator)
+        return unless min_for(validator)
+
+        @min = min_for(validator) if @min.nil? || min_for(validator) > @min
+      end
+
+      # Sets or updates @max so it matches validator
+      # @param validator [ActiveModel::Validations::EachValidator]
+      # @return [Integer, nil]
+      def adjust_max!(validator)
+        return unless max_for(validator)
+
+        @max = max_for(validator) if @max.nil? || max_for(validator) < @max
+      end
+
+      # Returns an integer representing the minimal acceptable value
+      # @param validator [ActiveModel::Validations::EachValidator]
+      # @return [Integer]
+      def min_for(validator)
+        validator.options[:greater_than]&.+(1) ||
+          validator.options[:greater_than_or_equal_to] ||
+          validator.options[:in]&.min
+      end
+
+      # Returns an integer representing the maximal acceptable value
+      # @param validator [ActiveModel::Validations::EachValidator]
+      # @return [Integer]
+      def max_for(validator)
+        validator.options[:less_than]&.-(1) ||
+          validator.options[:less_than_or_equal_to] ||
+          validator.options[:in]&.max
+      end
+    end
+  end
+end

data/lib/dirty_seed/assigners/dirty_string.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+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
+      # @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
+      end
+
+      private
+
+      # Returns a standard string
+      # @return [String]
+      def default
+        ::Faker::Lorem.unique.sentence(word_count: 3, supplemental: false, random_words_to_add: 4)
+      end
+    end
+  end
+end

data/lib/dirty_seed/assigners/dirty_time.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module DirtySeed
+  module Assigners
+    # Draws a Time matching validators
+    class DirtyTime < DirtyAssigner
+      # Returns a time matching all validators
+      # @return [Time]
+      def value
+        ::Faker::Time.between(from: DateTime.now - 42, to: DateTime.now + 42)
+      end
+    end
+  end
+end

data/lib/dirty_seed/data_model.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module DirtySeed
+  # Represents the data model
+  class DataModel
+    include Singleton
+    attr_accessor :logs
+
+    class << self
+      # Defines class methods forwarding to instance methods
+      %i[seed models active_record_models print_logs].each do |method_name|
+        define_method(method_name) { instance.public_send(method_name) }
+      end
+
+      # Returns dirty model if method_name matches its name
+      # @return [DirtySeed::DirtyModel]
+      # @raise [NoMethodError] if method_name does not match any dirty model
+      def method_missing(method_name, *args, &block)
+        models.find do |model|
+          model.name.underscore.to_sym == method_name
+        end || super
+      end
+
+      # Returns true if method_name matches a dirty model name
+      # @return [Boolean]
+      def respond_to_missing?(method_name, include_private = false)
+        models.any? do |model|
+          model.name.underscore.to_sym == method_name
+        end || super
+      end
+    end
+
+    # Initializes an instance
+    # @return [DirtySeed::DataModel]
+    def initialize
+      Rails.application.eager_load!
+      @logs = {}
+    end
+
+    # Seeds the database with dirty instances
+    # @return [void]
+    def seed
+      # check if ApplicationRecord is defined first
+      ::ApplicationRecord && 3.times { models.each(&:seed) }
+      print_logs
+    end
+
+    # Returns an dirty models
+    # @return [Array<DirtySeed::DirtyModel>]
+    def models
+      @models ||=
+        active_record_models.map do |active_record_model|
+          DirtySeed::DirtyModel.new(active_record_model)
+        end
+    end
+
+    # Returns ApplicationRecord inherited classes sorted by their associations
+    # @return [Array<Class>] a class inheriting from ApplicationRecord
+    def active_record_models
+      @active_record_models ||=
+        DirtySeed::Sorter.new(unsorted_active_record_models).sort!
+    end
+
+    # Returns an ApplicationRecord inherited classes
+    # @return [Array<Class>] a class inheriting from ApplicationRecord
+    def unsorted_active_record_models
+      ::ApplicationRecord.descendants.reject(&:abstract_class)
+    end
+
+    # Prints logs in the console
+    # @return [void]
+    def print_logs
+      models.sort_by(&:name).each do |model|
+        puts model.name
+        puts "  created: #{model.seeded}"
+        puts "  errors: #{model.errors.join(', ')}" if model.errors.any?
+      end
+    end
+  end
+end