Module: SyntaxTree::CLI

Defined in:

lib/syntax_tree/cli.rb

Overview

Syntax Tree ships with the ‘stree` CLI, which can be used to inspect and manipulate Ruby code. This module is responsible for powering that CLI.

Defined Under Namespace

Classes: AST, Action, Check, Color, Debug, Doc, Format, Json, Match, Write

Constant Summary

HELP =

The help message displayed if the input arguments are not correctly ordered or formatted.

<<~HELP
  #{Color.bold("stree ast [OPTIONS] [FILE]")}
    Print out the AST corresponding to the given files

  #{Color.bold("stree check [OPTIONS] [FILE]")}
    Check that the given files are formatted as syntax tree would format them

  #{Color.bold("stree debug [OPTIONS] [FILE]")}
    Check that the given files can be formatted idempotently

  #{Color.bold("stree doc [OPTIONS] [FILE]")}
    Print out the doc tree that would be used to format the given files

  #{Color.bold("stree format [OPTIONS] [FILE]")}
    Print out the formatted version of the given files

  #{Color.bold("stree json [OPTIONS] [FILE]")}
    Print out the JSON representation of the given files

  #{Color.bold("stree match [OPTIONS] [FILE]")}
    Print out a pattern-matching Ruby expression that would match the given files

  #{Color.bold("stree help")}
    Display this help message

  #{Color.bold("stree lsp")}
    Run syntax tree in language server mode

  #{Color.bold("stree version")}
    Output the current version of syntax tree

  #{Color.bold("stree write [OPTIONS] [FILE]")}
    Read, format, and write back the source of the given files

  [OPTIONS]

  --plugins=...
    A comma-separated list of plugins to load.
HELP

Class Method Summary

• .run(argv) ⇒ Object

  Run the CLI over the given array of strings that make up the arguments passed to the invocation.

Class Method Details

.run(argv) ⇒ Object

Run the CLI over the given array of strings that make up the arguments passed to the invocation.

# File 'lib/syntax_tree/cli.rb', line 201

def run(argv)
  name, *arguments = argv

  case name
  when "help"
    puts HELP
    return 0
  when "lsp"
    require "syntax_tree/language_server"
    LanguageServer.new.run
    return 0
  when "version"
    puts SyntaxTree::VERSION
    return 0
  end

  action =
    case name
    when "a", "ast"
      AST.new
    when "c", "check"
      Check.new
    when "debug"
      Debug.new
    when "doc"
      Doc.new
    when "j", "json"
      Json.new
    when "m", "match"
      Match.new
    when "f", "format"
      Format.new
    when "w", "write"
      Write.new
    else
      warn(HELP)
      return 1
    end

  # If we're not reading from stdin and the user didn't supply and
  # filepaths to be read, then we exit with the usage message.
  if $stdin.tty? && arguments.empty?
    warn(HELP)
    return 1
  end

  # If there are any plugins specified on the command line, then load them
  # by requiring them here. We do this by transforming something like
  #
  #     stree format --plugins=haml template.haml
  #
  # into
  #
  #     require "syntax_tree/haml"
  #
  if arguments.first&.start_with?("--plugins=")
    plugins = arguments.shift[/^--plugins=(.*)$/, 1]
    plugins.split(",").each { |plugin| require "syntax_tree/#{plugin}" }
  end

  # Track whether or not there are any errors from any of the files that
  # we take action on so that we can properly clean up and exit.
  errored = false

  each_file(arguments) do |handler, filepath, source|
    action.run(handler, filepath, source)
  rescue Parser::ParseError => error
    warn("Error: #{error.message}")
    highlight_error(error, source)
    errored = true
  rescue Check::UnformattedError, Debug::NonIdempotentFormatError
    errored = true
  rescue StandardError => error
    warn(error.message)
    warn(error.backtrace)
    errored = true
  end

  if errored
    action.failure
    1
  else
    action.success
    0
  end
end