pretty_irb 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30ecfb0481118f36e1674ff5dd9174fbd1e678b50743a6ea03cab465dd2c800e
-  data.tar.gz: a5fd1711ecdd51ee203546ea3a12f96b5a2ec268e4711c85f1ea0045e55311e2
+  metadata.gz: 95ec3de4041e5f89096a2fe2f3a2c34506bde577008b8539d6d5459067d0b360
+  data.tar.gz: 2277edc3c5e7913d3537b219e77bc0f0fd85d33c47a259bcc50a57f84f542296
 SHA512:
-  metadata.gz: 2d45064a505563e76cc975821c9caf2745885306a50e450e6dafebce7c9ec73270a37201151436db83caf1fe67502bcb8763e216910828b48fd2da6a9095e965
-  data.tar.gz: 64623e8b5a19298cdb41808c38be3b9f241bd9133b5b0b0354851c7f100a98e5db56ddca2e501ff7ef61f59e637e5f270a3d7045cbe7b95da2bc4eba18fe50a3
+  metadata.gz: a7257181d6bf2c0a01212c13cc1ddee99ddda9f2b41131e9ae40b93b1979039b090921494dcd566bfc4d01583e831f37f75812729b008d1f88363f4bc213bb40
+  data.tar.gz: b3795b0bcd2e5d7a8ddb5a6bed472b92fd43dbad7f34342bc72709b90ebe95852d986341e7726ad99d3ced9a61a73b5bd8021c5a5de05f6b9732781fa37b6d1f

data/CHANGELOG.md

@@ -5,6 +5,15 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.4] - 2026-11-11
+
+### Added
+- **Rails 7+ Console Integration (`PrettyIRB::Railtie`)** - Automatically wires `config.console` in `rails c` across Rails 7.0, 7.1, 7.2, and 8.x while preserving `reload!`, `app`, `helper`, `controller`, `Rails.backtrace_cleaner`, and `--sandbox`, plus `DISABLE_PRETTY_IRB=1` opt-out
+- **Configuration API (`PrettyIRB::Configuration`)** - Supports `PrettyIRB.configure` and Rails `config.pretty_irb` toggles (`colorize`, `syntax_highlight`, `auto_correct`, `banner`, `rails_env_prompt`)
+- **Terminal UI Toolkit (`PrettyIRB::UI`)** - ANSI-aware alignment, rounded banner/command cards, environment badges (`dev`, `test`, bold red `PROD`, `SANDBOX`), and column-aligned multiline prompt rails
+- **ActiveRecord & Struct Formatting** - Multi-line attribute formatting for `ActiveRecord::Base` and bounded `.limit(31)` formatting for `ActiveRecord::Relation`
+- **Exception Hints & Error History** - `ExceptionHook` on `IRB::Irb#handle_exception` records runtime errors in `HistoryManager` and provides non-duplicate typo / nil-receiver / syntax suggestions
+
 ## [0.1.0] - 2025-11-27
 
 ### Added

data/lib/pretty_irb/ai_helper.rb

@@ -286,13 +286,13 @@ module PrettyIRB
 
       def example_loops
         <<~EXAMPLES
-          📚 Loop Examples:
+          📚 Loops and Iteration Examples:
           
           Using each:
             [1, 2, 3].each { |x| puts x }
             
           Using times:
-            5.times { |i| puts "Number #{i}" }
+            5.times { |i| puts "Number \#{i}" }
             
           Using while:
             i = 0
@@ -707,7 +707,7 @@ module PrettyIRB
 
       def general_best_practices
         <<~PRACTICES
-          ✅ General Best Practices:
+          ✅ General Ruby Best Practices:
           
           Code Quality:
             • DRY: Don't Repeat Yourself

data/lib/pretty_irb/auto_corrector.rb

@@ -1,76 +1,87 @@
-module PrettyIRB
-  class AutoCorrector
-    class << self
-      # Suggest corrections for common Ruby mistakes
-      def suggest_corrections(error)
-        case error
-        when NameError
-          suggest_name_error(error)
-        when NoMethodError
-          suggest_method_error(error)
-        when SyntaxError
-          suggest_syntax_error(error)
-        else
-          ""
-        end
-      rescue
-        ""
-      end
-
-      # Auto-correct common typos in code
-      def auto_correct_code(code)
-        code = fix_method_names(code)
-        code
-      rescue
-        code
-      end
-
-      private
-
-      def suggest_name_error(error)
-        # Try to get corrections, but safely
-        begin
-          if error.respond_to?(:corrections)
-            corrections = error.corrections
-            if corrections.is_a?(Array) && corrections.length > 0
-              "\n💡 Did you mean?: #{corrections.join(', ')}"
-            else
-              ""
-            end
-          else
-            ""
-          end
-        rescue
-          ""
-        end
-      end
-
-      def suggest_method_error(error)
-        begin
-          if error.respond_to?(:corrections)
-            corrections = error.corrections
-            if corrections.is_a?(Array) && corrections.length > 0
-              "\n💡 Did you mean?: #{corrections.join(', ')}"
-            else
-              ""
-            end
-          else
-            ""
-          end
-        rescue
-          ""
-        end
-      end
-
-      def suggest_syntax_error(error)
-        ""
-      end
-
-      def fix_method_names(code)
-        # Common method name corrections
-        code.gsub(/\.lenght/, ".length")
-           .gsub(/\.sizze/, ".size")
-      end
-    end
-  end
-end
+module PrettyIRB
+  class AutoCorrector
+    COMMON_METHOD_TYPOS = {
+      "lenght" => "length",
+      "sizze"  => "size",
+      "empyt?" => "empty?",
+      "nil"    => "nil?",
+      "to_str" => "to_s",
+      "to_int" => "to_i"
+    }.freeze
+
+    class << self
+      # Suggest corrections for common Ruby mistakes
+      def suggest_corrections(error)
+        case error
+        when NameError
+          suggest_name_or_method_error(error)
+        when SyntaxError
+          suggest_syntax_error(error)
+        else
+          ""
+        end
+      rescue
+        ""
+      end
+
+      # Auto-correct common typos in code
+      def auto_correct_code(code)
+        fix_method_names(code)
+      rescue
+        code
+      end
+
+      private
+
+      def suggest_name_or_method_error(error)
+        hints = []
+
+        if error.respond_to?(:corrections)
+          corrections = begin
+            error.corrections
+          rescue ArgumentError
+            nil
+          end
+          if corrections.is_a?(Array) && !corrections.empty?
+            hints << "Did you mean?: #{corrections.join(', ')}"
+          end
+        end
+
+        if error.is_a?(NoMethodError)
+          method_name = error.name.to_s
+          if (replacement = COMMON_METHOD_TYPOS[method_name])
+            hints << "Did you mean `.#{replacement}`?"
+          end
+
+          nil_receiver = begin
+            error.respond_to?(:receiver) && error.receiver.nil?
+          rescue ArgumentError
+            false
+          end
+
+          if nil_receiver && !method_name.empty?
+            hints << "Receiver is nil — check initialization or use safe navigation (`&.#{method_name}`)"
+          end
+        end
+
+        hints.empty? ? "" : "\n💡 #{hints.uniq.join(' · ')}"
+      end
+
+      def suggest_syntax_error(error)
+        msg = error.message.to_s
+        if msg.include?("unexpected end-of-input") || msg.include?("unterminated")
+          "\n💡 Check for a missing `end`, closing bracket, or closing quote."
+        elsif msg.include?("unexpected `end'") || msg.include?("unexpected end")
+          "\n💡 Extra `end` detected — check block/method nesting."
+        else
+          ""
+        end
+      end
+
+      def fix_method_names(code)
+        code.gsub(/\.lenght\b/, ".length")
+            .gsub(/\.sizze\b/, ".size")
+      end
+    end
+  end
+end

data/lib/pretty_irb/benchmarker.rb

@@ -2,77 +2,79 @@ require "benchmark"
 
 module PrettyIRB
   class Benchmarker
-    # Benchmark a code snippet
-    def self.benchmark(code, iterations = 1000)
-      begin
-        time = Benchmark.measure do
-          iterations.times do
-            eval(code)
-          end
+    # Benchmark a code snippet, optionally with caller's binding for variable access
+    def self.benchmark(code, iterations = 1000, binding = nil)
+      time = Benchmark.measure do
+        iterations.times do
+          binding ? eval(code, binding) : eval(code)
         end
+      end
 
-        total_ms = time.real * 1000
-        per_iteration_us = (total_ms * 1000) / iterations
+      total_ms = time.real * 1000
+      per_iteration_us = (total_ms * 1000).to_f / iterations
 
-        format_benchmark_result(code, iterations, total_ms, per_iteration_us)
-      rescue => e
-        "❌ Benchmark failed: #{e.message}"
-      end
+      format_benchmark_result(code, iterations, total_ms, per_iteration_us)
+    rescue => e
+      "❌ Benchmark failed: #{e.message}"
     end
 
     # Compare two code snippets
-    def self.compare(code1, code2, iterations = 1000)
-      begin
-        time1 = Benchmark.measure do
-          iterations.times { eval(code1) }
-        end
-
-        time2 = Benchmark.measure do
-          iterations.times { eval(code2) }
-        end
+    def self.compare(code1, code2, iterations = 1000, binding = nil)
+      time1 = Benchmark.measure do
+        iterations.times { binding ? eval(code1, binding) : eval(code1) }
+      end
 
-        format_comparison(code1, code2, time1, time2, iterations)
-      rescue => e
-        "❌ Comparison failed: #{e.message}"
+      time2 = Benchmark.measure do
+        iterations.times { binding ? eval(code2, binding) : eval(code2) }
       end
+
+      format_comparison(code1, code2, time1, time2, iterations)
+    rescue => e
+      "❌ Comparison failed: #{e.message}"
     end
 
     # Profile memory
-    def self.profile_memory(code, iterations = 100)
-      begin
-        gc_stat_before = GC.stat
-        
-        iterations.times { eval(code) }
-        
-        gc_stat_after = GC.stat
-
-        format_memory_profile(gc_stat_before, gc_stat_after, iterations)
-      rescue => e
-        "❌ Memory profile failed: #{e.message}"
-      end
+    def self.profile_memory(code, iterations = 100, binding = nil)
+      gc_stat_before = GC.stat
+
+      iterations.times { binding ? eval(code, binding) : eval(code) }
+
+      gc_stat_after = GC.stat
+
+      format_memory_profile(gc_stat_before, gc_stat_after, iterations)
+    rescue => e
+      "❌ Memory profile failed: #{e.message}"
     end
 
     private
 
+    def self.truncate(str, max)
+      str.length > max ? str[0, max - 3] + "..." : str
+    end
+
     def self.format_benchmark_result(code, iterations, total_ms, per_iteration_us)
       output = "⏱️  Benchmark Results:\n\n"
-      output += "Code: #{code.truncate(50)}\n"
+      output += "Code: #{truncate(code, 50)}\n"
       output += "Iterations: #{iterations}\n\n"
       output += "Total Time: #{total_ms.round(2)} ms\n"
       output += "Per Iteration: #{per_iteration_us.round(4)} µs\n"
-      output += "Rate: #{(iterations / (total_ms / 1000)).round(0)} ops/sec\n"
+      output += "Rate: #{(iterations / (total_ms / 1000.0)).round(0)} ops/sec\n"
       output
     end
 
     def self.format_comparison(code1, code2, time1, time2, iterations)
-      ratio = time2.real / time1.real
-      faster = ratio < 1 ? "Code 2 is #{(1/ratio - 1) * 100}% faster" : "Code 1 is #{(ratio - 1) * 100}% faster"
+      ratio = time1.real > 0 ? time2.real / time1.real : 1.0
+      faster = if ratio < 1
+        "Code 2 is #{((1.0 / ratio - 1) * 100).round(1)}% faster"
+      else
+        "Code 1 is #{((ratio - 1) * 100).round(1)}% faster"
+      end
 
       output = "⚡ Comparison Results:\n\n"
       output += "Iterations: #{iterations}\n\n"
-      output += "Code 1 (#{code1.truncate(40)}):\n"
+      output += "Code 1 (#{truncate(code1, 40)}):\n"
       output += "  Time: #{(time1.real * 1000).round(2)} ms\n\n"
-      output += "Code 2 (#{code2.truncate(40)}):\n"
+      output += "Code 2 (#{truncate(code2, 40)}):\n"
       output += "  Time: #{(time2.real * 1000).round(2)} ms\n\n"
       output += "Winner: #{faster}\n"
       output
@@ -81,13 +83,14 @@ module PrettyIRB
     def self.format_memory_profile(before, after, iterations)
       allocated = after[:total_allocated_objects] - before[:total_allocated_objects]
       freed = after[:total_freed_objects] - before[:total_freed_objects]
+      net = allocated - freed
 
       output = "💾 Memory Profile:\n\n"
       output += "Iterations: #{iterations}\n\n"
       output += "Objects Allocated: #{allocated}\n"
       output += "Objects Freed: #{freed}\n"
-      output += "Net Objects: #{allocated - freed}\n"
-      output += "Per Iteration: #{((allocated - freed) / iterations).round(1)} objects\n"
+      output += "Net Objects: #{net}\n"
+      output += "Per Iteration: #{(net.to_f / iterations).round(2)} objects\n"
       output
     end
   end

data/lib/pretty_irb/configuration.rb

@@ -0,0 +1,40 @@
+module PrettyIRB
+  # Global and per-session configuration options for PrettyIRB.
+  class Configuration
+    attr_accessor :colorize, :syntax_highlight, :auto_correct, :banner, :rails_env_prompt
+
+    def initialize
+      @colorize         = true
+      @syntax_highlight = true
+      @auto_correct     = true
+      @banner           = true
+      @rails_env_prompt = true
+    end
+
+    # Return a duplicate configuration with any non-nil overrides applied.
+    def merge(overrides = {})
+      copy = dup
+      return copy if overrides.nil?
+
+      hash = overrides.respond_to?(:to_h) ? overrides.to_h : {}
+      hash.each do |key, value|
+        next if value.nil?
+
+        setter = "#{key}="
+        copy.public_send(setter, value) if copy.respond_to?(setter)
+      end
+      copy
+    end
+
+    def to_h
+      {
+        colorize: @colorize,
+        syntax_highlight: @syntax_highlight,
+        auto_correct: @auto_correct,
+        banner: @banner,
+        rails_env_prompt: @rails_env_prompt
+      }
+    end
+  end
+end
+

data/lib/pretty_irb/formatter.rb

@@ -1,66 +1,201 @@
-require "colorize"
-
-module PrettyIRB
-  class Formatter
-    class << self
-      # Pretty print output with colors
-      def format_output(output)
-        case output
-        when String
-          output.light_blue
-        when Numeric
-          output.to_s.light_green
-        when TrueClass, FalseClass
-          output.to_s.light_cyan
-        when NilClass
-          "nil".light_black
-        when Array
-          format_array(output)
-        when Hash
-          format_hash(output)
-        else
-          output.inspect.light_yellow
-        end
-      rescue
-        output.to_s
-      end
-
-      # Format error messages with pretty colors
-      def format_error(error_message)
-        error_message.red.bold
-      rescue
-        error_message
-      end
-
-      # Format success messages
-      def format_success(message)
-        message.green
-      rescue
-        message
-      end
-
-      # Format warning messages
-      def format_warning(message)
-        message.yellow
-      rescue
-        message
-      end
-
-      private
-
-      def format_array(array)
-        formatted = array.map { |item| format_output(item) }.join(", ")
-        "[#{formatted}]".light_blue
-      rescue
-        array.inspect
-      end
-
-      def format_hash(hash)
-        formatted = hash.map { |k, v| "#{format_output(k)}=>#{format_output(v)}" }.join(", ")
-        "{#{formatted}}".light_blue
-      rescue
-        hash.inspect
-      end
-    end
-  end
-end
+require "colorize"
+require "rouge"
+
+module PrettyIRB
+  class Formatter
+    INLINE_MAX_WIDTH = 72
+    MAX_COLLECTION_ITEMS = 30
+
+    class << self
+      # Muted "=> " indicator so the returned value stands out clearly.
+      def format_result(output)
+        color("=> ", :light_black) + format_output(output)
+      rescue
+        "=> #{output}"
+      end
+
+      def format_output(value, indent: 0)
+        case value
+        when String          then color(value.inspect, :light_yellow)
+        when Integer, Float  then color(value.to_s, :light_green)
+        when Numeric         then color(value.to_s, :light_green)
+        when TrueClass       then color("true", :cyan)
+        when FalseClass      then color("false", :cyan)
+        when NilClass        then color("nil", :light_black)
+        when Symbol          then color(value.inspect, :light_magenta)
+        when Regexp          then color(value.inspect, :light_red)
+        when Range           then color(value.inspect, :light_cyan)
+        when Class, Module   then color(value.inspect, :light_blue)
+        when Time            then color(value.inspect, :light_cyan)
+        when Array           then format_array(value, indent: indent)
+        when Hash            then format_hash(value, indent: indent)
+        else                      format_object(value, indent: indent)
+        end
+      rescue
+        value.to_s
+      end
+
+      # Rouge Monokai syntax highlight for Ruby code (used in history / snippets)
+      def highlight_code(code)
+        return code unless syntax_highlight? && colorize?
+
+        formatter = Rouge::Formatters::Terminal256.new(Rouge::Themes::Monokai.new)
+        lexer     = Rouge::Lexers::Ruby.new
+        formatter.format(lexer.lex(code))
+      rescue
+        code
+      end
+
+      # "ErrorType: message" — bold red type, crisp light-red detail
+      def format_error(type, message = nil)
+        if colorize?
+          message ? type.red.bold + ": ".red + message.light_red : type.red.bold
+        else
+          message ? "#{type}: #{message}" : type.to_s
+        end
+      rescue
+        "#{type}: #{message}"
+      end
+
+      def format_success(message)
+        color(message, :green)
+      rescue
+        message
+      end
+
+      def format_warning(message)
+        color(message, :yellow)
+      rescue
+        message
+      end
+
+      private
+
+      def colorize?
+        return true unless defined?(PrettyIRB) && PrettyIRB.respond_to?(:configuration)
+
+        PrettyIRB.configuration.colorize
+      end
+
+      def syntax_highlight?
+        return true unless defined?(PrettyIRB) && PrettyIRB.respond_to?(:configuration)
+
+        PrettyIRB.configuration.syntax_highlight
+      end
+
+      def color(text, style)
+        colorize? ? text.public_send(style) : text
+      end
+
+      def visible_length(text)
+        defined?(PrettyIRB::UI) ? PrettyIRB::UI.visible_length(text) : text.gsub(/\e\[[0-9;]*m/, "").length
+      end
+
+      def format_object(value, indent: 0)
+        return color(value.inspect, :light_cyan) if defined?(Date) && value.is_a?(Date)
+        return format_active_record_relation(value, indent: indent) if active_record_relation?(value)
+        return format_active_record_model(value, indent: indent) if active_record_model?(value)
+        return format_struct(value, indent: indent) if value.is_a?(Struct)
+
+        color(value.inspect, :white)
+      end
+
+      def active_record_relation?(value)
+        defined?(ActiveRecord::Relation) && value.is_a?(ActiveRecord::Relation)
+      end
+
+      def active_record_model?(value)
+        defined?(ActiveRecord::Base) && value.is_a?(ActiveRecord::Base) && value.respond_to?(:attributes)
+      end
+
+      def format_active_record_model(record, indent: 0)
+        attrs = record.attributes
+        klass = record.class.name || "ActiveRecord"
+        new_tag = record.respond_to?(:new_record?) && record.new_record? ? color(" (new)", :yellow) : ""
+        header = color("#<#{klass}", :light_cyan) + new_tag
+        closing = color(">", :light_cyan)
+
+        return "#{header} #{color('(no attributes)', :light_black)}#{closing}" if attrs.nil? || attrs.empty?
+
+        pairs = attrs.map { |k, v| color("#{k}: ", :light_black) + format_output(v, indent: indent + 1) }
+        join_collection(pairs, "#{header} ", closing, indent: indent, inline_limit: 3, inline_separator: ", ")
+      rescue
+        color(record.inspect, :white)
+      end
+
+      def format_active_record_relation(relation, indent: 0)
+        loaded = relation.respond_to?(:loaded?) && relation.loaded?
+        if loaded
+          all_records = relation.to_a
+          truncated   = all_records.length > MAX_COLLECTION_ITEMS
+          shown       = all_records.first(MAX_COLLECTION_ITEMS)
+          trunc_label = "… (#{all_records.length} total)"
+        else
+          fetched     = relation.limit(MAX_COLLECTION_ITEMS + 1).to_a
+          truncated   = fetched.length > MAX_COLLECTION_ITEMS
+          shown       = fetched.first(MAX_COLLECTION_ITEMS)
+          trunc_label = "… (showing first #{MAX_COLLECTION_ITEMS})"
+        end
+
+        header  = color("#<ActiveRecord::Relation [", :light_cyan)
+        closing = color("]>", :light_cyan)
+        return "#{header}#{closing}" if shown.empty?
+
+        items = shown.map { |rec| format_output(rec, indent: indent + 1) }
+        items << color(trunc_label, :light_black) if truncated
+
+        join_collection(items, header, closing, indent: indent)
+      rescue
+        color(relation.inspect, :white)
+      end
+
+      def format_struct(struct_obj, indent: 0)
+        name = struct_obj.class.name || "Struct"
+        pairs = struct_obj.to_h.map do |k, v|
+          color("#{k}: ", :light_black) + format_output(v, indent: indent + 1)
+        end
+        header  = color("#<struct #{name}", :light_cyan)
+        closing = color(">", :light_cyan)
+        join_collection(pairs, "#{header} ", closing, indent: indent, inline_limit: 4)
+      rescue
+        color(struct_obj.inspect, :white)
+      end
+
+      def format_array(arr, indent: 0)
+        return color("[]", :light_black) if arr.empty?
+
+        items = arr.first(MAX_COLLECTION_ITEMS).map { |v| format_output(v, indent: indent + 1) }
+        items << color("… (#{arr.length} total)", :light_black) if arr.length > MAX_COLLECTION_ITEMS
+
+        join_collection(items, color("[", :light_black), color("]", :light_black), indent: indent, inline_limit: 6)
+      rescue
+        arr.inspect
+      end
+
+      def format_hash(hash, indent: 0)
+        return color("{}", :light_black) if hash.empty?
+
+        pairs = hash.first(MAX_COLLECTION_ITEMS).map do |k, v|
+          format_output(k, indent: indent + 1) + color(" => ", :light_black) + format_output(v, indent: indent + 1)
+        end
+        pairs << color("… (#{hash.length} total)", :light_black) if hash.length > MAX_COLLECTION_ITEMS
+
+        join_collection(pairs, color("{", :light_black), color("}", :light_black), indent: indent, inline_limit: 4)
+      rescue
+        hash.inspect
+      end
+
+      def join_collection(entries, open_delim, close_delim, indent:, inline_limit: nil, inline_separator: ", ")
+        inline = "#{open_delim}#{entries.join(color(inline_separator, :light_black))}#{close_delim}"
+        if inline_limit && entries.length <= inline_limit && !inline.include?("\n") && visible_length(inline) <= INLINE_MAX_WIDTH
+          return inline
+        end
+
+        pad_inner = "  " * (indent + 1)
+        pad_outer = "  " * indent
+        body = entries.map { |entry| "#{pad_inner}#{entry}" }.join(color(",\n", :light_black))
+        "#{open_delim.rstrip}\n#{body}\n#{pad_outer}#{close_delim}"
+      end
+    end
+  end
+end