Add a better CLI that will format files

exe/stree

@@ -3,9 +3,74 @@
 
 require_relative File.expand_path('../lib/syntax_tree', __dir__)
 
-source = ARGF.read
-program = SyntaxTree.new(source).parse
+help = <<~EOF
+  stree MDOE FILE
 
-pp program
-puts
-puts program.format
+  MODE: one of "a", "ast", "d", "doc", "f", or "format"
+  FILE: one or more paths to files to parse
+EOF
+
+if ARGV.length < 2
+  warn(help)
+  exit(1)
+end
+
+module SyntaxTree::CLI
+  class AST
+    def run(source)
+      pp SyntaxTree.parse(source)
+    end
+  end
+
+  class Doc
+    def run(source)
+      formatter = SyntaxTree::Formatter.new([])
+      SyntaxTree.parse(source).format(formatter)
+      pp formatter.groups.first
+    end
+  end
+
+  class Format
+    def run(source)
+      puts SyntaxTree.format(source)
+    end
+  end
+end
+
+mode =
+  case ARGV.shift
+  when 'a', 'ast'
+    SyntaxTree::CLI::AST.new
+  when 'd', 'doc'
+    SyntaxTree::CLI::Doc.new
+  when 'f', 'format'
+    SyntaxTree::CLI::Format.new
+  else
+    warn(help)
+    exit(1)
+  end
+
+queue = Queue.new
+ARGV.each { |pattern| Dir[pattern].each { |filepath| queue << filepath } }
+
+if queue.size <= 1
+  filepath = queue.shift
+  mode.run(File.read(filepath)) if File.file?(filepath)
+  return
+end
+
+count = [8, queue.size].min
+threads =
+  count.times.map do
+    Thread.new do
+      loop do
+        filepath = queue.shift
+        break if filepath == :exit
+
+        mode.run(File.read(filepath)) if File.file?(filepath)
+      end
+    end
+  end
+
+count.times { queue << :exit }
+threads.each(&:join)

lib/syntax_tree.rb

@@ -118,7 +118,6 @@ class Formatter < PP
 
     def initialize(*)
       super
-
       @stack = []
       @quote = '"'
     end
@@ -258,6 +257,16 @@ def self.parse(source)
     response unless parser.error?
   end
 
+  def self.format(source)
+    output = []
+
+    formatter = Formatter.new(output)
+    parse(source).format(formatter)
+
+    formatter.flush
+    output.join
+  end
+
   private
 
   # ----------------------------------------------------------------------------
@@ -8718,15 +8727,9 @@ def child_nodes
       [statements]
     end
 
-    def format
-      out = []
-      q = Formatter.new(out)
-
+    def format(q)
       q.format(statements)
       q.breakable(force: true)
-      q.flush
-
-      out.join
     end
 
     def pretty_print(q)

lib/syntax_tree/prettyprint.rb

@@ -344,7 +344,7 @@ def self.for(output)
   # output. If an IfBreak node is used, only the flat contents are printed.
   # LineSuffix nodes are printed at the end of the buffer when #flush is called.
   class SingleLine
-    # The output object. It stores rendered text and shoudl respond to <<.
+    # The output object. It stores rendered text and should respond to <<.
     attr_reader :output
 
     # The current array of contents that the print tree builder methods should
@@ -653,12 +653,17 @@ def self.visit(doc, visitor)
   end
 
   # The output object. It represents the final destination of the contents of
-  # the print tree. Its type is one of the classes in the Buffer module. Those
-  # classes all wrap an object that should respond to <<.
+  # the print tree. It should respond to <<.
   #
-  # This defaults to Buffer::StringBuffer.new('')
+  # This defaults to "".dup
   attr_reader :output
 
+  # This is an output buffer that wraps the output object and provides
+  # additional functionality depending on its type.
+  #
+  # This defaults to Buffer::StringBuffer.new("".dup)
+  attr_reader :buffer
+
   # The maximum width of a line, before it is separated in to a newline
   #
   # This defaults to 80, and should be an Integer
@@ -699,7 +704,8 @@ def self.visit(doc, visitor)
   # The block is used to generate spaces. ->(n) { ' ' * n } is used if it is not
   # given.
   def initialize(output = ''.dup, maxwidth = 80, newline = DEFAULT_NEWLINE, &genspace)
-    @output = Buffer.for(output)
+    @output = output
+    @buffer = Buffer.for(output)
     @maxwidth = maxwidth
     @newline = newline
     @genspace = genspace || DEFAULT_GENSPACE
@@ -772,7 +778,7 @@ def flush
 
       case doc
       when Text
-        doc.objects.each { |object| output << object }
+        doc.objects.each { |object| buffer << object }
         position += doc.width
       when Array
         doc.reverse_each { |part| commands << [indent, mode, part] }
@@ -781,7 +787,7 @@ def flush
       when Align
         commands << [indent.align(doc.indent), mode, doc.contents]
       when Trim
-        position -= output.trim!
+        position -= buffer.trim!
       when Group
         if mode == MODE_FLAT && !should_remeasure
           commands << [indent, doc.break? ? MODE_BREAK : MODE_FLAT, doc.contents]
@@ -813,7 +819,7 @@ def flush
             # groups).
             should_remeasure = true
           else
-            output << doc.separator
+            buffer << doc.separator
             position += doc.width
             next
           end
@@ -829,18 +835,18 @@ def flush
         end
 
         if !doc.indent?
-          output << newline
+          buffer << newline
 
           if indent.root
-            output << indent.root.value
+            buffer << indent.root.value
             position = indent.root.length
           else
             position = 0
           end
         else
-          position -= output.trim!
-          output << newline
-          output << indent.value
+          position -= buffer.trim!
+          buffer << newline
+          buffer << indent.value
           position = indent.length
         end
       when BreakParent
@@ -853,7 +859,7 @@ def flush
         #
         # This is useful behavior for putting marker nodes into the list so that
         # you can know how things are getting mapped before they get printed.
-        output << doc
+        buffer << doc
       end
 
       if commands.empty? && line_suffixes.any?
@@ -1079,7 +1085,7 @@ def fits?(next_command, rest_commands, remaining)
     # This is our output buffer, really only necessary to keep track of
     # because we could encounter a Trim doc node that would actually add
     # remaining space.
-    buffer = output.class.new
+    fit_buffer = buffer.class.new
 
     while remaining >= 0
       if commands.empty?
@@ -1094,7 +1100,7 @@ def fits?(next_command, rest_commands, remaining)
 
       case doc
       when Text
-        doc.objects.each { |object| buffer << object }
+        doc.objects.each { |object| fit_buffer << object }
         remaining -= doc.width
       when Array
         doc.reverse_each { |part| commands << [indent, mode, part] }
@@ -1103,7 +1109,7 @@ def fits?(next_command, rest_commands, remaining)
       when Align
         commands << [indent.align(doc.indent), mode, doc.contents]
       when Trim
-        remaining += buffer.trim!
+        remaining += fit_buffer.trim!
       when Group
         commands << [indent, doc.break? ? MODE_BREAK : mode, doc.contents]
       when IfBreak
@@ -1114,7 +1120,7 @@ def fits?(next_command, rest_commands, remaining)
         end
       when Breakable
         if mode == MODE_FLAT && !doc.force?
-          buffer << doc.separator
+          fit_buffer << doc.separator
           remaining -= doc.width
           next
         end

test/syntax_tree_test.rb

@@ -1024,10 +1024,7 @@ def test_zsuper
         .each_with_index do |source, index|
           define_method(:"test_formatting_#{basename}_#{index}") do
             original, expected = source.split("-\n")
-            expected ||= original
-
-            actual = SyntaxTree.new(original).parse.format
-            assert_equal(expected, actual)
+            assert_equal(expected || original, SyntaxTree.format(original))
           end
         end
     end