pokotarou 1.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0313ae9034a4b9ed1a64829a7d16a1811df5da6937f5639a8e3700a7c658a211
-  data.tar.gz: b7b90ac0f1fd81f2fb11e015ee0cfd6b8b38544f4e0ed272ee1a834dc05cf340
+  metadata.gz: cb37e93ab913cfc45d6bb0c06cbfec3149ac957e0592ef12d62f1ad6d3b0146e
+  data.tar.gz: c67cccf940b65008a991684a9603a99395aca02a9137613331680dc23612b841
 SHA512:
-  metadata.gz: 79b8112bd089213e28269d6cced5a1cc4157453079a3502218d4afecc01864393a6aab6dad7dc238dd257c8b47e0ba53c0fface455e2f32fa590bab8fa6fda02
-  data.tar.gz: 27462bd7caa6e7173a623fdbabaa406141a6cbd80618c70e7581355f2521d3921b75b0225f1503b3236aad45efab3645b8505b92033cabd21163c93ea9102028
+  metadata.gz: 870208b9d5b2449ccd6bc1884bf0a78596da211d261deccba8353919fec4a617925cbcdeaf2330949d34c07370e89b24ad8649eef3c28aa8fe0f41b5602bab3c
+  data.tar.gz: 406ad8070133722c71dcebf8b2df12f2471563b0e0ad15f4647d41a62025c20e85a32ba2334fee1951966e6b77fb8815e23f668e4f5320c92cfb57d26f6f3e87

data/lib/pokotarou.rb

@@ -1,31 +1,30 @@
-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 Operater
     class NotFoundLoader < StandardError; end
     class << self
       def execute input
-        init_proc()
+        AdditionalMethods::Main.init()
   
         # if input is filepath, generate config_data
         return_val =
           if input.kind_of?(String)
-            DataRegister.register(gen_config(input))
+            SeedDataRegister::Main.register(gen_config(input))
           else
-            DataRegister.register(input)
+            SeedDataRegister::Main.register(input)
           end
   
-        AdditionalMethods.remove_filepathes_from_yml()
+        AdditionalMethods::Main.remove_filepathes_from_yml()
   
         return_val
       end
   
       def pipeline_execute input_arr
-        init_proc()
+        AdditionalMethods::Main.init()
   
         return_vals = []
         input_arr.each do |e|
@@ -46,37 +45,36 @@ module Pokotarou
           set_args(e[:args])
   
           return_vals << Pokotarou.execute(handler.get_data())
-          AdditionalMethods.remove_filepathes_from_yml()
+          AdditionalMethods::Main.remove_filepathes_from_yml()
         end
   
         return_vals
       end
   
       def import filepath
-        init_proc()
-  
-        AdditionalMethods.import(filepath)
+        AdditionalMethods::Main.init()
+        AdditionalMethods::Main.import(filepath)
       end
   
       def set_args hash
-        Arguments.import(hash)
+        AdditionalArguments::Main.import(hash)
       end
   
       def reset
-        AdditionalMethods.remove()
-        Arguments.remove()
-        AdditionalVariables.remove()
+        AdditionalMethods::Main.remove()
+        AdditionalArguments::Main.remove()
+        AdditionalVariables::Main.remove()
         @handler_chache = {}
       end
   
       def gen_handler filepath
-        init_proc()
+        AdditionalMethods::Main.init()
   
         PokotarouHandler.new(gen_config(filepath))
       end
   
       def gen_handler_with_cache filepath
-        init_proc()
+        AdditionalMethods::Main.init()
   
         @handler_cache ||= {}
         @handler_cache[filepath] ||= PokotarouHandler.new(gen_config(filepath))
@@ -85,28 +83,13 @@ module Pokotarou
       end
   
       private
-      def init_proc
-        AdditionalMethods.init()
-      end
   
       def gen_config filepath
-        contents = load_file(filepath)
-        set_const_val_config(contents)
-        DataStructure.gen(contents)
-      end
-  
-      def set_const_val_config contents
-        AdditionalVariables.set_const(contents)
-      end
-  
-      def load_file filepath
-        case File.extname(filepath)
-        when ".yml"
-          return YmlLoader.load(filepath)
-        else
-          raise NotFoundLoader.new("not found loader")
-        end
+        contents = YAML.load_file(filepath).deep_symbolize_keys!
+        AdditionalVariables::Main.set_const(contents)
+        RegistrationConfigMaker::Main.gen(contents)
       end
+      
     end
   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

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