pokotarou 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ca710c0922d3f1b4f41cb3158af2fe2fa81b927dcc742906a6de0b39eec160b
-  data.tar.gz: c93a9880f9bbc1df8faee6e9da83515907820da3e469b2147a72b9c67c8dfec7
+  metadata.gz: 2e36d9755f7ed2c3f0a2e723405f6a633b1f3d5034c9ba1823441ab1cf0fb01d
+  data.tar.gz: c7b5467264f7d06f79361b00277e752345ce14c0879fbceeb2752b5cd7b0eb6e
 SHA512:
-  metadata.gz: fb8b4c6439d927c2c27a1b58e1e2c254570439e6bd06811cae431e8a3a3e672cf3e6186e7bb7f7c3529f538beb773e52a3fbcd47430c7f9b3347ba943a9d56dc
-  data.tar.gz: e54083be7a8bc6145cf9760109ffb26a467ee4220aecf58398e84fd133daa610008518c96de6d1a45f67cab02b6d3568865edc3c53eeb14f624a06dc3c65f88b
+  metadata.gz: 1cf01f158f6f73f494009bdcb930e2c12d6ee47ed9c017ff2408c04ae744aa605e388ee2843fbee493cd5a0b0847d0d66b63fe53887279fd5d1b6c2618cbb4d4
+  data.tar.gz: 69c4b0079556d2060d42c2c1a9f53e1fe7d65f95e107ce488c56dde6d278893b1d074f81883423e0b01300d2640db30abbd5bc9574b72fd6127d7258763fbcd5

data/README.md

@@ -45,7 +45,9 @@ The gem is available as open source under the terms of the [MIT License](http://
 
 ## Usage
 
-Set following configration_file in somewhere.
+Following yml file become seed data.
+
+Please make following yml file in your favorite dir.
 
 ```yml
 Default:
@@ -53,25 +55,24 @@ Default:
     loop: 3
 ```
 
-execute the following ruby code in seeds.rb.
+and write following ruby code in seeds.rb.
 
 ```ruby
 Pokotarou.execute("./config_filepath")
 ```
 
-run rails db:seed
+when you finished writing, then run rails db:seed
 
 ```bash
 $ rails db:seed
 ```
 
-finish
-
-### Configration file
+As a result, seed data is registerd your db.
 
-Introduce how to write config file
+## How to set configlation file(.yml)?
+explain how to write the configuration file below.
 
-#### Model used for explanation
+### Model used for explanation
 Table name below is 'prefs' and model name is 'Pref'
 
 |Field|Type|NULL|
@@ -95,12 +96,14 @@ Table name below is 'members' and model name is 'Member'
 |updated_at|datetime|NO|
 
 
-#### Basic
-If there is no column definition, prepared data is registerd.
+### Standerd Setting
+The basic setting method is written below
 
-Registered 3 times in the following cases.
+#### Automatic data entry
 
-and id column is basically registerd by autoincrement.
+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:
@@ -108,8 +111,7 @@ Default:
     loop: 3
 ```
 
-Also you can set seed_data by yourself.
-
+also you can set seed_data by yourself.
 ```yml
 Default:
   Pref:
@@ -118,40 +120,24 @@ Default:
       name: "Hokkaido"
 ```
 
-#### Array
-You can set array_data.
-
-Array data is registerd one by one.
+#### Omitted loop
+If you want to register the test data at once, I suggest ommited loop
 
 ```yml
 Default:
-  Pref:
-    loop: 3
+  Pref: 
     col:
-      name: ["Hokkaido", "Aomori", "Iwate"]
+      name: ["Hokkaido"]
 ```
 
-#### Maked data
-'maked' is very useful function.
-
-Registration is possible using registerd data
-
-Use maked in different model area in the following cases.
-
-```yml
-Default:
-  Pref:
-    loop: 2
-    col:
-      name: ["Hokkaido", "Aomori"]
-  Member:
-    loop: 2
-    col:
-      name: <maked[:Default][:Pref][:name]>
-      pref_id: F|Pref
+```ruby
+["Hokkaido"]
 ```
 
-Use maked in same model area in the following cases.
+#### Array
+You can set array_data.
+
+Array data is registerd one by one.
 
 ```yml
 Default:
@@ -159,24 +145,20 @@ Default:
     loop: 3
     col:
       name: ["Hokkaido", "Aomori", "Iwate"]
-  Member:
-    loop: 3
-    col:
-      name: ["Tarou", "Jirou", "Saburou"]
-      remarks: <maked[:Default][:Member][:name]>
-      pref_id: F|Pref
-
 ```
 
-Use maked in diffrent block area in the following cases.
+#### 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:
@@ -188,9 +170,9 @@ Default2:
 
 **※ If you set association(belongs_to, has_many...), Pokotarou automatically register foreign keys**
 
-' F| ' means foreign key.
+' F| ' means foreign key. 'F|' is Model.all.pluck(:id)
 
-In the following source code, id of Pref is registerd with Member
+For example, in the case of below, Member model record is registerd with pref_id(foregin key).
 
 ```yml
 Default:
@@ -205,9 +187,8 @@ Default:
 ```
 
 #### Expression expansion
-'< >' means expression expansion
-
-You can run ruby code in '< >'
+'< >' means expression expansion.
+You can run ruby code in '< >'.
 
 ```yml
 Default:
@@ -218,7 +199,7 @@ Default:
       created_at: <Date.parse('1997/02/05')>
 ```
 
-#### Add method
+#### Additional method
 You can add method and use it in pokotarou
 
 ```yml
@@ -237,17 +218,18 @@ def pref_name
 end
 ```
 
-and execute the following source code in seeds.rb.
+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:
@@ -269,6 +251,10 @@ 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
 
@@ -324,6 +310,9 @@ The following results change from run to run
 ["Hokkaido_0", "Iwate_1", "Hokkaido_2"]
 ```
 
+### Advanced Setting
+The advanced setting method is written below
+
 #### Validation
 
 Run validation when regist
@@ -352,7 +341,10 @@ 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>
@@ -405,9 +397,113 @@ In the following example, delete col config
   Pokotarou.execute(handler.get_data)
 ```
 
-#### 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"]
+
+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]>
+
+```
+
+```ruby
+ return_val = Pokotarou.execute("filepath")
+ puts return_val
+```
+
+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")
+```
 
-You can convert seed data
+### Convert
+convert is a convenient function. Will convert the seed data.
+
+#### convert option
 
 |convert   |description                               |
 |:---------|------------------------------------------|
@@ -432,7 +528,7 @@ Default:
 [nil, nil, nil]
 ```
 
-complex version
+a little complex version
 
 ```yml
 Default:
@@ -446,18 +542,4 @@ Default:
 
 ```ruby
 ["", nil, nil]
-```
-
-#### Omitted loop
-If you want to register the test data at once, I suggest ommited loop
-
-```yml
-Default:
-  Pref: 
-    col:
-      name: ["Hokkaido"]
-```
-
-```ruby
-["Hokkaido"]
 ```

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,12 +11,15 @@ 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
@@ -142,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
@@ -170,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,69 @@ 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]
+        apply_template_option(val, template)
+      end
+    end
+
+    def apply_template_option config_data, template
+      template.each do |key, val|
+        if val.kind_of?(Hash)
+          config_data[key] ||= Hash.new
+          apply_template_option(config_data[key], val)
+        else
+
+          config_data[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 +150,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,74 +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
-    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
-    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;
+def is_foreign_key? val
   return false unless val.kind_of?(String)
   FOREIGN_KEY =~ val
 end
@@ -77,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/version.rb

@@ -1,3 +1,3 @@
 module Pokotarou
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end

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)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pokotarou
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Kashiwara
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-07 00:00:00.000000000 Z
+date: 2019-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -50,6 +50,10 @@ 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