RubyGems - remlint - Versions diffs - 0.1.0 - Mend

remlint 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (81) hide show

checksums.yaml +7 -0
data/LICENSE +328 -0
data/config/default.yml +374 -0
data/docs/remlint-rules.md +390 -0
data/docs/remlint.md +238 -0
data/exe/remlint +8 -0
data/lib/remlint/cli.rb +300 -0
data/lib/remlint/command.rb +229 -0
data/lib/remlint/config.rb +255 -0
data/lib/remlint/date_literal.rb +283 -0
data/lib/remlint/document.rb +161 -0
data/lib/remlint/expr_lexer.rb +197 -0
data/lib/remlint/extractors.rb +210 -0
data/lib/remlint/formatter.rb +96 -0
data/lib/remlint/invocation.rb +145 -0
data/lib/remlint/logical_line.rb +194 -0
data/lib/remlint/offense.rb +117 -0
data/lib/remlint/rule.rb +216 -0
data/lib/remlint/rules/addomit_without_scanfrom.rb +189 -0
data/lib/remlint/rules/advance_warning_body.rb +176 -0
data/lib/remlint/rules/banner_placement.rb +126 -0
data/lib/remlint/rules/calendar_text_limited.rb +125 -0
data/lib/remlint/rules/callback_signature.rb +221 -0
data/lib/remlint/rules/clause_needs_full_date.rb +176 -0
data/lib/remlint/rules/clause_requires_at.rb +178 -0
data/lib/remlint/rules/clause_value_range.rb +257 -0
data/lib/remlint/rules/color_component_range.rb +295 -0
data/lib/remlint/rules/coordinate_not_string.rb +175 -0
data/lib/remlint/rules/dangling_continuation.rb +134 -0
data/lib/remlint/rules/date_out_of_range.rb +180 -0
data/lib/remlint/rules/debug_command.rb +189 -0
data/lib/remlint/rules/easterdate_from_today.rb +160 -0
data/lib/remlint/rules/function_arity.rb +385 -0
data/lib/remlint/rules/function_redefinition.rb +159 -0
data/lib/remlint/rules/generated_file_edited.rb +125 -0
data/lib/remlint/rules/hebrew_date.rb +245 -0
data/lib/remlint/rules/iftrig_with_satisfy.rb +101 -0
data/lib/remlint/rules/include_path.rb +155 -0
data/lib/remlint/rules/info_clause.rb +186 -0
data/lib/remlint/rules/info_substitution_without_header.rb +169 -0
data/lib/remlint/rules/invocation_mismatch.rb +223 -0
data/lib/remlint/rules/keyword_case.rb +172 -0
data/lib/remlint/rules/license_header.rb +101 -0
data/lib/remlint/rules/line_length.rb +101 -0
data/lib/remlint/rules/literal_type_mismatch.rb +324 -0
data/lib/remlint/rules/localization_pack.rb +144 -0
data/lib/remlint/rules/moon_phase_argument.rb +162 -0
data/lib/remlint/rules/omit_aware_delta.rb +168 -0
data/lib/remlint/rules/push_vars_missing_name.rb +158 -0
data/lib/remlint/rules/repeat_trigger.rb +188 -0
data/lib/remlint/rules/satisfy_constraint.rb +230 -0
data/lib/remlint/rules/shell_maxlen.rb +170 -0
data/lib/remlint/rules/shell_use_while_run_disabled.rb +172 -0
data/lib/remlint/rules/string_escape.rb +158 -0
data/lib/remlint/rules/syntax.rb +229 -0
data/lib/remlint/rules/system_variable_assignment.rb +197 -0
data/lib/remlint/rules/tag_syntax.rb +145 -0
data/lib/remlint/rules/text_after_eof_marker.rb +134 -0
data/lib/remlint/rules/time_zone_name.rb +212 -0
data/lib/remlint/rules/tk_tag_namespace.rb +121 -0
data/lib/remlint/rules/todo_complete_through.rb +122 -0
data/lib/remlint/rules/trailing_whitespace.rb +116 -0
data/lib/remlint/rules/translate_command.rb +203 -0
data/lib/remlint/rules/unbalanced_blocks.rb +305 -0
data/lib/remlint/rules/unbalanced_delimiters.rb +251 -0
data/lib/remlint/rules/unknown_special_type.rb +155 -0
data/lib/remlint/rules/unknown_substitution_sequence.rb +255 -0
data/lib/remlint/rules/unknown_system_variable.rb +145 -0
data/lib/remlint/rules/unquoted_shell_substitution.rb +266 -0
data/lib/remlint/rules/until_before_from.rb +204 -0
data/lib/remlint/rules/world_writable_script.rb +128 -0
data/lib/remlint/rules.rb +60 -0
data/lib/remlint/runner.rb +274 -0
data/lib/remlint/source.rb +36 -0
data/lib/remlint/tables.rb +395 -0
data/lib/remlint/trigger.rb +359 -0
data/lib/remlint/version.rb +5 -0
data/lib/remlint/vocabulary.rb +236 -0
data/lib/remlint.rb +35 -0
data/tasks/generate_tables.rb +175 -0
metadata +170 -0

data/lib/remlint/rules/unknown_substitution_sequence.rb ADDED Viewed

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+require_relative "../rule"
+module RemLint
+  module Rules
+    # `%` sequences Remind does not substitute.
+    #
+    # Narrower than it first looks, and the narrowing is worth stating. The set
+    # in `dosubst.c` is closed but *wide*: the switch is on `UPPER(c)`, and
+    # every one of the twenty-six letters and all ten digits is a case. So
+    # there is no `%z` typo to catch -- `%z` is the seconds-since-epoch
+    # sequence. What is left to report is punctuation, and the argument forms
+    # that were opened and never closed.
+    #
+    # It is worth reporting because the failure is invisible. The `default:`
+    # branch emits the character *and drops the percent*: `%~` prints `~`, with
+    # no error, no warning, and nothing to distinguish it from text somebody
+    # meant to type.
+    #
+    # Four sequences take an argument rather than a single character, and all
+    # four are recognised here so their contents are not mistaken for the
+    # sequence itself:
+    #
+    #   %<Header>   an INFO header      (silently empty when absent)
+    #   %{name}     calls subst_name    (warns only at warning level 05.00.03)
+    #   %(text)     a translated string
+    #   %*x         the alternate-mode modifier, then a real sequence
+    #
+    # Leaving one of the first three unterminated is a warning from Remind at
+    # run time; reporting it here says the same thing without running the file.
+    #
+    # A `%` at the very end of a body is *not* an error. It suppresses the
+    # newline Remind would otherwise append -- `dosubst("hello")` is six
+    # characters and `dosubst("hello%")` is five (remind.1: "if str does not
+    # end with %, a newline character will be added"). Remind's own
+    # tests/test.rem ends 160 bodies that way.
+    #
+    # Only reminder bodies are checked. Elsewhere on a line a `%` is an
+    # ordinary character -- `BANNER %` is the idiom for no banner at all.
+    class UnknownSubstitutionSequence < Rule
+      # From the `switch (UPPER(c))` in src/dosubst.c. Every letter and every
+      # digit is a case; the punctuation is the part that is actually a set.
+      LETTERS = ("A".."Z").to_a.freeze
+      DIGITS = ("0".."9").to_a.freeze
+      PUNCTUATION = %w[! ? @ # : _ "].freeze
+      # `%%` has no case of its own, but the default branch emits the second
+      # `%` -- so it is the working way to write a literal percent, and
+      # reporting it would be reporting the fix.
+      LITERAL_PERCENT = "%"
+      SIMPLE = (LETTERS + DIGITS + PUNCTUATION + [LITERAL_PERCENT]).freeze
+      # A trailing `%` suppresses the newline; the regex reports it as an empty
+      # body, because there is no character after the percent to report.
+      TRAILING = ""
+      # An opener with no closer before end of body. Remind warns about each of
+      # these at run time ("Unterminated %<...> substitution sequence").
+      UNTERMINATED = { "<" => ">", "{" => "}", "(" => ")" }.freeze
+      # The whole sequence, in every form, so the scan advances past an
+      # argument rather than stopping inside it.
+      SEQUENCE = /%(?<modifier>\*?)(?<body><[^>]*>|\{[^}]*\}|\([^)]*\)|.|\z)/
+      ARGUMENT_FORMS = /\A[<{(]/
+      def self.default_severity
+        "warning"
+      end
+      def self.description
+        "A % sequence in a reminder body that Remind does not substitute."
+      end
+      def check
+        document.code_commands.each do |command|
+          body = body_of(command)
+          if body
+            report(command, body.fetch(:text), body.fetch(:offset))
+          end
+        end
+      end
+      private
+        def body_of(command)
+          trigger = document.trigger_for(command)
+          if trigger.text_body?
+            { text: command.text[trigger.body_offset..].to_s, offset: trigger.body_offset }
+          end
+        end
+        def report(command, text, offset)
+          text.to_enum(:scan, SEQUENCE).each do
+            match = Regexp.last_match
+            unless recognised?(match[:body])
+              offend_at(command.logical_line, offset + match.begin(0), message_for(match))
+            end
+          end
+        end
+        # A complete argument form, or a single character in the set. An
+        # unterminated `%<` arrives here as the one character `<`, which is
+        # exactly what distinguishes it from a closed `%<Header>`.
+        def recognised?(body)
+          body == TRAILING ||
+            (body.length > 1 && body.match?(ARGUMENT_FORMS)) ||
+            SIMPLE.include?(body.upcase)
+        end
+        def message_for(match)
+          body = match[:body]
+          closer = UNTERMINATED[body]
+          if closer
+            "`%#{body}` is never closed by `#{closer}`"
+          else
+            "`%#{match[:modifier]}#{body}` is not a substitution sequence; " \
+            "Remind drops the `%` and prints `#{body}`"
+          end
+        end
+    end
+  end
+end
+__END__
+require_relative "../document"
+describe "RemLint::Rules::UnknownSubstitutionSequence" do
+  lint = proc do |text|
+    source = RemLint::Source.new(path: "t.rem", text: text)
+    RemLint::Rules::UnknownSubstitutionSequence.new.run(RemLint::Document.new(source))
+  end
+  messages = proc { |text| lint.(text).map(&:message) }
+  describe "sequences Remind has" do
+    it "accepts the letter sequences in either case" do
+      lint.("REM 1 Jan MSG Birthday %a and %B and %c\n").should.be.empty
+    end
+    it "accepts the digit sequences" do
+      lint.("REM 1 Jan AT 15:00 MSG Meeting %1 %2 %3 %0\n").should.be.empty
+    end
+    it "accepts the punctuation sequences" do
+      lint.(%(REM 1 Jan MSG a %! b %? c %@ d %# e %: f %_ g\n)).should.be.empty
+    end
+    it "accepts the calendar-text delimiter" do
+      lint.(%{REM 1 Jan MSG %"Bob's birthday%" is %b\n}).should.be.empty
+    end
+    it "accepts the alternate-mode modifier" do
+      lint.("REM 1 Jan MSG %*l and %*3\n").should.be.empty
+    end
+  end
+  describe "the argument-taking forms" do
+    it "accepts an INFO header reference" do
+      lint.("REM 1 Jan INFO \"Location: pub\" MSG Meet at %<Location>\n").should.be.empty
+    end
+    it "accepts a substitution-callback call" do
+      lint.("REM 1 Jan MSG %{ordinal} of the month\n").should.be.empty
+    end
+    it "accepts a translated string" do
+      lint.("REM 1 Jan MSG %(Happy birthday)\n").should.be.empty
+    end
+    it "does not read the contents of an argument as sequences" do
+      # The ~ inside the braces is part of a function name, not a sequence.
+      lint.("REM 1 Jan MSG %{a~b}\n").should.be.empty
+    end
+    it "reports an unterminated argument form" do
+      messages.("REM 1 Jan MSG Meet at %<Location\n").first.should ==
+        "`%<` is never closed by `>`"
+      messages.("REM 1 Jan MSG %{ordinal\n").first.should == "`%{` is never closed by `}`"
+      messages.("REM 1 Jan MSG %(hello\n").first.should == "`%(` is never closed by `)`"
+    end
+  end
+  describe "sequences Remind does not have" do
+    it "reports an unknown punctuation mark" do
+      messages.("REM 1 Jan MSG See %~ here\n").first.should ==
+        "`%~` is not a substitution sequence; Remind drops the `%` and prints `~`"
+    end
+    it "reports each one on a line" do
+      messages.("REM 1 Jan MSG %~ and %$\n").length.should == 2
+    end
+    it "points at the percent" do
+      text = "REM 1 Jan MSG See %~ here\n"
+      lint.(text).first.column.should == text.index("%~") + 1
+    end
+    it "accepts every letter, because every letter is a real sequence" do
+      body = ("a".."z").map { |letter| "%#{letter}" }.join(" ")
+      lint.("REM 1 Jan AT 15:00 MSG #{body}\n").should.be.empty
+    end
+    it "accepts %% as the literal percent it is" do
+      # No case of its own, but the default branch emits the second `%`.
+      lint.("REM 1 Jan MSG 50%% off\n").should.be.empty
+    end
+    it "accepts a trailing percent, which suppresses the appended newline" do
+      # Documented in remind.1, and used 160 times in Remind's own test.rem.
+      lint.("REM 1 Jan MSG all done %\n").should.be.empty
+    end
+  end
+  describe "where it does not look" do
+    it "says nothing about a percent in the trigger" do
+      lint.("REM 1 Jan MSG hi\n").should.be.empty
+    end
+    it "says nothing about BANNER %" do
+      # The idiom for no banner at all, and not a reminder body.
+      lint.("BANNER %\n").should.be.empty
+    end
+    it "says nothing about a percent in a comment" do
+      lint.("# 50% done\n").should.be.empty
+    end
+    it "says nothing about a command with no body" do
+      lint.("SET a 50\n").should.be.empty
+    end
+  end
+  it "checks a RUN body too" do
+    messages.("REM 1 Jan RUN echo %~\n").length.should == 1
+  end
+  it "reports at warning severity" do
+    lint.("REM 1 Jan MSG %~\n").first.severity.should == "warning"
+  end
+  it "reports the physical line inside a continuation" do
+    lint.("REM 1 Jan MSG a \\\n    %~\n").first.line.should == 2
+  end
+end

data/lib/remlint/rules/unknown_system_variable.rb ADDED Viewed

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+require_relative "../rule"
+require_relative "../vocabulary"
+module RemLint
+  module Rules
+    # `$Names` Remind does not have.
+    #
+    # Remind's system-variable namespace is closed: `FindSysVar` binary-searches
+    # a fixed table and anything missing is `E_NOSUCH_VAR` (src/var.c). So a
+    # typo here is never a variable that happens to be empty -- it is an error,
+    # and one that fires only when the line runs, which for a reminder can be
+    # months away.
+    #
+    # The one exception the rule has to know about is `-i` on the command line:
+    # `remind -i$Latitude="..."` initialises a variable that is not in the
+    # table, and `examples/astro` does exactly that in all four of its heredocs.
+    # Those come in as ordinary user variables without the sigil, so they do not
+    # reach this rule -- but a file that names its own `$`-prefixed variables
+    # can list them under `AllowedNames`.
+    class UnknownSystemVariable < Rule
+      def self.default_severity
+        "error"
+      end
+      def self.description
+        "A $SystemVariable that is not one of Remind's."
+      end
+      def check
+        allowed = option("AllowedNames", []).map(&:downcase)
+        document.logical_lines.each_with_index do |logical_line, index|
+          if document.commands[index].code?
+            check_line(logical_line, allowed)
+          end
+        end
+      end
+      private
+        def check_line(logical_line, allowed)
+          document.tokens_for(logical_line).each do |token|
+            if unknown?(token, allowed)
+              offend_at(logical_line, token.offset, "`#{token.value}` is not a Remind system variable")
+            end
+          end
+        end
+        def unknown?(token, allowed)
+          token.type == :sysvar &&
+            Vocabulary.sysvar(token.value).nil? &&
+            !allowed.include?(token.value.delete_prefix("$").downcase)
+        end
+    end
+  end
+end
+__END__
+require_relative "../document"
+describe "RemLint::Rules::UnknownSystemVariable" do
+  lint = proc do |text, config = {}|
+    source = RemLint::Source.new(path: "t.rem", text: text)
+    RemLint::Rules::UnknownSystemVariable.new(config).run(RemLint::Document.new(source))
+  end
+  messages = proc { |text, config = {}| lint.(text, config).map(&:message) }
+  describe "variables Remind has" do
+    it "accepts one in a SET" do
+      lint.("SET $AddBlankLines 0\n").should.be.empty
+    end
+    it "accepts one in a bracketed expression" do
+      lint.("INCLUDE [$SysInclude]/ansitext.rem\n").should.be.empty
+    end
+    it "accepts one whatever its case, as FindSysVar does" do
+      lint.("SET $addblanklines 0\n").should.be.empty
+      lint.("SET $ADDBLANKLINES 0\n").should.be.empty
+    end
+    it "accepts the trigger variables" do
+      lint.("MSG [$T] and [$U]\n").should.be.empty
+    end
+  end
+  describe "variables Remind does not have" do
+    it "reports a typo" do
+      messages.("SET $AddBlankLine 0\n").should == ["`$AddBlankLine` is not a Remind system variable"]
+    end
+    it "points at the sigil" do
+      lint.("SET $Nope 1\n").first.column.should == 5
+    end
+    it "reports every one on a line" do
+      messages.("MSG [$Nope] and [$AlsoNope]\n").length.should == 2
+    end
+    it "reports at error severity" do
+      lint.("SET $Nope 1\n").first.severity.should == "error"
+    end
+  end
+  describe "what it stays quiet about" do
+    it "says nothing about a plain variable with no sigil" do
+      lint.("SET Latitude \"45.42\"\n").should.be.empty
+    end
+    it "says nothing about a name inside a string" do
+      lint.(%(MSG "costs $Nope dollars"\n)).should.be.empty
+    end
+    it "says nothing about comments" do
+      lint.("# uses $Nope somewhere\n").should.be.empty
+    end
+    it "says nothing about a bare dollar sign" do
+      lint.("RUN echo $ done\n").should.be.empty
+    end
+  end
+  describe "AllowedNames" do
+    it "accepts a name the configuration allows" do
+      lint.("MSG [$Latitude]\n", "AllowedNames" => ["Latitude"]).should.be.empty
+    end
+    it "matches an allowed name case-insensitively" do
+      lint.("MSG [$latitude]\n", "AllowedNames" => ["Latitude"]).should.be.empty
+    end
+    it "still reports the names it does not allow" do
+      messages.("MSG [$Latitude] [$Nope]\n", "AllowedNames" => ["Latitude"]).length.should == 1
+    end
+  end
+  it "reports the physical line inside a continuation" do
+    lint.("SET x 1 + \\\n    $Nope\n").first.line.should == 2
+  end
+end

data/lib/remlint/rules/unquoted_shell_substitution.rb ADDED Viewed

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+require_relative "../rule"
+module RemLint
+  module Rules
+    # Reminder text pasted into a shell command without quotes.
+    #
+    # `RUN` and `INCLUDECMD` bodies go through Remind's substitution filter and
+    # the result is handed to `/bin/sh`. So `%s`, `%<Location>` and `[expr]` are
+    # not text in a shell command -- they are *holes* in one, and what lands in
+    # them is data: a reminder body, a place name, somebody's surname.
+    #
+    #   REM 1 Jan RUN notify-send [msg]        # msg = "Bob's party" -> broken
+    #   REM 1 Jan RUN notify-send "[msg]"      # quoted, and fine
+    #
+    # An apostrophe is the polite failure. `$(...)`, a backtick or a `;` in the
+    # same position is a command running that nobody wrote, from a calendar,
+    # under cron, with the user's own privileges. Chapter 17's own INCLUDECMD
+    # example is careful to write `L="[lessons]"`; nothing enforces that care.
+    #
+    # This reports only what it is sure of: a substitution sitting outside any
+    # quote. Quoting is tracked by walking the body character by character --
+    # single quotes, double quotes, and the backslash escape inside double
+    # quotes -- because that is what the shell does with it.
+    #
+    # A body with no substitution at all is not this rule's business: a fixed
+    # `RUN echo hello` has no hole for anything to land in.
+    class UnquotedShellSubstitution < Rule
+      # Every hole the author did not write the contents of: the `%` sequences
+      # in all their forms, and a pasted `[expr]`.
+      SUBSTITUTION = /%\*?(?<simple><[^>]*>|\{[^}]*\}|\([^)]*\)|.)|\[[^\]]*\]/
+      # Sequences that expand to something fixed rather than to reminder data,
+      # and so are not holes:
+      #
+      #   %"  the calendar-text marker, which NORMAL_MODE deletes outright
+      #   %%  a literal percent
+      #   %_  a newline or a space
+      #
+      # Remind's own `tests/dedupe.rem` writes `RUN echo %"foo%"`; there is no
+      # data in that command for anyone to inject through.
+      CONSTANT = %w[" % _].freeze
+      def self.default_severity
+        "error"
+      end
+      def self.description
+        "Reminder text pasted into a RUN or INCLUDECMD body outside shell quotes."
+      end
+      def check
+        document.code_commands.each do |command|
+          body = shell_body(command)
+          if body
+            report_unquoted(command, body.fetch(:text), body.fetch(:offset))
+          end
+        end
+      end
+      private
+        # The shell text of the command, and where it starts in the logical
+        # line, or nil if this command does not run a shell at all.
+        def shell_body(command)
+          if command.keyword?("INCLUDECMD")
+            { text: command.args, offset: command.args_offset }
+          else
+            reminder_body(command)
+          end
+        end
+        def reminder_body(command)
+          trigger = document.trigger_for(command)
+          if trigger.body&.name == "RUN"
+            { text: command.text[trigger.body_offset..].to_s, offset: trigger.body_offset }
+          end
+        end
+        def report_unquoted(command, text, offset)
+          unquoted_spans(text).each do |span|
+            offend_at(
+              command.logical_line,
+              offset + span.begin(0),
+              "`#{span[0]}` is pasted into a shell command unquoted; " \
+              "wrap it in double quotes",
+            )
+          end
+        end
+        # Every substitution in `text` that the shell would see outside quotes.
+        def unquoted_spans(text)
+          quoted = quote_map(text)
+          text.to_enum(:scan, SUBSTITUTION).filter_map do
+            match = Regexp.last_match
+            unless quoted[match.begin(0)] || constant?(match)
+              match
+            end
+          end
+        end
+        def constant?(match)
+          CONSTANT.include?(match[:simple])
+        end
+        # A flag per character: is the shell inside a quote here? Walked rather
+        # than pattern-matched, because whether a quote opens or closes depends
+        # on every quote before it.
+        def quote_map(text)
+          state = nil
+          escaped = false
+          text.each_char.map do |character|
+            inside = !state.nil?
+            state, escaped = step(character, state, escaped)
+            inside || !state.nil?
+          end
+        end
+        def step(character, state, escaped)
+          if escaped
+            [state, false]
+          elsif state == '"' && character == "\\"
+            [state, true]
+          elsif state.nil? && (character == "'" || character == '"')
+            [character, false]
+          elsif state == character
+            [nil, false]
+          else
+            [state, false]
+          end
+        end
+    end
+  end
+end
+__END__
+require_relative "../document"
+describe "RemLint::Rules::UnquotedShellSubstitution" do
+  lint = proc do |text|
+    source = RemLint::Source.new(path: "t.rem", text: text)
+    RemLint::Rules::UnquotedShellSubstitution.new.run(RemLint::Document.new(source))
+  end
+  messages = proc { |text| lint.(text).map(&:message) }
+  describe "RUN bodies" do
+    it "reports a bare substitution" do
+      messages.("REM 1 Jan RUN notify-send %s\n").length.should == 1
+      messages.("REM 1 Jan RUN notify-send %s\n").first.should.match(/`%s` is pasted/)
+    end
+    it "reports a bare pasted expression" do
+      messages.("REM 1 Jan RUN notify-send [msg]\n").length.should == 1
+    end
+    it "accepts a substitution in double quotes" do
+      lint.(%(REM 1 Jan RUN notify-send "%s"\n)).should.be.empty
+    end
+    it "accepts a substitution in single quotes" do
+      lint.("REM 1 Jan RUN notify-send '%s'\n").should.be.empty
+    end
+    it "accepts a pasted expression in double quotes" do
+      lint.(%(REM 1 Jan RUN notify-send "[msg]"\n)).should.be.empty
+    end
+    it "reports the second of two when only the first is quoted" do
+      offenses = lint.(%(REM 1 Jan RUN cmd "%s" %t\n))
+      offenses.length.should == 1
+      offenses.first.message.should.match(/`%t`/)
+    end
+    it "is not fooled by a quote that closes before the substitution" do
+      lint.(%(REM 1 Jan RUN echo "hello" %s\n)).length.should == 1
+    end
+    it "is not fooled by an escaped quote inside a double-quoted string" do
+      # The \\" does not close the string, so %s is still inside it.
+      lint.(%(REM 1 Jan RUN echo "a \\" %s"\n)).should.be.empty
+    end
+    it "treats an apostrophe inside double quotes as text, not a quote" do
+      lint.(%(REM 1 Jan RUN echo "Bob's %s"\n)).should.be.empty
+    end
+    it "reports the substitution forms that take arguments" do
+      messages.("REM 1 Jan RUN cmd %<Location>\n").first.should.match(/%<Location>/)
+      messages.("REM 1 Jan RUN cmd %{name}\n").first.should.match(/%\{name\}/)
+    end
+    it "handles the %* modifier" do
+      messages.("REM 1 Jan RUN cmd %*l\n").first.should.match(/`%\*l`/)
+    end
+    it "says nothing about a RUN body with no substitution at all" do
+      lint.("REM 1 Jan RUN /usr/bin/backup --now\n").should.be.empty
+    end
+    it "says nothing about the sequences that expand to something fixed" do
+      # Straight from tests/dedupe.rem. `%"` is the calendar-text marker and
+      # NORMAL_MODE deletes it; there is no data here to inject through.
+      lint.(%(REM 8 RUN echo %"foo%"\n)).should.be.empty
+      lint.("REM 1 Jan RUN echo 50%% off\n").should.be.empty
+    end
+    it "says nothing about a command that only looks like it runs a shell" do
+      # `run` here is English, and ERRMSG takes its own argument.
+      lint.("ERRMSG Please run [filename()] with the -q option\n").should.be.empty
+    end
+  end
+  describe "INCLUDECMD" do
+    it "reports an unquoted paste" do
+      messages.("INCLUDECMD ./lessons [lessons]\n").length.should == 1
+    end
+    it "accepts the quoted form the book uses" do
+      lint.(%(INCLUDECMD ./gen L="[lessons]"\n)).should.be.empty
+    end
+  end
+  describe "what it leaves alone" do
+    it "says nothing about a MSG body" do
+      # A MSG body is printed, not executed.
+      lint.("REM 1 Jan MSG Party at [place]\n").should.be.empty
+    end
+    it "says nothing about a CAL or SPECIAL body" do
+      lint.("REM 1 Jan CAL [place]\n").should.be.empty
+      lint.("REM 1 Jan SPECIAL HTML [place]\n").should.be.empty
+    end
+    it "says nothing about a substitution in the trigger" do
+      lint.("REM [trigger(today())] MSG hi\n").should.be.empty
+    end
+    it "says nothing about comments" do
+      lint.("# REM 1 Jan RUN cmd %s\n").should.be.empty
+    end
+  end
+  it "reports at error severity" do
+    lint.("REM 1 Jan RUN cmd %s\n").first.severity.should == "error"
+  end
+  it "points at the substitution" do
+    text = "REM 1 Jan RUN cmd %s\n"
+    lint.(text).first.column.should == text.index("%s") + 1
+  end
+  it "reports the physical line inside a continuation" do
+    lint.("REM 1 Jan RUN cmd \\\n    %s\n").first.line.should == 2
+  end
+end