rblade 3.1.0 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 565a823219a85db94f6fa31e42de52cab5d1de562c89c42243a0105d54eab581
-  data.tar.gz: 484ca84492233eabd1c61a534be991cfdb489273751e4e43a1b5ac400965b867
+  metadata.gz: b2a97583c74dd9bff9b805c0eeedc59751909eea8bd3130e6947ca5e70355b30
+  data.tar.gz: fceb38fd16cbb4e569e8cdbf0082710862388d98e428bf99a81f6bc8e4f15e0a
 SHA512:
-  metadata.gz: a3fa94d7c7c3f19f3671dd346bffedbee1fdaaf3b93ce0928cba1b6bb7d24a7c7da83c016863df9aa8c5cbdd0d5519d65efef7aa18a59a77a7861764e8188f03
-  data.tar.gz: 29325e82f35eb1e6b949b49684ea5c78cea910ffeeacf18ef012c39ff6cbe2a73e26bd47d1753734cc712421b19a958dab54224c024c25ca580b53b34b6dcb9a
+  metadata.gz: 1d8d277be52f54f2a524eacb9f7f5cf8095032f2d076bb893640ed7e86be6a49dcde5eb50e0309f592c2d69451b171f7d265eb198fd324eadcc41daf1df74b70
+  data.tar.gz: 5ac646bdcbc33e0183c981ac651cf8493beaf2494b1c07fb3aa13c933eb50115d8673bb6ff37ee2f17f3f8e367e6020ca3433c2d656b5d87d0be0bb9eeaf6b3f

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 3.2.0 [UNRELEASED]
+- Add translate_location method to improve error messages in RBlade templates
+
+## 3.1.1 [2025-05-11]
+- Fix issue with component attributes mutating unfrozen strings (#19)
+
 ## 3.1.0 [2025-04-02]
 - Add ability to use slots in dynamic components and the component view helper method
 - Change statement matching to use regular expressions to improve compile performance

data/lib/rblade/compiler/compiles_comments.rb

@@ -10,5 +10,22 @@ module RBlade
         token.value.gsub!(/<%#(?:[^%]++|%)*?%>/, "")
       end
     end
+
+    def self.comment_offsets(source)
+      current_match_id = nil
+      offsets = []
+
+      source.split(/(\{\{--(?:[^-]++|-)*?--}}|<%#(?:[^%]++|%)*?%>)/) do |before_match|
+        next if current_match_id == $~.object_id || $&.nil?
+        current_match_id = $~.object_id
+
+        offsets << {
+          source_position: (offsets.last&.[](:source_position) || 0) + before_match.length,
+          offset: $&.length,
+        }
+      end
+
+      offsets
+    end
   end
 end

data/lib/rblade/compiler/compiles_components.rb

@@ -107,15 +107,13 @@ module RBlade
     end
 
     def process_string_attribute(string)
-      result = string.split(/((?<!@)\{\{(?:[^}]++|\})*?\}\})/).map do |substring|
+      string.split(/((?<!@)\{\{(?:[^}]++|\})*?\}\})/).map do |substring|
         if substring.start_with?("{{") && substring.end_with?("}}")
           "(#{substring[2..-3]}).to_s"
         elsif !substring.empty?
           "'#{RBlade.escape_quotes(substring.gsub(/@\{\{/, "{{"))}'"
         end
-      end.compact.join("<<")
-
-      result.empty? ? "+''" : result.prepend("+")
+      end.compact.unshift("+''").join("<<")
     end
   end
 end

data/lib/rblade/compiler/compiles_injections.rb

@@ -6,56 +6,79 @@ module RBlade
       tokens.map! do |token|
         next(token) if token.type != :unprocessed
 
-        segments = token.value.split(/
-          (@?\{!!)(\s*+(?:[^!}%@]++|[!}%@])+?\s*+)(!!})
+        current_match_id = nil
+        segments = []
+        token.value.split(/
+          (?<escape_unsafe_rblade>@?)\{!!(?<unsafe_rblade>(?:[^!}]++|[!}])+?)!!}
           |
-          (@?\{\{)(\s*+(?:[^!}%@]++|[!}%@])+?\s*+)(}})
+          (?<escape_safe_rblade>@?) \{\{ (?<safe_rblade>(?:[^!}]++|[!}])+?) }}
           |
-          (\s?(?<!\w)@?@ruby)(\s++(?:[^!}%@]++|[!}%@])+?\s*+)((?<!\w)@end_?ruby(?!\w)\s?)
+          \s?(?<![\w@])@ruby\s++(?<ruby>(?:[^@]++|[@])+?)(?<!\w)@end_?ruby(?!\w)\s?
           |
-          (<%%?=?=?)(\s*+(?:[^!}%@]++|[!}%@])+?\s*+)(%%?>)
-        /xi)
+          (?<escaped_erb_start><%%)
+          |
+          (?<escaped_erb_end>%%>)
+          |
+          (?<erb_tag><%(?!%)=?=?)\s*+(?<erb_tag_content>(?:[^%]++|[%])+?)(?<!%)%?>
+        /xi) do |before_match|
+          next if current_match_id == $~.object_id
+          current_match_id = $~.object_id
 
-        i = 0
-        while i < segments.count
-          case segments[i]
-          when "{{", "<%="
-            segments[i] = create_token(segments[i + 1].strip, true)
-          when "<%", /\A\s?@ruby\z/i
-            segments[i + 1].strip!
-            segments[i + 1] << ";" unless segments[i + 1].end_with?(";")
-            segments[i] = Token.new(type: :ruby, value: segments[i + 1])
-          when "{!!", "<%=="
-            segments[i] = create_token(segments[i + 1].strip, false)
-          when "@{!!", "@{{", /\A\s?@@ruby\z/i
-            segments[i].sub!("@", "")
-            segments[i] = Token.new(type: :raw_text, value: "#{segments[i]}#{segments[i + 1]}#{segments[i + 2]}")
-          when "<%%", "<%%=", "<%%=="
-            segments[i] = Token.new(type: :raw_text, value: "<#{segments[i].delete_prefix!("<%")}#{segments[i + 1]}%>")
-          when "", nil
-            segments.delete_at i
-            next
-          else
-            segments[i] = Token.new(type: :unprocessed, value: segments[i])
-            i += 1
-            next
+          unless before_match == ""
+            RBlade::Utility.append_unprocessed_string_segment!(token, segments, before_match)
           end
+          next if $~.nil?
+
+          if $~[:unsafe_rblade].present? || $~[:erb_tag] == "<%=="
+            if $~[:escape_unsafe_rblade] == "@"
+              RBlade::Utility.append_unprocessed_string_segment!(token, segments, $&.delete_prefix("@"))
+            else
+              start_offset = segments.last&.end_offset || token.start_offset
+              segments << create_token(
+                ($~[:unsafe_rblade] || $~[:erb_tag_content]).strip,
+                false,
+                start_offset,
+                start_offset + $&.length,
+              )
+            end
+          elsif $~[:safe_rblade].present? || $~[:erb_tag] == "<%="
+            if $~[:escape_safe_rblade] == "@"
+              RBlade::Utility.append_unprocessed_string_segment!(token, segments, $&.delete_prefix("@"))
+            else
+              start_offset = segments.last&.end_offset || token.start_offset
+              segments << create_token(
+                ($~[:safe_rblade] || $~[:erb_tag_content]).strip,
+                true,
+                start_offset,
+                start_offset + $&.length,
+              )
+            end
+          elsif $~[:ruby].present? || $~[:erb_tag] == "<%"
+            value = ($~[:ruby] || $~[:erb_tag_content]).strip
+            value << ";" unless value.end_with?(";")
+            start_offset = segments.last&.end_offset || token.start_offset
 
-          segments.delete_at i + 1
-          segments.delete_at i + 1
-          i += 1
+            segments << Token.new(
+              type: :ruby,
+              value: value,
+              start_offset: start_offset,
+              end_offset: start_offset + $&.length,
+            )
+          elsif $~[:escaped_erb_start].present?
+            RBlade::Utility.append_unprocessed_string_segment!(token, segments, +"<%")
+          elsif $~[:escaped_erb_end].present?
+            RBlade::Utility.append_unprocessed_string_segment!(token, segments, +"%>")
+          end
         end
 
         segments
       end.flatten!
     end
 
-    private
-
-    def create_token(expression, escape_html)
+    private def create_token(expression, escape_html, start_offset, end_offset)
       # Don't try to print ends
       if expression.match?(/\A(?:}|end(?![[:alnum:]_]|[^\0-\177]))/i)
-        return Token.new(:ruby, "#{expression};")
+        return Token.new(:ruby, "#{expression};", start_offset, end_offset)
       end
 
       segment_value = if escape_html
@@ -75,7 +98,7 @@ module RBlade
         "@output_buffer.raw_buffer<<(#{expression}).to_s;"
       end
 
-      Token.new(:print, segment_value)
+      Token.new(:print, segment_value, start_offset, end_offset)
     end
   end
 end

data/lib/rblade/compiler/compiles_verbatim.rb

@@ -6,26 +6,38 @@ module RBlade
       tokens.map! do |token|
         next(token) if token.type != :unprocessed
 
-        segments = token.value.split(/\s?(?<!\w)(@verbatim)(?!\w)\s?((?:[^@\s]++|[@\s])+?)\s?(?<!\w)@end_?verbatim(?!\w)\s?/i)
+        current_match_id = nil
+        segments = []
+        token.value.split(/\s?(?<!\w)@verbatim(?!\w)\s?(?<contents>(?:[^@\s]++|[@\s])+?)\s?(?<!\w)@end_?verbatim(?!\w)\s?/i) do |before_match|
+          next if current_match_id == $~.object_id
+          current_match_id = $~.object_id
 
-        i = 0
-        while i < segments.count
-          if segments[i] == "@verbatim"
-            segments.delete_at i
-            segments[i] = Token.new(type: :raw_text, value: segments[i])
-
-            i += 1
-          elsif !segments[i].nil? && segments[i] != ""
-            segments[i] = Token.new(type: :unprocessed, value: segments[i])
+          # Add the current string to the segment list
+          unless before_match == ""
+            RBlade::Utility.append_unprocessed_string_segment!(token, segments, before_match)
+          end
+          next if $~.nil?
 
-            i += 1
-          else
-            segments.delete_at i
+          if $~[:contents].present?
+            start_offset = segments.last&.end_offset || token.start_offset
+            segments << Token.new(
+              type: :raw_text,
+              value: $~[:contents],
+              start_offset: start_offset,
+              end_offset: start_offset + $&.length,
+            )
           end
         end
 
         segments
       end.flatten!
     end
+
+    # Replaces verbatim statements with spaces of the same length. Used in comment offset calculation for source maps.
+    def self.nullify_verbatim(source)
+      source.gsub(/\s?(?<!\w)@verbatim(?!\w)\s?(?<contents>(?:[^@\s]++|[@\s])+?)\s?(?<!\w)@end_?verbatim(?!\w)\s?/i) do |match|
+        " " * match.length
+      end
+    end
   end
 end

data/lib/rblade/compiler/tokenizes_components.rb

@@ -8,53 +8,106 @@ module RBlade
       tokens.map! do |token|
         next(token) if token.type != :unprocessed
 
-        segments = tokenize_component_tags token.value
-
-        i = 0
-        while i < segments.count
-          if segments[i] == "</" && segments[i + 1]&.match?(/x[-:]/)
-            segments[i] = Token.new(type: :component_end, value: {name: segments[i + 1][2..]})
-
-            segments.delete_at i + 1
-            i += 1
-          elsif segments[i] == "<//>"
-            segments[i] = Token.new(type: :component_unsafe_end)
-            i += 1
-          elsif segments[i] == "<" && segments[i + 1]&.match?(/x[-:]/)
-            name = segments[i + 1][2..]
-            raw_attributes = (segments[i + 2] != ">") ? tokenize_attributes(segments[i + 2]) : nil
-
-            attributes = process_attributes raw_attributes
-
-            if raw_attributes.nil?
-              segments.delete_at i + 1
-            else
-              while segments[i + 1] != ">" && segments[i + 1] != "/>"
-                segments.delete_at i + 1
-              end
-            end
-
-            token_type = (segments[i + 1] == "/>") ? :component : :component_start
-            segments[i] = Token.new(type: token_type, value: {name:, attributes:})
-            segments.delete_at i + 1
+        process_component_tags token
+      end.flatten!
+    end
 
-            i += 1
-          elsif !segments[i].nil? && segments[i] != ""
-            segments[i] = Token.new(type: :unprocessed, value: segments[i])
+    private def process_component_tags(token)
+      current_match_id = nil
+      segments = []
 
-            i += 1
-          else
-            segments.delete_at i
-          end
+      token.value.split(%r/
+        # Opening and self-closing tags
+        (?<opening_tag>
+          <
+            \s*+
+            x[-\:](?<opening_tag_name>[\w\-\:\.]++)
+            (?<tag_attributes>
+              (?:
+                \s++
+                (?:
+                  (?:
+                    @class(?<nested_parentheses>\( (?: [^()]++ | \g<nested_parentheses> )*+ \))
+                  )
+                  |
+                  (?:
+                    @style\g<nested_parentheses>
+                  )
+                  |
+                  \{\{ \s*+ attributes (?:[^}]++|\})*? \}\}
+                  |
+                  (?:
+                    [\w\-:.@%]++
+                    (?:
+                      =
+                      (?:
+                        "(?> [^"{]++ | (?<!@)\{\{ (?:[^}]++|\})*? \}\} | \{ )*+"
+                        |
+                        '(?> [^'{]++ | (?<!@)\{\{ (?:[^}]++|\})*? \}\} | \{ )*+'
+                        |
+                        (?> [^'"=<>\s\/{]++ | (?<!@)\{\{ (?:[^}]++|\})*? \}\} | \{ )++
+                      )
+                    )?
+                  )
+                )
+              )*+
+            )
+            \s*+
+          (?<opening_tag_end>\/?>)
+        )
+        |
+        # Closing tags
+        (?<closing_tag>
+          <\/
+            \s*+
+            x[-\:](?<closing_tag_name>[\w\-\:\.]++)
+            \s*+
+          >
+        )
+        |
+        (?<unsafe_closing_tag><\/\/>)
+      /x) do |before_match|
+        next if current_match_id == $~.object_id
+        current_match_id = $~.object_id
+
+        # Add the current string to the segment list
+        unless before_match == ""
+          RBlade::Utility.append_unprocessed_string_segment!(token, segments, before_match)
         end
+        next if $~.nil?
+
+        start_offset = segments.last&.end_offset || token.start_offset
+        if $~[:unsafe_closing_tag].present?
+          segments << Token.new(
+            type: :component_unsafe_end,
+            start_offset: start_offset,
+            end_offset: start_offset + $&.length,
+          )
+        elsif $~[:closing_tag].present?
+          segments << Token.new(
+            type: :component_end,
+            value: {name: $~[:closing_tag_name]},
+            start_offset: start_offset,
+            end_offset: start_offset + $&.length,
+          )
+        elsif $~[:opening_tag].present?
+          raw_attributes = tokenize_attributes($~[:tag_attributes])
+          attributes = process_attributes raw_attributes
+
+          token_type = ($~[:opening_tag_end] == "/>") ? :component : :component_start
+          segments << Token.new(
+            type: token_type,
+            value: {name: $~[:opening_tag_name], attributes:},
+            start_offset: start_offset,
+            end_offset: start_offset + $&.length,
+          )
+        end
+      end
 
-        segments
-      end.flatten!
+      segments
     end
 
-    private
-
-    def process_attributes(raw_attributes)
+    private def process_attributes(raw_attributes)
       attributes = []
       i = 0
       while i < raw_attributes.count
@@ -112,61 +165,7 @@ module RBlade
       attributes
     end
 
-    def tokenize_component_tags(value)
-      value.split(%r/
-        # Opening and self-closing tags
-        (?:
-          (<)
-            \s*+
-            (x[-\:][\w\-\:\.]++)
-            ((?:
-              \s++
-              (?:
-                (?:
-                  @class(\( (?: [^()]++ | \g<-1> )*+ \))
-                )
-                |
-                (?:
-                  @style(\( (?: [^()]++ | \g<-1> )*+ \))
-                )
-                |
-                (
-                  \{\{ \s*+ attributes (?:[^}]++|\})*? \}\}
-                )
-                |
-                (?:
-                  [\w\-:.@%]++
-                  (?:
-                    =
-                    (?:
-                      "(?> [^"{]++ | (?<!@)\{\{ (?:[^}]++|\})*? \}\} | \{ )*+"
-                      |
-                      '(?> [^'{]++ | (?<!@)\{\{ (?:[^}]++|\})*? \}\} | \{ )*+'
-                      |
-                      (?> [^'"=<>\s\/{]++ | (?<!@)\{\{ (?:[^}]++|\})*? \}\} | \{ )++
-                    )
-                  )?
-                )
-              )
-            )*+)
-            \s*+
-          (\/?>)
-        )
-        |
-        # Closing tags
-        (?:
-          (<\/)
-            \s*+
-            (x[-\:][\w\-\:\.]++)
-            \s*+
-          >
-        )
-        |
-        (<\/\/>)
-      /x)
-    end
-
-    def tokenize_attributes(segment)
+    private def tokenize_attributes(segment)
       segment.scan(%r/
         (?<=\s|^)
         (?:

data/lib/rblade/compiler/tokenizes_statements.rb

@@ -16,7 +16,7 @@ module RBlade
           (?:
             (?:
               (?<escaped_at>@@)
-              (?=\w++[!\?]?(?!\w))
+              (?<escaped_statement_name>\w++[!\?]?(?!\w))
             )
             |
             (?:
@@ -50,36 +50,29 @@ module RBlade
           unless before_match == ""
             # Skip output between case and when statements
             unless segments.last&.type == :statement && segments.last&.value&.[](:name) == "case"
-              if segments.last && segments.last.type == :unprocessed
-                segments.last.value << before_match
-              else
-                segments << Token.new(type: :unprocessed, value: before_match)
-              end
+              RBlade::Utility.append_unprocessed_string_segment!(token, segments, before_match)
             end
           end
           next if $~.nil?
 
-          # Skip escaped statements
-          if $~&.[](:escaped_at) == "@@"
-            segment = $&
-            # Remove the first or second @, depending on whether there is whitespace
-            segment.slice!(1).inspect
-            if segments.last && segments.last.type == :unprocessed
-              segments.last.value << segment
-            else
-              segments << Token.new(type: :unprocessed, value: segment)
-            end
+          statement_handle = ($~[:statement_name] || $~[:escaped_statement_name])
+            &.downcase
+            &.tr("_", "")
+          next if statement_handle.nil?
+
+          unless CompilesStatements.has_handler(statement_handle)
+            RBlade::Utility.append_unprocessed_string_segment!(token, segments, $&)
 
             next
           end
 
-          statement_handle = $~[:statement_name].downcase.tr("_", "")
-          unless CompilesStatements.has_handler(statement_handle)
-            if segments.last && segments.last.type == :unprocessed
-              segments.last.value << $&
-            else
-              segments << Token.new(type: :unprocessed, value: $&)
-            end
+          # Skip escaped statements
+          if $~&.[](:escaped_at) == "@@"
+            segment = $&.dup
+            # Remove the first or second @, depending on whether there is whitespace
+            segment.slice!(1)
+
+            RBlade::Utility.append_unprocessed_string_segment!(token, segments, segment, 1)
 
             next
           end
@@ -95,7 +88,13 @@ module RBlade
 
           end
 
-          segments << Token.new(type: :statement, value: statement_data)
+          start_offset = segments.last&.end_offset || token.start_offset
+          segments << Token.new(
+            type: :statement,
+            value: statement_data,
+            start_offset: start_offset,
+            end_offset: start_offset + $&.length,
+          )
         end
 
         segments

data/lib/rblade/compiler.rb

@@ -7,9 +7,10 @@ require "rblade/compiler/compiles_verbatim"
 require "rblade/compiler/compiles_statements"
 require "rblade/compiler/tokenizes_components"
 require "rblade/compiler/tokenizes_statements"
+require "rblade/helpers/utility"
 require "active_support/core_ext/string/output_safety"
 
-Token = Struct.new(:type, :value)
+Token = Struct.new(:type, :value, :start_offset, :end_offset)
 
 module RBlade
   def self.escape_quotes(string)
@@ -38,7 +39,46 @@ module RBlade
 
   class Compiler
     def self.compile_string(string_template, component_store)
-      tokens = [Token.new(:unprocessed, string_template)]
+      tokens = tokenize_string string_template, component_store
+
+      compile_tokens tokens
+    end
+
+    def self.generate_source_map(string_template, component_store)
+      tokens = tokenize_string string_template, component_store
+      source_map = SourceMap.new(string_template)
+
+      i = 0
+      while i < tokens.count
+        token = tokens[i]
+
+        if token.type == :unprocessed || token.type == :raw_text
+          start_offset = token.start_offset
+          compiled_code = +"@output_buffer.raw_buffer<<-'"
+
+          # Merge together consecutive prints
+          while tokens[i + 1]&.type == :unprocessed || tokens[i + 1]&.type == :raw_text
+            compiled_code << RBlade.escape_quotes(token.value)
+            i += 1
+            token = tokens[i]
+          end
+
+          compiled_code << RBlade.escape_quotes(token.value)
+          compiled_code << "';"
+
+          source_map.add(start_offset, token.end_offset, compiled_code)
+        else
+          source_map.add(token.start_offset, token.end_offset, token.value)
+        end
+
+        i += 1
+      end
+
+      source_map
+    end
+
+    def self.tokenize_string(string_template, component_store)
+      tokens = [Token.new(:unprocessed, string_template, 0, string_template.length)]
 
       CompilesVerbatim.new.compile! tokens
       CompilesComments.new.compile! tokens
@@ -50,7 +90,8 @@ module RBlade
       component_compiler = CompilesComponents.new(component_store)
       component_compiler.compile! tokens
       component_compiler.ensure_all_tags_closed
-      compile_tokens tokens
+
+      tokens
     end
 
     def self.compile_attribute_string(string_template)

data/lib/rblade/helpers/source_map.rb

@@ -0,0 +1,58 @@
+module RBlade
+  class SourceMap
+    def initialize(template)
+      @source_tokens = []
+      @compiled_column = 0
+      @compiled_offset = 0
+
+      calculate_comment_offsets(template)
+    end
+
+    private def calculate_comment_offsets(template)
+      template_without_verbatim = CompilesVerbatim.nullify_verbatim(template)
+
+      @comment_offsets = CompilesComments.comment_offsets(template_without_verbatim)
+      @current_comment_offset = 0
+    end
+
+    def add(start_offset, end_offset, compiled_code)
+      increment_comment_offset_to start_offset
+      start_offset += @current_comment_offset
+
+      # Prevent extending the end offset into a comment
+      increment_comment_offset_to end_offset - 1
+      end_offset += @current_comment_offset
+
+      lines = StringUtility.lines(compiled_code)
+
+      @source_tokens << {
+        start_offset: start_offset,
+        end_offset: end_offset,
+        compiled_start_line: @compiled_column,
+        compiled_start_offset: @compiled_offset,
+      }
+
+      @compiled_column += lines.length - 1
+      @compiled_offset = (lines.length == 1) ? @compiled_offset + compiled_code.length : lines.last.length
+    end
+
+    private def increment_comment_offset_to(source_position)
+      while @comment_offsets.any? && @comment_offsets.first[:source_position] <= source_position
+        @current_comment_offset += @comment_offsets.shift[:offset]
+      end
+    end
+
+    def source_location(first_lineno, first_column)
+      previous_token = nil
+
+      @source_tokens.each do |token|
+        break previous_token if token[:compiled_start_line] > first_lineno ||
+          (token[:compiled_start_line] == first_lineno && token[:compiled_start_offset] > first_column)
+
+        previous_token = token
+      end
+
+      previous_token
+    end
+  end
+end

data/lib/rblade/helpers/string_utility.rb

@@ -0,0 +1,10 @@
+class StringUtility
+  class << self
+    def lines(string)
+      lines = string.split(/(?<=\n)/, -1)
+      lines = [""] if lines.length == 0
+
+      lines
+    end
+  end
+end

data/lib/rblade/helpers/utility.rb

@@ -0,0 +1,18 @@
+module RBlade
+  class Utility
+    def self.append_unprocessed_string_segment!(token, segments, string, offset = 0)
+      if segments.last&.type == :unprocessed
+        segments.last.value << string
+        segments.last.end_offset += string.length
+      else
+        start_offset = segments.last&.end_offset || token.start_offset
+        segments << Token.new(
+          type: :unprocessed,
+          value: string,
+          start_offset: start_offset,
+          end_offset: start_offset + string.length + offset,
+        )
+      end
+    end
+  end
+end

data/lib/rblade/rails_template.rb

@@ -5,7 +5,9 @@ require "rblade/component_store"
 require "rblade/helpers/attributes_manager"
 require "rblade/helpers/class_manager"
 require "rblade/helpers/slot_manager"
+require "rblade/helpers/source_map"
 require "rblade/helpers/stack_manager"
+require "rblade/helpers/string_utility"
 require "rblade/helpers/style_manager"
 
 module RBlade
@@ -32,7 +34,47 @@ module RBlade
         end
       end
 
-      -"#{preamble}#{component_store.get}#{RBlade::Compiler.compile_string(source, component_store)}@output_buffer.raw_buffer.prepend(@_rblade_stack_manager.get(_stacks));@output_buffer;"
+      -"#{preamble}\n#{component_store.get}\n#{RBlade::Compiler.compile_string(source, component_store)}@output_buffer.raw_buffer.prepend(@_rblade_stack_manager.get(_stacks));@output_buffer;"
+    end
+
+    def translate_location(spot, backtrace_location, source)
+      view_name = backtrace_location.path
+        .sub(/^.*app\/views\/(.+?)(?:\.\w++)?\.rblade$/, "\\1")
+        .tr("/", ".")
+
+      # Let the component store know about the current view for relative components
+      component_store = RBlade::ComponentStore.new
+      component_store.view_name("view::#{view_name}")
+
+      source_map = RBlade::Compiler.generate_source_map(source, component_store)
+
+      # Account for the preamble and component store
+      offset = 2 + StringUtility.lines(component_store.get).length
+      offset += 1 if spot[:script_lines]&.first == "# frozen_string_literal: true\n"
+
+      location = source_map.source_location(spot[:first_lineno] - offset - 1, spot[:first_column])
+
+      before_lines = StringUtility.lines(source[0...(location[:start_offset])])
+      excerpt = source[(location[:start_offset])...(location[:end_offset])]
+      excerpt_lines = StringUtility.lines(excerpt)
+
+      first_lineno = before_lines.length
+      first_column = before_lines.last.length
+
+      last_lineno = first_lineno + excerpt_lines.length - 1
+      last_column = (excerpt_lines.length > 1) ? excerpt_lines.last.length : first_column + excerpt_lines.first.length
+
+      {
+        first_lineno: first_lineno,
+        first_column: first_column,
+        last_lineno: last_lineno,
+        last_column: last_column,
+        snippet: excerpt,
+        script_lines: source.lines,
+      }
+    rescue => e
+      Rails.logger&.debug "Unable to locate error position in template: #{e.message}"
+      spot
     end
   end
 end

data/rblade.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "rblade"
-  s.version = "3.1.0"
+  s.version = "3.2.0"
   s.summary = "A component-first templating engine for Rails"
   s.description = "RBlade is a simple, yet powerful templating engine for Ruby on Rails, inspired by Laravel Blade."
   s.authors = ["Simon J"]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rblade
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.2.0
 platform: ruby
 authors:
 - Simon J
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-02 00:00:00.000000000 Z
+date: 2025-06-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -156,8 +156,11 @@ files:
 - lib/rblade/helpers/class_manager.rb
 - lib/rblade/helpers/regular_expressions.rb
 - lib/rblade/helpers/slot_manager.rb
+- lib/rblade/helpers/source_map.rb
 - lib/rblade/helpers/stack_manager.rb
+- lib/rblade/helpers/string_utility.rb
 - lib/rblade/helpers/style_manager.rb
+- lib/rblade/helpers/utility.rb
 - lib/rblade/rails_template.rb
 - lib/rblade/railtie.rb
 - rblade.gemspec