rggen-core 0.20.0 → 0.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9079e5f068e752e9f083fd64c97dda8cdc9f47f2e4ce3c6f1d0568f4950caa3
-  data.tar.gz: e60e14aa24f9f7b003391f0d87d773a35adbdf99c794016cdd803fc8025df8de
+  metadata.gz: 040113a3bef96502aae386b3aa7dafcca07af29d8881b41bfc6e17b3e0769885
+  data.tar.gz: 4392f0ae0bc1cd8d7422606eea73f11dffe293e29cc39250c5fd3479581dc349
 SHA512:
-  metadata.gz: 7f2b3f56089899d459e62bd6873166a467eec667d559690ad26a17558a72b4e399744d156c9a092181067a1313c82615db12a63469e8b7d9145678adfed2c830
-  data.tar.gz: a5cf836ea12ba57a905d925f29406f76155ce3e389d4678f76adee6da8bec9f5964c3f973f2803019c4aa8756f7223abf1de958f2ceb6b6fd97024d663c02327
+  metadata.gz: c77e46129bc726cb7afee6b21b3b31e2a692ee3fa2d99aade8eb6f6a3d1082e4f3fab1c83ff4f20afead532c521dfea6f23c8c6762a0b54ed9ab9cfbf013b484
+  data.tar.gz: c20b96a0be7b1f15cae6cc8b1512d05b83d8f06cb3407b34fe1731221065de3467522bdabfd74b2b5336fcc96b245a9eff191629ff58c61635b8ca77af511be1

data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017-2020 Taichi Ishitani
+Copyright (c) 2017-2021 Taichi Ishitani
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -13,6 +13,7 @@ RgGen::Core is a core library of RgGen tool and provides features listed below:
 * Basic loaders for configuration file and register map documents
     * Ruby with APIs for description
     * YAML
+    * TOML
     * JSON
 * Structure and APIs for defining output file writers
 * Building RgGen tool up by linking defined above features
@@ -43,7 +44,7 @@ Feedbacks, bug reports, questions and etc. are wellcome! You can post them by us
 
 ## Copyright & License
 
-Copyright © 2017-2020 Taichi Ishitani. RgGen::Core is licensed under the [MIT License](https://opensource.org/licenses/MIT), see [LICENSE](LICENSE) for futher details.
+Copyright © 2017-2021 Taichi Ishitani. RgGen::Core is licensed under the [MIT License](https://opensource.org/licenses/MIT), see [LICENSE](LICENSE) for futher details.
 
 ## Code of Conduct
 

data/exe/rggen

@@ -8,6 +8,6 @@ begin
   cli = RgGen::Core::CLI.new
   cli.run(ARGV)
 rescue ScriptError, StandardError => e
-  abort RgGen::Core::Utility::ErrorUtility
-          .compose_error_message(e, cli.options[:print_backtrace])
+  options = [cli.options[:print_verbose_info], cli.options[:print_backtrace]]
+  abort RgGen::Core::Utility::ErrorUtility.compose_error_message(e, *options)
 end

data/lib/rggen/core.rb

@@ -8,6 +8,7 @@ require 'json'
 require 'optparse'
 require 'pathname'
 require 'singleton'
+require 'tomlrb'
 require 'yaml'
 
 require_relative 'core/version'
@@ -38,8 +39,10 @@ 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/toml_loader'
 require_relative 'core/input_base/yaml_loader'
 require_relative 'core/input_base/component'
 require_relative 'core/input_base/component_factory'
@@ -59,6 +62,7 @@ require_relative 'core/configuration/loader'
 require_relative 'core/configuration/ruby_loader'
 require_relative 'core/configuration/hash_loader'
 require_relative 'core/configuration/json_loader'
+require_relative 'core/configuration/toml_loader'
 require_relative 'core/configuration/yaml_loader'
 require_relative 'core/configuration'
 
@@ -72,6 +76,7 @@ require_relative 'core/register_map/loader'
 require_relative 'core/register_map/ruby_loader'
 require_relative 'core/register_map/hash_loader'
 require_relative 'core/register_map/json_loader'
+require_relative 'core/register_map/toml_loader'
 require_relative 'core/register_map/yaml_loader'
 require_relative 'core/register_map'
 
@@ -87,16 +92,19 @@ 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'
 require_relative 'core/builder/list_feature_entry'
 require_relative 'core/builder/feature_registry'
 require_relative 'core/builder/layer'
-require_relative 'core/builder/plugins'
+require_relative 'core/builder/plugin_spec'
+require_relative 'core/builder/plugin_manager'
 require_relative 'core/builder/builder'
 require_relative 'core/builder'
 
+require_relative 'core/plugin'
 require_relative 'core/printers'
 require_relative 'core/options'
 require_relative 'core/dsl'

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

@@ -4,32 +4,36 @@ module RgGen
   module Core
     module Builder
       class Builder
+        extend Forwardable
+
         def initialize
           initialize_component_registries
           initialize_layers
-          @plugins = Plugins.new
+          @plugin_manager = PluginManager.new(self)
         end
 
-        attr_reader :plugins
+        attr_reader :plugin_manager
 
         def input_component_registry(name, &body)
-          component_registry(:input, name, body)
+          component_registry(:input, name, &body)
         end
 
         def output_component_registry(name, &body)
-          component_registry(:output, name, body)
-        end
-
-        def register_loader(component, loader)
-          @component_registries[:input][component].register_loader(loader)
+          component_registry(:output, name, &body)
         end
 
-        def register_loaders(component, loaders)
-          @component_registries[:input][component].register_loaders(loaders)
+        [
+          :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 define_loader(component, &body)
-          @component_registries[:input][component].define_loader(&body)
+        def register_map_layers
+          REGISTER_MAP_LAYERS
         end
 
         def add_feature_registry(name, target_layer, registry)
@@ -90,23 +94,9 @@ module RgGen
           RegisterMap.setup(self)
         end
 
-        def setup(name, module_or_version = nil, &block)
-          plugins.add(name, module_or_version, &block)
-        end
-
-        def activate_plugins(**options)
-          plugins.activate(self, **options)
-        end
-
-        def load_setup_file(file, activation = true)
-          (file.nil? || file.empty?) &&
-            (raise Core::LoadError.new('no setup file is given'))
-          File.readable?(file) ||
-            (raise Core::LoadError.new("cannot load such setup file: #{file}"))
-          RgGen.builder(self)
-          load(file)
-          activation && activate_plugins
-        end
+        def_delegator :plugin_manager, :load_plugin
+        def_delegator :plugin_manager, :load_plugins
+        def_delegator :plugin_manager, :register_plugin
 
         private
 
@@ -119,26 +109,30 @@ module RgGen
           end
         end
 
+        REGISTER_MAP_LAYERS = [
+          :root, :register_block, :register_file, :register, :bit_field
+        ].freeze
+
+        ALL_LAYERS = [
+          :global, *REGISTER_MAP_LAYERS
+        ].freeze
+
         def initialize_layers
           @layers = Hash.new do |_, layer_name|
             raise BuilderError.new("unknown layer: #{layer_name}")
           end
-          [
-            :global, :root, :register_block, :register_file, :register, :bit_field
-          ].each do |layer|
-            @layers[layer] = Layer.new(layer)
-          end
+          ALL_LAYERS.each { |layer| @layers[layer] = Layer.new(layer) }
         end
 
         COMPONENT_REGISTRIES = {
           input: InputComponentRegistry, output: OutputComponentRegistry
         }.freeze
 
-        def component_registry(type, name, body)
+        def component_registry(type, name, &body)
           registries = @component_registries[type]
           klass = COMPONENT_REGISTRIES[type]
           registries.key?(name) || (registries[name] = klass.new(name, self))
-          Docile.dsl_eval(registries[name], &body)
+          block_given? && Docile.dsl_eval(registries[name], &body) || registries[name]
         end
       end
     end

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

@@ -11,22 +11,22 @@ module RgGen
         end
 
         def register_component(layers = nil, &block)
-          if layers
-            Array(layers).each do |layer|
-              @entries << create_new_entry(layer, block)
-            end
-          else
-            @entries << create_new_entry(nil, block)
+          Array(layers || @builder.register_map_layers).each do |layer|
+            @entries << create_new_entry(layer, &block)
           end
         end
 
+        def register_global_component(&block)
+          @entries << create_new_entry(nil, &block)
+        end
+
         def build_factory
           build_factories.first.tap(&:root_factory)
         end
 
         private
 
-        def create_new_entry(layer, block)
+        def create_new_entry(layer, &block)
           entry = ComponentEntry.new(@component_name, layer)
           Docile.dsl_eval(entry, layer, &block)
           add_feature_registry(layer, entry.feature_registry)
@@ -35,8 +35,7 @@ module RgGen
 
         def add_feature_registry(layer, feature_registry)
           feature_registry &&
-            @builder
-              .add_feature_registry(@component_name, layer, feature_registry)
+            @builder.add_feature_registry(@component_name, layer, feature_registry)
         end
 
         def build_factories

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

@@ -11,22 +11,19 @@ module RgGen
           @enabled_features = {}
         end
 
-        def define_simple_feature(names, context = nil, &body)
-          Array(names)
-            .each { |name| create_new_entry(:simple, name, context, body) }
+        def define_simple_feature(name, context = nil, &body)
+          create_new_entry(:simple, name, context, body)
         end
 
-        def define_list_feature(list_names, context = nil, &body)
-          Array(list_names)
-            .each { |name| create_new_entry(:list, name, context, body) }
+        def define_list_feature(list_name, context = nil, &body)
+          create_new_entry(:list, list_name, context, body)
         end
 
-        def define_list_item_feature(list_name, feature_names, context = nil, &body)
+        def define_list_item_feature(list_name, feature_name, context = nil, &body)
           entry = @feature_entries[list_name]
           entry&.match_entry_type?(:list) ||
             (raise BuilderError.new("unknown list feature: #{list_name}"))
-          Array(feature_names)
-            .each { |name| entry.define_feature(name, context, &body) }
+          entry.define_feature(feature_name, context, &body)
         end
 
         def enable(feature_or_list_names, feature_names = nil)

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/layer.rb

@@ -11,16 +11,8 @@ module RgGen
 
           attr_setter :body
           attr_setter :method_name
-          attr_setter :list_names
-          attr_setter :feature_names
-
-          def shared_context(&body)
-            if block_given?
-              @shared_context ||= Object.new
-              @shared_context.instance_eval(&body)
-            end
-            @shared_context
-          end
+          attr_setter :list_name
+          attr_setter :feature_name
 
           def register_execution(registry, &body)
             @executions ||= []
@@ -29,15 +21,14 @@ module RgGen
 
           def execute(layer)
             Docile.dsl_eval(layer, &body)
-            @executions&.each(&method(:call_execution))
+            @executions&.each { |execution| call_execution(layer, execution) }
           end
 
           private
 
-          def call_execution(execution)
-            args = [list_names, feature_names, shared_context].compact
-            execution[:registry]
-              .__send__(method_name, *args, &execution[:body])
+          def call_execution(layer, execution)
+            args = [list_name, feature_name, layer.shared_context].compact
+            execution[:registry].__send__(method_name, *args, &execution[:body])
           end
         end
 
@@ -52,31 +43,44 @@ module RgGen
         end
 
         def shared_context(&body)
-          block_given? && @proxy&.shared_context(&body)
+          return unless @proxy
+
+          if block_given?
+            context = current_shared_context(true)
+            context.singleton_exec(&body)
+          end
+
+          current_shared_context(false)
         end
 
         def define_simple_feature(feature_names, &body)
-          do_proxy_call do |proxy|
-            proxy.body(body)
-            proxy.method_name(__method__)
-            proxy.feature_names(feature_names)
+          Array(feature_names).each do |feature_name|
+            do_proxy_call do |proxy|
+              proxy.body(body)
+              proxy.method_name(__method__)
+              proxy.feature_name(feature_name)
+            end
           end
         end
 
         def define_list_feature(list_names, &body)
-          do_proxy_call do |proxy|
-            proxy.body(body)
-            proxy.method_name(__method__)
-            proxy.list_names(list_names)
+          Array(list_names).each do |list_name|
+            do_proxy_call do |proxy|
+              proxy.body(body)
+              proxy.method_name(__method__)
+              proxy.list_name(list_name)
+            end
           end
         end
 
         def define_list_item_feature(list_name, feature_names, &body)
-          do_proxy_call do |proxy|
-            proxy.body(body)
-            proxy.method_name(__method__)
-            proxy.list_names(list_name)
-            proxy.feature_names(feature_names)
+          Array(feature_names).each do |feature_name|
+            do_proxy_call do |proxy|
+              proxy.body(body)
+              proxy.method_name(__method__)
+              proxy.list_name(list_name)
+              proxy.feature_name(feature_name)
+            end
           end
         end
 
@@ -111,6 +115,17 @@ module RgGen
           @proxy.execute(self)
           remove_instance_variable(:@proxy)
         end
+
+        def current_shared_context(allocate)
+          list_name = @proxy.list_name || @proxy.feature_name
+          feature_name = @proxy.feature_name
+          allocate && (shared_contexts[list_name][feature_name] ||= Object.new)
+          shared_contexts[list_name][feature_name]
+        end
+
+        def shared_contexts
+          @shared_contexts ||= Hash.new { |h, k| h[k] = {} }
+        end
       end
     end
   end