rggen-core 0.16.0 → 0.21.0

data/lib/rggen/core/configuration/component.rb

@@ -4,6 +4,11 @@ module RgGen
   module Core
     module Configuration
       class Component < InputBase::Component
+        private
+
+        def post_initialize
+          need_no_children
+        end
       end
     end
   end

data/lib/rggen/core/configuration/component_factory.rb

@@ -7,7 +7,7 @@ module RgGen
         private
 
         def create_input_data(&block)
-          InputBase::InputData.new(valid_value_lists, &block)
+          InputData.new(valid_value_lists, &block)
         end
       end
     end

data/lib/rggen/core/configuration/hash_loader.rb

@@ -4,8 +4,10 @@ module RgGen
   module Core
     module Configuration
       module HashLoader
-        def format(read_data, file)
-          input_data.values(Hash(read_data), file)
+        private
+
+        def format_layer_data(read_data, _layer, file)
+          Hash(read_data)
         rescue TypeError => e
           raise Core::LoadError.new(e.message, file)
         end

data/lib/rggen/core/configuration/input_data.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Configuration
+      class InputData < InputBase::InputData
+        def initialize(valid_value_lists, &block)
+          super(nil, valid_value_lists, &block)
+        end
+
+        undef_method :child
+      end
+    end
+  end
+end

data/lib/rggen/core/input_base/component_factory.rb

@@ -4,6 +4,20 @@ module RgGen
   module Core
     module InputBase
       class ComponentFactory < Base::ComponentFactory
+        class << self
+          def enable_no_children_error
+            @enable_no_children_error = true
+          end
+
+          def disable_no_children_error
+            @enable_no_children_error = false
+          end
+
+          def enable_no_children_error?
+            @enable_no_children_error.nil? || @enable_no_children_error
+          end
+        end
+
         attr_setter :loaders
 
         private
@@ -27,8 +41,13 @@ module RgGen
         end
 
         def find_loader(file)
-          loader = loaders.find { |l| l.support?(file) }
-          loader || (raise Core::LoadError.new('unsupported file type', file))
+          loaders.find { |l| l.support?(file) } ||
+            (raise Core::LoadError.new('unsupported file type', file))
+        end
+
+        def valid_value_lists
+          component_factories
+            .transform_values(&->(f) { f.valid_value_list })
         end
 
         def create_input_data(&block)
@@ -58,9 +77,23 @@ module RgGen
         end
 
         def post_build(component)
+          exist_no_children?(component) &&
+            raise_no_children_error(component)
           component.verify(:component)
         end
 
+        def exist_no_children?(component)
+          enable_no_children_error? &&
+            component.need_children? && component.children.empty?
+        end
+
+        def enable_no_children_error?
+          self.class.enable_no_children_error?
+        end
+
+        def raise_no_children_error(_component)
+        end
+
         def finalize(component)
           component.verify(:all)
         end
@@ -77,10 +110,8 @@ module RgGen
 
         protected
 
-        def valid_value_lists
-          list = [Array(active_feature_factories&.keys)]
-          list.concat(Array(child_factory&.valid_value_lists))
-          list
+        def valid_value_list
+          Array(active_feature_factories&.keys)
         end
       end
     end

data/lib/rggen/core/input_base/feature.rb

@@ -44,14 +44,14 @@ module RgGen
 
           def input_pattern(pattern_or_patterns, **options, &converter)
             @input_matcher =
-              InputMatcher.new(pattern_or_patterns, options, &converter)
+              InputMatcher.new(pattern_or_patterns, **options, &converter)
           end
 
           attr_reader :input_matcher
 
           def verify(scope, &block)
             @verifiers ||= {}
-            (@verifiers[scope] ||= []) << Verifier.new(&block)
+            (@verifiers[scope] ||= []) << create_verifier(&block)
           end
 
           attr_reader :verifiers
@@ -75,10 +75,14 @@ module RgGen
 
           private
 
+          def create_verifier(&body)
+            Verifier.new(&body)
+          end
+
           def export_verifiers(subclass)
-            copied_verifiers =
-              @verifiers.map { |scope, blocks| [scope, blocks.dup] }.to_h
-            subclass.instance_variable_set(:@verifiers, copied_verifiers)
+            subclass.instance_variable_set(
+              :@verifiers, @verifiers.transform_values(&:dup)
+            )
           end
         end
 

data/lib/rggen/core/input_base/input_data.rb

@@ -4,7 +4,8 @@ module RgGen
   module Core
     module InputBase
       class InputData
-        def initialize(valid_value_lists)
+        def initialize(layer, valid_value_lists)
+          @layer = layer
           @valid_value_lists = valid_value_lists
           @values = Hash.new(NAValue)
           @children = []
@@ -12,6 +13,8 @@ module RgGen
           block_given? && yield(self)
         end
 
+        attr_reader :layer
+
         def value(value_name, value, position = nil)
           symbolized_name = value_name.to_sym
           return unless valid_value?(symbolized_name)
@@ -24,8 +27,8 @@ module RgGen
             end
         end
 
-        def []=(value_name, position = nil, value)
-          value(value_name, value, position)
+        def []=(value_name, position_or_value, value = nil)
+          value(value_name, value || position_or_value, position_or_value)
         end
 
         def [](value_name)
@@ -39,8 +42,8 @@ module RgGen
 
         attr_reader :children
 
-        def child(value_list = nil, &block)
-          create_child_data do |child_data|
+        def child(layer, value_list = nil, &block)
+          create_child_data(layer) do |child_data|
             child_data.build_by_block(block)
             child_data.values(value_list)
             @children << child_data
@@ -56,11 +59,11 @@ module RgGen
         private
 
         def valid_value?(value_name)
-          @valid_value_lists.first.include?(value_name)
+          @valid_value_lists[layer].include?(value_name)
         end
 
         def define_setter_methods
-          @valid_value_lists.first.each(&method(:define_setter_method))
+          @valid_value_lists[layer].each(&method(:define_setter_method))
         end
 
         def define_setter_method(value_name)
@@ -79,12 +82,12 @@ module RgGen
           locations[0].path.include?('docile') ? locations[1] : locations[0]
         end
 
-        def create_child_data(&block)
-          child_data_class.new(@valid_value_lists[1..-1], &block)
+        def create_child_data(layer, &block)
+          child_data_class.new(layer, @valid_value_lists, &block)
         end
 
         def child_data_class
-          InputData
+          self.class
         end
 
         protected

data/lib/rggen/core/input_base/input_matcher.rb

@@ -4,7 +4,7 @@ module RgGen
   module Core
     module InputBase
       class InputMatcher
-        def initialize(pattern_or_patterns, options, &converter)
+        def initialize(pattern_or_patterns, **options, &converter)
           @options = options
           @converter = converter
           @patterns = format_patterns(pattern_or_patterns)
@@ -22,23 +22,22 @@ module RgGen
 
         private
 
-        def format_patterns(patterns)
+        def format_patterns(pattern_or_patterns)
           if @options.fetch(:match_wholly, true)
-            patterns_hash(patterns)
-              .map { |i, pattern| [i, /\A#{pattern}\z/] }
-              .to_h
+            expand_patterns(pattern_or_patterns)
+              .transform_values { |pattern| /\A#{pattern}\z/ }
           else
-            patterns_hash(patterns)
+            expand_patterns(pattern_or_patterns)
           end
         end
 
-        def patterns_hash(patterns)
-          if patterns.is_a?(Hash)
-            patterns
-          else
-            Array(patterns)
-              .map.with_index { |pattern, i| [i, pattern] }
-              .to_h
+        def expand_patterns(pattern_or_patterns)
+          Array(pattern_or_patterns).each_with_object({}) do |pattern, patterns|
+            if pattern.is_a? Hash
+              patterns.update(pattern)
+            else
+              patterns[patterns.size] = pattern
+            end
           end
         end
 
@@ -62,11 +61,11 @@ module RgGen
         end
 
         def match_patterns(rhs)
-          match_data, index =
+          index, match_data =
             @patterns
-              .map { |i, pattern| pattern.match(rhs) { |m| [m, i] } }
+              .transform_values { |pattern| pattern.match(rhs) }
               .compact
-              .max { |m| m[0].length }
+              .max_by { |_, m| m[0].length }
           match_data && [convert_match_data(match_data), index]
         end
 

data/lib/rggen/core/input_base/input_value_extractor.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module InputBase
+      class InputValueExtractor
+        def initialize(target_layers, target_value)
+          @target_layers = Array(target_layers)
+          @target_value = target_value
+        end
+
+        class << self
+          attr_reader :extractor
+
+          private
+
+          def extract(&body)
+            @extractor = body
+          end
+        end
+
+        def target_value?(layer, value)
+          value == @target_value &&
+            (@target_layers.empty? || @target_layers.include?(layer))
+        end
+
+        def extract(input_data)
+          body = self.class.extractor
+          instance_exec(input_data, &body)
+        end
+      end
+    end
+  end
+end

data/lib/rggen/core/input_base/loader.rb

@@ -4,40 +4,83 @@ module RgGen
   module Core
     module InputBase
       class Loader
-        class << self
-          def support_types(types)
-            @support_types = types.map(&:to_sym)
-          end
+        def self.support_types(types = nil)
+          types && (@support_types ||= []).concat(types.map(&:to_sym))
+          @support_types
+        end
 
-          def support?(file)
-            file_ext = File.ext(file).to_sym
-            @support_types.any? { |type| type.casecmp?(file_ext) }
-          end
+        def initialize(extractors, ignore_values)
+          @extractors = extractors
+          @ignore_values = ignore_values
+        end
 
-          def load_file(file, input_data, valid_value_list)
-            new(input_data, valid_value_list).load_file(file)
-          end
+        def support?(file)
+          ext = File.ext(file).to_sym
+          types = self.class.support_types
+          types&.any? { |type| type.casecmp?(ext) } || false
         end
 
-        def initialize(input_data, valid_value_lists)
+        def load_file(file, input_data, valid_value_lists)
+          File.readable?(file) ||
+            (raise Core::LoadError.new('cannot load such file', file))
           @input_data = input_data
           @valid_value_lists = valid_value_lists
+          format(read_file(file), input_data, input_data.layer, file)
         end
 
-        def load_file(file)
-          File.readable?(file) || (
-            raise Core::LoadError.new('cannot load such file', file)
-          )
-          format(read_file(file), file)
+        private
+
+        attr_reader :input_data
+
+        def format(read_data, input_data, layer, file)
+          layer_data =
+            format_layer_data(read_data, layer, file) ||
+            format_layer_data_by_extractors(read_data, layer)
+          layer_data &&
+            input_data.values(filter_layer_data(layer_data, layer), file)
+          format_sub_layer(read_data, input_data, layer, file)
         end
 
-        private
+        def format_sub_layer(read_data, input_data, layer, file)
+          format_sub_layer_data(read_data, layer, file)
+            &.flat_map { |sub_layer, data_array| [sub_layer].product(data_array) }
+            &.each do |(sub_layer, data)|
+              format(data, input_data.child(sub_layer), sub_layer, file)
+            end
+        end
 
-        def format(_read_data, _file)
+        def format_layer_data(_read_data, _layer, _file)
         end
 
-        attr_reader :input_data
-        attr_reader :valid_value_lists
+        def format_layer_data_by_extractors(read_data, layer)
+          layer_data = {}
+          valid_values(layer).each do |value|
+            @extractors
+              .select { |extractor| extractor.target_value?(layer, value) }
+              .each do |extractor|
+                extract_value(read_data, extractor, layer_data, value)
+              end
+          end
+          layer_data.empty? ? nil : layer_data
+        end
+
+        def extract_value(read_data, extractor, layer_data, value)
+          data = extractor.extract(read_data)
+          data && (layer_data[value] = data)
+        end
+
+        def filter_layer_data(layer_data, layer)
+          layer_data
+            .select { |key, _| valid_values(layer).include?(key) }
+        end
+
+        def format_sub_layer_data(_read_data, _layer, _file)
+        end
+
+        def valid_values(layer)
+          @valid_value_lists[layer]
+            .reject { |value| @ignore_values[layer]&.include?(value) }
+        end
       end
     end
   end

data/lib/rggen/core/input_base/verifier.rb

@@ -20,20 +20,19 @@ module RgGen
           @message = block
         end
 
-        def verify(feature)
+        def verify(feature, *values)
           if @error_checker
-            feature.instance_eval(&@error_checker)
+            feature.instance_exec(*values, &@error_checker)
           else
-            default_error_check(feature)
+            default_error_check(feature, values)
           end
         end
 
         private
 
-        def default_error_check(feature)
-          feature.instance_exec(@condition, @message) do |condition, message|
-            instance_eval(&condition) && error(instance_eval(&message))
-          end
+        def default_error_check(feature, values)
+          feature.instance_exec(*values, &@condition) &&
+            feature.__send__(:error, feature.instance_exec(*values, &@message))
         end
       end
     end