rggen-core 0.25.0 → 0.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 57e33c7b563198efa0e1d2c20adcb0b6896d72d4575673c9f64761aeca93779a
-  data.tar.gz: 61e593cab9704bdc330a3767791afc9e6373020809777c7cd4f67ac18adb7b92
+  metadata.gz: 87457243bd057e719ca35386df5b23f6c0cc72a86029e93998b51d8436f0b184
+  data.tar.gz: 96a4fd969fd9399e3a1bffdbc9319315bcd9a4df1f45827eb31517eb942bb489
 SHA512:
-  metadata.gz: 40b23ff5bd0eca3b9a53cda4cb37a220bd8e7a5648bfce598c1404031bfb43421eda997eb8a7c37868e31418a54c7267d336f72631d29522106c20dc3752433a
-  data.tar.gz: 6918ad93d019dd22e4af13205eb5c8529b1ae8b7c71cd50352b183ae84d3c5a54682189e606859adcd7e70cd292f42d11b8621997cff95ac2e89e2b47f876d1f
+  metadata.gz: ab5f4642ecd2d47c88dfffe5432733c7c91320dace927c84d537cdc12be2e54ab70cf9e4ee32f47bd03f7ec044090f13e1b4a4efab6fa1f2549f6e99d3f05d5d
+  data.tar.gz: 1faf35891545834a2ba9df954b15d818c65ea6910859c4987c8e587d495dcfd167fbbb0a5a9206d060fca16c817a004474d721298ac0f6fa9eecbef2dccb04dc

data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017-2021 Taichi Ishitani
+Copyright (c) 2017-2022 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

@@ -37,14 +37,15 @@ $ gem install rggen-core
 
 Feedbacks, bug reports, questions and etc. are wellcome! You can post them by using following ways:
 
-* [GitHub Issue Tracker](https://github.com/rggen/rggen-core/issues)
+* [GitHub Issue Tracker](https://github.com/rggen/rggen/issues)
+* [GitHub Discussions](https://github.com/rggen/rggen/discussions)
 * [Chat Room](https://gitter.im/rggen/rggen)
 * [Mailing List](https://groups.google.com/d/forum/rggen)
 * [Mail](mailto:rggen@googlegroups.com)
 
 ## Copyright & License
 
-Copyright © 2017-2021 Taichi Ishitani. RgGen::Core is licensed under the [MIT License](https://opensource.org/licenses/MIT), see [LICENSE](LICENSE) for futher details.
+Copyright © 2017-2022 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/lib/rggen/core/base/component_factory.rb

@@ -27,7 +27,7 @@ module RgGen
             if root_factory?
               [nil, preprocess(args)]
             else
-              [args.first, preprocess(args[1..-1])]
+              [args.first, preprocess(args[1..])]
             end
           create_component(parent, sources) do |component|
             build_component(parent, component, sources)

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

@@ -24,11 +24,10 @@ module RgGen
 
         [
           :register_loader, :register_loaders,
-          :define_value_extractor, :ignore_value, :ignore_values
+          :setup_loader, :define_value_extractor
         ].each do |method_name|
           define_method(method_name) do |component, *args, &block|
-            @component_registries[:input][component]
-              .__send__(__method__, *args, &block)
+            @component_registries[:input][component].__send__(__method__, *args, &block)
           end
         end
 
@@ -61,12 +60,8 @@ module RgGen
           @layers[layer].enable(*args)
         end
 
-        def disable_all
-          @layers.each_value(&:disable)
-        end
-
-        def disable(layer, *args)
-          @layers.key?(layer) && @layers[layer].disable(*args)
+        def enable_all
+          @layers.each_value(&:enable_all)
         end
 
         def build_factory(type, component)
@@ -94,7 +89,7 @@ module RgGen
 
         def_delegator :plugin_manager, :load_plugin
         def_delegator :plugin_manager, :load_plugins
-        def_delegator :plugin_manager, :register_plugin
+        def_delegator :plugin_manager, :setup_plugin
 
         private
 

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

@@ -42,7 +42,7 @@ module RgGen
           factories =
             @entries
               .map(&:build_factory)
-              .map { |f| [f.layer, f] }.to_h
+              .to_h { |f| [f.layer, f] }
           factories.each_value { |f| f.component_factories factories }
           factories.values
         end

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

@@ -28,68 +28,61 @@ module RgGen
 
         def enable(feature_or_list_names, feature_names = nil)
           if feature_names
-            @enabled_features[feature_or_list_names]
-              &.merge!(Array(feature_names))
+            list_name = feature_or_list_names
+            (@enabled_features[list_name] ||= []).merge!(Array(feature_names))
           else
             Array(feature_or_list_names).each do |name|
-              @enabled_features[name] ||= []
+              @enabled_features.key?(name) || (@enabled_features[name] = nil)
             end
           end
         end
 
-        def enabled_features(list_name = nil)
-          if list_name
-            @enabled_features[list_name] || []
-          else
-            @enabled_features.keys
-          end
-        end
-
-        def disable(feature_or_list_names = nil, feature_names = nil)
-          if feature_names
-            @enabled_features[feature_or_list_names]
-              &.delete_if { |key, _| Array(feature_names).include?(key) }
-          elsif feature_or_list_names
-            Array(feature_or_list_names)
-              .each(&@enabled_features.method(:delete))
-          else
-            @enabled_features.clear
-          end
+        def enable_all
+          @enabled_features.clear
         end
 
         def delete(feature_or_list_names = nil, feature_names = nil)
           if feature_names
             @feature_entries[feature_or_list_names]&.delete(feature_names)
           elsif feature_or_list_names
-            Array(feature_or_list_names)
-              .each(&@feature_entries.method(:delete))
+            Array(feature_or_list_names).each(&@feature_entries.method(:delete))
           else
             @feature_entries.clear
           end
         end
 
         def simple_feature?(feature_name)
-          enabled_feature?(feature_name, :simple)
+          @feature_entries[feature_name]&.match_entry_type?(:simple) || false
         end
 
         def list_feature?(list_name, feature_name = nil)
-          return false unless enabled_feature?(list_name, :list)
+          return false unless @feature_entries[list_name]&.match_entry_type?(:list)
           return true unless feature_name
-          enabled_list_item_feature?(list_name, feature_name)
+          @feature_entries[list_name].feature?(feature_name)
         end
 
         def feature?(feature_or_list_name, feature_name = nil)
           if feature_name
             list_feature?(feature_or_list_name, feature_name)
           else
-            simple_feature?(feature_or_list_name) ||
-              list_feature?(feature_or_list_name)
+            simple_feature?(feature_or_list_name) || list_feature?(feature_or_list_name)
+          end
+        end
+
+        def enabled_features(list_name = nil)
+          if list_name
+            enabled_list_features(list_name)
+          else
+            @enabled_features.empty? && @feature_entries.keys ||
+              @enabled_features.keys & @feature_entries.keys
           end
         end
 
         def build_factories
+          target_features =
+            (@enabled_features.empty? && @feature_entries || @enabled_features).keys
           @feature_entries
-            .slice(*@enabled_features.keys)
+            .slice(*target_features)
             .transform_values(&method(:build_factory))
         end
 
@@ -105,16 +98,17 @@ module RgGen
           @feature_entries[name] = entry
         end
 
-        def enabled_feature?(name, entry_type)
-          return false unless @feature_entries[name]
-                                &.match_entry_type?(entry_type)
-          @enabled_features.key?(name)
+        def enabled_list_features(list_name)
+          return [] unless enabled_list?(list_name)
+          features = @feature_entries[list_name].features
+          (@enabled_features[list_name] || features) & features
         end
 
-        def enabled_list_item_feature?(list_name, feature_name)
-          return false unless @feature_entries[list_name]
-                                .feature?(feature_name)
-          @enabled_features[list_name].include?(feature_name)
+        def enabled_list?(list_name)
+          return false unless list_feature?(list_name)
+          return true if @enabled_features.empty?
+          return true if @enabled_features.key?(list_name)
+          false
         end
 
         def build_factory(entry)

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

@@ -6,45 +6,26 @@ module RgGen
       class InputComponentRegistry < ComponentRegistry
         def initialize(name, builder)
           super
-          @loader_registries = {}
+          @loader_registries = Hash.new do |h, k|
+            h[k] = LoaderRegistry.new
+          end
         end
 
         def register_loader(loader_type, loader)
-          loader_registry(loader_type).register_loader(loader)
+          @loader_registries[loader_type].register_loader(loader)
         end
 
         def register_loaders(loader_type, loaders)
-          loader_registry(loader_type).register_loaders(loaders)
+          @loader_registries[loader_type].register_loaders(loaders)
         end
 
-        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 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)
+        def setup_loader(loader_type)
+          block_given? && yield(@loader_registries[loader_type])
         end
 
-        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)
+        def define_value_extractor(loader_type, layers_or_value, value = nil, &body)
+          @loader_registries[loader_type]
+            .define_value_extractor(layers_or_value, value, &body)
         end
 
         def build_factory
@@ -55,10 +36,6 @@ module RgGen
 
         private
 
-        def loader_registry(loader_type)
-          @loader_registries[loader_type] ||= LoaderRegistry.new
-        end
-
         def build_loaders
           @loader_registries.values.flat_map(&:create_loaders)
         end

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

@@ -90,10 +90,8 @@ module RgGen
           end
         end
 
-        def disable(feature_or_list_names = nil, feature_names = nil)
-          @feature_registries.each_value do |registry|
-            registry.disable(*[feature_or_list_names, feature_names].compact)
-          end
+        def enable_all
+          @feature_registries.each_value(&:enable_all)
         end
 
         def delete(feature_or_list_names = nil, feature_names = nil)

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

@@ -32,9 +32,9 @@ module RgGen
 
         alias_method :factory, :define_factory
 
-        def build_factory(enabled_features)
+        def build_factory(targets)
           @factory.new(@name) do |f|
-            f.target_features(target_features(enabled_features))
+            f.target_features(target_features(targets))
             f.target_feature(@default_feature)
           end
         end
@@ -77,6 +77,10 @@ module RgGen
           @features.key?(feature)
         end
 
+        def features
+          @features.keys
+        end
+
         private
 
         def attach_shared_context(context)
@@ -85,8 +89,8 @@ module RgGen
           end
         end
 
-        def target_features(enabled_features)
-          @features.slice(*enabled_features)
+        def target_features(targets)
+          targets && @features.slice(*targets) || @features
         end
       end
     end

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

@@ -11,22 +11,25 @@ module RgGen
         end
 
         def register_loader(loader)
-          register_loaders([loader])
+          @loaders << loader
         end
 
         def register_loaders(loaders)
           @loaders.concat(Array(loaders))
         end
 
-        def define_value_extractor(layers, value, &body)
+        def define_value_extractor(layers_or_value, value = nil, &body)
+          value, layers = [value, layers_or_value].compact
           @extractors << create_extractor(layers, value, &body)
         end
 
-        def ignore_value(layers, value)
+        def ignore_value(layers_or_value, value = nil)
+          value, layers = [value, layers_or_value].compact
           ignore_values(layers, [value])
         end
 
-        def ignore_values(layers, values)
+        def ignore_values(layers_or_values, values = nil)
+          values, layers = [values, layers_or_values].compact
           [layers].flatten.each do |layer|
             (@ignore_values[layer] ||= []).concat(Array(values))
           end

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

@@ -3,22 +3,65 @@
 module RgGen
   module Core
     module Builder
-      class PluginRegistry
-        def initialize(plugin_module, &block)
-          @plugin_module = plugin_module
-          @block = block
+      DEFAULT_PLUGSINS = 'rggen/default'
+
+      class PluginInfo
+        attr_reader :path
+        attr_reader :gemname
+        attr_reader :version
+
+        def self.parse(path_or_name, version)
+          info = new
+          info.parse(path_or_name.to_s.strip, version)
+          info
         end
 
-        def default_setup(builder)
-          @plugin_module.plugin_spec.activate(builder)
+        def parse(path_or_name, version)
+          @name, @path, @gemname, @version =
+            if plugin_path?(path_or_name)
+              [nil, path_or_name, *find_gemspec_by_path(path_or_name)]
+            else
+              [
+                path_or_name, get_plugin_path(path_or_name),
+                get_gemname(path_or_name), version
+              ]
+            end
         end
 
-        def optional_setup(builder)
-          @block && @plugin_module.instance_exec(builder, &@block)
+        def to_s
+          if @name && @version
+            "#{@name} (#{@version})"
+          elsif @name
+            @name
+          else
+            @path
+          end
         end
 
-        def version_info
-          @plugin_module.plugin_spec.version_info
+        private
+
+        def plugin_path?(path_or_name)
+          path_or_name == DEFAULT_PLUGSINS || File.ext(path_or_name) == 'rb'
+        end
+
+        def find_gemspec_by_path(path)
+          Gem::Specification
+            .each.find { |spec| match_gemspec_path?(spec, path) }
+            .yield_self { |spec| spec && [spec.name, spec.version] }
+        end
+
+        def match_gemspec_path?(gemspec, path)
+          gemspec.full_require_paths.any?(&path.method(:start_with?))
+        end
+
+        def get_plugin_path(name)
+          base_name, sub_name = name.split('/', 2)
+          base_name = base_name.sub(/^rggen[-_]/, '').tr('-', '_')
+          File.join(*['rggen', base_name, sub_name].compact)
+        end
+
+        def get_gemname(name)
+          name.split('/', 2).first
         end
       end
 
@@ -28,34 +71,31 @@ module RgGen
           @plugins = []
         end
 
-        def load_plugin(setup_path_or_name)
-          setup_path_or_name = setup_path_or_name.to_s.strip
-          setup_path =
-            if setup_file_directly_given?(setup_path_or_name)
-              setup_path_or_name
-            else
-              get_setup_path(setup_path_or_name)
-            end
-          read_setup_file(setup_path, setup_path_or_name)
+        def load_plugin(path_or_name, version = nil)
+          info = PluginInfo.parse(path_or_name, version)
+          read_plugin_file(info)
         end
 
         def load_plugins(plugins, no_default_plugins, activation = true)
           RgGen.builder(@builder)
-          merge_plugins(plugins, no_default_plugins).each(&method(:load_plugin))
+          merge_plugins(plugins, no_default_plugins)
+            .each { |plugin| load_plugin(*plugin) }
           activation && activate_plugins
         end
 
-        def register_plugin(plugin_module, &block)
-          plugin?(plugin_module) ||
-            (raise Core::PluginError.new('no plugin spec is given'))
-          @plugins << PluginRegistry.new(plugin_module, &block)
+        def setup_plugin(plugin_name, &block)
+          @plugins << PluginSpec.new(plugin_name, &block)
         end
 
-        def activate_plugins(**options)
-          options[:no_default_setup] ||
-            @plugins.each { |plugin| plugin.default_setup(@builder) }
-          options[:no_optional_setup] ||
-            @plugins.each { |plugin| plugin.optional_setup(@builder) }
+        def activate_plugins
+          @plugins.each { |plugin| plugin.activate(@builder) }
+          @plugins.each { |plugin| plugin.activate_additionally(@builder) }
+        end
+
+        def activate_plugin_by_name(plugin_name)
+          target_plugin = @plugins.find { |plugin| plugin.name == plugin_name }
+          target_plugin&.activate(@builder)
+          target_plugin&.activate_additionally(@builder)
         end
 
         def version_info
@@ -64,27 +104,11 @@ module RgGen
 
         private
 
-        def setup_file_directly_given?(setup_path_or_name)
-          File.ext(setup_path_or_name) == 'rb' ||
-            File.basename(setup_path_or_name, '.*') == 'setup'
-        end
-
-        def get_setup_path(name)
-          base, sub_directory = name.split('/', 2)
-          base = base.sub(/^rggen[-_]/, '').tr('-', '_')
-          File.join(*['rggen', base, sub_directory, 'setup'].compact)
-        end
-
-        def read_setup_file(setup_path, setup_path_or_name)
-          require setup_path
+        def read_plugin_file(info)
+          info.gemname && gem(info.gemname, info.version)
+          require info.path
         rescue ::LoadError
-          message =
-            if setup_path_or_name == setup_path
-              "cannot load such plugin: #{setup_path_or_name}"
-            else
-              "cannot load such plugin: #{setup_path_or_name} (#{setup_path})"
-            end
-          raise Core::PluginError.new(message)
+          raise Core::PluginError.new("cannot load such plugin: #{info}")
         end
 
         def merge_plugins(plugins, no_default_plugins)
@@ -95,8 +119,6 @@ module RgGen
           ]
         end
 
-        DEFAULT_PLUGSINS = 'rggen/setup'
-
         def default_plugins(no_default_plugins)
           load_default_plugins?(no_default_plugins) && DEFAULT_PLUGSINS || nil
         end
@@ -110,11 +132,9 @@ module RgGen
 
         def plugins_from_env
           ENV['RGGEN_PLUGINS']
-            &.split(':')&.map(&:strip)&.reject(&:empty?)
-        end
-
-        def plugin?(plugin_module)
-          plugin_module.respond_to?(:plugin_spec) && plugin_module.plugin_spec
+            &.split(':')
+            &.reject(&:blank?)
+            &.map { |entry| entry.split(',', 2) }
         end
       end
     end

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

@@ -4,14 +4,16 @@ module RgGen
   module Core
     module Builder
       class PluginSpec
-        def initialize(name, plugin_module)
+        def initialize(name)
           @name = name
-          @plugin_module = plugin_module
           @component_registrations = []
           @loader_registrations = []
           @files = []
+          block_given? && yield(self)
         end
 
+        attr_reader :name
+
         def version(value = nil)
           @version = value if value
           version_value
@@ -25,13 +27,8 @@ module RgGen
           @component_registrations << [component, layers, body]
         end
 
-        def register_loader(component, loader_type, loader)
-          @loader_registrations << [component, loader_type, loader]
-        end
-
-        def register_loaders(component, loader_type, loaders)
-          Array(loaders)
-            .each { |loader| register_loader(component, loader_type, loader) }
+        def setup_loader(component, loader_type, &body)
+          @loader_registrations << [component, loader_type, body]
         end
 
         def register_files(files)
@@ -41,23 +38,26 @@ module RgGen
 
         alias_method :files, :register_files
 
+        def addtional_setup(&body)
+          @addtional_setup = body
+        end
+
         def activate(builder)
           activate_components(builder)
           activate_loaders(builder)
           load_files
         end
 
+        def activate_additionally(builder)
+          @addtional_setup&.call(builder)
+        end
+
         private
 
         DEFAULT_VERSION = '0.0.0'
 
         def version_value
-          @version || const_version || DEFAULT_VERSION
-        end
-
-        def const_version
-          @plugin_module.const_defined?(:VERSION) &&
-            @plugin_module.const_get(:VERSION)
+          @version || DEFAULT_VERSION
         end
 
         def activate_components(builder)
@@ -69,8 +69,10 @@ module RgGen
         end
 
         def activate_loaders(builder)
-          @loader_registrations.each do |component, loader_type, loader|
-            builder.register_loader(component, loader_type, loader)
+          @loader_registrations.each do |component, loader_type, body|
+            builder
+              .input_component_registry(component)
+              .setup_loader(loader_type, &body)
           end
         end
 

data/lib/rggen/core/dsl.rb

@@ -11,17 +11,17 @@ module RgGen
         :input_component_registry,
         :output_component_registry,
         :register_loader,
+        :setup_loader,
+        :load_plugin,
         :define_loader,
         :define_simple_feature,
         :define_list_feature,
         :define_list_item_feature,
         :define_value_extractor,
         :enable,
-        :disable_all,
-        :disable,
+        :enable_all,
         :delete,
-        :register_plugin,
-        :load_plugin
+        :setup_plugin
       ].each do |method_name|
         def_delegator :'RgGen.builder', method_name
       end

data/lib/rggen/core/facets.rb

@@ -3,6 +3,7 @@
 require 'facets/array/merge'
 require 'facets/file/ext'
 require 'facets/hash/except' if RUBY_VERSION < '3.0.0'
+require 'facets/kernel/blank'
 require 'facets/pathname/to_path'
 require 'facets/module/attr_setter'
 require 'facets/module/lastname'

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

@@ -45,9 +45,7 @@ module RgGen
         end
 
         def load_file(file)
-          build_by_block(&instance_eval(<<~BODY, file, 1))
-            -> { #{File.binread(file)} }  # -> { File.binread(file) }
-          BODY
+          build_by_block { instance_eval(File.binread(file), file, 1) }
         end
 
         private

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

@@ -42,11 +42,9 @@ module RgGen
         end
 
         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
+          format_sub_layer_data(read_data, layer, file)&.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)

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

@@ -6,22 +6,13 @@ module RgGen
       module YAMLLoader
         private
 
-        if RUBY_VERSION >= '2.6.0'
-          def yaml_safe_load(yaml, file)
-            YAML.safe_load(
-              yaml,
-              permitted_classes: [Symbol], aliases: true, filename: file,
-              symbolize_names: true
-            )
-          end
-        else
-          def yaml_safe_load(yaml, file)
-            YAML.safe_load(yaml, [Symbol], [], true, file, symbolize_names: true)
-          end
-        end
-
         def load_yaml(file)
-          yaml_safe_load(File.binread(file), file)
+          yaml = File.binread(file)
+          YAML.safe_load(
+            yaml,
+            permitted_classes: [Symbol], aliases: true,
+            filename: file, symbolize_names: true
+          )
         end
       end
     end

data/lib/rggen/core/options.rb

@@ -109,9 +109,9 @@ module RgGen
     end
 
     Options.add_option(:plugins) do |option|
-      option.long_option '--plugin PLUGIN'
+      option.long_option '--plugin PLUGIN[:VERSION]'
       option.default { [] }
-      option.action { |value, options| options[:plugins] << value }
+      option.action { |value, options| options[:plugins] << value.split(':', 2) }
       option.description 'Load a RgGen plugin ' \
                          "(name of plugin/path to 'setup.rb' file)"
     end

data/lib/rggen/core/output_base/file_writer.rb

@@ -32,7 +32,7 @@ module RgGen
 
         def create_directory(path)
           directory = path.dirname
-          directory.directory? || directory.mkpath
+          directory.directory? || FileUtils.mkpath(directory)
         end
       end
     end

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

@@ -47,12 +47,12 @@ module RgGen
         end
 
         def format_array_sub_layer_data(read_data, layer, file)
-          read_data.each_with_object({}) do |data, sub_layer_data|
+          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 = {})
+        def format_hash_sub_layer_data(read_data, layer, file, sub_layer_data = [])
           convert_to_hash(read_data, file)
             .slice(*SUB_LAYER_KEYS[layer])
             .each { |k, v| merge_sub_layer_data(sub_layer_data, layer, k, v) }
@@ -61,9 +61,10 @@ module RgGen
 
         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)
+            sub_layer_data
+              .concat([SUB_LAYER_KEY_MAP[layer][key]].product(value))
           else
-            (sub_layer_data[key] ||= []) << value
+            sub_layer_data << [key, value]
           end
         end
 

data/lib/rggen/core/version.rb

@@ -2,7 +2,7 @@
 
 module RgGen
   module Core
-    VERSION = '0.25.0'
+    VERSION = '0.27.0'
     MAJOR, MINOR, PATCH = VERSION.split('.').map(&:to_i)
   end
 end

data/lib/rggen/core.rb

@@ -105,7 +105,6 @@ 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'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rggen-core
 version: !ruby/object:Gem::Version
-  version: 0.25.0
+  version: 0.27.0
 platform: ruby
 authors:
 - Taichi Ishitani
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-02-28 00:00:00.000000000 Z
+date: 2022-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: docile
@@ -165,7 +165,6 @@ files:
 - lib/rggen/core/output_base/raise_error.rb
 - lib/rggen/core/output_base/source_file_component_factory.rb
 - lib/rggen/core/output_base/template_engine.rb
-- lib/rggen/core/plugin.rb
 - lib/rggen/core/printers.rb
 - lib/rggen/core/register_map.rb
 - lib/rggen/core/register_map/component.rb
@@ -193,8 +192,9 @@ homepage: https://github.com/rggen/rggen-core
 licenses:
 - MIT
 metadata:
-  bug_tracker_uri: https://github.com/rggen/rggen-core/issues
+  bug_tracker_uri: https://github.com/rggen/rggen/issues
   mailing_list_uri: https://groups.google.com/d/forum/rggen
+  rubygems_mfa_required: 'true'
   source_code_uri: https://github.com/rggen/rggen-core
   wiki_uri: https://github.com/rggen/rggen/wiki
 post_install_message: 
@@ -205,15 +205,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.5'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.3.3
 signing_key: 
 specification_version: 4
-summary: rggen-core-0.25.0
+summary: rggen-core-0.27.0
 test_files: []

data/lib/rggen/core/plugin.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module RgGen
-  module Core
-    module Plugin
-      attr_reader :plugin_spec
-
-      private
-
-      def setup_plugin(name)
-        @plugin_spec = Builder::PluginSpec.new(name, self)
-        block_given? && yield(@plugin_spec)
-      end
-    end
-  end
-end