Class: RDoc::RI::DefaultDisplay

Inherits:
Object
  • Object
show all
Includes:
Display
Defined in:
lib/rdoc/ri/display.rb

Overview

A paging display module. Uses the RDoc::RI::Formatter class to do the actual presentation.

Instance Method Summary collapse

Methods included from Display

append_features, new

Constructor Details

#initialize(formatter, width, use_stdout, output = $stdout) ⇒ DefaultDisplay

Returns a new instance of DefaultDisplay.



35
36
37
38
 
# File 'lib/rdoc/ri/display.rb', line 35

def initialize(formatter, width, use_stdout, output = $stdout)
  @use_stdout = use_stdout
  @formatter = formatter.new output, width, "     "
end

Instance Method Details

#display_class_info(klass, ri_reader) ⇒ Object

Display information about klass. Fetches additional information from ri_reader as necessary.



44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
 
# File 'lib/rdoc/ri/display.rb', line 44

def display_class_info(klass, ri_reader)
  page do
    superclass = klass.superclass_string

    if superclass
      superclass = " < " + superclass
    else
      superclass = ""
    end

    @formatter.draw_line(klass.display_name + ": " +
                         klass.full_name + superclass)

    display_flow(klass.comment)
    @formatter.draw_line

    unless klass.includes.empty?
      @formatter.blankline
      @formatter.display_heading("Includes:", 2, "")
      incs = []
      klass.includes.each do |inc|
        inc_desc = ri_reader.find_class_by_name(inc.name)
        if inc_desc
          str = inc.name + "("
          str << inc_desc.instance_methods.map{|m| m.name}.join(", ")
          str << ")"
          incs << str
        else
          incs << inc.name
        end
    end
      @formatter.wrap(incs.sort.join(', '))
    end

    unless klass.constants.empty?
      @formatter.blankline
      @formatter.display_heading("Constants:", 2, "")

      constants = klass.constants.sort_by { |constant| constant.name }

      constants.each do |constant|
        if constant.comment then
          @formatter.wrap "#{constant.name}:"

          @formatter.indent do
            @formatter.display_flow constant.comment
          end
        else
          @formatter.wrap constant.name
        end
      end
    end

    class_data = [
      :class_methods,
      :class_method_extensions,
      :instance_methods,
      :instance_method_extensions,
    ]

    class_data.each do |data_type|
      data = klass.send data_type

      unless data.empty? then
        @formatter.blankline

        heading = data_type.to_s.split('_').join(' ').capitalize << ':'
        @formatter.display_heading heading, 2, ''

        data = data.map { |item| item.name }.sort.join ', '
        @formatter.wrap data
      end
    end

    unless klass.attributes.empty? then
      @formatter.blankline

      @formatter.display_heading 'Attributes:', 2, ''

      attributes = klass.attributes.sort_by { |attribute| attribute.name }

      attributes.each do |attribute|
        if attribute.comment then
          @formatter.wrap "#{attribute.name} (#{attribute.rw}):"
          @formatter.indent do
            @formatter.display_flow attribute.comment
          end
        else
          @formatter.wrap "#{attribute.name} (#{attribute.rw})"
        end
      end
    end
  end
end

#display_flow(flow) ⇒ Object

Display an Array of RDoc::Markup::Flow objects, flow.



142
143
144
145
146
147
148
 
# File 'lib/rdoc/ri/display.rb', line 142

def display_flow(flow)
  if flow and not flow.empty? then
    @formatter.display_flow flow
  else
    @formatter.wrap '[no description]'
  end
end

#display_method_info(method) ⇒ Object

Display information about method.



153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
 
# File 'lib/rdoc/ri/display.rb', line 153

def display_method_info(method)
  page do
    @formatter.draw_line(method.full_name)
    display_params(method)

    @formatter.draw_line
    display_flow(method.comment)

    if method.aliases and not method.aliases.empty? then
      @formatter.blankline
      aka = "(also known as #{method.aliases.map { |a| a.name }.join(', ')})"
      @formatter.wrap aka
    end
  end
end

#display_method_list(methods) ⇒ Object

Display the list of methods.



172
173
174
175
176
177
178
179
180
 
# File 'lib/rdoc/ri/display.rb', line 172

def display_method_list(methods)
  page do
    @formatter.wrap "More than one method matched your request.  You can refine your search by asking for information on one of:"

    @formatter.blankline

    @formatter.wrap methods.map { |m| m.full_name }.join(", ")
  end
end

#display_params(method) ⇒ Object

Display the params for method.



185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
 
# File 'lib/rdoc/ri/display.rb', line 185

def display_params(method)
  params = method.params

  if params[0,1] == "(" then
    if method.is_singleton
      params = method.full_name + params
    else
      params = method.name + params
    end
  end

  params.split(/\n/).each do |param|
    @formatter.wrap param
    @formatter.break_to_newline
  end

  if method.source_path then
    @formatter.blankline
    @formatter.wrap("Extension from #{method.source_path}")
  end
end

#list_known_classes(classes) ⇒ Object

List the classes in classes.



210
211
212
213
214
215
216
217
218
219
220
221
 
# File 'lib/rdoc/ri/display.rb', line 210

def list_known_classes(classes)
  if classes.empty?
    warn_no_database
  else
    page do
      @formatter.draw_line "Known classes and modules"
      @formatter.blankline

      @formatter.wrap classes.sort.join(', ')
    end
  end
end

#page ⇒ Object

Paginates output through a pager program.



226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
 
# File 'lib/rdoc/ri/display.rb', line 226

def page
  if pager = setup_pager then
    begin
      orig_output = @formatter.output
      @formatter.output = pager
      yield
    ensure
      @formatter.output = orig_output
      pager.close
    end
  else
    yield
  end
rescue Errno::EPIPE
end

#setup_pager ⇒ Object

Sets up a pager program to pass output through.



245
246
247
248
249
250
251
252
253
 
# File 'lib/rdoc/ri/display.rb', line 245

def setup_pager
  unless @use_stdout then
    for pager in [ ENV['PAGER'], "less", "more", 'pager' ].compact.uniq
      return IO.popen(pager, "w") rescue nil
    end
    @use_stdout = true
    nil
  end
end

#warn_no_database ⇒ Object

Displays a message that describes how to build RI data.



258
259
260
261
262
263
264
265
266
267
268
269
270
271
 
# File 'lib/rdoc/ri/display.rb', line 258

def warn_no_database
  output = @formatter.output

  output.puts "No ri data found"
  output.puts
  output.puts "If you've installed Ruby yourself, you need to generate documentation using:"
  output.puts
  output.puts "  make install-doc"
  output.puts
  output.puts "from the same place you ran `make` to build ruby."
  output.puts
  output.puts "If you installed Ruby from a packaging system, then you may need to"
  output.puts "install an additional package, or ask the packager to enable ri generation."
end