pokotarou 1.1.7 → 1.2.2

data/lib/pokotarou/parser/parser_domain.rb

@@ -0,0 +1,40 @@
+module Pokotarou
+  class ParserDomain
+    class << self
+      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 
+    end
+  end
+end

data/lib/pokotarou/parser/return_expression_parser..rb

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

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,48 @@
+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_dush_preset_path_syntax? all_content
+          return false if all_content.blank?
+          return all_content.has_key?(:"preset_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,65 @@
+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"
+require "pokotarou/registration_config_maker/preset_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_preset_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_preset_option all_content
+          return all_content unless ConfigDomain.has_dush_preset_path_syntax?(all_content)
+          PresetOptionSetter.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/preset_option_setter.rb

@@ -0,0 +1,45 @@
+require "pokotarou/registration_config_maker/config_domain.rb"
+module Pokotarou
+  module RegistrationConfigMaker
+    class PresetOptionSetter
+      class << self
+        def set all_content
+          preset_content = {}
+
+          all_content[:"preset_path'"].each do |path|
+            YAML.load_file(path).deep_symbolize_keys!.each do |preset|
+                preset_content[preset.first] = preset.second
+            end
+          end
+
+          # 使用済みのKeyなので削除
+          all_content.delete(:"preset_path'")
+          
+          # hashの順番を更新するために一度全てのKeyを消す
+          tmp = {}
+          all_content.each do |config|
+            key = config.first
+            value = config.second
+            tmp[key] = value
+
+            all_content.delete(key)
+          end
+          
+          # presetを先に展開する必要があるので、再代入して順番を変更する
+          merge(all_content, preset_content)
+          merge(all_content, tmp)
+        end
+
+        private
+        def merge all_content, merge_hash
+          merge_hash.each do |config|
+            key = config.first
+            value = config.second
+            all_content[key] = value
+          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