webri 1.0.4 → 2.0.0

data/lib/webri.rb

@@ -1,45 +1,75 @@
 # frozen_string_literal: true
 
 require 'rbconfig'
-require 'open-uri'
-require 'rexml'
-require 'cgi'
 require 'reline'
+require 'json'
+require 'json/add/core'
+require 'uri'
+require 'open3'
 
-# TODO: Make it work on Aliki.
-# TODO: Use reline.
-#
-# TODO: Subroutinize.
-# TODO: Make initialization faster.
+require_relative 'scraper'
 
 # TODO: Choose dynamically the test names (rather than fixed)?
 # TODO: Test on Linux.
-# TODO: Test all releases(?).0
-# TODO: Test all pages(?).
-
-# TODO: Make it work for naked method ('parse') or dotted method ('.parse').
+# TODO: Test all releases(?).
+# TODO: Test all web pages(?).
+
+# TODO: Make it work for:
+# - Array.new
+# - Array::new
+# - Array.sort
+# - Array#sort
+# - .new
+# - ::new
+# - .sort
+# - #sort
 
 # TODO: Support pager.
 
 # TODO: Support .webrirc.
 # TODO: Make it save options to .webrirc.
 # TODO: Make it show .webrirc.
+# TODO: Support ENV.
 
+# TODO: Support favorites.
+# TODO: Support recents.
+# TODO: Support direct in REPL; e.g., Array.sort.
+# TODO: Support direct from command-line.
+# TODO: Support partial on command-line, into REPL.
+#
+# TODO: Support alternate character for '\#' on command-line. ('3'?)
+#
+# TODO: Token begins with character, period, colon, or hashmark;
+#       anything else could signal a special op.
+#
 # A class to display Ruby online HTML documentation.
 class WebRI
 
   # Site of the official documentation.
-  DocSite = 'https://docs.ruby-lang.org/en/'
+  DOC_SITE = 'https://docs.ruby-lang.org/en/'
+
+  PROMPT = "('?' for help) webri> "
 
-  # Get the info from the Ruby doc site's table of contents
-  # and build our @index_for_type.
-  def initialize(options = {})
+  CLASS = 'class/module'
+  SINGLETON = 'singleton method'
+  INSTANCE = 'instance method'
+  FILE = 'file'
+
+  attr_accessor :release_name,
+                :href_for_class_name,
+                :href_for_file_name,
+                :href_for_singleton_method_name,
+                :href_for_instance_method_name
+
+  def initialize(release_name = nil, options = {})
+    self.release_name = set_doc_release(release_name)
     capture_options(options)
-    set_doc_release
-    get_toc_html
-    build_indexes
+    # data_file_path = File.join('data', self.release_name + '.json')
+    data_file_path = File.expand_path("../data/#{self.release_name}.json", __dir__)
+    json = open(data_file_path).read
+    @data = JSON.parse(json, create_additions: true)
+    make_groups
     print_info if @info
-    print @noreline
     if os_type == :linux && !@noreline
       repl_reline
     else
@@ -47,13 +77,36 @@ class WebRI
     end
   end
 
+  def make_groups
+    self.href_for_class_name = {}
+    self.href_for_file_name = {}
+    self.href_for_singleton_method_name = {}
+    self.href_for_instance_method_name = {}
+    @data['hrefs_for_name'].group_by do |name, hrefs|
+      case
+      when name.start_with?('ruby:')
+        self.href_for_file_name[name] = hrefs.first
+      when name.start_with?('#')
+        self.href_for_instance_method_name[name] = hrefs
+      when name.start_with?('::')
+        self.href_for_singleton_method_name[name] = hrefs
+      else
+        self.href_for_class_name[name] = hrefs.first
+      end
+    end
+  end
+
   def repl_plain # Read-evaluate-print loop, without Reline.
     while true
-      $stdout.write('webri> ')
+        $stdout.write(PROMPT)
       $stdout.flush
       response = $stdin.gets.chomp
       exit if response == 'exit'
       next if response.empty?
+      if response.start_with?('?')
+        help(response)
+        next
+      end
       if response.split(' ').size > 1
         puts "One name at a time, please."
         next
@@ -69,18 +122,11 @@ class WebRI
     end
 
     begin
-      completion_words= []
-      @index_for_type.each_pair do |type, index|
-        if type == :page
-          completion_words += index.keys.map {|name| 'ruby:' + name }
-        else
-          completion_words += index.keys
-        end
-      end
+      completion_words= @data['hrefs_for_name'].keys.sort
       Reline.completion_proc = proc { |word|
         completion_words
       }
-      while line = Reline.readline("webri> ", true)
+      while line = Reline.readline(PROMPT, true)
         case line.chomp
         when 'exit'
           exit 0
@@ -102,147 +148,49 @@ class WebRI
     puts
   end
 
-  def set_doc_release
-    supported_releases = []
-    unsupported_releases = []
-    master_release = nil
-    io = URI.open('https://docs.ruby-lang.org/en/')
-    lines = io.readlines
-    lines.each do |line|
-      next unless line.match(/<a/)
-      doc = REXML::Document.new(line)
-      _, release, end_of_support = doc.root.text.split(' ')
-      break if release.start_with?('2')
-      if end_of_support
-        unsupported_releases.push(release)
-      elsif release == 'master'
-        master_release = release
-      else
-        supported_releases.push(release)
-      end
-    end
-    all_releases = [master_release] + supported_releases + unsupported_releases
-    if @doc_release
-      unless all_releases.include?(@doc_release)
-        puts "Unknown documentation release:  #{@doc_release}"
-        puts "Available releases: #{all_releases.join(' ')}"
-        exit
-      end
-    else
-      a = RUBY_VERSION.split('.')
-      @doc_release ||= a[0..1].join('.')
-    end
+  def set_doc_release(release_name)
+    # If doc release not specified, get it from the local Ruby version.
+    unless release_name
+      s = RUBY_VERSION.split('.')
+      release_name ||= s[0..1].join('.')
+      puts "Documentation release defaulting to #{release_name} (the Ruby version you're running)."
+      release_name
+    end
+    # If the doc release is not available, let them choose.
+    release_names = Scraper.release_names
+    unless release_names.include?(release_name)
+      puts "Found no documentation release #{release_name}."
+      puts "Releases:"
+      release_name = get_choice_(release_names, required: true)
+    end
+    release_name
   end
 
   def print_info
-    puts "Ruby documentation release:  #{@doc_release}"
-    puts "Ruby documentation URL:      #{@toc_url}"
-    puts "Executable to open page:     #{opener_name}"
+    puts "Ruby documentation:"
+    puts "  Release:   #{release_name}"
+    puts "  Site:      #{DOC_SITE}"
+    puts "  Snapshot:  #{@data['timestamp']}"
     puts "Names:"
-    @index_for_type.each_pair do |type, items|
-      puts format("  %5d %s names", items.count, type)
-    end
+    puts format("  %5d %s", href_for_file_name.size, 'Files')
+    puts format("  %5d %s", href_for_class_name.size, 'Classes and modules')
+    count = 0
+    href_for_singleton_method_name.each_pair do |name, href_for_name|
+      count += href_for_name.size
+    end
+    puts format("  %5d %s", count, 'Singleton methods')
+    count = 0
+    href_for_instance_method_name.each_pair do |name, href_for_name|
+      count += href_for_name.size
+    end
+    puts format("  %5d %s", count, 'Instance methods')
     exit
   end
 
-  def build_indexes
-    # Index for each type of entry.
-    # Each index has a hash; key is name, value is array of URIs.
-    @index_for_type = {
-      class: {}, # Has both classes and modules.
-      singleton_method: {},
-      instance_method: {},
-      page: {},
-    }
-    # Iterate over the lines of the TOC page.
-    lines = @toc_html.split("\n")
-    i = 0
-    while i < lines.count
-      item_line = lines[i]
-      i += 1
-      next unless item_line.match('<li class="(\w+)"')
-      class_attr_value = $1 # Save for later.
-      # We have a pair of lines such as:
-      #     <li class="file">
-      #       <a href="COPYING.html">COPYING</a>
-      anchor_line = lines[i] # Second line of pair.
-      # Consume anchor_line.
-      i += 1
-      # We capture variables thus:
-      # - +type+ is the value of attribute 'class'.
-      # - +path+ is the value of attribute 'href'.
-      # - +full_name+ is the HTML text.
-      type = class_attr_value
-      _, path, rest = anchor_line.split('"')
-      full_name = rest.split(/<|>/)[1]
-      full_name = CGI.unescapeHTML(full_name)
-      case type
-      when 'class', 'module'
-        index = @index_for_type[:class]
-        if index.include?(full_name)
-          entry = index[full_name]
-        else
-          entry = ClassEntry.new(full_name)
-          index[full_name] = entry
-        end
-        entry.paths.push(path) unless entry.paths.include?(path)
-      when 'file'
-        index = @index_for_type[:page]
-        if index.include?(full_name)
-          entry = index[full_name]
-        else
-          entry = FileEntry.new(full_name)
-          index[full_name] = entry
-        end
-        entry.paths.push(path) unless entry.paths.include?(path)
-      when 'method'
-        case anchor_line
-        when /method-c-/
-          index = @index_for_type[:singleton_method]
-          if index.include?(full_name)
-            entry = index[full_name]
-          else
-            entry = SingletonMethodEntry.new(full_name)
-            index[full_name] = entry
-          end
-          entry.paths.push(path) unless entry.paths.include?(path)
-        when /method-i-/
-          index = @index_for_type[:instance_method]
-          if index.include?(full_name)
-            entry = index[full_name]
-          else
-            entry = InstanceMethodEntry.new(full_name)
-            index[full_name] = entry
-          end
-          entry.paths.push(path) unless entry.paths.include?(path)
-        else
-          fail anchor_line
-        end
-      else
-        fail class_attr_val
-      end
-    end
-  end
-
   def capture_options(options)
     @noop = options[:noop]
     @info = options[:info]
     @noreline = options[:noreline]
-    @doc_release = options[:release]
-  end
-
-  def get_toc_html
-    # Construct the doc release; e.g., '3.4'.
-    # Get the doc table of contents as a temp file.
-    @toc_url = DocSite + @doc_release + '/table_of_contents.html'
-    begin
-      toc_file = URI.open(@toc_url)
-      @toc_html = toc_file.read
-    rescue Socket::ResolutionError => x
-      message = "#{x.class}: #{x.message}\nPossibly not connected to internet."
-      $stderr.puts(message)
-      exit
-    end
   end
 
   class Entry
@@ -322,15 +270,15 @@ class WebRI
     # Figure out what's asked for.
     case
     when name.match(/^[A-Z]/)
-      show_class(name, @index_for_type[:class])
+      show_class(name)
     when %w[fatal fata fat fa f].include?(name)
-      show_class(name, @index_for_type[:class])
+      show_class(name)
     when name.start_with?('ruby:')
-      show_file(name, @index_for_type[:page])
+      show_file(name)
     when name.start_with?('::')
-      show_singleton_method(name, @index_for_type[:singleton_method])
+      show_singleton_method(name)
     when name.start_with?('#')
-      show_instance_method(name, @index_for_type[:instance_method])
+      show_instance_method(name)
     when name == '@help'
       show_help
     when name == '@readme'
@@ -340,207 +288,123 @@ class WebRI
     # when name.match(/^[a-z]/)
     #   show_method(name, @index_for_type[:singleton_method], @index_for_type[:instance_method])
     else
+
       puts "No documentation available for name '#{name}'."
     end
   end
 
-  # Show class.
-  def show_class(name, class_index)
-    all_entries = @index_for_type[:class]
-    all_choices = ClassEntry.choices(all_entries)
-    # Find entries whose names that start with name.
-    selected_entries = all_entries.select do |key, value|
-      key.start_with?(name)
-    end
-    # Find paths for selected_choices
-    selected_paths = []
-    selected_entries.each_pair do |name, entry|
-      entry.paths.each do |path|
-        selected_paths.push(path)
-      end
-    end
-    case selected_paths.size
-    when 1
-      selected_choices = ClassEntry.choices(selected_entries)
-      choice = selected_choices.keys.first
-      path = selected_choices.values.first
-      puts "Found one class/module name starting with '#{name}'\n  #{choice}"
-      full_name = ClassEntry.full_name_for_choice(choice)
-      if name != full_name
-        message = "Open page #{path}?"
-        return unless get_boolean_answer(message)
-      end
-      path
-    when 0
-      puts "Found no class/module name starting with '#{name}'."
-      message = "Show #{all_choices.size} class/module names?"
-      return unless get_boolean_answer(message)
-      choice_index = get_choice(all_choices.keys)
-      return if choice_index.nil?
-      path = all_choices[choice_index]
-    else
-      selected_choices = ClassEntry.choices(selected_entries)
-      puts "Found #{selected_choices.size} class/module names starting with '#{name}'."
-      message = "Show #{selected_choices.size} class/module names?'"
-      return unless get_boolean_answer(message)
-      key = get_choice(selected_choices.keys)
-      return if key.nil?
-      path = selected_choices[key]
+  def get_choice(situation, choices, type)
+    puts situation
+    count = choices.size
+    if count > 20
+      message = "Show #{count} #{type} names?"
+      return nil unless get_boolean_answer(message)
     end
-    uri = Entry.uri(path)
-    open_page(name, uri)
-  end
-
-  # Show page.
-  def show_file(name, file_index)
-    # Target page is a free-standing page such as 'COPYING'.
-    name = name.sub(/^ruby:/, '') # Discard leading 'ruby:'
-    all_entries = @index_for_type[:page]
-    all_choices = FileEntry.choices(all_entries)
-    # Find entries whose names that start with name.
-    selected_entries = all_entries.select do |key, value|
-      key.start_with?(name)
-    end
-    # Find paths for selected_choices
-    selected_paths = []
-    selected_entries.each_pair do |name, entry|
-      entry.paths.each do |path|
-        selected_paths.push(path)
-      end
-    end
-    case selected_paths.size
-    when 1
-      selected_choices = FileEntry.choices(selected_entries)
-      choice = selected_choices.keys.first
-      path = selected_choices.values.first
-      puts "Found one page name starting with '#{name}'\n  #{choice}"
-      full_name = FileEntry.full_name_for_choice(choice)
-      if name != full_name
-        message = "Open page #{path}?"
-        return unless get_boolean_answer(message)
-      end
-      path
-    when 0
-      puts "Found no page name starting with '#{name}'."
-      message = "Show names of all #{all_choices.size} pages?"
-      return unless get_boolean_answer(message)
-      key = get_choice(all_choices.keys)
-      return if key.nil?
-      path = all_choices[key]
-    else
-      selected_choices = FileEntry.choices(selected_entries)
-      puts "Found #{selected_choices.size} page names starting with '#{name}'."
-      message = "Show #{selected_choices.size} names?'"
-      return unless get_boolean_answer(message)
-      key = get_choice(selected_choices.keys)
-      return if key.nil?
-      path = selected_choices[key]
-    end
-    uri = Entry.uri(path)
-    open_page(name, uri)
-  end
-
-  # Show singleton method.
-  def show_singleton_method(name, singleton_method_index)
-    # Target page is a singleton method such as ::new.
-    all_entries = @index_for_type[:singleton_method]
-    all_choices = SingletonMethodEntry.choices(all_entries)
-    # Find entries whose names that start with name.
-    selected_entries = all_entries.select do |key, value|
-      key.start_with?(name)
-    end
-    # Find paths for selected_choices
-    selected_paths = []
-    selected_entries.each_pair do |name, entry|
-      entry.paths.each do |path|
-        selected_paths.push(path)
-      end
-    end
-    selected_choices = SingletonMethodEntry.choices(selected_entries)
-    case selected_paths.size
-    when 1
-      full_name = selected_entries.keys.first
-      path = selected_choices.values.first
-      puts "Found one singleton method name starting with '#{name}'\n  #{full_name}"
-      if name != full_name
-        uri = URI.parse(path)
-        message = "Open page #{uri.path} at method #{full_name}?"
-        return unless get_boolean_answer(message)
-      end
-      path
-    when 0
-      puts "Found no singleton method name starting with '#{name}'."
-      message = "Show names of all #{all_choices.size} singleton methods?"
-      return unless get_boolean_answer(message)
-      choice = get_choice(all_choices.keys)
-      return if choice.nil?
-      full_name = SingletonMethodEntry.full_name_for_choice(choice)
-      path = all_choices[choice]
-    else
-      puts "Found #{selected_paths.size} singleton method names starting with '#{name}'."
-      message = "Show #{selected_paths.size} names?'"
-      return unless get_boolean_answer(message)
-      choice = get_choice(selected_choices.keys)
-      return if choice.nil?
-      full_name = SingletonMethodEntry.full_name_for_choice(choice)
-      path = all_choices[choice]
-    end
-    uri = Entry.uri(path)
-    open_page(full_name, uri)
-  end
-
-  # Show instance method.
-  def show_instance_method(name, instance_method_index)
-    # Target page is an instance method such as #to_s.
-    all_entries = @index_for_type[:instance_method]
-    all_choices = InstanceMethodEntry.choices(all_entries)
-    # Find entries whose names that start with name.
-    selected_entries = all_entries.select do |key, value|
-      key.start_with?(name)
-    end
-    # Find paths for selected_choices
-    selected_paths = []
-    selected_entries.each_pair do |name, entry|
-      entry.paths.each do |path|
-        selected_paths.push(path)
+    get_choice_(choices)
+  end
+
+  # Show web page for selected file or class name.
+  def show_web_page_for_file_or_class(partial_name, href_for_name, type)
+    # Find names that start with partial name (which may in fact be the full name).
+    selected_names = href_for_name.keys.select do |name|
+      name.start_with?(partial_name)
+    end
+    count = selected_names.size
+    selected_name =
+      case count
+      when 0
+        situation = "Found no #{type} name starting with '#{partial_name}'."
+        selected_name = get_choice(situation, href_for_name.keys, type)
+        return if selected_name.nil?
+        selected_name
+      when 1
+        full_name = selected_names.first
+        puts "Found one #{type} name starting with '#{partial_name}': #{full_name}"
+        if partial_name != full_name
+          message = "Open web page #{full_name}?"
+          return unless get_boolean_answer(message)
+        end
+        full_name
+      else
+        situation =  "Found #{count} #{type} names starting with '#{partial_name}'."
+        selected_name = get_choice(situation, selected_names, type)
+        return if selected_name.nil?
+        selected_name
       end
-    end
-    selected_choices = InstanceMethodEntry.choices(selected_entries)
-    case selected_paths.size
-    when 1
-      full_name = selected_entries.keys.first
-      path = selected_choices.values.first
-      puts "Found one instance method name starting with '#{name}'\n  #{full_name}"
-      if name != full_name
-        uri = URI.parse(path)
-        message = "Open page #{uri.path} at method #{full_name}?"
-        return unless get_boolean_answer(message)
+    href = href_for_name[selected_name]
+    show_web_page(selected_name, href)
+  end
+
+  # Show web page for selected class name.
+  def show_class(partial_name)
+    show_web_page_for_file_or_class(partial_name, href_for_class_name, CLASS)
+  end
+
+  # Show web page for selected file name.
+  def show_file(partial_name)
+    show_web_page_for_file_or_class(partial_name, href_for_file_name, FILE)
+  end
+
+  # Show web page for selected method name.
+  def show_web_page_for_method(partial_name, href_for_name, type)
+    # Find names that start with partial name (which may in fact be the full name).
+    selected_names = href_for_name.keys.select do |name|
+      name.start_with?(partial_name)
+    end
+    count = selected_names.size
+    selected_name =
+      case count
+      when 0
+        situation = "Found no #{type} name starting with '#{partial_name}'."
+        selected_name = get_choice(situation, href_for_name, type)
+        return if selected_name.nil?
+        selected_name
+      when 1
+        full_name = selected_names.first
+        puts "Found one #{type} name starting with '#{partial_name}': #{full_name}"
+        if partial_name != full_name
+          message = "Open web page #{full_name}?"
+          return unless get_boolean_answer(message)
+        end
+        full_name
+      else
+        situation = "Found #{count} #{type} names starting with '#{partial_name}'."
+        selected_name = get_choice(situation, selected_names, type)
+        return if selected_name.nil?
+        selected_name
       end
-      path
-    when 0
-      puts "Found no instance method name starting with '#{name}'."
-      message = "Show names of all #{all_choices.size} instance methods?"
-      return unless get_boolean_answer(message)
-      choice = get_choice(all_choices.keys)
-      return if choice.nil?
-      path = all_choices[choice]
-      full_name = InstanceMethodEntry.full_name_for_choice(choice)
+    qualified_names = []
+    @data['classes_for_method'][selected_name].each do |class_name|
+      qualified_names << "#{class_name}#{selected_name}"
+    end
+    count = qualified_names.size
+    if count == 1
+      puts "Found one #{CLASS} that has method '#{selected_name}'."
+      qualified_name = qualified_names.first
     else
-      puts "Found #{selected_paths.size} instance method names starting with '#{name}'."
-      message = "Show #{selected_paths.size} names?'"
-      return unless get_boolean_answer(message)
-      choice = get_choice(selected_choices.keys)
-      return if choice.nil?
-      path = all_choices[choice]
-      full_name = InstanceMethodEntry.full_name_for_choice(choice)
-    end
-    uri = Entry.uri(path)
-    open_page(full_name, uri)
+      situation = "Found #{count} #{type} names that have method '#{selected_name}'."
+      qualified_name = get_choice(situation, qualified_names, type)
+      return if qualified_name.nil?
+    end
+    method_href = href_for_name[selected_name]
+    class_name = qualified_name.sub(selected_name, '')
+    href = "#{class_name}.html#{method_href}"
+    show_web_page(selected_name, href)
+  end
+
+  # Show web page for singleton method name.
+  def show_singleton_method(partial_name)
+    show_web_page_for_method(partial_name, href_for_singleton_method_name, SINGLETON)
+  end
+
+  # Show web page for instance method name.
+  def show_instance_method(partial_name)
+    show_web_page_for_method(partial_name, href_for_instance_method_name, INSTANCE)
   end
 
   def show_help
     puts 'Showing help.'
-    puts `ruby bin/webri --help`
+    puts `ruby exe/webri --help`
   end
 
   def show_readme
@@ -548,7 +412,7 @@ class WebRI
   end
 
   # Present choices; return choice.
-  def get_choice(choices)
+  def get_choice_(choices, required: false)
     index = nil
     range = (0..choices.size - 1)
     until range.include?(index)
@@ -557,14 +421,20 @@ class WebRI
         puts "  #{s}:  #{choice}"
       end
       while true
-        print "Type a number to choose, or Return to skip:  "
+        message = if required
+                    'Type a number to choose:  '
+                  else
+                    'Type a number to choose, or Return to skip:  '
+                  end
+        print message
         $stdout.flush
         response = $stdin.gets
         case response
         when /(\d+)/
-          return choices[$1.to_i]
+          index = $1.to_i
+          return choices[index] if index < choices.size
         when "\n"
-          return nil
+          return nil unless required
         else
 
         end
@@ -586,8 +456,9 @@ class WebRI
   end
 
   # Open URL in browser.
-  def open_page(name, target_uri)
-    uri = URI.parse(File.join(DocSite, @doc_release, target_uri.to_s))
+  def show_web_page(name, href)
+    href.gsub!('::', '/')
+    uri = URI.parse(File.join(DOC_SITE, release_name, href))
     open_uri(name, uri)
   end
 
@@ -629,10 +500,58 @@ class WebRI
     puts message
     command = "#{opener_name} #{full_url}"
     if @noop
-      puts "Command: '#{command}'"
+      # puts "Command: '#{command}'"
     else
-      system(command)
+      # system(command)
+      Open3.popen3(command) do |stdin, stdout, stderr, wait_thr|
+      end
+    end
+  end
+
+  def self.get_webri_root_dir
+    webri_root_dir = `git rev-parse --show-toplevel`.chomp
+    if $?.success? && File.basename(webri_root_dir) == 'webri'
+      return webri_root_dir
     end
+    message = "Current working directory must be in a webri project, not #{Dir.pwd}."
+    puts message
+    exit
+  end
+
+  def self.check_release_name(release_name)
+    release_names = Scraper.release_names
+    unless release_names.include?(release_name)
+      message = "Release must be one of #{release_names.inspect}, not #{release_name.inspect}."
+      puts message
+      exit 1
+    end
+  end
+
+  def help(response)
+    if response == '?'
+      puts <<HELP
+Type:
+  - 'exit' to exit webri.
+  - #{CLASS.capitalize} name (full or partial) to see #{CLASS} names:
+      - 'Array' (full name, not the start of other names).
+      - 'Ar' (partial name).
+  - #{SINGLETON.capitalize} name (full or partial) to see #{SINGLETON} names:
+      - '::tanh' (full name, not the start of other names).
+      - '::ta' (partial name).
+  - #{INSTANCE.capitalize} name (full or partial) to see #{INSTANCE} names:
+      - '#query=' (full name, not the start of other names).
+      - '#qu' (partial name).
+  - #{FILE.capitalize}name (full or partial) to see #{FILE} names:
+      - 'ruby:syntax_rdoc' (full name, not the start of other names).
+      - 'ruby:syntax' (partial name).
+HELP
+    else
+      p response
+    end
+  end
+
+  def help_main
+
   end
 
 end