rggen-core 0.28.0 → 0.30.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30286c1aefc400e1d6cda52dddc797fca2ad3a35fcf3a43578371a5b9a8fc4b0
-  data.tar.gz: e7bb012b70a143c1412eab481febce79e7083ab83c22136f3e52540a41e67c69
+  metadata.gz: 977e436971681e3425cdb967c6a86d7debeb89fac6ab33db6e7ab1d831102b8f
+  data.tar.gz: 9d49db2290dfdc7b5c7dfc4a0369a2428ed9606f6487cad4c956c7144d46319f
 SHA512:
-  metadata.gz: a14bd1ce40c782d0628e55f23a6acffa1578598a421bae4a7127c4464800078ac3181504e0a53b829581cfba4820b56fbc07803cf3fe338097479f4d3aca646a
-  data.tar.gz: 524360603dae2839afe73e23a8c2cbedac3e2373e70a24e671d006977caf08dea6a5813d50a99a1724b3ab1a098b38134b0f653cbde2f9c6ee341d12596a73d0
+  metadata.gz: 999522157b4878363182b31f22a3a12c73c6908409b043c972df3885e9908df66b7093b27bfbe90da30b5dfcebffdcbcdc2ccb1b11da87ebed244f071c991134
+  data.tar.gz: 61149e6066502b04f73f525304745b7e555355c141944fb3e03a1043a6ab6761cd0637ffa90ca22c7d3e330d65020831031f525fa4a189b54c9834b78eccc551

data/LICENSE

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

@@ -45,7 +45,7 @@ Feedbacks, bug reports, questions and etc. are wellcome! You can post them by us
 
 ## Copyright & License
 
-Copyright © 2017-2022 Taichi Ishitani. RgGen::Core is licensed under the [MIT License](https://opensource.org/licenses/MIT), see [LICENSE](LICENSE) for futher details.
+Copyright © 2017-2023 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.rb

@@ -75,9 +75,9 @@ module RgGen
 
         def define_proxy_call(receiver, method_name)
           (@proxy_receivers ||= {})[method_name.to_sym] = receiver
-          define_singleton_method(method_name) do |*args, &block|
+          define_singleton_method(method_name) do |*args, **keywords, &block|
             name = __method__
-            @proxy_receivers[name].__send__(name, *args, &block)
+            @proxy_receivers[name].__send__(name, *args, **keywords, &block)
           end
         end
       end

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

@@ -47,6 +47,7 @@ module RgGen
         end
 
         [
+          :define_feature,
           :define_simple_feature,
           :define_list_feature,
           :define_list_item_feature
@@ -73,7 +74,7 @@ module RgGen
             if targets.empty?
               @component_registries[type]
             else
-              @component_registries[type].slice(*targets)
+              collect_component_factories(type, targets)
             end
           registries.each_value.map(&:build_factory)
         end
@@ -127,6 +128,14 @@ module RgGen
             (registries[name] = COMPONENT_REGISTRIES[type].new(name, self))
           body && Docile.dsl_eval(registries[name], &body) || registries[name]
         end
+
+        def collect_component_factories(type, targets)
+          unknown_components = targets - @component_registries[type].keys
+          unknown_components.empty? ||
+            (raise BuilderError.new("unknown component: #{unknown_components.first}"))
+
+          @component_registries[type].slice(*targets)
+        end
       end
     end
   end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Builder
+      class FeatureEntryBase
+        def initialize(registry, name)
+          @registry = registry
+          @name = name
+        end
+
+        attr_reader :registry
+        attr_reader :name
+
+        def match_entry_type?(entry_type)
+          entry_type == entry_type_name
+        end
+
+        def build_factory(targets)
+          @factory.new(name) do |f|
+            f.target_features(target_features(targets))
+            f.target_feature(target_feature)
+          end
+        end
+
+        private
+
+        def attach_shared_context(context, *targets)
+          (context && targets)&.each do |target|
+            target.attach_context(context)
+          end
+        end
+
+        def target_features(_tergets)
+        end
+
+        def target_feature
+        end
+      end
+    end
+  end
+end

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

@@ -11,6 +11,10 @@ module RgGen
           @enabled_features = {}
         end
 
+        def define_feature(name, context = nil, &body)
+          create_new_entry(:general, name, context, &body)
+        end
+
         def define_simple_feature(name, context = nil, &body)
           create_new_entry(:simple, name, context, &body)
         end
@@ -26,12 +30,11 @@ module RgGen
           entry.define_feature(feature_name, context, &body)
         end
 
-        def enable(feature_or_list_names, feature_names = nil)
-          if feature_names
-            list_name = feature_or_list_names
+        def enable(list_name = nil, feature_names)
+          if list_name
             (@enabled_features[list_name] ||= []).merge!(Array(feature_names))
           else
-            Array(feature_or_list_names).each do |name|
+            Array(feature_names).each do |name|
               @enabled_features.key?(name) || (@enabled_features[name] = nil)
             end
           end
@@ -41,31 +44,23 @@ module RgGen
           @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))
+        def delete(list_name = nil, feature_names)
+          if list_name
+            @feature_entries[list_name]&.delete(feature_names)
           else
-            @feature_entries.clear
+            Array(feature_names).each(&@feature_entries.method(:delete))
           end
         end
 
-        def simple_feature?(feature_name)
-          @feature_entries[feature_name]&.match_entry_type?(:simple) || false
+        def delete_all
+          @feature_entries.clear
         end
 
-        def list_feature?(list_name, feature_name = nil)
-          return false unless @feature_entries[list_name]&.match_entry_type?(:list)
-          return true unless 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)
+        def feature?(list_name = nil, feature_name)
+          if list_name
+            list_feature?(list_name, feature_name)
           else
-            simple_feature?(feature_or_list_name) || list_feature?(feature_or_list_name)
+            @feature_entries.key?(feature_name)
           end
         end
 
@@ -89,7 +84,9 @@ module RgGen
         private
 
         FEATURE_ENTRIES = {
-          simple: SimpleFeatureEntry, list: ListFeatureEntry
+          general: GeneralFeatureEntry,
+          simple: SimpleFeatureEntry,
+          list: ListFeatureEntry
         }.freeze
 
         def create_new_entry(type, name, context, &body)
@@ -105,7 +102,7 @@ module RgGen
         end
 
         def enabled_list?(list_name)
-          return false unless list_feature?(list_name)
+          return false unless @feature_entries[list_name]&.match_entry_type?(:list)
           return true if @enabled_features.empty?
           return true if @enabled_features.key?(list_name)
           false
@@ -114,6 +111,11 @@ module RgGen
         def build_factory(entry)
           entry.build_factory(@enabled_features[entry.name])
         end
+
+        def list_feature?(list_name, feature_name)
+          @feature_entries[list_name]&.match_entry_type?(:list) &&
+            @feature_entries[list_name]&.feature?(feature_name) || false
+        end
       end
     end
   end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Builder
+      class GeneralFeatureEntry < FeatureEntryBase
+        include Base::SharedContext
+
+        def setup(base_feature, base_factory, context, &body)
+          @feature = Class.new(base_feature)
+          @factory = Class.new(base_factory)
+          attach_shared_context(context, @feature, @factory, self)
+          block_given? && Docile.dsl_eval(self, @name, &body)
+        end
+
+        def define_factory(&body)
+          @factory.class_exec(&body)
+        end
+
+        alias_method :factory, :define_factory
+
+        def define_feature(&body)
+          @feature.class_exec(&body)
+        end
+
+        alias_method :feature, :define_feature
+
+        private
+
+        def entry_type_name
+          :general
+        end
+
+        def target_feature
+          @feature
+        end
+      end
+    end
+  end
+end

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

@@ -23,9 +23,9 @@ module RgGen
           block_given? && yield(@loader_registries[loader_type])
         end
 
-        def define_value_extractor(loader_type, layers_or_value, value = nil, &body)
+        def define_value_extractor(loader_type, layers = nil, value, &body)
           @loader_registries[loader_type]
-            .define_value_extractor(layers_or_value, value, &body)
+            .define_value_extractor(layers, value, &body)
         end
 
         def build_factory

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

@@ -53,6 +53,16 @@ module RgGen
           current_shared_context(false)
         end
 
+        def define_feature(feature_names, &body)
+          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_simple_feature(feature_names, &body)
           Array(feature_names).each do |feature_name|
             do_proxy_call do |proxy|
@@ -84,9 +94,9 @@ module RgGen
           end
         end
 
-        def enable(feature_or_list_names, feature_names = nil)
+        def enable(...)
           @feature_registries.each_value do |registry|
-            registry.enable(feature_or_list_names, feature_names)
+            registry.enable(...)
           end
         end
 
@@ -94,12 +104,16 @@ module RgGen
           @feature_registries.each_value(&:enable_all)
         end
 
-        def delete(feature_or_list_names = nil, feature_names = nil)
+        def delete(...)
           @feature_registries.each_value do |registry|
-            registry.delete(*[feature_or_list_names, feature_names].compact)
+            registry.delete(...)
           end
         end
 
+        def delete_all
+          @feature_registries.each_value(&:delete_all)
+        end
+
         private
 
         def define_proxy_call(name)

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

@@ -3,42 +3,27 @@
 module RgGen
   module Core
     module Builder
-      class ListFeatureEntry
+      class ListFeatureEntry < FeatureEntryBase
         include Base::SharedContext
 
         def initialize(registry, name)
-          @registry = registry
-          @name = name
+          super(registry, name)
           @features = {}
         end
 
-        attr_reader :registry
-        attr_reader :name
-
         def setup(base_feature, base_factory, context, &body)
           @base_feature = Class.new(base_feature)
           @factory = Class.new(base_factory)
-          context && attach_shared_context(context)
+          attach_shared_context(context, @base_feature, @factory, self)
           block_given? && Docile.dsl_eval(self, @name, &body)
         end
 
-        def match_entry_type?(entry_type)
-          entry_type == :list
-        end
-
         def define_factory(&body)
           @factory.class_exec(&body)
         end
 
         alias_method :factory, :define_factory
 
-        def build_factory(targets)
-          @factory.new(@name) do |f|
-            f.target_features(target_features(targets))
-            f.target_feature(@default_feature)
-          end
-        end
-
         def define_base_feature(&body)
           body && @base_feature.class_exec(&body)
         end
@@ -51,7 +36,7 @@ module RgGen
           if context
             feature.method_defined?(:shared_context) &&
               (raise BuilderError.new('shared context has already been set'))
-            feature.attach_context(context)
+            attach_shared_context(context, feature)
           end
           body && feature.class_exec(feature_name, &body)
         end
@@ -83,15 +68,17 @@ module RgGen
 
         private
 
-        def attach_shared_context(context)
-          [@factory, @base_feature, self].each do |target|
-            target.attach_context(context)
-          end
+        def entry_type_name
+          :list
         end
 
         def target_features(targets)
           targets && @features.slice(*targets) || @features
         end
+
+        def target_feature
+          @default_feature
+        end
       end
     end
   end

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

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

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

@@ -3,36 +3,28 @@
 module RgGen
   module Core
     module Builder
-      class SimpleFeatureEntry
-        def initialize(registry, name)
-          @registry = registry
-          @name = name
-        end
-
-        attr_reader :registry
-        attr_reader :name
-
+      class SimpleFeatureEntry < FeatureEntryBase
         def setup(base_feature, factory, context, &body)
           @feature = define_feature(base_feature, context, &body)
           @factory = factory
         end
 
-        def match_entry_type?(entry_type)
-          entry_type == :simple
-        end
+        private
 
-        def build_factory(_enabled_features)
-          @factory.new(@name) { |f| f.target_feature(@feature) }
+        def entry_type_name
+          :simple
         end
 
-        private
-
         def define_feature(base, context, &body)
           feature = Class.new(base)
-          context && feature.attach_context(context)
+          attach_shared_context(context, feature)
           block_given? && feature.class_exec(@name, &body)
           feature
         end
+
+        def target_feature
+          @feature
+        end
       end
     end
   end

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

@@ -7,9 +7,12 @@ module RgGen
       end
 
       module RaiseError
-        def error(message, input_value = nil)
-          position = input_value.position if input_value.respond_to?(:position)
-          raise ConfigurationError.new(message, position || @position)
+        include InputBase::RaiseError
+
+        private
+
+        def error_exception
+          ConfigurationError
         end
       end
     end

data/lib/rggen/core/core_extensions/object.rb

@@ -8,7 +8,7 @@ class Object
         .then { |v| to.instance_variable_set(variable, v) }
   end
 
-  def singleton_exec(*args, &block)
-    singleton_class.class_exec(*args, &block)
+  def singleton_exec(...)
+    singleton_class.class_exec(...)
   end
 end

data/lib/rggen/core/dsl.rb

@@ -14,6 +14,7 @@ module RgGen
         :setup_loader,
         :load_plugin,
         :define_loader,
+        :define_feature,
         :define_simple_feature,
         :define_list_feature,
         :define_list_item_feature,

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module InputBase
+      module ConversionUtility
+        private
+
+        def to_int(value, position = nil)
+          v, pos =
+            if value.is_a?(InputValue)
+              [value.value, value.position]
+            else
+              [value, position]
+            end
+          Integer(v)
+        rescue ArgumentError, TypeError
+          message = yield(v)
+          error message, pos
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module InputBase
+      ApproximatelyErrorPosition = Struct.new(:position) do
+        def self.create(position)
+          position && new(position)
+        end
+
+        def to_s
+          "#{position} (approximately)"
+        end
+      end
+
+      module RaiseError
+        private
+
+        def error(message, position = nil)
+          pos = extract_error_position(position)
+          raise error_exception.new(message, pos)
+        end
+
+        def extract_error_position(position)
+          pos =
+            if position.respond_to?(:position)
+              position.position
+            else
+              position
+            end
+          pos ||
+            if respond_to?(:error_position)
+              error_position
+            else
+              @position
+            end
+        end
+      end
+    end
+  end
+end

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

@@ -6,6 +6,7 @@ module RgGen
       class Feature < Base::Feature
         include Utility::RegexpPatterns
         include Utility::TypeChecker
+        include ConversionUtility
 
         class << self
           def property(name, **options, &body)
@@ -29,15 +30,13 @@ module RgGen
           end
 
           def build(&block)
-            @builders ||= []
-            @builders << block
+            (@builders ||= []) << block
           end
 
           attr_reader :builders
 
           def post_build(&block)
-            @post_builders ||= []
-            @post_builders << block
+            (@post_builders ||= []) << block
           end
 
           attr_reader :post_builders
@@ -64,8 +63,7 @@ module RgGen
           attr_reader :verifiers
 
           def printable(name, &body)
-            @printables ||= {}
-            @printables[name] = body
+            (@printables ||= {})[name] = body
           end
 
           attr_reader :printables
@@ -119,11 +117,22 @@ module RgGen
         end
 
         def inspect
-          printable_values =
-            printables&.map { |name, value| "#{name}: #{value.inspect}" }
+          printable_values = printables&.map { |name, value| "#{name}: #{value.inspect}" }
           (printable_values && "#{super}[#{printable_values.join(', ')}]") || super
         end
 
+        attr_reader :position
+
+        def error_position
+          if position
+            position
+          else
+            approximate_position =
+              component.features.map(&:position).find(&:itself)
+            ApproximatelyErrorPosition.create(approximate_position)
+          end
+        end
+
         private
 
         def do_build(args)
@@ -137,16 +146,12 @@ module RgGen
           self.class.builders.each { |builder| instance_exec(*args, &builder) }
         end
 
-        attr_reader :position
-
         def match_automatically?
-          matcher = self.class.input_matcher
-          matcher&.match_automatically?
+          self.class.input_matcher&.match_automatically?
         end
 
         def match_pattern(rhs)
-          matcher = self.class.input_matcher
-          @match_data, @match_index = matcher&.match(rhs)
+          @match_data, @match_index = self.class.input_matcher&.match(rhs)
         end
 
         attr_reader :match_data
@@ -161,8 +166,7 @@ module RgGen
         end
 
         def do_verify(scope)
-          self.class.verifiers&.[](scope)
-            &.each { |verifier| verifier.verify(self) }
+          self.class.verifiers&.[](scope)&.each { |verifier| verifier.verify(self) }
           (@verified ||= {})[scope] = true
         end
 

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

@@ -18,12 +18,9 @@ module RgGen
             @default_value
           end
 
-          def allow_options
-            @allow_options = true
-          end
-
-          def allow_options?
-            @allow_options || false
+          def value_format(format = nil, **options)
+            @value_format = [format, options] if format
+            @value_format
           end
         end
 
@@ -48,50 +45,41 @@ module RgGen
         def process_input_value(input_value)
           if passive_feature_factory?
             input_value
-          elsif self.class.allow_options?
-            process_input_value_with_options(input_value)
           else
-            process_input_value_without_options(input_value)
+            process_active_input_value(input_value)
           end
         end
 
-        def process_input_value_with_options(input_value)
-          value, options =
-            if string?(input_value)
-              parse_string_value(input_value)
-            else
-              Array(input_value).then { |values| [values.first, values[1..]] }
+        def process_active_input_value(input_value)
+          parsed_value, options =
+            if self.class.value_format
+              parse_input_value(input_value, self.class.value_format)
             end
-          value = convert_value(value, input_value.position) || value
-          InputValue.new(value, options || [], input_value.position)
-        end
-
-        def parse_string_value(input_value)
-          value, options = split_string(input_value, ':', 2)
-          [value, parse_option_string(options)]
+          override_input_value(input_value, parsed_value, options) || input_value
         end
 
-        def parse_option_string(option_string)
-          split_string(option_string, /[,\n]/, 0)&.map do |option|
-            name, value = split_string(option, ':', 2)
-            value && [name, value] || name
-          end
-        end
+        VALUE_PARSERS = {
+          option_array: OptionArrayParser,
+          option_hash: OptionHashParser,
+          hash_list: HashListParser
+        }.freeze
 
-        def split_string(string, separator, limit)
-          string&.split(separator, limit)&.map(&:strip)
+        def parse_input_value(input_value, value_format)
+          format, options = value_format
+          VALUE_PARSERS[format].new(error_exception, **options).parse(input_value)
         end
 
-        def process_input_value_without_options(input_value)
-          value = convert_value(input_value.value, input_value.position)
-          value && InputValue.new(value, input_value.position) || input_value
+        def override_input_value(input_value, parsed_value, options)
+          (convert_value(input_value, parsed_value) || parsed_value)
+            &.then { |v| InputValue.new(v, options, input_value.position) }
         end
 
-        def convert_value(value, position)
+        def convert_value(input_value, parsed_value)
+          value = parsed_value || input_value.value
           if empty_value?(value)
-            evaluate_defalt_value(position)
+            evaluate_defalt_value(input_value.position)
           else
-            convert(value, position)
+            convert(value, input_value.position)
           end
         end
 

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module InputBase
+      class HashListParser < InputValueParser
+        def parse(input_value)
+          list =
+            if string?(input_value)
+              split_string(input_value, /^\s*$/, 0)
+            elsif hash?(input_value) && !input_value.empty?
+              [input_value]
+            else
+              Array(input_value)
+            end
+          [list.map { |item| parse_hash(item, input_value) }]
+        end
+
+        private
+
+        def parse_hash(item, input_value)
+          if string?(item)
+            parse_string_hash(item)
+          else
+            Hash(item)
+          end
+        rescue TypeError, ArgumentError
+          error "cannot convert #{item.inspect} into hash", input_value
+        end
+
+        def parse_string_hash(item)
+          split_string(item, /[,\n]/, 0)
+            .to_h { |element| split_string(element, ':', 2) }
+        end
+      end
+    end
+  end
+end

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

@@ -21,8 +21,8 @@ module RgGen
             assign_value(symbolized_name, value, position)
         end
 
-        def []=(value_name, position_or_value, value = nil)
-          value(value_name, value || position_or_value, position_or_value)
+        def []=(value_name, position = nil, value)
+          value(value_name, value, position)
         end
 
         def [](value_name)

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

@@ -6,14 +6,10 @@ module RgGen
       class InputValue < ::SimpleDelegator
         NoValue = Object.new
 
-        def initialize(value, options_or_position, position = NoValue)
+        def initialize(value, options = NoValue, position)
           super((value.is_a?(String) && value.strip) || value)
-          @options, @position =
-            if position.equal?(NoValue)
-              [NoValue, options_or_position]
-            else
-              [options_or_position, position]
-            end
+          @options = options
+          @position = position
         end
 
         alias_method :value, :__getobj__

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module InputBase
+      class InputValueParser
+        include Utility::TypeChecker
+
+        def initialize(exception, **_option)
+          @exception = exception
+        end
+
+        private
+
+        def split_string(string, separator, limit)
+          string&.split(separator, limit)&.map(&:strip)
+        end
+
+        def error(message, position_or_input_value = nil)
+          position =
+            if position_or_input_value.respond_to?(:position)
+              position_or_input_value.position
+            else
+              position_or_input_value
+            end
+          raise @exception.new(message, position)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module InputBase
+      class OptionArrayParser < InputValueParser
+        def parse(input_value)
+          value, options =
+            if string?(input_value)
+              parse_string_value(input_value)
+            else
+              Array(input_value).then { |v| [v.first, v[1..]] }
+            end
+          [value, options || []]
+        end
+
+        private
+
+        def parse_string_value(input_value)
+          value, option_string = split_string(input_value, ':', 2)
+          [value, parse_option_string(option_string)]
+        end
+
+        def parse_option_string(option_string)
+          split_string(option_string, /[,\n]/, 0)&.map do |option|
+            name_value = split_string(option, ':', 2)
+            name_value.size == 2 && name_value || name_value.first
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module InputBase
+      class OptionHashParser < InputValueParser
+        def initialize(exception, allowed_options: nil, multiple_values: false)
+          super
+          @allowed_options = allowed_options
+          @multiple_values = multiple_values
+        end
+
+        def parse(input_value)
+          values, options = parse_input_value(input_value)
+          check_result(values, options, input_value)
+          pack_result(values, options)
+        end
+
+        private
+
+        def parse_input_value(input_value)
+          values, options =
+            if string?(input_value)
+              parse_string_value(input_value)
+            elsif array?(input_value)
+              parse_array_value(input_value)
+            elsif hash?(input_value)
+              [nil, input_value]
+            elsif !input_value.empty_value?
+              [[input_value.value]]
+            end
+          [values || [], symbolize_keys(options) || {}]
+        end
+
+        def parse_string_value(input_value)
+          value_string, option_string = split_string(input_value, ':', 2)
+          values = split_string(value_string, /[,\n]/, 0)
+          options = parse_option_string(option_string, input_value.position)
+          [values, options]
+        end
+
+        def parse_option_string(option_string, position)
+          split_string(option_string, /[,\n]/, 0)
+            &.to_h { |option| split_string(option, ':', 2) }
+        rescue ArgumentError, TypeError
+          error "invalid options are given: #{option_string.inspect}", position
+        end
+
+        def parse_array_value(input_value)
+          input_value.each_with_object([[], {}]) do |item, (values, options)|
+            if value_item?(item, values)
+              values << item
+            else
+              update_option_hash(options, item, input_value.position)
+            end
+          end
+        end
+
+        def value_item?(item, values)
+          !hash?(item) && (@multiple_values || values.empty?)
+        end
+
+        def update_option_hash(option_hash, item, position)
+          option_hash.update(item)
+        rescue ArgumentError, TypeError
+          error "invalid option is given: #{item.inspect}", position
+        end
+
+        def symbolize_keys(options)
+          options&.transform_keys { |k| string?(k) && k.to_sym || k }
+        end
+
+        def check_result(values, options, input_value)
+          no_values?(values, options) &&
+            (error "no input values are given: #{input_value.inspect}", input_value)
+          illegal_value_size?(values) &&
+            (error "multiple input values are given: #{values}", input_value)
+          check_option(options, input_value.position)
+        end
+
+        def no_values?(values, options)
+          values.empty? && !options.empty?
+        end
+
+        def illegal_value_size?(values)
+          !@multiple_values && values.size > 1
+        end
+
+        def check_option(options, position)
+          return if @allowed_options.nil? || @allowed_options.empty?
+          return if options.nil? || options.empty?
+
+          unknown_options = options.keys - @allowed_options
+          unknown_options.empty? ||
+            (error "unknown options are given: #{unknown_options}", position)
+        end
+
+        def pack_result(values, options)
+          [@multiple_values && values || values.first, options]
+        end
+      end
+    end
+  end
+end

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

@@ -23,16 +23,16 @@ module RgGen
 
         def define(feature)
           feature.class_exec(self) do |property|
-            define_method(property.name) do |*args, &block|
-              property.evaluate(self, args, &block)
+            define_method(property.name) do |*args, **keywords, &block|
+              property.evaluate(self, *args, **keywords, &block)
             end
           end
         end
 
-        def evaluate(feature, args, &block)
+        def evaluate(feature, *args, **keywords, &block)
           feature.verify(@options[:verify]) if @options.key?(:verify)
           if proxy_property?
-            proxy_property(feature, args, &block)
+            proxy_property(feature, *args, **keywords, &block)
           else
             default_property(feature)
           end
@@ -55,7 +55,7 @@ module RgGen
           ].any?
         end
 
-        def proxy_property(feature, args, &block)
+        def proxy_property(feature, *args, **keywords, &block)
           receiver, method =
             if @costom_property
               [@costom_property.bind(feature), :call]
@@ -64,7 +64,7 @@ module RgGen
             else
               [feature, @options[:forward_to]]
             end
-          receiver.__send__(method, *args, &block)
+          receiver.__send__(method, *args, **keywords, &block)
         end
 
         def default_property(feature)

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

@@ -55,18 +55,16 @@ module RgGen
             end
           end
 
-          def register(node, object)
-            obj =
-              if override_object?(node)
-                file = node.filename
-                line = node.start_line + 1
-                column = node.start_column + 1
-                position = Position.new(file, line, column)
-                InputValue.new(object, position)
-              else
-                object
-              end
-            super(node, obj)
+          def accept(node)
+            object = super
+            if override_object?(node)
+              file = node.filename
+              line = node.start_line + 1
+              column = node.start_column + 1
+              InputValue.new(object, Position.new(file, line, column))
+            else
+              object
+            end
           end
 
           private
@@ -100,10 +98,9 @@ module RgGen
           return result if ::Psych::VERSION >= '3.2.0'
 
           if result.match_class?(Hash)
-            keys = result.keys
-            keys.each do |key|
-              result[key.to_sym] = symbolize_names(result.delete(key))
-            end
+            result
+              .transform_keys!(&:to_sym)
+              .transform_values!(&method(:symbolize_names))
           elsif result.match_class?(Array)
             result.map! { |value| symbolize_names(value) }
           end

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

@@ -7,9 +7,12 @@ module RgGen
       end
 
       module RaiseError
-        def error(message, input_value = nil)
-          position = input_value.position if input_value.respond_to?(:position)
-          raise RegisterMapError.new(message, position || @position)
+        include InputBase::RaiseError
+
+        private
+
+        def error_exception
+          RegisterMapError
         end
       end
     end

data/lib/rggen/core/utility/code_utility/source_file.rb

@@ -4,6 +4,8 @@ module RgGen
   module Core
     module Utility
       module CodeUtility
+        MacroDefinition = Struct.new(:name, :value)
+
         class SourceFile
           include CodeUtility
 
@@ -43,6 +45,15 @@ module RgGen
             include_files([file])
           end
 
+          def macro_definitions(macros)
+            @macro_definitions ||= []
+            @macro_definitions.concat(Array(macros))
+          end
+
+          def macro_definition(macro)
+            macro_definitions([macro])
+          end
+
           def body(&block)
             @bodies ||= []
             @bodies << block
@@ -65,6 +76,7 @@ module RgGen
               @file_header,
               include_guard_header,
               include_file_block,
+              macro_definition_block,
               *Array(@bodies),
               include_guard_footer
             ].compact
@@ -94,6 +106,19 @@ module RgGen
             end
           end
 
+          def macro_definition_block
+            @macro_definitions && lambda do
+              keyword = self.class.define_keyword
+              @macro_definitions.flat_map do |macro|
+                if macro.value.nil?
+                  [keyword, space, macro.name, nl]
+                else
+                  [keyword, space, macro.name, space, macro.value, nl]
+                end
+              end
+            end
+          end
+
           def include_guard_footer
             @guard_macro && (-> { self.class.endif_keyword })
           end

data/lib/rggen/core/version.rb

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

data/lib/rggen/core.rb

@@ -42,6 +42,8 @@ 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/error'
+require_relative 'core/input_base/conversion_utility'
 require_relative 'core/input_base/loader'
 require_relative 'core/input_base/json_loader'
 require_relative 'core/input_base/toml_loader'
@@ -52,6 +54,10 @@ require_relative 'core/input_base/input_matcher'
 require_relative 'core/input_base/verifier'
 require_relative 'core/input_base/property'
 require_relative 'core/input_base/feature'
+require_relative 'core/input_base/input_vaue_parser'
+require_relative 'core/input_base/option_array_parser'
+require_relative 'core/input_base/option_hash_parser'
+require_relative 'core/input_base/hash_list_parser'
 require_relative 'core/input_base/feature_factory'
 
 require_relative 'core/configuration/input_data'
@@ -99,6 +105,8 @@ 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/feature_entry_base'
+require_relative 'core/builder/general_feature_entry'
 require_relative 'core/builder/simple_feature_entry'
 require_relative 'core/builder/list_feature_entry'
 require_relative 'core/builder/feature_registry'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rggen-core
 version: !ruby/object:Gem::Version
-  version: 0.28.0
+  version: 0.30.0
 platform: ruby
 authors:
 - Taichi Ishitani
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-10-10 00:00:00.000000000 Z
+date: 2023-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: docile
@@ -111,7 +111,9 @@ files:
 - lib/rggen/core/builder/builder.rb
 - lib/rggen/core/builder/component_entry.rb
 - lib/rggen/core/builder/component_registry.rb
+- lib/rggen/core/builder/feature_entry_base.rb
 - lib/rggen/core/builder/feature_registry.rb
+- lib/rggen/core/builder/general_feature_entry.rb
 - lib/rggen/core/builder/input_component_registry.rb
 - lib/rggen/core/builder/layer.rb
 - lib/rggen/core/builder/list_feature_entry.rb
@@ -142,14 +144,20 @@ files:
 - lib/rggen/core/generator.rb
 - lib/rggen/core/input_base/component.rb
 - lib/rggen/core/input_base/component_factory.rb
+- lib/rggen/core/input_base/conversion_utility.rb
+- lib/rggen/core/input_base/error.rb
 - lib/rggen/core/input_base/feature.rb
 - lib/rggen/core/input_base/feature_factory.rb
+- lib/rggen/core/input_base/hash_list_parser.rb
 - 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/input_vaue_parser.rb
 - lib/rggen/core/input_base/json_loader.rb
 - lib/rggen/core/input_base/loader.rb
+- lib/rggen/core/input_base/option_array_parser.rb
+- lib/rggen/core/input_base/option_hash_parser.rb
 - lib/rggen/core/input_base/property.rb
 - lib/rggen/core/input_base/toml_loader.rb
 - lib/rggen/core/input_base/verifier.rb
@@ -207,15 +215,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.6'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.10
 signing_key: 
 specification_version: 4
-summary: rggen-core-0.28.0
+summary: rggen-core-0.30.0
 test_files: []