pokotarou 1.1.2 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 26d3f8f68a7a87d027466c80654f9c1de4234fbe2b97707b9658532165b3b2c2
-  data.tar.gz: 1b2480d5b364cf046516f717f71dd39edf7bd55af22043ac97d211ebcb90967f
+  metadata.gz: e5c1ca5e0b1537a768623eb035c99be512b4fa31a57714ee3f0b1b5a0d4e29db
+  data.tar.gz: 55fa713f56db0dc7d928ef3f4edc70727fc24a1c2c936d273fb58964d0cabc59
 SHA512:
-  metadata.gz: c23b14720511e56b883626512b5dd30f58217c3993889368aa67bf946a9b3d152a16dd28a61caa2204f2bd8733544e6e2a1c126dbeafdf26cd014be1fd2d1648
-  data.tar.gz: ec67cf38c079ab6a7b9c01fcec4bdd800210c7e28c7deed0c5e994610d2702f5d0bd1acc94eae04a5f3250b1fd40105238c0368873f41323dd98141c6dad5e7c
+  metadata.gz: 74de5054c2bab3a5c8908239a6973442c431486ab6018bb779f598cdde3de7f6d6b596237843bd336cd963c327635fbf05d7c7c96ca3abd039bf179558336ad8
+  data.tar.gz: 9e33defb98f9ada2032d6de9b4d300272a3dda290ad5a09590960e8412ea868616bbd110903ac53c0dd39a177ad57c2dc7b730160c2b676ff22a07221f613805

data/README.md

@@ -4,17 +4,21 @@
 [![Gem Version](https://badge.fury.io/rb/pokotarou.svg)](https://badge.fury.io/rb/pokotarou)
 [![Build Status](https://travis-ci.org/Kashiwara0205/Pokotarou.svg?branch=master)](https://travis-ci.org/Kashiwara0205/Pokotarou)
 
-Pokotarou is convenient seeder of 'Ruby on Rails'
-In MySql, operation has been confirmed
-
 ## Features
 
-### Easy to use
-You don't have to write a program for seed
-Can be set simply by writing a yml file!
+__Pokotarou__ is convinient Mysql seeder of Ruby on Rails.
+
+__Easy to use!!__  
+Just use yml file.  
+very very very simple!  
+You dont' have to write ruby program about seed data!
 
-### Fast speed
-If it is the following table, 10,000 records can regist in 0.41s on average
+__Fast speed!!__  
+__Pokotarou__ is fast seeder.  
+Because contains [Activerecord-import](https://github.com/zdennis/activerecord-import).  
+so, always run bulk insert when execute rails db:seed command!
+
+If you use __Pokotarou__ about following table.
 
 |Field|Type|NULL|
 |:---|:---|:---|
@@ -23,9 +27,7 @@ If it is the following table, 10,000 records can regist in 0.41s on average
 |created_at|datetime|NO|
 |updated_at|datetime|NO|
 
-Thanks to ActiveRecordImport
-
-
+__Pokotarou__ can register in 0.41s on average.
 
 ## Getting started
 Add this line to your application's Gemfile:
@@ -44,40 +46,12 @@ Or install it yourself as:
 $ gem install pokotarou
 ```
 
-## License
-The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-
-## Usage
-
-Following yml file become seed data.
-
-Please make following yml file in your favorite dir.
-
-```yml
-Default:
-  Pref:
-    loop: 3
-```
-
-and write following ruby code in seeds.rb.
-
-```ruby
-Pokotarou.execute("./config_filepath")
-```
-
-when you finished writing, then run rails db:seed
-
-```bash
-$ rails db:seed
-```
-
-As a result, seed data is registerd your db.
+## Basic Usage
 
-## How to set configlation file(.yml)?
-explain how to write the configuration file below.
-
-### Model used for explanation
-Table name below is 'prefs' and model name is 'Pref'
+Just make yml file.  
+If you register data to following prefecture data. 
+     
+__prefecture table__
 
 |Field|Type|NULL|
 |:---|:---|:---|
@@ -87,463 +61,44 @@ Table name below is 'prefs' and model name is 'Pref'
 |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|
-
-
-### Standerd Setting
-The basic setting method is written below
-
-#### Automatic data entry
-
-If there is no definition about col, then automatically prepared data is registrd.
-
-For example, in the case of below, it is registered automatically prepared data three times.
-
-```yml
-Default:
-  Pref:
-    loop: 3
-```
-
-also you can set seed_data by yourself.
-```yml
-Default:
-  Pref:
-    loop: 3
-    col:
-      name: "Hokkaido"
-```
-
-#### Omitted loop
-If you want to register the test data at once, I suggest ommited loop
-
-```yml
-Default:
-  Pref: 
-    col:
-      name: ["Hokkaido"]
-```
-
-```ruby
-["Hokkaido"]
-```
-
-#### Array
-You can set array_data.
-
-Array data is registerd one by one.
-
-```yml
-Default:
-  Pref:
-    loop: 3
-    col:
-      name: ["Hokkaido", "Aomori", "Iwate"]
-```
-
-#### Maked function
-'maked' is very useful function.
-it is hash and accumulate data created in the past. 
-
-For example, in the case of below, reffer name of Pref in Default block by maked 
-
-```yml
-Default:
-  Pref:
-    loop: 2
-    col:
-      name: ["Hokkaido", "Aomori"]
-  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**
-
-' F| ' means foreign key. 'F|' is Model.all.pluck(:id)
-
-For example, in the case of below, Member model record is registerd with pref_id(foregin key).
-
-```yml
-Default:
-  Pref:
-    loop: 3
-    col:
-      name: ["Hokkaido", "Aomori", "Iwate"]
-  Member:
-    loop: 3
-    col:
-      pref_id: F|Pref
-```
-
-#### Expression expansion
-'< >' means expression expansion.
-You can run ruby code in '< >'.
-
-```yml
-Default:
-  Pref:
-    loop: 3
-    col:
-      name: <["Hokkaido", "Aomori", "Iwate"]>
-      created_at: <Date.parse('1997/02/05')>
-```
-
-#### Additional method
-You can add method and use it in pokotarou
-
-```yml
-Default:
-  Pref:
-    loop: 3
-    col:
-      name: <pref_name>
-```
-
-Prepare the following ruby file
-
-```ruby
-def pref_name
-  ["Hokkaido", "Aomori", "Iwate"]
-end
-```
-
-and run the following code in seeds.rb.
-
-```ruby
-Pokotarou.import("./method_filepath")
-Pokotarou.execute("./config_filepath")
-```
-
-As as result, pokotarou can call pref_name method, and seed data is registrd by pref_name method.
-
-#### Multiple blocks
-
-You can use multiple blocks.
-
-```yml
-Default:
-  Pref:
-    loop: 3
-Default2:
-  Pref:
-    loop: 3
-```
-
-and, You can change the name of the block
-
-```yml
-Hoge:
-  Pref:
-    loop: 3
-Fuga:
-  Pref:
-    loop: 3
-```
-
-### option
-Option is useful function.
-If you can master it, it may be easier to create test data.
-
-#### Random
-Shuffle seed data when regist
-
-```yml
-Default:
-  Pref:
-    loop: 3
-    col:
-      name: ["Hokkaido", "Aomori", "Iwate"]
-    option:
-      name: ["random"]
-```
-
-The following results change from run to run
-
-```ruby
-["Aomori", "Iwate", "Iwate"]
-```
-
-#### Add_id
-Add individual number to seed data of String type
-
-```yml
-Default:
-  Pref:
-    loop: 3
-    col:
-      name: ["Hokkaido", "Aomori", "Iwate"]
-    option:
-      name: ["add_id"]
-```
-
-```ruby
-["Hokkaido_0", "Aomori"_1, "Iwate_2"]
-```
-
-#### Combine serveral options
-Combination of options is possible
-
-```yml
-Default:
-  Pref:
-    loop: 3
-    col:
-      name: ["Hokkaido", "Aomori", "Iwate"]
-    option:
-      name: ["add_id", "random"]
-```
-
-The following results change from run to run
-
-```ruby
-["Hokkaido_0", "Iwate_1", "Hokkaido_2"]
-```
-
-### Advanced Setting
-The advanced setting method is written below
-
-#### Validation
-
-Run validation when regist
-
-```yml
-Default:
-  Pref:
-    loop: 3
-    validate: true
-```
-
-#### Disable Autoincrement
-
-You can disable the autoincrement setting
-
-If you disable the setting, you can register id data prepared by yourself
-
-```yml
-Default:
-  Pref:
-    loop: 3
-    autoincrement: false
-    col:
-      id: [100, 101, 102]
-```
-
-#### Pokotarou Handler
-
-If you want to use configlation yml data in ruby code then you can use "PokotarouHandler"
-
-When you use "PokotarouHandler", can update pokotarou's parameter
-in ruby code.
-
-
-<b>Change Operation</b>
-
-In the following example, the number of loops is changed
-
-```ruby
-  handler = Pokotarou.gen_handler("./config_filepath")
-  # change loop config
-  handler.change_loop(:Default, :Pref, 6)
-  Pokotarou.execute(handler.get_data)
-```
-
-
-In the following example, seed data is changed
-
-```ruby
-  handler = Pokotarou.gen_handler("./config_filepath")
-  # change seed data config number
-  handler.change_seed(:Default, :Pref, :name, ["a", "b", "c"])
-  Pokotarou.execute(handler.get_data)
-```
-
-<b>Delete Operation</b>
-
-In the following example, delete block config
-
-```ruby
-  handler = Pokotarou.gen_handler("./config_filepath")
-  # delete model config in parameter
-  handler.delete_block(:Default)
-  Pokotarou.execute(handler.get_data)
-```
-
-In the following example, delete model config
+__prefecture model__
 
-```ruby
-  handler = Pokotarou.gen_handler("./config_filepath")
-  # delete model config in parameter
-  handler.delete_model(:Default, :Pref)
-  Pokotarou.execute(handler.get_data)
-```
-
-In the following example, delete col config
-
-```ruby
-  handler = Pokotarou.gen_handler("./config_filepath")
-  # delete col config in parameter
-  handler.delete_col(:Default, :Pref, :name)
-  Pokotarou.execute(handler.get_data)
-```
+|Model|
+|:---|
+|Pref|
 
-#### Const
-You can set const variables by const' key.
+First, Please make following yml file your favorite directory of rails project.  
+The file name can be anything.  
+In my case, made yml file in db directory and named file __pref_data__.  
 
 ```yml
-const':
-  name: "hoge"
 Default:
   Pref:
     loop: 3
-  col:
-    name: <const[:name]>
-```
-
-#### Grouping
-Grouping is very useful function.
-Especially useful when setting multiple options.
-
-
-```yml
-Default:
-  Member:
-    grouping: 
-      # set columns you want to group
-      hoge_g: ["name", "remark"]
-    col:
-      # you can use "hoge_g" at col
-      hoge_g: <['fugafuga!']>
-    option:
-      # also you can use "hoge_g" at option
-      hoge_g: ["add_id"]
-
-```
-
-#### Template
-You can set template config by template' key.
-
-The template can be overwritten with the one set later.
-
-```yml
-template':
-  pref_template:
-    loop: 3
-    col:
-      pref_id: F|Pref
-      name: ["hogeta", "fuga", "pokota"]
-Pref:
-  Pref: 
-    loop: 3
-    col:
-      name: ["Hokkaido", "Aomori", "Iwate"]
-
-Member1:
-  Member:
-    template: pref_template
-  
-Member2:
-  Member:
-    template: pref_template
-    col:
-      name: ["hogeta2", "fuga2", "pokota2"]
 ```
 
-#### Return 
-You can set return val by return' key.
-
-```yml
-Default:
-  Pref: 
-    loop: 3
-    col:
-      name: ["Hokkaido", "Aomori", "Iwate"]
-
-return': <maked[:Default][:Pref][:name]>
-
-```
+and write following ruby code in seeds.rb.
 
 ```ruby
- return_val = Pokotarou.execute("filepath")
- puts return_val
-```
-
-result
-```
-Hokkaido
-Aomori
-Iwate
+Pokotarou.execute("./db/pref_data.yml")
 ```
-#### Args
 
-You can set args by hash.
+and execute following command!!!!!  
 
-```yml
-Default:
-  Pref: 
-    loop: 3
-    col:
-      name: <args[:name]>
-```
-```ruby
-  Pokotarou.set_args({ name:  ["Hokkaido", "Aomori", "Iwate"] })
-  Pokotarou.execute("filepath")
+```bash
+$ rails db:seed
 ```
 
-### Convert
-convert is a convenient function. Will convert the seed data.
-
-#### convert option
-
-|convert   |description                               |
-|:---------|------------------------------------------|
-| empty    | convert val to empty                     |
-| nil      | convert val to nil                       |
-| big_text | convert val to big_text("text" * 50)     |
-| br_text  | convert val to br_text("text\n" * 5)     |
-
-For example, following configfile register seed data while replacing with nil
-
-```yml
-Default:
-  Pref: 
-    loop: 3
-    col:
-      name: ["Hokkaido", "Aomori", "Iwate"]
-    convert:
-      name: ["nil(0..2)"]
-```
+prefecture data is registerd your db.
+Let's check with the following code.
 
 ```ruby
-[nil, nil, nil]
+# You have to get 3
+Pref.all.count => 3
 ```
 
-a little complex version
+## Documentaion
+You can read a lot more about Pokotarou in its [official docs](https://kashiwara0205.github.io/PokotarouDocs/)
 
-```yml
-Default:
-  Pref: 
-    loop: 3
-    col:
-      name: ["Hokkaido", "Aomori", "Iwate"]
-    convert:
-      name: ["empty(0..0)", "nil(1..2)"]
-```
-
-```ruby
-["", nil, nil]
-```
+## License
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/lib/pokotarou.rb

@@ -1,6 +1,7 @@
 Dir[File.expand_path('../pokotarou', __FILE__) << '/*.rb'].each do |file|
   require file
 end
+
 require "activerecord-import"
 
 module Pokotarou
@@ -10,10 +11,35 @@ module Pokotarou
     def execute input
       # if input is filepath, generate config_data
       if input.kind_of?(String)
-        DataRegister.regist(gen_config(input))
+        DataRegister.register(gen_config(input))
       else
-        DataRegister.regist(input)
+        DataRegister.register(input)
+      end
+    end
+
+    def pipleine_execute input_arr
+      return_vals = []
+      input_arr.each do |e|
+        handler = gen_handler_with_cache(e[:filepath])
+
+        if e[:change_data].present?
+          e[:change_data].each do |block, config|
+            config.each do |model, seed|
+              seed.each do |col_name, val|         
+                handler.change_seed(block, model, col_name, val)
+              end
+            end
+          end
+        end
+        
+        e[:args] ||= {}
+        e[:args][:passed_return_val] = return_vals.last
+        set_args(e[:args])
+
+        return_vals << Pokotarou.execute(handler.get_data())
       end
+
+      return_vals
     end
 
     def import filepath
@@ -27,12 +53,20 @@ module Pokotarou
     def reset
       AdditionalMethods.remove()
       Arguments.remove()
+      @handler_chache = {}
     end
 
     def gen_handler filepath
       PokotarouHandler.new(gen_config(filepath))
     end
 
+    def gen_handler_with_cache filepath
+      @handler_cache ||= {}
+      @handler_cache[filepath] ||= PokotarouHandler.new(gen_config(filepath))
+
+      @handler_cache[filepath].deep_dup
+    end
+
     private
 
     def gen_config filepath

data/lib/pokotarou/data_register.rb

@@ -1,58 +1,112 @@
 class RegistError < StandardError; end
+class SettingError < StandardError; end
 class SeedError < StandardError; end
 
 class DataRegister
   class << self
-    def regist data
+    def register data
       # init maked to accumulate maded data
-      maked = Hash.new
+      maked = {}
+      maked_col = {}
       # init model_data to cache data of model
-      model_cache = Hash.new
+      model_cache = {}
       ActiveRecord::Base.transaction do
         begin
           data.each do |sym_block, model_data|
             next if is_dush?(sym_block.to_s)
-            regist_models(sym_block, model_data, maked, model_cache)
+            setting_register_val_for_bulk(sym_block, model_data, maked, model_cache, maked_col)
           end
         rescue => e
           raise StandardError.new("#{e.message}")
         end
       end
 
-      ReturnExpressionParser.parse(data[:"return'"], maked) 
+      ReturnExpressionParser.parse(data[:"return'"], maked, maked_col)
     end
 
     private
 
-    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
+    Commented because the influence range was large
+    Used in later versions
+
+    def merge_block data
+      bulk_hash = {}
+      data.each do |block, val|
+        next if is_dush?(block.to_s)
+        val.each do |model, config|
+          if bulk_hash[model].nil?
+            bulk_hash[model] = config
+          else
+            merge_loop(model, config, bulk_hash) if config[:loop].present?
+            merge_seed_data(model, config, bulk_hash) if config[:col].present?
+          end
+        end
+      end
+
+      bulk_hash
+    end
+=end
+
+    def merge_loop model, config, bulk_hash
+      bulk_hash[model][:loop] += config[:loop]
+    end
+
+    def merge_seed_data model, config, bulk_hash
+      config[:col].each do |col_name, seed|
+        bulk_hash[model][:col][col_name].concat(seed)
+      end
+    end
+
+    def setting_register_val_for_bulk sym_block, model_data, maked, model_cache, maked_col
+      begin
+        model_data.each do |e|
+          str_model = e.first.to_s
+          save_model_cache(model_cache, str_model)
+
+          model = model_cache[str_model][:model]
+          sym_model = model_cache[str_model][:sym_model]
+
+          # model_data.values is config_data
+          config_data = e.second
+          # set expand expression for loop '<>' and ':' and so on...
+          set_loop_expand_expression(config_data, maked, maked_col)
+          # 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]...]
+          set_seed_arr(model, sym_block, sym_model, config_data, maked, maked_col)
+
+          output_log(config_data[:log])
+          register_by_bulk(sym_block, str_model, config_data ,model_cache)
+        end
+      rescue => e
+        raise SettingError.new("
+          Failed setting for bulk insert...
+
+          block: #{sym_block}
+          model: #{str_model}
+          message: #{e.message}
+        ")
+      end
+    end
+
+    def register_by_bulk sym_block, str_model, config_data, model_cache
+      # col_arr: [:col1, :col2, :col3]
+      col_arr = config_data[:col].keys
+      # seed_arr: [[elem1, elem2, elem3...]]
+      seed_arr = config_data[:col].map{|_, val| val }.transpose
+
         begin
-          model_cache[str_model][:model].import(col_arr, seed_arr.transpose, validate: config_data[:validate], timestamps: false)
+          model_cache[str_model][:model].import(col_arr, seed_arr, validate: config_data[:validate], timestamps: false)
         rescue => e
           raise RegistError.new("
+            Failed bulk insert...
+
             block: #{sym_block}
             model: #{str_model}
             message: #{e.message}
           ")
         end
-      end
     end
 
     def save_model_cache model_cache, str_model
@@ -74,23 +128,30 @@ class DataRegister
         # if there is data already, skip
         next if config_data[:col][key].present?
 
-        config_data[:col][key] = Seeder.gen(config_data, key) 
+        config_data[:col][key] = Seeder.gen(config_data, key)
       end
     end
-    
-    def get_seed_arr model, sym_block, sym_model, config_data, maked
+
+    def set_seed_arr model, sym_block, sym_model, config_data, maked, maked_col
       options = config_data[:option]
       convert_conf = config_data[:convert]
       loop_size = config_data[:loop]
 
       if apply_autoincrement?(config_data[:autoincrement])
-        set_autoincrement(config_data, model, loop_size)
+        prev_id_arr =
+          if maked_col[sym_model].present? && maked_col[sym_model].has_key?(:id)
+            maked_col[sym_model][:id]
+          else
+            []
+          end
+
+        set_autoincrement(config_data, model, loop_size, prev_id_arr)
       end
 
-      config_data[:col].map do |key, val|
-        begin 
+      config_data[:col].each do |key, val|
+        begin
           # set expand expression '<>' and ':' and so on...
-          set_expand_expression(config_data, key, val, maked)
+          set_expand_expression(config_data, key, val, maked, maked_col)
           expanded_val = config_data[:col][key]
           expanded_val_size = expanded_val.size
 
@@ -104,7 +165,7 @@ class DataRegister
 
           # Take count yourself, because .with_index is slow
           cnt = 0
-          seeds = 
+          seeds =
             loop_size.times.map do
               seed =
                 option_conf.nil? ? get_seed(expanded_val, expanded_val_size, cnt) : get_seed_with_option(expanded_val, expanded_val_size, option_conf, cnt)
@@ -112,11 +173,13 @@ class DataRegister
 
               seed
             end
-          update_maked_data(maked, sym_block, sym_model, key, seeds)
 
-          seeds
+          update_maked_data(maked, sym_block, sym_model, key, seeds )
+          update_maked_col(maked_col, sym_model, key, config_data[:col][key])
+          config_data[:col][key] = seeds
         rescue => e
           raise SeedError.new("
+            Failed generate seed data...
             block: #{sym_block}
             model: #{sym_model}
             column: #{key}
@@ -132,25 +195,32 @@ class DataRegister
       autoincrement_flg
     end
 
-    def set_autoincrement config_data, model, loop_size
+    def set_autoincrement config_data, model, loop_size, prev_id_arr
       last_record = model.last
-      # if id is nothing, get 0
-      current_id = last_record.nil? ? 0 : last_record.id
+      current_id =
+        if prev_id_arr.present?
+          prev_id_arr.last
+        elsif last_record.nil?
+          0
+        else
+          last_record.id
+        end
+
       additions = current_id + loop_size
       next_id = current_id + 1
 
       config_data[:col][:id] = [*next_id..additions]
     end
 
-    def set_expand_expression config_data, key, val, maked
+    def set_expand_expression config_data, key, val, maked, maked_col
       # if it exists type, there is no need for doing 'expand expression'
       return if config_data[:type][key].present?
-      config_data[:col][key] = SeedExpressionParser.parse(val, maked)
+      config_data[:col][key] = SeedExpressionParser.parse(val, maked, maked_col)
     end
 
-    def set_loop_expand_expression config_data, maked
-      config_data[:loop] = 
-        LoopExpressionParser.parse(config_data[:loop], maked)  
+    def set_loop_expand_expression config_data, maked, maked_col
+      config_data[:loop] =
+        LoopExpressionParser.parse(config_data[:loop], maked, maked_col)
     end
 
     def get_seed arr, size, cnt
@@ -163,11 +233,19 @@ class DataRegister
 
     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] ||= {}
+      maked[sym_block][sym_model] ||= {}
       maked[sym_block][sym_model][col] = seed
     end
 
+    def update_maked_col maked_col, sym_model, column, vals
+      maked_col[sym_model] ||= {}
+      maked_col[sym_model][column] ||= []
+      maked_col[sym_model][column].concat(vals)
+
+      maked_col
+    end
+
     def output_log log
       return if log.nil?
       puts log

data/lib/pokotarou/data_structure.rb

@@ -4,7 +4,7 @@ class DataStructure
       execute_template_option_setting(data)
       # return data structure bellow
       # [{ block_name => { model_name => { column_configration }}}, ...]
-      data.reduce(Hash.new) do |acc, r|
+      data.reduce({}) do |acc, r|
         if is_dush?(r.first.to_s)
           acc[r.first] = r.second
         else
@@ -46,7 +46,7 @@ class DataStructure
     def deep_overwrite from_hash, to_hash
       from_hash.each do |key, val|
         if val.kind_of?(Hash)
-          to_hash[key] ||= Hash.new
+          to_hash[key] ||= {}
           deep_overwrite(val, to_hash[key])
         else
           to_hash[key] = val
@@ -88,7 +88,7 @@ class DataStructure
     end
 
     def gen_structure model_data
-      model_data.reduce(Hash.new) do |acc, r|
+      model_data.reduce({}) 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
@@ -101,7 +101,7 @@ class DataStructure
       model = eval(str_model)
       foreign_key_data = get_foreign_key_data(model)
 
-      config_data[:col] ||= Hash.new
+      config_data[:col] ||= {}
       model.columns.each do |e|
         symbol_col_name = e.name.to_sym
 
@@ -111,20 +111,22 @@ class DataStructure
           config_data[:col][symbol_col_name] = nil
 
           # set type info
-          config_data[:type] ||= Hash.new
+          config_data[:type] ||= {}
           config_data[:type][symbol_col_name] = e.type.to_s
 
           # set enum info
-          config_data[:enum] ||= Hash.new
+          config_data[:enum] ||= {}
           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]
+            # delete type val for don't run default seeder
+            config_data[:type].delete(symbol_col_name)
+            # use F function for set foreign key
+            config_data[:col][symbol_col_name] = "F|#{foreign_key_data[symbol_col_name].to_s}"
           end
         end
 
@@ -134,7 +136,7 @@ class DataStructure
     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|
+      associations.reduce({})do |acc, r|
         model = r.name.to_s.camelize
         if Object.const_defined?(model.to_sym)
           acc[r.foreign_key.to_sym] = eval(model)

data/lib/pokotarou/expression_parser.rb

@@ -3,23 +3,29 @@ require "pokotarou/additional_variables/additional_variables.rb"
 require "pokotarou/arguments/arguments.rb"
 class ParseError < StandardError; end
 FOREIGN_KEY_SYMBOL = "F|"
+COLUMN_SYMBOL = "C|"
 
 class ExpressionParser
   class << self
-    def parse config_val, maked = nil
+    def parse config_val, maked = nil, maked_col = nil
       begin
         case
+
         # Array
         when is_array?(config_val)
           array_procees(config_val)
 
         # ForeignKey
         when is_foreign_key?(config_val)
-          foreign_key_process(config_val)
+          foreign_key_process(config_val, maked_col)
+
+        # Column
+        when is_column_symbol?(config_val)
+          column_symbol_process(config_val, maked_col)
 
         # Expression
         when is_expression?(config_val)
-          expression_process(config_val, maked)
+          expression_process(config_val, maked, maked_col)
 
         # Integer
         when is_integer?(config_val)
@@ -43,20 +49,28 @@ class ExpressionParser
       return val
     end
 
-    def foreign_key_process val
+    def foreign_key_process val, maked_col
       # remove 'F|'
       str_model = val.sub(FOREIGN_KEY_SYMBOL, "")
       model = eval(str_model)
       return model.pluck(:id)
     end
 
-    def expression_process val, maked
+    def column_symbol_process val, maked_col
+      # remove 'C|'
+      str_model, column = val.sub(COLUMN_SYMBOL, "").split("|")
+      model = eval(str_model)
+      elemnts = model.pluck(column.to_sym)
+      return elemnts.concat(maked_col[str_model.to_sym][column.to_sym])
+    end
+
+    def expression_process val, maked, maked_col
       # remove '<>'
       expression = val.strip[1..-2]
       require AdditionalVariables.filepath if AdditionalVariables.const.present?
       require AdditionalMethods.filepath if AdditionalMethods.filepath.present?
       require Arguments.filepath if Arguments.filepath.present?
-      return self.parse(eval(expression), maked)
+      return self.parse(eval(expression), maked, maked_col)
     end
 
     def integer_process val
@@ -100,6 +114,20 @@ class ReturnExpressionParser < ExpressionParser
     def output_error e
       ParseError.new("Failed Const Expression parse:#{e.message}")
     end
+
+    def foreign_key_process val, _
+      # remove 'F|'
+      str_model = val.sub(FOREIGN_KEY_SYMBOL, "")
+      model = eval(str_model)
+      return model.pluck(:id)
+    end
+
+    def column_symbol_process val, _
+      # remove 'C|'
+      str_model, column = val.sub(COLUMN_SYMBOL, "").split("|")
+      model = eval(str_model)
+      return model.pluck(column.to_sym)
+    end
   end
 end
 
@@ -111,7 +139,7 @@ class LoopExpressionParser < ExpressionParser
       val.size
     end
 
-    def foreign_key_process val
+    def foreign_key_process val, maked_col
       # remove 'F|'
       str_model = val.sub(FOREIGN_KEY_SYMBOL, "")
       model = eval(str_model)
@@ -136,7 +164,7 @@ end
 class ConstExpressionParser < ExpressionParser
   class << self
     private
-    def expression_process val, _
+    def expression_process val, _, _
       # remove '<>'
       expression = val.strip[1..-2]
       require AdditionalMethods.filepath if AdditionalMethods.filepath.present?
@@ -155,16 +183,22 @@ class ConstExpressionParser < ExpressionParser
   end
 end
 
-FOREIGN_KEY = /^F\|[A-Z][:A-Za-z0-9]*$/
+FOREIGN_KEY_REGEXP = /^F\|[A-Z][:A-Za-z0-9]*$/
 def is_foreign_key? val
   return false unless val.kind_of?(String)
-  FOREIGN_KEY =~ val
+  FOREIGN_KEY_REGEXP =~ val
+end
+
+COLUMN_REGEXP  = /^C\|[A-Z][:A-Za-z0-9]*\|[a-z][:a-z0-9]*$/
+def is_column_symbol? val
+  return false unless val.kind_of?(String)
+  COLUMN_REGEXP =~ val
 end
 
-EXPRESSION = /^\s*<.*>\s*$/
+EXPRESSION_REGEXP = /^\s*<.*>\s*$/
 def is_expression? val
   return false unless val.kind_of?(String)
-  EXPRESSION =~ val
+  EXPRESSION_REGEXP =~ val
 end
 
 def is_array? val

data/lib/pokotarou/pokotarou_handler.rb

@@ -30,4 +30,8 @@ class PokotarouHandler
   def get_data
     @data
   end
+
+  def set_data data
+    @data = data
+  end
 end

data/lib/pokotarou/seeder.rb

@@ -4,9 +4,7 @@ class Seeder
       n = 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"

data/lib/pokotarou/version.rb

@@ -1,3 +1,3 @@
 module Pokotarou
-  VERSION = '1.1.2'
+  VERSION = '1.1.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pokotarou
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.1.3
 platform: ruby
 authors:
 - Kashiwara
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-07 00:00:00.000000000 Z
+date: 2020-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -84,8 +84,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: This gem is seeder which is very usefull