← Back to branch summary

~ubuntu-branches/ubuntu/trusty/ruby1.9/trusty

« back to all changes in this revision

Viewing changes to lib/rdoc/ri/display.rb

  • Committer: Bazaar Package Importer
  • Author(s): Stephan Hermann
  • Date: 2008-05-16 12:37:06 UTC
  • mfrom: (1.1.10 upstream)
  • Revision ID: james.westby@ubuntu.com-20080516123706-r4llcdfd35aobrjv
Tags: 1.9.0.1-1ubuntu1
https://launchpad.net/bugs/228345
* Merge from debian unstable, remaining changes:
  - Robustify check for target_os, fixing build failure on lpia.
* debian/control:
  - ruby1.9 pkg: moved rdoc1.9 suggestion to depends. (LP: #228345)

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/rdoc/ri/display.rb
 
1
require 'rdoc/ri'
 
2
 
 
3
##
 
4
# This is a kind of 'flag' module. If you want to write your own 'ri' display
 
5
# module (perhaps because you'r writing an IDE or somesuch beast), you simply
 
6
# write a class which implements the various 'display' methods in
 
7
# 'DefaultDisplay', and include the 'RiDisplay' module in that class.
 
8
#
 
9
# To access your class from the command line, you can do
 
10
#
 
11
#    ruby -r <your source file>  ../ri ....
 
12
 
 
13
module RDoc::RI::Display
 
14
 
 
15
  @@display_class = nil
 
16
 
 
17
  def self.append_features(display_class)
 
18
    @@display_class = display_class
 
19
  end
 
20
 
 
21
  def self.new(*args)
 
22
    @@display_class.new(*args)
 
23
  end
 
24
 
 
25
end
 
26
 
 
27
##
 
28
# A paging display module. Uses the RDoc::RI::Formatter class to do the actual
 
29
# presentation.
 
30
 
 
31
class RDoc::RI::DefaultDisplay
 
32
 
 
33
  include RDoc::RI::Display
 
34
 
 
35
  def initialize(formatter, width, use_stdout)
 
36
    @use_stdout = use_stdout
 
37
    @formatter = formatter.new $stdout, width, "     "
 
38
  end
 
39
 
 
40
  def display_method_info(method)
 
41
    page do
 
42
      @formatter.draw_line(method.full_name)
 
43
      display_params(method)
 
44
      @formatter.draw_line
 
45
      display_flow(method.comment)
 
46
      if method.aliases && !method.aliases.empty?
 
47
        @formatter.blankline
 
48
        aka = "(also known as "
 
49
        aka << method.aliases.map {|a| a.name }.join(", ")
 
50
        aka << ")"
 
51
        @formatter.wrap(aka)
 
52
      end
 
53
    end
 
54
  end
 
55
 
 
56
  def display_class_info(klass, ri_reader)
 
57
    page do
 
58
      superclass = klass.superclass_string
 
59
 
 
60
      if superclass
 
61
        superclass = " < " + superclass
 
62
      else
 
63
        superclass = ""
 
64
      end
 
65
 
 
66
      @formatter.draw_line(klass.display_name + ": " +
 
67
                           klass.full_name + superclass)
 
68
 
 
69
      display_flow(klass.comment)
 
70
      @formatter.draw_line
 
71
 
 
72
      unless klass.includes.empty?
 
73
        @formatter.blankline
 
74
        @formatter.display_heading("Includes:", 2, "")
 
75
        incs = []
 
76
        klass.includes.each do |inc|
 
77
          inc_desc = ri_reader.find_class_by_name(inc.name)
 
78
          if inc_desc
 
79
            str = inc.name + "("
 
80
            str << inc_desc.instance_methods.map{|m| m.name}.join(", ")
 
81
            str << ")"
 
82
            incs << str
 
83
          else
 
84
            incs << inc.name
 
85
          end
 
86
      end
 
87
        @formatter.wrap(incs.sort.join(', '))
 
88
      end
 
89
 
 
90
      unless klass.constants.empty?
 
91
        @formatter.blankline
 
92
        @formatter.display_heading("Constants:", 2, "")
 
93
        len = 0
 
94
        klass.constants.each { |c| len = c.name.length if c.name.length > len }
 
95
        len += 2
 
96
        klass.constants.each do |c|
 
97
          @formatter.wrap(c.value,
 
98
                          @formatter.indent+((c.name+":").ljust(len)))
 
99
        end
 
100
      end
 
101
 
 
102
      unless klass.class_methods.empty?
 
103
        @formatter.blankline
 
104
        @formatter.display_heading("Class methods:", 2, "")
 
105
        @formatter.wrap(klass.class_methods.map{|m| m.name}.sort.join(', '))
 
106
      end
 
107
 
 
108
      unless klass.class_method_extensions.empty?
 
109
        @formatter.blankline
 
110
        @formatter.display_heading("Class Method Extensions:", 2, "")
 
111
        @formatter.wrap(klass.class_method_extensions.map{|m| m.name}.sort.join(', '))
 
112
      end
 
113
 
 
114
      unless klass.instance_methods.empty?
 
115
        @formatter.blankline
 
116
        @formatter.display_heading("Instance methods:", 2, "")
 
117
        @formatter.wrap(klass.instance_methods.map{|m| m.name}.sort.join(', '))
 
118
      end
 
119
 
 
120
      unless klass.instance_method_extensions.empty?
 
121
        @formatter.blankline
 
122
        @formatter.display_heading("Instance Method Extensions:", 2, "")
 
123
        @formatter.wrap(klass.instance_method_extensions.map{|m| m.name}.sort.join(', '))
 
124
      end
 
125
 
 
126
      unless klass.attributes.empty?
 
127
        @formatter.blankline
 
128
        @formatter.wrap("Attributes:", "")
 
129
        @formatter.wrap(klass.attributes.map{|a| a.name}.sort.join(', '))
 
130
      end
 
131
    end
 
132
  end
 
133
 
 
134
  ##
 
135
  # Display a list of method names
 
136
 
 
137
  def display_method_list(methods)
 
138
    page do
 
139
      @formatter.raw_print_line("More than one method matched your request. You can refine")
 
140
      @formatter.raw_print_line("your search by asking for information on one of:\n\n")
 
141
      @formatter.wrap(methods.map {|m| m.full_name} .join(", "))
 
142
    end
 
143
  end
 
144
 
 
145
  def display_class_list(namespaces)
 
146
    page do
 
147
      @formatter.raw_print_line("More than one class or module matched your request. You can refine")
 
148
      @formatter.raw_print_line("your search by asking for information on one of:\n\n")
 
149
      @formatter.wrap(namespaces.map {|m| m.full_name}.join(", "))
 
150
    end
 
151
  end
 
152
 
 
153
  def list_known_classes(classes)
 
154
    if classes.empty?
 
155
      warn_no_database
 
156
    else
 
157
      page do
 
158
        @formatter.draw_line("Known classes and modules")
 
159
        @formatter.blankline
 
160
        @formatter.wrap(classes.sort.join(", "))
 
161
      end
 
162
    end
 
163
  end
 
164
 
 
165
  def list_known_names(names)
 
166
    if names.empty?
 
167
      warn_no_database
 
168
    else
 
169
      page do
 
170
        names.each {|n| @formatter.raw_print_line(n)}
 
171
      end
 
172
    end
 
173
  end
 
174
 
 
175
  private
 
176
 
 
177
  def page
 
178
    if pager = setup_pager then
 
179
      begin
 
180
        orig_output = @formatter.output
 
181
        @formatter.output = pager
 
182
        yield
 
183
      ensure
 
184
        @formatter.output = orig_output
 
185
        pager.close
 
186
      end
 
187
    else
 
188
      yield
 
189
    end
 
190
  rescue Errno::EPIPE
 
191
  end
 
192
 
 
193
  def setup_pager
 
194
    unless @use_stdout then
 
195
      for pager in [ ENV['PAGER'], "less", "more", 'pager' ].compact.uniq
 
196
        return IO.popen(pager, "w") rescue nil
 
197
      end
 
198
      @use_stdout = true
 
199
      nil
 
200
    end
 
201
  end
 
202
 
 
203
  def display_params(method)
 
204
    params = method.params
 
205
 
 
206
    if params[0,1] == "("
 
207
      if method.is_singleton
 
208
        params = method.full_name + params
 
209
      else
 
210
        params = method.name + params
 
211
      end
 
212
    end
 
213
    params.split(/\n/).each do |p|
 
214
      @formatter.wrap(p)
 
215
      @formatter.break_to_newline
 
216
    end
 
217
    if method.source_path then
 
218
      @formatter.blankline
 
219
      @formatter.wrap("Extension from #{method.source_path}")
 
220
    end
 
221
  end
 
222
 
 
223
  def display_flow(flow)
 
224
    if !flow || flow.empty?
 
225
      @formatter.wrap("(no description...)")
 
226
    else
 
227
      @formatter.display_flow(flow)
 
228
    end
 
229
  end
 
230
 
 
231
  def warn_no_database
 
232
    puts "No ri data found"
 
233
    puts
 
234
    puts "If you've installed Ruby yourself, you need to generate documentation using:"
 
235
    puts
 
236
    puts "  make install-doc"
 
237
    puts
 
238
    puts "from the same place you ran `make` to build ruby."
 
239
    puts
 
240
    puts "If you installed Ruby from a packaging system, then you may need to"
 
241
    puts "install an additional package, or ask the packager to enable ri generation."
 
242
  end
 
243
end
 
244