pokotarou 1.2.0 → 1.2.1

data/lib/pokotarou/data_structure.rb

@@ -1,187 +0,0 @@
-require "pokotarou/additional_methods.rb"
-
-class DataStructure
-  class << self
-    def gen data
-      execute_template_option_setting(data)
-      execute_import_setting(data)
-      # return data structure bellow
-      # [{ block_name => { model_name => { column_configration }}}, ...]
-      data.reduce({}) do |acc, r|
-        if is_dush?(r.first.to_s)
-          acc[r.first] = r.second
-        else
-          set_reshape_data_to_acc(acc, r)
-        end
-
-        acc
-      end
-    end
-
-    private
-
-    def execute_import_setting data
-      return unless data.has_key?(:"import'")
-      AdditionalMethods.import_from_yml(data[:"import'"])
-      data.delete(:"import'")
-    end
-
-    def execute_template_option_setting data
-      return unless data.has_key?(:"template'")
-      templates = data[:"template'"]
-      data.delete(:"template'")
-      data.each do |key, val|
-        next if is_dush?(key.to_s)
-        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] ||= {}
-          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({}) do |acc, r|
-        # r.second is config_data, like {loop: 3, ...}
-        set_col_type(r.second, r[0].to_s)
-        acc[r[0]] = r.second
-
-        acc
-      end
-    end
-
-    def set_col_type config_data, str_model
-      model = eval(str_model)
-      foreign_key_data = get_foreign_key_data(model)
-
-      config_data[:col] ||= {}
-      model.columns.each do |e|
-        symbol_col_name = e.name.to_sym
-
-        unless exists_seed_data?(config_data, symbol_col_name)
-          # prepare setting to run default seed
-          # set nil to seed data
-          config_data[:col][symbol_col_name] = nil
-
-          # set type info
-          config_data[:type] ||= {}
-          config_data[:type][symbol_col_name] = e.type.to_s
-
-          # set enum info
-          config_data[:enum] ||= {}
-          if is_enum?(e.sql_type.to_s)
-            config_data[:enum][symbol_col_name] =
-              e.sql_type.to_s[5..-2].tr("'", "").split(",")
-          end
-
-          # set foreign_key info
-          if is_foreign_key?(symbol_col_name, foreign_key_data)
-            # delete type val for don't run default seeder
-            config_data[:type].delete(symbol_col_name)
-            # use F function for set foreign key
-            config_data[:col][symbol_col_name] = "F|#{foreign_key_data[symbol_col_name].to_s}"
-          end
-        end
-
-      end
-    end
-
-    def get_foreign_key_data model
-      associations = model.reflect_on_all_associations(:belongs_to)
-      return { } if associations.empty?
-      associations.reduce({})do |acc, r|
-        model = r.name.to_s.camelize
-        if Object.const_defined?(model.to_sym)
-          acc[r.foreign_key.to_sym] = eval(model)
-        end
-
-        acc
-      end
-    end
-
-    def is_foreign_key? symbol_col_name, foreign_key_data
-      foreign_key_data[symbol_col_name].present?
-    end
-
-    def exists_seed_data? config_data ,symbol_col_name
-      config_data[:col].has_key?(symbol_col_name)
-    end
-
-    ENUM = /^enum(\s*.)*$/
-    def is_enum? val
-      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,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