Module: IRB::Color

Defined in:
lib/irb/color.rb

Constant Summary collapse

CLEAR = 
0
BOLD = 
1
UNDERLINE = 
4
REVERSE = 
7
RED = 
31
GREEN = 
32
YELLOW = 
33
BLUE = 
34
MAGENTA = 
35
CYAN = 
36

Class Method Summary collapse

Class Method Details

.clear(colorable: colorable?) ) ⇒ Object 



112
113
114
115
 
# File 'lib/irb/color.rb', line 112

def clear(colorable: colorable?)
  return '' unless colorable
  "\e[#{CLEAR}m"
end

.colorable? ⇒ Boolean

Returns:

  • (Boolean) 


79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/irb/color.rb', line 79

def colorable?
  supported = $stdout.tty? && (/mswin|mingw/ =~ RUBY_PLATFORM || (ENV.key?('TERM') && ENV['TERM'] != 'dumb'))

  # because ruby/debug also uses irb's color module selectively,
  # irb won't be activated in that case.
  if IRB.respond_to?(:conf)
    supported && IRB.conf.fetch(:USE_COLORIZE, true)
  else
    supported
  end
end

.colorize(text, seq, colorable: colorable?) ) ⇒ Object 



117
118
119
120
121
 
# File 'lib/irb/color.rb', line 117

def colorize(text, seq, colorable: colorable?)
  return text unless colorable
  seq = seq.map { |s| "\e[#{const_get(s)}m" }.join('')
  "#{seq}#{text}#{clear(colorable: colorable)}"
end

.colorize_code(code, complete: true, ignore_error: false, colorable: colorable?) ) ⇒ Object

If ‘complete` is false (code is incomplete), this does not warn compile_error. This option is needed to avoid warning a user when the compile_error is happening because the input is not wrong but just incomplete.



126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
 
# File 'lib/irb/color.rb', line 126

def colorize_code(code, complete: true, ignore_error: false, colorable: colorable?)
  return code unless colorable

  symbol_state = SymbolState.new
  colored = +''

  scan(code, allow_last_error: !complete) do |token, str, expr|
    # handle uncolorable code
    if token.nil?
      colored << Reline::Unicode.escape_for_print(str)
      next
    end

    # IRB::ColorPrinter skips colorizing fragments with any invalid token
    if ignore_error && ERROR_TOKENS.include?(token)
      return Reline::Unicode.escape_for_print(code)
    end

    in_symbol = symbol_state.scan_token(token)
    str.each_line do |line|
      line = Reline::Unicode.escape_for_print(line)
      if seq = dispatch_seq(token, expr, line, in_symbol: in_symbol)
        colored << seq.map { |s| "\e[#{s}m" }.join('')
        colored << line.sub(/\Z/, clear(colorable: colorable))
      else
        colored << line
      end
    end
  end
  colored
end

.inspect_colorable?(obj, seen: {}.compare_by_identity) ⇒ Boolean

Returns:

  • (Boolean) 


91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
 
# File 'lib/irb/color.rb', line 91

def inspect_colorable?(obj, seen: {}.compare_by_identity)
  case obj
  when String, Symbol, Regexp, Integer, Float, FalseClass, TrueClass, NilClass
    true
  when Hash
    without_circular_ref(obj, seen: seen) do
      obj.all? { |k, v| inspect_colorable?(k, seen: seen) && inspect_colorable?(v, seen: seen) }
    end
  when Array
    without_circular_ref(obj, seen: seen) do
      obj.all? { |o| inspect_colorable?(o, seen: seen) }
    end
  when Range
    inspect_colorable?(obj.begin, seen: seen) && inspect_colorable?(obj.end, seen: seen)
  when Module
    !obj.name.nil?
  else
    false
  end
end