Module: IRB::Color

Defined in:
lib/irb/color.rb

Constant Summary collapse

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

Class Method Summary collapse

Class Method Details

.clear(colorable: colorable?) ) ⇒ Object 



114
115
116
117
 
# File 'lib/irb/color.rb', line 114

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

.colorable? ⇒ Boolean

Returns:

  • (Boolean) 


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

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 



119
120
121
122
123
 
# File 'lib/irb/color.rb', line 119

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?, , local_variables: []) ⇒ 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.



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
157
158
159
160
161
162
163
164
165
 
# File 'lib/irb/color.rb', line 128

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

  symbol_state = SymbolState.new
  colored = +''
  lvars_code = RubyLex.generate_local_variables_assign_code(local_variables)
  code_with_lvars = lvars_code ? "#{lvars_code}\n#{code}" : code

  scan(code_with_lvars, 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

  if lvars_code
    raise "#{lvars_code.dump} should have no \\n" if lvars_code.include?("\n")
    colored.sub!(/\A.+\n/, '') # delete_prefix lvars_code with colors
  end
  colored
end

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

Returns:

  • (Boolean) 


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

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