rggen-core 0.20.0 → 0.24.0

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Builder
+      class LoaderRegistry
+        def initialize
+          @loaders = []
+          @extractors = []
+          @ignore_values = {}
+        end
+
+        def register_loader(loader)
+          register_loaders([loader])
+        end
+
+        def register_loaders(loaders)
+          @loaders.concat(Array(loaders))
+        end
+
+        def define_value_extractor(layers, value, &body)
+          @extractors <<
+            create_extractor(layers, value, &body)
+        end
+
+        def ignore_value(layers, value)
+          ignore_values(layers, [value])
+        end
+
+        def ignore_values(layers, values)
+          [layers].flatten.each do |layer|
+            (@ignore_values[layer] ||= []).concat(Array(values))
+          end
+        end
+
+        def create_loaders
+          @loaders.map { |loader| loader.new(@extractors, @ignore_values) }
+        end
+
+        private
+
+        def create_extractor(layers, value, &body)
+          Class.new(Core::InputBase::InputValueExtractor, &body).new(layers, value)
+        end
+      end
+    end
+  end
+end

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

@@ -5,13 +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
 
-          base_loader Loader
-          register_loaders [RubyLoader, JSONLoader, YAMLLoader]
+          register_loader :ruby, RubyLoader
+          register_loader :json, JSONLoader
+          register_loader :toml, TOMLLoader
+          register_loader :yaml, YAMLLoader
         end
       end
     end

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

@@ -4,8 +4,10 @@ module RgGen
   module Core
     module Configuration
       module HashLoader
-        def format(read_data, file)
-          input_data.values(Hash(read_data), file)
+        private
+
+        def format_layer_data(read_data, _layer, file)
+          Hash(read_data)
         rescue TypeError => e
           raise Core::LoadError.new(e.message, file)
         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/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,6 @@
 
 require 'facets/array/merge'
 require 'facets/file/ext'
-require 'facets/hash/at'
 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/feature.rb

@@ -149,8 +149,8 @@ module RgGen
         end
 
         def do_verify(scope)
-          Array(self.class.verifiers&.at(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/input_data.rb

@@ -51,9 +51,9 @@ module RgGen
         end
 
         def load_file(file)
-          build_by_block(
-            instance_eval("-> { #{File.binread(file)} }", file, 1)
-          )
+          build_by_block(instance_eval(<<~BODY, file, 1))
+            -> { #{File.binread(file)} }  # -> { File.binread(file) }
+          BODY
         end
 
         private
@@ -79,7 +79,11 @@ module RgGen
 
         def position_from_caller
           locations = caller_locations(3, 2)
-          locations[0].path.include?('docile') ? locations[1] : locations[0]
+          include_docile_path?(locations[0]) && locations[1] || locations[0]
+        end
+
+        def include_docile_path?(caller_location)
+          caller_location.path.include?('docile')
         end
 
         def create_child_data(layer, &block)

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module InputBase
+      class InputValueExtractor
+        def initialize(target_layers, target_value)
+          @target_layers = Array(target_layers)
+          @target_value = target_value
+        end
+
+        class << self
+          attr_reader :extractor
+
+          private
+
+          def extract(&body)
+            @extractor = body
+          end
+        end
+
+        def target_value?(layer, value)
+          value == @target_value &&
+            (@target_layers.empty? || @target_layers.include?(layer))
+        end
+
+        def extract(input_data)
+          body = self.class.extractor
+          instance_exec(input_data, &body)
+        end
+      end
+    end
+  end
+end