rggen-core 0.15.0 → 0.20.0

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

@@ -63,9 +63,11 @@ module RgGen
           @plugins << Plugin.new(name, module_or_version, &block)
         end
 
-        def activate(builder)
-          @plugins.each { |plugin| plugin.default_setup(builder) }
-          @plugins.each { |plugin| plugin.optional_setup(builder) }
+        def activate(builder, **options)
+          options[:no_default_setup] ||
+            @plugins.each { |plugin| plugin.default_setup(builder) }
+          options[:no_optional_setup] ||
+            @plugins.each { |plugin| plugin.optional_setup(builder) }
         end
 
         def version_info

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

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

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

@@ -6,12 +6,8 @@ module RgGen
       class ComponentFactory < InputBase::ComponentFactory
         private
 
-        def create_component(*_, &block)
-          @target_component.new(&block)
-        end
-
         def create_input_data(&block)
-          InputBase::InputData.new(valid_value_lists, &block)
+          InputData.new(valid_value_lists, &block)
         end
       end
     end

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

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

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

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

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

@@ -44,14 +44,14 @@ module RgGen
 
           def input_pattern(pattern_or_patterns, **options, &converter)
             @input_matcher =
-              InputMatcher.new(pattern_or_patterns, options, &converter)
+              InputMatcher.new(pattern_or_patterns, **options, &converter)
           end
 
           attr_reader :input_matcher
 
           def verify(scope, &block)
             @verifiers ||= {}
-            (@verifiers[scope] ||= []) << Verifier.new(&block)
+            (@verifiers[scope] ||= []) << create_verifier(&block)
           end
 
           attr_reader :verifiers
@@ -75,10 +75,14 @@ module RgGen
 
           private
 
+          def create_verifier(&body)
+            Verifier.new(&body)
+          end
+
           def export_verifiers(subclass)
-            copied_verifiers =
-              @verifiers.map { |scope, blocks| [scope, blocks.dup] }.to_h
-            subclass.instance_variable_set(:@verifiers, copied_verifiers)
+            subclass.instance_variable_set(
+              :@verifiers, @verifiers.transform_values(&:dup)
+            )
           end
         end
 
@@ -105,6 +109,12 @@ module RgGen
           !helper.printables.nil?
         end
 
+        def inspect
+          printable_values =
+            printables&.map { |name, value| "#{name}: #{value.inspect}" }
+          (printable_values && "#{super}[#{printable_values.join(', ')}]") || super
+        end
+
         private
 
         def do_build(args)

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

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

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

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

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

@@ -25,9 +25,8 @@ module RgGen
         end
 
         def load_file(file)
-          File.readable?(file) || (
-            raise Core::LoadError.new('cannot load such file', file)
-          )
+          File.readable?(file) ||
+            (raise Core::LoadError.new('cannot load such file', file))
           format(read_file(file), file)
         end
 

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

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

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

@@ -6,34 +6,39 @@ module RgGen
       module YAMLLoader
         private
 
-        def load_yaml(file)
-          result = yaml_safe_load(File.binread(file), file)
-          symbolize_key(result)
-        end
-
-        if Psych::VERSION >= '3.1.0'
+        if RUBY_VERSION >= '2.6.0'
           def yaml_safe_load(yaml, file)
             YAML.safe_load(
               yaml,
-              permitted_classes: [Symbol], aliases: true, filename: file
+              permitted_classes: [Symbol], aliases: true, filename: file,
+              symbolize_names: true
             )
           end
+        elsif RUBY_VERSION >= '2.5.0'
+          def yaml_safe_load(yaml, file)
+            YAML.safe_load(yaml, [Symbol], [], true, file, symbolize_names: true)
+          end
         else
           def yaml_safe_load(yaml, file)
-            YAML.safe_load(yaml, [Symbol], [], true, file)
+            reuslt = YAML.safe_load(yaml, [Symbol], [], true, file)
+            symbolize_keys(reuslt)
           end
-        end
 
-        def symbolize_key(result)
-          case result
-          when Hash
-            result.keys.each do |key|
-              result[key.to_sym] = symbolize_key(result.delete(key))
+          def symbolize_keys(result)
+            if result.is_a? Hash
+              result.each_with_object({}) do |(key, value), hash|
+                hash[key.to_sym] = symbolize_keys(value)
+              end
+            elsif result.is_a? Array
+              result.map(&method(:symbolize_keys))
+            else
+              result
             end
-          when Array
-            result.map! { |value| symbolize_key(value) }
           end
-          result
+        end
+
+        def load_yaml(file)
+          yaml_safe_load(File.binread(file), file)
         end
       end
     end

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

@@ -9,11 +9,10 @@ module RgGen
           code_blocks[kind] << block
         end
 
-        def generate(context, kind, code)
-          return code unless generatable?(kind)
-          execute_code_blocks(
-            context, kind, code || context.create_blank_code
-          )
+        def generate(context, code, kind)
+          code_blocks[kind].each do |block|
+            execute_code_block(context, code, block)
+          end
         end
 
         def copy
@@ -28,30 +27,18 @@ module RgGen
           @code_blocks ||= Hash.new { |blocks, kind| blocks[kind] = [] }
         end
 
-        def generatable?(kind)
-          @code_blocks&.key?(kind)
-        end
-
-        def execute_code_blocks(context, kind, code)
-          code_blocks[kind].each(&code_block_executor(context, code))
-          code
-        end
-
-        def code_block_executor(context, code)
-          lambda do |block|
-            if block.arity.zero?
-              code << context.instance_exec(&block)
-            else
-              context.instance_exec(code, &block)
-            end
+        def execute_code_block(context, code, block)
+          if block.arity.zero?
+            code << context.instance_exec(&block)
+          else
+            context .instance_exec(code, &block)
           end
         end
 
         protected
 
         def copy_code_blocks(original_blocks)
-          original_blocks
-            .each { |kind, blocks| code_blocks[kind] = blocks.dup }
+          original_blocks.each { |kind, blocks| code_blocks[kind] = blocks.dup }
         end
       end
     end