parsanol 1.3.4 → 1.3.7

data/lib/parsanol/interval_tree.rb

@@ -132,7 +132,10 @@ module Parsanol
 
       # Check right subtree
       # Only search right if intervals starting there could overlap
-      query_recursive(node.right, low, high, results) if node.right && node.low < high
+      if node.right && node.low < high
+        query_recursive(node.right, low, high,
+                        results)
+      end
     end
 
     # Find exact interval match
@@ -154,10 +157,16 @@ module Parsanol
       return nil if node.nil?
 
       # Recursively delete from left subtree
-      node.left = delete_overlapping_recursive(node.left, low, high, deleted) if node.left
+      if node.left
+        node.left = delete_overlapping_recursive(node.left, low, high,
+                                                 deleted)
+      end
 
       # Recursively delete from right subtree
-      node.right = delete_overlapping_recursive(node.right, low, high, deleted) if node.right
+      if node.right
+        node.right = delete_overlapping_recursive(node.right, low, high,
+                                                  deleted)
+      end
 
       # Check if current node overlaps
       if node.low < high && low < node.high

data/lib/parsanol/lazy_result.rb

@@ -85,10 +85,10 @@ module Parsanol
     # @yield [element] Each element
     # @return [Enumerator, self] Enumerator if no block, self otherwise
     #
-    def each(&block)
+    def each(&)
       return to_enum(:each) unless block_given?
 
-      to_a.each(&block)
+      to_a.each(&)
       self
     end
 

data/lib/parsanol/mermaid.rb

@@ -16,7 +16,7 @@ module Parsanol
   # Generates Mermaid diagram syntax from parser atoms.
   class MermaidBuilder
     def initialize
-      @lines = ['graph TD']
+      @lines = ["graph TD"]
       @node_counter = 0
       @connections = []
       @seen_rules = Set.new
@@ -24,8 +24,8 @@ module Parsanol
 
     # Entry point for parser visualization
     def visit_parser(root_atom)
-      add_node('Parser', 'root')
-      traverse(root_atom, 'Parser')
+      add_node("Parser", "root")
+      traverse(root_atom, "Parser")
       finalize
     end
 
@@ -35,7 +35,7 @@ module Parsanol
 
       @seen_rules << rule_name
 
-      node_id = add_node(rule_name.to_s.upcase, 'rule')
+      node_id = add_node(rule_name.to_s.upcase, "rule")
       connect(current_parent, node_id)
       traverse(rule_block.call, node_id)
     end
@@ -67,18 +67,18 @@ module Parsanol
 
     # Leaf nodes
     def visit_re(regexp)
-      add_node("match(#{regexp.inspect})", 'terminal', style: 'ellipse')
+      add_node("match(#{regexp.inspect})", "terminal", style: "ellipse")
     end
 
     def visit_str(string)
-      add_node("'#{string}'", 'terminal', style: 'ellipse')
+      add_node("'#{string}'", "terminal", style: "ellipse")
     end
 
     private
 
     attr_reader :current_parent
 
-    def add_node(label, _shape_type = 'rect', _style = nil)
+    def add_node(label, _shape_type = "rect", _style = nil)
       @node_counter += 1
       node_id = "node_#{@node_counter}"
       @lines << "    #{node_id}[\"#{escape_mermaid(label)}\"]"
@@ -97,7 +97,7 @@ module Parsanol
       @connections.each do |from, to|
         @lines << "    #{from} --> #{to}"
       end
-      @lines << ''
+      @lines << ""
       @lines.join("\n")
     end
 
@@ -125,7 +125,10 @@ module Parsanol
     def mermaid_for_rule(rule_name)
       builder = MermaidBuilder.new
       rule_method = method(rule_name)
-      raise NotImplementedError, "Rule '#{rule_name}' not found" unless rule_method
+      unless rule_method
+        raise NotImplementedError,
+              "Rule '#{rule_name}' not found"
+      end
 
       rule_method.call.accept(builder)
       builder.output

data/lib/parsanol/native/batch_decoder.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'parsanol/native/transformer'
+require "parsanol/native/transformer"
 
 module Parsanol
   module Native
@@ -59,7 +59,7 @@ module Parsanol
         # @param slice_class [Class] The Slice class to use
         # @param grammar_atom [Parsanol::Atoms::Base] The grammar atom (unused, kept for API compat)
         # @return [Object] Transformed Ruby AST
-        def decode_and_flatten(data, input, slice_class, grammar_atom)
+        def decode_and_flatten(data, input, slice_class, _grammar_atom)
           # Check if data is batch data (flat u64 array) or already a Ruby value
           if data.is_a?(Integer) || (data.is_a?(Array) && data.first.is_a?(Integer))
             # Batch data (flat u64 array) - decode first, then transform
@@ -84,11 +84,13 @@ module Parsanol
           case value
           when Array
             # Recursively process array elements
-            processed = value.map { |v| join_consecutive_slices(v, slice_class, input) }
+            processed = value.map do |v|
+              join_consecutive_slices(v, slice_class, input)
+            end
 
             # Check if all non-nil elements are Slices
             non_nil = processed.compact
-            if non_nil.all? { |v| v.is_a?(slice_class) }
+            if non_nil.all?(slice_class)
               # Check if slices are consecutive
               if slices_consecutive?(non_nil)
                 # Join into single slice
@@ -129,7 +131,7 @@ module Parsanol
           last = slices.last
           total_length = last.offset + last.content.bytesize - first.offset
           content = input_bytes[first.offset, total_length]
-          content = content.force_encoding('UTF-8') if content
+          content = content.force_encoding("UTF-8") if content
           slice_class.new(first.offset, content, input)
         end
 
@@ -156,7 +158,7 @@ module Parsanol
             bits = @data[@pos]
             @pos += 1
             # Convert IEEE 754 bits to float
-            [bits].pack('Q').unpack1('D')
+            [bits].pack("Q").unpack1("D")
           when TAG_STRING
             offset = @data[@pos]
             length = @data[@pos + 1]
@@ -203,6 +205,7 @@ module Parsanol
 
             # Read key
             raise "Expected TAG_HASH_KEY, got #{tag}" unless tag == TAG_HASH_KEY
+
             @pos += 1
             key = decode_inline_string
 
@@ -228,22 +231,23 @@ module Parsanol
         def decode_inline_string_bytes(len)
           # Read u64 chunks
           chunks = (len + 7) / 8
-          bytes = String.new(encoding: 'ASCII-8BIT', capacity: len)
+          bytes = String.new(encoding: "ASCII-8BIT", capacity: len)
           chunks.times do
             chunk = @data[@pos]
             @pos += 1
             8.times do |byte_idx|
               break if bytes.bytesize >= len
+
               bytes << ((chunk >> (byte_idx * 8)) & 0xFF)
             end
           end
 
-          bytes.force_encoding('UTF-8')
+          bytes.force_encoding("UTF-8")
         end
 
         def create_slice(offset, length)
           content = @input_bytes[offset, length]
-          content = content.force_encoding('UTF-8') if content
+          content = content.force_encoding("UTF-8") if content
           @slice_class.new(offset, content, @input)
         end
       end

data/lib/parsanol/native/dynamic.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'json'
+require "json"
 
 module Parsanol
   module Native
@@ -49,13 +49,14 @@ module Parsanol
         #
         def register(block, description: nil)
           # Register with Rust FFI
-          ffi_id = Native.register_callback(@next_id, description || "Ruby callback ##{@next_id}")
+          ffi_id = Native.register_callback(@next_id,
+                                            description || "Ruby callback ##{@next_id}")
 
           # Also keep a Ruby-side reference for GC safety
           @mutex.synchronize do
             @callbacks[ffi_id] = {
               block: block,
-              description: description || "Ruby callback ##{ffi_id}"
+              description: description || "Ruby callback ##{ffi_id}",
             }
           end
 
@@ -136,7 +137,7 @@ module Parsanol
           ctx = DynamicContext.new(
             context[:input],
             context[:pos],
-            context[:captures].transform_keys(&:to_sym)
+            context[:captures].transform_keys(&:to_sym),
           )
 
           # Call the block
@@ -207,7 +208,7 @@ module Parsanol
       # @return [String] The remaining input
       #
       def remaining
-        @input[@pos..] || ''
+        @input[@pos..] || ""
       end
 
       # Check if at end of input
@@ -229,7 +230,7 @@ module Parsanol
         if length
           @input[@pos + start, length]
         else
-          @input[@pos + start..]
+          @input[(@pos + start)..]
         end
       end
     end

data/lib/parsanol/native/parser.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'digest'
+require "digest"
 
 module Parsanol
   module Native
@@ -16,7 +16,13 @@ module Parsanol
           return @cached_available unless @cached_available.nil?
 
           @cached_available = begin
-            require 'parsanol/parsanol_native'
+            # Try versioned path first (released gem), then non-versioned (local dev)
+            ruby_version = RUBY_VERSION.split(".").take(2).join(".")
+            begin
+              require "parsanol/#{ruby_version}/parsanol_native"
+            rescue LoadError
+              require "parsanol/parsanol_native"
+            end
             Parsanol::Native.is_available
           rescue LoadError
             false
@@ -48,7 +54,7 @@ module Parsanol
         def cache_stats
           {
             hash_cache_size: GRAMMAR_HASH_CACHE.size,
-            grammar_cache_size: GRAMMAR_CACHE.size
+            grammar_cache_size: GRAMMAR_CACHE.size,
           }
         end
 
@@ -64,6 +70,7 @@ module Parsanol
           if visited[obj_id]
             return [:cycle, atom.class.name]
           end
+
           visited[obj_id] = true
 
           case atom
@@ -83,7 +90,8 @@ module Parsanol
           when ::Parsanol::Atoms::Named
             [:named, atom.name.to_s, atom_structure(atom.parslet, visited)]
           when ::Parsanol::Atoms::Lookahead
-            [:lookahead, atom.positive, atom_structure(atom.bound_parslet, visited)]
+            [:lookahead, atom.positive,
+             atom_structure(atom.bound_parslet, visited)]
           else
             [:unknown, atom.class.name]
           end

data/lib/parsanol/native/serializer.rb

@@ -78,9 +78,9 @@ module Parsanol
 
     def serialize_str(atom)
       {
-        'Str' => {
-          'pattern' => atom.str
-        }
+        "Str" => {
+          "pattern" => atom.str,
+        },
       }
     end
 
@@ -90,46 +90,46 @@ module Parsanol
       pattern = atom.match
       pattern = ::Regexp.last_match(1) if pattern =~ /^\(\?[-mix]*:(.+)\)$/
       {
-        'Re' => {
-          'pattern' => pattern
-        }
+        "Re" => {
+          "pattern" => pattern,
+        },
       }
     end
 
     def serialize_sequence(atom)
       atom_ids = atom.parslets.map { |p| serialize_atom(p) }
       {
-        'Sequence' => {
-          'atoms' => atom_ids
-        }
+        "Sequence" => {
+          "atoms" => atom_ids,
+        },
       }
     end
 
     def serialize_alternative(atom)
       atom_ids = atom.alternatives.map { |p| serialize_atom(p) }
       {
-        'Alternative' => {
-          'atoms' => atom_ids
-        }
+        "Alternative" => {
+          "atoms" => atom_ids,
+        },
       }
     end
 
     def serialize_repetition(atom)
       {
-        'Repetition' => {
-          'atom' => serialize_atom(atom.parslet),
-          'min' => atom.min,
-          'max' => atom.max
-        }
+        "Repetition" => {
+          "atom" => serialize_atom(atom.parslet),
+          "min" => atom.min,
+          "max" => atom.max,
+        },
       }
     end
 
     def serialize_named(atom)
       {
-        'Named' => {
-          'name' => atom.name.to_s,
-          'atom' => serialize_atom(atom.parslet)
-        }
+        "Named" => {
+          "name" => atom.name.to_s,
+          "atom" => serialize_atom(atom.parslet),
+        },
       }
     end
 
@@ -169,7 +169,7 @@ module Parsanol
                        serialize_named(parslet)
                      when Parsanol::Atoms::Entity
                        # Nested entity - just reference it via serialize_atom
-                       { 'Entity' => { 'atom' => serialize_atom(parslet) } }
+                       { "Entity" => { "atom" => serialize_atom(parslet) } }
                      when Parsanol::Atoms::Lookahead
                        serialize_lookahead(parslet)
                      else
@@ -181,9 +181,9 @@ module Parsanol
       else
         # If the entity's block returns nil, create a placeholder that will fail
         @atoms[atom_id] = {
-          'Str' => {
-            'pattern' => "\x00__UNIMPLEMENTED_ENTITY_#{atom.name}__"
-          }
+          "Str" => {
+            "pattern" => "\x00__UNIMPLEMENTED_ENTITY_#{atom.name}__",
+          },
         }
       end
       atom_id
@@ -191,10 +191,10 @@ module Parsanol
 
     def serialize_lookahead(atom)
       {
-        'Lookahead' => {
-          'atom' => serialize_atom(atom.bound_parslet),
-          'positive' => atom.positive
-        }
+        "Lookahead" => {
+          "atom" => serialize_atom(atom.bound_parslet),
+          "positive" => atom.positive,
+        },
       }
     end
 
@@ -202,10 +202,10 @@ module Parsanol
       # Capture stores matched text for later reference by Dynamic atoms.
       # Now properly serialized for native parser support (parsanol-rs 0.3.0+).
       {
-        'Capture' => {
-          'name' => atom.capture_key.to_s,
-          'atom' => serialize_atom(atom.inner_atom)
-        }
+        "Capture" => {
+          "name" => atom.capture_key.to_s,
+          "atom" => serialize_atom(atom.inner_atom),
+        },
       }
     end
 
@@ -220,9 +220,9 @@ module Parsanol
       return serialize_unknown(atom) unless inner
 
       {
-        'Scope' => {
-          'atom' => serialize_atom(inner)
-        }
+        "Scope" => {
+          "atom" => serialize_atom(inner),
+        },
       }
     end
 
@@ -232,9 +232,9 @@ module Parsanol
       callback_id = Parsanol::Native::Dynamic.register(atom.block)
 
       {
-        'Dynamic' => {
-          'callback_id' => callback_id
-        }
+        "Dynamic" => {
+          "callback_id" => callback_id,
+        },
       }
     end
 
@@ -242,9 +242,9 @@ module Parsanol
       # For unsupported atom types, create a placeholder
       # This will cause a parse error at runtime
       {
-        'Str' => {
-          'pattern' => '' # Empty pattern that will never match
-        }
+        "Str" => {
+          "pattern" => "", # Empty pattern that will never match
+        },
       }
     end
   end