herb 0.10.4 → 0.11.0

data/lib/herb/dev/runner.rb

@@ -2,36 +2,39 @@
 # typed: ignore
 
 require_relative "../colors"
+require_relative "../configuration"
+require_relative "../diagnostic"
+require_relative "../diagnostic/formatter"
+require_relative "classifier"
 
 module Herb
   module Dev
     class Runner
       include Herb::Colors
 
-      PATCHABLE_TYPES = ["text_changed", "attribute_value_changed", "attribute_added", "attribute_removed"].freeze #: Array[String]
+      PATCHABLE_TYPES = Herb::Dev::Classifier::PATCHABLE_TYPES #: Array[String]
 
+      #: (Array[Herb::Diff::Operation]) -> bool
       def self.can_patch?(operations)
-        operations.all? { |operation|
-          next false unless PATCHABLE_TYPES.include?(operation.type.to_s)
-          next false if operation.new_node&.type&.to_s&.include?("ERB")
-          next false if operation.old_node&.type&.to_s&.include?("ERB")
-
-          true
-        }
+        Herb::Dev::Classifier.can_patch?(operations)
       end
 
-      CLEAR_SCREEN = "\e[2J\e[H"
-      HIDE_CURSOR = "\e[?25l"
-      SHOW_CURSOR = "\e[?25h"
+      CLEAR_SCREEN = "\e[2J\e[H" #: String
+      HIDE_CURSOR = "\e[?25l" #: String
+      SHOW_CURSOR = "\e[?25h" #: String
 
-      def initialize(path: ".", cli: nil)
+      #: (?path: String) -> void
+      def initialize(path: ".")
         @path = path
-        @cli = cli
       end
 
+      #: () -> void
       def run
+        $stdout.sync = true
+
         require_cruise
         require_relative "server"
+        require_relative "../dev"
 
         unless File.directory?(@path)
           puts "Not a directory: '#{@path}'."
@@ -44,13 +47,31 @@ module Herb
         check_existing_server(expanded_path)
         port = find_port
 
-        print CLEAR_SCREEN
-        print HIDE_CURSOR
+        terminal(CLEAR_SCREEN)
+        terminal(HIDE_CURSOR)
         print_header(config, expanded_path)
 
-        file_states = index_files(config, @path)
-
         websocket = Herb::Dev::Server.new(port: port, project_path: expanded_path)
+        pipeline = Herb::Dev::Pipeline.new(server: websocket, configuration: config)
+        pipeline.on_classified { |event, classification| paint(event, classification) }
+
+        @first_change = true
+        @broken_files = Set.new
+
+        websocket.on_welcome { pipeline.broken_entries }
+
+        websocket.on_client do |event, count|
+          announce_first_change
+          paint_client(event, count)
+        end
+
+        watcher = Herb::Dev::Watcher.new(config: config, root: expanded_path) do |event|
+          announce_first_change
+          pipeline.handle_event(event)
+        end
+
+        @broken_files = Set.new(index_files(watcher, pipeline))
+
         websocket.start
 
         puts "  #{fg("WebSocket:".ljust(11), 245)}#{fg("ws://localhost:#{websocket.port}", 250)}"
@@ -58,18 +79,20 @@ module Herb
         puts "  #{fg("Ready!", 42)} #{fg("Watching for changes...", 241)}"
         puts
 
-        watch_files(config, expanded_path, websocket, file_states)
+        watch_stdin
+        watcher.run
       rescue Interrupt
         websocket&.stop
-        print SHOW_CURSOR
+        terminal(SHOW_CURSOR)
         puts
         puts "Stopped."
         exit(0)
       ensure
         websocket&.stop
-        print SHOW_CURSOR
+        terminal(SHOW_CURSOR)
       end
 
+      #: () -> void
       def stop
         require_relative "server"
 
@@ -82,12 +105,18 @@ module Herb
 
         entries.each do |entry|
           entry.stop!
-          puts "Stopped herb dev server for #{entry.project_name} (PID: #{entry.pid}, port: #{entry.port})"
+
+          if entry.embedded?
+            puts "Stopped the server for #{entry.project_name} (PID: #{entry.pid}, port: #{entry.port}). The Herb dev server was embedded in it, so the whole server shut down."
+          else
+            puts "Stopped herb dev server for #{entry.project_name} (PID: #{entry.pid}, port: #{entry.port})"
+          end
         end
 
         exit(0)
       end
 
+      #: () -> void
       def restart
         require_relative "server"
 
@@ -96,6 +125,7 @@ module Herb
         run
       end
 
+      #: () -> void
       def status
         require_relative "server"
 
@@ -105,7 +135,7 @@ module Herb
           puts "No herb dev servers running."
         else
           entries.each do |entry|
-            puts "#{entry.project_name} — PID: #{entry.pid}, port: #{entry.port}, started: #{entry.started_at}"
+            puts "#{entry.project_name} — PID: #{entry.pid}, port: #{entry.port}, #{entry.kind}, started: #{entry.started_at}"
           end
         end
 
@@ -114,13 +144,38 @@ module Herb
 
       private
 
+      #: () -> bool
+      def interactive?
+        $stdout.tty?
+      end
+
+      #: (String) -> void
+      def terminal(sequence)
+        print sequence if interactive?
+      end
+
+      #: (String, Array[Herb::Diagnostic], String) -> void
+      def print_diagnostics(source, diagnostics, filename)
+        return if diagnostics.empty?
+
+        formatter = Herb::Diagnostic::Formatter.new(source, diagnostics, filename: filename)
+
+        formatter.format_all(highlight: enabled?).each_line do |line|
+          stripped = line.chomp
+
+          puts stripped.empty? ? "" : "  #{stripped}"
+        end
+      end
+
+      #: (Integer, String) -> String
       def pluralize(count, word)
         "#{count} #{word}#{"s" unless count == 1}"
       end
 
+      #: () -> void
       def require_cruise
-        require "cruise"
-      rescue LoadError
+        Herb.ensure_installed("cruise")
+      rescue StandardError
         abort <<~MESSAGE
           The 'cruise' gem is required for the Herb Dev Server.
 
@@ -132,18 +187,27 @@ module Herb
         MESSAGE
       end
 
+      #: (String) -> void
       def check_existing_server(expanded_path)
         existing = Herb::Dev::ServerEntry.find_by_project(expanded_path)
 
         return unless existing
 
-        puts "Herb dev server is already running for this project (PID: #{existing.pid}, port: #{existing.port})."
-        puts
-        puts "  herb dev stop       Stop the running server"
-        puts "  herb dev restart    Restart the server"
+        if existing.embedded?
+          puts "Herb dev server is already running for this project, embedded in another server for this app (PID: #{existing.pid}, port: #{existing.port})."
+          puts
+          puts "  herb dev stop       Stop it. The dev server lives inside that server, so this stops the whole server."
+        else
+          puts "Herb dev server is already running for this project (PID: #{existing.pid}, port: #{existing.port})."
+          puts
+          puts "  herb dev stop       Stop the running server"
+          puts "  herb dev restart    Restart the server"
+        end
+
         exit(1)
       end
 
+      #: () -> Integer
       def find_port
         port = Herb::Dev::Server::DEFAULT_PORT
         port_owner = Herb::Dev::ServerEntry.find_by_port(port)
@@ -156,6 +220,7 @@ module Herb
         port
       end
 
+      #: (Herb::Configuration, String) -> void
       def print_header(config, expanded_path)
         puts
         puts fg_bg(" \u{1F33F} Herb Dev Server ", 255, 28)
@@ -175,29 +240,29 @@ module Herb
         end
       end
 
-      def index_files(config, path)
-        puts "  #{fg("Indexing files...", 241)}"
+      #: (Watcher, Pipeline) -> Array[String]
+      def index_files(watcher, pipeline)
+        puts "  #{fg("Indexing files...", 241)}" if interactive?
 
-        file_states = {}
-        initial_files = config.find_files(path)
+        count = watcher.index(@path)
+        broken = pipeline.remember_broken(watcher.sources)
 
-        initial_files.each do |file_path|
-          file_states[file_path] = File.read(file_path)
-        rescue StandardError
-          # skip files that can't be read
-        end
+        terminal("\e[1A\e[2K")
+        puts "  #{fg("Files:".ljust(11), 245)}#{fg("#{pluralize(count, "template")} indexed", 250)}#{broken_summary(broken.size)}"
+
+        broken
+      end
 
-        print "\e[1A\e[2K"
-        puts "  #{fg("Files:".ljust(11), 245)}#{fg("#{file_states.size} templates indexed", 250)}"
+      #: (Integer) -> String
+      def broken_summary(broken)
+        return "" unless broken.positive?
 
-        file_states
+        fg(", #{broken} #{broken == 1 ? "doesn't" : "don't"} parse", 214)
       end
 
-      def watch_files(config, expanded_path, websocket, file_states)
-        include_patterns = config.file_include_patterns
-        exclude_patterns = config.file_exclude_patterns
-        first_change = true
-        errored_files = Set.new
+      #: () -> Thread?
+      def watch_stdin
+        return nil unless $stdin.tty?
 
         Thread.new do
           $stdin.gets(nil)
@@ -205,163 +270,96 @@ module Herb
         rescue IOError, Errno::EBADF
           Thread.main.raise(Interrupt)
         end
+      end
 
-        Cruise.watch(expanded_path, only: ["created", "modified", "removed"]) do |event|
-          file_path = event.path
-          relative_path = file_path.delete_prefix("#{expanded_path}/")
-
-          next if config.path_excluded?(relative_path, exclude_patterns)
-          next unless config.path_included?(relative_path, include_patterns)
-
-          if first_change
-            print "\e[2A\e[J"
-            puts "  #{fg("Recent changes:", 245)}"
-            puts
-            first_change = false
-          end
-
-          timestamp = fg(Time.now.strftime("%H:%M:%S.%L"), 241)
-          display_path = fg(relative_path, 250)
+      #: () -> void
+      def announce_first_change
+        return unless @first_change
 
-          case event.kind
-          when "created", "modified"
-            handle_file_change(file_path, relative_path, file_states, errored_files, websocket, timestamp, display_path)
-          when "removed"
-            file_states.delete(file_path)
-            badge = bold(fg("- removed", 196))
-            puts "    #{timestamp} #{badge} #{display_path}"
-          end
-        end
+        terminal("\e[2A\e[J")
+        puts "  #{fg("Recent changes:", 245)}"
+        puts
+        @first_change = false
       end
 
-      def handle_file_change(file_path, relative_path, file_states, errored_files, websocket, timestamp, display_path)
-        return unless File.exist?(file_path)
+      #: (Symbol, Integer) -> void
+      def paint_client(event, count)
+        timestamp = fg(Time.now.strftime("%H:%M:%S.%L"), 241)
+        badge = event == :connected ? bold(fg("+ client ", 75)) : bold(fg("- client ", 241))
 
-        current_content = File.read(file_path)
-        previous_content = file_states[file_path]
+        puts "    #{timestamp} #{badge} #{fg(event.to_s, 250)} #{fg("(#{count} open)", 241)}"
+      end
 
-        if previous_content.nil?
-          file_states[file_path] = current_content
-          badge = bold(fg("+ added  ", 42))
-          puts "    #{timestamp} #{badge} #{display_path}"
-          return
+      #: (Watcher::Event, Classifier::Classification?) -> void
+      def paint(event, classification)
+        timestamp = fg(Time.now.strftime("%H:%M:%S.%L"), 241)
+        display_path = fg(event.relative_path, 250)
+
+        case event.kind
+        when :removed
+          @broken_files.delete(event.relative_path)
+          puts "    #{timestamp} #{bold(fg("- removed", 196))} #{display_path}"
+        when :added
+          puts "    #{timestamp} #{bold(fg("+ added  ", 42))} #{display_path}"
+        when :changed
+          paint_change(event, classification, timestamp, display_path)
         end
+      end
 
-        return if previous_content == current_content && !errored_files.include?(file_path)
-
-        current_parse = Herb.parse(current_content, strict: true, analyze: true)
+      #: (Watcher::Event, Classifier::Classification, String, String) -> void
+      def paint_change(event, classification, timestamp, display_path)
+        case classification&.kind
+        when :parse_error
+          @broken_files.add(event.relative_path)
 
-        if current_parse.errors.any?
-          broadcast_errors(file_path, relative_path, current_parse, previous_content, errored_files, websocket, timestamp, display_path)
-          return
-        end
+          errors = new_errors(event, classification)
 
-        if errored_files.delete?(file_path)
-          broadcast_fixed(file_path, relative_path, current_content, file_states, websocket, timestamp, display_path)
-          return
+          unless errors.empty?
+            print "    #{timestamp} #{bold(fg("\u{2717} error", 196))}"
+            print_diagnostics(event.current.to_s, Herb::Diagnostic.from_errors(errors, template: event.relative_path), event.relative_path)
+            puts
+          end
+        when :none, :whitespace, nil
+          paint_cleared(event, timestamp, display_path)
+        else
+          if @broken_files.include?(event.relative_path)
+            paint_cleared(event, timestamp, display_path)
+          else
+            print_diff_summary(classification, timestamp, display_path)
+          end
         end
-
-        handle_diff(file_path, relative_path, current_content, previous_content, file_states, websocket, timestamp, display_path)
       end
 
-      def broadcast_errors(file_path, relative_path, current_parse, previous_content, errored_files, websocket, timestamp, display_path)
-        current_errors = current_parse.errors
-
-        previous_parse = Herb.parse(previous_content, strict: true, analyze: true)
-        previous_errors = previous_parse.errors
+      #: (Watcher::Event, Classifier::Classification) -> Array[Herb::Errors::Error]
+      def new_errors(event, classification)
+        previous_errors = Herb.parse(event.previous.to_s, strict: true, analyze: true).errors
 
-        new_errors = current_errors.select { |error|
+        classification.errors.select { |error|
           previous_errors.none? { |previous_error|
             previous_error.error_name == error.error_name && previous_error.location.start.line == error.location.start.line
           }
         }
-
-        badge = bold(fg("\u{2717} error  ", 196))
-        puts "    #{timestamp} #{badge} #{display_path} #{fg("(#{pluralize(current_errors.size, "error")})", 241)}"
-
-        new_errors.each do |error|
-          location = fg("#{relative_path}:#{error.location.start.line}:#{error.location.start.column}", 241)
-          puts "                        #{fg(error.error_name, 196)} #{location}"
-          puts "                        #{fg(error.message, 250)}" if error.message && !error.message.empty?
-        end
-
-        errored_files.add(file_path)
-
-        if websocket.client_count.positive?
-          websocket.broadcast({
-            type: "error",
-            file: relative_path,
-            errors: current_errors.map { |error|
-              {
-                name: error.error_name,
-                message: error.message,
-                line: error.location.start.line,
-                column: error.location.start.column,
-              }
-            },
-          })
-        end
-
-        puts
       end
 
-      def broadcast_fixed(file_path, relative_path, current_content, file_states, websocket, timestamp, display_path)
-        file_states[file_path] = current_content
-        badge = bold(fg("\u{2713} fixed  ", 42))
-        puts "    #{timestamp} #{badge} #{display_path}"
-
-        if websocket.client_count.positive?
-          websocket.broadcast({ type: "fixed", file: relative_path })
-        end
+      #: (Watcher::Event, String, String) -> void
+      def paint_cleared(event, timestamp, display_path)
+        return unless @broken_files.delete?(event.relative_path)
 
+        puts "    #{timestamp} #{bold(fg("\u{2713} clear  ", 42))} #{display_path}"
         puts
       end
 
-      def handle_diff(file_path, relative_path, current_content, previous_content, file_states, websocket, timestamp, display_path)
-        diff_result = Herb.diff(previous_content, current_content)
-        file_states[file_path] = current_content
-
-        return if diff_result.identical?
-
-        operations = diff_result.operations
-        can_patch = self.class.can_patch?(operations)
-
-        if can_patch && websocket.client_count.positive?
-          patch_operations = operations.map do |operation|
-            {
-              type: operation.type.to_s,
-              path: operation.path,
-              old_value: extract_node_value(operation.old_node),
-              new_value: extract_node_value(operation.new_node),
-              old_node_type: operation.old_node&.type,
-              new_node_type: operation.new_node&.type,
-            }
-          end
-
-          websocket.broadcast({
-            type: "patch",
-            file: relative_path,
-            operations: patch_operations,
-          })
-        elsif !can_patch && websocket.client_count.positive?
-          websocket.broadcast({
-            type: "reload",
-            file: relative_path,
-          })
-        end
-
-        print_diff_summary(operations, can_patch, websocket, timestamp, display_path)
-      end
+      #: (Classifier::Classification, String, String) -> void
+      def print_diff_summary(classification, timestamp, display_path)
+        operations = classification.operations
 
-      def print_diff_summary(operations, can_patch, websocket, timestamp, display_path)
-        badge = if can_patch
-                  bold(fg("\u{2713} patch ", 42))
+        badge = if classification.kind == :static
+                  bold(fg("\u{2713} static ", 42))
                 else
-                  bold(fg("\u{21BB} reload ", 214))
+                  bold(fg("\u{21BB} fetch  ", 214))
                 end
 
-        clients_label = websocket.client_count.positive? ? " #{fg("[#{pluralize(websocket.client_count, "client")}]", 241)}" : ""
-        puts "    #{timestamp} #{badge} #{display_path} #{fg("(#{pluralize(operations.size, "operation")})", 241)}#{clients_label}"
+        puts "    #{timestamp} #{badge} #{display_path} #{fg("(#{pluralize(operations.size, "operation")})", 241)}"
 
         operations.each_with_index do |operation, index|
           type = operation.type.to_s
@@ -391,6 +389,7 @@ module Herb
         puts
       end
 
+      #: (String, String, Integer, Herb::AST::Node, String) -> void
       def print_diff_node(indent, sign, color, node, _type)
         value = extract_node_value(node)
 
@@ -405,6 +404,7 @@ module Herb
         end
       end
 
+      #: (Herb::AST::Node?) -> String?
       def extract_node_value(node)
         return nil unless node
 
@@ -412,7 +412,7 @@ module Herb
           return node.content&.to_s
         end
 
-        if node.is_a?(Herb::AST::ERBContentNode)
+        if node.is_a?(Herb::AST::ERBContentNode) || node.is_a?(Herb::AST::ERBCommentNode) || node.is_a?(Herb::AST::HerbDirectiveNode) || node.is_a?(Herb::AST::HerbStateDirectiveNode)
           return node.content&.value&.to_s
         end