orb_template 0.1.0

data/lib/orb/patterns.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ORB
+  module Patterns
+    SPACE_CHARS                   = /\s/
+    TAG_NAME                      = %r{[^\s>/=$]+}
+    ATTRIBUTE_NAME                = %r{[^\s>/=]+}
+    UNQUOTED_VALUE_INVALID_CHARS  = /["'=<`]/
+    UNQUOTED_VALUE                = %r{[^\s/>]+}
+    BLOCK_NAME_CHARS              = /[^\s}]+/
+    START_TAG_START               = /</
+    START_TAG_END                 = />/
+    START_TAG_END_SELF_CLOSING    = %r{/>}
+    START_TAG_END_VERBATIM        = /\$>/
+    END_TAG_START                 = %r{</}
+    END_TAG_END                   = />/
+    END_TAG_END_VERBATIM          = /\$>/
+    PUBLIC_COMMENT_START          = /<!--/
+    PUBLIC_COMMENT_END            = /-->/
+    PRIVATE_COMMENT_START         = /{!--/
+    PRIVATE_COMMENT_END           = /--}/
+    PRINTING_EXPRESSION_START     = /{{ */
+    PRINTING_EXPRESSION_END       = / *}}/
+    CONTROL_EXPRESSION_START      = /{% */
+    CONTROL_EXPRESSION_END        = / *%}/
+    BLOCK_OPEN                    = /{#/
+    BLOCK_CLOSE                   = %r[{/]
+    ATTRIBUTE_ASSIGN              = /=/
+    SINGLE_QUOTE                  = /'/
+    DOUBLE_QUOTE                  = /"/
+    SPLAT_START                   = /\*/
+    BRACE_OPEN                    = /\{/
+    BRACE_CLOSE                   = /\}/
+    CR                            = /\r/
+    NEWLINE                       = /\n/
+    CRLF                          = /\r\n/
+    BLANK                         = /[[:blank:]]/
+    OTHER                         = /./
+  end
+end

data/lib/orb/rails_derp.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+# HACK DO NOT USE - THIS IF FOR DEBUGGING ERB ERROR SPOT HIGHLIGHTING ONLY
+module ORB
+  class RailsDerp
+    class << self
+      def call(template, source = nil)
+        new.call(template, source)
+      end
+    end
+
+    # Specify trim mode for the ERB compiler. Defaults to '-'.
+    # See ERB documentation for suitable values.
+    class_attribute :erb_trim_mode, default: "-"
+
+    # Default implementation used.
+    # class_attribute :erb_implementation, default: Erubi
+
+    # Do not escape templates of these mime types.
+    class_attribute :escape_ignore_list, default: ["text/plain"]
+
+    # Strip trailing newlines from rendered output
+    class_attribute :strip_trailing_newlines, default: false
+
+    ENCODING_FLAG = '#.*coding[:=]\s*(\S+)[ \t]*'
+    ENCODING_TAG = Regexp.new("\\A(<%#{ENCODING_FLAG}-?%>)[ \\t]*")
+
+    # Translate an error location returned by ErrorHighlight to the correct
+    # source location inside the template.
+    def translate_location(spot, backtrace_location, source)
+      Rails.logger.debug "in translate_location"
+      Rails.logger.debug ""
+      Rails.logger.debug spot
+      Rails.logger.debug ""
+      Rails.logger.debug backtrace_location
+      Rails.logger.debug ""
+      Rails.logger.debug source
+
+      # Tokenize the source line
+      tokens = ORB::Utils::ERB.tokenize(source.lines[backtrace_location.lineno - 1])
+      new_first_column = find_offset(spot[:snippet], tokens, spot[:first_column])
+      lineno_delta = spot[:first_lineno] - backtrace_location.lineno
+      spot[:first_lineno] -= lineno_delta
+      spot[:last_lineno] -= lineno_delta
+
+      column_delta = spot[:first_column] - new_first_column
+      spot[:first_column] -= column_delta
+      spot[:last_column] -= column_delta
+      spot[:script_lines] = source.lines
+
+      spot
+    end
+
+    def call(template, source)
+      # First, convert to BINARY, so in case the encoding is
+      # wrong, we can still find an encoding tag
+      # (<%# encoding %>) inside the String using a regular
+      # expression
+      template_source = source.b
+
+      erb = template_source.gsub(ENCODING_TAG, "")
+      encoding = ::Regexp.last_match(2)
+
+      erb.force_encoding valid_encoding(source.dup, encoding)
+
+      # Always make sure we return a String in the default_internal
+      erb.encode!
+
+      # Strip trailing newlines from the template if enabled
+      erb.chomp! if strip_trailing_newlines
+
+      options = {
+        escape: (self.class.escape_ignore_list.include? template.type),
+        trim: (self.class.erb_trim_mode == "-")
+      }
+
+      if ActionView::Base.annotate_rendered_view_with_filenames && template.format == :html
+        options[:preamble] = "@output_buffer.safe_append='<!-- BEGIN #{template.short_identifier} -->';"
+        options[:postamble] = "@output_buffer.safe_append='<!-- END #{template.short_identifier} -->';@output_buffer"
+      end
+
+      ActionView::Template::Handlers::ERB::Erubi.new(erb, options).src
+    end
+
+    private
+
+    def valid_encoding(string, encoding)
+      # If a magic encoding comment was found, tag the
+      # String with this encoding. This is for a case
+      # where the original String was assumed to be,
+      # for instance, UTF-8, but a magic comment
+      # proved otherwise
+      string.force_encoding(encoding) if encoding
+
+      # If the String is valid, return the encoding we found
+      return string.encoding if string.valid_encoding?
+
+      # Otherwise, raise an exception
+      raise WrongEncodingError.new(string, string.encoding)
+    end
+
+    def find_offset(compiled, source_tokens, error_column)
+      compiled = StringScanner.new(compiled)
+
+      passed_tokens = []
+
+      while (tok = source_tokens.shift)
+        tok_name, str = *tok
+        case tok_name
+        when :TEXT
+          raise unless compiled.scan(str)
+        when :CODE
+          raise "We went too far" if compiled.pos > error_column
+
+          if compiled.pos + str.bytesize >= error_column
+            offset = error_column - compiled.pos
+            return passed_tokens.map(&:last).join.bytesize + offset
+          else
+            raise unless compiled.scan(str)
+          end
+        when :OPEN, :CLOSE
+          next_tok = source_tokens.first.last
+          loop do
+            break if compiled.match?(next_tok)
+
+            compiled.getch
+          end
+        else
+          raise NotImplemented, tok.first
+        end
+
+        passed_tokens << tok
+      end
+    end
+  end
+
+  ActionView::Template.register_template_handler(:derp, RailsDerp.new)
+end

data/lib/orb/rails_template.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module ORB
+  class RailsTemplate
+    require 'orb/utils/orb'
+    # Compatible with: https://github.com/judofyr/temple/blob/v0.7.7/lib/temple/mixins/options.rb#L15-L24
+    class << self
+      def options
+        @options ||= {
+          generator: ::Temple::Generators::RailsOutputBuffer,
+          use_html_safe: true,
+          streaming: true,
+          buffer_class: 'ActionView::OutputBuffer',
+          disable_capture: true,
+        }
+      end
+
+      def set_options(opts)
+        options.update(opts)
+      end
+    end
+
+    def call(template, source = nil)
+      source ||= template.source
+      options = RailsTemplate.options
+
+      # Make the filename available in parser etc.
+      options = options.merge(file: template.identifier) if template.respond_to?(:identifier)
+
+      # Set type
+      options = options.merge(format: :xhtml) if template.respond_to?(:type) && template.type == 'text/xml'
+
+      # Annotations
+      if ActionView::Base.try(:annotate_rendered_view_with_filenames) && template.format == :html
+        options = options.merge(
+          preamble: "<!-- BEGIN #{template.short_identifier} -->\n",
+          postamble: "<!-- END #{template.short_identifier} -->\n",
+        )
+      end
+
+      # Pipe through the ORB Temple engine
+      ORB::Temple::Engine.new(options).call(source)
+    end
+
+    # See https://github.com/rails/rails/pull/47005
+    def translate_location(spot, backtrace_location, source)
+      offending_line_source = source.lines[backtrace_location.lineno - 1]
+      tokens = ORB::Utils::ORB.tokenize(offending_line_source)
+      new_column = find_offset(spot[:snippet], tokens, spot[:first_column])
+
+      lineno_delta = spot[:first_lineno] - backtrace_location.lineno
+      spot[:first_lineno] -= lineno_delta
+      spot[:last_lineno] -= lineno_delta
+
+      column_delta = spot[:first_column] - new_column
+      spot[:first_column] -= column_delta
+      spot[:last_column] -= column_delta
+      spot[:script_lines] = source.lines
+
+      spot
+    rescue StandardError => _e
+      spot
+    end
+
+    def find_offset(snippet, src_tokens, snippet_error_column)
+      offset = 0
+      passed_tokens = []
+
+      # Pass over tokens until we are just over the snippet error column
+      # then the column of the last token is the offset (without the token static offset for tags {% %})
+      while (tok = src_tokens.shift)
+        offset = snippet.index(tok.value, offset)
+        raise "text not found" unless offset
+        raise "we went too far" if offset > snippet_error_column
+
+        passed_tokens << tok
+      end
+    rescue StandardError
+      offset_token = passed_tokens.last
+      offset_from_token(offset_token)
+    end
+
+    def offset_from_token(token)
+      case token.type
+      when :tag_open, :tag_close
+        token.column + 1
+      when :public_comment, :private_comment
+        token.column + 4
+      when :block_open, :block_close
+        token.column + 2 + token.value.length
+      when :printing_expression, :control_expression
+        token.column + 2
+      end
+    end
+
+    def supports_streaming?
+      RailsTemplate.options[:streaming]
+    end
+  end
+  ActionView::Template.register_template_handler(:orb, RailsTemplate.new)
+end

data/lib/orb/railtie.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ORB
+  class Railtie < ::Rails::Railtie
+    initializer :orb_template, before: :load_config_initializers do
+      require 'orb/rails_template'
+    end
+  end
+end

data/lib/orb/render_context.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ORB
+  class RenderContext
+    def initialize(assigns = {})
+      @assigns = assigns
+      @errors = []
+    end
+
+    def []=(key, value)
+      @assigns[key] = value
+    end
+
+    def [](key)
+      resolve(key)
+    end
+
+    def has_key?(key)
+      resolve(key) != nil
+    end
+
+    attr_reader :errors
+
+    def binding
+      # rubocop:disable Style/OpenStructUse
+      OpenStruct.new(@assigns).instance_eval { binding }
+      # rubocop:enable Style/OpenStructUse
+    end
+
+    private
+
+    def resolve(key)
+      @assigns[key]
+    end
+  end
+end

data/lib/orb/template.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module ORB
+  class Template
+    attr_reader :doc
+
+    class << self
+      # create a new `Template` instance and parse the given source
+      def parse(source, opts = {})
+        template = Template.new(**opts)
+        template.parse(source)
+        template
+      end
+    end
+
+    # Create a new `Template` instance. Use `Template.parse` instead.
+    def initialize(**opts)
+      @options = opts
+    end
+
+    # Parses the given `source` and returns `self` for chaining.
+    def parse(source)
+      @doc = Document.new(tokenize(source))
+      self
+    end
+
+    # Local assigns
+    def assigns
+      @assigns ||= {}
+    end
+
+    # Parsing and rendering errors
+    def errors
+      @errors ||= []
+    end
+
+    # Render the template with the given `assigns`, which is a hash of local variables.
+    def render(*args)
+      # if we don't have a Document node, render to an empty string
+      retun "" unless @doc
+
+      # Determine the rendering context, which can either be a hash of local variables
+      # or an instance of `ORB::RenderContext`.
+      render_context = case args.first
+                       when ORB::RenderContext
+                         args.shift
+                       when Hash
+                         assigns.merge!(args.shift)
+                         ORB::RenderContext.new(assigns)
+                       when nil
+                         ORB::RenderContext.new(assigns)
+                       else
+                         raise ArgumentError, "Expected a hash of local assigns or a ORB::RenderContext."
+                       end
+
+      # Render loop
+      begin
+        @doc.render(render_context)
+      ensure
+        @errors = render_context.errors
+      end
+    end
+
+    private
+
+    def tokenize(source)
+      return [] if source.nil? || source.empty?
+
+      ORB::Tokenizer2.new(source, **@options).tokenize!
+    end
+  end
+end

data/lib/orb/temple/attributes_compiler.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module ORB
+  module Temple
+    class AttributesCompiler
+      def initialize(options = {})
+        @options = options
+      end
+
+      # Compile the given array of AST::Attribute objects into Temple capture expressions
+      # using the given prefix in variable names
+      def compile_captures(attributes, prefix)
+        result = []
+
+        attributes.each do |attribute|
+          # TODO: handle splat attributes
+          next if attribute.splat?
+
+          # generate a unique variable name for the attribute
+          var_name = prefixed_variable_name(attribute.name, prefix)
+
+          # inject a code expression for the attribute value and assign to the variable
+          if attribute.string?
+            result << [:code, "#{var_name} = \"#{attribute.value}\""]
+          elsif attribute.bool?
+            result << [:code, "#{var_name} = true"]
+          elsif attribute.expression?
+            result << [:code, "#{var_name} = #{attribute.value}"]
+          end
+        end
+
+        result
+      end
+
+      # Compile the given array of AST::Attribute objects into a string of arguments
+      # the can be used in a ViewComponent constructor call, as long as the
+      # compiled captures are available in the same scope.
+      def compile_komponent_args(attributes, prefix)
+        args = {}
+        attributes.each do |attribute|
+          # TODO: handle splat attributes
+          next if attribute.splat?
+
+          var_name = prefixed_variable_name(attribute.name, prefix)
+          args = args.deep_merge(dash_to_hash(attribute.name, var_name))
+        end
+
+        hash_to_args_list(args)
+      end
+
+      # Compile the attributes of a node into a Temple core abstraction
+      def compile_attributes(attributes)
+        temple = [:html, :attrs]
+
+        attributes.each do |attribute|
+          # Ignore splat attributes
+          next if attribute.splat?
+
+          temple << compile_attribute(attribute)
+        end
+
+        temple
+      end
+
+      ##
+      # Compile splat attributes to a code string
+      def compile_splat_attributes(attributes)
+        attributes.map(&:value).join(',')
+      end
+
+      # Compile a single attribute into Temple core abstraction
+      # an attribute can be a static string, a dynamic expression,
+      # or a boolean attribute (an attribute without a value, e.g. disabled, checked, etc.)
+      #
+      # For boolean attributes, we return a [:dynamic, "nil"] expression, so that the
+      # final render for the attribute will be `attribute` instead of `attribute="true"`
+      def compile_attribute(attribute)
+        if attribute.string?
+          [:html, :attr, attribute.name, [:static, attribute.value]]
+        elsif attribute.bool?
+          [:html, :attr, attribute.name, [:dynamic, "nil"]]
+        elsif attribute.expression?
+          [:html, :attr, attribute.name, [:dynamic, attribute.value]]
+        end
+      end
+
+      def dash_to_hash(name, value)
+        parts = name.split('-')
+        parts.reverse.inject(value) { |a, n| { n => a } }
+      end
+
+      def hash_to_args_list(obj, level = -1)
+        case obj
+        when String
+          obj
+        when Array
+          obj.map { |v| hash_to_args_list(v, level + 1) }.join(", ")
+        when Hash
+          down_the_rabbit_hole = obj.map { |k, v| "#{k}: #{hash_to_args_list(v, level + 1)}" }.join(", ")
+          return down_the_rabbit_hole if level.negative?
+
+          "{#{down_the_rabbit_hole}}"
+
+        else
+          raise "Invalid argument passed to hash_to_args_list: #{obj.inspect}"
+        end
+      end
+
+      def prefixed_variable_name(name, prefix)
+        "#{prefix}_arg_#{name.underscore}"
+      end
+    end
+  end
+end