pokotarou 1.2.0 → 1.2.1

data/lib/pokotarou/parser/seed_data_expression_parser.rb

@@ -0,0 +1,18 @@
+require "pokotarou/parser/parser.rb"
+
+# for seed data
+module Pokotarou
+  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
+end

data/lib/pokotarou/registration_config_maker/column_domain.rb

@@ -0,0 +1,17 @@
+module Pokotarou
+  module RegistrationConfigMaker
+    class ColumnDomain
+      class << self
+        def is_foreign_key? col_name_sym, foreign_key_dict
+          return foreign_key_dict[col_name_sym].present?
+        end
+  
+        ENUM_REGEX = /^enum(\s*.)*$/
+        def is_enum? sql_type
+          return false unless sql_type.kind_of?(String)
+          return ENUM_REGEX =~ sql_type
+        end
+      end
+    end
+  end
+end

data/lib/pokotarou/registration_config_maker/config_domain.rb

@@ -0,0 +1,43 @@
+module Pokotarou
+  module RegistrationConfigMaker
+    class ConfigDomain
+      class << self
+        def has_dush_import_syntax? all_content
+          return false if all_content.blank?
+          return all_content.has_key?(:"import'")
+        end
+    
+        def has_dush_template_syntax? all_content
+          return false if all_content.blank?
+          return all_content.has_key?(:"template'")
+        end
+  
+        def has_dush_template_path_syntax? all_content
+          return false if all_content.blank?
+          return all_content.has_key?(:"template_path'")
+        end
+  
+        def has_grouping_syntax? model_content
+          return false if model_content.blank?
+          return model_content.has_key?(:grouping)
+        end
+    
+        def has_template_syntax? model_content
+          return false if model_content.blank?
+          return model_content.has_key?(:template)
+        end
+    
+        def has_seed_data_syntax? col_config, col_name_sym
+          return false if col_config.blank?
+          return col_config.has_key?(col_name_sym)
+        end
+    
+        DUSH_OPTION_REGEX = /^.*\'$/
+        def is_dush_syntax? syntax
+          return false unless syntax.kind_of?(String)
+          return DUSH_OPTION_REGEX =~ syntax
+        end
+      end
+    end
+  end
+end

data/lib/pokotarou/registration_config_maker/grouping_option_setter.rb

@@ -0,0 +1,28 @@
+module Pokotarou
+  module RegistrationConfigMaker
+    class GroupingOptionSetter
+      class << self
+        def set seed_config
+            seed_config[:grouping].each do |grouping_key, cols|
+            set_grouping_data(:col, seed_config, grouping_key, cols)
+            set_grouping_data(:option, seed_config, grouping_key, cols)
+            set_grouping_data(:convert, seed_config, grouping_key, cols)
+          end
+      
+          seed_config.delete(:grouping)
+        end
+      
+        private
+        def set_grouping_data config_name, seed_config, grouping_key, cols
+          return if seed_config[config_name].blank?
+          return unless seed_config[config_name].has_key?(grouping_key)
+          cols.each do |e|
+            seed_config[config_name][e.to_sym] = seed_config[config_name][grouping_key]
+          end
+          
+          seed_config[config_name].delete(grouping_key)
+        end
+      end
+    end
+  end
+end

data/lib/pokotarou/registration_config_maker/import_option_setter.rb

@@ -0,0 +1,13 @@
+require "pokotarou/additional_methods/main"
+module Pokotarou
+  module RegistrationConfigMaker
+    class ImportOptionSetter
+      class << self
+        def set all_content
+          ::Pokotarou::AdditionalMethods::Main.import_from_yml(all_content[:"import'"])
+          all_content.delete(:"import'")
+        end
+      end
+    end
+  end
+end

data/lib/pokotarou/registration_config_maker/main.rb

@@ -0,0 +1,58 @@
+require "pokotarou/registration_config_maker/column_domain.rb"
+require "pokotarou/registration_config_maker/config_domain.rb"
+require "pokotarou/registration_config_maker/import_option_setter.rb"
+require "pokotarou/registration_config_maker/template_option_setter.rb"
+require "pokotarou/registration_config_maker/grouping_option_setter.rb"
+require "pokotarou/registration_config_maker/model_option_setter.rb"
+  
+module Pokotarou
+  module RegistrationConfigMaker
+    class Main
+      class << self
+        def gen all_content
+          set_header_config(all_content)
+          all_content.reduce({}) do |acc, block_content|
+            block_name = block_content.first
+            block_config = block_content.second
+  
+            if ConfigDomain.is_dush_syntax?(block_name.to_s)
+              acc[block_name] = block_config
+            else
+              set_model_config_to_acc(acc, block_content)
+            end
+  
+            acc
+          end
+        end
+  
+        private
+  
+        def set_header_config all_content
+          set_template_option(all_content)
+          set_import_option(all_content)
+        end
+  
+        def set_import_option all_content
+          return unless ConfigDomain.has_dush_import_syntax?(all_content)
+          ImportOptionSetter.set(all_content)
+        end
+  
+        def set_template_option all_content
+          return if !ConfigDomain.has_dush_template_syntax?(all_content) && !ConfigDomain.has_dush_template_path_syntax?(all_content)
+          TemplateOptionSetter.set(all_content)
+        end
+  
+        def set_model_config_to_acc acc, block_content
+          set_grouping_option(block_content.second)
+          ModelOptionSetter.set(acc, block_content)
+        end
+  
+        def set_grouping_option block_content
+          block_content.each do |_, model_content|
+            GroupingOptionSetter.set(model_content) if ConfigDomain.has_grouping_syntax?(model_content)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pokotarou/registration_config_maker/model_option_setter.rb

@@ -0,0 +1,65 @@
+module Pokotarou
+  module RegistrationConfigMaker
+    class ModelOptionSetter
+      class << self
+        def set acc, block_content
+          block_name = block_content.first
+          block_config = block_content.second
+          acc[block_name] = {}
+    
+          block_config.each do |model_content|
+            model_name = model_content.first
+            model_config = model_content.second
+            set_column_type(model_config, model_name)
+            acc[block_name][model_name] = model_config
+          end
+        end
+    
+        private
+    
+        def set_column_type model_config, model_name
+          model = eval(model_name.to_s)
+          foreign_key_data = get_foreign_key_data(model)
+    
+          model_config[:col] ||= {}
+          model.columns.each do |e|
+            symbol_col_name = e.name.to_sym
+    
+            next if ConfigDomain.has_seed_data_syntax?(model_config[:col], symbol_col_name)
+    
+            # set foreign_key info
+            if ColumnDomain.is_foreign_key?(symbol_col_name, foreign_key_data)
+              # don't set :type val for don't run default seeder
+              # use F function for set foreign key
+              model_config[:col][symbol_col_name] = "F|#{foreign_key_data[symbol_col_name].to_s}"
+            else
+              model_config[:type] ||= {}
+              model_config[:type][symbol_col_name] = e.type.to_s
+            end
+    
+            # set enum info
+            model_config[:enum] ||= {}
+            if ColumnDomain.is_enum?(e.sql_type.to_s)
+              model_config[:enum][symbol_col_name] = e.sql_type.to_s[5..-2].tr("'", "").split(",")
+            end
+     
+          end
+        end
+    
+        def get_foreign_key_data model
+          relations = model.reflect_on_all_associations(:belongs_to)
+          return {} if relations.empty?
+          relations.reduce({})do |acc, r|
+    
+            relation_model = r.name.to_s.camelize
+            if Object.const_defined?(relation_model.to_sym)
+              acc[r.foreign_key.to_sym] = eval(relation_model)
+            end
+    
+            acc
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pokotarou/registration_config_maker/template_option_setter.rb

@@ -0,0 +1,63 @@
+require "pokotarou/registration_config_maker/config_domain.rb"
+module Pokotarou
+  module RegistrationConfigMaker
+    class TemplateOptionSetter
+      class << self
+        def set all_content
+          templates = fetch_template_option(all_content)
+  
+          all_content.each do |key, block_content|
+            next if ConfigDomain.is_dush_syntax?(key.to_s)
+            set_template_option(block_content, templates)
+          end
+        end
+      
+        private
+  
+        def fetch_template_option all_content
+          templates = ConfigDomain.has_dush_template_syntax?(all_content) ? all_content.delete(:"template'") : {}
+  
+          if ConfigDomain.has_dush_template_path_syntax?(all_content)
+            merge_template_from_template_path(all_content, templates)
+          end
+  
+          return templates 
+        end
+  
+        def merge_template_from_template_path all_content, templates
+          template_path = all_content.delete(:"template_path'")
+          template_path.each do |e|
+            YAML.load_file(e).deep_symbolize_keys!.each do |loaded_template|
+              templates[loaded_template.first] = loaded_template.second
+            end
+          end
+        end
+    
+        def set_template_option block_content, templates
+          block_content.each do |key, model_content|
+            next unless ConfigDomain.has_template_syntax?(model_content)
+            template_copy = get_template_copy(model_content[:template], templates)
+            deep_overwrite(model_content, template_copy)
+            # update config all_config
+            block_content[key] = template_copy
+          end
+        end
+    
+        def get_template_copy template_name, templates
+          return templates[template_name.to_sym].deep_dup
+        end
+      
+        def deep_overwrite source, destination
+          source.each do |key, val|
+            if val.kind_of?(Hash)
+              destination[key] ||= {}
+              deep_overwrite(val, destination[key])
+            else
+              destination[key] = val
+            end
+          end
+        end
+      end
+    end
+  end
+end

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