Update syntax_tree version and doc/index.html to reflect it

Gemfile

@@ -4,4 +4,4 @@ source "https://rubygems.org"
 
 gem "bundler"
 gem "rake"
-gem "syntax_tree"
+gem "syntax_tree", "~> 6.0"

Gemfile.lock

@@ -1,8 +1,10 @@
 GEM
   remote: https://rubygems.org/
   specs:
+    prettier_print (1.2.0)
     rake (13.0.6)
-    syntax_tree (2.3.1)
+    syntax_tree (6.0.0)
+      prettier_print (>= 1.2.0)
 
 PLATFORMS
   ruby
@@ -12,7 +14,7 @@ PLATFORMS
 DEPENDENCIES
   bundler
   rake
-  syntax_tree
+  syntax_tree (~> 6.0)
 
 BUNDLED WITH
    2.3.6

docs/index.html

@@ -22,31 +22,120 @@ <h1>Syntax Tree</h1>
       </nav>
       <textarea id="editor"># frozen_string_literal: true
 
-require "json"
-require "pp"
-require "prettyprint"
+require "prettier_print"
 require "ripper"
-require "stringio"
 
-require_relative "syntax_tree/formatter"
 require_relative "syntax_tree/node"
+require_relative "syntax_tree/basic_visitor"
+require_relative "syntax_tree/visitor"
+
+require_relative "syntax_tree/formatter"
 require_relative "syntax_tree/parser"
-require_relative "syntax_tree/prettyprint"
 require_relative "syntax_tree/version"
-require_relative "syntax_tree/visitor"
-require_relative "syntax_tree/visitor/json_visitor"
-require_relative "syntax_tree/visitor/pretty_print_visitor"
 
+# Syntax Tree is a suite of tools built on top of the internal CRuby parser. It
+# provides the ability to generate a syntax tree from source, as well as the
+# tools necessary to inspect and manipulate that syntax tree. It can be used to
+# build formatters, linters, language servers, and more.
 module SyntaxTree
+  # Syntax Tree the library has many features that aren't always used by the
+  # CLI. Requiring those features takes time, so we autoload as many constants
+  # as possible in order to keep the CLI as fast as possible.
+
+  autoload :DSL, "syntax_tree/dsl"
+  autoload :FieldVisitor, "syntax_tree/field_visitor"
+  autoload :Index, "syntax_tree/index"
+  autoload :JSONVisitor, "syntax_tree/json_visitor"
+  autoload :LanguageServer, "syntax_tree/language_server"
+  autoload :MatchVisitor, "syntax_tree/match_visitor"
+  autoload :Mermaid, "syntax_tree/mermaid"
+  autoload :MermaidVisitor, "syntax_tree/mermaid_visitor"
+  autoload :MutationVisitor, "syntax_tree/mutation_visitor"
+  autoload :Pattern, "syntax_tree/pattern"
+  autoload :PrettyPrintVisitor, "syntax_tree/pretty_print_visitor"
+  autoload :Search, "syntax_tree/search"
+  autoload :Translation, "syntax_tree/translation"
+  autoload :WithScope, "syntax_tree/with_scope"
+  autoload :YARV, "syntax_tree/yarv"
+
   # This holds references to objects that respond to both #parse and #format
   # so that we can use them in the CLI.
   HANDLERS = {}
   HANDLERS.default = SyntaxTree
 
-  # This is a hook provided so that plugins can register themselves as the
-  # handler for a particular file type.
-  def self.register_handler(extension, handler)
-    HANDLERS[extension] = handler
+  # This is the default print width when formatting. It can be overridden in the
+  # CLI by passing the --print-width option or here in the API by passing the
+  # optional second argument to ::format.
+  DEFAULT_PRINT_WIDTH = 80
+
+  # This is the default ruby version that we're going to target for formatting.
+  # It shouldn't really be changed except in very niche circumstances.
+  DEFAULT_RUBY_VERSION = Formatter::SemanticVersion.new(RUBY_VERSION).freeze
+
+  # The default indentation level for formatting. We allow changing this so
+  # that Syntax Tree can format arbitrary parts of a document.
+  DEFAULT_INDENTATION = 0
+
+  # Parses the given source and returns the formatted source.
+  def self.format(
+    source,
+    maxwidth = DEFAULT_PRINT_WIDTH,
+    base_indentation = DEFAULT_INDENTATION,
+    options: Formatter::Options.new
+  )
+    format_node(
+      source,
+      parse(source),
+      maxwidth,
+      base_indentation,
+      options: options
+    )
+  end
+
+  # Parses the given file and returns the formatted source.
+  def self.format_file(
+    filepath,
+    maxwidth = DEFAULT_PRINT_WIDTH,
+    base_indentation = DEFAULT_INDENTATION,
+    options: Formatter::Options.new
+  )
+    format(read(filepath), maxwidth, base_indentation, options: options)
+  end
+
+  # Accepts a node in the tree and returns the formatted source.
+  def self.format_node(
+    source,
+    node,
+    maxwidth = DEFAULT_PRINT_WIDTH,
+    base_indentation = DEFAULT_INDENTATION,
+    options: Formatter::Options.new
+  )
+    formatter = Formatter.new(source, [], maxwidth, options: options)
+    node.format(formatter)
+
+    formatter.flush(base_indentation)
+    formatter.output.join
+  end
+
+  # Indexes the given source code to return a list of all class, module, and
+  # method definitions. Used to quickly provide indexing capability for IDEs or
+  # documentation generation.
+  def self.index(source)
+    Index.index(source)
+  end
+
+  # Indexes the given file to return a list of all class, module, and method
+  # definitions. Used to quickly provide indexing capability for IDEs or
+  # documentation generation.
+  def self.index_file(filepath)
+    Index.index_file(filepath)
+  end
+
+  # A convenience method for creating a new mutation visitor.
+  def self.mutation
+    visitor = MutationVisitor.new
+    yield visitor
+    visitor
   end
 
   # Parses the given source and returns the syntax tree.
@@ -56,27 +145,46 @@ <h1>Syntax Tree</h1>
     response unless parser.error?
   end
 
-  # Parses the given source and returns the formatted source.
-  def self.format(source)
-    formatter = Formatter.new(source, [])
-    parse(source).format(formatter)
-
-    formatter.flush
-    formatter.output.join
+  # Parses the given file and returns the syntax tree.
+  def self.parse_file(filepath)
+    parse(read(filepath))
   end
 
   # Returns the source from the given filepath taking into account any potential
   # magic encoding comments.
   def self.read(filepath)
     encoding =
       File.open(filepath, "r") do |file|
+        break Encoding.default_external if file.eof?
+
         header = file.readline
-        header += file.readline if header.start_with?("#!")
+        header += file.readline if !file.eof? && header.start_with?("#!")
         Ripper.new(header).tap(&:parse).encoding
       end
 
     File.read(filepath, encoding: encoding)
   end
+
+  # This is a hook provided so that plugins can register themselves as the
+  # handler for a particular file type.
+  def self.register_handler(extension, handler)
+    HANDLERS[extension] = handler
+  end
+
+  # Searches through the given source using the given pattern and yields each
+  # node in the tree that matches the pattern to the given block.
+  def self.search(source, query, &block)
+    pattern = Pattern.new(query).compile
+    program = parse(source)
+
+    Search.new(pattern).scan(program, &block)
+  end
+
+  # Searches through the given file using the given pattern and yields each
+  # node in the tree that matches the pattern to the given block.
+  def self.search_file(filepath, query, &block)
+    search(read(filepath), query, &block)
+  end
 end
 </textarea>
       <textarea id="output" disabled readonly>Loading...</textarea>