rggen-core 0.20.0 → 0.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9079e5f068e752e9f083fd64c97dda8cdc9f47f2e4ce3c6f1d0568f4950caa3
-  data.tar.gz: e60e14aa24f9f7b003391f0d87d773a35adbdf99c794016cdd803fc8025df8de
+  metadata.gz: 135125b25bc30e8eb74fa97644c356afd817cda2a84a810a401efbcde7d2a647
+  data.tar.gz: c4cb605aaa49801ff0f70458148f1349a220de2c41b6f7ed614e98466e425668
 SHA512:
-  metadata.gz: 7f2b3f56089899d459e62bd6873166a467eec667d559690ad26a17558a72b4e399744d156c9a092181067a1313c82615db12a63469e8b7d9145678adfed2c830
-  data.tar.gz: a5cf836ea12ba57a905d925f29406f76155ce3e389d4678f76adee6da8bec9f5964c3f973f2803019c4aa8756f7223abf1de958f2ceb6b6fd97024d663c02327
+  metadata.gz: 122340fafae09f08a604c54b3f21e8428a0d03af5ef81b37f4211f881a99186c2f0a45e50cad9367406a75f784041eabc0ef87ebf692946a2dfbec5221135e8f
+  data.tar.gz: fb87835adc54ec4416f5811126ff65355ada76e05cc46d89eedbe87e2899fd16665d26caf66e41a9919a074824f51ef97fd6dee9abc2aa959b42d83b9c4dd35c

data/lib/rggen/core.rb

@@ -38,6 +38,7 @@ require_relative 'core/base/feature_layer_extension'
 
 require_relative 'core/input_base/input_value'
 require_relative 'core/input_base/input_data'
+require_relative 'core/input_base/input_value_extractor'
 require_relative 'core/input_base/loader'
 require_relative 'core/input_base/json_loader'
 require_relative 'core/input_base/yaml_loader'
@@ -87,6 +88,7 @@ require_relative 'core/output_base/feature_factory'
 
 require_relative 'core/builder/component_entry'
 require_relative 'core/builder/component_registry'
+require_relative 'core/builder/loader_registry'
 require_relative 'core/builder/input_component_registry'
 require_relative 'core/builder/output_component_registry'
 require_relative 'core/builder/simple_feature_entry'

data/lib/rggen/core/builder/builder.rb

@@ -20,16 +20,14 @@ module RgGen
           component_registry(:output, name, body)
         end
 
-        def register_loader(component, loader)
-          @component_registries[:input][component].register_loader(loader)
-        end
-
-        def register_loaders(component, loaders)
-          @component_registries[:input][component].register_loaders(loaders)
-        end
-
-        def define_loader(component, &body)
-          @component_registries[:input][component].define_loader(&body)
+        [
+          :register_loader, :register_loaders,
+          :define_value_extractor, :ignore_value, :ignore_values
+        ].each do |method_name|
+          define_method(method_name) do |component, *args, &block|
+            @component_registries[:input][component]
+              .__send__(__method__, *args, &block)
+          end
         end
 
         def add_feature_registry(name, target_layer, registry)

data/lib/rggen/core/builder/input_component_registry.rb

@@ -6,29 +6,62 @@ module RgGen
       class InputComponentRegistry < ComponentRegistry
         def initialize(name, builder)
           super
-          @loaders = []
+          @loader_registries = {}
         end
 
-        attr_setter :base_loader
+        def register_loader(loader_type, loader)
+          loader_registry(loader_type).register_loader(loader)
+        end
+
+        def register_loaders(loader_type, loaders)
+          loader_registry(loader_type).register_loaders(loaders)
+        end
 
-        def register_loader(loader)
-          @loaders << loader
+        def define_value_extractor(loader_type, layers_or_value, value = nil, &body)
+          layers, value =
+            if value
+              [layers_or_value, value]
+            else
+              [nil, layers_or_value]
+            end
+          loader_registry(loader_type).define_value_extractor(layers, value, &body)
         end
 
-        def register_loaders(loaders)
-          @loaders.concat(Array(loaders))
+        def ignore_value(loader_type, layers_or_value, value = nil)
+          layers, value =
+            if value
+              [layers_or_value, value]
+            else
+              [nil, layers_or_value]
+            end
+          loader_registry(loader_type).ignore_value(layers, value)
         end
 
-        def define_loader(&body)
-          loader = Class.new(@base_loader, &body)
-          register_loader(loader)
+        def ignore_values(loader_type, layers_or_values, values = nil)
+          layers, values =
+            if values
+              [layers_or_values, values]
+            else
+              [nil, layers_or_values]
+            end
+          loader_registry(loader_type).ignore_values(layers, values)
         end
 
         def build_factory
           factory = super
-          factory.loaders(@loaders)
+          factory.loaders(build_loaders)
           factory
         end
+
+        private
+
+        def loader_registry(loader_type)
+          @loader_registries[loader_type] ||= LoaderRegistry.new
+        end
+
+        def build_loaders
+          @loader_registries.values.flat_map(&:create_loaders)
+        end
       end
     end
   end

data/lib/rggen/core/builder/loader_registry.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Builder
+      class LoaderRegistry
+        def initialize
+          @loaders = []
+          @extractors = []
+          @ignore_values = {}
+        end
+
+        def register_loader(loader)
+          register_loaders([loader])
+        end
+
+        def register_loaders(loaders)
+          @loaders.concat(Array(loaders))
+        end
+
+        def define_value_extractor(layers, value, &body)
+          @extractors <<
+            create_extractor(layers, value, &body)
+        end
+
+        def ignore_value(layers, value)
+          ignore_values(layers, [value])
+        end
+
+        def ignore_values(layers, values)
+          [layers].flatten.each do |layer|
+            (@ignore_values[layer] ||= []).concat(Array(values))
+          end
+        end
+
+        def create_loaders
+          @loaders.map { |loader| loader.new(@extractors, @ignore_values) }
+        end
+
+        private
+
+        def create_extractor(layers, value, &body)
+          Class.new(Core::InputBase::InputValueExtractor, &body).new(layers, value)
+        end
+      end
+    end
+  end
+end

data/lib/rggen/core/configuration.rb

@@ -10,8 +10,9 @@ module RgGen
             feature Feature, FeatureFactory
           end
 
-          base_loader Loader
-          register_loaders [RubyLoader, JSONLoader, YAMLLoader]
+          register_loader :ruby, RubyLoader
+          register_loader :yaml, YAMLLoader
+          register_loader :json, JSONLoader
         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/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,39 +4,83 @@ module RgGen
   module Core
     module InputBase
       class Loader
-        class << self
-          def support_types(types)
-            @support_types = types.map(&:to_sym)
-          end
-
-          def support?(file)
-            file_ext = File.ext(file).to_sym
-            @support_types.any? { |type| type.casecmp?(file_ext) }
-          end
+        def self.support_types(types = nil)
+          types && (@support_types ||= []).concat(types.map(&:to_sym))
+          @support_types
+        end
 
-          def load_file(file, input_data, valid_value_list)
-            new(input_data, valid_value_list).load_file(file)
-          end
+        def initialize(extractors, ignore_values)
+          @extractors = extractors
+          @ignore_values = ignore_values
         end
 
-        def initialize(input_data, valid_value_lists)
-          @input_data = input_data
-          @valid_value_lists = valid_value_lists
+        def support?(file)
+          ext = File.ext(file).to_sym
+          types = self.class.support_types
+          types&.any? { |type| type.casecmp?(ext) } || false
         end
 
-        def load_file(file)
+        def load_file(file, input_data, valid_value_lists)
           File.readable?(file) ||
             (raise Core::LoadError.new('cannot load such file', file))
-          format(read_file(file), file)
+          @input_data = input_data
+          @valid_value_lists = valid_value_lists
+          format(read_file(file), input_data, input_data.layer, file)
         end
 
         private
 
-        def format(_read_data, _file)
+        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
 
-        attr_reader :input_data
-        attr_reader :valid_value_lists
+        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_layer_data(_read_data, _layer, _file)
+        end
+
+        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/register_map.rb

@@ -12,8 +12,9 @@ module RgGen
             feature Feature, FeatureFactory if layer != :root
           end
 
-          base_loader Loader
-          register_loaders [RubyLoader, JSONLoader, YAMLLoader]
+          register_loader :ruby, RubyLoader
+          register_loader :yaml, YAMLLoader
+          register_loader :json, JSONLoader
         end
       end
     end

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

@@ -4,36 +4,77 @@ module RgGen
   module Core
     module RegisterMap
       module HashLoader
-        def format(read_data, file)
-          format_data(:root, root, read_data, file)
-        rescue TypeError => e
-          raise Core::LoadError.new(e.message, file)
-        end
-
         private
 
-        LAYER_MAP = {
+        SUB_LAYER_KEYS = {
+          root: [:register_block, :register_blocks],
+          register_block: [:register_file, :register_files, :register, :registers],
+          register_file: [:register_file, :register_files, :register, :registers],
+          register: [:bit_field, :bit_fields]
+        }.freeze
+
+        SUB_LAYER_KEY_MAP = {
           root: { register_blocks: :register_block },
           register_block: { register_files: :register_file, registers: :register },
           register_file: { register_files: :register_file, registers: :register },
           register: { bit_fields: :bit_field }
         }.freeze
 
-        def format_data(layer, input_data, read_data, file)
-          read_data = Hash(read_data)
-          input_data.values(read_data, file)
-          format_next_layer_data(layer, input_data, read_data, file)
+        def format_layer_data(read_data, layer, file)
+          if read_data.is_a?(Array)
+            format_array_layer_data(read_data, layer, file)
+          else
+            fomrat_hash_layer_data(read_data, layer, file)
+          end
+        end
+
+        def format_array_layer_data(read_data, layer, file)
+          read_data.each_with_object({}) do |data, layer_data|
+            layer_data.merge!(fomrat_hash_layer_data(data, layer, file))
+          end
+        end
+
+        def fomrat_hash_layer_data(read_data, layer, file)
+          convert_to_hash(read_data, file)
+            .reject { |key, _| SUB_LAYER_KEYS[layer]&.include?(key) }
         end
 
-        def format_next_layer_data(layer, input_data, read_data, file)
-          LAYER_MAP[layer]&.each do |key, next_layer|
-            Array(read_data[key]).each do |data|
-              format_data(
-                next_layer, input_data.child(next_layer), data, file
-              )
+        def format_sub_layer_data(read_data, layer, file)
+          if read_data.is_a?(Array)
+            format_array_sub_layer_data(read_data, layer, file)
+          else
+            format_hash_sub_layer_data(read_data, layer, file)
+          end
+        end
+
+        def format_array_sub_layer_data(read_data, layer, file)
+          read_data.each_with_object({}) do |data, sub_layer_data|
+            format_hash_sub_layer_data(data, layer, file, sub_layer_data)
+          end
+        end
+
+        def format_hash_sub_layer_data(read_data, layer, file, sub_layer_data = {})
+          convert_to_hash(read_data, file)
+            .select { |key, _| SUB_LAYER_KEYS[layer]&.include?(key) }
+            .each do |key, value|
+              merge_sub_layer_data(sub_layer_data, layer, key, value)
             end
+          sub_layer_data
+        end
+
+        def merge_sub_layer_data(sub_layer_data, layer, key, value)
+          if SUB_LAYER_KEY_MAP[layer].key?(key)
+            (sub_layer_data[SUB_LAYER_KEY_MAP[layer][key]] ||= []).concat(value)
+          else
+            (sub_layer_data[key] ||= []) << value
           end
         end
+
+        def convert_to_hash(read_data, file)
+          Hash(read_data)
+        rescue TypeError => e
+          raise Core::LoadError.new(e.message, file)
+        end
       end
     end
   end

data/lib/rggen/core/version.rb

@@ -3,7 +3,7 @@
 module RgGen
   module Core
     MAJOR = 0
-    MINOR = 20
+    MINOR = 21
     PATCH = 0
     VERSION = "#{MAJOR}.#{MINOR}.#{PATCH}"
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rggen-core
 version: !ruby/object:Gem::Version
-  version: 0.20.0
+  version: 0.21.0
 platform: ruby
 authors:
 - Taichi Ishitani
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-07-06 00:00:00.000000000 Z
+date: 2020-07-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: docile
@@ -96,6 +96,7 @@ files:
 - lib/rggen/core/builder/input_component_registry.rb
 - lib/rggen/core/builder/layer.rb
 - lib/rggen/core/builder/list_feature_entry.rb
+- lib/rggen/core/builder/loader_registry.rb
 - lib/rggen/core/builder/output_component_registry.rb
 - lib/rggen/core/builder/plugins.rb
 - lib/rggen/core/builder/simple_feature_entry.rb
@@ -124,6 +125,7 @@ files:
 - lib/rggen/core/input_base/input_data.rb
 - lib/rggen/core/input_base/input_matcher.rb
 - lib/rggen/core/input_base/input_value.rb
+- lib/rggen/core/input_base/input_value_extractor.rb
 - lib/rggen/core/input_base/json_loader.rb
 - lib/rggen/core/input_base/loader.rb
 - lib/rggen/core/input_base/property.rb
@@ -187,5 +189,5 @@ requirements: []
 rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
-summary: rggen-core-0.20.0
+summary: rggen-core-0.21.0
 test_files: []