rggen-core 0.21.0 → 0.25.0

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

@@ -15,11 +15,11 @@ module RgGen
         attr_reader :registry
         attr_reader :name
 
-        def setup(base_feature, base_factory, context, body)
+        def setup(base_feature, base_factory, context, &body)
           @base_feature = Class.new(base_feature)
           @factory = Class.new(base_factory)
           context && attach_shared_context(context)
-          body && Docile.dsl_eval(self, @name, &body)
+          block_given? && Docile.dsl_eval(self, @name, &body)
         end
 
         def match_entry_type?(entry_type)
@@ -49,9 +49,8 @@ module RgGen
           @features[feature_name] ||= Class.new(@base_feature)
           feature = @features[feature_name]
           if context
-            feature.method_defined?(:shared_context) && (
-              raise BuilderError.new('shared context has already been set')
-            )
+            feature.method_defined?(:shared_context) &&
+              (raise BuilderError.new('shared context has already been set'))
             feature.attach_context(context)
           end
           body && feature.class_exec(feature_name, &body)
@@ -87,10 +86,7 @@ module RgGen
         end
 
         def target_features(enabled_features)
-          enabled_features
-            .select { |n| @features.key?(n) }
-            .map { |n| [n, @features[n]] }
-            .to_h
+          @features.slice(*enabled_features)
         end
       end
     end

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

@@ -19,8 +19,7 @@ module RgGen
         end
 
         def define_value_extractor(layers, value, &body)
-          @extractors <<
-            create_extractor(layers, value, &body)
+          @extractors << create_extractor(layers, value, &body)
         end
 
         def ignore_value(layers, value)

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Builder
+      class PluginRegistry
+        def initialize(plugin_module, &block)
+          @plugin_module = plugin_module
+          @block = block
+        end
+
+        def default_setup(builder)
+          @plugin_module.plugin_spec.activate(builder)
+        end
+
+        def optional_setup(builder)
+          @block && @plugin_module.instance_exec(builder, &@block)
+        end
+
+        def version_info
+          @plugin_module.plugin_spec.version_info
+        end
+      end
+
+      class PluginManager
+        def initialize(builder)
+          @builder = builder
+          @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)
+        end
+
+        def load_plugins(plugins, no_default_plugins, activation = true)
+          RgGen.builder(@builder)
+          merge_plugins(plugins, no_default_plugins).each(&method(:load_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)
+        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) }
+        end
+
+        def version_info
+          @plugins.map(&:version_info)
+        end
+
+        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
+        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)
+        end
+
+        def merge_plugins(plugins, no_default_plugins)
+          [
+            *default_plugins(no_default_plugins),
+            *plugins_from_env,
+            *plugins
+          ]
+        end
+
+        DEFAULT_PLUGSINS = 'rggen/setup'
+
+        def default_plugins(no_default_plugins)
+          load_default_plugins?(no_default_plugins) && DEFAULT_PLUGSINS || nil
+        end
+
+        def load_default_plugins?(no_default_plugins)
+          return false if no_default_plugins
+          return false if ENV.key?('RGGEN_NO_DEFAULT_PLUGINS')
+          return false if Gem.find_files(DEFAULT_PLUGSINS).empty?
+          true
+        end
+
+        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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Builder
+      class PluginSpec
+        def initialize(name, plugin_module)
+          @name = name
+          @plugin_module = plugin_module
+          @component_registrations = []
+          @loader_registrations = []
+          @files = []
+        end
+
+        def version(value = nil)
+          @version = value if value
+          version_value
+        end
+
+        def version_info
+          "#{@name} #{version}"
+        end
+
+        def register_component(component, layers = nil, &body)
+          @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) }
+        end
+
+        def register_files(files)
+          root = File.dirname(caller_locations(1, 1).first.path)
+          files.each { |file| @files << File.join(root, file) }
+        end
+
+        alias_method :files, :register_files
+
+        def activate(builder)
+          activate_components(builder)
+          activate_loaders(builder)
+          load_files
+        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)
+        end
+
+        def activate_components(builder)
+          @component_registrations.each do |component, layers, body|
+            builder
+              .output_component_registry(component)
+              .register_component(layers, &body)
+          end
+        end
+
+        def activate_loaders(builder)
+          @loader_registrations.each do |component, loader_type, loader|
+            builder.register_loader(component, loader_type, loader)
+          end
+        end
+
+        def load_files
+          @files.each(&method(:require))
+        end
+      end
+    end
+  end
+end

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

@@ -12,8 +12,8 @@ module RgGen
         attr_reader :registry
         attr_reader :name
 
-        def setup(base_feature, factory, context, body)
-          @feature = define_feature(base_feature, context, body)
+        def setup(base_feature, factory, context, &body)
+          @feature = define_feature(base_feature, context, &body)
           @factory = factory
         end
 
@@ -27,10 +27,10 @@ module RgGen
 
         private
 
-        def define_feature(base, context, body)
+        def define_feature(base, context, &body)
           feature = Class.new(base)
           context && feature.attach_context(context)
-          body && feature.class_exec(@name, &body)
+          block_given? && feature.class_exec(@name, &body)
           feature
         end
       end

data/lib/rggen/core/configuration.rb

@@ -5,14 +5,15 @@ module RgGen
     module Configuration
       def self.setup(builder)
         builder.input_component_registry(:configuration) do
-          register_component do
+          register_global_component do
             component Component, ComponentFactory
             feature Feature, FeatureFactory
           end
 
           register_loader :ruby, RubyLoader
-          register_loader :yaml, YAMLLoader
           register_loader :json, JSONLoader
+          register_loader :toml, TOMLLoader
+          register_loader :yaml, YAMLLoader
         end
       end
     end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Configuration
+      class TOMLLoader < Loader
+        include HashLoader
+        include InputBase::TOMLLoader
+
+        support_types [:toml]
+
+        def read_file(file)
+          load_toml(file)
+        end
+      end
+    end
+  end
+end

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

@@ -2,10 +2,10 @@
 
 class Object
   def export_instance_variable(variable, to)
-    return unless instance_variable_defined?(variable)
-    v = instance_variable_get(variable)
-    v = yield(v) if block_given?
-    to.instance_variable_set(variable, v)
+    instance_variable_defined?(variable) &&
+      instance_variable_get(variable)
+        .yield_self { |v| block_given? ? yield(v) : v }
+        .yield_self { |v| to.instance_variable_set(variable, v) }
   end
 
   def singleton_exec(*args, &block)

data/lib/rggen/core/dsl.rb

@@ -15,11 +15,13 @@ module RgGen
         :define_simple_feature,
         :define_list_feature,
         :define_list_item_feature,
+        :define_value_extractor,
         :enable,
         :disable_all,
         :disable,
         :delete,
-        :setup
+        :register_plugin,
+        :load_plugin
       ].each do |method_name|
         def_delegator :'RgGen.builder', method_name
       end

data/lib/rggen/core/exceptions.rb

@@ -3,23 +3,28 @@
 module RgGen
   module Core
     class RgGenError < StandardError
-      def initialize(message, additional_info = nil)
+      def initialize(message, location_info = nil, verbose_info = nil)
         super(message)
         @error_message = message
-        @additional_info = additional_info
+        @location_info = location_info
+        @verbose_info = verbose_info
       end
 
       attr_reader :error_message
-      attr_reader :additional_info
+      attr_reader :location_info
+      attr_reader :verbose_info
 
       def to_s
-        additional_info ? "#{super} -- #{additional_info}" : super
+        location_info && "#{super} -- #{location_info}" || super
       end
     end
 
     class BuilderError < RgGenError
     end
 
+    class PluginError < RgGenError
+    end
+
     class RuntimeError < RgGenError
     end
 

data/lib/rggen/core/facets.rb

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

data/lib/rggen/core/generator.rb

@@ -4,7 +4,7 @@ module RgGen
   module Core
     class Generator
       def run(builder, options)
-        load_setup_file(builder, options[:setup])
+        load_plugins(builder, options)
         load_configuration(builder, options[:configuration])
         load_register_map(builder, options.register_map_files)
         write_files(builder, options)
@@ -15,8 +15,8 @@ module RgGen
       attr_reader :configuration
       attr_reader :register_map
 
-      def load_setup_file(builder, file)
-        builder.load_setup_file(file)
+      def load_plugins(builder, options)
+        builder.load_plugins(options[:plugins], options[:no_default_plugins])
       end
 
       def load_configuration(builder, file)

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

@@ -9,10 +9,22 @@ module RgGen
           define_proxy_calls(feature, feature.properties)
         end
 
+        def document_only
+          @document_only = true
+        end
+
+        def document_only?
+          instance_variable_defined?(:@document_only) && @document_only
+        end
+
         def properties
           features.flat_map(&:properties)
         end
 
+        def post_build
+          features.each(&:post_build)
+        end
+
         def verify(scope)
           features.each { |feature| feature.verify(scope) }
           children.each { |child| child.verify(scope) } if scope == :all

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

@@ -79,6 +79,7 @@ module RgGen
         def post_build(component)
           exist_no_children?(component) &&
             raise_no_children_error(component)
+          component.post_build
           component.verify(:component)
         end