orb_template 0.2.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cce449d0ac0ab86e9a8bec2e22d3016cbd165bec8dc45f13208609acbc621639
-  data.tar.gz: cf2eba65f10e960d939f7cc0f32a405a1c5faa29aec05eb73777b4c02f5ba81a
+  metadata.gz: 0231005def8767c0efd2cb24b0efcb03b83b469f4760c5e3fcbaf262344c296e
+  data.tar.gz: c086ac14ba16300c36f7f0d39f02c426ca4ff568ef61cde48dfa91df3b433391
 SHA512:
-  metadata.gz: f2874e3e0763b2f00fef23dcc43e01b5b4013429cdf61fba6d82db80127cfce92bf9a755a64d56f4f6b355fa38890da58d5dc82ba54fd40d6b7effca47d63895
-  data.tar.gz: 1536a650424e03821225cd9b74745457b620d1f539f56c5d0ad66215ada01e4b2b8068f06cc497771f85844fd33781194bf150f1bced6ee9e810f9dbf0c1d492
+  metadata.gz: 168996b1d44310ecffbf9ecb8e24b1a550b45b13b8110e80060b164d7175b2ecf623aa2e7d4b9da550378f7fb39f0862b85593844c9e8dff5936344dc376b9eb
+  data.tar.gz: 826c5078e0941e8874f1c70527b0ee967c900be19d1e520d4768601f5086b1d107b7655ec9d534868aa4e11abb488b5cfce7a2f9cc7b1506561849bca53ab19f

data/CHANGELOG.md

@@ -1,5 +1,30 @@
 ## [Unreleased]
 
+## [0.2.2] - 2026-03-13
+
+### Fixed
+
+- Tuple destructuring in `:for` expressions now works correctly (e.g., `{#for name, spec in @tokens}`)
+
+### Performance
+
+- **33% faster** compilation pipeline for realistic templates, up to **52% faster** for expression-heavy templates
+- Removed Temple `StaticAnalyzer` filter from engine pipeline -- ORB never emits static expressions as `:dynamic` nodes, so Ripper lexing/parsing on every dynamic node was pure overhead
+- Boolean attributes now emit `[:static, ""]` directly instead of `[:dynamic, "nil"]`, avoiding unnecessary Ripper analysis
+- Cached `block?`/`end?` regex results in expression node constructors (computed once instead of on every call)
+- Optimized `Identity.generate` with direct string interpolation instead of array/compact/join
+- Lazy-initialized `@errors` on AST nodes, saving one array allocation per node
+- Removed unused `context={}` parameter from all compiler transform methods, eliminating hash allocation per recursive call
+- Added single-pass `compile_captures_and_args` to `AttributesCompiler`, reducing double iteration over attributes
+- Optimized `Token` constructor to avoid `method_missing` overhead and skip hash merge for common no-meta case
+- Tokenizer: replaced per-call `StringScanner` allocation in `move_by` with `String#count`/`rindex`
+- Tokenizer: switched from `StringIO` to `String` buffer with swap-on-consume pattern
+- Tokenizer: added greedy multi-character scanning patterns for bulk text consumption in 9 tokenizer states
+
+### Added
+
+- Benchmark test suite (`test/benchmark_test.rb`) with 8 template categories, per-template regression thresholds, stage-level profiling, and Temple IR node count tracking
+
 ## [0.2.0] - 2026-03-12
 
 ### Security

data/README.md

@@ -407,10 +407,10 @@ To enable `Tailwindcss` support for ORB, add this to your `settings.json`:
   - [ ] full YARD-compatible documentation of the library
 - [ ] **Step 3: Make it fast**
   - [x] convert Lexer code to `StringScanner`
-  - [ ] create benchmark suite to establish baseline
+  - [x] create benchmark suite to establish baseline
   - [ ] possibly merge lexer states through more intelligent look-ahead
-  - [ ] optimize AST Parser
-  - [ ] optimize Compiler
+  - [x] optimize AST Parser
+  - [x] optimize Compiler
 - [ ] **Step 4: Evolve**
   - [ ] support additional directives, for instance, `Turbo` or `Stimulus` specific directives
   - [ ] support additional block constructs

data/lib/orb/ast/abstract_node.rb

@@ -3,17 +3,27 @@
 module ORB
   module AST
     class AbstractNode
-      attr_accessor :children, :attributes, :errors
+      attr_accessor :children, :attributes
+      attr_writer :errors
+
+      EMPTY_ARRAY = [].freeze
 
       def initialize(*_args)
         @children = []
-        @errors = []
+      end
+
+      def errors
+        @errors || EMPTY_ARRAY
       end
 
       def add_child(node)
         @children << node
       end
 
+      def add_error(error)
+        (@errors ||= []) << error
+      end
+
       def render(_context)
         raise "Not implemented - you must implement render in your subclass!"
       end

data/lib/orb/ast/control_expression_node.rb

@@ -13,14 +13,16 @@ module ORB
       def initialize(token)
         super
         @expression = token.value
+        @is_block = BLOCK_RE.match?(@expression)
+        @is_end = @expression == 'end' || @expression.strip == 'end'
       end
 
       def block?
-        @expression =~ BLOCK_RE
+        @is_block
       end
 
       def end?
-        @expression.strip == 'end'
+        @is_end
       end
     end
   end

data/lib/orb/ast/printing_expression_node.rb

@@ -11,14 +11,16 @@ module ORB
       def initialize(token)
         super
         @expression = token.value
+        @is_block = BLOCK_RE.match?(@expression)
+        @is_end = @expression == 'end' || @expression.strip == 'end'
       end
 
       def block?
-        @expression =~ BLOCK_RE
+        @is_block
       end
 
       def end?
-        @expression.strip == 'end'
+        @is_end
       end
 
       def render(_context)

data/lib/orb/patterns.rb

@@ -4,7 +4,7 @@ module ORB
   module Patterns
     SPACE_CHARS                   = /\s/
     TAG_NAME                      = %r{[^\s>/=$]+}
-    ATTRIBUTE_NAME                = %r{[a-zA-Z_:][-a-zA-Z0-9_:.]*}
+    ATTRIBUTE_NAME                = /[a-zA-Z_:][-a-zA-Z0-9_:.]*/
     UNQUOTED_VALUE_INVALID_CHARS  = /["'=<`]/
     UNQUOTED_VALUE                = %r{[^\s/>]+}
     BLOCK_NAME_CHARS              = /[^\s}]+/
@@ -37,5 +37,17 @@ module ORB
     CRLF                          = /\r\n/
     BLANK                         = /[[:blank:]]/
     OTHER                         = /./
+
+    # Greedy multi-character patterns for bulk scanning in each tokenizer state.
+    # Each pattern excludes only the characters that could start a delimiter in
+    # that state, so the tokenizer consumes runs of "boring" text in one match
+    # instead of character-by-character.
+    INITIAL_TEXT                  = /[^\n\r{<]+/
+    EXPRESSION_TEXT               = /[^\n\r{}]+/
+    COMMENT_TEXT                  = /[^\n\r-]+/
+    VERBATIM_TEXT                 = /[^\n\r<]+/
+    SINGLE_QUOTED_TEXT            = /[^\n\r']+/
+    DOUBLE_QUOTED_TEXT            = /[^\n\r"]+/
+    BLOCK_CONTENT_TEXT            = /[^{}\n\r]+/
   end
 end

data/lib/orb/temple/attributes_compiler.rb

@@ -81,13 +81,14 @@ module ORB
       # 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"`
+      # Compile a single attribute into Temple core abstraction.
+      # Boolean attributes emit [:static, ""] directly instead of [:dynamic, "nil"]
+      # to avoid unnecessary Ripper analysis in Temple's StaticAnalyzer filter.
       def compile_attribute(attribute)
         if attribute.string?
           [:html, :attr, attribute.name, [:static, attribute.value]]
         elsif attribute.bool?
-          [:html, :attr, attribute.name, [:dynamic, "nil"]]
+          [:html, :attr, attribute.name, [:static, ""]]
         elsif attribute.expression?
           [:html, :attr, attribute.name, [:escape, true, [:dynamic, attribute.value]]]
         end
@@ -115,9 +116,46 @@ module ORB
         end
       end
 
+      # Pre-build the variable name string with a single interpolation
       def prefixed_variable_name(name, prefix)
         "#{prefix}_arg_#{name.underscore}"
       end
+
+      # Combined single-pass compilation of captures and komponent args
+      # Returns [captures_array, args_string]
+      def compile_captures_and_args(attributes, prefix)
+        captures = []
+        args = {}
+        splats = []
+
+        attributes.each do |attribute|
+          if attribute.splat?
+            splats << attribute.value
+            next
+          end
+
+          var_name = prefixed_variable_name(attribute.name, prefix)
+
+          # Build capture
+          if attribute.string?
+            captures << [:code, "#{var_name} = \"#{attribute.value}\""]
+          elsif attribute.bool?
+            captures << [:code, "#{var_name} = true"]
+          elsif attribute.expression?
+            captures << [:code, "#{var_name} = #{attribute.value}"]
+          end
+
+          # Build args hash
+          args = args.deep_merge(dash_to_hash(attribute.name, var_name))
+        end
+
+        # Build the argument list
+        result_parts = []
+        result_parts << hash_to_args_list(args) unless args.empty?
+        result_parts += splats
+
+        [captures, result_parts.join(', ')]
+      end
     end
   end
 end

data/lib/orb/temple/compiler.rb

@@ -31,33 +31,33 @@ module ORB
       #
       # rubocop:disable Metrics/CyclomaticComplexity
       # rubocop:disable Metrics/PerceivedComplexity
-      def transform(node, context = {})
+      def transform(node)
         if node.is_a?(ORB::AST::RootNode)
-          transform_children(node, context)
+          transform_children(node)
         elsif node.is_a?(ORB::AST::TextNode)
-          transform_text_node(node, context)
+          transform_text_node(node)
         elsif node.is_a?(ORB::AST::PrintingExpressionNode)
-          transform_printing_expression_node(node, context)
+          transform_printing_expression_node(node)
         elsif node.is_a?(ORB::AST::ControlExpressionNode)
-          transform_control_expression_node(node, context)
+          transform_control_expression_node(node)
         elsif node.is_a?(ORB::AST::TagNode) && node.compiler_directives?
-          transform_directives_for_tag_node(node, context)
+          transform_directives_for_tag_node(node)
         elsif node.is_a?(ORB::AST::TagNode) && node.dynamic?
-          transform_dynamic_tag_node(node, context)
+          transform_dynamic_tag_node(node)
         elsif node.is_a?(ORB::AST::TagNode) && node.html_tag?
-          transform_html_tag_node(node, context)
+          transform_html_tag_node(node)
         elsif node.is_a?(ORB::AST::TagNode) && node.component_tag?
-          transform_component_tag_node(node, context)
+          transform_component_tag_node(node)
         elsif node.is_a?(ORB::AST::TagNode) && node.component_slot_tag?
-          transform_component_slot_tag_node(node, context)
+          transform_component_slot_tag_node(node)
         elsif node.is_a?(ORB::AST::BlockNode)
-          transform_block_node(node, context)
+          transform_block_node(node)
         elsif node.is_a?(ORB::AST::PublicCommentNode)
-          transform_public_comment_node(node, context)
+          transform_public_comment_node(node)
         elsif node.is_a?(ORB::AST::PrivateCommentNode)
-          transform_private_comment_node(node, context)
+          transform_private_comment_node(node)
         elsif node.is_a?(ORB::AST::NewlineNode)
-          transform_newline_node(node, context)
+          transform_newline_node(node)
         elsif node.is_a?(ORB::Error)
           runtime_error(node)
         else
@@ -68,128 +68,116 @@ module ORB
       # rubocop:enable Metrics/PerceivedComplexity
 
       # Compile the children of a node and collect the result into a Temple expression
-      def transform_children(node, context)
-        [:multi, *node.children.map { |child| transform(child, context) }]
+      def transform_children(node)
+        [:multi, *node.children.map { |child| transform(child) }]
       end
 
       # Compile a TextNode into a Temple expression
-      def transform_text_node(node, _context)
+      def transform_text_node(node)
         [:static, node.text]
       end
 
       # Compile an PExpressionNode into a Temple expression
-      def transform_printing_expression_node(node, context)
+      def transform_printing_expression_node(node)
         if node.block?
           tmp = @identity.generate(:variable)
           [:multi,
-            # Capture the result of the code in a variable. We can't do
-            # `[:dynamic, code]` because it's probably not a complete
-            # expression (which is a requirement for Temple).
             [
               :block, "#{tmp} = #{node.expression}",
-
-              # Capture the content of a block in a separate buffer. This means
-              # that `yield` will not output the content to the current buffer,
-              # but rather return the output.
-              #
-              # The capturing can be disabled with the option :disable_capture.
-              # Output code in the block writes directly to the output buffer then.
-              # Rails handles this by replacing the output buffer for helpers.
               if @options.fetch(:disable_capture, false)
-                transform_children(node, context)
+                transform_children(node)
               else
-                [:capture, @identity.generate(:variable), transform_children(node, context)]
+                [:capture, @identity.generate(:variable), transform_children(node)]
               end
             ],
-            # Output the content.
             [:escape, true, [:dynamic, tmp]]]
         elsif node.children.any?
-          [:multi, [:escape, true, [:dynamic, node.expression]], transform_children(node, context)]
+          [:multi, [:escape, true, [:dynamic, node.expression]], transform_children(node)]
         else
           [:escape, true, [:dynamic, node.expression]]
         end
       end
 
       # Compile an NPExpressionNode into a Temple expression
-      def transform_control_expression_node(node, context)
+      def transform_control_expression_node(node)
         if node.block?
           tmp = @identity.generate(:variable)
           [:multi,
-            [:block, "#{tmp} = #{node.expression}", transform_children(node, context)]]
+            [:block, "#{tmp} = #{node.expression}", transform_children(node)]]
         elsif node.children.any?
-          [:multi, [:code, node.expression], transform_children(node, context)]
+          [:multi, [:code, node.expression], transform_children(node)]
         else
           [:code, node.expression]
         end
       end
 
       # Compile an HTML TagNode into a Temple expression
-      def transform_html_tag_node(node, context)
-        [:orb, :tag, node.tag, node.attributes, transform_children(node, context)]
+      def transform_html_tag_node(node)
+        [:orb, :tag, node.tag, node.attributes, transform_children(node)]
       end
 
       # Compile a component TagNode into a Temple expression
-      def transform_component_tag_node(node, context)
-        [:orb, :component, node, transform_children(node, context)]
+      def transform_component_tag_node(node)
+        [:orb, :component, node, transform_children(node)]
       end
 
       # Compile a component slot TagNode into a Temple expression
-      def transform_component_slot_tag_node(node, context)
-        [:orb, :slot, node, transform_children(node, context)]
+      def transform_component_slot_tag_node(node)
+        [:orb, :slot, node, transform_children(node)]
       end
 
       # Compile a block node into a Temple expression
-      def transform_block_node(node, context)
+      def transform_block_node(node)
         case node.name
         when :if
-          [:orb, :if, node.expression, transform_children(node, context)]
+          [:orb, :if, node.expression, transform_children(node)]
         when :for
-          [:orb, :for, node.expression, transform_children(node, context)]
+          [:orb, :for, node.expression, transform_children(node)]
         else
           [:static, 'Unknown block node']
         end
       end
 
       # Compile a comment node into a Temple expression
-      def transform_public_comment_node(node, _context)
+      def transform_public_comment_node(node)
         [:html, :comment, [:static, node.text]]
       end
 
       # Compile a private_comment node into a Temple expression
-      def transform_private_comment_node(_node, _context)
+      def transform_private_comment_node(_node)
         [:static, ""]
       end
 
       # Compile a newline node into a Temple expression
-      def transform_newline_node(_node, _context)
+      def transform_newline_node(_node)
         [:newline]
       end
 
       # Compile a tag node with directives
-      def transform_directives_for_tag_node(node, context)
+      def transform_directives_for_tag_node(node)
         # First, process any :if directives
         if_directive = node.directives.fetch(:if, false)
         if if_directive
           node.remove_directive(:if)
           return [:if,
             if_directive,
-            transform(node, context)]
+            transform(node)]
         end
 
         # Second, process any :for directives
         for_directive = node.directives.fetch(:for, false)
         if for_directive
           node.remove_directive(:for)
-          return [:orb, :for, for_directive, transform(node, context)]
+          return [:orb, :for, for_directive, transform(node)]
         end
 
         # Last, render as a dynamic node expression
-        transform(node, context)
+        transform(node)
       end
 
       # Compile a dynamic tag node
-      def transform_dynamic_tag_node(node, context)
-        [:orb, :dynamic, node, transform_children(node, context)]
+      def transform_dynamic_tag_node(node)
+        [:orb, :dynamic, node, transform_children(node)]
       end
 
       # Helper or raising exceptions during compilation

data/lib/orb/temple/engine.rb

@@ -30,7 +30,10 @@ module ORB
       html :Fast
       filter :Ambles
       filter :Escapable
-      filter :StaticAnalyzer
+      # NOTE: StaticAnalyzer intentionally omitted. It calls Ripper.lex + Ripper.parse
+      # on every [:dynamic, ...] node to check if it's actually a static expression.
+      # ORB's compiler never emits static expressions as :dynamic nodes, so this
+      # filter always concludes "not static" -- pure overhead (Ripper is expensive).
       filter :ControlFlow
       filter :MultiFlattener
       filter :StaticMerger

data/lib/orb/temple/filters.rb

@@ -16,6 +16,11 @@ module ORB
       # Used to validate slot names before interpolation into generated Ruby code.
       VALID_SLOT_NAME = /\A[a-z_]\w*\z/
 
+      # Valid :for expression: single identifier or tuple-destructured identifiers
+      # (e.g., "item in items", "key, value in hash", "(key, value) in hash")
+      # followed by " in " and the collection expression.
+      VALID_FOR_EXPRESSION = /\A\s*(\(?[a-z_]\w*(?:\s*,\s*[a-z_]\w*)*\)?)\s+in\s+(.+)\z/m
+
       def initialize(options = {})
         @options = options
         @attributes_compiler = AttributesCompiler.new
@@ -51,15 +56,13 @@ module ORB
 
         block_name = "__orb__#{komponent_name.rpartition('::').last.underscore}"
         block_name = node.directives.fetch(:with, block_name)
-        unless block_name.match?(/\A[a-z_]\w*\z/)
+        unless block_name.match?(VALID_SLOT_NAME)
           raise ORB::SyntaxError.new("Invalid :with directive value: must be a valid Ruby identifier", 0)
         end
 
-        # We need to compile the attributes into a set of captures and a set of arguments
-        # since arguments passed to the view component constructor may be defined as
-        # dynamic expressions in our template, and we need to first capture their results.
-        arg_captures = @attributes_compiler.compile_captures(node.attributes, tmp)
-        args = @attributes_compiler.compile_komponent_args(node.attributes, tmp)
+        # Compile attributes in a single pass: captures for variable assignment +
+        # args string for the component constructor call.
+        arg_captures, args = @attributes_compiler.compile_captures_and_args(node.attributes, tmp)
 
         # Construct the render call for the view component
         code = "render #{komponent_name}.new(#{args}) do |#{block_name}|"
@@ -87,20 +90,18 @@ module ORB
       def on_orb_slot(node, content = [])
         tmp = unique_name
 
-        # We need to compile the attributes into a set of captures and a set of arguments
-        # since arguments passed to the view component constructor may be defined as
-        # dynamic expressions in our template, and we need to first capture their results.
-        arg_captures = @attributes_compiler.compile_captures(node.attributes, tmp)
-        args = @attributes_compiler.compile_komponent_args(node.attributes, tmp)
+        # Compile attributes in a single pass
+        arg_captures, args = @attributes_compiler.compile_captures_and_args(node.attributes, tmp)
 
         # Prepare the slot name, parent name, and block name
         slot_name = node.slot
         unless slot_name.match?(VALID_SLOT_NAME)
           raise ORB::SyntaxError.new("Invalid slot name: #{slot_name.inspect}", 0)
         end
+
         parent_name = "__orb__#{node.component.underscore}"
         block_name = node.directives.fetch(:with, "__orb__#{slot_name}")
-        unless block_name.match?(/\A[a-z_]\w*\z/)
+        unless block_name.match?(VALID_SLOT_NAME)
           raise ORB::SyntaxError.new("Invalid :with directive value: must be a valid Ruby identifier", 0)
         end
 
@@ -132,10 +133,15 @@ module ORB
       # @param [Array] content The content to be rendered for each iteration
       # @return [Array] compiled Temple expression
       def on_orb_for(expression, content)
-        match = expression.match(/\A\s*([a-z_]\w*)\s+in\s+(.+)\z/m)
-        raise ORB::SyntaxError.new("Invalid :for expression: enumerator must be a valid Ruby identifier", 0) unless match
+        # Match single identifier or tuple-destructured identifiers (e.g., "key, value" or "(key, value)")
+        match = expression.match(VALID_FOR_EXPRESSION)
+        unless match
+          raise ORB::SyntaxError.new("Invalid :for expression: enumerator must be a valid Ruby identifier",
+            0)
+        end
 
-        enumerator, collection = match[1], match[2]
+        enumerator = match[1]
+        collection = match[2]
 
         # Reject semicolons in the collection expression to prevent statement injection.
         # Legitimate complex expressions should be assigned in a {%...%} block first.
@@ -163,6 +169,7 @@ module ORB
           unless node.tag.match?(VALID_HTML_TAG_NAME)
             raise ORB::SyntaxError.new("Invalid tag name: #{node.tag.inspect}", 0)
           end
+
           tmp = unique_name
           splats = @attributes_compiler.compile_splat_attributes(node.splat_attributes)
           code = "content_tag('#{node.tag}', #{splats}) do"

data/lib/orb/temple/identity.rb

@@ -9,7 +9,11 @@ module ORB
 
       def generate(prefix = nil)
         @unique_id += 1
-        ["_orb_compiler", prefix, @unique_id].compact.join('_')
+        if prefix
+          "_orb_compiler_#{prefix}_#{@unique_id}"
+        else
+          "_orb_compiler_#{@unique_id}"
+        end
       end
     end
   end

data/lib/orb/token.rb

@@ -9,7 +9,7 @@ module ORB
       @type = type
       @value = value
       @meta = meta
-      @line = line || 0
+      @line = meta[:line] || 0
     end
 
     def set_meta(key, value)

data/lib/orb/tokenizer2.rb

@@ -34,7 +34,6 @@ module ORB
       @raise_errors = options.fetch(:raise_errors, true)
 
       # Streaming Tokenizer State
-      @cursor = 0
       @column = 1
       @line = 1
       @errors = []
@@ -42,7 +41,7 @@ module ORB
       @attributes = []
       @braces = []
       @state = :initial
-      @buffer = StringIO.new
+      @buffer = +''
     end
 
     # Main Entry
@@ -66,11 +65,6 @@ module ORB
 
     # Dispatcher based on current state
     def next_token
-      # Detect infinite loop
-      # if @previous_cursor == @cursor && @previous_state == @state
-      #   raise "Internal Error: detected infinite loop in :#{@state}"
-      # end
-
       # Dispatch to state handler
       send(:"next_in_#{@state}")
     end
@@ -124,7 +118,7 @@ module ORB
         add_token(:tag_open, nil)
         move_by_matched
         transition_to(:tag_open)
-      elsif @source.scan(OTHER)
+      elsif @source.scan(INITIAL_TEXT) || @source.scan(OTHER)
         buffer_matched
         move_by_matched
       else
@@ -243,7 +237,7 @@ module ORB
         current_attribute[2] = attribute_value
         move_by_matched
         transition_to(:tag_open_content)
-      elsif @source.scan(NEWLINE) || @source.scan(CRLF) || @source.scan(BLANK) || @source.scan(OTHER)
+      elsif @source.scan(SINGLE_QUOTED_TEXT) || @source.scan(NEWLINE) || @source.scan(CRLF) || @source.scan(OTHER)
         buffer_matched
         move_by_matched
       else
@@ -259,7 +253,7 @@ module ORB
         current_attribute[2] = attribute_value
         move_by_matched
         transition_to(:tag_open_content)
-      elsif @source.scan(NEWLINE) || @source.scan(CRLF) || @source.scan(BLANK) || @source.scan(OTHER)
+      elsif @source.scan(DOUBLE_QUOTED_TEXT) || @source.scan(NEWLINE) || @source.scan(CRLF) || @source.scan(OTHER)
         buffer_matched
         move_by_matched
       else
@@ -285,7 +279,7 @@ module ORB
           move_by_matched
           transition_to(:tag_open_content)
         end
-      elsif @source.scan(NEWLINE) || @source.scan(CRLF) || @source.scan(BLANK) || @source.scan(OTHER)
+      elsif @source.scan(EXPRESSION_TEXT) || @source.scan(NEWLINE) || @source.scan(CRLF) || @source.scan(OTHER)
         buffer_matched
         move_by_matched
       else
@@ -311,7 +305,7 @@ module ORB
           clear_braces
           transition_to(:tag_open_content)
         end
-      elsif @source.scan(NEWLINE) || @source.scan(CRLF) || @source.scan(BLANK) || @source.scan(OTHER)
+      elsif @source.scan(EXPRESSION_TEXT) || @source.scan(NEWLINE) || @source.scan(CRLF) || @source.scan(OTHER)
         buffer_matched
         move_by_matched
       else
@@ -356,7 +350,7 @@ module ORB
         update_current_token(text)
         move_by_matched
         transition_to(:initial)
-      elsif @source.scan(NEWLINE) || @source.scan(CRLF) || @source.scan(BLANK) || @source.scan(OTHER)
+      elsif @source.scan(COMMENT_TEXT) || @source.scan(NEWLINE) || @source.scan(CRLF) || @source.scan(OTHER)
         buffer_matched
         move_by_matched
       else
@@ -371,7 +365,7 @@ module ORB
         update_current_token(text)
         move_by_matched
         transition_to(:initial)
-      elsif @source.scan(NEWLINE) || @source.scan(CRLF) || @source.scan(BLANK) || @source.scan(OTHER)
+      elsif @source.scan(COMMENT_TEXT) || @source.scan(NEWLINE) || @source.scan(CRLF) || @source.scan(OTHER)
         buffer_matched
         move_by_matched
       else
@@ -409,7 +403,7 @@ module ORB
           buffer_matched
           move_by_matched
         end
-      elsif @source.scan(BLANK) || @source.scan(OTHER)
+      elsif @source.scan(BLOCK_CONTENT_TEXT) || @source.scan(OTHER)
         buffer_matched
         move_by_matched
       end
@@ -508,7 +502,7 @@ module ORB
           buffer(tmp)
           move_by(tmp)
         end
-      elsif @source.scan(NEWLINE) || @source.scan(CRLF) || @source.scan(BLANK) || @source.scan(OTHER)
+      elsif @source.scan(VERBATIM_TEXT) || @source.scan(NEWLINE) || @source.scan(CRLF) || @source.scan(OTHER)
         buffer_matched
         move_by_matched
       end
@@ -551,6 +545,7 @@ module ORB
       if @braces.length >= MAX_BRACE_DEPTH
         raise ORB::SyntaxError.new("Maximum brace nesting depth (#{MAX_BRACE_DEPTH}) exceeded", @line)
       end
+
       @braces << "{"
     end
 
@@ -560,14 +555,15 @@ module ORB
       @column = column
     end
 
+    # Update line/column tracking from a matched string.
+    # Uses String#count and String#rindex instead of re-scanning with StringScanner.
     def move_by(str)
-      scan = StringScanner.new(str)
-      until scan.eos?
-        if scan.scan(NEWLINE) || scan.scan(CRLF)
-          move(@line + 1, 1)
-        elsif scan.scan(OTHER)
-          move(@line, @column + scan.matched.size)
-        end
+      newlines = str.count("\n")
+      if newlines.positive?
+        @line += newlines
+        @column = str.length - str.rindex("\n")
+      else
+        @column += str.length
       end
     end
 
@@ -582,7 +578,11 @@ module ORB
 
     # Create a new token
     def create_token(type, value, meta = {})
-      Token.new(type, value, meta.merge(line: @line, column: @column) { |_k, v1, _v2| v1 })
+      if meta.empty?
+        Token.new(type, value, { line: @line, column: @column })
+      else
+        Token.new(type, value, { line: @line, column: @column }.merge!(meta))
+      end
     end
 
     # Create a token and add it to the token list
@@ -603,18 +603,18 @@ module ORB
 
     # Read the buffer to a string
     def read_buffer
-      @buffer.string.clone
+      @buffer.dup
     end
 
     # Clear the buffer
     def clear_buffer
-      @buffer = StringIO.new
+      @buffer = +''
     end
 
     # Read the buffer to a string and clear it
     def consume_buffer
-      str = read_buffer
-      clear_buffer
+      str = @buffer
+      @buffer = +''
       str
     end
 

data/lib/orb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ORB
-  VERSION = "0.2.0"
+  VERSION = "0.2.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: orb_template
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.2
 platform: ruby
 authors:
 - KUY.io Inc.