pokotarou 1.1.7 → 1.2.2

data/lib/pokotarou/expression_parser.rb

@@ -1,233 +0,0 @@
-require "pokotarou/additional_methods.rb"
-require "pokotarou/additional_variables/additional_variables.rb"
-require "pokotarou/arguments/arguments.rb"
-require "pokotarou/p_tool.rb"
-
-def load_filepath
-  require AdditionalVariables.filepath
-  require Arguments.filepath
-  AdditionalMethods.filepathes.each do |filepath|; require filepath end
-  AdditionalMethods.filepathes_from_yml.each do |filepath|; require filepath end
-end
-
-class ParseError < StandardError; end
-FOREIGN_KEY_SYMBOL = "F|"
-COLUMN_SYMBOL = "C|"
-
-class ExpressionParser
-  class << self
-    
-    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, 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, maked_col)
-
-        # Integer
-        when is_integer?(config_val)
-          integer_process(config_val)
-        
-        # NeedUpdate
-        when is_need_update?(config_val)
-          need_update_process(config_val, maked, maked_col)
-
-        # Nil
-        when is_nil?(config_val)
-          nil_process(config_val)
-
-        # Other
-        else
-          nothing_apply_process(config_val)
-        end
-      rescue => e
-        output_error(e)
-      end
-    end
-
-    private
-    def array_procees val
-      return val
-    end
-
-    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 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]
-      load_filepath()
-      return self.parse(eval(expression), maked, maked_col)
-    end
-
-    def integer_process val
-      nothing_apply_process(val)
-    end
-
-    def need_update_process val, maked, maked_col
-      return self.parse(val[:NeedUpdate], maked, maked_col)
-    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
-
-    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
-
-# for loop data
-class LoopExpressionParser < ExpressionParser
-  class << self
-    private
-    def array_procees val
-      val.size
-    end
-
-    def foreign_key_process val, maked_col
-      # 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 ConstParser < ExpressionParser
-  class << self
-    private
-    def expression_process val, _, _
-      # remove '<>'
-      expression = val.strip[1..-2]
-      load_filepath()
-      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_REGEXP = /^F\|[A-Z][:A-Za-z0-9]*$/
-def is_foreign_key? val
-  return false unless val.kind_of?(String)
-  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_REGEXP = /^\s*<.*>\s*$/
-def is_expression? val
-  return false unless val.kind_of?(String)
-  EXPRESSION_REGEXP =~ val
-end
-
-def is_array? val
-  val.instance_of?(Array)
-end
-
-def is_integer? val
-  val.instance_of?(Integer)
-end
-
-def is_need_update? val
-  return false unless val.kind_of?(Hash)
-  val.has_key?(:NeedUpdate)
-end
-
-def is_nil? val
-  val.nil?
-end

data/lib/pokotarou/file_loader.rb

@@ -1,16 +0,0 @@
-class FileLoader
-  class << self
-    # load data with the use of indicated filepath 
-    def load filepath
-    end
-  end
-end
-
-class YmlLoader < FileLoader
-  class << self
-    def load filepath
-      # convert 'str_key' to 'symbol_key'
-      YAML.load_file(filepath).deep_symbolize_keys!
-    end
-  end
-end

data/lib/pokotarou/option.rb

@@ -1,46 +0,0 @@
-class Option
-  class << self
-    def gen option
-      # shape option data
-      # [option1, option2] => { select: [option2], add: [option1] }
-      # [] => { select: [], add: [] }
-      option.nil? ? { select: [], add: [] } : separate(option)
-    end
-
-    def apply 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_filter = ->(name){ ["rotate", "random"].include?(name) }
-      add_filter = ->(name){ ["add_id", "sequence"].include?(name) }
-
-      {
-        select: option.find{|s| select_filter.call(s)},
-        add: option.find{|s| add_filter.call(s)}
-      }
-    end
-
-    def select option, arr, size, cnt
-      return arr.sample if option == "random"
-
-      # default return rotate
-      ArrayOperation.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

data/lib/pokotarou/pokotarou_handler.rb

@@ -1,37 +0,0 @@
-class PokotarouHandler
-  def initialize data
-    @data = data
-  end
-
-  def delete_block sym_block
-    @data.delete(sym_block)
-  end
-
-  def delete_model sym_block, sym_class
-    @data[sym_block].delete(sym_class)
-  end
-
-  def delete_col sym_block, sym_class, sym_col
-    exists_content = ->(key){ @data[sym_block][sym_class][key].present? }
-
-    @data[sym_block][sym_class][:col].delete(sym_col) if exists_content.call(:col)
-    @data[sym_block][sym_class][:option].delete(sym_col) if exists_content.call(:option)
-    @data[sym_block][sym_class][:convert].delete(sym_col) if exists_content.call(:convert)
-  end
-
-  def change_loop sym_block, sym_class, n
-    @data[sym_block][sym_class][:loop] = n
-  end
-
-  def change_seed sym_block, sym_class, sym_col, arr
-    @data[sym_block][sym_class][:col][sym_col] = arr
-  end
-
-  def get_data
-    @data.deep_dup
-  end
-
-  def set_data data
-    @data = data
-  end
-end

data/lib/pokotarou/seeder.rb

@@ -1,29 +0,0 @@
-class Seeder
-  class << self
-    def gen 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_string_array(n, enum) if type == "string"
-      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