rggen-core 0.9.0

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Builder
+      class ComponentEntry
+        Entry = Struct.new(:target, :factory)
+
+        [:component, :feature].each do |entry_name|
+          define_method(entry_name) do |target, factory|
+            instance_variable_set("@#{__method__}", Entry.new(target, factory))
+          end
+        end
+
+        def feature_registry
+          return unless @feature
+          @feature_registry ||= FeatureRegistry.new(*@feature.values)
+        end
+
+        def build_factory
+          @component.factory.new do |f|
+            f.target_component(@component.target)
+            f.feature_factories(feature_registry&.build_factories)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Builder
+      class ComponentRegistry
+        def initialize(name, builder)
+          @name = name
+          @builder = builder
+          @entries = []
+        end
+
+        def register_component(categories = nil, &block)
+          if categories
+            Array(categories).each do |category|
+              @entries << create_new_entry(category, block)
+            end
+          else
+            @entries << create_new_entry(nil, block)
+          end
+        end
+
+        def build_factory
+          factories = @entries.map(&:build_factory)
+          factories.each_cons(2) { |(f0, f1)| f0.child_factory(f1) }
+          root_factory = factories.first
+          root_factory.root_factory
+          root_factory
+        end
+
+        private
+
+        def create_new_entry(category, block)
+          entry = ComponentEntry.new
+          Docile.dsl_eval(entry, category, &block)
+          add_feature_registry(category, entry.feature_registry)
+          entry
+        end
+
+        def add_feature_registry(category, feature_registry)
+          feature_registry || return
+          @builder.add_feature_registry(@name, category, feature_registry)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Builder
+      class FeatureRegistry
+        def initialize(base_feature, factory)
+          @base_feature = base_feature
+          @factory = factory
+          @feature_entries = {}
+          @enabled_features = {}
+        end
+
+        def define_simple_feature(names, context = nil, &body)
+          Array(names)
+            .each { |name| create_new_entry(:simple, name, context, body) }
+        end
+
+        def define_list_feature(list_names, context = nil, &body)
+          Array(list_names)
+            .each { |name| create_new_entry(:list, name, context, body) }
+        end
+
+        def define_list_item_feature(list_name, feature_names, context = nil, &body)
+          entry = @feature_entries[list_name]
+          entry&.match_entry_type?(:list) ||
+            (raise BuilderError.new("unknown list feature: #{list_name}"))
+          Array(feature_names)
+            .each { |name| entry.define_feature(name, context, &body) }
+        end
+
+        def enable(feature_or_list_names, feature_names = nil)
+          if feature_names
+            @enabled_features[feature_or_list_names]
+              &.merge!(Array(feature_names))
+          else
+            Array(feature_or_list_names).each do |name|
+              @enabled_features[name] ||= []
+            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
+        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))
+          else
+            @feature_entries.clear
+          end
+        end
+
+        def simple_feature?(feature_name)
+          enabled_feature?(feature_name, :simple)
+        end
+
+        def list_feature?(list_name, feature_name = nil)
+          return false unless enabled_feature?(list_name, :list)
+          return true unless feature_name
+          enabled_list_item_feature?(list_name, 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)
+          end
+        end
+
+        def build_factories
+          @enabled_features
+            .select { |n, _| @feature_entries.key?(n) }
+            .map { |n, f| [n, @feature_entries[n].build_factory(f)] }
+            .to_h
+        end
+
+        private
+
+        FEATURE_ENTRIES = {
+          simple: SimpleFeatureEntry, list: ListFeatureEntry
+        }.freeze
+
+        def create_new_entry(type, name, context, body)
+          entry = FEATURE_ENTRIES[type].new(self, name)
+          entry.setup(@base_feature, @factory, context, body)
+          @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)
+        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)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Builder
+      class InputComponentRegistry < ComponentRegistry
+        def initialize(name, builder)
+          super
+          @loaders = []
+        end
+
+        attr_setter :base_loader
+
+        def register_loader(loader)
+          @loaders << loader
+        end
+
+        def register_loaders(loaders)
+          @loaders.concat(Array(loaders))
+        end
+
+        def define_loader(&body)
+          loader = Class.new(@base_loader, &body)
+          register_loader(loader)
+        end
+
+        def build_factory
+          factory = super
+          factory.loaders(@loaders)
+          factory
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Builder
+      class ListFeatureEntry
+        include Base::SharedContext
+
+        def initialize(registry, name)
+          @registry = registry
+          @name = 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)
+          body && 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(enabled_features)
+          @factory.new(@name) do |f|
+            f.target_features(target_features(enabled_features))
+            f.target_feature(@default_feature)
+          end
+        end
+
+        def define_base_feature(&body)
+          body && @base_feature.class_exec(&body)
+        end
+
+        alias_method :base_feature, :define_base_feature
+
+        def define_feature(feature_name, context = nil, &body)
+          @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.attach_context(context)
+          end
+          body && feature.class_exec(feature_name, &body)
+        end
+
+        alias_method :feature, :define_feature
+
+        def define_default_feature(&body)
+          @default_feature ||= Class.new(@base_feature)
+          body && @default_feature.class_exec(&body)
+        end
+
+        alias_method :default_feature, :define_default_feature
+
+        def delete(features = nil)
+          if features
+            Array(features).each { |feature| @features.delete(feature) }
+          else
+            @features.clear
+          end
+        end
+
+        def feature?(feature)
+          @features.key?(feature)
+        end
+
+        private
+
+        def attach_shared_context(context)
+          [@factory, @base_feature, self].each do |target|
+            target.attach_context(context)
+          end
+        end
+
+        def target_features(enabled_features)
+          enabled_features
+            .select { |n| @features.key?(n) }
+            .map { |n| [n, @features[n]] }
+            .to_h
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Builder
+      class OutputComponentRegistry < ComponentRegistry
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Builder
+      class SimpleFeatureEntry
+        def initialize(registry, name)
+          @registry = registry
+          @name = name
+        end
+
+        attr_reader :registry
+        attr_reader :name
+
+        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
+
+        def build_factory(_enabled_features)
+          @factory.new(@name) { |f| f.target_feature(@feature) }
+        end
+
+        private
+
+        def define_feature(base, context, body)
+          feature = Class.new(base)
+          context && feature.attach_context(context)
+          body && feature.class_exec(@name, &body)
+          feature
+        end
+      end
+    end
+  end
+end

data/lib/rggen/core/cli.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    class CLI
+      def initialize(builder = nil)
+        RgGen.builder(builder || Builder.create)
+      end
+
+      def run(args)
+        options = parse_options(args)
+        builder = RgGen.builder
+        runner(options).run(builder, options)
+      end
+
+      private
+
+      def parse_options(args)
+        options = Options.new
+        options.parse(args)
+        options
+      end
+
+      def runner(options)
+        options[:runner] || Generator.new
+      end
+    end
+  end
+end

data/lib/rggen/core/configuration.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Configuration
+      def self.setup(builder)
+        builder.input_component_registry(:configuration) do
+          register_component do
+            component Component, ComponentFactory
+            feature Feature, FeatureFactory
+          end
+
+          base_loader Loader
+          register_loaders [RubyLoader, JSONLoader, YAMLLoader]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Configuration
+      class Component < InputBase::Component
+      end
+    end
+  end
+end