simple_english 0.3.0 → 0.4.0

data/lib/simple_english/{server.rb → daemon/server.rb}

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 # The se daemon: process lifecycle only. The wire protocol lives in
-# lib/simple_english/http.rb, the lint engine in lib/simple_english/engine.rb.
+# lib/simple_english/daemon/http.rb, the lint engine in
+# lib/simple_english/daemon/engine.rb.
 # Failures raise typed errors (PortInUse, SetupError, InnerDied,
 # InnerTimeout). bin/se owns turning them into warnings and exit codes.
 
@@ -11,7 +12,10 @@ require "socket"
 require "tempfile"
 require "tmpdir"
 
-require_relative "install"
+require_relative "../setup/install"
+require_relative "../client/daemon"
+require_relative "../setup/fingerprint"
+require_relative "../version"
 
 module SimpleEnglish
   module Server
@@ -40,24 +44,123 @@ module SimpleEnglish
     # Probes both loopback families: on IPv6-first resolvers a "localhost"
     # probe falls back to IPv4 and misses an IPv6 listener.
     def assert_port_free(port)
+      raise PortInUse, port unless port_free?(port)
+    end
+
+    def port_free?(port)
       ["127.0.0.1", "::1"].each do |address|
         TCPServer.new(address, port).close
-      rescue Errno::EADDRNOTAVAIL
+      rescue Errno::EADDRNOTAVAIL, Errno::EAFNOSUPPORT
+        # One family may be missing on this host (EADDRNOTAVAIL, or
+        # EAFNOSUPPORT when the kernel has no IPv6 at all): skip it
+        # and probe the other. A rescue at method scope returns here
+        # and never probes the second family.
         next
       end
+      true
     rescue Errno::EADDRINUSE
-      raise PortInUse, port
+      false
     rescue Errno::EACCES
       raise ServerError, "port #{port} cannot be bound. Use a port above 1024."
     end
 
+    # `se serve` over a live daemon (gem upgrade): when
+    # one of our daemons holds the port (it answers the
+    # handshake), stop it and take over the port. A service that
+    # does not answer the handshake, pre-handshake daemon included,
+    # keeps the PortInUse error: those need a manual look.
+    def takeover(port)
+      daemon = Client.info(base_url: "http://localhost:#{port}")
+      return unless daemon.is_a?(Hash)
+      stop(daemon["pid"])
+      # The outer listener closes first. The inner JVM takes seconds
+      # longer. Both ports must free, or the next boot hits the inner
+      # port and dies.
+      deadline = Time.now + 10
+      sleep 0.2 until Time.now > deadline ||
+          !Client.info(base_url: "http://localhost:#{port}").is_a?(Hash) &&
+              port_free?(port + 1)
+    end
+
+    # Graceful only. SIGKILL skips the TERM trap and the inner JVM
+    # teardown. The orphan still holds port + 1 and breaks the next
+    # boot. The pid comes off the wire, so only a positive integer is
+    # TERMed: 0 signals the caller's own process group, a negative
+    # one every process the user may signal.
+    def stop(pid)
+      return nil unless pid.is_a?(Integer) && pid > 1
+      Process.kill("TERM", pid)
+    rescue Errno::ESRCH, Errno::EPERM
+      nil
+    end
+
+    # Everything a boot needs on the machine, checked before the
+    # takeover stops the old daemon: a reload that cannot boot must
+    # leave the running daemon alive.
+    def preflight_install(install)
+      return if File.exist?(install.server_jar) && install.java?
+      raise Install::SetupError,
+        install.java? ? install.setup_error : install.java_message
+    end
+    private_class_method :preflight_install
+
+    # `se serve --detached`: replace any se daemon on the port, then
+    # boot a plain foreground serve as a detached child - the same
+    # shape the auto-boot spawns. The parent returns once the
+    # handshake answers. nil means the child never came up, and the
+    # visible serve (same command, no flag) shows why. dev_log is
+    # forwarded so a detached daemon can still get a log file.
+    def start_detached(port: Client::DEFAULT_PORT, install: Install.from_env,
+      dev_log: nil)
+      preflight_install(install)
+      takeover(port)
+      # A foreign port holder survives the takeover untouched: fail
+      # in milliseconds like the foreground boot, not after the
+      # 90 s spawn timeout.
+      assert_port_free(port)
+      assert_port_free(port + 1)
+      args = ["--port", port.to_s]
+      args.concat(["--dev-log", dev_log]) if dev_log
+      pid = Client.spawn_daemon(*args)
+      # The child gives its inner JVM TIMEOUT_SECONDS to boot, and
+      # the handshake answers only after that: wait the child's own
+      # budget, not the default 90 s, or a slow boot reads as
+      # failure while the child is still coming up.
+      daemon = Client.wait_for(
+        seconds: SimpleEnglish::LanguageTool::TIMEOUT_SECONDS + 10
+      ) { Client.info(base_url: "http://localhost:#{port}") }
+      return daemon if daemon.is_a?(Hash)
+      # Readiness failed. The child is either dead (InnerTimeout and
+      # InnerDied make it exit itself) or a straggler that later
+      # takes over the port from whatever daemon comes next.
+      # Stop it either way, and reap so nothing is left behind.
+      stop(pid)
+      begin
+        Process.wait(pid)
+      rescue SystemCallError
+        # The child already exited on its own (InnerTimeout,
+        # InnerDied): only the reap is left.
+      end
+      nil
+    end
+
     def start(port: Client::DEFAULT_PORT, install: Install.from_env, log: $stderr)
+      rules_dir = Dir.mktmpdir("se-rules")
+      # The enabled IDs come from the staged file, so what LT loads
+      # and what each request enables can never diverge.
+      staged = stage_rules(rules_dir)
+      enabled_rules = SimpleEnglish::LanguageTool.rule_ids
+      daemon_info = {"version" => VERSION, "pid" => Process.pid,
+                     "gem_digest" => Fingerprint.gem,
+                     "rules_digest" => Fingerprint.sha(File.read(staged))}
+      # Preflight everything the replacement needs before the
+      # takeover stops the old daemon.
+      preflight_install(install)
+      takeover(port)
       assert_port_free(port)
       # The inner JVM lives on port + 1. Guard it too so an occupied
       # inner port raises in milliseconds instead of timing out later.
       assert_port_free(port + 1)
-      rules_dir = Dir.mktmpdir("se-rules")
-      stage_rules(rules_dir)
       # The inner JVM's stderr goes to a file so failure messages can quote
       # its first line. Only an explicitly opened dev log (a File) is reused
       # for that. $stderr reports path "<STDERR>", so it creates a file
@@ -103,7 +206,10 @@ module SimpleEnglish
         # Select timeout on an idle socket: loop back and select again.
         next if ready.nil?
         client = server.accept
-        Thread.new(client) { |c| HTTP.handle_client(c, port: port) }
+        Thread.new(client) { |c|
+          HTTP.handle_client(c, port: port,
+            enabled_rules: enabled_rules, info: daemon_info)
+        }
       rescue IOError, Errno::EBADF
         # A trap or the inner-death monitor closed the listener. This
         # happens during the select, or between select and accept.

data/lib/simple_english/lint/lint_plan.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# One decision, two callers: the CLI (SimpleEnglish.lint_file) and
+# the daemon (Engine.lint) must agree on what kind of lint an input
+# is. The CLI decides to skip comment-free files without a boot.
+# The daemon decides again on its side of the wire. Both call this
+# module, so the two tiers cannot drift.
+
+module SimpleEnglish
+  module LintPlan
+    module_function
+
+    # Returns :prose when there is no language (the Markdown
+    # pipeline), nil for a comment-free code file (nothing to lint:
+    # no boot, no POST), or the comment spans for a code file.
+    def call(text, language)
+      return :prose unless language
+      spans = SimpleEnglish::Extractor.comment_spans(text, language)
+      spans.empty? ? nil : spans
+    end
+  end
+end

data/lib/simple_english/lint/plain_text.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module SimpleEnglish
+  # The plain-text payload for /v2/check, duck-compatible with
+  # AnnotatedText::Result: #lt_params and #locate.
+  PlainText = Struct.new(:text) do
+    def lt_params
+      {"text" => text}
+    end
+
+    # LanguageTool reports offsets in Java UTF-16 code units.
+    # Return a 1-based line and UTF-16 column for a 0-based offset.
+    def locate(utf16_offset)
+      line = 1
+      column = 1
+      units = 0
+      text.each_char do |char|
+        return [line, column] if units >= utf16_offset
+        units += (char.ord > 0xFFFF) ? 2 : 1
+        if char == "\n"
+          line += 1
+          column = 1
+        else
+          column += (char.ord > 0xFFFF) ? 2 : 1
+        end
+      end
+      [line, column]
+    end
+  end
+end

data/lib/simple_english/{result.rb → lint/result.rb}

@@ -3,7 +3,7 @@
 module SimpleEnglish
   module AnnotatedText
     # The payload for code comments. Duck interface shared with
-    # Client::PlainText: #lt_params (the form data for LanguageTool)
+    # PlainText: #lt_params (the form data for LanguageTool)
     # and #locate (a match offset back to file line and column).
     Result = Struct.new(:source, :segments, :stream) do
       def lt_params

data/lib/simple_english/{config.rb → setup/config.rb}

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-# .simple-english.yml: ignore (path globs, matched against the paths given
-# on the command line) and disabled-rules. Loaded from the CWD.
+# .simple-english.yml: ignore (path globs, matched against the paths
+# given on the command line) and disabled-rules (rule IDs dropped
+# from every file). Loaded from the CWD.
 
 module SimpleEnglish
   module Config

data/lib/simple_english/setup/fingerprint.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# Fingerprints for the daemon handshake. `gem` identifies the code and
+# built-in rules a daemon runs: any release that changes lint behavior
+# changes it, and nothing else does. `sha` covers the staged rule
+# content wherever the caller resolved it.
+
+require_relative "languagetool"
+
+module SimpleEnglish
+  module Fingerprint
+    module_function
+
+    # Hash everything the daemon can execute, not a curated list: a
+    # curated list goes stale the first time a new file is forgotten,
+    # and a missed file means silent staleness, the exact bug the
+    # handshake exists to catch. The accepted cost: a release that
+    # only changes caller-side code triggers one needless restart.
+    # ponytail: whole-lib glob. If restarts ever hurt, curate per-file.
+    def gem
+      files = Dir.glob(File.expand_path("../../**/*.rb", __dir__)).sort
+      files << LanguageTool::RULES_FILE
+      # Each file is length-prefixed: bare concatenation cannot tell
+      # ["ab", "c"] from ["a", "bc"], so bytes moved across a file
+      # boundary leave the digest unchanged.
+      framed = files.map do |path|
+        content = File.read(path)
+        "#{content.bytesize}\n#{content}"
+      end
+      sha(framed.join)
+    end
+
+    def sha(content)
+      require "digest"
+      ::Digest::SHA256.hexdigest(content)
+    end
+  end
+end

data/lib/simple_english/{install.rb → setup/install.rb}

@@ -13,11 +13,12 @@ module SimpleEnglish
     class SetupError < StandardError
     end
 
-    attr_reader :cache_dir, :java
+    attr_reader :cache_dir, :java, :java_source
 
-    def initialize(cache_dir:, java: nil)
+    def initialize(cache_dir:, java: nil, java_source: nil)
       @cache_dir = cache_dir
       @java = java
+      @java_source = java_source
     end
 
     # The one place the environment is read. SE_JAVA wins outright,
@@ -25,15 +26,21 @@ module SimpleEnglish
     # Otherwise the code probes the PATH candidate by running it,
     # because a file can exist and still be the macOS stub that
     # reports no runtime. The last resort is the Homebrew location,
-    # which sits outside PATH.
+    # which sits outside PATH. java_source records which of the three
+    # won, so `se setup` can say so.
     def self.from_env(env = ENV)
       cache = File.expand_path(env.fetch(LanguageTool::CACHE_DIR_ENV) do
         File.join(Dir.home, ".cache", "se")
       end)
-      java = env[LanguageTool::JAVA_ENV] ||
-        ("java" if probe?("java", env)) ||
-        (LanguageTool::HOMEBREW_JAVA if File.executable?(LanguageTool::HOMEBREW_JAVA))
-      new(cache_dir: cache, java: java)
+      java, source =
+        if (explicit = env[LanguageTool::JAVA_ENV])
+          [explicit, :env]
+        elsif probe?("java", env)
+          ["java", :path]
+        elsif File.executable?(LanguageTool::HOMEBREW_JAVA)
+          [LanguageTool::HOMEBREW_JAVA, :homebrew]
+        end
+      new(cache_dir: cache, java: java, java_source: source)
     end
 
     # Runs the candidate under the given PATH, isolated from this
@@ -50,8 +57,11 @@ module SimpleEnglish
 
     def java!
       return java if java?
-      raise SetupError,
-        "java not found. Install a JRE (on macOS: brew install openjdk), " \
+      raise SetupError, java_message
+    end
+
+    def java_message
+      "java not found. Install a JRE (on macOS: brew install openjdk), " \
         "or set SE_JAVA to your java binary."
     end
 

data/lib/simple_english/setup/languagetool.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+# The pinned LanguageTool distro: its version, its rules file, and the
+# downloader. Everything that resolves "where it is on this machine and
+# which java runs it" lives in Install. The engine runs as the daemon's
+# inner HTTP server (lib/simple_english/daemon/server.rb).
+
+module SimpleEnglish
+  module LanguageTool
+    RULES_FILE = File.expand_path("../../../rules/simple-english.xml", __dir__)
+    # The only place a LanguageTool version number appears. `se
+    # setup` downloads this version, and every jar path derives from it. No
+    # env var can point at another one.
+    LT_VERSION = "6.6"
+    CACHE_DIR_ENV = "SE_CACHE_DIR"
+    JAVA_ENV = "SE_JAVA"
+    # macOS ships a /usr/bin/java stub that reports no runtime. Homebrew
+    # installs the real one here, outside PATH.
+    HOMEBREW_JAVA = "/opt/homebrew/opt/openjdk/bin/java"
+    TIMEOUT_SECONDS = 300
+
+    module_function
+
+    # Download and unpack the pinned LanguageTool into DIR. Idempotent:
+    # returns {"dir" => install dir, "downloaded" => bool} so `se setup`
+    # can say what it found and what it fetched, or nil after warning
+    # why. Pure Ruby throughout: the download uses Net::HTTP and the
+    # unpack parses the zip with stdlib Zlib, so setup needs no curl,
+    # unzip, or unpack gem on the machine.
+    def install(dir)
+      require "fileutils"
+      dest = File.join(dir, "LanguageTool-#{LT_VERSION}")
+      if File.exist?(File.join(dest, "languagetool-commandline.jar"))
+        remove_stale_versions(dir, dest)
+        return {"dir" => dest, "downloaded" => false}
+      end
+      zip = File.join(dir, "LanguageTool-#{LT_VERSION}.zip")
+      FileUtils.mkdir_p(dir)
+      return nil unless download(download_url, zip)
+      return nil unless extract(zip, dir)
+      File.delete(zip)
+      remove_stale_versions(dir, dest)
+      {"dir" => dest, "downloaded" => true}
+    end
+
+    def download_url
+      "https://languagetool.org/download/LanguageTool-#{LT_VERSION}.zip"
+    end
+
+    # Streams URL to TO and follows redirects. Warns and returns false
+    # on any transport or HTTP failure, so callers never see a stack
+    # trace.
+    def download(url, to, redirects: 3)
+      require "net/http"
+      uri = URI(url)
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https",
+        open_timeout: 10, read_timeout: 60) do |http|
+        http.request(Net::HTTP::Get.new(uri)) do |response|
+          case response
+          when Net::HTTPRedirection
+            return false if redirects.zero?
+            return download(response["location"], to, redirects: redirects - 1)
+          when Net::HTTPSuccess
+            File.binwrite(to, "")
+            File.open(to, "wb") do |file|
+              response.read_body { |chunk| file.write(chunk) }
+            end
+            return true
+          else
+            warn "error: download failed: HTTP #{response.code} from #{url}"
+            return false
+          end
+        end
+      end
+    rescue SystemCallError, SocketError, Timeout::Error,
+      OpenSSL::SSL::SSLError, Net::ProtocolError => e
+      warn "error: download failed: #{e.class}: #{e.message}"
+      false
+    end
+
+    # Unpacks ZIP into DIR on stdlib Zlib: the End of Central Directory
+    # record locates the central directory, each entry names a local
+    # header, and each stream inflates raw. The input is the one pinned
+    # LanguageTool distro, not arbitrary archives, so zip64 (4 GB+ or
+    # 65,535+ entries) is refused, not parsed. Warns and returns false
+    # on any failure.
+    def extract(zip, dir)
+      require "fileutils"
+      require "zlib"
+      bytes = File.binread(zip)
+      tail = eocd(bytes)
+      raise Zlib::DataError, "not a zip archive" if tail.nil?
+      count, cd_offset = tail
+      pos = cd_offset
+      count.times do
+        name, method, csize, crc, local, pos = cd_entry(bytes, pos)
+        raise Zlib::DataError, "corrupt central directory" if name.nil?
+        next if name.end_with?("/")
+        target = safe_entry_target(dir, name)
+        if target.nil?
+          warn "error: zip entry escapes the install dir: #{name}"
+          return false
+        end
+        data_at = local_data_offset(bytes, local)
+        raise Zlib::DataError, "corrupt local header" if data_at.nil?
+        data = inflate_entry(bytes.byteslice(data_at, csize), method)
+        raise Zlib::DataError, "CRC mismatch: #{name}" unless Zlib.crc32(data) == crc
+        FileUtils.mkdir_p(File.dirname(target))
+        File.binwrite(target, data)
+      end
+      true
+    rescue Zlib::Error, SystemCallError => e
+      warn "error: unpack failed: #{e.class}: #{e.message}"
+      false
+    end
+
+    # The End of Central Directory record: the entry count and the
+    # central directory offset, or nil. The record ends the archive,
+    # possibly behind a comment of at most 65,535 bytes, so the scan
+    # starts at the tail. Zip64 sentinels are refused: the pinned
+    # distro is far under the limits.
+    def eocd(bytes)
+      limit = [bytes.bytesize, 65_557].min
+      window = bytes.byteslice(bytes.bytesize - limit, limit)
+      at = window.rindex("PK\x05\x06")
+      return nil if at.nil?
+      rec = window.byteslice(at, 22)
+      return nil if rec.bytesize < 22
+      count = rec.byteslice(10, 2).unpack1("v")
+      cd = rec.byteslice(16, 4).unpack1("V")
+      return nil if count == 0xFFFF || cd == 0xFFFFFFFF
+      [count, cd]
+    end
+
+    # One central-directory record at POS: the entry name,
+    # compression method, compressed size, CRC-32, local header
+    # offset, and the offset of the next record. nil when the record
+    # is truncated or unsigned.
+    def cd_entry(bytes, pos)
+      head = bytes.byteslice(pos, 46)
+      return nil unless head.byteslice(0, 4) == "PK\x01\x02" && head.bytesize == 46
+      name_len = head.byteslice(28, 2).unpack1("v")
+      name = bytes.byteslice(pos + 46, name_len)
+      [name,
+        head.byteslice(10, 2).unpack1("v"),
+        head.byteslice(20, 4).unpack1("V"),
+        head.byteslice(16, 4).unpack1("V"),
+        head.byteslice(42, 4).unpack1("V"),
+        pos + 46 + name_len + head.byteslice(30, 2).unpack1("v") +
+          head.byteslice(32, 2).unpack1("v")]
+    end
+
+    # Where an entry's data sits: the local header at OFFSET names
+    # its own name and extra lengths, and the data follows them. nil
+    # when the header is truncated or unsigned.
+    def local_data_offset(bytes, offset)
+      head = bytes.byteslice(offset, 30)
+      return nil unless head.byteslice(0, 4) == "PK\x03\x04" && head.bytesize == 30
+      offset + 30 + head.byteslice(26, 2).unpack1("v") +
+        head.byteslice(28, 2).unpack1("v")
+    end
+
+    # One entry's bytes: STORED is copied, DEFLATE is inflated raw.
+    def inflate_entry(blob, method)
+      return blob if method.zero?
+      return Zlib::Inflate.new(-Zlib::MAX_WBITS).inflate(blob) if method == 8
+      raise Zlib::DataError, "unsupported compression method #{method}"
+    end
+
+    # The path to write zip entry NAME into, or nil when NAME escapes
+    # DIR. A download is untrusted input: this is the zip-slip
+    # guard.
+    def safe_entry_target(dir, name)
+      target = File.expand_path(File.join(dir, name))
+      base = File.expand_path(dir) + File::SEPARATOR
+      target.start_with?(base) ? target : nil
+    end
+
+    # One gem version pins one LanguageTool version. Older dirs are
+    # hundreds of MB each, so delete them on every setup run and keep
+    # only the current version (and any zips: they are re-deleted or
+    # re-extracted by their own flow).
+    def remove_stale_versions(dir, keep)
+      require "fileutils"
+      Dir.glob(File.join(dir, "LanguageTool-*")).each do |entry|
+        FileUtils.rm_rf(entry) if File.directory?(entry) && entry != keep
+      end
+    end
+
+    # Proves the installation works end to end: java runs the
+    # commandline jar and the custom rules load. The command exits
+    # nonzero on a broken java, a corrupt jar, or invalid rules XML,
+    # so setup can report a real verdict instead of "files exist".
+    # Returns a boolean, never raises or warns: the caller owns the
+    # message.
+    def smoke(install)
+      rule = rule_ids.first
+      return false if rule.nil?
+      require "tmpdir"
+      Dir.mktmpdir do |dir|
+        text = File.join(dir, "smoke.txt")
+        File.write(text, "Check this sentence.\n")
+        system(install.java!, "-jar", install.commandline_jar,
+          "--language", "en", "--rulefile", RULES_FILE,
+          "--enable", rule, "--enabledonly", text,
+          out: File::NULL, err: File::NULL) ? true : false
+      end
+    end
+
+    # All rule IDs in RULES_FILE, in document order. The tag scan pairs each opening rule or rulegroup
+    # tag with the id attribute inside it, so attribute order never
+    # matters. It reads the repo's own file, which the test suite
+    # round-trips through LanguageTool, so malformed XML fails the
+    # build, not the boot. The daemon's enabledRules parameter on
+    # every lint request needs this list. A rule LT loads but the
+    # list omits is dead, because enabledOnly is set.
+    # examples_check asserts this list against a real XML parser,
+    # and LT itself rejects duplicate ids at load, so no dedup is
+    # needed here.
+    def rule_ids(path = RULES_FILE)
+      File.read(path).scan(/<(?:rule|rulegroup)\b[^>]*>/).filter_map do |tag|
+        tag[/\bid="([^"]+)"/, 1]
+      end
+    end
+  end
+end

data/lib/simple_english/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SimpleEnglish
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/simple_english.rb

@@ -5,19 +5,23 @@
 # This file is the composition root. The pieces live in lib/simple_english/.
 
 require_relative "simple_english/version"
-require_relative "simple_english/finding"
-require_relative "simple_english/markdown"
-require_relative "simple_english/counts"
-require_relative "simple_english/languagetool"
-require_relative "simple_english/install"
-require_relative "simple_english/extractor"
-require_relative "simple_english/annotated_text"
-require_relative "simple_english/suppressions"
-require_relative "simple_english/config"
-require_relative "simple_english/engine"
-require_relative "simple_english/http"
-require_relative "simple_english/client"
-require_relative "simple_english/server"
+require_relative "simple_english/lint/finding"
+require_relative "simple_english/lint/paragraph"
+require_relative "simple_english/lint/markdown"
+require_relative "simple_english/lint/counts"
+require_relative "simple_english/setup/languagetool"
+require_relative "simple_english/setup/install"
+require_relative "simple_english/lint/extractor"
+require_relative "simple_english/lint/lint_plan"
+require_relative "simple_english/lint/annotated_text"
+require_relative "simple_english/lint/suppressions"
+require_relative "simple_english/setup/config"
+require_relative "simple_english/setup/fingerprint"
+require_relative "simple_english/client/language_tool"
+require_relative "simple_english/client/daemon"
+require_relative "simple_english/daemon/engine"
+require_relative "simple_english/daemon/http"
+require_relative "simple_english/daemon/server"
 
 module SimpleEnglish
   module_function
@@ -30,48 +34,26 @@ module SimpleEnglish
     Client.lint(text)
   end
 
-  # One entry point for files. Markdown keeps the counting rules. Code
-  # files lint comments through the daemon. nil means unreachable:
+  # One entry point for files. LintPlan decides what kind of lint
+  # this is. Both tiers share it, so they cannot drift. Code files
+  # lint comments through the daemon. nil means unreachable:
   # the caller decides how fatal that is.
   def lint_file(path, text = File.read(path))
     language = Extractor.language_for(path)
+    plan = LintPlan.call(text, language)
+    return [] if plan.nil?
     findings =
-      if language
-        # Comment-free files never reach the daemon. No boot, no POST.
-        return [] if Extractor.comment_spans(text, language).empty?
+      if plan == :prose
+        lint_text(text)
+      else
         return nil unless Client.ensure_up(install: Install.from_env)
         result = Client.lint(text, language: language)
         if result.nil?
           warn "error: se daemon did not answer. Run `se serve` and read its output."
         end
         result
-      else
-        lint_text(text)
       end
     return nil unless findings
     Suppressions.filter(text, findings)
   end
-
-  def corpus_test
-    pairs = Dir.glob(File.expand_path("../test/corpus/*-before.md", __dir__))
-      .sort
-    failed = pairs.flat_map do |before|
-      after = before.sub(/-before\.md\z/, "-after.md")
-      before_findings = lint_text(File.read(before))
-      after_findings = lint_text(File.read(after))
-      messages = []
-      if before_findings.nil? || after_findings.nil?
-        messages << "#{before}: daemon unreachable"
-      else
-        messages << "#{before}: no findings, the rule set misses this case" if before_findings.empty?
-        unless after_findings.empty?
-          messages << "#{after}: still flagged: #{after_findings.map(&:rule).join(", ")}"
-        end
-      end
-      messages
-    end
-    failed.each { |failure| puts "FAIL #{failure}" }
-    puts "corpus: #{pairs.size} pairs, #{failed.size} failures"
-    failed.empty?
-  end
 end