rich-ruby 1.0.0

data/lib/rich/control.rb

@@ -0,0 +1,332 @@
+# frozen_string_literal: true
+
+module Rich
+  # Terminal control codes and escape sequences.
+  # Provides constants and methods for cursor movement, screen clearing,
+  # and other terminal control operations.
+  module Control
+    # Control code types for segment rendering
+    module ControlType
+      BELL                  = :bell
+      CARRIAGE_RETURN       = :carriage_return
+      HOME                  = :home
+      CLEAR                 = :clear
+      SHOW_CURSOR           = :show_cursor
+      HIDE_CURSOR           = :hide_cursor
+      ENABLE_ALT_SCREEN     = :enable_alt_screen
+      DISABLE_ALT_SCREEN    = :disable_alt_screen
+      CURSOR_UP             = :cursor_up
+      CURSOR_DOWN           = :cursor_down
+      CURSOR_FORWARD        = :cursor_forward
+      CURSOR_BACKWARD       = :cursor_backward
+      CURSOR_MOVE_TO_COLUMN = :cursor_move_to_column
+      CURSOR_MOVE_TO        = :cursor_move_to
+      ERASE_IN_LINE         = :erase_in_line
+      SET_WINDOW_TITLE      = :set_window_title
+    end
+
+    # ESC character for ANSI sequences
+    ESC = "\e"
+
+    # Control Sequence Introducer
+    CSI = "\e["
+
+    # Operating System Command
+    OSC = "\e]"
+
+    # String Terminator
+    ST = "\e\\"
+
+    # Bell character
+    BEL = "\a"
+
+    class << self
+      # Generate bell/alert
+      # @return [String]
+      def bell
+        BEL
+      end
+
+      # Carriage return (move to column 0)
+      # @return [String]
+      def carriage_return
+        "\r"
+      end
+
+      # Move cursor to home position (1,1)
+      # @return [String]
+      def home
+        "#{CSI}H"
+      end
+
+      # Clear the screen
+      # @param mode [Integer] 0=cursor to end, 1=start to cursor, 2=entire screen
+      # @return [String]
+      def clear(mode = 2)
+        "#{CSI}#{mode}J"
+      end
+
+      # Clear entire screen and move to home
+      # @return [String]
+      def clear_screen
+        "#{CSI}2J#{CSI}H"
+      end
+
+      # Show the cursor
+      # @return [String]
+      def show_cursor
+        "#{CSI}?25h"
+      end
+
+      # Hide the cursor
+      # @return [String]
+      def hide_cursor
+        "#{CSI}?25l"
+      end
+
+      # Enable alternative screen buffer
+      # @return [String]
+      def enable_alt_screen
+        "#{CSI}?1049h"
+      end
+
+      # Disable alternative screen buffer
+      # @return [String]
+      def disable_alt_screen
+        "#{CSI}?1049l"
+      end
+
+      # Move cursor up
+      # @param count [Integer] Number of rows
+      # @return [String]
+      def cursor_up(count = 1)
+        return "" if count < 1
+
+        "#{CSI}#{count}A"
+      end
+
+      # Move cursor down
+      # @param count [Integer] Number of rows
+      # @return [String]
+      def cursor_down(count = 1)
+        return "" if count < 1
+
+        "#{CSI}#{count}B"
+      end
+
+      # Move cursor forward (right)
+      # @param count [Integer] Number of columns
+      # @return [String]
+      def cursor_forward(count = 1)
+        return "" if count < 1
+
+        "#{CSI}#{count}C"
+      end
+
+      # Move cursor backward (left)
+      # @param count [Integer] Number of columns
+      # @return [String]
+      def cursor_backward(count = 1)
+        return "" if count < 1
+
+        "#{CSI}#{count}D"
+      end
+
+      # Move cursor to next line
+      # @param count [Integer] Number of lines
+      # @return [String]
+      def cursor_next_line(count = 1)
+        return "" if count < 1
+
+        "#{CSI}#{count}E"
+      end
+
+      # Move cursor to previous line
+      # @param count [Integer] Number of lines
+      # @return [String]
+      def cursor_prev_line(count = 1)
+        return "" if count < 1
+
+        "#{CSI}#{count}F"
+      end
+
+      # Move cursor to column (1-based)
+      # @param column [Integer] Column number (1-based)
+      # @return [String]
+      def cursor_move_to_column(column)
+        "#{CSI}#{column}G"
+      end
+
+      # Move cursor to position (1-based coordinates)
+      # @param row [Integer] Row (1-based)
+      # @param column [Integer] Column (1-based)
+      # @return [String]
+      def cursor_move_to(row, column)
+        "#{CSI}#{row};#{column}H"
+      end
+
+      # Save cursor position
+      # @return [String]
+      def save_cursor
+        "#{CSI}s"
+      end
+
+      # Restore cursor position
+      # @return [String]
+      def restore_cursor
+        "#{CSI}u"
+      end
+
+      # Erase in line
+      # @param mode [Integer] 0=cursor to end, 1=start to cursor, 2=entire line
+      # @return [String]
+      def erase_line(mode = 2)
+        "#{CSI}#{mode}K"
+      end
+
+      # Erase from cursor to end of line
+      # @return [String]
+      def erase_end_of_line
+        "#{CSI}0K"
+      end
+
+      # Erase from start of line to cursor
+      # @return [String]
+      def erase_start_of_line
+        "#{CSI}1K"
+      end
+
+      # Set window title
+      # @param title [String] Window title
+      # @return [String]
+      def set_title(title)
+        "#{OSC}2;#{title}#{ST}"
+      end
+
+      # Set icon name (some terminals)
+      # @param name [String] Icon name
+      # @return [String]
+      def set_icon_name(name)
+        "#{OSC}1;#{name}#{ST}"
+      end
+
+      # Set both icon name and window title
+      # @param title [String] Title/name
+      # @return [String]
+      def set_icon_and_title(title)
+        "#{OSC}0;#{title}#{ST}"
+      end
+
+      # Request cursor position (terminal will respond)
+      # @return [String]
+      def request_cursor_position
+        "#{CSI}6n"
+      end
+
+      # Scroll up
+      # @param count [Integer] Number of lines
+      # @return [String]
+      def scroll_up(count = 1)
+        "#{CSI}#{count}S"
+      end
+
+      # Scroll down
+      # @param count [Integer] Number of lines
+      # @return [String]
+      def scroll_down(count = 1)
+        "#{CSI}#{count}T"
+      end
+
+      # Reset all attributes
+      # @return [String]
+      def reset
+        "#{CSI}0m"
+      end
+
+      # Create a hyperlink
+      # @param url [String] URL
+      # @param text [String] Link text
+      # @param id [String, nil] Optional link ID
+      # @return [String]
+      def hyperlink(url, text, id: nil)
+        params = id ? "id=#{id}" : ""
+        "#{OSC}8;#{params};#{url}#{ST}#{text}#{OSC}8;;#{ST}"
+      end
+
+      # Start hyperlink
+      # @param url [String] URL
+      # @param id [String, nil] Optional link ID
+      # @return [String]
+      def hyperlink_start(url, id: nil)
+        params = id ? "id=#{id}" : ""
+        "#{OSC}8;#{params};#{url}#{ST}"
+      end
+
+      # End hyperlink
+      # @return [String]
+      def hyperlink_end
+        "#{OSC}8;;#{ST}"
+      end
+
+      # Strip ANSI escape sequences from text
+      # @param text [String] Text to strip
+      # @return [String] Text without ANSI sequences
+      def strip_ansi(text)
+        text.gsub(/\e\[[0-9;]*[A-Za-z]/, "")
+            .gsub(/\e\][^\a\e]*(?:\a|\e\\)/, "")
+            .gsub(/\e[()][\dAB]/, "")
+      end
+
+      # Check if text contains ANSI escape sequences
+      # @param text [String] Text to check
+      # @return [Boolean]
+      def contains_ansi?(text)
+        text.match?(/\e[\[\]()][^\a\e]*/)
+      end
+
+      # Generate control code for a control type
+      # @param control_type [Symbol] Control type
+      # @param param1 [Object] First parameter
+      # @param param2 [Object] Second parameter
+      # @return [String]
+      def generate(control_type, param1 = nil, param2 = nil)
+        case control_type
+        when ControlType::BELL
+          bell
+        when ControlType::CARRIAGE_RETURN
+          carriage_return
+        when ControlType::HOME
+          home
+        when ControlType::CLEAR
+          clear
+        when ControlType::SHOW_CURSOR
+          show_cursor
+        when ControlType::HIDE_CURSOR
+          hide_cursor
+        when ControlType::ENABLE_ALT_SCREEN
+          enable_alt_screen
+        when ControlType::DISABLE_ALT_SCREEN
+          disable_alt_screen
+        when ControlType::CURSOR_UP
+          cursor_up(param1 || 1)
+        when ControlType::CURSOR_DOWN
+          cursor_down(param1 || 1)
+        when ControlType::CURSOR_FORWARD
+          cursor_forward(param1 || 1)
+        when ControlType::CURSOR_BACKWARD
+          cursor_backward(param1 || 1)
+        when ControlType::CURSOR_MOVE_TO_COLUMN
+          cursor_move_to_column(param1 || 1)
+        when ControlType::CURSOR_MOVE_TO
+          cursor_move_to(param1 || 1, param2 || 1)
+        when ControlType::ERASE_IN_LINE
+          erase_line(param1 || 2)
+        when ControlType::SET_WINDOW_TITLE
+          set_title(param1.to_s)
+        else
+          ""
+        end
+      end
+    end
+  end
+end

data/lib/rich/json.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "style"
+require_relative "segment"
+
+module Rich
+  # JSON syntax highlighting and formatting
+  module JSON
+    # Default styles for JSON elements
+    DEFAULT_STYLES = {
+      key: "cyan",
+      string: "green",
+      number: "yellow",
+      boolean: "italic magenta",
+      null: "dim",
+      brace: "bold",
+      bracket: "bold",
+      comma: "dim",
+      colon: "dim"
+    }.freeze
+
+    class << self
+      # Render JSON with syntax highlighting
+      # @param data [Object] Data to render as JSON
+      # @param indent [Integer] Indentation size
+      # @param styles [Hash] Style overrides
+      # @return [Array<Segment>]
+      def render(data, indent: 2, styles: {})
+        merged_styles = DEFAULT_STYLES.merge(styles)
+        json_str = ::JSON.pretty_generate(data, indent: " " * indent)
+
+        segments = []
+        tokenize(json_str, merged_styles, segments)
+        segments
+      end
+
+      # Render to string with ANSI codes
+      # @param data [Object] Data to render
+      # @param indent [Integer] Indentation
+      # @param color_system [Symbol] Color system
+      # @return [String]
+      def to_s(data, indent: 2, color_system: ColorSystem::TRUECOLOR)
+        segments = render(data, indent: indent)
+        Segment.render(segments, color_system: color_system)
+      end
+
+      # Parse and render a JSON string
+      # @param json_str [String] JSON string
+      # @param styles [Hash] Style overrides
+      # @return [Array<Segment>]
+      def highlight(json_str, styles: {})
+        merged_styles = DEFAULT_STYLES.merge(styles)
+        segments = []
+        tokenize(json_str, merged_styles, segments)
+        segments
+      end
+
+      private
+
+      def tokenize(json_str, styles, segments)
+        pos = 0
+
+        while pos < json_str.length
+          char = json_str[pos]
+
+          case char
+          when "{"
+            segments << Segment.new("{", style: parse_style(styles[:brace]))
+            pos += 1
+          when "}"
+            segments << Segment.new("}", style: parse_style(styles[:brace]))
+            pos += 1
+          when "["
+            segments << Segment.new("[", style: parse_style(styles[:bracket]))
+            pos += 1
+          when "]"
+            segments << Segment.new("]", style: parse_style(styles[:bracket]))
+            pos += 1
+          when ","
+            segments << Segment.new(",", style: parse_style(styles[:comma]))
+            pos += 1
+          when ":"
+            segments << Segment.new(":", style: parse_style(styles[:colon]))
+            pos += 1
+          when '"'
+            # String - check if it's a key (followed by :)
+            str_end = find_string_end(json_str, pos)
+            str_content = json_str[pos..str_end]
+
+            # Look ahead to see if this is a key
+            look_ahead = json_str[str_end + 1..].lstrip
+            is_key = look_ahead.start_with?(":")
+
+            style = is_key ? styles[:key] : styles[:string]
+            segments << Segment.new(str_content, style: parse_style(style))
+            pos = str_end + 1
+          when /[0-9\-]/
+            # Number
+            num_end = pos
+            while num_end < json_str.length && json_str[num_end].match?(/[0-9eE.\-+]/)
+              num_end += 1
+            end
+            num_content = json_str[pos...num_end]
+            segments << Segment.new(num_content, style: parse_style(styles[:number]))
+            pos = num_end
+          when /[tfn]/
+            # Boolean or null
+            if json_str[pos, 4] == "true"
+              segments << Segment.new("true", style: parse_style(styles[:boolean]))
+              pos += 4
+            elsif json_str[pos, 5] == "false"
+              segments << Segment.new("false", style: parse_style(styles[:boolean]))
+              pos += 5
+            elsif json_str[pos, 4] == "null"
+              segments << Segment.new("null", style: parse_style(styles[:null]))
+              pos += 4
+            else
+              segments << Segment.new(char)
+              pos += 1
+            end
+          when /\s/
+            # Whitespace
+            ws_end = pos
+            while ws_end < json_str.length && json_str[ws_end].match?(/\s/)
+              ws_end += 1
+            end
+            segments << Segment.new(json_str[pos...ws_end])
+            pos = ws_end
+          else
+            segments << Segment.new(char)
+            pos += 1
+          end
+        end
+      end
+
+      def find_string_end(str, start_pos)
+        pos = start_pos + 1
+        while pos < str.length
+          if str[pos] == '"' && str[pos - 1] != '\\'
+            return pos
+          end
+          pos += 1
+        end
+        str.length - 1
+      end
+
+      def parse_style(style)
+        return nil if style.nil?
+        return style if style.is_a?(Style)
+
+        Style.parse(style)
+      end
+    end
+  end
+
+  # Pretty printing of Ruby objects
+  module Pretty
+    class << self
+      # Pretty print a Ruby object
+      # @param obj [Object] Object to print
+      # @param indent [Integer] Indentation
+      # @return [Array<Segment>]
+      def render(obj, indent: 2)
+        segments = []
+        render_object(obj, 0, indent, segments)
+        segments
+      end
+
+      # Render to string
+      # @param obj [Object] Object to render
+      # @param color_system [Symbol] Color system
+      # @return [String]
+      def to_s(obj, color_system: ColorSystem::TRUECOLOR)
+        Segment.render(render(obj), color_system: color_system)
+      end
+
+      private
+
+      def render_object(obj, depth, indent, segments)
+        case obj
+        when NilClass
+          segments << Segment.new("nil", style: Style.parse("dim"))
+        when TrueClass, FalseClass
+          segments << Segment.new(obj.to_s, style: Style.parse("italic magenta"))
+        when Integer, Float
+          segments << Segment.new(obj.to_s, style: Style.parse("yellow"))
+        when String
+          segments << Segment.new(obj.inspect, style: Style.parse("green"))
+        when Symbol
+          segments << Segment.new(":#{obj}", style: Style.parse("cyan bold"))
+        when Array
+          render_array(obj, depth, indent, segments)
+        when Hash
+          render_hash(obj, depth, indent, segments)
+        else
+          segments << Segment.new(obj.inspect, style: Style.parse("white"))
+        end
+      end
+
+      def render_array(arr, depth, indent, segments)
+        if arr.empty?
+          segments << Segment.new("[]", style: Style.parse("bold"))
+          return
+        end
+
+        segments << Segment.new("[", style: Style.parse("bold"))
+        segments << Segment.new("\n")
+
+        arr.each_with_index do |item, index|
+          segments << Segment.new(" " * ((depth + 1) * indent))
+          render_object(item, depth + 1, indent, segments)
+          segments << Segment.new(",") if index < arr.length - 1
+          segments << Segment.new("\n")
+        end
+
+        segments << Segment.new(" " * (depth * indent))
+        segments << Segment.new("]", style: Style.parse("bold"))
+      end
+
+      def render_hash(hash, depth, indent, segments)
+        if hash.empty?
+          segments << Segment.new("{}", style: Style.parse("bold"))
+          return
+        end
+
+        segments << Segment.new("{", style: Style.parse("bold"))
+        segments << Segment.new("\n")
+
+        entries = hash.to_a
+        entries.each_with_index do |(key, value), index|
+          segments << Segment.new(" " * ((depth + 1) * indent))
+
+          # Key
+          if key.is_a?(Symbol)
+            segments << Segment.new(":#{key}", style: Style.parse("cyan"))
+          else
+            segments << Segment.new(key.inspect, style: Style.parse("cyan"))
+          end
+
+          segments << Segment.new(" => ", style: Style.parse("dim"))
+
+          # Value
+          render_object(value, depth + 1, indent, segments)
+          segments << Segment.new(",") if index < entries.length - 1
+          segments << Segment.new("\n")
+        end
+
+        segments << Segment.new(" " * (depth * indent))
+        segments << Segment.new("}", style: Style.parse("bold"))
+      end
+    end
+  end
+end