pokotarou 0.1.3 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ac5ca9e6a97f214d20ea830f738f3b444ab696dd83005d0e469bc7f42f2d7d0
-  data.tar.gz: 8e58ee4c95f0465de660f5c188e9f3b46d3311a4391b0ec1076a855d8d2bb927
+  metadata.gz: '09fe06e78e1bb9689b0bbdd003ad3261dee699ce3f201bdf9174b10b6771f629'
+  data.tar.gz: 14ae8d05a09c850be66328e46172f16aa2bce32dbacc2564802fa41982473c59
 SHA512:
-  metadata.gz: 01761775a3d8204d369de8aab3e7bcc52554e96ba89b1aa164b6c25a11a090f99d90f4c9a37fc0426143c0ff24ee8e409adc8b735ddafca0b8f5ebf35d400c0d
-  data.tar.gz: 608db2c1580ea6151b370e6cb8fb0c97e9f7b902232f6bd73cec988674cb52d7f4e20189092bdc926937d1694307bcae6e03ea825778ab5d37184d8bea0a0aca
+  metadata.gz: e0a6dccec5227439517f6b52ec1da3ca6181bdf4b04e2bee2f6afb4b439d709899fe731332d11ddce677fac9c8a2ed112ec0ac95a9ef1bc2aa5da674e4f4aae0
+  data.tar.gz: f50b5e74b3c0aef027785cec760372ea2ab6df81323950180726d4ebbbaa196b6b2a788eb4e7a5fa2ac3b0e9a94a9f99e3aaac4ee27ae20ac0d7e56f4571cf51

data/README.md

@@ -1,18 +1,20 @@
-![s_PokotarouLogo](https://user-images.githubusercontent.com/52961642/61586183-ef59b580-aba8-11e9-83b0-19eac7339982.png)  
+![s_PokotarouLogo](https://user-images.githubusercontent.com/52961642/62843884-46f6c700-bcf8-11e9-8267-b9fad8f34085.png)
+
+
 [![Gem Version](https://badge.fury.io/rb/pokotarou.svg)](https://badge.fury.io/rb/pokotarou)
-[![Build Status](https://travis-ci.org/Tamatebako0205/Pokotarou.svg?branch=master)](https://travis-ci.org/Tamatebako0205/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' that uses .yml
-Currently only mysql supported
+Pokotarou is convenient seeder of 'Ruby on Rails'
+In MySql, operation has been confirmed
 
 ## Features
 
 ### Easy to use
-Currently can be used only for simple configuration file settings
-You don't have to write a program for seeder
+You don't have to write a program for seed
+Can be set simply by writing a yml file!
 
 ### Fast speed
-If it is the following table, 10,000 records can regist in 0.4s on average
+If it is the following table, 10,000 records can regist in 0.41s on average
 
 |Field|Type|NULL|
 |:---|:---|:---|
@@ -42,20 +44,35 @@ $ gem install pokotarou
 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
+Following yml file become seed data.
+
+Please make following yml file in your favorite dir.
 
+```yml
+Default:
+  Pref:
+    loop: 3
 ```
-Pokotarou.execute(ConfigrationFilePath)
+
+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
 ```
-### Configration file
 
-Introduce how to write yml configuration file
+As a result, seed data is registerd your db.
+
+## How to set configlation file(.yml)?
+explain how to write the configuration file below.
 
-#### Definition for explanation
+### Model used for explanation
 Table name below is 'prefs' and model name is 'Pref'
 
 |Field|Type|NULL|
@@ -79,76 +96,69 @@ Table name below is 'members' and model name is 'Member'
 |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
+### Standerd Setting
+The basic setting method is written below
 
-```
-Default:
-  Pref:
-    loop: 3
-```
+#### Automatic data entry
 
+If there is no definition about col, then automatically prepared data is registrd.
 
-In the following source code, id, created_at, updated_at will be registerd with the prepared data
+For example, in the case of below, it is registered automatically prepared data three times.
 
-```
+```yml
 Default:
   Pref:
     loop: 3
-    col:
-      name: "Hokkaido"
 ```
 
-#### Array
-Array data is registerd one by one
-
-```
+also you can set seed_data by yourself.
+```yml
 Default:
   Pref:
     loop: 3
     col:
-      name: ["Hokkaido", "Aomori", "Iwate"]
+      name: "Hokkaido"
 ```
 
-#### Maked data
-Registration is possible using registerd data
+#### Omitted loop
+If you want to register the test data at once, I suggest ommited loop
 
-```
+```yml
 Default:
-  Pref:
-    loop: 2
-    col:
-      name: ["Hokkaido", "Aomori"]
-  Member:
-    loop: 2
+  Pref: 
     col:
-      name: <maked[:Default][:Pref][:name]>
-      pref_id: F|Pref
+      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"]
-  Member:
-    loop: 3
-    col:
-      name: ["Tarou", "Jirou", "Saburou"]
-      remarks: <maked[:Default][:Member][:name]>
-      pref_id: F|Pref
-
 ```
 
-```
+#### 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: 
+  Pref:
     loop: 2
     col:
       name: ["Hokkaido", "Aomori"]
-Default2:
   Member:
     loop: 2
     col:
@@ -160,10 +170,11 @@ Default2:
 
 **※ 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
+' 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
@@ -176,10 +187,10 @@ Default:
 ```
 
 #### Expression expansion
-What a means is '< >' expression expansion
-You can run ruby code in '< >'
+'< >' means expression expansion.
+You can run ruby code in '< >'.
 
-```
+```yml
 Default:
   Pref:
     loop: 3
@@ -188,10 +199,10 @@ Default:
       created_at: <Date.parse('1997/02/05')>
 ```
 
-#### Add method
+#### Additional method
 You can add method and use it in pokotarou
 
-```
+```yml
 Default:
   Pref:
     loop: 3
@@ -200,24 +211,27 @@ Default:
 ```
 
 Prepare the following ruby file
-```
+
+```ruby
 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)
+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.
 
-#### Use multiple blocks
+#### Multiple blocks
 
-Registration is possible using two blocks
+You can use multiple blocks.
 
-```
+```yml
 Default:
   Pref:
     loop: 3
@@ -228,7 +242,7 @@ Default2:
 
 and, You can change the name of the block
 
-```
+```yml
 Hoge:
   Pref:
     loop: 3
@@ -237,11 +251,14 @@ Fuga:
     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
@@ -253,14 +270,14 @@ Default:
 
 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
@@ -270,14 +287,14 @@ Default:
       name: ["add_id"]
 ```
 
-```
+```ruby
 ["Hokkaido_0", "Aomori"_1, "Iwate_2"]
 ```
 
 #### Combine serveral options
 Combination of options is possible
 
-```
+```yml
 Default:
   Pref:
     loop: 3
@@ -289,28 +306,31 @@ Default:
 
 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
 ```
 
-#### Autoincrement
+#### Disable Autoincrement
 
 You can disable the autoincrement setting
 
-If you disable the setting, you can register id data prepared by myself
+If you disable the setting, you can register id data prepared by yourself
 
-```
+```yml
 Default:
   Pref:
     loop: 3
@@ -321,59 +341,169 @@ Default:
 
 #### Pokotarou Handler
 
-if you use Pokotarou handler, can update pokotarou's parameter
+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
 
-```
-  handler = Pokotarou.gen_handler("ConfigrationFilePath")
-  # change loop number
+```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, delete class in parameter
 
+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)
 ```
-  handler = Pokotarou.gen_handler("ConfigrationFilePath")
-  # delete class in parameter
-  handler.delete(:Default, :Member)
+
+In the following example, delete model config
+
+```ruby
+  handler = Pokotarou.gen_handler("./config_filepath")
+  # delete model config in parameter
+  handler.delete_model(:Default, :Pref)
   Pokotarou.execute(handler.get_data)
 ```
 
-#### Convert seed 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)
+```
 
-You can convert seed data
+#### Const
+You can set const variables by const' key.
 
+```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"]
-    convert:
-      name: ["nil(0..2)"]
-```
 
-```
-[nil, nil, nil]
+Member1:
+  Member:
+    template: pref_template
+  
+Member2:
+  Member:
+    template: pref_template
+    col:
+      name: ["hogeta2", "fuga2", "pokota2"]
 ```
 
-complex version
+#### Return 
+You can set return val by return' key.
 
-```
+```yml
 Default:
   Pref: 
     loop: 3
     col:
       name: ["Hokkaido", "Aomori", "Iwate"]
-    convert:
-      name: ["empty(0..0)", "nil(1..2)"]
+
+return': <maked[:Default][:Pref][:name]>
+
 ```
 
+```ruby
+ return_val = Pokotarou.execute("filepath")
+ puts return_val
 ```
-["", nil, nil]
+
+result
 ```
+Hokkaido
+Aomori
+Iwate
+```
+#### Args
+
+You can set args by hash.
+
+```yml
+Default:
+  Pref: 
+    loop: 3
+    col:
+      name: <args[:name]>
+```
+```ruby
+  Pokotarou.set_args({ name:  ["Hokkaido", "Aomori", "Iwate"] })
+  Pokotarou.execute("filepath")
+```
+
+### Convert
+convert is a convenient function. Will convert the seed data.
+
+#### convert option
 
 |convert   |description                               |
 |:---------|------------------------------------------|
@@ -381,3 +511,35 @@ Default:
 | 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)"]
+```
+
+```ruby
+[nil, nil, nil]
+```
+
+a little complex version
+
+```yml
+Default:
+  Pref: 
+    loop: 3
+    col:
+      name: ["Hokkaido", "Aomori", "Iwate"]
+    convert:
+      name: ["empty(0..0)", "nil(1..2)"]
+```
+
+```ruby
+["", nil, nil]
+```

data/lib/pokotarou.rb

@@ -20,8 +20,13 @@ module Pokotarou
       AdditionalMethods.import(filepath)
     end
 
+    def set_args hash
+      Arguments.import(hash)
+    end
+
     def reset
       AdditionalMethods.remove()
+      Arguments.remove()
     end
 
     def gen_handler filepath
@@ -32,9 +37,13 @@ module Pokotarou
 
     def gen_config filepath
       contents = load_file(filepath)
+      set_const_val_config(contents)
       DataStructure.gen(contents)
     end
 
+    def set_const_val_config contents
+      AdditionalVariables.import(contents)
+    end
 
     def load_file filepath
       case File.extname(filepath)

data/lib/pokotarou/additional_variables/additional_variables.rb

@@ -0,0 +1,24 @@
+module AdditionalVariables
+  class << self
+    CONST_KEY = :"const'"
+    @const = nil
+    attr_reader :const
+    
+    def import data
+      return unless data.has_key?(CONST_KEY)
+      @const = data[CONST_KEY]
+
+      # parse expression configlation
+      @const.each do |key, val|
+        @const[key] = ConstExpressionParser.parse(val)
+      end
+
+      data.delete(CONST_KEY)
+    end
+
+    def filepath
+      "pokotarou/additional_variables/def_const.rb"
+    end
+
+  end  
+end

data/lib/pokotarou/additional_variables/def_const.rb

@@ -0,0 +1 @@
+def const; AdditionalVariables.const end

data/lib/pokotarou/arguments/arguments.rb

@@ -0,0 +1,23 @@
+class MisMatchArgType < StandardError; end
+module Arguments
+  class << self
+    @args = nil
+    attr_reader :args
+    
+    def import hash_data
+      unless hash_data.kind_of?(Hash)
+        raise MisMatchArgType.new("Please use Hash for args")
+      end
+      @args = hash_data
+    end
+
+    def remove
+      @args = nil
+    end
+
+    def filepath
+      "pokotarou/arguments/def_args.rb"
+    end
+
+  end  
+end

data/lib/pokotarou/arguments/def_args.rb

@@ -0,0 +1 @@
+def args; Arguments.args end

data/lib/pokotarou/data_register.rb

@@ -11,28 +11,19 @@ class DataRegister
       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)
           end
         rescue => e
           raise StandardError.new("#{e.message}")
         end
       end
+
+      ReturnExpressionParser.parse(data[:"return'"], maked) 
     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
@@ -53,9 +44,7 @@ class DataRegister
 
         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)
+          model_cache[str_model][:model].import(col_arr, seed_arr.transpose, validate: config_data[:validate], timestamps: false)
         rescue => e
           raise RegistError.new("
             block: #{sym_block}
@@ -156,7 +145,7 @@ class DataRegister
     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)
+      config_data[:col][key] = SeedExpressionParser.parse(val, maked)
     end
 
     def set_loop_expand_expression config_data, maked
@@ -184,5 +173,10 @@ class DataRegister
       puts log
     end
 
+    DUSH_OPTION = /^.*\'$/
+    def is_dush? val
+      return false unless val.kind_of?(String)
+      DUSH_OPTION =~ val
+    end
   end
 end

data/lib/pokotarou/data_structure.rb

@@ -1,12 +1,15 @@
 class DataStructure
   class << self
     def gen data
+      execute_template_option_setting(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)
+        if is_dush?(r.first.to_s)
+          acc[r.first] = r.second
+        else
+          set_reshape_data_to_acc(acc, r)
+        end
 
         acc
       end
@@ -14,6 +17,75 @@ class DataStructure
 
     private
 
+    def execute_template_option_setting data
+      return unless data.has_key?(:"template'")
+      templates = data[:"template'"]
+      data.delete(:"template'")
+      data.each do |_, val|
+        set_template_option(val, templates)
+      end
+    end
+
+    def set_template_option model_data, templates
+      model_data.each do |key, val|
+        next unless has_template?(val)
+        template_name = val[:template]
+        template = templates[template_name.to_sym]
+        copy_template = template.deep_dup
+        # when a new key is generated, it is added behind
+        # so, overwrite config_data to template first
+
+        # from val to copy_template
+        deep_overwrite(val, copy_template)
+        # update config data
+        model_data[key] = copy_template
+      end
+    end
+
+    def deep_overwrite from_hash, to_hash
+      from_hash.each do |key, val|
+        if val.kind_of?(Hash)
+          to_hash[key] ||= Hash.new
+          deep_overwrite(val, to_hash[key])
+        else
+          to_hash[key] = val
+        end
+      end
+    end
+
+    def set_reshape_data_to_acc acc, r
+      execute_grouping_option_setting(r.second)
+      # r.first is block_name
+      # r.second is model_data, like { Pref: {loop: 3}, Member: {loop: 3}... }
+      acc[r.first] = gen_structure(r.second)
+    end
+
+    def execute_grouping_option_setting model_data
+      model_data.each do |key, val|
+        set_grouping_option(val) if has_grouping?(val)
+      end
+    end
+
+    def set_grouping_option val
+      val[:grouping].each do |grouping_key, cols|
+        apply_grouping_col(:col, val, grouping_key, cols)
+        apply_grouping_col(:option, val, grouping_key, cols)
+        apply_grouping_col(:convert, val, grouping_key, cols)
+      end
+
+      val.delete(:grouping)
+    end
+
+    def apply_grouping_col config_name, val, grouping_key, cols
+      return if val[config_name].blank?
+      return unless val[config_name].has_key?(grouping_key)
+      cols.each do |e|
+        val[config_name][e.to_sym] = val[config_name][grouping_key]
+      end
+    
+      val[config_name].delete(grouping_key)
+    end
+
     def gen_structure model_data
       model_data.reduce(Hash.new) do |acc, r|
         # r.second is config_data, like {loop: 3, ...}
@@ -84,5 +156,20 @@ class DataStructure
       return false unless val.kind_of?(String)
       ENUM =~ val
     end
+
+    DUSH_OPTION = /^.*\'$/
+    def is_dush? val
+      return false unless val.kind_of?(String)
+      DUSH_OPTION =~ val
+    end
+    
+    def has_grouping? config_data
+      return false if config_data.blank?
+      config_data.has_key?(:grouping)
+    end
+
+    def has_template? config_data
+      config_data.has_key?(:template)
+    end
   end
 end

data/lib/pokotarou/expression_parser.rb

@@ -1,75 +1,162 @@
 require "pokotarou/additional_methods.rb"
+require "pokotarou/additional_variables/additional_variables.rb"
+require "pokotarou/arguments/arguments.rb"
 class ParseError < StandardError; end
+FOREIGN_KEY_SYMBOL = "F|"
 
-# for seed data
 class ExpressionParser
   class << self
-    FOREIGN_KEY_SYMBOL = "F|"
-    def parse config_val, maked
+    def parse config_val, maked = nil
       begin
-        require AdditionalMethods.filepath if AdditionalMethods.filepath.present?
         case
-        when config_val.instance_of?(Array)
-          return config_val
+        # Array
+        when is_array?(config_val)
+          array_procees(config_val)
+
+        # ForeignKey
         when is_foreign_key?(config_val)
-          # remove 'F|'
-          str_model = config_val.sub(FOREIGN_KEY_SYMBOL, "")
-          model = eval(str_model)
-          return model.pluck(:id)
+          foreign_key_process(config_val)
+
+        # Expression
         when is_expression?(config_val)
-          # remove '<>'
-          expression = config_val.strip[1..-2]
-          return self.parse(eval(expression), maked)
+          expression_process(config_val, maked)
+
+        # Integer
+        when is_integer?(config_val)
+          integer_process(config_val)
+
+        # Nil
+        when is_nil?(config_val)
+          nil_process(config_val)
+
+        # Other
         else
-          if config_val.instance_of?(String)
-            # escape \\
-            [config_val.tr("\\","")]
-          else
-            [config_val]
-          end
+          nothing_apply_process(config_val)
         end
       rescue => e
-        ParseError.new("Failed Expression parse:#{e.message}")
+        output_error(e)
       end
     end
+
+    private
+    def array_procees val
+      return val
+    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 expression_process val, maked
+      # 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)
+    end
+
+    def integer_process val
+      nothing_apply_process(val)
+    end
+
+    def nil_process val
+      nothing_apply_process(val)
+    end
+
+    def nothing_apply_process val
+      # for escape \\
+      val.instance_of?(String) ? val.tr("\\","") : val
+    end
+
+    def output_error e
+      raise ParseError.new("Failed Expression parse:#{e.message}")
+    end
+  end
+end
+
+# for seed data
+class SeedExpressionParser < ExpressionParser
+  class << self
+    private
+    def nothing_apply_process val
+      # for escape \\
+      val.instance_of?(String) ? [val.tr("\\","")] : [val]
+    end
+
+    def output_error e
+      raise ParseError.new("Failed Seed Expression parse:#{e.message}")
+    end
+  end
+end
+
+# for return variables
+class ReturnExpressionParser < ExpressionParser
+  class << self
+    private
+    def output_error e
+      ParseError.new("Failed Const Expression parse:#{e.message}")
+    end
   end
 end
 
 # for loop data
-class LoopExpressionParser
+class LoopExpressionParser < 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.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
+    private
+    def array_procees val
+      val.size
+    end
+
+    def foreign_key_process val
+      # remove 'F|'
+      str_model = val.sub(FOREIGN_KEY_SYMBOL, "")
+      model = eval(str_model)
+      return model.pluck(:id).size
+    end
+
+    def integer_process val
+      val
+    end
+
+    def nil_process _
+      1
+    end
+
+    def output_error e
+      ParseError.new("Failed Loop Expression parse: #{e.message}")
+    end
+  end
+end
+
+# for const variables
+class ConstExpressionParser < ExpressionParser
+  class << self
+    private
+    def expression_process val, _
+      # remove '<>'
+      expression = val.strip[1..-2]
+      require AdditionalMethods.filepath if AdditionalMethods.filepath.present?
+      require Arguments.filepath if Arguments.filepath.present?
+      return self.parse(eval(expression))
+    end
+
+    def nothing_apply_process val
+      # for escape \\
+      val.instance_of?(String) ? val.tr("\\","") : val
+    end
+
+    def output_error
+      ParseError.new("Failed Const Expression parse: #{e.message}")
     end
   end
 end
 
-FOREIGN_KEY = /^F\|[A-Z][A-Za-z0-9]*$/
-def is_foreign_key? val;
+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
@@ -78,4 +165,16 @@ EXPRESSION = /^\s*<.*>\s*$/
 def is_expression? val
   return false unless val.kind_of?(String)
   EXPRESSION =~ val
+end
+
+def is_array? val
+  val.instance_of?(Array)
+end
+
+def is_integer? val
+  val.instance_of?(Integer)
+end
+
+def is_nil? val
+  val.nil?
 end

data/lib/pokotarou/pokotarou_handler.rb

@@ -23,7 +23,7 @@ class PokotarouHandler
     @data[sym_block][sym_class][:loop] = n
   end
 
-  def change_col sym_block, sym_class, sym_col, arr
+  def change_seed sym_block, sym_class, sym_col, arr
     @data[sym_block][sym_class][:col][sym_col] = arr
   end
 

data/lib/pokotarou/seeder.rb

@@ -13,7 +13,7 @@ class Seeder
       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_array(n, ->(){ [true, false].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

data/lib/pokotarou/version.rb

@@ -1,3 +1,3 @@
 module Pokotarou
-  VERSION = '0.1.3'
+  VERSION = '1.1.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pokotarou
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 1.1.1
 platform: ruby
 authors:
 - Kashiwara
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-10 00:00:00.000000000 Z
+date: 2019-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -38,7 +38,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.00'
-description: 'Pokotarou is convenient seeder of ''Ruby on Rails'' URL: https://github.com/Tamatebako0205/Pokotarou'
+description: Pokotarou is convenient seeder of 'Ruby on Rails'
 email:
 - tamatebako0205@gmail.com
 executables: []
@@ -50,15 +50,18 @@ files:
 - Rakefile
 - lib/pokotarou.rb
 - lib/pokotarou/additional_methods.rb
+- lib/pokotarou/additional_variables/additional_variables.rb
+- lib/pokotarou/additional_variables/def_const.rb
+- lib/pokotarou/arguments/arguments.rb
+- lib/pokotarou/arguments/def_args.rb
 - lib/pokotarou/array_operation.rb
 - lib/pokotarou/converter.rb
 - lib/pokotarou/data_register.rb
 - lib/pokotarou/data_structure.rb
 - lib/pokotarou/expression_parser.rb
-- lib/pokotarou/loader.rb
+- lib/pokotarou/file_loader.rb
 - lib/pokotarou/option.rb
 - lib/pokotarou/pokotarou_handler.rb
-- lib/pokotarou/query_builder.rb
 - lib/pokotarou/seeder.rb
 - lib/pokotarou/version.rb
 - lib/tasks/pokotarou_tasks.rake

data/lib/pokotarou/query_builder.rb

@@ -1,43 +0,0 @@
-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