sloplint 0.5.0 → 0.7.0

data/exe/sloplint

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Integer compare, not string: "3.10" < "3.3" is true and would reject a future
+# Ruby. Array has <=> but no <, hence the explicit compare. Not Gem::Version --
+# this has to hold when RubyGems is not loaded.
+if (RUBY_VERSION.split(".").map(&:to_i).first(2) <=> [3, 3]) < 0
+  abort "sloplint needs Ruby 3.3 or later, found #{RUBY_VERSION}.\n" \
+        "macOS ships Ruby 2.6 at /usr/bin/ruby. Install a current one with `brew install ruby`."
+end
+
+require_relative "../lib/sloplint/cli"
+exit Sloplint::CLI.run(ARGV)

data/lib/sloplint/cli.rb

@@ -10,7 +10,8 @@ require_relative "output"
 module Sloplint
   # Command-line shell: optparse, subcommands, exit codes. See docs/SPEC.md.
   #
-  # Exit codes: 0 ran/no notes, 1 ran/notes found, 2 bad arguments.
+  # Exit codes: 0 ran/no notes, 1 ran/notes found, 2 bad arguments. Empty
+  # input is a 2 as well: an unread draft must not report as a clean one.
   module CLI
     module_function
 
@@ -18,7 +19,14 @@ module Sloplint
       opts = { format: "full" }
       parser = global_parser(opts, out:)
       # Split global options from the subcommand and its args.
-      parser.order!(argv)
+      begin
+        parser.order!(argv)
+      rescue OptionParser::InvalidOption => e
+        # `check` is the default command, so its options are accepted before
+        # any command word: `sloplint --markdown -`. The global parser does not
+        # know them, so put the option back and let check's parser judge it.
+        argv.unshift("check", *e.args)
+      end
       return 0 if opts[:help_shown] || opts[:version_shown]
 
       command = argv.shift
@@ -45,15 +53,17 @@ module Sloplint
     # ── check ───────────────────────────────────────────────────────────────
     def cmd_check(argv, opts, out:, err:, stdin:)
       markdown = false
+      strict = false
       select = nil
       ignore = nil
       p = OptionParser.new do |o|
         o.banner = "usage: sloplint check [options] [paths...]  (\"-\" or no paths = stdin)"
         o.on("-o", "--output-format FORMAT", %w[full json],
              "Output format: 'full' or 'json' (may also be given before the command).") { |v| opts[:format] = v }
-        o.on("--markdown", "Skip fenced/inline code spans and URLs before scanning.") { markdown = true }
+        o.on("--markdown", "Skip fenced/inline code spans, HTML comments, and URLs before scanning.") { markdown = true }
         o.on("--select IDS", "Only run these rules (comma-separated rule ids or category names).") { |v| select = v.split(",").map(&:strip) }
         o.on("--ignore IDS", "Skip these rules (comma-separated rule ids or category names).") { |v| ignore = v.split(",").map(&:strip) }
+        o.on("--strict", "Run every rule, including the ones that are off by default.") { strict = true }
       end
       p.order!(argv)
 
@@ -64,24 +74,42 @@ module Sloplint
         return 2
       end
 
-      rules = select_rules(select, ignore)
+      rules = select_rules(select, ignore, strict)
       paths = argv.empty? ? ["-"] : argv
       by_path = paths.reject { |x| x == "-" }.size > 1
 
-      all_notes = []
+      sources = []
       paths.each do |path|
+        # Read as UTF-8 whatever the locale says. A sandbox with no LANG set
+        # leaves Ruby's default external encoding at US-ASCII, and then the
+        # first em dash raises "invalid byte sequence in US-ASCII" -- on prose
+        # that is perfectly valid UTF-8. Prose is the only input sloplint
+        # takes, so UTF-8 is the assumption, not the locale's guess.
         text =
           if path == "-"
-            stdin.read
+            stdin.read.force_encoding(Encoding::UTF_8)
           else
             unless File.file?(path)
               err.puts("sloplint: no such file: #{path}")
               return 2
             end
-            File.read(path)
+            File.read(path, encoding: Encoding::UTF_8)
           end
-        label = path == "-" ? "-" : path
-        all_notes.concat(Engine.scan(text, rules:, markdown:, path: label))
+        sources << [path == "-" ? "-" : path, text]
+      end
+
+      # Tested on the raw text, before --markdown blanks code and URLs: a file
+      # that holds only a fenced code block did arrive, and scanning it clean
+      # is right. Nothing arriving at all is the trap -- the same one a
+      # mistyped rule id sets, and it exits 2 for the same reason.
+      if sources.all? { |_, text| text.strip.empty? }
+        names = sources.map { |label, _| label == "-" ? "stdin" : label }
+        err.puts("sloplint: empty input: nothing to check in #{names.join(", ")}")
+        return 2
+      end
+
+      all_notes = sources.flat_map do |label, text|
+        Engine.scan(text, rules:, markdown:, path: label)
       end
 
       case opts[:format]
@@ -93,7 +121,10 @@ module Sloplint
       end
 
       all_notes.empty? ? 0 : 1
-    rescue ArgumentError => e
+    # Invalid UTF-8 reaches this two ways: String#strip in the empty check
+    # raises Encoding::CompatibilityError, the engine's regexes raise
+    # ArgumentError. Both are the same thing to the reader.
+    rescue ArgumentError, Encoding::CompatibilityError => e
       err.puts("sloplint: invalid input: #{e.message}")
       2
     end
@@ -168,9 +199,11 @@ module Sloplint
 
     # --select/--ignore accept rule ids or category names. Default set excludes
     # default_on:false rules unless they are explicitly selected.
-    def select_rules(select, ignore)
+    def select_rules(select, ignore, strict = false)
       rules = if select
         RULES.select { |r| select.include?(r.id) || select.include?(r.category) }
+      elsif strict
+        RULES
       else
         RULES.select(&:default_on)
       end
@@ -187,7 +220,7 @@ module Sloplint
 
           # Recommended for agents:
           cat FILE | sloplint check --markdown -o json -
-          # exit 0 = clean, 1 = notes found, >1 = error
+          # exit 0 = clean, 1 = notes found, >1 = error (empty input is an error)
           # each note: {path,line,column,severity,rule,category,message,excerpt,context,rationale,suggestion}
 
           usage: sloplint [-o full|json] [command] [args]

data/lib/sloplint/engine.rb

@@ -14,7 +14,7 @@ module Sloplint
 
     module_function
 
-    # text: the source. rules: which Rule objects to run. markdown: blank code/URLs first.
+    # text: the source. rules: which Rule objects to run. markdown: blank code, HTML comments and URLs first.
     # path: label carried into each Note (e.g. filename or "-" for stdin).
     def scan(text, rules: RULES, markdown: false, path: "-")
       source = text
@@ -95,14 +95,13 @@ module Sloplint
       starts
     end
 
-    # Replace fenced code, inline code, and URLs with same-length whitespace so
-    # line/column stay correct. Newlines are preserved.
+    # Replace fenced code, HTML comments, inline code, and URLs with same-length
+    # whitespace so line/column stay correct. Newlines are preserved. One pass
+    # with one alternation, so whichever construct opens first is the one that
+    # gets consumed: a `<!--` quoted inside backticks is inline code, and a
+    # backtick inside a comment is part of the comment.
     def blank_markdown(text)
-      blank = lambda { |s| s.gsub(/[^\n]/, " ") }
-      text
-        .gsub(/```.*?```/m) { |s| blank.call(s) }   # fenced code
-        .gsub(/`[^`\n]*`/) { |s| blank.call(s) }    # inline code
-        .gsub(%r{https?://\S+}) { |s| blank.call(s) } # bare URLs
+      text.gsub(/```.*?```|<!--.*?-->|`[^`\n]*`|https?:\/\/\S+/m) { |s| s.gsub(/[^\n]/, " ") }
     end
   end
 end