auto-seeding 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 55b1d2585f1d0df108b79d8df59c08fba396a4e0
-  data.tar.gz: 1e369657c4836f5019a9f7b42b44c63e7be04861
+  metadata.gz: 959a395df405f309c48515a254490e92c6f6b08c
+  data.tar.gz: e1f48a26d1d196ff4c5581a0e750ed240792c65c
 SHA512:
-  metadata.gz: 6a62fc30f1c4acd766ba2216e8d5c147672c2d7a6947df735097bf5e5239f16c96ed34879dcc24bb419b30c61c5ae96ac91f12e6a3dba3b4765c865449348ab0
-  data.tar.gz: 25fd7522b909b4dfd55711e41a5381e94c7aca40f65758f52ef11e7b5914a6bf9e6eb79b1878fef910cfd45954eec63c3516b49ef8208188ec3af96bb199902e
+  metadata.gz: bc92862725d1ce097d198b8aed277eefe2816f293bf1ef0a59e4a9871649d18eb0757ed78fbf32f9074526cab6c4f0e68a1217dd5aba2a6b77719dd5663b3f8d
+  data.tar.gz: 3b884c46b754398e1a058eeb92436fc4e8aa57d090a7a48f4e759486f99add265253bddde82dd5a58bed25ebb953e8586f6be0c88a8fa33f759664f9cfe42345

data/.gitignore

@@ -0,0 +1 @@
+_misc/

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+cache: bundler
+sudo: false
+rvm:
+  - 2.2.7
+  - 2.3.4
+  - 2.4.1

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,120 @@
+# Auto-seeding [![Gem Version](https://badge.fury.io/rb/auto-seeding.svg)](https://badge.fury.io/rb/auto-seeding) [![Build Status](https://travis-ci.org/blocknotes/auto-seeding.svg)](https://travis-ci.org/blocknotes/auto-seeding)
+
+A component to auto generate seed data with ActiveRecord using a set of predefined or custom rules respecting models validations.
+
+## Install
+
+- Add to Gemfile: `gem 'auto-seeding'` (better in *development* group)
+- Edit the seed task:
+
+```rb
+auto_seeding = AutoSeeding::Seeder.new
+3.times.each do
+  auto_seeding.update( Author.new ).save!
+end
+```
+
+### Options
+
+- **conf/seeder**: seeding source [*nil* | *:faker* | *:ffaker*] (*:faker* requires Faker gem, *:ffaker* requires FFaker gem)
+- **conf/file**: load seed configuration from a local file
+- **auto_create**: array of nested associations to create while seeding (useful for has_one associations), ex. [*:profile*]
+- **ignore_attrs**: ignore some attributes, ex. [*:id*, *updated_at*]
+- **skip_associations**: array of nested associations to skip while seeding, ex. [*:posts*]
+- **sources**: configure sources rules for autoseed data
+
+Conf file: see [data folder](https://github.com/blocknotes/auto-seeding/tree/master/lib/auto-seeding/data)
+
+Global options (shared between instances):
+
+```rb
+AutoSeeding::Seeder.config({
+  skip_associations: [:versions],
+  conf: {
+    seeder: :ffaker,
+  },
+})
+```
+
+Instance options:
+
+```rb
+autoseeding = AutoSeeding::Seeder.new({
+  auto_create: [:profile],       # array of symbols
+  conf: {
+    file: 'test/conf.yml',       # string
+    seeder: :faker,              # symbol - :faker or :ffaker
+  },
+  ignore_attrs: [:id],           # array of symbols - ignored attributes
+  skip_associations: [:author],  # array of symbols - ignored nested associations
+  sources: {                     # hash - keys: types, fields
+    types: {                     # hash - override basic types rules
+      integer: {
+        source_model: 'Random',
+        source_method: 'rand',
+        source_args: '0..100',
+      }
+    },
+    fields: [                    # array of hashes - override fields rules
+      {
+        in: ['name'],
+        source_model: 'Faker::StarWars',
+        source_method: 'character',
+        type: 'string'
+      },
+      {
+        regexp: '^(.+_|)title(|_.+)$',
+        source_model: 'Faker::Book',
+        source_method: 'title',
+        post_process: '->( val ) { val + " (seeding)" }',
+        type: 'string'
+      }
+    ]
+  }
+})
+```
+
+## Notes
+
+Generated data can be manipulated easily before saving:
+
+```rb
+obj = auto_seeding.update( Author.new )
+obj.name = 'John Doe'
+obj.save!
+```
+
+Field names can be changed using *append* and *prepend* options - example using Carrierwave remote url property:
+
+```rb
+AutoSeeding::Seeder.new({
+  sources: {
+    fields: [
+      {
+        regexp: '^(.+_|)photo(|_.+)$|^(.+_|)image(|_.+)$',
+        source_model: 'Faker::Avatar',
+        source_method: 'image',
+        prepend: 'remote_',
+        append: '_url',
+        type: 'string'
+      }
+    ]
+  }
+}
+```
+
+To avoid problems with PaperTrail use:
+
+`AutoSeeding::Seeder.config({ skip_associations: [:versions] })`
+
+## Do you like it? Star it!
+
+If you use this component just star it. A developer is more motivated to improve a project when there is some interest.
+
+## Contributors
+
+- [Mattia Roccoberton](http://blocknot.es) - creator, maintainer
+
+## License
+
+[MIT](LICENSE.txt)

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/auto-seeding.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+# frozen_string_literal: true
+lib = File.expand_path( '../lib/', __FILE__ )
+$LOAD_PATH.unshift lib unless $LOAD_PATH.include?( lib )
+require 'auto-seeding'
+
+Gem::Specification.new do |spec|
+  spec.name          = AutoSeeding::NAME
+  spec.version       = AutoSeeding::VERSION.join('.')
+  spec.date          = AutoSeeding::DATE
+  spec.summary       = AutoSeeding::INFO
+  spec.description   = AutoSeeding::DESC
+  spec.authors       = AutoSeeding::AUTHORS.map { |a| a[0] }.flatten
+  spec.email         = AutoSeeding::AUTHORS.first[1]
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.require_paths = ['lib']
+  spec.homepage      = 'https://github.com/blocknotes/auto-seeding'
+  spec.license       = 'MIT'
+  spec.add_dependency 'activerecord', '~> 5'
+  spec.add_development_dependency 'rake', '~> 12'
+  spec.add_development_dependency 'minitest', '~> 5'
+  spec.add_development_dependency 'faker', '~> 1'
+  spec.add_development_dependency 'ffaker', '~> 2'
+end

data/lib/auto-seeding.rb

@@ -7,6 +7,6 @@ module AutoSeeding
   INFO = 'Auto seeding component for ActiveRecord'.freeze
   DESC = 'A component to auto generate seed data with ActiveRecord using a set of predefined or custom rules respecting models validations'.freeze
   AUTHORS = [ [ 'Mattia Roccoberton', 'mat@blocknot.es', 'http://blocknot.es' ] ].freeze
-  DATE = '2017-09-10'.freeze
-  VERSION = [ 0, 1, 4 ].freeze
+  DATE = '2017-09-30'.freeze
+  VERSION = [ 0, 1, 5 ].freeze
 end

data/lib/auto-seeding/data/basic.yml

@@ -0,0 +1,47 @@
+sources:
+  types:
+    boolean:
+      source_model: AutoSeeding::Source
+      source_method: random_boolean
+    date:
+      source_model: Date
+      source_method: today
+      post_process: ->( val ) { val + rand( -30..30 ) }
+    datetime:
+      source_model: Time
+      source_method: now
+      post_process: ->( val ) { ( val + rand( -MONTH_SECONDS..MONTH_SECONDS ) ).to_datetime }
+    decimal:
+      source_model: Random
+      source_method: rand
+    float:
+      source_model: Random
+      source_method: rand
+    integer:
+      source_model: Random
+      source_method: rand
+      # source_args: 20..25
+    string:
+      source_model: AutoSeeding::Source
+      source_method: random_string
+    text:
+      source_model: AutoSeeding::Source
+      source_method: random_string
+      source_args: 50
+    time:
+      source_model: Time
+      source_method: now
+      post_process: ->( val ) { val + rand( 0..DAY_SECONDS ) }
+    timestamp:
+      source_model: Time
+      source_method: now
+      post_process: ->( val ) { ( val + rand( -MONTH_SECONDS..MONTH_SECONDS ) ).to_datetime }
+  fields:
+    -
+      in:
+        - name
+        - title
+      source_model: AutoSeeding::Source
+      source_method: random_string
+      source_args: 5
+      type: string

data/lib/auto-seeding/data/faker.yml

@@ -0,0 +1,75 @@
+sources:
+  types:
+    boolean:
+      source_model: AutoSeeding::Source
+      source_method: random_boolean
+    date:
+      source_model: Date
+      source_method: today
+      post_process: ->( val ) { val + rand( -30..30 ) }
+    datetime:
+      source_model: Time
+      source_method: now
+      post_process: ->( val ) { ( val + rand( -MONTH_SECONDS..MONTH_SECONDS ) ).to_datetime }
+    decimal:
+      source_model: Random
+      source_method: rand
+    float:
+      source_model: Random
+      source_method: rand
+    integer:
+      source_model: Random
+      source_method: rand
+    string:
+      source_model: Faker::Hipster
+      source_method: sentence
+    text:
+      source_model: Faker::Hipster
+      source_method: paragraph
+    time:
+      source_model: Time
+      source_method: now
+      post_process: ->( val ) { val + rand( 0..DAY_SECONDS ) }
+    timestamp:
+      source_model: Time
+      source_method: now
+      post_process: ->( val ) { ( val + rand( -MONTH_SECONDS..MONTH_SECONDS ) ).to_datetime }
+  fields:
+    # -
+    #   in:
+    #     - name
+    #     - title
+    #   source_model: Faker::Hipster
+    #   source_method: word
+    #   type: string
+    -
+      regexp: ^(.+_|)email(|_.+)$
+      source_model: Faker::Internet
+      source_method: safe_email
+      type: string
+    -
+      regexp: ^(.+_|)name(|_.+)$
+      source_model: Faker::Hipster
+      source_method: word
+      type: string
+    -
+      regexp: ^(.+_|)title(|_.+)$
+      source_model: Faker::Book
+      source_method: genre
+      type: string
+    -
+      regexp: ^(.+_|)url(|_.+)$
+      source_model: Faker::Internet
+      source_method: url
+      source_args: example.com
+      type: string
+      # source_args:
+      #   - example.com
+      #   - /foobar.html
+    # Models
+    -
+      model: ^(.+_|)admin(|_.+)$|^(.+_|)author(|_.+)$|^(.+_|)user(|_.+)$
+      regexp: ^(.+_|)name(|_.+)$
+      source_model: Faker::Book
+      source_method: author
+      type: string

data/lib/auto-seeding/data/ffaker.yml

@@ -0,0 +1,69 @@
+sources:
+  types:
+    boolean:
+      source_model: FFaker::Boolean
+      source_method: random
+    date:
+      source_model: Date
+      source_method: today
+      post_process: ->( val ) { val + rand( -30..30 ) }
+    datetime:
+      source_model: Time
+      source_method: now
+      post_process: ->( val ) { ( val + rand( -MONTH_SECONDS..MONTH_SECONDS ) ).to_datetime }
+    decimal:
+      source_model: Random
+      source_method: rand
+    float:
+      source_model: Random
+      source_method: rand
+    integer:
+      source_model: Random
+      source_method: rand
+    string:
+      source_model: FFaker::Book
+      source_method: genre
+    text:
+      source_model: FFaker::Book
+      source_method: description
+    time:
+      source_model: Time
+      source_method: now
+      post_process: ->( val ) { val + rand( 0..DAY_SECONDS ) }
+    timestamp:
+      source_model: Time
+      source_method: now
+      post_process: ->( val ) { ( val + rand( -MONTH_SECONDS..MONTH_SECONDS ) ).to_datetime }
+  fields:
+    # -
+    #   in:
+    #     - title
+    #   source_model: FFaker::Book
+    #   source_method: title
+    #   type: string
+    -
+      regexp: ^(.+_|)email(|_.+)$
+      source_model: FFaker::Internet
+      source_method: safe_email
+      type: string
+    -
+      regexp: ^(.+_|)name(|_.+)$
+      source_model: FFaker::Movie
+      source_method: title
+      type: string
+    -
+      regexp: ^(.+_|)title(|_.+)$
+      source_model: FFaker::Book
+      source_method: title
+      type: string
+    -
+      regexp: ^(.+_|)url(|_.+)$
+      source_model: FFaker::Internet
+      source_method: http_url
+      type: string
+    -
+      model: ^(.+_|)admin(|_.+)$|^(.+_|)author(|_.+)$|^(.+_|)user(|_.+)$
+      regexp: ^(.+_|)name(|_.+)$
+      source_model: FFaker::Name
+      source_method: name
+      type: string

data/lib/auto-seeding/seeder.rb

@@ -0,0 +1,171 @@
+# coding: utf-8
+module AutoSeeding
+  class Seeder
+    TYPES = [:boolean, :date, :datetime, :float, :decimal, :integer, :string, :text, :time, :timestamp]
+
+    attr_reader :options, :sources
+
+    @@globals = { conf: {}, sources: {} }
+
+    def initialize( opts = {} )
+      options = { conf: @@globals[:conf], sources: @@globals[:sources] }
+      AutoSeeding::_deep_merge!( options, opts )
+
+      @columns = {}
+      @models = {}
+      @extra_validations = { confirmations: [] }
+      options[:ignore_attrs] ||= [:id, :created_at, :updated_at]
+      options[:ignore_attrs] += @@globals[:ignore_attrs] if @@globals[:ignore_attrs]
+      options[:skip_associations] ||= []
+      options[:skip_associations] += @@globals[:skip_associations] if @@globals[:skip_associations]
+
+      path = options[:conf][:file]
+      if path
+        options[:conf].delete :seeder
+      else
+        yml_file = if options[:conf][:seeder] == :ffaker
+            puts 'warning: seeder set to ffaker but FFaker is not available' unless defined? FFaker
+            'ffaker.yml'
+          elsif options[:conf][:seeder] == :faker
+            puts 'warning: seeder set to faker but Faker is not available' unless defined? Faker
+            'faker.yml'
+          else
+            'basic.yml'
+          end
+        path = Pathname.new( File.dirname __FILE__ ).join( 'data', yml_file ).to_s
+      end
+
+      # Random.srand( options[:conf][:seed_number] ? options[:conf][:seed_number].to_i : Random.new_seed )  # NOTE: problems here
+
+      yml = Seeder::symbolize_keys YAML.load_file( path )
+      # @sources = yml[:sources].merge( options[:sources] ? options[:sources] : {} )
+      @sources = yml[:sources].dup
+      AutoSeeding::_deep_merge!( @sources, options[:sources] ) if options[:sources]
+      @sources[:fields] ||= {}
+      @sources[:fields].map! { |s| Seeder::symbolize_keys s }
+      @sources[:fields].sort! { |a, b| ( a['model'] || a[:model] ) ? -1 : ( ( b['model'] || b[:model] ) ? 1 : 0 ) }
+      @options = options
+
+      self
+    end
+
+    def update( object )
+      model = object.class
+
+      model.content_columns.each do |column|
+        col = column.name.to_sym
+        next if @options[:ignore_attrs].include? col
+        @columns[col] ||= {
+          validators: prepare_validators( model._validators[col] )
+        }
+
+        found = false
+        @sources[:fields].each do |f|
+          if f[:model]
+            next unless Regexp.new( f[:model], Regexp::IGNORECASE ).match( model.to_s )
+          end
+          if( f[:in] && f[:in].include?( col.to_s ) ) ||
+            ( f[:regexp] && Regexp.new( f[:regexp], Regexp::IGNORECASE ).match( col.to_s ) )
+            col_ = ( f[:prepend] || f[:append] ) ? ( f[:prepend].to_s + col.to_s + f[:append].to_s ) : col.to_s
+            @columns[col][:src] ||= Source.new( col, f[:type] ? f[:type].to_sym : :string, @columns[col][:validators], f )
+            object.send( col_ + '=', @columns[col][:src].gen )
+            found = true
+            break
+          end
+        end
+        next if found
+
+        if TYPES.include? column.type
+          object.send( col.to_s + '=', ( @columns[col][:src] ||= Source.new( col, column.type, @columns[col][:validators], @sources[:types][column.type] ) ).gen )
+        end
+      end
+
+      # Setup associations
+      model._reflections.each do |association, data|
+        next if @options[:skip_associations].include? association.to_sym
+        model2 = data.klass
+        if @options[:auto_create] && @options[:auto_create].include?( association.to_sym )
+          auto_seeding = AutoSeeding::Seeder.new( { conf: { seeder: @options[:seeder] || @@globals[:conf][:seeder] }, skip_associations: [model.to_s.underscore.to_sym] } )
+          object.send( association + '=', auto_seeding.update( model2.new ) )
+        else
+          @models[model2.table_name] ||= model2.all
+          if data.is_a?( ActiveRecord::Reflection::ThroughReflection )  # many-to-many
+            sam = @models[model2.table_name].sample( rand( 5 ) )
+            object.send( association ).push( sam ) if sam.any?
+          elsif data.parent_reflection && data.parent_reflection.is_a?( ActiveRecord::Reflection::HasAndBelongsToManyReflection )
+            next
+          else
+            sam = @models[model2.table_name].sample
+            object.send( association + '=', sam ) if sam
+          end
+        end
+      end
+
+      # Extra validations
+      @extra_validations[:confirmations].each do |field|
+        object.send field.to_s+'_confirmation=', object[field]
+      end
+
+      object
+    end
+
+    def self.config( options = nil )
+      @@globals = options ? options : { conf: {}, sources: {} }
+    end
+
+  protected
+
+    def prepare_validators( validators )
+      ret = {}
+      validators.each do |validator|
+        case validator.class.name.split( '::' ).last
+        when 'AcceptanceValidator'
+          ret[:accept] = validator.options[:accept].is_a?( Array ) ? validator.options[:accept] : [ validator.options[:accept] ]
+        when 'ConfirmationValidator'
+          # ret[:confirmation] = validator.options[:confirmation]
+          @extra_validations[:confirmations] += validator.attributes
+          # case_sensitive - TODO: not implemented
+        when 'ExclusionValidator'
+          ret[:not_in] = validator.options[:in] # TODO: not implemented
+        when 'InclusionValidator'
+          ret[:in] = validator.options[:in]
+        when 'LengthValidator'
+          if validator.options[:is]
+            ret[:length_minimum] = validator.options[:is]
+            ret[:length_maximum] = validator.options[:is]
+          else
+            ret[:length_minimum] = validator.options[:minimum]
+            ret[:length_maximum] = validator.options[:maximum]
+          end
+        when 'NumericalityValidator'
+          ret[:num_gt] = validator.options[:greater_than]
+          ret[:num_gte] = validator.options[:greater_than_or_equal_to]
+          ret[:equal_to] = validator.options[:equal_to]
+          ret[:num_lt] = validator.options[:less_than]
+          ret[:num_lte] = validator.options[:less_than_or_equal_to]
+          # ret[:other_than] = validator.options[:other_than] # TODO: not implemented
+          # ret[:odd] = validator.options[:odd]               # TODO: not implemented
+          # ret[:even] = validator.options[:even]             # TODO: not implemented
+        when 'PresenceValidator'
+          # ret[:presence] = true # TODO: not implemented
+        when 'UniquenessValidator'
+          ret[:uniqueness] = true
+        else
+          # p validator.class.name.split( '::' ).last # DEBUG
+        end
+      end
+      ret
+    end
+
+    def self.symbolize_keys( obj )
+      if obj.is_a?( Hash )
+        obj2 ||= {}
+        obj.each do |k, v|
+          obj2[k.to_sym] = symbolize_keys( v )
+        end
+        return obj2
+      end
+      obj
+    end
+  end
+end

data/lib/auto-seeding/source.rb

@@ -0,0 +1,114 @@
+# coding: utf-8
+module AutoSeeding
+  class Source
+    DAY_SECONDS = ( 60 * 60 * 24 )
+    MIN_INT = 0
+    MAX_INT = 1_000_000
+    MIN_FLOAT = 0.0
+    MAX_FLOAT = 1000.0
+    MONTH_SECONDS = ( DAY_SECONDS * 30 ).freeze
+    VOWELS = %w(a e i o u).freeze
+    CONSONANTS = (('a'..'z').to_a - VOWELS).freeze
+
+    def initialize( column, type, rules, options = {} )
+      @column = column
+      @type = type
+      @rules = rules ? rules : {}
+      @options = options || {}
+      if @options[:source_model] && @options[:source_method]
+        @source_class  = Object.const_get @options[:source_model]
+        @source_method = @options[:source_method].to_sym
+        @source_args   = @options[:source_args]
+      else
+        @source_class  = AutoSeeding::Source
+        @source_method = :random_string
+        @source_args = nil
+      end
+      @uniqueness = {}
+      self
+    end
+
+    def gen
+      @retry = 100
+      process @type
+    end
+
+    def self.random_boolean
+      [false, true].sample
+    end
+
+    def self.random_string( words = 10 )
+      (1..rand(words)+1).map do
+        (0..rand(10)+1).map do |i|
+          i % 2 == 0 ? CONSONANTS.sample : VOWELS.sample
+        end.join
+      end.join( ' ' ).capitalize
+    end
+
+  protected
+
+    def process( type = nil )
+      value =
+        if @rules[:equal_to]
+          @rules[:equal_to]
+        elsif @rules[:in]
+          @rules[:in].sample
+        elsif @rules[:accept]
+          @rules[:accept].sample
+        else
+          case type
+          when :float, :decimal
+            min = @rules[:num_gte] ? @rules[:num_gte].to_f : ( @rules[:num_gt] ? ( @rules[:num_gt].to_f + 0.1 ) : MIN_FLOAT )
+            max = @rules[:num_lte] ? @rules[:num_lte].to_f : ( @rules[:num_lt] ? ( @rules[:num_lt].to_f - 0.1 ) : MAX_FLOAT )
+            @source_class.send( @source_method, @source_args ? eval( @source_args ) : (min .. max) )
+          when :integer
+            min = @rules[:num_gte] ? @rules[:num_gte].to_i : ( @rules[:num_gt] ? ( @rules[:num_gt].to_i + 1 ) : MIN_INT )
+            max = @rules[:num_lte] ? @rules[:num_lte].to_i : ( @rules[:num_lt] ? ( @rules[:num_lt].to_i - 1 ) : MAX_INT )
+            @source_class.send( @source_method, @source_args ? eval( @source_args ) : (min .. max) )
+          when :string, :text
+            @source_class.send( @source_method, *@source_args ).to_s
+          else
+            @source_class.send( @source_method, *@source_args )
+          end
+        end
+
+      if @options[:post_process]
+        post_process = eval @options[:post_process]
+        value = post_process.call( value )
+      end
+
+      # validations
+      case type
+      when :float, :decimal
+        value = ( @rules[:num_gt].to_f + 0.1 ) if @rules[:num_gt] && ( value <= @rules[:num_gt].to_f )
+        value = @rules[:num_gte].to_f if @rules[:num_gte] && ( value < @rules[:num_gte].to_f )
+        value = ( @rules[:num_lt].to_f - 0.1 ) if @rules[:num_lt] && ( value >= @rules[:num_lt].to_f )
+        value = @rules[:num_lte].to_f if @rules[:num_lte] && ( value > @rules[:num_lte].to_f )
+      when :integer
+        value = ( @rules[:num_gt].to_i + 1 ) if @rules[:num_gt] && ( value <= @rules[:num_gt].to_i )
+        value = @rules[:num_gte].to_i if @rules[:num_gte] && ( value < @rules[:num_gte].to_i )
+        value = ( @rules[:num_lt].to_i - 1 ) if @rules[:num_lt] && ( value >= @rules[:num_lt].to_i )
+        value = @rules[:num_lte].to_i if @rules[:num_lte] && ( value > @rules[:num_lte].to_i )
+      when :string, :text
+        value = value.ljust( @rules[:length_minimum], '-' ) if @rules[:length_minimum]
+        value = value.slice( 0..( @rules[:length_maximum] - 1 ) ) if @rules[:length_maximum]
+      end
+
+      if @rules[:not_in] && @rules[:not_in].include?( value )
+        @retry -= 1
+        return @retry > 0 ? process( type ) : raise( Exception.new( 'Reserved value' ) )
+      end
+
+      if @rules[:uniqueness]
+        @uniqueness[@column] ||= {}
+        if @uniqueness[@column].has_key?( value )
+          return ( @retry -= 1 ) > 0 ? process( type ) : raise( Exception.new( 'Value already taken' ) )
+        else
+          @uniqueness[@column][value] = true
+        end
+      end
+
+      value
+    end
+  end
+end

data/lib/auto-seeding/utils.rb

@@ -0,0 +1,25 @@
+module AutoSeeding
+  # From activesupport
+  def self._deep_merge( hash, other_hash, &block )
+    _deep_merge!( hash.dup, other_hash, &block )
+  end
+
+  # From activesupport
+  def self._deep_merge!( hash, other_hash, &block )
+    other_hash.each_pair do |current_key, other_value|
+      this_value = hash[current_key]
+
+      hash[current_key] = if this_value.is_a?(Hash) && other_value.is_a?(Hash)
+        _deep_merge( this_value, other_value, &block )
+      else
+        if block_given? && key?(current_key)
+          block.call(current_key, this_value, other_value)
+        else
+          other_value
+        end
+      end
+    end
+
+    hash
+  end
+end

data/test/conf.yml

@@ -0,0 +1,8 @@
+sources:
+  fields:
+    -
+      regexp: ^(.+_|)name(|_.+)$
+      source_model: AutoSeeding::Source
+      source_method: random_string
+      source_args: 1 # test field
+      type: string

data/test/test_basic.rb

@@ -0,0 +1,63 @@
+# require 'pry'
+require 'minitest/autorun'
+require 'ostruct'
+require 'pathname'
+require 'yaml'
+require_relative '../lib/auto-seeding'
+
+# class TestObject
+#   # def initialize
+#   #   super
+#   # end
+
+#   def self.content_columns
+#     [OpenStruct.new({
+#       name: 'test',
+#     })]
+#   end
+
+#   def self._reflections
+#     []
+#   end
+
+#   def self._validators
+#     {
+#       test: []
+#     }
+#   end
+# end
+
+describe 'AutoSeeding basic' do
+  before do
+    @auto_seeding = AutoSeeding::Seeder.new
+  end
+
+  describe 'When generating a value of any type' do
+    it 'must return a correct value' do
+      @auto_seeding.sources[:types].each do |type, data|
+        value = AutoSeeding::Source.new( :test1, type, nil, data ).gen
+        case type
+        when :boolean
+          assert( value.is_a?( FalseClass ) || value.is_a?( TrueClass ) )
+        when :date
+          assert_instance_of( Date, value )
+        when :datetime, :timestamp
+          assert_instance_of( DateTime, value )
+        when :float, :decimal
+          assert_instance_of( Float, value )
+        when :integer
+          assert_instance_of( Fixnum, value )
+        when :string, :text
+          assert_instance_of( String, value )
+          v = value.strip
+          assert( v.length > 0 )
+          assert( !v.empty? )
+        when :time
+          assert_instance_of( Time, value )
+        else
+          assert( false, "Invalid type: #{type}" )
+        end
+      end
+    end
+  end
+end

data/test/test_faker.rb

@@ -0,0 +1,45 @@
+# require 'pry'
+require 'minitest/autorun'
+require 'faker'
+require 'ostruct'
+require 'pathname'
+require 'yaml'
+require_relative '../lib/auto-seeding'
+
+describe 'AutoSeeding using Faker' do
+  before do
+    AutoSeeding::Seeder.config  # reset global options
+    @test_faker = AutoSeeding::Seeder.new({
+      seeder: :faker
+    })
+  end
+
+  describe 'When generating a value of any type' do
+    it 'must return a correct value' do
+      @test_faker.sources[:types].each do |type, data|
+        value = AutoSeeding::Source.new( :test1, type, nil, data ).gen
+        case type
+        when :boolean
+          assert( value.is_a?( FalseClass ) || value.is_a?( TrueClass ) )
+        when :date
+          assert_instance_of( Date, value )
+        when :datetime, :timestamp
+          assert_instance_of( DateTime, value )
+        when :float, :decimal
+          assert_instance_of( Float, value )
+        when :integer
+          assert_instance_of( Fixnum, value )
+        when :string, :text
+          assert_instance_of( String, value )
+          v = value.strip
+          assert( v.length > 0 )
+          assert( !v.empty? )
+        when :time
+          assert_instance_of( Time, value )
+        else
+          assert( false, "Invalid type: #{type}" )
+        end
+      end
+    end
+  end
+end

data/test/test_ffaker.rb

@@ -0,0 +1,45 @@
+# require 'pry'
+require 'minitest/autorun'
+require 'ffaker'
+require 'ostruct'
+require 'pathname'
+require 'yaml'
+require_relative '../lib/auto-seeding'
+
+describe 'AutoSeeding using FFaker' do
+  before do
+    AutoSeeding::Seeder.config  # reset global options
+    @test_ffaker = AutoSeeding::Seeder.new({
+      seeder: :ffaker
+    })
+  end
+
+  describe 'When generating a value of any type' do
+    it 'must return a correct value' do
+      @test_ffaker.sources[:types].each do |type, data|
+        value = AutoSeeding::Source.new( :test1, type, nil, data ).gen
+        case type
+        when :boolean
+          assert( value.is_a?( FalseClass ) || value.is_a?( TrueClass ) )
+        when :date
+          assert_instance_of( Date, value )
+        when :datetime, :timestamp
+          assert_instance_of( DateTime, value )
+        when :float, :decimal
+          assert_instance_of( Float, value )
+        when :integer
+          assert_instance_of( Fixnum, value )
+        when :string, :text
+          assert_instance_of( String, value )
+          v = value.strip
+          assert( v.length > 0 )
+          assert( !v.empty? )
+        when :time
+          assert_instance_of( Time, value )
+        else
+          assert( false, "Invalid type: #{type}" )
+        end
+      end
+    end
+  end
+end

data/test/test_globals.rb

@@ -0,0 +1,27 @@
+# require 'pry'
+require 'minitest/autorun'
+require 'ostruct'
+require 'pathname'
+require 'yaml'
+require 'ffaker'
+require_relative '../lib/auto-seeding'
+
+describe 'AutoSeeding global config' do
+  before do
+    AutoSeeding::Seeder.config({
+      skip_associations: [:versions],
+      conf: {
+        seeder: :ffaker,
+      },
+    })
+  end
+
+  describe 'When using config method' do
+    it 'must merge the internal options' do
+      auto_seeding = AutoSeeding::Seeder.new
+      assert_equal( auto_seeding.options[:conf][:seeder], :ffaker )
+      auto_seeding2 = AutoSeeding::Seeder.new
+      assert_equal( auto_seeding2.options[:conf][:seeder], :ffaker )
+    end
+  end
+end

data/test/test_options.rb

@@ -0,0 +1,49 @@
+# require 'pry'
+require 'minitest/autorun'
+require 'ostruct'
+require 'pathname'
+require 'yaml'
+require_relative '../lib/auto-seeding'
+
+describe 'AutoSeeding Options' do
+  before do
+    AutoSeeding::Seeder.config  # reset global options
+    @test_options = AutoSeeding::Seeder.new({
+      auto_create: [:profile],       # array of symbols - nested associations to create while seeding
+      conf: {
+        file: 'test/conf.yml',       # string - local seed configuration file
+        seeder: :faker,              # symbol - :faker or :ffaker
+      },
+      ignore_attrs: [:id],           # array of symbols - ignored attributes
+      skip_associations: [:author],  # array of symbols - ignored nested associations
+      sources: {                     # hash - keys: types, fields
+        types: {                     # hash - override basic types rules
+          integer: {
+            source_model: Random,
+            source_method: 'rand',
+            source_args: 0..100,
+          }
+        },
+        # fields: [                    # array of hashes - overried fields rules
+        #   {
+        #     in: ['name'],
+        #     source_model: 'Faker::Hipster',
+        #     source_method: 'word',
+        #     type: 'string'
+        #   }
+        # ]
+      }
+    })
+  end
+
+  describe 'When using constructor options hash' do
+    it 'must merge the internal options' do
+      assert_nil( @test_options.options[:conf][:seeder] ) # overriden by file option
+      assert_equal( @test_options.options[:auto_create], [:profile] )
+      assert_equal( @test_options.options[:ignore_attrs], [:id] )
+      assert_equal( @test_options.options[:skip_associations], [:author] )
+      assert_equal( @test_options.sources[:fields][0][:source_args], 1 )
+      assert_equal( @test_options.sources[:types].keys, [:integer] )
+    end
+  end
+end

data/test/test_validators.rb

@@ -0,0 +1,167 @@
+# require 'pry'
+require 'minitest/autorun'
+require 'active_record'
+require 'ostruct'
+require 'pathname'
+require 'yaml'
+require_relative '../lib/auto-seeding'
+
+AutoSeeding::Seeder.class_eval do
+  attr_reader :columns, :extra_validations
+end
+
+class TestObject # < ActiveRecord::Base
+  include ActiveRecord::Validations
+
+  FIELDS = {
+    privacy:  :boolean,
+    privacy2: :boolean,
+    email:    :string,
+    email2:   :string,
+    letter:   :string,
+    letter2:  :string,
+    title:    :string,
+    title2:   :text,
+    title3:   :text,
+    title4:   :text,
+    title5:   :text,
+    integer:  :float,
+    number:   :integer,
+    number2:  :float,
+    number3:  :decimal,
+    number4:  :integer,
+    unique:   :string,
+    unique2:  :integer
+  }.freeze
+  FIELDS_EXTRA = [:email_confirmation, :email_confirmation2].freeze
+  FIELDS_SET = ( FIELDS.keys + FIELDS_EXTRA ).map { |field| ( field.to_s + '=' ).to_sym }.freeze
+
+  validates :privacy, acceptance: true
+  validates :privacy2, acceptance: { accept: true }
+  validates :email, confirmation: true
+  validates :email_confirmation, presence: true
+  validates :email2, confirmation: { case_sensitive: false }
+  validates :letter, exclusion: { in: %w(a b c) }, length: { is: 1 }
+  validates :letter2, inclusion: { in: %w(a b c) }, length: { is: 1 }
+  validates :title,  length: { in: 15..20 }
+  validates :title2, length: { within: 15..20 }
+  validates :title3, length: { minimum: 15 }
+  validates :title4, length: { maximum: 20 }
+  validates :title5, length: { is: 18 }
+  validates :integer, numericality: { only_integer: true }
+  validates :number, numericality: true
+  validates :number2, numericality: { greater_than: 15, less_than_or_equal_to: 20 }
+  validates :number3, numericality: { greater_than_or_equal_to: 15, less_than: 20 }
+  validates :number4, numericality: { equal_to: 18 }
+  validates :unique, uniqueness: true
+  validates :unique2, uniqueness: { scope: :email }
+
+  def initialize
+    @data = {}
+  end
+
+  def []( field )
+    @data[field.to_sym]
+  end
+
+  def self.content_columns
+    FIELDS.map do |field, type|
+      OpenStruct.new( { name: field.to_s, type: type } )
+    end
+  end
+
+  def self._reflections
+    []
+  end
+
+protected
+
+  def method_missing( method, *args, &block )
+    if FIELDS.keys.include?( method ) || FIELDS_EXTRA.include?( method )
+      self[method]
+    elsif FIELDS_SET.include?( method )
+      # p method
+      @data[method.to_s.chop.to_sym] = args[0]
+    else
+      # p method
+      super
+    end
+  end
+
+  def respond_to?( method, include_private = false )
+    FIELDS.keys.include?( method ) || FIELDS_EXTRA.include?( method ) || FIELDS_SET.include?( method ) || super
+  end
+end
+
+describe 'Check validators' do
+  before do
+    AutoSeeding::Seeder.config  # reset global options
+    @test_validators = AutoSeeding::Seeder.new
+  end
+
+  describe 'When update method is called' do
+    it 'must set the validators options' do
+      @test_validators.update( TestObject.new )
+      cols = @test_validators.columns
+
+      ## Validation Helpers
+      # --- acceptance --------------------------------------------------------
+      assert_equal cols[:privacy][:validators][:accept], ['1', true]
+      assert_equal cols[:privacy2][:validators][:accept], [true]
+      # --- confirmation ------------------------------------------------------
+      assert_equal @test_validators.extra_validations[:confirmations], [:email, :email2]
+      # --- exclusion ---------------------------------------------------------
+      assert_equal cols[:letter][:validators][:not_in], ['a', 'b', 'c']
+      # --- format ------------------------------------------------------------
+      # TODO: not implemented
+      # --- inclusion ---------------------------------------------------------
+      assert_equal cols[:letter2][:validators][:in], ['a', 'b', 'c']
+      # --- length ------------------------------------------------------------
+      assert_equal cols[:title][:validators][:length_minimum], 15
+      assert_equal cols[:title][:validators][:length_maximum], 20
+      assert_equal cols[:title2][:validators][:length_minimum], 15
+      assert_equal cols[:title2][:validators][:length_maximum], 20
+      assert_equal cols[:title3][:validators][:length_minimum], 15
+      assert_equal cols[:title4][:validators][:length_maximum], 20
+      assert_equal cols[:title5][:validators][:length_minimum], 18
+      assert_equal cols[:title5][:validators][:length_maximum], 18
+      # --- numericality ------------------------------------------------------
+      # cols[:number]  # -> set type to integer ?
+      # cols[:integer] # -> set type to integer ?
+      assert_equal cols[:number2][:validators][:num_gt],   15
+      assert_equal cols[:number2][:validators][:num_lte],  20
+      assert_equal cols[:number3][:validators][:num_gte],  15
+      assert_equal cols[:number3][:validators][:num_lt],   20
+      assert_equal cols[:number4][:validators][:equal_to], 18
+      # --- presence ----------------------------------------------------------
+      # TODO: not implemented
+      # --- absence -----------------------------------------------------------
+      # TODO: not implemented
+      # --- uniqueness --------------------------------------------------------
+      assert cols[:unique][:validators][:uniqueness]
+      assert cols[:unique2][:validators][:uniqueness]
+      # --- validates_with ----------------------------------------------------
+      # TODO: not implemented
+      # --- validates_each ----------------------------------------------------
+      # TODO: not implemented
+    end
+
+    it 'must generate values respecting validations rules' do
+      obj = @test_validators.update( TestObject.new )
+      assert obj.privacy == '1' || obj.privacy == true
+      assert obj.privacy2
+      assert obj.email == obj.email_confirmation
+      assert obj.email2 == obj.email2_confirmation
+      assert !( ['a', 'b', 'c'].include?( obj.letter ) )
+      assert ['a', 'b', 'c'].include?( obj.letter2 )
+      assert obj.title.length  >= 15 && obj.title.length  <= 20
+      assert obj.title2.length >= 15 && obj.title2.length <= 20
+      assert obj.title3.length >= 15
+      assert obj.title4.length <= 20
+      assert obj.title5.length == 18
+      assert obj.number2 >  15 && obj.number2 <= 20
+      assert obj.number3 >= 15 && obj.number3 <  20
+      assert obj.number4 == 18
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: auto-seeding
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Mattia Roccoberton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-10 00:00:00.000000000 Z
+date: 2017-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -87,7 +87,26 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- auto-seeding.gemspec
 - lib/auto-seeding.rb
+- lib/auto-seeding/data/basic.yml
+- lib/auto-seeding/data/faker.yml
+- lib/auto-seeding/data/ffaker.yml
+- lib/auto-seeding/seeder.rb
+- lib/auto-seeding/source.rb
+- lib/auto-seeding/utils.rb
+- test/conf.yml
+- test/test_basic.rb
+- test/test_faker.rb
+- test/test_ffaker.rb
+- test/test_globals.rb
+- test/test_options.rb
+- test/test_validators.rb
 homepage: https://github.com/blocknotes/auto-seeding
 licenses:
 - MIT