rggen-core 0.9.0

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module OutputBase
+      class ComponentFactory < Base::ComponentFactory
+        private
+
+        def create_component(parent, configuration, register_map, &block)
+          target_component.new(parent, configuration, register_map, &block)
+        end
+
+        def create_features(component, configuration, register_map)
+          @feature_factories.each_value do |factory|
+            create_feature(component, factory, configuration, register_map)
+          end
+        end
+
+        def create_children(component, configuration, register_map)
+          register_map.children.each do |child|
+            create_child(component, configuration, child)
+          end
+        end
+
+        def post_build(component)
+          component.pre_build
+        end
+
+        def finalize(component)
+          component.build
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module OutputBase
+      class ERBEngine < TemplateEngine
+        def file_extension
+          :erb
+        end
+
+        def parse_template(path)
+          Erubi::Engine.new(File.binread(path), filename: path)
+        end
+
+        def render(context, template)
+          context.instance_eval(template.src, template.filename, 1)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module OutputBase
+      class Feature < Base::Feature
+        include Base::HierarchicalFeatureAccessors
+
+        class << self
+          attr_reader :pre_builders
+          attr_reader :builders
+
+          def code_generators
+            @code_generators ||= {}
+          end
+
+          def template_engine(engine = nil)
+            @template_engine = engine.instance if engine
+            @template_engine
+          end
+
+          attr_reader :file_writer
+
+          def exported_methods
+            @exported_methods ||= []
+          end
+
+          private
+
+          def pre_build(&body)
+            @pre_builders ||= []
+            @pre_builders << body
+          end
+
+          def build(&body)
+            @builders ||= []
+            @builders << body
+          end
+
+          [:pre_code, :main_code, :post_code].each do |phase|
+            define_method(phase) do |kind, **options, &body|
+              block =
+                if options[:from_template]
+                  caller_location = caller_locations(1, 1).first
+                  template_path = extract_template_path(options)
+                  -> { process_template(template_path, caller_location) }
+                else
+                  body
+                end
+              code_generators[__method__] ||= CodeGenerator.new
+              code_generators[__method__].register(kind, block)
+            end
+          end
+
+          def extract_template_path(options)
+            path = options[:from_template]
+            path.equal?(true) ? nil : path
+          end
+
+          def write_file(file_name_pattern, &body)
+            @file_writer = FileWriter.new(file_name_pattern, body)
+          end
+
+          def export(*methods)
+            methods.each do |method|
+              exported_methods.include?(method) || (
+                exported_methods << method
+              )
+            end
+          end
+        end
+
+        class << self
+          def inherited(subclass)
+            export_instance_variable(:@pre_builders, subclass, &:dup)
+            export_instance_variable(:@builders, subclass, &:dup)
+            export_instance_variable(:@template_engine, subclass)
+            export_instance_variable(:@file_writer, subclass)
+            export_instance_variable(:@exported_methods, subclass, &:dup)
+            copy_code_generators(subclass)
+          end
+
+          def copy_code_generators(subclass)
+            @code_generators&.each do |phase, generator|
+              subclass.code_generators[phase] = generator.copy
+            end
+          end
+        end
+
+        def post_initialize
+          define_hierarchical_accessors
+        end
+
+        def pre_build
+          helper
+            .pre_builders
+            &.each { |body| instance_exec(&body) }
+        end
+
+        def build
+          helper
+            .builders
+            &.each { |body| instance_exec(&body) }
+        end
+
+        def export(*methods)
+          methods.each do |method|
+            unless exported_methods(:class).include?(method) ||
+                   exported_methods(:object).include?(method)
+              exported_methods(:object) << method
+            end
+          end
+        end
+
+        def exported_methods(scope)
+          if scope == :class
+            self.class.exported_methods
+          else
+            @exported_methods ||= []
+          end
+        end
+
+        def generate_code(phase, kind, code = nil)
+          generator = self.class.code_generators[phase]
+          (generator&.generate(self, kind, code)) || code
+        end
+
+        def write_file(directory = nil)
+          file_writer = self.class.file_writer
+          file_writer&.write_file(self, directory)
+        end
+
+        private
+
+        def configuration
+          component.configuration
+        end
+
+        def process_template(path = nil, caller_location = nil)
+          caller_location ||= caller_locations(1, 1).first
+          template_engine = self.class.template_engine
+          template_engine.process_template(self, path, caller_location)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module OutputBase
+      class FeatureFactory < Base::FeatureFactory
+        def create(component, configuration, register_map)
+          create_feature(component, configuration, register_map)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module OutputBase
+      class FileWriter
+        def initialize(pattern, body)
+          @pattern = Erubi::Engine.new(pattern)
+          @body = body
+        end
+
+        def write_file(context, directory = nil)
+          path = generate_path(context, directory)
+          content = generate_content(context, path)
+          create_directory(path)
+          File.binwrite(path, content)
+        end
+
+        private
+
+        def generate_path(context, directory)
+          [
+            *Array(directory), context.instance_eval(@pattern.src)
+          ].map(&:to_s).reject(&:empty?).to_path
+        end
+
+        def generate_content(context, path)
+          content = context.create_blank_file(path)
+          @body && context.instance_exec(content, &@body)
+          content
+        end
+
+        def create_directory(path)
+          directory = path.dirname
+          directory.directory? || directory.mkpath
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module OutputBase
+      class TemplateEngine
+        include Singleton
+
+        def process_template(context, path = nil, caller_location = nil)
+          unless path
+            caller_location ||= caller_locations(1, 1).first
+            path = File.ext(caller_location.path, file_extension.to_s)
+          end
+          render(context, templates[path])
+        end
+
+        private
+
+        def templates
+          @templates ||= Hash.new do |templates, path|
+            templates[path] = parse_template(path)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rggen/core/printers.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    class HelpPrinter
+      def initialize(option_parser)
+        @option_parser = option_parser
+      end
+
+      def run(_builder, _options)
+        puts @option_parser.help
+      end
+    end
+
+    class VersionPrinter
+      def initialize(verbose)
+        @verbose = verbose
+      end
+
+      def run(builder, options)
+        verbose? && load_setup_file(builder, options[:setup])
+        puts help_message(builder)
+      end
+
+      private
+
+      def verbose?
+        @verbose
+      end
+
+      def load_setup_file(builder, file)
+        file.nil? || file.empty? || builder.load_setup_file(file)
+      end
+
+      def help_message(builder)
+        [
+          simple_version,
+          *(verbose? && verbose_version(builder) || nil)
+        ].join("\n")
+      end
+
+      def simple_version
+        "RgGen #{Core::MAJOR}.#{Core::MINOR}"
+      end
+
+      def verbose_version(builder)
+        { core: Core::VERSION }
+          .merge(builder.library_versions)
+          .map { |(lib, version)| "  - rggen-#{lib} #{version}" }
+      end
+    end
+  end
+end

data/lib/rggen/core/register_map.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module RegisterMap
+      def self.setup(builder)
+        builder.input_component_registry(:register_map) do
+          register_component [
+            :register_map, :register_block, :register, :bit_field
+          ] do |category|
+            component Component, ComponentFactory
+            feature Feature, FeatureFactory if category != :register_map
+          end
+
+          base_loader Loader
+          register_loaders [RubyLoader, JSONLoader, YAMLLoader]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module RegisterMap
+      class Component < InputBase::Component
+        include Base::HierarchicalAccessors
+
+        attr_reader :configuration
+
+        private
+
+        def post_initialize(_parent, configuration)
+          @configuration = configuration
+          define_hierarchical_accessors
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module RegisterMap
+      class ComponentFactory < InputBase::ComponentFactory
+        private
+
+        def create_component(parent, configuration, _, &block)
+          @target_component.new(parent, configuration, &block)
+        end
+
+        def create_input_data(&block)
+          RegisterMapData.new(valid_value_lists, &block)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module RegisterMap
+      class RegisterMapError < Core::RuntimeError
+      end
+
+      module RaiseError
+        def error(message, position = nil)
+          raise RegisterMapError.new(message, position || @position)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module RegisterMap
+      class Feature < InputBase::Feature
+        include Base::HierarchicalFeatureAccessors
+        include RaiseError
+
+        private
+
+        def configuration
+          @component.configuration
+        end
+
+        def post_initialize
+          define_hierarchical_accessors
+        end
+      end
+    end
+  end
+end