RubyGems - rbxrb - Versions diffs - 0.1.0 - Mend

rbxrb 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

checksums.yaml +7 -0
data/CHANGELOG.md +11 -0
data/Gemfile +10 -0
data/README.md +31 -0
data/Rakefile +12 -0
data/lib/rbx/compiler.rb +164 -0
data/lib/rbx/component.rb +59 -0
data/lib/rbx/option_marshaller.rb +81 -0
data/lib/rbx/parser.rb +204 -0
data/lib/rbx/syntax_error.rb +45 -0
data/lib/rbx/version.rb +6 -0
data/lib/rbx.rb +169 -0
data/rbxrb.gemspec +37 -0
metadata +81 -0

checksums.yaml ADDED Viewed

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1ff8db77bcb7cdfbc84cd2f4ec4812c16c27eb8f59d096b32232ddbea098d66c
+  data.tar.gz: 5e6ccc51a4502d3eaa09c00a56c59381ca38d91d2baf66ab123a1f75fa626362
+SHA512:
+  metadata.gz: 2ecd471a44e30f275b49f708c4a64904441463316f42476a758bee91b97c102f569628ad706a7d5392e22139245c65a96f272c2ec87b9511fde388c01bb22398
+  data.tar.gz: ae80fbb76b174081610fa71d582e9cbffe794ab395d001a1272313c7a99eaa61733dd794d30425b4e01d202164ef5b7542ce0bd7c332e657f612f99adce87a33

data/CHANGELOG.md ADDED Viewed

@@ -0,0 +1,11 @@
+## [Unreleased]
+## [0.1.0] - 2026-09-06
+Initial release with support for
+- Parsing templates
+- Resolving tagnames to RBX::Component classes
+- Compiling to HTML
+- Auto-defining `render` on RBX::Components that will find the template, compile it
+  and define a ruby method on the component of the resulting ruby.

data/Gemfile ADDED Viewed

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+source "https://rubygems.org"
+gemspec
+gem "irb"
+gem "rake", "~> 13.0"
+gem "rspec", "~> 3.0"
+gem "rubocop", "~> 1.21"

data/README.md ADDED Viewed

@@ -0,0 +1,31 @@
+# RBX
+A ruby templating language similar to JSX
+```ruby
+class Layout
+  include RBX::Component
+end
+class Home
+  include RBX::Component
+  attr_reader :name
+  def initializer(name:)
+    @name = name
+  end
+end
+puts Home.new(name: "Bobby").render()
+__END__
+@@Layout
+<html>
+  <body>{ yield }</body>
+</html>
+@@Home
+<Layout>
+  <h1>Hello { name }</h1>
+</Layout>
+```

data/Rakefile ADDED Viewed

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec)
+require "rubocop/rake_task"
+RuboCop::RakeTask.new
+task default: %i[spec rubocop]

data/lib/rbx/compiler.rb ADDED Viewed

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+module RBX
+  # Compiler takes in the parsed AST and outputs generated code.
+  class Compiler
+    # Compile parsed nodes into ruby source code that will output html
+    def self.compile(nodes)
+      new.compile(nodes)
+    end
+    def compile(nodes) # :nodoc:
+      <<~RBX
+        buffer = String.new
+        #{nodes.map { |n| buf_out(compile_node(n)) }.join.rstrip}
+        buffer
+      RBX
+    end
+    private
+    def compile_node(node)
+      case node.kind
+      when :raw then node.content.strip.empty? ? "" : "'#{escape(node.content)}'"
+      when :html then compile_html(node).join("+")
+      when :component then compile_component(node)
+      when :expr_group then compile_text_expr_group(node)
+      else raise "unexpected node kind #{node.kind}"
+      end
+    end
+    def compile_text_expr_group(node)
+      return "(#{compile_expr_group(node)}).to_s" if contains_markup?(node)
+      "::RBX.escape((#{compile_expr_group(node)}))"
+    end
+    def contains_markup?(node)
+      node.content&.any? { |n| %i[html component].include?(n.kind) }
+    end
+    def compile_html(node)
+      parts = tag_open(node)
+      parts.concat(node.content.map(&method(:compile_node))) unless node.void || node.content.nil?
+      parts << "'</#{node.name}>'" unless node.void
+      compact(parts)
+    end
+    def tag_open(node)
+      buffer = "<#{node.name}"
+      parts = []
+      node.attributes&.each { |attr| tag_attribute(buffer, parts, attr) }
+      buffer << (node.void ? "/>" : ">")
+      parts << "'#{escape(buffer)}'"
+      parts
+    end
+    def tag_attribute(buffer, parts, attr)
+      return kwarg_attribute(buffer, parts, attr) if attr.kind == :expr_group
+      buffer << " #{attr.name}"
+      return if attr.content.nil?
+      buffer << "="
+      case attr.content.kind
+      when :raw then buffer << attr.content.content
+      when :expr_group then tag_attribute_expression(buffer, parts, attr.content)
+      else raise "unexpected attribute value kind #{attr.content.kind}"
+      end
+    end
+    def tag_attribute_expression(buffer, parts, expr_group)
+      buffer << '"'
+      flush_buffer(buffer, parts)
+      parts << "::RBX.escape((#{compile_attr_expr_group(expr_group)}))"
+      buffer << '"'
+    end
+    def kwarg_attribute(buffer, parts, expr_group)
+      flush_buffer(buffer, parts)
+      parts << "(::RBX.tag_kwargs(#{compile_attr_expr_group(expr_group)})).to_s"
+    end
+    def flush_buffer(buffer, parts)
+      parts << "'#{escape(buffer)}'" unless buffer.empty?
+      buffer.replace("")
+    end
+    def compile_component(node)
+      "::#{node.name.split(".").join("::")}.new(#{component_props(node)})#{component_block(node)}.render"
+    end
+    def component_props(node)
+      node.attributes&.map { |attr| component_prop(attr) }&.join(", ")
+    end
+    def component_prop(attr)
+      return "#{attr.name}: true" if attr.content.nil?
+      "#{attr.name}: #{component_prop_value(attr.content)}"
+    end
+    def component_prop_value(expr)
+      case expr.kind
+      when :raw then expr.content
+      when :expr_group then "(#{compile_attr_expr_group(expr)})"
+      else raise "unexpected component prop kind #{expr.kind}"
+      end
+    end
+    def compile_attr_expr_group(node)
+      node.content&.map do |n|
+        case n.kind
+        when :raw, :expression then n.content
+        else raise "unexpected component prop kind #{n.kind}"
+        end
+      end&.join
+    end
+    def compile_expr_group(node)
+      node.content&.map do |n|
+        case n.kind
+        when :raw, :expression then n.content
+        when :html then "(#{compile_html(n).join("+")})"
+        when :component then "(#{compile_component(n)})"
+        else raise "unexpected component prop kind #{n.kind}"
+        end
+      end&.join
+    end
+    def component_block(node)
+      return "" if node.content.nil? || node.content.empty?
+      <<~RBX.strip
+        .capture do |buffer|
+          #{node.content.map { |n| buf_out(compile_node(n)) }.join.rstrip}
+        end
+      RBX
+    end
+    def buf_out(content)
+      content.strip.empty? ? "" : %(buffer << #{content}\n)
+    end
+    def escape(str)
+      str.gsub("\\") { "\\\\" }.gsub("'") { "\\'" }
+    end
+    def compact(parts)
+      parts&.each_with_object([]) do |item, compacted|
+        next if item.empty?
+        if quoted_string?(item) && quoted_string?(compacted.last)
+          compacted[-1] = compacted.last.delete_suffix("'") + item.delete_prefix("'")
+        else
+          compacted.push(item)
+        end
+      end
+    end
+    def quoted_string?(item)
+      item =~ /^'.*'$/
+    end
+  end
+end

data/lib/rbx/component.rb ADDED Viewed

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+module RBX
+  # Component is a mixin that lazily resolves and compiles a template into a
+  # `_render_template` instance method on the first render, then calls that
+  # compiled method directly on every render after that. It also provides
+  # the supporting capture/option marshalling behavior compiled templates
+  # rely on.
+  module Component
+    def self.included(base) # :nodoc:
+      base.extend(ClassMethods)
+    end
+    # ClassMethods is extended onto any class that includes Component. It
+    # handles template resolution and compilation.
+    module ClassMethods
+      # Set the template for this class as a provided string. This method uses
+      # caller location to be able to provide better error messages.
+      def template_source(tmpl)
+        compile!(caller_locations(1, 1).first.absolute_path, tmpl)
+      end
+      # Set the template for this class as the contents of a separate file
+      def template_file(filepath)
+        loc, tmpl = RBX.extract_template(filepath, self, inline: false)
+        compile!(loc, tmpl)
+      end
+      protected
+      def compile!(loc, tmpl) # :nodoc:
+        return if loc.nil? || tmpl.empty?
+        class_eval(<<~RENDER, __FILE__, __LINE__ + 1)
+          def _render_template
+            #{RBX.compile(loc, tmpl)} # compiled template body
+          end
+        RENDER
+      end
+    end
+    # render will lazily compile the template for this class and then render it using
+    # the class as context as the compilation will define a _render_template method
+    # on the instance.
+    def render
+      klass = self.class
+      klass.send(:compile!, *RBX.resolve_template(klass)) unless klass.respond_to?(:_render_template)
+      _render_template { RBX.safe(@child_buffer.nil? ? "" : @child_buffer) }
+    end
+    # public method to capture child content but should not be considered public interface.
+    def capture(&) # :nodoc:
+      @child_buffer = String.new
+      yield(@child_buffer)
+      self
+    end
+  end
+end

data/lib/rbx/option_marshaller.rb ADDED Viewed

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+require "json"
+require "rack"
+module RBX
+  # OptionMarshaller is a class that is used for serializing a hash into
+  # html tag attributes.
+  class OptionMarshaller
+    BOOLEAN_ATTRIBUTES = %w[allowfullscreen allowpaymentrequest async autofocus
+                            autoplay checked compact controls declare default
+                            defaultchecked defaultmuted defaultselected defer
+                            disabled enabled formnovalidate hidden indeterminate
+                            inert ismap itemscope loop multiple muted nohref
+                            nomodule noresize noshade novalidate nowrap open
+                            pauseonexit playsinline readonly required reversed
+                            scoped seamless selected sortable truespeed
+                            typemustmatch visible].to_set
+    BOOLEAN_ATTRIBUTES.merge(BOOLEAN_ATTRIBUTES.map(&:to_sym))
+    BOOLEAN_ATTRIBUTES.freeze
+    private_constant :BOOLEAN_ATTRIBUTES
+    class << self
+      ##
+      # Marshal a hash into html tag attributes. If the key is aria, data, or class
+      # it will also spread that data creatively like `data-key="true"` from `{data: {key: true}}`
+      # and for class it will only include the class name if the value is truthy.
+      def tag_kwargs(options)
+        options.reject { |k, _v| k.empty? }.map do |key, value|
+          case key.to_s
+          when "aria" then aria_attribute(value)
+          when "data" then data_attribute(value)
+          when "class" then class_attribute(value)
+          when "hx" then hx_attribute(value)
+          else boolean_or_option(key, value)
+          end
+        end.flatten.compact.join(" ")
+      end
+      private
+      def boolean_or_option(key, value)
+        BOOLEAN_ATTRIBUTES.include?(key) ? (key if value) : tag_option(key, value)
+      end
+      def aria_attribute(value)
+        value.map { |k, v| %(aria-#{k}="#{Rack::Utils.escape_html(v.to_s)}") }
+      end
+      def data_attribute(value)
+        value.map do |k, v|
+          tag_option("data-#{k}", v.is_a?(String) || v.is_a?(Symbol) ? v : JSON.dump(v))
+        end
+      end
+      def hx_attribute(value)
+        value.map { |k, v| tag_option("hx-#{k}", v.to_s) }
+      end
+      def class_attribute(value)
+        classes = if value.is_a?(Hash)
+                    value.each_with_object([]) { |(key, value), final| final << key if value }.join(" ")
+                  else
+                    value.is_a?(Array) ? value.join(" ") : value.to_s
+                  end
+        %(class="#{Rack::Utils.escape_html(classes)}")
+      end
+      def tag_option(key, value)
+        value = case value
+                when Array then value.join(" ")
+                when Hash then value.map { |k, v| "#{k}=#{v}" }.join(" ")
+                else value.to_s
+                end
+        %(#{key.to_s.tr("_", "-")}="#{Rack::Utils.escape_html(value)}")
+      end
+    end
+  end
+end

data/lib/rbx/parser.rb ADDED Viewed

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+module RBX
+  # Parser breaks down templates into a tree like data structure
+  class Parser
+    KNOWN_HTML_ELEMENTS = %w[
+      a abbr acronym address animate animateMotion animateTransform applet area article aside audio b base basefont
+      bdi bdo bgsound big blink blockquote body br button canvas caption center circle cite clipPath code col colgroup
+      color-profile command content data datalist dd defs del desc details dfn dialog dir discard div dl dt element
+      ellipse em embed feBlend feColorMatrix feComponentTransfer feComposite feConvolveMatrix feDiffuseLighting
+      feDisplacementMap feDistantLight feDropShadow feFlood feFuncA feFuncB feFuncG feFuncR feGaussianBlur feImage
+      feMerge feMergeNode feMorphology feOffset fePointLight feSpecularLighting feSpotLight feTile feTurbulence
+      fieldset figcaption figure filter font footer foreignObject form frame frameset g h1 h2 h3 h4 h5 h6 hatch
+      hatchpath head header hgroup hr html i iframe image img input ins isindex kbd keygen label legend li line
+      linearGradient link listing main map mark marker marquee mask menu menuitem mesh meshgradient meshpatch meshrow
+      meta metadata meter mpath multicol nav nextid nobr noembed noframes noscript object ol optgroup option output p
+      param path pattern picture plaintext polygon polyline pre progress q radialGradient rb rect rp rt rtc ruby s
+      samp script section select set shadow slot small solidcolor source spacer span stop strike strong style sub
+      summary sup svg switch symbol table tbody td template text textarea textPath tfoot th thead time title tr track
+      tspan tt u ul unknown use var video view wbr xmp
+    ].to_set
+    HTML_VOID_ELEMENTS = %w[area base br col embed hr img input link meta source track wbr].freeze
+    DECLR_OR_COMMENT = /\s*<![^>]*>/
+    TAG_START = %r{\s*<(?!/)}
+    TAG_END = %r{\s*/?>}
+    EXPR_START = /\s*{/
+    QUOTED_STRING = /["'](?<str>(?:[^"'\\]|\\.)*)["']/
+    QUOTES = /["']/
+    QUOTED_EXPRESSION_STRING = /(?<q>["'])(?:\\.|(?!\k<q>).)*\k<q>/m
+    PLAIN_TEXT = /(?<text>(?:[^<{\\]|\\.)*)/
+    TAGNAME = /[A-Za-z0-9\-_.]+/
+    DO_BLOCK_PREFIX = /do\s+(\|[^|]+\|)?/
+    BLOCK_PREFIX = /{\s*(\|[^|]+\|)?/
+    AND = /&&/
+    OR = /\|\|/
+    TERNARY = /[?:]/
+    TAG_PREFIX = Regexp.union(DO_BLOCK_PREFIX, BLOCK_PREFIX, AND, OR, TERNARY)
+    NESTED_TAG_PREFIX = /(\s+#{TAG_PREFIX.source}\s*\z|\A\s*\z)/
+    WORD = /\w+/
+    private_constant :KNOWN_HTML_ELEMENTS, :HTML_VOID_ELEMENTS, :DECLR_OR_COMMENT,
+                     :TAG_START, :TAG_END, :EXPR_START, :QUOTED_STRING, :QUOTES,
+                     :QUOTED_EXPRESSION_STRING, :PLAIN_TEXT, :TAGNAME, :DO_BLOCK_PREFIX,
+                     :BLOCK_PREFIX, :AND, :OR, :TERNARY, :TAG_PREFIX, :NESTED_TAG_PREFIX, :WORD
+    attr_reader :filename, :template, :scanner # :nodoc:
+    # Is a struct for a single node in an AST type structure returned from the parser.
+    # This struct consists of:
+    #
+    # - `kind`: raw, attribute, expression, expr_group, html, component
+    # - `name`: If it is a component or html element this will be the tag name and
+    #   the name of an element attribute if the node is an attribute.
+    # - `attributes`: For tag, or components these are the attributes and their values.
+    # - `content`: For tag, or components this will be any nested child nodes, for
+    #   raw or expressions, this will be a string of raw output.
+    # - `void`: marks if an element has nested content or expects nested content.
+    Node = Struct.new(:kind, :name, :attributes, :content, :void)
+    # Reads a template, lexes tokens, and builds an AST from the tokens.
+    def self.parse(filename, template)
+      new(filename, template).parse
+    end
+    def initialize(filename, template) # :nodoc:
+      @filename = filename
+      @template = template
+      @scanner = StringScanner.new(template)
+    end
+    def parse # :nodoc:
+      parse_children
+    end
+    private
+    def parse_children
+      children = []
+      children << parse_child until scanner.eos? || scanner.check(%r{</})
+      children.empty? ? nil : children
+    end
+    def parse_child
+      if scanner.scan(DECLR_OR_COMMENT) then Node.new(kind: :raw, content: scanner.matched.gsub("'", "\\\\'"))
+      elsif scanner.scan(TAG_START) then parse_tag
+      elsif scanner.scan(EXPR_START) then parse_expression
+      elsif scanner.scan(PLAIN_TEXT) then Node.new(kind: :raw, content: scanner[:text])
+      else raise SyntaxError.new(self, "unexpected element")
+      end
+    end
+    def parse_tag
+      tagname = scanner.scan(TAGNAME) # tagname
+      attributes = parse_tag_attributes
+      raise SyntaxError.new(self, "unclosed tag <#{tagname} found") unless scanner.scan(TAG_END)
+      is_void = scanner.matched.strip == "/>" || HTML_VOID_ELEMENTS.include?(tagname)
+      children = is_void ? nil : parse_tag_contents(tagname, is_void)
+      Node.new(kind: resolve_kind(tagname), name: tagname, void: is_void, attributes: attributes, content: children)
+    end
+    def parse_tag_contents(tagname, is_void)
+      return consume_script_tag_raw(tagname) if tagname == "script" && !is_void
+      children = parse_children
+      if !is_void && !scanner.scan(%r{\s*</#{tagname}>})
+        raise SyntaxError.new(self, "Closing tag for non-void <#{tagname}> not found")
+      end
+      children
+    end
+    # We consume script tag contents simply as a raw node because we cannot interpolate
+    # anything in javascript. We cannot tell what {} are javascript and which are
+    # interpolation so it is safer to just leave script contents alone.
+    def consume_script_tag_raw(tagname)
+      warn "WARN found a <script> tag in #{filename}, be aware contents are consumed raw and will not be interpolated."
+      scanner.scan(%r{(?<str>.*)</#{tagname}>})
+      val = scanner[:str]
+      raise SyntaxError.new(self, "unterminated tag #{tagname}") if val.nil?
+      [Node.new(kind: :raw, content: val)]
+    end
+    def resolve_kind(tagname)
+      return :html if KNOWN_HTML_ELEMENTS.include?(tagname)
+      klass_name = "::#{tagname.split(".").join("::")}"
+      klass = Object.const_get(klass_name)
+      # TODO: allow duck typing, i.e responds_to
+      !klass.nil? && klass.include?(RBX::Component) ? :component : :html
+    end
+    def parse_tag_attributes
+      attrs = []
+      while scanner.check(/\s+[A-Za-z0-9\-_.:]+/) || scanner.check(EXPR_START)
+        attrs << (scanner.scan(EXPR_START) ? parse_expression : parse_tag_attribute)
+      end
+      attrs.empty? ? nil : attrs
+    end
+    def parse_tag_attribute
+      name = scanner.scan(/\s+[A-Za-z0-9\-_.:]+/).strip
+      value = parse_tag_attribute_value if scanner.scan(/\s*=\s*/)
+      Node.new(kind: :attribute, name: name, content: value)
+    end
+    def parse_tag_attribute_value
+      if scanner.check(QUOTES) then Node.new(kind: :raw, content: chomp_quoted)
+      elsif scanner.scan(WORD) then Node.new(kind: :raw, content: scanner.matched)
+      elsif scanner.scan(EXPR_START) then parse_expression
+      else raise SyntaxError.new(self, "unexpected tag attribute formatting.")
+      end
+    end
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def parse_expression
+      exprs = []
+      depth = 0
+      curr_expr = String.new
+      until scanner.eos?
+        if scanner.scan(/}/)
+          break if depth.zero?
+          depth -= 1
+          curr_expr << "}"
+        elsif scanner.scan(QUOTED_EXPRESSION_STRING)
+          curr_expr << scanner.matched
+        elsif scanner.scan(TAG_START)
+          # try to work out if we found a tag or a lessthan
+          if curr_expr =~ NESTED_TAG_PREFIX
+            exprs << Node.new(kind: :expression, content: curr_expr) unless curr_expr.empty?
+            curr_expr = String.new
+            exprs << parse_tag
+          else
+            curr_expr << scanner.matched
+          end
+        else
+          text = scanner.scan(/([^<}'"]|<\/)+/) || scanner.getch
+          depth += text.count("{")
+          curr_expr << text
+        end
+      end
+      exprs << Node.new(kind: :expression, content: curr_expr) unless curr_expr.empty?
+      Node.new(kind: :expr_group, content: exprs)
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def chomp_quoted
+      scanner.scan(QUOTED_STRING)
+      val = scanner[:str]
+      raise SyntaxError.new(self, "unterminated string") if val.nil?
+      %("#{val}")
+    end
+  end
+end

data/lib/rbx/syntax_error.rb ADDED Viewed

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+module RBX
+  # SyntaxError is a error with a pinpoint of where in the template the issue lies.
+  class SyntaxError < StandardError
+    # Create a new syntax error with the parser, to locate where the syntax error
+    # is located.
+    def initialize(parser, message)
+      @parser = parser
+      super("#{@parser.filename}:#{line}:#{col} #{message}\n#{excerpt}")
+    end
+    private
+    def excerpt
+      (excerpt_start..excerpt_end).map do |i|
+        "#{i + 1 == line ? "->" : "  "} #{i + 1}: #{lines[i]}"
+      end.join("\n")
+    end
+    def lines
+      @lines ||= @parser.template.split(/\R/, -1)
+    end
+    def excerpt_start
+      [line - 4, 0].max
+    end
+    def excerpt_end
+      [line - 5, lines.length - 1].min
+    end
+    def line
+      @line ||= line_info.size
+    end
+    def col
+      @col ||= line_info.last.length + 1
+    end
+    def line_info
+      @line_info ||= @parser.template[0..@parser.scanner.pos].split(/\R/, -1)
+    end
+  end
+end

data/lib/rbx/version.rb ADDED Viewed

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module RBX
+  # Version number for RBX
+  VERSION = "0.1.0"
+end

data/lib/rbx.rb ADDED Viewed

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+require "rack"
+# RBX is a module for handling enriched html parsing in a same manner that jsx does
+# allowing for class resolution for tag names and dynamic content taken from those
+# ruby classes.
+#
+# Example:
+#
+# ```ruby
+# module Todos
+#   class List
+#     include RBX::Component
+#
+#     attr_reader :todos
+#
+#     def initialize(todos:)
+#       super()
+#       @todos = todos
+#     end
+#   end
+#
+#   class Todo
+#     include RBX::Component
+#     attr_reader :todo
+#
+#     def initialize(todo:)
+#       super()
+#       @todo = todo
+#     end
+#   end
+# end
+#
+# view = Todos::List.new(todos: [{"text" => "work"}])
+# puts view.render # => <ul><li>work</li> </ul>
+#
+# __END__
+# @@Todos.List
+# <ul>{todos.map { |todo| <Todos.Todo todo={todo} /> }.join}</ul>
+#
+# @@Todos.Todo
+# <li>{ todo["text"] }</li>
+# ```
+#
+# Component templates can be defined in several ways.
+#
+# - With the entirety of the `__END__` section if it does not contain any labels.
+# - Several templates defined for several classes in the same file (like the example above).
+#   To do this the templates need a `@@<klass-name>` label to identify them.
+# - Use the component class method `template_file` to define where to look for the
+#   template file.
+# - Use the component class method `template_source` to provide a raw string as a
+#   template for the component.
+#
+module RBX
+  autoload :Compiler, "rbx/compiler"
+  autoload :Parser, "rbx/parser"
+  autoload :SyntaxError, "rbx/syntax_error"
+  autoload :Component, "rbx/component"
+  autoload :OptionMarshaller, "rbx/option_marshaller"
+  autoload :Version, "rbx/version"
+  # SafeString is a string wrapper that marks a string as having been escaped and
+  # is safe for putting on a webpage.
+  class SafeString < String; end
+  @template_cache = {}
+  class << self
+    # parse and then compile the template which will return a string of ruby to
+    # be evaluated. This can then be passed to `instance_eval` to make it execute
+    # in context of your class. Include `RBX::Component` in your class to do this
+    # for you. It will lazily compile the template and cache it afterwards.
+    def compile(template_name, template)
+      Compiler.compile(Parser.parse(template_name, template))
+    end
+    # escape any non-safe text for html. This is used to ensure that text that
+    # you are using in your templates will not cause security issues. This will
+    # be outputted by the compiler so it is here also for easy access by the compiled
+    # ruby.
+    def escape(value)
+      value.is_a?(SafeString) ? value.to_s : ::Rack::Utils.escape_html(value.to_s)
+    end
+    # mark a string as safe, not needing any further escaping. This can be done to
+    # skip escaping if you're sure it needs to be raw.
+    def safe(value)
+      SafeString.new(value.to_s)
+    end
+    # marshal a hash into html tag attributes. See OptionMarshaller.
+    def tag_kwargs(options)
+      " #{OptionMarshaller.tag_kwargs(options)}"
+    end
+    # resolve an inline template for a klass. It will look at the klass's source
+    # location, and check if there is an `__END__` section on the file. If there
+    # is, it will extract that template data.
+    #
+    # A template can be the whole `__END__` section if there are no labels found
+    # or several templates can be defined in the `__END__` section by labeling them
+    # with an `@@<name>` label on the line before the template. See the example above.
+    def resolve_template(klass)
+      location = Object.const_source_location(klass.name).first
+      extract_template(location, klass, inline: true)
+    end
+    # depending on how the template is defined, extract_template will look in the
+    # `__END__` section, determine if there are several templates, and pick out
+    # the template for the specific class passed as a parameter. It will return
+    # an empty string if no content was found.
+    #
+    # This will also ensure that templates were not reused just incase labels were
+    # not added.
+    def extract_template(filepath, klass, inline: true)
+      name = klass.name.split("::").last
+      fullname = template_name(filepath, name)
+      parse_templates(filepath, name, inline) unless @template_cache[fullname]
+      tmpl = @template_cache.fetch(fullname, nil)
+      validate_uniq_templates(filepath, tmpl[:content]) if tmpl
+      [fullname, tmpl&.dig(:content) || ""]
+    end
+    private
+    def validate_uniq_templates(filepath, content)
+      found = @template_cache.values.select { |tmpl| tmpl[:filepath] == filepath && tmpl[:content] == content }
+      return unless found.count > 1
+      warn "[RBX WARNING] Possible reuse of template #{template_name(found[:filepath], found[:name])}"
+    end
+    def template_name(filepath, name)
+      "#{filepath}@@#{name}"
+    end
+    def parse_templates(filepath, name, inline)
+      data = read_file(filepath, inline)
+      return if data.nil?
+      cache_template(filepath, name, data)
+      return unless data.include?("@@")
+      data.strip.split(/^(@@\s*.*\S)\s*$/)[1..].each_slice(2) do |(section_name, tmpl)|
+        section_name = section_name.delete_prefix("@@").strip
+        cache_template(filepath, section_name, tmpl)
+      end
+    end
+    def cache_template(filepath, name, content)
+      @template_cache[template_name(filepath, name)] = {
+        filepath: filepath,
+        name: name,
+        content: content
+      }
+    end
+    def read_file(filepath, inline)
+      data = File.read(filepath)
+      return if inline && !data.include?("__END__")
+      data = data.split(/^__END__$/, 2)[1] if data.include?("__END__")
+      data
+    end
+  end
+end

data/rbxrb.gemspec ADDED Viewed

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+require_relative "lib/rbx/version"
+Gem::Specification.new do |spec|
+  spec.name = "rbxrb"
+  spec.version = RBX::VERSION
+  spec.authors = ["Tim Anema"]
+  spec.email = ["timanema@gmail.com"]
+  spec.summary = "A ruby templating language similar to JSX."
+  spec.description = <<~DOC
+    A ruby templating language similar to JSX that compiles to a ruby function.
+    It allows for defining that function on a class that can then define variables
+    and methods that can be used in the template.
+  DOC
+  spec.homepage = "https://github.com/tanema/nextrb"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.1"
+  spec.require_paths = ["lib"]
+  spec.metadata = {
+    "source_code_uri" => "https://github.com/tanema/nextrb",
+    "changelog_uri" => "https://github.com/tanema/nextrb/blob/main/rbx/CHANGELOG.md",
+    "homepage_uri" => spec.homepage,
+    "bug_tracker_uri" => "https://github.com/tanema/nextrb/issues",
+    "documentation_uri" => "https://github.com/tanema/nextrb",
+    "rubygems_mfa_required" => "true"
+  }
+  spec.files = Dir["lib/**/*"] + [
+    "README.md",
+    "CHANGELOG.md",
+    "Gemfile",
+    "Rakefile",
+    "rbxrb.gemspec"
+  ]
+  spec.add_dependency "rack", ">= 3.0.0", "< 4"
+end

metadata ADDED Viewed

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: rbxrb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tim Anema
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+description: |
+  A ruby templating language similar to JSX that compiles to a ruby function.
+  It allows for defining that function on a class that can then define variables
+  and methods that can be used in the template.
+email:
+- timanema@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Gemfile
+- README.md
+- Rakefile
+- lib/rbx.rb
+- lib/rbx/compiler.rb
+- lib/rbx/component.rb
+- lib/rbx/option_marshaller.rb
+- lib/rbx/parser.rb
+- lib/rbx/syntax_error.rb
+- lib/rbx/version.rb
+- rbxrb.gemspec
+homepage: https://github.com/tanema/nextrb
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/tanema/nextrb
+  changelog_uri: https://github.com/tanema/nextrb/blob/main/rbx/CHANGELOG.md
+  homepage_uri: https://github.com/tanema/nextrb
+  bug_tracker_uri: https://github.com/tanema/nextrb/issues
+  documentation_uri: https://github.com/tanema/nextrb
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: A ruby templating language similar to JSX.
+test_files: []