pokotarou 1.1.7 → 1.2.2

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,230 +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
-      last_record = model.last
-      current_id =
-        if prev_id_arr.present?
-          prev_id_arr.last
-        elsif last_record.nil?
-          0
-        else
-          last_record.id
-        end
-
-      additions = current_id + loop_size
-      next_id = current_id + 1
-
-      config_data[:col][:id] = [*next_id..additions]
-    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

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