pokotarou 1.1.7 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ba6e2645cf94bcf9be0f58eed852f3a72aaa781a0c7cd3464bae15198d06995
-  data.tar.gz: 7e0a7526bf12d795d141a5ab1c5adf798011c397a1c6a5897e7562da5d96385a
+  metadata.gz: 12597f8db907a8280e94b6007de1bdd0b77e63501a3123f202e6fec7786c7bcd
+  data.tar.gz: 15072090ef575f4e34eba0e403c04552f22046a3ca1cc3effbe4d5cf4d8625e1
 SHA512:
-  metadata.gz: 5d60e710e9da88f544e396ee0bf8bd2fdbfd9f71691eb326c6f38caccef07d07c7424b5804936432947ad7d5c4b2d787e8ce98f3d1e4fada1f161ce465be46ef
-  data.tar.gz: 127ec4685eedae5f3dfa6f0b19d82c3d64aa8ef2fe16f8c14450e434d891796ffc9059d42c30bb5f5550dbd5994951d5bb4a18e1f9f2db440c05280eb95cea80
+  metadata.gz: ff32c23a477fc3c4a618c6dce3eff767e413b63c37ec8a21dc83c6bc65d41b62c4c37109ab4faa0e96086b00eb48b673ca79184d1f764fe94b6c39bf1c9b6102
+  data.tar.gz: 84d896e8fc5418a08ce555aaf40fe327ee245d9e081a76ebb632789eb10c5dee6669d876bd7eeea7fbdfac2b734c4d4fcb47738cd06f46ea90ac9f5a26c8d30a

data/lib/pokotarou.rb

@@ -1,104 +1,177 @@
-Dir[File.expand_path('../pokotarou', __FILE__) << '/*.rb'].each do |file|
-  require file
-end
-
 require "activerecord-import"
+require "pokotarou/registration_config_maker/main.rb"
+require "pokotarou/seed_data_register/main.rb"
+require "pokotarou/parser/const_parser.rb"
 
 module Pokotarou
-  class NotFoundLoader < StandardError; end
-
-  class << self
-    def execute input
-      AdditionalMethods.init()
-
-      # if input is filepath, generate config_data
-      return_val =
-        if input.kind_of?(String)
-          DataRegister.register(gen_config(input))
-        else
-          DataRegister.register(input)
-        end
-
-      AdditionalMethods.remove_filepathes_from_yml()
-
-      return_val
-    end
-
-    def pipeline_execute input_arr
-      AdditionalMethods.init()
-
-      return_vals = []
-      input_arr.each do |e|
-        handler = gen_handler_with_cache(e[:filepath])
-
-        if e[:change_data].present?
-          e[:change_data].each do |block, config|
-            config.each do |model, seed|
-              seed.each do |col_name, val|         
-                handler.change_seed(block, model, col_name, val)
+  class Operater
+    class NotFoundLoader < StandardError; end
+    class << self
+      def execute input
+        AdditionalMethods::Main.init()
+  
+        # if input is filepath, generate config_data
+        return_val =
+          if input.kind_of?(String)
+            SeedDataRegister::Main.register(gen_config(input))
+          else
+            SeedDataRegister::Main.register(input)
+          end
+  
+        AdditionalMethods::Main.remove_filepathes_from_yml()
+  
+        return_val
+      end
+  
+      def pipeline_execute input_arr
+        AdditionalMethods::Main.init()
+  
+        return_vals = []
+        input_arr.each do |e|
+          handler = gen_handler_with_cache(e[:filepath])
+  
+          if e[:change_data].present?
+            e[:change_data].each do |block, config|
+              config.each do |model, seed|
+                seed.each do |col_name, val|         
+                  handler.change_seed(block, model, col_name, val)
+                end
               end
             end
           end
+          
+          e[:args] ||= {}
+          e[:args][:passed_return_val] = return_vals.last
+          set_args(e[:args])
+  
+          return_vals << Pokotarou.execute(handler.get_data())
+          AdditionalMethods::Main.remove_filepathes_from_yml()
         end
-        
-        e[:args] ||= {}
-        e[:args][:passed_return_val] = return_vals.last
-        set_args(e[:args])
-
-        return_vals << Pokotarou.execute(handler.get_data())
-        AdditionalMethods.remove_filepathes_from_yml()
+  
+        return_vals
+      end
+  
+      def import filepath
+        AdditionalMethods::Main.init()
+        AdditionalMethods::Main.import(filepath)
+      end
+  
+      def set_args hash
+        AdditionalArguments::Main.import(hash)
+      end
+  
+      def reset
+        AdditionalMethods::Main.remove()
+        AdditionalArguments::Main.remove()
+        AdditionalVariables::Main.remove()
+        @handler_chache = {}
+      end
+  
+      def gen_handler filepath
+        AdditionalMethods::Main.init()
+  
+        PokotarouHandler.new(gen_config(filepath))
+      end
+  
+      def gen_handler_with_cache filepath
+        AdditionalMethods::Main.init()
+  
+        @handler_cache ||= {}
+        @handler_cache[filepath] ||= PokotarouHandler.new(gen_config(filepath))
+  
+        @handler_cache[filepath].deep_dup
       end
+  
+      private
+  
+      def gen_config filepath
+        contents = YAML.load_file(filepath).deep_symbolize_keys!
+        AdditionalVariables::Main.set_const(contents)
+        RegistrationConfigMaker::Main.gen(contents)
+      end
+      
+    end
+  end
+end
 
-      return_vals
+module Pokotarou
+  class << self
+    def execute input
+      Operater.execute(input)
+    end
+
+    def pipeline_execute input_arr
+      Operater.pipeline_execute(input_arr)
     end
 
     def import filepath
-      AdditionalMethods.init()
-      AdditionalMethods.import(filepath)
+      Operater.import(filepath)
     end
 
     def set_args hash
-      Arguments.import(hash)
+      Operater.set_args(hash)
     end
 
     def reset
-      AdditionalMethods.remove()
-      Arguments.remove()
-      AdditionalVariables.remove()
-      @handler_chache = {}
+      Operater.reset()
     end
 
     def gen_handler filepath
-      PokotarouHandler.new(gen_config(filepath))
+      Operater.gen_handler(filepath)
     end
 
     def gen_handler_with_cache filepath
-      @handler_cache ||= {}
-      @handler_cache[filepath] ||= PokotarouHandler.new(gen_config(filepath))
-
-      @handler_cache[filepath].deep_dup
+      Operater.gen_handler_with_cache(filepath)
     end
+  end
+end
 
-    private
+class PokotarouHandler
+  def initialize data
+    @data = data
+  end
 
-    def gen_config filepath
-      contents = load_file(filepath)
-      set_const_val_config(contents)
-      DataStructure.gen(contents)
-    end
+  def make
+    ::Pokotarou::Operater.execute(get_data())
+  end
 
-    def set_const_val_config contents
-      AdditionalVariables.set_const(contents)
-    end
+  def delete_block sym_block
+    @data.delete(sym_block)
+  end
 
-    def load_file filepath
-      case File.extname(filepath)
-      when ".yml"
-        return YmlLoader.load(filepath)
-      else
-        raise NotFoundLoader.new("not found loader")
-      end
-    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
-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
+ 
+  def set_randomincrement sym_block, sym_class, status
+    @data[sym_block][sym_class][:randomincrement] = status
+  end
+
+  def set_autoincrement sym_block, sym_class, status
+    @data[sym_block][sym_class][:autoincrement] = status
+  end
+end

data/lib/pokotarou/additional_arguments/main.rb

@@ -0,0 +1,24 @@
+module Pokotarou
+  class MisMatchArgType < StandardError; end
+  class AdditionalArguments
+    module Main
+      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
+  
+      end  
+    end
+  end
+end

data/lib/pokotarou/additional_methods/main.rb

@@ -0,0 +1,49 @@
+module Pokotarou
+  module ::Pokotarou::AdditionalMethods
+    module Main
+      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
+  
+        def load
+          @filepathes.each do |filepath|; require filepath end
+          @filepathes_from_yml.each do |filepath|; require filepath end
+        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
+  end
+end

data/lib/pokotarou/additional_variables/main.rb

@@ -0,0 +1,28 @@
+module Pokotarou
+  class AdditionalVariables
+    module Main
+      class << self
+        CONST_KEY = :"const'"
+        @const = {}
+        attr_reader :const
+  
+        def set_const 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
+  
+        def remove
+          @const = {}
+        end
+      
+      end
+    end  
+  end
+end

data/lib/pokotarou/parser/const_parser.rb

@@ -0,0 +1,25 @@
+require "pokotarou/parser/parser.rb"
+
+# for const variables
+module Pokotarou
+  class ConstParser < ExpressionParser
+    class << self
+      private
+      def expression_process val, _, _
+        # remove '<>'
+        expression = val.strip[1..-2]
+        ::Pokotarou::AdditionalMethods::Main.load
+        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
+end

data/lib/pokotarou/parser/loop_expression_parser.rb

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

data/lib/pokotarou/parser/parser.rb

@@ -0,0 +1,108 @@
+require "pokotarou/additional_variables/main.rb"
+require "pokotarou/additional_methods/main.rb"
+require "pokotarou/additional_arguments/main.rb"
+require "pokotarou/parser/parser_domain.rb"
+require "pokotarou/p_tool.rb"
+
+
+module Pokotarou
+  class ParseError < StandardError; end
+  FOREIGN_KEY_SYMBOL = "F|"
+  COLUMN_SYMBOL = "C|"
+  
+  class ExpressionParser
+    class << self
+      
+      def args; ::Pokotarou::AdditionalArguments::Main.args end
+      def const; ::Pokotarou::AdditionalVariables::Main.const end
+      
+      def parse config_val, maked = nil, maked_col = nil
+        begin
+          case
+          # Array
+          when ParserDomain.is_array?(config_val)
+            array_procees(config_val)
+  
+          # ForeignKey
+          when ParserDomain.is_foreign_key?(config_val)
+            foreign_key_process(config_val, maked_col)
+  
+          # Column
+          when ParserDomain.is_column_symbol?(config_val)
+            column_symbol_process(config_val, maked_col)
+  
+          # Expression
+          when ParserDomain.is_expression?(config_val)
+            expression_process(config_val, maked, maked_col)
+  
+          # Integer
+          when ParserDomain.is_integer?(config_val)
+            integer_process(config_val)
+          
+          # NeedUpdate
+          when ParserDomain.is_need_update?(config_val)
+            need_update_process(config_val, maked, maked_col)
+  
+          # Nil
+          when ParserDomain.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]
+        ::Pokotarou::AdditionalMethods::Main.load
+        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
+end