rhales 0.4.0 → 0.5.4

data/lib/rhales/{view_composition.rb → core/view_composition.rb}

@@ -1,7 +1,9 @@
 # lib/rhales/view_composition.rb
+#
+# frozen_string_literal: true
 
 require_relative 'rue_document'
-require_relative 'refinements/require_refinements'
+require_relative '../integrations/refinements/require_refinements'
 
 using Rhales::Ruequire
 
@@ -23,6 +25,8 @@ module Rhales
   # - Immutable: Once created, the composition is read-only
   # - Cacheable: Can be cached in production for performance
   class ViewComposition
+    include Rhales::Utils::LoggingHelpers
+
     class TemplateNotFoundError < StandardError; end
     class CircularDependencyError < StandardError; end
 
@@ -39,9 +43,23 @@ module Rhales
 
     # Resolve all template dependencies
     def resolve!
-      load_template_recursive(@root_template_name)
-      freeze_composition
-      self
+      log_timed_operation(Rhales.logger, :debug, 'Template dependency resolution',
+        root_template: @root_template_name
+      ) do
+        load_template_recursive(@root_template_name)
+        freeze_composition
+
+        # Log resolution results
+        log_with_metadata(Rhales.logger, :debug, 'Template composition resolved',
+          root_template: @root_template_name,
+          total_templates: @templates.size,
+          total_dependencies: @dependencies.values.sum(&:size),
+          partials: @dependencies.values.flatten.uniq,
+          layout: layout
+        )
+
+        self
+      end
     end
 
     # Iterate through all documents in render order
@@ -84,25 +102,50 @@ module Rhales
       @dependencies[template_name] || []
     end
 
+    # Get the layout for the root template (if any)
+    def layout
+      root_template = @templates[@root_template_name]
+      return nil unless root_template
+
+      root_template.layout
+    end
 
     private
 
-    def load_template_recursive(template_name, _parent_path = nil)
+    def load_template_recursive(template_name, parent_path = nil)
+      depth = @loading.size
+
       # Check for circular dependencies
       if @loading.include?(template_name)
+        log_with_metadata(Rhales.logger, :error, 'Circular dependency detected',
+          template: template_name,
+          dependency_chain: @loading.to_a,
+          depth: depth
+        )
         raise CircularDependencyError, "Circular dependency detected: #{template_name} -> #{@loading.to_a.join(' -> ')}"
       end
 
-      # Skip if already loaded
-      return if @templates.key?(template_name)
+      # Skip if already loaded (cache hit)
+      if @templates.key?(template_name)
+        Rhales.logger.debug("Template cache hit: template=#{template_name}")
+        return
+      end
 
       @loading.add(template_name)
 
       begin
         # Load template using the provided loader
+        start_time = now_in_μs
         parser = @loader.call(template_name)
+        load_duration = now_in_μs - start_time
 
         unless parser
+          log_with_metadata(Rhales.logger, :error, 'Template not found',
+            template: template_name,
+            parent: parent_path,
+            depth: depth,
+            search_duration: load_duration
+          )
           raise TemplateNotFoundError, "Template not found: #{template_name}"
         end
 
@@ -111,15 +154,42 @@ module Rhales
         @dependencies[template_name] = []
 
         # Extract and load partials
-        extract_partials(parser).each do |partial_name|
+        partials = extract_partials(parser)
+
+        if partials.any?
+          log_with_metadata(Rhales.logger, :debug, 'Resolved partial',
+            template: template_name,
+            partials_found: partials,
+            partial_count: partials.size,
+            depth: depth,
+            load_duration: load_duration
+          )
+        end
+
+        partials.each do |partial_name|
           @dependencies[template_name] << partial_name
           load_template_recursive(partial_name, template_name)
         end
 
         # Load layout if specified and not already loaded
         if parser.layout && !@templates.key?(parser.layout)
+          log_with_metadata(Rhales.logger, :debug, 'Layout resolution',
+            template: template_name,
+            layout: parser.layout,
+            depth: depth
+          )
           load_template_recursive(parser.layout, template_name)
         end
+
+        # Log successful template load
+        log_with_metadata(Rhales.logger, :debug, 'Template loaded',
+          template: template_name,
+          parent: parent_path,
+          depth: depth,
+          has_partials: partials.any?,
+          has_layout: !parser.layout.nil?,
+          load_duration: load_duration
+        )
       ensure
         @loading.delete(template_name)
       end

data/lib/rhales/core.rb

@@ -0,0 +1,9 @@
+# lib/rhales/core.rb
+#
+# frozen_string_literal: true
+
+require_relative 'core/context'
+require_relative 'core/rue_document'
+require_relative 'core/template_engine'
+require_relative 'core/view_composition'
+require_relative 'core/view'

data/lib/rhales/errors/hydration_collision_error.rb

@@ -1,4 +1,6 @@
 # lib/rhales/errors/hydration_collision_error.rb
+#
+# frozen_string_literal: true
 
 module Rhales
   class HydrationCollisionError < Error

data/lib/rhales/errors.rb

@@ -1,4 +1,6 @@
 # lib/rhales/errors.rb
+#
+# frozen_string_literal: true
 
 module Rhales
   class Error < StandardError; end

data/lib/rhales/{earliest_injection_detector.rb → hydration/earliest_injection_detector.rb}

@@ -1,3 +1,7 @@
+# lib/rhales/hydration/earliest_injection_detector.rb
+#
+# frozen_string_literal: true
+
 require 'strscan'
 require_relative 'safe_injection_validator'
 
@@ -22,6 +26,8 @@ module Rhales
     def detect(template_html)
       scanner = StringScanner.new(template_html)
       validator = SafeInjectionValidator.new(template_html)
+      # Build byte-to-char map once for the entire template
+      @byte_to_char_map = build_byte_to_char_map(template_html)
 
       # Try head section injection points first
       head_injection_point = detect_head_injection_point(scanner, validator, template_html)
@@ -64,7 +70,9 @@ module Rhales
 
       # Find opening <body> tag
       if scanner.scan_until(/<body\b[^>]*>/i)
-        body_start = scanner.pos - scanner.matched.length
+        # Convert byte position to character position using pre-built map
+        byte_body_start = scanner.pos - scanner.matched.length
+        body_start = @byte_to_char_map[byte_body_start]
         safe_position = find_safe_injection_position(validator, body_start)
         return safe_position if safe_position
       end
@@ -77,11 +85,15 @@ module Rhales
 
       # Find opening <head> tag
       return nil unless scanner.scan_until(/<head\b[^>]*>/i)
-      head_start = scanner.pos
+      # Convert byte position to character position using pre-built map
+      byte_head_start = scanner.pos
+      head_start = @byte_to_char_map[byte_head_start]
 
       # Find closing </head> tag
       return nil unless scanner.scan_until(/<\/head>/i)
-      head_end = scanner.pos - scanner.matched.length
+      # Convert byte position to character position using pre-built map
+      byte_head_end = scanner.pos - scanner.matched.length
+      head_end = @byte_to_char_map[byte_head_end]
 
       [head_start, head_end]
     end
@@ -90,9 +102,13 @@ module Rhales
       head_content = template_html[head_start...head_end]
       scanner = StringScanner.new(head_content)
       last_link_end = nil
+      byte_to_char_map = build_byte_to_char_map(head_content)
 
       while scanner.scan_until(/<link\b[^>]*\/?>/i)
-        last_link_end = scanner.pos
+        # scanner.pos is byte position within head_content
+        byte_pos = scanner.pos
+        # Convert to character position using pre-built map
+        last_link_end = byte_to_char_map[byte_pos]
       end
 
       last_link_end ? head_start + last_link_end : nil
@@ -102,9 +118,13 @@ module Rhales
       head_content = template_html[head_start...head_end]
       scanner = StringScanner.new(head_content)
       last_meta_end = nil
+      byte_to_char_map = build_byte_to_char_map(head_content)
 
       while scanner.scan_until(/<meta\b[^>]*\/?>/i)
-        last_meta_end = scanner.pos
+        # scanner.pos is byte position within head_content
+        byte_pos = scanner.pos
+        # Convert to character position using pre-built map
+        last_meta_end = byte_to_char_map[byte_pos]
       end
 
       last_meta_end ? head_start + last_meta_end : nil
@@ -113,14 +133,18 @@ module Rhales
     def find_after_first_script(template_html, head_start, head_end)
       head_content = template_html[head_start...head_end]
       scanner = StringScanner.new(head_content)
+      byte_to_char_map = build_byte_to_char_map(head_content)
 
       # Find first script opening tag
       if scanner.scan_until(/<script\b[^>]*>/i)
-        script_start = scanner.pos - scanner.matched.length
+        # Only the script end position is needed for this method, not the start position
 
         # Find corresponding closing tag
         if scanner.scan_until(/<\/script>/i)
-          first_script_end = scanner.pos
+          # scanner.pos is byte position within head_content
+          byte_script_end = scanner.pos
+          # Convert to character position using pre-built map
+          first_script_end = byte_to_char_map[byte_script_end]
           return head_start + first_script_end
         end
       end
@@ -145,5 +169,43 @@ module Rhales
       # No safe position found
       nil
     end
+
+    # Builds a mapping from byte positions to character positions for efficient
+    # conversion when processing UTF-8 strings with StringScanner.
+    #
+    # This method creates a hash where keys are byte positions and values are
+    # the corresponding character positions. For multibyte UTF-8 characters,
+    # only the starting byte position has an entry in the map.
+    #
+    # @param str [String] The UTF-8 encoded string to map
+    # @return [Hash<Integer, Integer>] A hash mapping byte positions to character positions
+    #
+    # @example ASCII string
+    #   build_byte_to_char_map("Hello")
+    #   # => {0=>0, 1=>1, 2=>2, 3=>3, 4=>4, 5=>5}
+    #
+    # @example UTF-8 with multibyte characters
+    #   build_byte_to_char_map("café")  # é is 2 bytes
+    #   # => {0=>0, 1=>1, 2=>2, 3=>3, 5=>4}  # Note: byte 4 is continuation byte
+    #
+    def build_byte_to_char_map(str)
+      map = {}
+      char_pos = 0
+      byte_pos = 0
+
+      # Iterate through each character (not byte) in the string
+      str.each_char do |char|
+        # Map the starting byte position of this character
+        map[byte_pos] = char_pos
+
+        # Advance byte position by the byte size of this character
+        byte_pos += char.bytesize
+        char_pos += 1
+      end
+
+      # Add final mapping for the end of the string
+      map[byte_pos] = char_pos
+      map
+    end
   end
 end