releasehx 0.1.2 → 0.2.0

data/lib/sourcerer/jekyll/liquid/file_system.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-require 'liquid'
-
-module Sourcerer
-  module Jekyll
-    module Liquid
-      # A custom Liquid file system that extends `Liquid::LocalFileSystem` to support
-      # multiple root paths for template lookups. This allows templates to be
-      # resolved from a prioritized list of directories.
-      class FileSystem < ::Liquid::LocalFileSystem
-        # Initializes the file system with one or more root paths.
-        #
-        # @param roots_or_root [String, Array<String>] A single root path or an array of root paths.
-        # rubocop:disable Lint/MissingSuper
-        # Intentional: Custom implementation that doesn't need parent's initialization
-        def initialize roots_or_root
-          if roots_or_root.is_a?(Array)
-            @roots = roots_or_root.map { |root| File.expand_path(root) }
-            @multi_root = true
-          else
-            @root = File.expand_path(roots_or_root)
-            @multi_root = false
-          end
-        end
-        # rubocop:enable Lint/MissingSuper
-
-        # Finds the full path of a template, searching through multiple roots if configured.
-        #
-        # @param template_path [String] The path to the template.
-        # @return [String] The full, validated path to the template.
-        # @raise [Liquid::FileSystemError] if the template is not found.
-        def full_path template_path
-          if @multi_root
-            @roots.each do |root|
-              full = File.expand_path(File.join(root, template_path))
-              return full if File.exist?(full) && full.start_with?(root)
-            end
-            raise ::Liquid::FileSystemError, "Template not found: '#{template_path}' in paths: #{@roots}"
-          else
-            full = File.expand_path(File.join(@root, template_path))
-            validate_path(full)
-          end
-        end
-
-        # Reads the content of a template file.
-        #
-        # @param template_path [String] The path to the template.
-        # @return [String] The content of the template file.
-        def read_template_file template_path
-          path = full_path(template_path)
-          File.read(path)
-        end
-
-        private
-
-        # Validates that the resolved path is within the allowed root(s).
-        def validate_path path
-          if @multi_root
-            # Check if path starts with any of the allowed roots
-            unless @roots.any? { |root| path.start_with?(root) }
-              raise ::Liquid::FileSystemError, "Illegal template path '#{path}'"
-            end
-
-          else
-            raise ::Liquid::FileSystemError, "Illegal template path '#{path}'" unless path.start_with?(@root)
-
-          end
-          path
-        end
-      end
-    end
-  end
-end

data/lib/sourcerer/jekyll/liquid/filters.rb

@@ -1,215 +0,0 @@
-# frozen_string_literal: true
-
-require 'kramdown-asciidoc'
-require 'base64'
-require 'cgi'
-
-module Sourcerer
-  module Jekyll
-    module Liquid
-      # This module provides a set of custom filters for use in Liquid templates.
-      module Filters
-        # Renders a Liquid template string with a given scope.
-        # @param input [String, Object] The Liquid template string or a pre-parsed template object.
-        # @param vars [Hash] A hash of variables to use as the scope.
-        # @return [String] The rendered output.
-        def render input, vars = nil
-          scope = if vars.is_a?(Hash)
-                    vars.transform_keys(&:to_s)
-                  else
-                    {}
-                  end
-
-          template =
-            if input.respond_to?(:render) && input.respond_to?(:templated?) && input.templated?
-              input
-            else
-              ::Liquid::Template.parse(input.to_s)
-            end
-
-          template.render(scope)
-        end
-
-        # Converts a string into a slug.
-        # @param input [String] The string to convert.
-        # @param format [String] The desired format (`kebab`, `snake`, `camel`, `pascal`).
-        # @return [String] The sluggerized string.
-        def sluggerize input, format = 'kebab'
-          return input unless input.is_a? String
-
-          case format
-          when 'kebab' then input.downcase.gsub(/[\s\-_]/, '-')
-          when 'snake' then input.downcase.gsub(/[\s\-_]/, '_')
-          when 'camel' then input.downcase.gsub(/[\s\-_]/, '_').camelize(:lower)
-          when 'pascal' then input.downcase.gsub(/[\s\-_]/, '_').camelize(:upper)
-          else input
-          end
-        end
-
-        # Replaces double newlines with a newline and a plus sign.
-        # @param input [String] The input string.
-        # @return [String] The processed string.
-        def plusify input
-          input.gsub(/\n\n+/, "\n+\n")
-        end
-
-        # Converts a Markdown string to AsciiDoc.
-        # @param input [String] The Markdown string.
-        # @param wrap [String] The wrapping option for the converter.
-        # @return [String] The converted AsciiDoc string.
-        def md_to_adoc input, wrap = 'ventilate'
-          options = {}
-          options[:wrap] = wrap.to_sym if wrap
-          Kramdoc.convert(input, options)
-        end
-
-        # Indents a string by a given number of spaces.
-        # @param input [String] The string to indent.
-        # @param spaces [Integer] The number of spaces for indentation.
-        # @param line1 [Boolean] Whether to indent the first line.
-        # @return [String] The indented string.
-        def indent input, spaces = 2, line1: false
-          indent = ' ' * spaces
-          lines = input.split("\n")
-          indented = if line1
-                       lines.map { |line| indent + line }
-                     else
-                       lines.map.with_index { |line, i| i.zero? ? line : indent + line }
-                     end
-          indented.join("\n")
-        end
-
-        # Checks the type of a value in the context of SG-YML.
-        # @param input [Object] The value to check.
-        # @return [String] A string representing the type.
-        def sgyml_type_check input
-          if input.nil?
-            'Null:nil'
-          elsif input.is_a? Array
-            # if all items in Array are (integer, float, string, boolean)
-            if input.all? do |item|
-              item.is_a?(Integer) || item.is_a?(Float) || item.is_a?(String) ||
-              item.is_a?(TrueClass) || item.is_a?(FalseClass)
-            end
-              'Compound:ArrayList'
-            elsif input.all? { |item| item.is_a?(Hash) && (item.keys.length >= 2) }
-              'Compound:ArrayTable'
-            else
-              'Compound:Array'
-            end
-          elsif input.is_a? Hash
-            if input.values.all? { |value| value.is_a?(Hash) && (value.keys.length >= 2) }
-              'Compound:MapTable'
-            else
-              'Compound:Map'
-            end
-          elsif input.is_a? String
-            'Scalar:String'
-          elsif input.is_a? Integer
-            'Scalar:Number'
-          elsif input.is_a? Time
-            'Scalar:DateTime'
-          elsif input.is_a? Float
-            'Scalar:Float'
-          elsif input.is_a?(TrueClass) || input.is_a?(FalseClass)
-            'Scalar:Boolean'
-          else
-            'unknown:unknown'
-          end
-        end
-
-        # Returns the Ruby class name of a value.
-        # @param input [Object] The value.
-        # @return [String] The class name.
-        def ruby_class input
-          input.class.name
-        end
-
-        # Removes markup from a string.
-        # @param input [String] The string to demarkupify.
-        # @return [String] The demarkupified string.
-        def demarkupify input
-          return input unless input.is_a? String
-
-          input = input.gsub(/`"|"`/, '"')
-          input = input.gsub(/'`|`'/, "'")
-          input = input.gsub(/[*_`]/, '')
-          # change curly quotes to striaght quotes
-          input = input.gsub(/[“”]/, '"')
-          input.gsub(/[‘’]/, "'")
-        end
-
-        # Dumps a value to YAML format.
-        # @param input [Object] The value to dump.
-        # @return [String] The YAML representation.
-        def inspect_yaml input
-          require 'yaml'
-          YAML.dump(input)
-        end
-
-        # Base64 encodes a string.
-        # @param input [String] The string to encode.
-        # @return [String] The Base64-encoded string.
-        def base64 input
-          return input unless input.is_a? String
-
-          Base64.strict_encode64(input)
-        end
-
-        # Decodes a Base64-encoded string.
-        # @param input [String] The string to decode.
-        # @return [String] The decoded string.
-        def base64_decode input
-          return input unless input.is_a? String
-
-          Base64.strict_decode64(input)
-        rescue ArgumentError
-          # Return original input if decoding fails
-          input
-        end
-
-        # URL-encodes a string.
-        # @param input [String] The string to encode.
-        # @return [String] The URL-encoded string.
-        def url_encode input
-          return input unless input.is_a? String
-
-          CGI.escape(input)
-        end
-
-        # Decodes a URL-encoded string.
-        # @param input [String] The string to decode.
-        # @return [String] The decoded string.
-        def url_decode input
-          return input unless input.is_a? String
-
-          CGI.unescape(input)
-        rescue ArgumentError
-          # Return original input if decoding fails
-          input
-        end
-
-        # HTML-escapes a string.
-        # @param input [String] The string to escape.
-        # @return [String] The HTML-escaped string.
-        def html_escape input
-          return input unless input.is_a? String
-
-          CGI.escapeHTML(input)
-        end
-
-        # Unescapes an HTML-escaped string.
-        # @param input [String] The string to unescape.
-        # @return [String] The unescaped string.
-        def html_unescape input
-          return input unless input.is_a? String
-
-          CGI.unescapeHTML(input)
-        end
-      end
-    end
-  end
-end
-
-# Register the filters automatically
-Liquid::Template.register_filter(Sourcerer::Jekyll::Liquid::Filters)

data/lib/sourcerer/jekyll/liquid/tags.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Sourcerer
-  module Jekyll
-    # This module contains custom Liquid tags for the Sourcerer templating environment.
-    module Tags
-      # A Liquid tag for embedding and rendering a file within a template.
-      # It searches for the file in the configured include paths.
-      class EmbedTag < ::Liquid::Tag
-        # @param tag_name [String] The name of the tag ('embed').
-        # @param markup [String] The name of the partial to embed.
-        # @param tokens [Array<String>] The list of tokens.
-        def initialize tag_name, markup, tokens
-          super
-          @partial_name = markup.strip
-        end
-
-        # Renders the embedded file.
-        #
-        # @param context [Liquid::Context] The Liquid context.
-        # @return [String] The rendered content of the embedded file.
-        # @raise [IOError] if the embed file is not found.
-        def render context
-          includes_paths = context.registers[:includes_load_paths] || []
-
-          found_path = includes_paths.find do |base|
-            candidate = File.expand_path(@partial_name, base)
-            File.exist?(candidate)
-          end
-
-          raise "Embed file not found: #{@partial_name}" unless found_path
-
-          full_path = File.expand_path(@partial_name, found_path)
-          source = File.read(full_path)
-
-          partial = ::Liquid::Template.parse(source)
-          partial.render!(context)
-        end
-      end
-    end
-  end
-end
-
-Liquid::Template.register_tag('embed', Sourcerer::Jekyll::Tags::EmbedTag)

data/lib/sourcerer/jekyll/monkeypatches.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module Sourcerer
-  module Jekyll
-    # This module contains monkeypatches for Jekyll to modify or extend its behavior.
-    module Monkeypatches
-      # Patches Jekyll's `OptimizedIncludeTag` to modify its behavior.
-      # The patch enhances include path resolution and context handling to better
-      # suit the needs of Sourcerer's templating environment.
-      def self.patch_jekyll
-        return unless defined?(::Jekyll::Tags::OptimizedIncludeTag)
-
-        ::Jekyll::Tags::OptimizedIncludeTag.class_eval do
-          define_method :render do |context|
-            site = context.registers[:site]
-            file = render_variable(context) || @file
-
-            context.stack do
-              context['include'] = parse_params(context) if @params
-
-              source = site.inclusions[file]
-
-              unless source
-
-                # Debug lines before attempting path resolution
-
-                # Safe resolution
-                paths = context.registers[:includes_load_paths] || []
-                path = paths
-                       .map { |dir| File.join(dir, file) }
-                       .find { |p| File.file?(p) }
-
-                raise IOError, "Include file not found: #{file}" unless path
-
-                source = File.read(path)
-              end
-
-              partial = ::Liquid::Template.parse(source)
-              partial.registers[:site] = context.registers[:site]
-              partial.assigns['include'] = context['include']
-
-              ::Liquid::Template.register_filter(::Jekyll::Filters)
-              ::Liquid::Template.register_filter(::Sourcerer::Jekyll::Liquid::Filters)
-
-              # Use an isolated context so we can inspect and copy assigns
-              subcontext = ::Liquid::Context.new(
-                [{ 'include' => context['include'] }],
-                {}, # Environments
-                context.registers,
-                rethrow_errors: true)
-
-              rendered = partial.render!(subcontext)
-
-              # Copy assigns from subcontext to parent context
-              subcontext.environments.each do |env|
-                env.each do |k, v|
-                  # Avoid clobbering outer include if reentrant
-                  next if k == 'include'
-
-                  context.environments.first[k] = v
-                end
-              end
-
-              rendered
-            end
-          end
-        end
-
-        ::Liquid::Template.tags['include'] = ::Jekyll::Tags::OptimizedIncludeTag
-      end
-    end
-  end
-end

data/lib/sourcerer/jekyll.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'jekyll/bootstrapper'
-require_relative 'jekyll/monkeypatches'
-require_relative 'jekyll/liquid/file_system'
-require_relative 'jekyll/liquid/filters'
-require_relative 'jekyll/liquid/tags'
-require 'jekyll-asciidoc'
-
-module Sourcerer
-  # This module encapsulates the logic for initializing a Jekyll-like Liquid
-  # templating environment. It loads necessary plugins, applies monkeypatches,
-  # and registers custom Liquid filters and tags.
-  module Jekyll
-    # Initializes the Liquid templating runtime by loading plugins,
-    # applying patches, and registering custom filters.
-    def self.initialize_liquid_runtime
-      Bootstrapper.load_plugins
-      Monkeypatches.patch_jekyll
-      # Ensure Sourcerer filters are registered
-      ::Liquid::Template.register_filter(::Sourcerer::Jekyll::Liquid::Filters)
-      # Ensure jekyll-asciidoc filters are registered
-      # ::Liquid::Template.register_filter(Jekyll::AsciiDoc::Filters)
-    end
-  end
-end

data/lib/sourcerer/plaintext_converter.rb

@@ -1,75 +0,0 @@
-# This module will likely spin off into a gem
-
-# frozen_string_literal: true
-
-require 'asciidoctor'
-
-module Sourcerer
-  # A custom Asciidoctor converter that outputs plain text.
-  # It is registered for the "plaintext" backend and can be used to extract
-  # the raw text content or attributes from an AsciiDoc document.
-  class PlainTextConverter < Asciidoctor::Converter::Base
-    # Identify ourselves as a converter for the "plaintext" backend
-    register_for 'plaintext'
-
-    # The main entry point for the converter.
-    # It is called by Asciidoctor to convert a node.
-    #
-    # @param node [Asciidoctor::AbstractNode] The node to convert.
-    # @param _transform [String] The transform to apply (unused).
-    # @param _opts [Hash] Options for the conversion (unused).
-    # @return [String] The converted plain text output.
-    def convert node, _transform = nil, _opts = {}
-      if respond_to?("convert_#{node.node_name}", true)
-        send("convert_#{node.node_name}", node)
-      elsif node.respond_to?(:content)
-        node.content.to_s
-      elsif node.respond_to?(:text)
-        node.text.to_s
-      else
-        ''
-      end
-    end
-
-    private
-
-    # Converts the document node.
-    def convert_document node
-      emit_attrs = node.attr('sourcerer_mode') == 'emit_attrs'
-
-      if emit_attrs
-        # only emit attribute lines directly, nothing else
-        attrs = node.attributes.select do |k, v|
-          k.is_a?(String) && !v.nil? && !k.start_with?('backend-', 'safe-mode', 'doctype', 'sourcerer_mode')
-        end
-
-        formatted_attrs = attrs.map { |k, v| ":#{k}: #{v}" }
-        formatted_attrs.join("\n") # NO EXTRA SPACES OR LINES
-      else
-        node.blocks.map { |block| convert block }.join("\n")
-      end
-    end
-
-    # Converts a section node.
-    def convert_section node
-      title = node.title? ? node.title : ''
-      body = node.blocks.map { |block| convert block }.join("\n")
-      [title, body].reject(&:empty?).join("\n")
-    end
-
-    # Converts a paragraph node.
-    def convert_paragraph node
-      node.lines.join("\n")
-    end
-
-    # Converts a listing node.
-    def convert_listing node
-      node.content
-    end
-
-    # Converts a literal node.
-    def convert_literal node
-      node.content
-    end
-  end
-end

data/lib/sourcerer/templating.rb

@@ -1,190 +0,0 @@
-# frozen_string_literal: true
-
-require 'liquid'
-
-module Sourcerer
-  # This module provides the core templating functionality for Sourcerer.
-  # It includes modules for template engines, and classes for representing
-  # templated fields and their context.
-  module Templating
-    # This module handles the compilation and rendering of templates.
-    module Engines
-      module_function
-
-      # A hash of supported template engines.
-      SUPPORTED_ENGINES = {
-        'liquid' => 'liquid',
-        'erb'    => 'erb'
-      }.freeze
-
-      # Compiles a template string using the specified engine.
-      #
-      # @param str [String] The template string to compile.
-      # @param engine [String] The name of the template engine to use.
-      # @return [Object] The compiled template object.
-      # @raise [ArgumentError] if the engine is not supported.
-      def compile str, engine
-        case engine.to_s
-        when 'liquid'
-          Liquid::Template.parse(str)
-        when 'erb'
-          require 'erb'
-          ERB.new(str)
-        else
-          raise ArgumentError, "Unsupported engine: #{engine}"
-        end
-      end
-
-      # Renders a compiled template with the given variables.
-      #
-      # @param compiled [Object] The compiled template object.
-      # @param engine [String] The name of the template engine.
-      # @param vars [Hash] A hash of variables to use for rendering.
-      # @return [String] The rendered output.
-      def render compiled, engine, vars = {}
-        case engine.to_s
-        when 'liquid'
-          compiled.render(vars)
-        when 'erb'
-          compiled.result_with_hash(vars)
-        else
-          compiled.to_s
-        end
-      end
-    end
-
-    # Represents a field that will be rendered by a template engine.
-    class TemplatedField
-      # @return [String] The raw, un-rendered template string.
-      attr_reader :raw
-      # @return [Object] The compiled template object.
-      attr_reader :compiled
-      # @return [String] The name of the template engine.
-      attr_reader :engine
-      # @return [Boolean] Whether the template was explicitly tagged.
-      attr_reader :tagged
-      # @return [Boolean] Whether the template engine was inferred.
-      attr_reader :inferred
-
-      # @param raw [String] The raw template string.
-      # @param compiled [Object] The compiled template object.
-      # @param engine [String] The name of the template engine.
-      # @param tagged [Boolean] Whether the template was explicitly tagged.
-      # @param inferred [Boolean] Whether the template engine was inferred.
-      def initialize raw, compiled, engine, tagged, inferred
-        @raw      = raw
-        @compiled = compiled
-        @engine   = engine
-        @tagged   = tagged
-        @inferred = inferred
-      end
-
-      # @return [true] Always returns true to indicate this is a templated field.
-      def templated?
-        true
-      end
-
-      # @return [Boolean] True if the field is deferred (not yet compiled).
-      def deferred?
-        compiled.nil?
-      end
-
-      # @return [self] Returns self for Liquid compatibility.
-      def to_liquid
-        self
-      end
-
-      # Renders the template with the given context.
-      # @param context [Hash, Liquid::Context] The context for rendering.
-      # @return [String] The rendered output.
-      def render context = {}
-        scope = context.respond_to?(:environments) ? context.environments.first : context
-        Engines.render(compiled, engine, scope)
-      end
-
-      # Renders the template with an empty context.
-      # @return [String] The rendered output.
-      def to_s
-        render({})
-      end
-    end
-
-    # Holds contextual information for templating.
-    class Context
-      # @return [Symbol] The rendering stage (e.g., `:load`).
-      attr_reader :stage
-      # @return [Boolean] Whether to use strict rendering.
-      attr_reader :strict
-      # @return [Hash] A hash of scopes for rendering.
-      attr_reader :scopes
-
-      # @param stage [Symbol] The rendering stage.
-      # @param strict [Boolean] Whether to use strict rendering.
-      # @param scopes [Hash] A hash of scopes.
-      def initialize stage: :load, strict: false, scopes: {}
-        @stage  = stage.to_sym
-        @strict = strict
-        @scopes = scopes.transform_keys(&:to_sym)
-      end
-
-      # Creates a new Context object from a schema fragment.
-      # @param schema_fragment [Hash] The schema fragment containing templating info.
-      # @return [Context] The new Context object.
-      def self.from_schema schema_fragment
-        render_conf = schema_fragment['templating'] || {}
-
-        stage  = (render_conf['stage'] || :load).to_sym
-        strict = render_conf['strict'] == true
-        scopes = (render_conf['scopes'] || {}).transform_keys(&:to_sym)
-
-        new(stage: stage, strict: strict, scopes: scopes)
-      end
-
-      # Merges all scopes into a single hash.
-      # @return [Hash] The merged scope.
-      def merged_scope
-        scopes.values.reduce({}) { |acc, s| acc.merge(s) }
-      end
-    end
-
-    # Compiles templated fields in a data structure.
-    # @param data [Hash] The data to process.
-    # @param schema [Hash] The schema defining the fields.
-    # @param fields [Array<Hash>] The fields to compile.
-    # @param scope [Hash] The scope for rendering.
-    def self.compile_templated_fields! data:, schema:, fields:, scope: {}
-      fields.each do |field_entry|
-        key  = field_entry[:key]
-        path = field_entry[:path]
-        val  = data[key]
-
-        next unless val.is_a?(String) || (val.is_a?(Hash) && val['__tag__'] && val['value'])
-
-        raw     = val.is_a?(Hash) ? val['value'] : val
-        tagged  = val.is_a?(Hash)
-        config  = SchemaGraphy::SchemaUtils.templating_config_for(schema, path)
-        engine  = tagged ? val['__tag__'] : (config['default'] || 'liquid')
-
-        compiled = Engines.compile(raw, engine)
-
-        data[key] = if config['delay']
-                      TemplatedField.new(raw, compiled, engine, tagged, inferred: !tagged)
-                    else
-                      Engines.render(compiled, engine, scope)
-                    end
-      end
-    end
-
-    # Renders a field if it is a template.
-    # @param val [Object] The value to render.
-    # @param context [Hash] The context for rendering.
-    # @return [Object] The rendered value, or the original value if not a template.
-    def self.render_field_if_template val, context = {}
-      if val.respond_to?(:templated?) && val.templated?
-        val.render(context)
-      else
-        val
-      end
-    end
-  end
-end