lapsoss 0.1.0 → 0.3.0

data/lib/lapsoss/backtrace_frame.rb

@@ -1,258 +1,79 @@
 # frozen_string_literal: true
 
 module Lapsoss
-  class BacktraceFrame
-    # Backtrace line patterns for different Ruby implementations
-    BACKTRACE_PATTERNS = [
-      # Standard Ruby format: filename.rb:123:in `method_name'
-      /^(?<filename>[^:]+):(?<line>\d+):in [`'](?<method>.*?)[`']$/,
-
-      # Ruby format without method: filename.rb:123
-      /^(?<filename>[^:]+):(?<line>\d+)$/,
-
-      # JRuby format: filename.rb:123:in method_name
-      /^(?<filename>[^:]+):(?<line>\d+):in (?<method>.*)$/,
-
-      # Eval'd code: (eval):123:in `method_name'
-      /^\(eval\):(?<line>\d+):in [`'](?<method>.*?)[`']$/,
-
-      # Block format: filename.rb:123:in `block in method_name'
-      /^(?<filename>[^:]+):(?<line>\d+):in [`']block (?<block_level>\(\d+\s+levels\)\s+)?in (?<method>.*?)[`']$/,
-
-      # Native extension format: [native_gem] filename.c:123:in `method_name'
-      /^\[(?<native_gem>[^\]]+)\]\s*(?<filename>[^:]+):(?<line>\d+):in [`'](?<method>.*?)[`']$/,
-
-      # Java backtrace format: org.jruby.Ruby.runScript(Ruby.java:123)
-      /^(?<method>[^(]+)\((?<filename>[^:)]+):(?<line>\d+)\)$/,
-
-      # Java backtrace format without line number: org.jruby.Ruby.runScript(Ruby.java)
-      /^(?<method>[^(]+)\((?<filename>[^:)]+)\)$/,
-
-      # Malformed Ruby format with invalid line number: filename.rb:abc:in `method'
-      /^(?<filename>[^:]+):(?<line>[^:]*):in [`'](?<method>.*?)[`']$/,
-
-      # Malformed Ruby format with missing line number: filename.rb::in `method'
-      /^(?<filename>[^:]+)::in [`'](?<method>.*?)[`']$/,
-
-      # Malformed Ruby format with missing method: filename.rb:123:in
-      /^(?<filename>[^:]+):(?<line>\d+):in$/
-    ].freeze
-
-    # Common paths that indicate library/gem code
-    LIBRARY_INDICATORS = [
-      '/gems/',
-      '/.bundle/',
-      '/vendor/',
-      '/ruby/',
-      '(eval)',
-      '(irb)',
-      '/lib/ruby/',
-      '/rbenv/',
-      '/rvm/',
-      '/usr/lib/ruby',
-      '/System/Library/Frameworks'
-    ].freeze
-
-    attr_reader :filename, :line_number, :method_name, :in_app, :raw_line
-    attr_reader :function, :module_name, :code_context, :block_info
-
+  BacktraceFrame = Data.define(
+    :filename,
+    :line_number,
+    :method_name,
+    :in_app,
+    :raw_line,
+    :function,
+    :module_name,
+    :code_context,
+    :block_info
+  ) do
     # Backward compatibility aliases
     alias_method :lineno, :line_number
     alias_method :raw, :raw_line
 
-    def initialize(raw_line, in_app_patterns: [], exclude_patterns: [], load_paths: [])
-      @raw_line = raw_line.to_s.strip
-      @in_app_patterns = Array(in_app_patterns)
-      @exclude_patterns = Array(exclude_patterns)
-      @load_paths = Array(load_paths)
-
-      parse_backtrace_line
-      determine_app_status
-      normalize_paths
-    end
-
     def to_h
       {
-        filename: @filename,
-        line_number: @line_number,
-        method: @method_name,
-        function: @function,
-        module: @module_name,
-        in_app: @in_app,
-        code_context: @code_context,
-        raw: @raw_line
+        filename: filename,
+        line_number: line_number,
+        method: method_name,
+        function: function,
+        module: module_name,
+        in_app: in_app,
+        code_context: code_context,
+        raw: raw_line
       }.compact
     end
 
     def add_code_context(processor, context_lines = 3)
-      return unless @filename && @line_number && File.exist?(@filename)
+      return unless filename && line_number && File.exist?(filename)
 
-      @code_context = processor.get_code_context(@filename, @line_number, context_lines)
+      with(code_context: processor.get_code_context(filename, line_number, context_lines))
     end
 
     def valid?
-      @filename && (@line_number.nil? || @line_number >= 0)
+      filename && (line_number.nil? || line_number >= 0)
     end
 
     def library_frame?
-      !@in_app
+      !in_app
     end
 
     def app_frame?
-      @in_app
+      in_app
     end
 
-    def excluded?
-      return false if @exclude_patterns.empty?
+    def excluded?(exclude_patterns = [])
+      return false if exclude_patterns.empty?
 
-      @exclude_patterns.any? do |pattern|
+      exclude_patterns.any? do |pattern|
         case pattern
         when Regexp
-          @raw_line.match?(pattern)
+          raw_line.match?(pattern)
         when String
-          @raw_line.include?(pattern)
+          raw_line.include?(pattern)
         else
           false
         end
       end
     end
 
-    def relative_filename
-      return @filename unless @filename && @load_paths.any?
+    def relative_filename(load_paths = [])
+      return filename unless filename && load_paths.any?
 
       # Try to make path relative to load paths
-      @load_paths.each do |load_path|
-        if @filename.start_with?(load_path)
-          relative = @filename.sub(/^#{Regexp.escape(load_path)}\/?/, '')
+      load_paths.each do |load_path|
+        if filename.start_with?(load_path)
+          relative = filename.sub(%r{^#{Regexp.escape(load_path)}/?}, "")
           return relative unless relative.empty?
         end
       end
 
-      @filename
-    end
-
-    private
-
-    def parse_backtrace_line
-      BACKTRACE_PATTERNS.each_with_index do |pattern, pattern_index|
-        match = @raw_line.match(pattern)
-        next unless match
-
-        @filename = match[:filename]
-        # Handle malformed line numbers - convert invalid numbers to 0
-        if match.names.include?('line') && match[:line]
-          @line_number = match[:line].match?(/^\d+$/) ? match[:line].to_i : 0
-        else
-          @line_number = nil
-        end
-        @method_name = match.names.include?('method') ? match[:method] : nil
-        @native_gem = match.names.include?('native_gem') ? match[:native_gem] : nil
-        @block_level = match.names.include?('block_level') ? match[:block_level] : nil
-
-        # Set default method name for lines without methods (top-level execution)
-        @method_name = "<main>" if @method_name.nil?
-
-        process_method_info
-        return
-      end
-
-      # Fallback: treat entire line as filename if no pattern matches
-      @filename = @raw_line
-      @line_number = nil
-      @method_name = "<main>"
-    end
-
-    def process_method_info
-      return unless @method_name
-
-      # Extract module/class and method information
-      if @method_name.include?('.')
-        # Class method: Module.method
-        parts = @method_name.split('.', 2)
-        @module_name = parts[0] if parts[0] != @method_name
-        @function = parts[1] || @method_name
-      elsif @method_name.include?('#')
-        # Instance method: Module#method
-        parts = @method_name.split('#', 2)
-        @module_name = parts[0] if parts[0] != @method_name
-        @function = parts[1] || @method_name
-      elsif @method_name.start_with?('block')
-        # Block method: process specially
-        @function = @method_name
-        process_block_info
-      else
-        @function = @method_name
-      end
-
-      # Clean up function name
-      @function = @function&.strip
-      @module_name = @module_name&.strip
-    end
-
-    def process_block_info
-      return unless @method_name&.include?('block')
-
-      @block_info = {
-        type: :block,
-        level: @block_level,
-        in_method: nil
-      }
-
-      # Extract the method that contains the block
-      if @method_name.match(/block (?:\([^)]+\)\s+)?in (.+)/)
-        @block_info[:in_method] = $1
-      end
-    end
-
-    def determine_app_status
-      return @in_app = false unless @filename
-
-      # Check explicit patterns first
-      if @in_app_patterns.any?
-        @in_app = @in_app_patterns.any? do |pattern|
-          case pattern
-          when Regexp
-            @filename.match?(pattern)
-          when String
-            @filename.include?(pattern)
-          else
-            false
-          end
-        end
-        return
-      end
-
-      # Default heuristics: check for library indicators
-      @in_app = !LIBRARY_INDICATORS.any? { |indicator| @filename.include?(indicator) }
-
-      # Special cases
-      @in_app = false if @native_gem # Native extensions are not app code
-      @in_app = false if @filename.start_with?('(') && @filename.end_with?(')') # Eval, irb, etc.
-    end
-
-    def normalize_paths
-      return unless @filename
-
-      # Expand relative paths
-      if @filename.start_with?('./')
-        @filename = File.expand_path(@filename)
-      end
-
-      # Handle Windows paths on Unix systems (for cross-platform stack traces)
-      if @filename.include?('\\') && !@filename.include?('/')
-        @filename = @filename.tr('\\', '/')
-      end
-
-      # Strip load paths to make traces more readable
-      if @load_paths.any?
-        original = @filename
-        @filename = relative_filename
-
-        # Keep absolute path if relative didn't work well
-        if @filename.empty? || @filename == '.'
-          @filename = original
-        end
-      end
+      filename
     end
   end
 end

data/lib/lapsoss/backtrace_frame_factory.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  class BacktraceFrameFactory
+    # Backtrace line patterns for different Ruby implementations
+    BACKTRACE_PATTERNS = [
+      # Standard Ruby format: filename.rb:123:in `method_name'
+      /^(?<filename>[^:]+):(?<line>\d+):in [`'](?<method>.*?)[`']$/,
+
+      # Ruby format without method: filename.rb:123
+      /^(?<filename>[^:]+):(?<line>\d+)$/,
+
+      # JRuby format: filename.rb:123:in method_name
+      /^(?<filename>[^:]+):(?<line>\d+):in (?<method>.*)$/,
+
+      # Eval'd code: (eval):123:in `method_name'
+      /^\(eval\):(?<line>\d+):in [`'](?<method>.*?)[`']$/,
+
+      # Block format: filename.rb:123:in `block in method_name'
+      /^(?<filename>[^:]+):(?<line>\d+):in [`']block (?<block_level>\(\d+\s+levels\)\s+)?in (?<method>.*?)[`']$/,
+
+      # Native extension format: [native_gem] filename.c:123:in `method_name'
+      /^\[(?<native_gem>[^\]]+)\]\s*(?<filename>[^:]+):(?<line>\d+):in [`'](?<method>.*?)[`']$/,
+
+      # Java backtrace format: org.jruby.Ruby.runScript(Ruby.java:123)
+      /^(?<method>[^(]+)\((?<filename>[^:)]+):(?<line>\d+)\)$/,
+
+      # Java backtrace format without line number: org.jruby.Ruby.runScript(Ruby.java)
+      /^(?<method>[^(]+)\((?<filename>[^:)]+)\)$/,
+
+      # Malformed Ruby format with invalid line number: filename.rb:abc:in `method'
+      /^(?<filename>[^:]+):(?<line>[^:]*):in [`'](?<method>.*?)[`']$/,
+
+      # Malformed Ruby format with missing line number: filename.rb::in `method'
+      /^(?<filename>[^:]+)::in [`'](?<method>.*?)[`']$/,
+
+      # Malformed Ruby format with missing method: filename.rb:123:in
+      /^(?<filename>[^:]+):(?<line>\d+):in$/
+    ].freeze
+
+    # Common paths that indicate library/gem code
+    LIBRARY_INDICATORS = [
+      "/gems/",
+      "/.bundle/",
+      "/vendor/",
+      "/ruby/",
+      "(eval)",
+      "(irb)",
+      "/lib/ruby/",
+      "/rbenv/",
+      "/rvm/",
+      "/usr/lib/ruby",
+      "/System/Library/Frameworks"
+    ].freeze
+
+    def self.from_raw_line(raw_line, in_app_patterns: [], exclude_patterns: [], load_paths: [])
+      new(in_app_patterns: in_app_patterns, exclude_patterns: exclude_patterns, load_paths: load_paths)
+        .create_frame(raw_line)
+    end
+
+    def initialize(in_app_patterns: [], exclude_patterns: [], load_paths: [])
+      @in_app_patterns = Array(in_app_patterns)
+      @exclude_patterns = Array(exclude_patterns)
+      @load_paths = Array(load_paths)
+    end
+
+    def create_frame(raw_line)
+      @raw_line = raw_line.to_s.strip
+      parse_backtrace_line
+    end
+
+    private
+
+    def parse_backtrace_line
+      filename, line_number, method_name, function, module_name, block_info = parse_line_components
+
+      in_app = determine_app_status(filename)
+      filename = normalize_path(filename) if filename
+
+      BacktraceFrame.new(
+        filename: filename,
+        line_number: line_number,
+        method_name: method_name,
+        in_app: in_app,
+        raw_line: @raw_line,
+        function: function,
+        module_name: module_name,
+        code_context: nil,
+        block_info: block_info
+      )
+    end
+
+    def parse_line_components
+      BACKTRACE_PATTERNS.each do |pattern|
+        match = @raw_line.match(pattern)
+        next unless match
+
+        filename = match[:filename]
+        # Handle malformed line numbers - convert invalid numbers to 0
+        line_number = if match.names.include?("line") && match[:line]
+                        match[:line].match?(/^\d+$/) ? match[:line].to_i : 0
+        end
+        method_name = match.names.include?("method") ? match[:method] : nil
+        match.names.include?("native_gem") ? match[:native_gem] : nil
+        block_level = match.names.include?("block_level") ? match[:block_level] : nil
+
+        # Set default method name for lines without methods (top-level execution)
+        method_name = "<main>" if method_name.nil?
+
+        function, module_name, block_info = process_method_info(method_name, block_level)
+
+        return [ filename, line_number, method_name, function, module_name, block_info ]
+      end
+
+      # Fallback: treat entire line as filename if no pattern matches
+      [ @raw_line, nil, "<main>", "<main>", nil, nil ]
+    end
+
+    def process_method_info(method_name, block_level)
+      return [ nil, nil, nil ] unless method_name
+
+      function = nil
+      module_name = nil
+      block_info = nil
+
+      # Extract module/class and method information
+      if method_name.include?(".")
+        # Class method: Module.method
+        parts = method_name.split(".", 2)
+        module_name = parts[0] if parts[0] != method_name
+        function = parts[1] || method_name
+      elsif method_name.include?("#")
+        # Instance method: Module#method
+        parts = method_name.split("#", 2)
+        module_name = parts[0] if parts[0] != method_name
+        function = parts[1] || method_name
+      elsif method_name.start_with?("block")
+        # Block method: process specially
+        function = method_name
+        block_info = process_block_info(method_name, block_level)
+      else
+        function = method_name
+      end
+
+      # Clean up function name
+      function = function&.strip
+      module_name = module_name&.strip
+
+      [ function, module_name, block_info ]
+    end
+
+    def process_block_info(method_name, block_level)
+      return nil unless method_name&.include?("block")
+
+      block_info = {
+        type: :block,
+        level: block_level,
+        in_method: nil
+      }
+
+      # Extract the method that contains the block
+      block_info[:in_method] = ::Regexp.last_match(1) if method_name =~ /block (?:\([^)]+\)\s+)?in (.+)/
+
+      block_info
+    end
+
+    def determine_app_status(filename)
+      return false unless filename
+
+      # Check explicit patterns first
+      if @in_app_patterns.any?
+        return @in_app_patterns.any? do |pattern|
+          case pattern
+          when Regexp
+            filename.match?(pattern)
+          when String
+            filename.include?(pattern)
+          else
+            false
+          end
+        end
+      end
+
+      # Default heuristics: check for library indicators
+      in_app = LIBRARY_INDICATORS.none? { |indicator| filename.include?(indicator) }
+
+      # Special cases
+      in_app = false if filename.start_with?("(") && filename.end_with?(")") # Eval, irb, etc.
+
+      in_app
+    end
+
+    def normalize_path(filename)
+      return filename unless filename
+
+      # Expand relative paths
+      filename = File.expand_path(filename) if filename.start_with?("./")
+
+      # Handle Windows paths on Unix systems (for cross-platform stack traces)
+      filename = filename.tr("\\", "/") if filename.include?("\\") && filename.exclude?("/")
+
+      # Strip load paths to make traces more readable
+      return filename unless @load_paths.any?
+
+      original = filename
+      filename = make_relative_filename(filename)
+
+      # Keep absolute path if relative didn't work well
+      filename = original if filename.empty? || filename == "."
+
+      filename
+    end
+
+    def make_relative_filename(filename)
+      return filename unless filename && @load_paths.any?
+
+      # Try to make path relative to load paths
+      @load_paths.each do |load_path|
+        if filename.start_with?(load_path)
+          relative = filename.sub(%r{^#{Regexp.escape(load_path)}/?}, "")
+          return relative unless relative.empty?
+        end
+      end
+
+      filename
+    end
+  end
+end

data/lib/lapsoss/backtrace_processor.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
-require "set"
 require "active_support/cache"
 require "active_support/core_ext/numeric/time"
-require_relative "backtrace_frame"
 
 module Lapsoss
   class BacktraceProcessor
@@ -33,19 +31,19 @@ module Lapsoss
 
     def initialize(config = {})
       # Handle different config formats for backward compatibility
-      if config.respond_to?(:backtrace_context_lines)
-        # Configuration object passed
-        config_hash = {
-          context_lines: config.backtrace_context_lines,
-          max_frames: config.backtrace_max_frames,
-          enable_code_context: config.backtrace_enable_code_context,
-          in_app_patterns: config.backtrace_in_app_patterns,
-          exclude_patterns: config.backtrace_exclude_patterns,
-          strip_load_path: config.backtrace_strip_load_path
-        }
+      config_hash = if config.respond_to?(:backtrace_context_lines)
+                      # Configuration object passed
+                      {
+                        context_lines: config.backtrace_context_lines,
+                        max_frames: config.backtrace_max_frames,
+                        enable_code_context: config.backtrace_enable_code_context,
+                        in_app_patterns: config.backtrace_in_app_patterns,
+                        exclude_patterns: config.backtrace_exclude_patterns,
+                        strip_load_path: config.backtrace_strip_load_path
+                      }
       else
-        # Hash passed
-        config_hash = config
+                      # Hash passed
+                      config
       end
 
       @config = DEFAULT_CONFIG.merge(config_hash)
@@ -77,17 +75,20 @@ module Lapsoss
     end
 
     # Backward compatibility alias
-    alias_method :process, :process_backtrace
+    alias process process_backtrace
 
     def process_exception_backtrace(exception, follow_cause: false)
       return [] unless exception&.backtrace
 
       frames = process_backtrace(exception.backtrace)
 
-      # Add exception-specific context
-      frames.each_with_index do |frame, index|
-        frame.define_singleton_method(:crash_frame?) { index == 0 }
-        frame.define_singleton_method(:exception_class) { exception.class.name }
+      # Wrap frames with exception-specific context
+      frames = frames.map.with_index do |frame, index|
+        ExceptionBacktraceFrame.new(
+          frame,
+          exception_class: exception.class.name,
+          is_crash_frame: index.zero?
+        )
       end
 
       # Follow exception causes if requested
@@ -100,7 +101,7 @@ module Lapsoss
     end
 
     # Backward compatibility aliases
-    alias_method :process_exception, :process_exception_backtrace
+    alias process_exception process_exception_backtrace
 
     def clear_cache!
       @file_cache.clear
@@ -205,11 +206,11 @@ module Lapsoss
 
       # Convert to 0-based index
       line_index = line_number - 1
-      return nil if line_index < 0 || line_index >= lines.length
+      return nil if line_index.negative? || line_index >= lines.length
 
       # Calculate context range
-      start_line = [0, line_index - context_lines].max
-      end_line = [lines.length - 1, line_index + context_lines].min
+      start_line = [ 0, line_index - context_lines ].max
+      end_line = [ lines.length - 1, line_index + context_lines ].min
 
       {
         pre_context: lines[start_line...line_index],
@@ -235,7 +236,7 @@ module Lapsoss
     def parse_frames(backtrace)
       load_paths = determine_load_paths
       frames = backtrace.map do |line|
-        BacktraceFrame.new(
+        BacktraceFrameFactory.from_raw_line(
           line,
           in_app_patterns: @config[:in_app_patterns],
           exclude_patterns: @config[:exclude_patterns],
@@ -249,7 +250,7 @@ module Lapsoss
 
     def filter_frames(frames)
       # Remove excluded frames
-      frames = frames.reject(&:excluded?)
+      frames = frames.reject { |frame| frame.excluded?(@config[:exclude_patterns]) }
 
       # Filter gems if configured
       unless @config[:include_gems_in_context]
@@ -283,10 +284,10 @@ module Lapsoss
       head_frames = frames.first(head_count)
 
       # Get tail frames (original cause)
-      tail_frames = if tail_count > 0
-        frames.last(tail_count)
+      tail_frames = if tail_count.positive?
+                      frames.last(tail_count)
       else
-        []
+                      []
       end
 
       head_frames + tail_frames
@@ -297,8 +298,9 @@ module Lapsoss
       context_frames = frames.select(&:app_frame?)
       context_frames += frames.select(&:library_frame?).first(3)
 
-      context_frames.each do |frame|
-        frame.add_code_context(self, @config[:context_lines])
+      context_frames.each_with_index do |frame, _index|
+        updated_frame = frame.add_code_context(self, @config[:context_lines])
+        frames[frames.index(frame)] = updated_frame if updated_frame
       end
     end
 
@@ -306,7 +308,7 @@ module Lapsoss
       seen = Set.new
       frames.select do |frame|
         # Create a key based on filename, line, and method
-        key = [frame.filename, frame.line_number, frame.function].join(':')
+        key = [ frame.filename, frame.line_number, frame.function ].join(":")
 
         if seen.include?(key)
           false
@@ -326,18 +328,16 @@ module Lapsoss
       # Add common Rails paths if in Rails
       if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
         paths << Rails.root.to_s
-        paths << Rails.root.join('app').to_s
-        paths << Rails.root.join('lib').to_s
-        paths << Rails.root.join('config').to_s
+        paths << Rails.root.join("app").to_s
+        paths << Rails.root.join("lib").to_s
+        paths << Rails.root.join("config").to_s
       end
 
       # Add current working directory
       paths << Dir.pwd
 
       # Add gem paths
-      if defined?(Gem)
-        paths.concat(Gem.path.map { |p| File.join(p, 'gems') })
-      end
+      paths.concat(Gem.path.map { |p| File.join(p, "gems") }) if defined?(Gem)
 
       # Sort by length (longest first) for better matching
       paths.uniq.sort_by(&:length).reverse