pokotarou 1.1.7 → 1.2.2

data/lib/pokotarou/registration_config_updater/array_utils.rb

@@ -0,0 +1,15 @@
+module Pokotarou
+  class NothingDataError < StandardError; end
+  module RegistrationConfigUpdater 
+    module ArrayUtils
+      # 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
+end

data/lib/pokotarou/registration_config_updater/convert_config.rb

@@ -0,0 +1,28 @@
+module Pokotarou
+  module RegistrationConfigUpdater
+    class ConvertConfig 
+      class << self
+        PARENTHESES = /\(.*\)/
+        def execute 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
+  
+        private
+        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
+  end
+end

data/lib/pokotarou/registration_config_updater/default_value_maker.rb

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

data/lib/pokotarou/registration_config_updater/main.rb

@@ -0,0 +1,170 @@
+require "pokotarou/registration_config_updater/default_value_maker.rb"
+require "pokotarou/registration_config_updater/option_config.rb"
+require "pokotarou/registration_config_updater/convert_config.rb"
+require "pokotarou/registration_config_updater/array_utils.rb"
+require "pokotarou/parser/seed_data_expression_parser.rb"
+require "pokotarou/parser/loop_expression_parser.rb"
+require "pokotarou/parser/return_expression_parser..rb"
+
+module Pokotarou
+  module RegistrationConfigUpdater
+    class Main
+      class << self
+        include ArrayUtils
+  
+        def update model_content, block_name_sym, model_cache, maked, maked_col
+          model_name = model_content.first.to_s
+          model_config = model_content.second
+          update_model_cache(model_cache, model_name)
+  
+  
+          model = model_cache[model_name][:model]
+          model_name_sym = model_cache[model_name][:sym_model]
+          set_loop_expand_expression(model_config, maked, maked_col)
+          set_default_seed(model_config)
+          set_seed_arr(model, block_name_sym, model_name_sym, model_config, maked, maked_col)
+        end
+  
+        private
+        def set_loop_expand_expression model_config, maked, maked_col
+          model_config[:loop] =
+            LoopExpressionParser.parse(model_config[:loop], maked, maked_col)
+        end
+  
+        def set_default_seed model_config
+          # each column type, key is symbolize column name
+          model_config[:type].each do |key, _|
+            # if it is id, skip
+            next if :id == key
+            # if there is data already, skip
+            next if model_config[:col][key].present?
+    
+            model_config[:col][key] = DefaultValueMaker.make(model_config, key)
+          end
+        end  
+  
+        def update_model_cache model_cache, model_name
+          return if model_cache[model_name].present?
+          model = eval(model_name)
+          model_cache[model_name] = {
+            model: model,
+            sym_model: model_name.to_sym,
+            table_name: model.table_name
+          }
+        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 has_autoincrement_config?(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 = 
+                  ConvertConfig.execute(expanded_val, convert_conf[key])
+              end
+    
+              # get option configration
+              option_conf = OptionConfig.fetch(options, key)
+    
+              # Take count yourself, because .with_index is slow
+              cnt = 0
+              seeds =
+                loop_size.times.map do
+                  seed = 
+                    option_conf.nil? ? get_rotated_val(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 has_autoincrement_config? autoincrement_flg
+          # default true
+          return true if autoincrement_flg.nil?
+          autoincrement_flg
+        end
+    
+        def set_autoincrement config_data, model, loop_size, prev_id_arr
+          
+          current_id =
+            if prev_id_arr.present?
+              prev_id_arr.last
+            else 
+              max_id = model.maximum("id")
+              max_id.nil? ? 0 : 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 get_seed_with_option arr, size, option, cnt
+          OptionConfig.execute(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
+    
+      end
+    end
+  end
+end

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.1.7'
+  VERSION = '1.2.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pokotarou
 version: !ruby/object:Gem::Version
-  version: 1.1.7
+  version: 1.2.2
 platform: ruby
 authors:
 - Kashiwara
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-20 00:00:00.000000000 Z
+date: 2021-04-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -49,24 +49,33 @@ 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/pokotarou_handler.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/preset_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: 
+homepage: https://github.com/Kashiwara0205/Pokotarou
 licenses:
 - MIT
 metadata: {}