pokotarou 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 38bd381d74ed4731fdb2c3af3211af492cea80f5e08f7d0cd42944e2b722aa8c
+  data.tar.gz: 161e98919c174d0cd170c9401d70d65bc5a2311912e8201618c6fac3c841580b
+SHA512:
+  metadata.gz: 5a39ece97d618b6670b69e3db80064b3a499ac315f918293550f807c7a5b8d7360900631bbd32710c05445ff9b780865e7ea621c66f59a5712252d612f145872
+  data.tar.gz: a3d17bd0d59f04e373ac31039d1399592e43aec29fba8802b509b690f97c00780b228529e01c883276f046162c906059ac7d7e54e1289e50926e6910524a5a92

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2019 
+
+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,342 @@
+![s_PokotarouLogo](https://user-images.githubusercontent.com/52961642/61586183-ef59b580-aba8-11e9-83b0-19eac7339982.png)
+
+[![Build Status](https://travis-ci.org/Tamatebako0205/Pokotarou.svg?branch=master)](https://travis-ci.org/Tamatebako0205/Pokotarou)
+
+Pokotarou is convenient seeder of 'Ruby on Rails' that uses .yml
+Currently only mysql supported
+
+## Features
+
+### Easy to use
+Currently can be used only for simple configuration file settings
+You don't have to write a program for seeder
+
+### Fast speed
+If it is the following table, 10,000 records can regist in 0.4s on average
+Also, If you enable 'optimize option', 10,000 records can regist in 0.23s on average
+
+|Field|Type|NULL|
+|:---|:---|:---|
+|id|bigint(20)| NO|
+|name|varchar(255)|YES|
+|created_at|datetime|NO|
+|updated_at|datetime|NO|
+
+## Getting started
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'pokotarou'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install pokotarou
+```
+
+## License
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+## Usage
+Introduce how to execute and write configuration file.
+If you want to know more information file settings,  please refer to the test
+
+### Extecute
+After write configuration file, execute the following source code in seeds.rb of Ruby on Rails
+
+```
+Pokotarou.execute(ConfigrationFilePath)
+```
+### Configration file
+
+Introduce how to write yml configuration file
+
+#### Definition for explanation
+Table name below is 'prefs' and model name is 'Pref'
+
+|Field|Type|NULL|
+|:---|:---|:---|
+|id|bigint(20)| NO|
+|name|varchar(255)|YES|
+|created_at|datetime|NO|
+|updated_at|datetime|NO|
+
+
+Table name below is 'members' and model name is 'Member'
+
+|Field|Type|NULL|
+|:---|:---|:---|
+|id|bigint(20)| NO|
+|name|varchar(255)|YES|
+|remarks|text|YES|
+|birthday|date|YES|
+|pref_id|bigint(20)|YES|
+|created_at|datetime|NO|
+|updated_at|datetime|NO|
+
+
+#### Default data
+If there is no column definition, prepared data is registerd three times
+id column is basically registerd by autoincrement
+
+```
+Default:
+  Pref:
+    loop: 3
+```
+
+
+In the following source code, id, created_at, updated_at will be registerd with the prepared data
+
+```
+Default:
+  Pref:
+    loop: 3
+    col:
+      name: "Hokkaido"
+```
+
+#### Array
+Array data is registerd one by one
+
+```
+Default:
+  Pref:
+    loop: 3
+    col:
+      name: ["Hokkaido", "Aomori", "Iwate"]
+```
+
+#### Maked data
+Registration is possible using registerd data
+
+```
+Default:
+  Pref:
+    loop: 2
+    col:
+      name: ["Hokkaido", "Aomori"]
+  Member:
+    loop: 2
+    col:
+      name: <maked[:Default][:Pref][:name]>
+      pref_id: F|Pref
+```
+
+```
+Default:
+  Pref:
+    loop: 3
+    col:
+      name: ["Hokkaido", "Aomori", "Iwate"]
+  Member:
+    loop: 3
+    col:
+      name: ["Tarou", "Jirou", "Saburou"]
+      remarks: <maked[:Default][:Member][:name]>
+      pref_id: F|Pref
+
+```
+
+```
+Default:
+  Pref: 
+    loop: 2
+    col:
+      name: ["Hokkaido", "Aomori"]
+Default2:
+  Member:
+    loop: 2
+    col:
+      name: <maked[:Default][:Pref][:name]>
+      pref_id: F|Pref
+```
+
+#### Foreign key
+
+**※ If you set association(belongs_to, has_many...), Pokotarou automatically register foreign keys**
+
+What a means is ' F| ' foreign key
+In the following source code, Foreign key of prefectures is registerd
+
+```
+Default:
+  Pref:
+    loop: 3
+    col:
+      name: ["Hokkaido", "Aomori", "Iwate"]
+  Member:
+    loop: 3
+    col:
+      pref_id: F|Pref
+```
+
+#### Expression expansion
+What a means is '< >' expression expansion
+You can run ruby code in '< >'
+
+```
+Default:
+  Pref:
+    loop: 3
+    col:
+      name: <["Hokkaido", "Aomori", "Iwate"]>
+      created_at: <Date.parse('1997/02/05')>
+```
+
+#### Add method
+You can add method and use it in pokotarou
+
+```
+Default:
+  Pref:
+    loop: 3
+    col:
+      name: <pref_name>
+```
+
+Prepare the following ruby file
+```
+def pref_name
+  ["Hokkaido", "Aomori", "Iwate"]
+end
+```
+and execute the following source code in seeds.rb of Ruby on Rails
+
+```
+Pokotarou.import(MethodFilePath)
+Pokotarou.execute(ConfigrationFilePath)
+```
+
+
+#### Use multiple blocks
+
+Registration is possible using two blocks
+
+```
+Default:
+  Pref:
+    loop: 3
+Default2:
+  Pref:
+    loop: 3
+```
+
+and, You can change the name of the block
+
+```
+Hoge:
+  Pref:
+    loop: 3
+Fuga:
+  Pref:
+    loop: 3
+```
+
+
+#### Random
+Shuffle seed data when regist
+
+```
+Default:
+  Pref:
+    loop: 3
+    col:
+      name: ["Hokkaido", "Aomori", "Iwate"]
+    option:
+      name: ["random"]
+```
+
+The following results change from run to run
+
+```
+["Aomori", "Iwate", "Iwate"]
+```
+
+#### Add_id
+Add individual number to seed data of String type
+
+```
+Default:
+  Pref:
+    loop: 3
+    col:
+      name: ["Hokkaido", "Aomori", "Iwate"]
+    option:
+      name: ["add_id"]
+```
+
+```
+["Hokkaido_0", "Aomori"_1, "Iwate_2"]
+```
+
+#### Combine serveral options
+Combination of options is possible
+
+```
+Default:
+  Pref:
+    loop: 3
+    col:
+      name: ["Hokkaido", "Aomori", "Iwate"]
+    option:
+      name: ["add_id", "random"]
+```
+
+The following results change from run to run
+
+```
+["Hokkaido_0", "Iwate_1", "Hokkaido_2"]
+```
+
+#### Validation
+
+Run validation when regist
+
+```
+Default:
+  Pref:
+    loop: 3
+    validate: true
+```
+
+#### Autoincrement
+
+You can disable the autoincrement setting
+
+If you disable the setting, you can register id data prepared by myself
+
+```
+Default:
+  Pref:
+    loop: 3
+    autoincrement: false
+    col:
+      id: [100, 101, 102]
+```
+
+#### Optimize
+
+If you enable 'optimize', Pokotarou Run a query builder, but disable validation
+
+```
+Default:
+  Pref:
+    loop: 3
+    optimaize: true
+```
+
+#### Update parameter
+
+You can update pokotarou's parameter
+
+```
+  config_data = Pokotarou.get_config("ConfigrationFilePath")
+  config_data[:Default][:Pref][:loop] = 6
+  Pokotarou.do_seed(config_data)
+```

data/Rakefile

@@ -0,0 +1,33 @@
+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    = 'Pokotarou'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/lib/pokotarou/additional_methods.rb

@@ -0,0 +1,14 @@
+module AdditionalMethods
+  class << self
+    @filepath = nil
+    attr_reader :filepath
+
+    def import filepath
+      @filepath = filepath
+    end
+
+    def remove
+      @filepath = nil
+    end
+  end
+end

data/lib/pokotarou/data_register.rb

@@ -0,0 +1,176 @@
+class RegistError < StandardError; end
+class SeedError < StandardError; end
+
+class DataRegister
+  class << self
+    def regist data
+      # init maked to accumulate maded data
+      maked = Hash.new
+      # init model_data to cache data of model
+      model_cache = Hash.new
+      ActiveRecord::Base.transaction do
+        begin
+          data.each do |sym_block, model_data|
+            regist_models(sym_block, model_data, maked, model_cache)
+          end
+        rescue => e
+          raise StandardError.new("#{e.message}")
+        end
+      end
+    end
+
+    private
+
+    def execute model, config_data, table_name, col_arr, seed_arr
+      # optimize is more faster than activerecord-import
+      # however, sql.conf setting is necessary to use
+      if config_data[:optimize] 
+        # seed_arr.transpose: [[col1_element, col2_element], [col1_element, col2_element]...]
+        insert_query = QueryBuilder.insert(table_name, col_arr, seed_arr.transpose)
+        ActiveRecord::Base.connection.execute(insert_query)
+      else
+        model.import(col_arr, seed_arr.transpose, validate: config_data[:validate], timestamps: false)
+      end
+    end
+
+    def regist_models sym_block, model_data, maked, model_cache
+      model_data.each do |e|
+        str_model = e.first.to_s
+        save_model_cache(model_cache, str_model)
+        # model_data.values is config_data
+        config_data = e.second
+        # col_arr: [:col1, :col2, :col3]
+        col_arr = config_data[:col].keys
+
+        # set expand expression for loop '<>' and ':' and so on...
+        set_loop_expand_expression(config_data, maked)
+        # if there is no setting data, set default seed data
+        set_default_seed(config_data)
+        # seed_arr: [[col1_element, col1_element], [col2_element, col2_element]...]
+        seed_arr = 
+          get_seed_arr(model_cache[str_model][:model], sym_block,
+                         model_cache[str_model][:sym_model], config_data, maked)
+
+        output_log(config_data[:log]) 
+        begin
+          # execute insert
+          execute(model_cache[str_model][:model], 
+                  config_data, model_cache[str_model][:table_name], col_arr, seed_arr)
+        rescue => e
+          raise RegistError.new("
+            block: #{sym_block}
+            model: #{str_model}
+            message: #{e.message}
+          ")
+        end
+      end
+    end
+
+    def save_model_cache model_cache, str_model
+      return if model_cache[str_model].present?
+      model = eval(str_model)
+      model_cache[str_model] = {
+        model: model,
+        sym_model: str_model.to_sym,
+        table_name: model.table_name
+      }
+    end
+
+    def set_default_seed config_data
+      block = ->(symbol){ :id == symbol }
+      # each column type, key is symbolize column name
+      config_data[:type].each do |key, _|
+        # if it is id, skip
+        next if block.call(key)
+        # if there is data already, skip
+        next if config_data[:col][key].present?
+
+        config_data[:col][key] = Seeder.gen(config_data, key) 
+      end
+    end
+    
+    def get_seed_arr model, sym_block, sym_model, config_data, maked
+      options = config_data[:option]
+      loop_size = config_data[:loop]
+
+
+      if apply_autoincrement?(config_data[:autoincrement])
+        set_autoincrement(config_data, model, loop_size)
+      end
+
+      config_data[:col].map do |key, val|
+        begin 
+          # set expand expression '<>' and ':' and so on...
+          set_expand_expression(config_data, key, val, maked)
+          expanded_val = config_data[:col][key]
+          option_conf = options.nil? ? nil : Option.gen(options[key])
+          # Take count yourself, because .with_index is slow
+          cnt = 0
+          seeds = 
+            loop_size.times.map do
+              seed = option_conf.nil? ? get_seed(expanded_val, cnt) : get_seed_with_option(expanded_val, option_conf, cnt)
+              cnt += 1
+
+              seed
+            end
+          update_maked_data(maked, sym_block, sym_model, key, seeds)
+
+          seeds
+        rescue => e
+          raise SeedError.new("
+            block: #{sym_block}
+            model: #{sym_model}
+            column: #{key}
+            message: #{e.message}
+          ")
+        end
+      end
+    end
+
+    def apply_autoincrement? autoincrement_flg
+      # default true
+      return true if autoincrement_flg.nil?
+      autoincrement_flg
+    end
+
+    def set_autoincrement config_data, model, loop_size
+      last_record = model.last
+      # use pluck to optimize(suppress make object)
+      additions = model.all.pluck(:id).size + loop_size      
+      latest_id = last_record.nil? ? 1 : last_record.id + 1
+      config_data[:col][:id] = [*latest_id..additions]
+    end
+
+    def set_expand_expression config_data, key, val, maked
+      # if it exists type, there is no need for doing 'expand expression'
+      return if config_data[:type][key].present?
+      config_data[:col][key] = ExpressionParser.parse(val, maked)
+    end
+
+    def set_loop_expand_expression config_data, maked
+      config_data[:loop] = 
+        LoopExpressionParser.parse(config_data[:loop], maked)  
+    end
+
+    def get_seed arr, cnt
+      get_rotated_val(arr, cnt)
+    end
+
+    def get_seed_with_option arr, option, cnt
+      Option.apply(arr, option, cnt)
+    end
+
+    def update_maked_data maked, sym_block, sym_model, col, seed
+      # maked: { key: Model, value: {key: col1, val: [col1_element, col1_element]} }
+      maked[sym_block] ||= Hash.new
+      maked[sym_block][sym_model] ||= Hash.new
+      maked[sym_block][sym_model][col] = seed
+    end
+
+    def output_log log
+      return if log.nil?
+      puts log
+    end
+
+  end
+end

data/lib/pokotarou/data_structure.rb

@@ -0,0 +1,85 @@
+class DataStructure
+  class << self
+    def gen data
+      # return data structure bellow
+      # [{ block_name => { model_name => { column_configration }}}, ...]
+      data.reduce(Hash.new) do |acc, r|
+        # r.first is block_name
+        # r.second is model_data, like { Pref: {loop: 3}, Member: {loop: 3}... }
+        acc[r.first] = gen_structure(r.second)
+
+        acc
+      end
+    end
+
+    private
+
+    def gen_structure model_data
+      model_data.reduce(Hash.new) do |acc, r|
+        # r.second is config_data, like {loop: 3, ...}
+        set_col_type(r.second, r[0].to_s)
+        acc[r[0]] = r.second
+
+        acc
+      end
+    end
+
+    def set_col_type config_data, str_model
+      model = eval(str_model)
+      foreign_key_data = get_foreign_key_data(model)
+      
+      config_data[:col] ||= Hash.new    
+      model.columns.each do |e|
+        symbol_col_name = e.name.to_sym
+        
+        unless exists_seed_data?(config_data, symbol_col_name)
+          # prepare setting to run default seed
+          # set nil to seed data
+          config_data[:col][symbol_col_name] = nil
+
+          # set type info
+          config_data[:type] ||= Hash.new
+          config_data[:type][symbol_col_name] = e.type.to_s
+
+          # set enum info
+          config_data[:enum] ||= Hash.new
+          if is_enum?(e.sql_type.to_s)
+            config_data[:enum][symbol_col_name] = 
+              e.sql_type.to_s[5..-2].tr("'", "").split(",")
+          end
+
+          # set foreign_key info
+          config_data[:foreign_key] ||= Hash.new
+          if is_foreign_key?(symbol_col_name, foreign_key_data)
+            config_data[:foreign_key][symbol_col_name] = foreign_key_data[symbol_col_name]
+          end
+        end
+      
+      end
+    end
+
+    def get_foreign_key_data model
+      associations = model.reflect_on_all_associations(:belongs_to)
+      return { } if associations.empty?
+      associations.reduce(Hash.new)do |acc, r|
+        acc[r.foreign_key.to_sym] = eval(r.name.to_s.classify)
+
+        acc
+      end
+    end
+
+    def is_foreign_key? symbol_col_name, foreign_key_data
+      foreign_key_data[symbol_col_name].present?
+    end
+
+    def exists_seed_data? config_data ,symbol_col_name
+      config_data[:col].has_key?(symbol_col_name)
+    end
+    
+    ENUM = /^enum(\s*.)*$/
+    def is_enum? val
+      return false unless val.kind_of?(String)
+      ENUM =~ val 
+    end
+  end
+end

data/lib/pokotarou/expression_parser.rb

@@ -0,0 +1,83 @@
+require "pokotarou/additional_methods.rb"
+class ParseError < StandardError; end
+
+# for seed data
+class ExpressionParser
+  class << self
+    FOREIGN_KEY_SYMBOL = "F|"
+    def parse config_val, maked
+      begin
+        require AdditionalMethods.filepath if AdditionalMethods.filepath.present?
+        case
+        when config_val.instance_of?(Array)
+          return config_val
+        when config_val.nil?
+          return nil
+        when is_foreign_key?(config_val)
+          # remove 'F|'
+          str_model = config_val.sub(FOREIGN_KEY_SYMBOL, "")
+          model = eval(str_model)
+          return model.pluck(:id)
+        when is_expression?(config_val)
+          # remove '<>'
+          expression = config_val.strip[1..-2]
+          return self.parse(eval(expression), maked)
+        else
+          if config_val.instance_of?(String)
+            # escape \\
+            [config_val.tr("\\","")]
+          else
+            [config_val]
+          end
+        end
+      rescue => e
+        ParseError.new("Failed Expression parse:#{e.message}")
+      end
+    end
+  end
+end
+
+# for loop data
+class LoopExpressionParser
+  class << self
+    FOREIGN_KEY_SYMBOL = "F|"
+    def parse config_val, maked
+      begin
+        require AdditionalMethods.filepath if AdditionalMethods.filepath.present?
+        case
+        when config_val.instance_of?(Array)
+          return config_val.size
+        when config_val.instance_of?(Integer)
+          return config_val
+        when config_val.nil?
+          return 1
+        when is_foreign_key?(config_val)
+          # remove 'F|'
+          str_model = config_val.sub(FOREIGN_KEY_SYMBOL, "")
+          model = eval(str_model)
+          return model.pluck(:id).size
+        when is_expression?(config_val)
+          # remove '<>'
+          expression = config_val.strip[1..-2]
+          return self.parse(eval(expression), maked)
+        else
+          return 1
+        end
+      rescue => e
+        ParseError.new("Failed Loop Expression parse: #{e.message}")
+      end
+    end
+  end
+end
+
+FOREIGN_KEY = /^F\|[A-Z][A-Za-z0-9]*$/
+def is_foreign_key? val;
+  return false unless val.kind_of?(String)
+  FOREIGN_KEY =~ val
+end
+
+EXPRESSION = /^\s*<.*>\s*$/
+def is_expression? val
+  return false unless val.kind_of?(String)
+  EXPRESSION =~ val
+end

data/lib/pokotarou/loader.rb

@@ -0,0 +1,16 @@
+class FileLoader
+  class << self
+    # load data with the use of indicated filepath 
+    def load filepath
+    end
+  end
+end
+
+class YmlLoader < FileLoader
+  class << self
+    def load filepath
+      # convert 'str_key' to 'symbol_key'
+      YAML.load_file(filepath).deep_symbolize_keys!
+    end
+  end
+end

data/lib/pokotarou/my_mthods.rb

@@ -0,0 +1,10 @@
+class NothingDataError < StandardError; end
+
+# return rotated val in passed array
+def get_rotated_val array, cnt
+  raise NothingDataError.new("Nothing seed data") if array.nil?
+  size = array.size
+  raise NothingDataError.new("Seed data is empty") if size.zero?
+  x = (size + cnt) / size
+  array[ size + cnt - size * x ]
+end

data/lib/pokotarou/option.rb

@@ -0,0 +1,42 @@
+class Option
+  class << self
+    def gen option
+      # shape option data
+      # [option1, option2] => { select: [option2], add: [option1] }
+      # [] => { select: [], add: [] }
+      option.nil? ? { select: [], add: [] } : separate(option)
+    end
+
+    def apply arr, option_conf, cnt = 0
+      selected_val = select(option_conf[:select], arr, cnt)
+      add(option_conf[:add], selected_val, cnt)
+    end
+
+    private
+
+    def separate option
+      # separate option to 'select' and 'add'
+      # { select = >[], add => [] }
+      select_filter = ->(name){ ["rotate", "random"].include?(name) }
+      add_filter = ->(name){ ["add_id"].include?(name) }
+
+      {
+        select: option.find{|s| select_filter.call(s)},
+        add: option.find{|s| add_filter.call(s)}
+      }
+    end
+
+    def select option, arr, cnt
+      return arr.sample if option == "random"
+      # default return rotate
+      get_rotated_val(arr, cnt)
+    end
+
+    def add option, val, cnt
+      # use '+', not use '<<' to avoid destructive effect
+      return val + "_#{cnt}" if option == "add_id"
+
+      val
+    end
+  end
+end

data/lib/pokotarou/query_builder.rb

@@ -0,0 +1,44 @@
+class QueryBuilder
+  class << self
+
+    # build insert query
+    def insert table_name, col_arr, seed_arr
+      col_str = convert_col_to_sql_str(col_arr)
+      seed_str = convert_seed_to_sql_str(seed_arr)
+
+      "INSERT INTO #{table_name} #{col_str} VALUES#{seed_str}"
+    end
+
+    def convert_to_sql_str arr
+      arr_str =
+        arr.reduce("(") do |acc, r|
+          acc << add_double_quote(r.to_s) << ","
+        end
+      # remove ' , ' and add ' ) '
+      arr_str.chop << ")"
+    end
+
+    def convert_seed_to_sql_str seed_arr
+      seed_str =
+        seed_arr.reduce("") do |acc, r|
+          acc << convert_to_sql_str(r) << ","
+        end
+      # remove ' , '
+      seed_str.chop
+    end
+
+    def convert_col_to_sql_str col_arr
+      col_str =
+        col_arr.reduce("(") do |acc, r|
+          acc << r.to_s << ","
+        end
+      # remove ' , ' and add ' ) '
+       col_str.chop << ")"
+    end
+
+
+    def add_double_quote str
+      "\"" << str << "\""
+    end
+  end
+end

data/lib/pokotarou/seeder.rb

@@ -0,0 +1,32 @@
+class Seeder 
+  class << self
+    MAX_LOOP = 100
+    def gen config_data, key
+      n = config_data[:loop] > MAX_LOOP ? MAX_LOOP : config_data[:loop]
+      type = config_data[:type][key]
+      enum = config_data[:enum][key]
+      foreign_key = config_data[:foreign_key][key]
+
+      return foreign_key.pluck(:id) if foreign_key.present?
+      return enum if enum.present?
+      return make_array(n, ->(){ rand(100) }) if type == "integer"
+      return make_array(n, ->(){ rand(0.0..100.0) }) if type == "float"
+      return make_array(n, ->(){ rand(0.0..1_000_000_000.0) }) if type == "decimal"
+      return make_array(n, ->(){ SecureRandom.hex(20) }) if type == "string"
+      return make_array(n, ->(){ SecureRandom.hex(300) }) if ["text", "binary"].include?(type)
+      return make_array(n, ->(){ [1, 0].sample }) if type == "boolean"
+      return make_string_array(n, enum) if type == "string"
+      return make_datetime_array() if ["string", "datetime", "date", "time"].include?(type)
+    end
+
+    private
+
+    def make_array n, proc
+      Array.new(n).map{ proc.call() }
+    end
+
+    def make_datetime_array
+      [Time.now.to_s(:db)]
+    end
+  end
+end

data/lib/pokotarou/version.rb

@@ -0,0 +1,3 @@
+module Pokotarou
+  VERSION = '0.1.0'
+end

data/lib/pokotarou.rb

@@ -0,0 +1,43 @@
+Dir[File.expand_path('../pokotarou', __FILE__) << '/*.rb'].each do |file|
+  require file
+end
+require "activerecord-import"
+
+module Pokotarou
+  class NotFoundLoader < StandardError; end
+
+  class << self
+    def execute filepath
+      do_seed(get_config(filepath))
+    end
+
+    def import filepath
+      AdditionalMethods.import(filepath)
+    end
+
+    def reset
+      AdditionalMethods.remove()
+    end
+
+    def get_config filepath
+      contents = load_file(filepath)
+      DataStructure.gen(contents)
+    end
+
+    def do_seed data
+      DataRegister.regist(data)
+    end
+
+    private
+
+    def load_file filepath
+      case File.extname(filepath)
+      when ".yml"
+        return YmlLoader.load(filepath)
+      else
+        raise NotFoundLoader.new("not found loader")
+      end
+    end
+
+  end
+end

data/lib/tasks/pokotarou_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :pokotarou do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: pokotarou
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kashiwara
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-07-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+- !ruby/object:Gem::Dependency
+  name: activerecord-import
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.00'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.00'
+description: 'Pokotarou is fast seeder of ''Ruby on Rails'' URL: https://github.com/Tamatebako0205/Pokotarou'
+email:
+- tamatebako0205@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/pokotarou.rb
+- lib/pokotarou/additional_methods.rb
+- lib/pokotarou/data_register.rb
+- lib/pokotarou/data_structure.rb
+- lib/pokotarou/expression_parser.rb
+- lib/pokotarou/loader.rb
+- lib/pokotarou/my_mthods.rb
+- lib/pokotarou/option.rb
+- lib/pokotarou/query_builder.rb
+- lib/pokotarou/seeder.rb
+- lib/pokotarou/version.rb
+- lib/tasks/pokotarou_tasks.rake
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: This gem is seeder which is very usefull
+test_files: []