pretty_irb 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de7427c34f3650136e317c86f5b32d53a24c4a883c4f3c70dc07684653cab46b
-  data.tar.gz: 258568ee7bc6cc9d42c20d56f7ad80ca16f0a7c63b3b303f0823f405ac67cfaa
+  metadata.gz: 95ec3de4041e5f89096a2fe2f3a2c34506bde577008b8539d6d5459067d0b360
+  data.tar.gz: 2277edc3c5e7913d3537b219e77bc0f0fd85d33c47a259bcc50a57f84f542296
 SHA512:
-  metadata.gz: 3cc973dea626a8ee900e7fbbf26b62d4a941a00fb0f95b137bad0d388c0989e6cfec92d33a35d707f37ddfaac64c24dbe2b5ab8b31ab2b5c48d6c14324368a2e
-  data.tar.gz: 02f2fcd034a86279c301c20497d0fdba10672e528a3df3026c1b6ac173beb13199a0332341ef67f141c92c034bfc23ba5622376f9db61ba8fd2ccca9bd38ac94
+  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/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

@@ -3,27 +3,33 @@ require "rouge"
 
 module PrettyIRB
   class Formatter
+    INLINE_MAX_WIDTH = 72
+    MAX_COLLECTION_ITEMS = 30
+
     class << self
-      # "=> value" — identical to how IRB shows results
+      # Muted "=> " indicator so the returned value stands out clearly.
       def format_result(output)
-        "=> ".white + format_output(output)
+        color("=> ", :light_black) + format_output(output)
       rescue
         "=> #{output}"
       end
 
-      def format_output(value)
+      def format_output(value, indent: 0)
         case value
-        when String      then value.inspect.light_yellow
-        when Integer     then value.to_s.light_green
-        when Float       then value.to_s.light_green
-        when Numeric     then value.to_s.light_green
-        when TrueClass   then "true".cyan
-        when FalseClass  then "false".cyan
-        when NilClass    then "nil".light_black
-        when Symbol      then value.inspect.light_magenta
-        when Array       then format_array(value)
-        when Hash        then format_hash(value)
-        else                  value.inspect.white
+        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
@@ -31,6 +37,8 @@ module PrettyIRB
 
       # 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))
@@ -38,52 +46,156 @@ module PrettyIRB
         code
       end
 
-      # "ErrorType: message" — red type, dim message
+      # "ErrorType: message" — bold red type, crisp light-red detail
       def format_error(type, message = nil)
-        if message
-          type.red.bold + ": ".red + message.light_red
+        if colorize?
+          message ? type.red.bold + ": ".red + message.light_red : type.red.bold
         else
-          type.red.bold
+          message ? "#{type}: #{message}" : type.to_s
         end
       rescue
         "#{type}: #{message}"
       end
 
       def format_success(message)
-        message.green
+        color(message, :green)
       rescue
         message
       end
 
       def format_warning(message)
-        message.yellow
+        color(message, :yellow)
       rescue
         message
       end
 
       private
 
-      def format_array(arr)
-        return "[]".white if arr.empty?
+      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 = arr.first(30).map { |v| format_output(v) }
-        items << "…  (#{arr.length} total)".light_black if arr.length > 30
-        "[".white + items.join(", ".white) + "]".white
+        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)
-        return "{}".white if hash.empty?
+      def format_hash(hash, indent: 0)
+        return color("{}", :light_black) if hash.empty?
 
-        pairs = hash.first(30).map do |k, v|
-          format_output(k) + " => ".white + format_output(v)
+        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 << "…  (#{hash.length} total)".light_black if hash.length > 30
-        "{".white + pairs.join(", ".white) + "}".white
+        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

data/lib/pretty_irb/history_manager.rb

@@ -19,6 +19,13 @@ module PrettyIRB
       }
     end
 
+    # Attach an error message to the most recent history entry
+    def record_error(error_message)
+      return if @entries.empty?
+
+      @entries.last[:error] = error_message
+    end
+
     # Search history by keyword
     def search(keyword)
       results = @entries.select { |entry| entry[:code].include?(keyword) }
@@ -51,8 +58,13 @@ module PrettyIRB
     # Export history to file
     def export(filename)
       path = File.expand_path(filename.to_s)
-      # Refuse paths that point at system-sensitive locations
-      if path.start_with?("/etc", "/sys", "/proc", "/dev")
+      # Refuse paths that point at system-sensitive locations (Unix and Windows)
+      normalized = path.tr('\\', '/')
+      unix_sensitive    = %w[/etc /sys /proc /dev]
+      windows_sensitive = %w[C:/Windows C:/Program]
+      blocked = unix_sensitive.any? { |p| normalized.start_with?(p) } ||
+                windows_sensitive.any? { |p| normalized.start_with?(p) }
+      if blocked
         return "❌ Refusing to write to system path: #{path}"
       end
       File.write(path, format_for_export)