pokotarou 1.2.0 → 1.2.1

data/lib/pokotarou/registration_config_updater/option_config.rb

@@ -0,0 +1,53 @@
+require "pokotarou/registration_config_updater/array_utils.rb"
+module Pokotarou
+  module RegistrationConfigUpdater
+    class OptionConfig
+      class << self
+  
+        include ArrayUtils
+  
+        def fetch option_hash, key
+          # shape option data
+          # [option1, option2] => { select: [option2], add: [option1] }
+          # [] => { select: [], add: [] }
+          return nil if option_hash.nil?
+          option = option_hash[key]
+          return option.nil? ? { select: [], add: [] } : separate(option)
+        end
+  
+        def execute arr, size, option_conf, cnt = 0
+          selected_val = select(option_conf[:select], arr, size, cnt)
+  
+          add(option_conf[:add], selected_val, cnt)
+        end
+  
+        private
+  
+        def separate option
+          # separate option to 'select' and 'add'
+          # { select = >[], add => [] }
+          {
+            select: option.find{|f| ["rotate", "random"].include?(f)},
+            add: option.find{|f| ["add_id", "sequence"].include?(f) }
+          }
+        end
+  
+        def select option, arr, size, cnt
+          return arr.sample if option == "random"
+  
+          # default return rotate
+          get_rotated_val(arr, size, cnt)
+        end
+  
+        def add option, val, cnt
+          # if val is nil, return nil
+          return nil if val.nil?
+          # not use '<<' to avoid destructive effect
+          return "#{val}_#{cnt}" if option == "add_id" || option == "sequence"
+  
+          val
+        end
+      end
+    end
+  end
+end

data/lib/pokotarou/seed_data_register/main.rb

@@ -0,0 +1,81 @@
+require "pokotarou/additional_variables/main.rb"
+require "pokotarou/registration_config_updater/main.rb"
+
+module Pokotarou
+  module SeedDataRegister
+    class Main
+      class RegisterError < StandardError; end
+      class SeedError < StandardError; end
+  
+      class << self
+        def register data
+          # init maked to accumulate maded data
+          maked = Hash.new { |h,k| h[k] = Hash.new(&h.default_proc) }
+          maked_col = Hash.new { |h,k| h[k] = {} }
+          # init model_data to cache data of model
+          model_cache = {}
+          ActiveRecord::Base.transaction do
+            begin
+              data.each do |sym_block, model_data|
+                next if is_dush?(sym_block.to_s)
+                register_val_by_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, maked_col)
+        end
+      
+        private
+      
+        def register_val_by_bulk block_name_sym, model_data, maked, model_cache, maked_col
+          model_data.each do |e|
+            begin
+              ::Pokotarou::RegistrationConfigUpdater::Main.update(e, block_name_sym, model_cache, maked, maked_col)
+              model_name = e.first.to_s
+              model_config = e.second
+              output_log(model_config[:log])
+              insert_record(block_name_sym, model_name, model_config ,model_cache)
+            rescue => e
+              print "\e[31m"
+              puts "[Pokotarou ERROR]"
+              puts "+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+"
+              puts "Failed Register record"
+              puts "BLOCK: #{block_name_sym}"
+              puts "MODEL: #{model_name}"
+              puts "MESSAGE: #{e.message}"
+              puts "+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+"
+              print "\e[0m"
+              puts ""
+      
+              raise RegisterError.new
+            end
+          end
+        end
+      
+        def insert_record 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
+          validate = config_data[:validate].nil? ? false : config_data[:validate]
+      
+          model_cache[str_model][:model].import(col_arr, seed_arr, validate: validate, timestamps: false)
+        end
+  
+        def output_log log
+          return if log.nil?
+          puts log
+        end
+      
+        DUSH_OPTION = /^.*\'$/
+        def is_dush? val
+          return false unless val.kind_of?(String)
+          DUSH_OPTION =~ val
+        end
+      end
+    end
+  end
+end

data/lib/pokotarou/version.rb

@@ -1,3 +1,3 @@
 module Pokotarou
-  VERSION = '1.2.0'
+  VERSION = '1.2.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pokotarou
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Kashiwara
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-13 00:00:00.000000000 Z
+date: 2020-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -49,20 +49,29 @@ files:
 - README.md
 - Rakefile
 - lib/pokotarou.rb
-- lib/pokotarou/additional_methods.rb
-- lib/pokotarou/additional_variables/additional_variables.rb
-- lib/pokotarou/additional_variables/def_variable.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/file_loader.rb
-- lib/pokotarou/option.rb
+- lib/pokotarou/additional_arguments/main.rb
+- lib/pokotarou/additional_methods/main.rb
+- lib/pokotarou/additional_variables/main.rb
 - lib/pokotarou/p_tool.rb
-- lib/pokotarou/seeder.rb
+- lib/pokotarou/parser/const_parser.rb
+- lib/pokotarou/parser/loop_expression_parser.rb
+- lib/pokotarou/parser/parser.rb
+- lib/pokotarou/parser/parser_domain.rb
+- lib/pokotarou/parser/return_expression_parser..rb
+- lib/pokotarou/parser/seed_data_expression_parser.rb
+- lib/pokotarou/registration_config_maker/column_domain.rb
+- lib/pokotarou/registration_config_maker/config_domain.rb
+- lib/pokotarou/registration_config_maker/grouping_option_setter.rb
+- lib/pokotarou/registration_config_maker/import_option_setter.rb
+- lib/pokotarou/registration_config_maker/main.rb
+- lib/pokotarou/registration_config_maker/model_option_setter.rb
+- lib/pokotarou/registration_config_maker/template_option_setter.rb
+- lib/pokotarou/registration_config_updater/array_utils.rb
+- lib/pokotarou/registration_config_updater/convert_config.rb
+- lib/pokotarou/registration_config_updater/default_value_maker.rb
+- lib/pokotarou/registration_config_updater/main.rb
+- lib/pokotarou/registration_config_updater/option_config.rb
+- lib/pokotarou/seed_data_register/main.rb
 - lib/pokotarou/version.rb
 - lib/tasks/pokotarou_tasks.rake
 homepage: https://github.com/Kashiwara0205/Pokotarou

data/lib/pokotarou/additional_methods.rb

@@ -1,40 +0,0 @@
-module AdditionalMethods
-  class << self
-    attr_reader :filepathes
-    attr_reader :filepathes_from_yml
-
-    @filepathes = []
-    @filepathes_from_yml = []
-
-    def init
-      @filepathes ||= []
-      @filepathes_from_yml = []
-    end
-
-    def import filepath
-      add(@filepathes, filepath)
-    end
-
-    def import_from_yml filepath
-      add(@filepathes_from_yml, filepath)
-    end
-
-    def remove
-      @filepathes = []
-      @filepathes_from_yml = []
-    end
-
-    def remove_filepathes_from_yml
-      @filepathes_from_yml = []
-    end
-
-    private
-    def add filepath_arr, filepath
-      if filepath.instance_of?(Array)
-        filepath_arr.concat(filepath)
-      else
-        filepath_arr.push(filepath)
-      end
-    end
-  end
-end

data/lib/pokotarou/additional_variables/additional_variables.rb

@@ -1,33 +0,0 @@
-module AdditionalVariables
-  class << self
-    CONST_KEY = :"const'"
-    @const = {}
-    attr_reader :const
-
-    def set_const data
-      set_const_variables(data)
-    end
-
-    def remove
-      @const = {}
-    end
-
-    def filepath
-      "pokotarou/additional_variables/def_variable.rb"
-    end
-
-    private 
-    def set_const_variables data
-      return {} unless data.has_key?(CONST_KEY)
-      @const = data[CONST_KEY]
-
-      # parse expression configlation
-      @const.each do |key, val|
-        @const[key] = ConstParser.parse(val)
-      end
-
-      data.delete(CONST_KEY)
-    end
-
-  end  
-end

data/lib/pokotarou/additional_variables/def_variable.rb

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

data/lib/pokotarou/arguments/arguments.rb

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

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

data/lib/pokotarou/array_operation.rb

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

data/lib/pokotarou/converter.rb

@@ -1,23 +0,0 @@
-class Converter 
-  class << self
-    PARENTHESES = /\(.*\)/
-    def convert arr, config
-      return arr if config.nil?
-      config.each do |e|
-        range = eval(e.slice(PARENTHESES).delete("()"))
-        convert_name = e.gsub(PARENTHESES, "")
-        arr[range] = get_val(convert_name, range.size)
-      end
-
-      arr
-    end
-
-    def get_val convert_name, size
-      return [""] * size if convert_name == "empty"
-      return [nil] * size if convert_name == "nil"
-      return ["text\n" * 5] * size if convert_name == "br_text"
-      return ["text" * 50] * size if convert_name == "big_text"
-    end
-
-  end
-end

data/lib/pokotarou/data_register.rb

@@ -1,233 +0,0 @@
-require "pokotarou/additional_variables/additional_variables.rb"
-
-class RegisterError < StandardError; end
-class SeedError < StandardError; end
-
-class DataRegister
-  class << self
-    def register data
-      # init maked to accumulate maded data
-      maked = Hash.new { |h,k| h[k] = Hash.new(&h.default_proc) }
-      maked_col = Hash.new { |h,k| h[k] = {} }
-      # init model_data to cache data of model
-      model_cache = {}
-      ActiveRecord::Base.transaction do
-        begin
-          data.each do |sym_block, model_data|
-            next if is_dush?(sym_block.to_s)
-            register_val_by_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, maked_col)
-    end
-
-    private
-
-    def register_val_by_bulk sym_block, model_data, maked, model_cache, maked_col
-      model_data.each do |e|
-        begin
-          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])
-          insert_record(sym_block, str_model, config_data ,model_cache)
-        rescue => e
-          print "\e[31m"
-          puts "[Pokotarou ERROR]"
-          puts "+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+"
-          puts "Failed Register record"
-          puts "BLOCK: #{sym_block}"
-          puts "MODEL: #{str_model}"
-          puts "MESSAGE: #{e.message}"
-          puts "+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+"
-          print "\e[0m"
-          puts ""
-
-          raise RegisterError.new
-        end
-      end
-    end
-
-    def insert_record 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
-      model_cache[str_model][:model].import(col_arr, seed_arr, validate: config_data[:validate], timestamps: false)
-    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 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])
-        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].each do |key, val|
-        begin
-          # set expand expression '<>' and ':' and so on...
-          set_expand_expression(config_data, key, val, maked, maked_col)
-          expanded_val = config_data[:col][key]
-          expanded_val_size = expanded_val.size
-
-          # apply converter
-          if convert_conf.present?
-            expanded_val = Converter.convert(expanded_val, convert_conf[key])
-          end
-
-          # get option configration
-          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, expanded_val_size, cnt) : get_seed_with_option(expanded_val, expanded_val_size, option_conf, cnt)
-              cnt += 1
-
-              seed
-            end
-
-          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
-          print "\e[31m"
-          puts "[Pokotarou ERROR]"
-          puts "+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+"
-          puts "Failed Generating seed"
-          puts "BLOCK: #{sym_block}"
-          puts "MODEL: #{sym_model}"
-          puts "COLUMN: #{key}"
-          puts "MESSAGE: #{e.message}"
-          puts "+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+"
-          print "\e[0m"
-          puts ""
-
-          raise SeedError.new
-        end
-      end
-    end
-
-    def update_let_key let, maked, maked_col
-      let.each do |key, val|
-        # TODO: run only maked_col or make key
-        AdditionalVariables.let[key] = ExpressionParser.parse(val, maked, maked_col)
-      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, prev_id_arr
-      max_id = model.maximum(:id)
-
-      current_id =
-        if prev_id_arr.present?
-          prev_id_arr.last
-        elsif max_id.nil?
-          0
-        else
-          max_id
-        end
-
-      additions = current_id + loop_size
-      next_id = current_id + 1
-
-      ids = [*next_id..additions]
-      ids.shuffle! if config_data[:randomincrement]
-      config_data[:col][:id] = ids
-    end
-
-    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, maked_col)
-    end
-
-    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
-      ArrayOperation.get_rotated_val(arr, size, cnt)
-    end
-
-    def get_seed_with_option arr, size, option, cnt
-      Option.apply(arr, size, 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][sym_model][col] = seed
-    end
-
-    def update_maked_col maked_col, sym_model, column, vals
-      maked_col[sym_model][column] ||= []
-      maked_col[sym_model][column].concat(vals)
-    end
-
-    def output_log log
-      return if log.nil?
-      puts log
-    end
-
-    DUSH_OPTION = /^.*\'$/
-    def is_dush? val
-      return false unless val.kind_of?(String)
-      DUSH_OPTION =~ val
-    end
-  end
-end