simple_english 0.4.2 → 0.13.1

data/lib/simple_english/setup/config.rb

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
 
 # .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.
+# given on the command line), disabled-rules (rule IDs dropped
+# from every file), and rule-ignores (a rule dropped only on the
+# listed path globs, fired everywhere else). Loaded from the CWD.
 
 module SimpleEnglish
   module Config
     ConfigError = Class.new(StandardError)
-    DEFAULT = {ignore: [], disabled_rules: []}.freeze
+    DEFAULT = {ignore: [], disabled_rules: [], rule_ignores: {}}.freeze
 
     module_function
 
@@ -17,13 +18,39 @@ module SimpleEnglish
       require "yaml"
       data = YAML.safe_load_file(file) || {}
       {ignore: Array(data["ignore"]),
-       disabled_rules: Array(data["disabled-rules"])}
+       disabled_rules: Array(data["disabled-rules"]),
+       rule_ignores: load_rule_ignores(data["rule-ignores"])}
     rescue Psych::SyntaxError => e
       raise ConfigError, ".simple-english.yml: #{e.message}"
     end
 
+    # Loose like the other keys: a rule ID with no entry means the
+    # rule fires everywhere, so a wrong ID surfaces its findings
+    # instead of hiding them.
+    def load_rule_ignores(data)
+      return {} unless data.is_a?(Hash)
+      data.to_h { |rule, globs| [rule, Array(globs)] }
+    end
+
+    # Hooks pass absolute paths while ignore globs are written
+    # relative to the repo root (the CWD). Match both forms.
+    # realpath because CWD may be a symlink-resolved path while the
+    # caller's string still carries the symlink (TMPDIR on macOS).
     def ignore?(config, path)
-      config[:ignore].any? { |pattern| matches?(pattern, path) }
+      path_matches?(config[:ignore], path)
+    end
+
+    def path_matches?(globs, path)
+      candidates = [path, relative_candidate(path)].compact
+      globs.any? do |pattern|
+        candidates.any? { |candidate| matches?(pattern, candidate) }
+      end
+    end
+
+    def relative_candidate(path)
+      pwd = Dir.pwd + "/"
+      resolved = File.exist?(path) ? File.realpath(path) : File.expand_path(path)
+      resolved.start_with?(pwd) ? resolved.delete_prefix(pwd) : nil
     end
 
     # File.fnmatch has no globstar: `**` never crosses directories.
@@ -43,10 +70,16 @@ module SimpleEnglish
       end.join("/") + "\\z")
     end
 
-    def filter(config, path, findings)
-      return [] if ignore?(config, path)
+    # rule-ignores needs the finding's file, which findings do not
+    # carry, so the caller passes path in. A nil path (stdin, MCP
+    # text) has no path to match, so every rule fires.
+    def filter(config, findings, path: nil)
       disabled = config[:disabled_rules]
-      findings.reject { |finding| disabled.include?(finding.rule) }
+      rule_ignores = config[:rule_ignores] || {}
+      findings.reject do |finding|
+        disabled.include?(finding.rule) ||
+          (path && path_matches?(rule_ignores[finding.rule] || [], path))
+      end
     end
   end
 end

data/lib/simple_english/setup/install.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-# The resolved LanguageTool installation: where the jars live and which
-# java runs them. Build it once from the environment at the process
-# edge with Install.from_env. Everything downstream takes the value,
-# never the environment. A nil java means "not found": ask with java?
-# or fail with java! and get the fix in the message.
+# Resolves the bundled native LanguageTool server once, at the process edge.
+# Tests and source builds can select an explicit executable through the
+# environment. Released platform gems provide the default under libexec.
 
 require_relative "languagetool"
 
@@ -13,73 +11,40 @@ module SimpleEnglish
     class SetupError < StandardError
     end
 
-    attr_reader :cache_dir, :java, :java_source
+    attr_reader :executable
 
-    def initialize(cache_dir:, java: nil, java_source: nil)
-      @cache_dir = cache_dir
-      @java = java
-      @java_source = java_source
+    def initialize(executable:)
+      @executable = File.expand_path(executable)
     end
 
-    # The one place the environment is read. SE_JAVA wins outright,
-    # because the user asserted it and nobody re-probes an override.
-    # 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. 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, 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)
+      executable = env.fetch(LanguageTool::EXECUTABLE_ENV,
+        LanguageTool::BUNDLED_EXECUTABLE)
+      new(executable: executable)
     end
 
-    # Runs the candidate under the given PATH, isolated from this
-    # process's own PATH so tests can probe a fake environment.
-    def self.probe?(candidate, env)
-      system({"PATH" => env.fetch("PATH", "")}, candidate, "-version",
-        out: File::NULL, err: File::NULL)
+    def executable?
+      File.file?(executable) && File.executable?(executable)
     end
-    private_class_method :probe?
 
-    def java?
-      !java.nil?
-    end
-
-    def java!
-      return java if java?
-      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
-
-    def lt_dir
-      File.join(cache_dir, "LanguageTool-#{LanguageTool::LT_VERSION}")
-    end
-
-    def commandline_jar
-      File.join(lt_dir, "languagetool-commandline.jar")
-    end
-
-    def server_jar
-      File.join(lt_dir, "languagetool-server.jar")
+    def executable!
+      return executable if executable?
+      raise SetupError, setup_error
     end
 
     def setup_error
-      "LanguageTool #{LanguageTool::LT_VERSION} not found at #{server_jar}. " \
-        "This gem pins that version. Run `se setup`."
+      if executable != LanguageTool::BUNDLED_EXECUTABLE
+        "#{LanguageTool::EXECUTABLE_ENV} points at a missing or " \
+          "non-executable file: #{executable}"
+      elsif File.directory?(File.dirname(executable))
+        "the lint engine is missing or not executable at " \
+          "#{executable}; reinstall the gem"
+      else
+        "this copy ships no lint engine: a source checkout and the " \
+          "plain gem both do. Install a platform build of the gem, or " \
+          "point #{LanguageTool::EXECUTABLE_ENV} at a languagetool-server " \
+          "binary."
+      end
     end
   end
 end

data/lib/simple_english/setup/languagetool.rb

@@ -1,227 +1,20 @@
 # 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).
+# Pinned LanguageTool facts shared by the native build and Ruby runtime.
 
 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
+    EXECUTABLE_ENV = "SE_LANGUAGETOOL_EXECUTABLE"
+    BUNDLED_EXECUTABLE = File.expand_path(
+      "../../../libexec/simple_english/languagetool-server", __dir__
+    )
+    TIMEOUT_SECONDS = 30
 
     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)
-      # Explicit UTF-8: the file holds non-ASCII bytes, and a bare
-      # File.read uses the process's external encoding. Under
-      # launchd that is US-ASCII, and the scan below dies on the
-      # first such byte. The daemon must boot in any locale.
       File.read(path, encoding: "UTF-8").scan(/<(?:rule|rulegroup)\b[^>]*>/).filter_map do |tag|
         tag[/\bid="([^"]+)"/, 1]
       end

data/lib/simple_english/version.rb

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

data/lib/simple_english.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
-# Lint Markdown prose with the SimpleEnglish Plain-mode rules.
-# Pattern rules run on LanguageTool. Counting rules run here.
+# Lint Markdown prose and code comments with the SimpleEnglish
+# Plain-mode rules. Pattern rules run on LanguageTool. Counting rules
+# run here.
 # This file is the composition root. The pieces live in lib/simple_english/.
 
 require_relative "simple_english/version"
 require_relative "simple_english/lint/finding"
 require_relative "simple_english/lint/paragraph"
+require_relative "simple_english/lint/utf16"
 require_relative "simple_english/lint/markdown"
 require_relative "simple_english/lint/counts"
 require_relative "simple_english/setup/languagetool"
@@ -15,45 +17,32 @@ 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/lint/linter"
 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/model_context_protocol"
 require_relative "simple_english/daemon/server"
 
 module SimpleEnglish
   module_function
 
-  # Returns findings, or nil when the daemon is unreachable. The
-  # caller (bin/se) owns the exit status. Diagnostics go to
-  # stderr here.
-  def lint_text(text)
-    return nil unless Client.ensure_up(install: Install.from_env)
-    Client.lint(text)
-  end
-
-  # 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)
+  # The engine: text in, findings out. LintPlan decides what kind of
+  # lint this is. Both tiers share it, so they cannot drift. A nil
+  # language means Markdown prose. Code lints its comments.
+  # nil means unreachable: the caller decides how fatal that is.
+  def lint(text, language: nil)
     plan = LintPlan.call(text, language)
     return [] if plan.nil?
-    findings =
-      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 `#{Client.runner} serve` and read its output."
-        end
-        result
-      end
-    return nil unless findings
+    return nil unless Client.ensure_up(install: Install.from_env)
+    findings = Client.lint(text, language: language)
+    if findings.nil?
+      warn "error: se daemon did not answer. Run `#{Client.runner} serve` and read its output."
+      return nil
+    end
     Suppressions.filter(text, findings)
   end
 end