simple_english 0.2.0 → 0.4.0

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.2.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

data/rules/simple-english.xml

@@ -56,10 +56,14 @@
     </rule>
 
     <rule id="SE_ING_AFTER_COMMA" name="No -ing after a comma">
-      <pattern><token>,</token><token postag="VBG"/></pattern>
+      <pattern><token>,</token><token postag="VBG"><exception scope="next" regexp="yes">[,)]|and|or</exception></token></pattern>
       <message>Start a new sentence instead of the -ing phrase.</message>
       <example type="incorrect">The tool runs<marker>, making</marker> it easy.</example>
       <example type="correct">The tool runs. It is easy.</example>
+      <example type="correct">The walkthrough (accounts, VPC, secrets, troubleshooting) is in the guide.</example>
+      <example type="correct">The guide covers billing, troubleshooting, and support for each environment.</example>
+      <example type="correct">The guide covers billing, troubleshooting and support for each environment.</example>
+      <example type="correct">The guide covers billing, troubleshooting or support for each environment.</example>
     </rule>
 
     <rule id="SE_KEEP_THAT" name="make sure that">

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simple_english
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - TonyCTHsu
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-28 00:00:00.000000000 Z
+date: 2026-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tree_sitter_language_pack
@@ -39,63 +39,63 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: rubyzip
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :runtime
+        version: '13.0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '6.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: minitest-mock
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '5.27'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '5.27'
 - !ruby/object:Gem::Dependency
-  name: minitest-mock
+  name: rubyzip
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.27'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.27'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: json
+  name: rexml
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -109,7 +109,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rexml
+  name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -135,31 +135,37 @@ files:
 - bin/se
 - docs/RULES.md
 - lib/simple_english.rb
-- lib/simple_english/annotated_text.rb
 - lib/simple_english/cli.rb
-- lib/simple_english/client.rb
-- lib/simple_english/config.rb
-- lib/simple_english/counts.rb
-- lib/simple_english/engine.rb
-- lib/simple_english/extractor.rb
-- lib/simple_english/finding.rb
-- lib/simple_english/http.rb
-- lib/simple_english/install.rb
-- lib/simple_english/languagetool.rb
-- lib/simple_english/markdown.rb
-- lib/simple_english/paragraph.rb
-- lib/simple_english/plain_text.rb
-- lib/simple_english/result.rb
-- lib/simple_english/segment.rb
-- lib/simple_english/server.rb
-- lib/simple_english/span.rb
-- lib/simple_english/suppressions.rb
+- lib/simple_english/client/daemon.rb
+- lib/simple_english/client/language_tool.rb
+- lib/simple_english/daemon/engine.rb
+- lib/simple_english/daemon/http.rb
+- lib/simple_english/daemon/server.rb
+- lib/simple_english/lint/annotated_text.rb
+- lib/simple_english/lint/counts.rb
+- lib/simple_english/lint/extractor.rb
+- lib/simple_english/lint/finding.rb
+- lib/simple_english/lint/lint_plan.rb
+- lib/simple_english/lint/markdown.rb
+- lib/simple_english/lint/paragraph.rb
+- lib/simple_english/lint/plain_text.rb
+- lib/simple_english/lint/result.rb
+- lib/simple_english/lint/segment.rb
+- lib/simple_english/lint/span.rb
+- lib/simple_english/lint/suppressions.rb
+- lib/simple_english/setup/config.rb
+- lib/simple_english/setup/fingerprint.rb
+- lib/simple_english/setup/install.rb
+- lib/simple_english/setup/languagetool.rb
 - lib/simple_english/version.rb
 - rules/simple-english.xml
 homepage: https://github.com/TonyCTHsu/simple-english
 licenses:
 - MIT
-metadata: {}
+metadata:
+  homepage_uri: https://github.com/TonyCTHsu/simple-english
+  source_code_uri: https://github.com/TonyCTHsu/simple-english
+  changelog_uri: https://github.com/TonyCTHsu/simple-english/blob/v0.4.0/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths:

data/lib/simple_english/client.rb

@@ -1,165 +0,0 @@
-# frozen_string_literal: true
-
-# HTTP client for the LanguageTool server and the se daemon.
-
-require "json"
-require "net/http"
-require "rbconfig"
-require "uri"
-
-require_relative "plain_text"
-require_relative "languagetool"
-
-module SimpleEnglish
-  module Client
-    module_function
-
-    # LanguageTool reports offsets in Java UTF-16 code units.
-    # Astral characters (emoji) count as two. Count them so a
-    # newline comparison cannot drift past a boundary. A match
-    # starting at the newline itself belongs to the next line.
-    def offset_to_line(text, offset)
-      line = 1
-      units = 0
-      text.each_char do |char|
-        line += 1 if char == "\n" && units <= offset
-        return line if units >= offset
-        units += (char.ord > 0xFFFF) ? 2 : 1
-      end
-      line
-    end
-
-    # The 1-based column of a UTF-16 offset within its line. Astral
-    # characters count as two units, like the match offset. A match
-    # starting at the newline itself is column one of the next line.
-    def offset_to_column(text, offset)
-      column = 0
-      units = 0
-      text.each_char do |char|
-        if char == "\n"
-          return 1 if units >= offset
-          column = 0
-          units += 1
-          next
-        end
-        return column + 1 if units >= offset
-        units += (char.ord > 0xFFFF) ? 2 : 1
-        column += 1
-      end
-      column + 1
-    end
-
-    DEFAULT_PORT = 8181
-    REQUEST_TIMEOUT = 30
-
-    def url
-      ENV.fetch("SE_SERVER_URL") { "http://localhost:#{DEFAULT_PORT}" }
-    end
-
-    def post(uri, params, read_timeout: REQUEST_TIMEOUT)
-      Net::HTTP.start(uri.host, uri.port, open_timeout: 5,
-        read_timeout: read_timeout) do |http|
-        request = Net::HTTP::Post.new(uri.request_uri)
-        request.set_form_data(params)
-        http.request(request)
-      end
-    end
-
-    private_class_method :post
-
-    # Pattern rules. `payload` is Markdown-stripped text (String) or an
-    # AnnotatedText::Result (code comments): one payload interface,
-    # #lt_params and #locate, either side of the daemon's LT request.
-    def check(payload, base_url: url)
-      payload = to_payload(payload)
-      params = {"language" => "en",
-                "enabledRules" => SimpleEnglish::LanguageTool.rule_ids.join(","),
-                "enabledOnly" => "true"}.merge(payload.lt_params)
-      response = post(URI("#{base_url}/v2/check"), params)
-      parse_matches(JSON.parse(response.body).fetch("matches"), payload)
-    end
-
-    def parse_matches(matches, payload)
-      payload = to_payload(payload)
-      matches.map do |match|
-        line, column = payload.locate(match.fetch("offset"))
-        Finding.new(line: line, column: column,
-          rule: match.fetch("rule").fetch("id"),
-          message: with_context(match.fetch("message"), match))
-      end
-    end
-
-    # Prefix the offending text, so a finding says what to change,
-    # not only how. LanguageTool returns it in the match context.
-    # Context offsets are Java UTF-16 code units, like the match
-    # offset.
-    def with_context(message, match)
-      context = match["context"] or return message
-      matched = context.fetch("text", "")[
-        context.fetch("offset", 0).to_i, context.fetch("length", 0).to_i]
-      matched.empty? ? message : "\"#{matched}\" - #{message}"
-    end
-
-    def to_payload(payload)
-      payload.is_a?(String) ? PlainText.new(payload) : payload
-    end
-
-    private_class_method :to_payload, :with_context
-
-    # Full lint via the se daemon. Raw Markdown in, or code
-    # source with a language for the comment pipeline. nil when
-    # unreachable or the response is unusable, so callers can fall
-    # back without seeing a stack trace.
-    def lint(text, base_url: url, language: nil)
-      params = {"text" => text}
-      params["language"] = language if language
-      response = post(URI("#{base_url}/lint"), params)
-      return nil unless response.is_a?(Net::HTTPSuccess)
-      body = JSON.parse(response.body)
-      return nil unless body.is_a?(Array)
-      body.map do |hash|
-        Finding.new(line: hash.fetch("line"), column: hash["column"],
-          rule: hash.fetch("rule"), message: hash.fetch("message"))
-      end
-    rescue SystemCallError, SocketError, Timeout::Error,
-      JSON::ParserError, TypeError
-      nil
-    end
-
-    def up?(base_url: url)
-      uri = URI(base_url)
-      Net::HTTP.start(uri.host, uri.port, open_timeout: 1,
-        read_timeout: 2) { |http| http.head("/") }
-      true
-    rescue Errno::ECONNREFUSED, SocketError, Timeout::Error
-      false
-    end
-
-    # True when the daemon answers. Starts it when we own the default
-    # URL. A custom SE_SERVER_URL belongs to someone else, so
-    # never spawn against it. It returns false when unusable. The
-    # caller owns the exit status. Diagnostics go to stderr here, where the cause
-    # is known.
-    def ensure_up(install: SimpleEnglish::Install.from_env)
-      return true if up?
-      if ENV["SE_SERVER_URL"]
-        warn "error: SE_SERVER_URL is set but #{url} does not answer."
-        return false
-      end
-      unless File.exist?(install.server_jar)
-        warn install.setup_error
-        return false
-      end
-      warn "se: daemon not running; starting it (first lint takes ~15s)..."
-      bin = File.expand_path("../../bin/se", __dir__)
-      Process.spawn(RbConfig.ruby, bin, "serve", out: File::NULL, err: File::NULL)
-      deadline = Time.now + 90
-      until Time.now > deadline
-        return true if up?
-        sleep 0.5
-      end
-      warn "error: se daemon did not come up. Run `se serve` and read its output."
-      false
-    end
-  end
-end