remlint 0.1.0

data/lib/remlint/rules/localization_pack.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require_relative "../rule"
+
+module RemLint
+  module Rules
+    # A language pack that never translates `LANGID`.
+    #
+    # Scripts branch on `_("LANGID")` to pick language-specific behaviour, and
+    # an untranslated LANGID reverts to `"en"`. So a fully translated pack that
+    # never translates LANGID sends every one of those scripts down the English
+    # path -- and does it by producing English, which reads as "not translated
+    # yet" rather than "translated and ignored".
+    #
+    # A pack is recognised by its day and month names, which is what
+    # `include/lang/*.rem` set and what nothing else does. A file translating a
+    # handful of strings -- `include/translations/de/sun.rem` is two lines --
+    # is not a pack and has no LANGID to translate.
+    class LocalizationPack < Rule
+      LANGID = "LANGID"
+
+      # What a language pack sets and a string file does not.
+      PACK_NAMES = (
+        %w[monday tuesday wednesday thursday friday saturday sunday] +
+        %w[january february march april may june july
+           august september october november december
+]
+      ).freeze
+
+      TRANSLATED = /\A\s*"(?<original>(?:[^"\\]|\\.)*)"\s*"/
+
+      SYSVAR_SET = /\A\$(?<name>\w+)\s/
+
+      def self.default_severity
+        "info"
+      end
+
+      def self.description
+        "A language pack that never translates LANGID, which reverts to English."
+      end
+
+      def check
+        if pack?
+          check_langid
+        end
+      end
+
+      private
+
+        # A pack names the days and months. `include/lang/de.rem` writes
+        # `SET $Monday "Montag"`; a translation file writes neither.
+        def pack?
+          document.code_commands.any? { |command| names_a_day_or_month?(command) }
+        end
+
+        def names_a_day_or_month?(command)
+          if command.keyword?("SET")
+            match = command.args.match(SYSVAR_SET)
+
+            !match.nil? && PACK_NAMES.include?(match[:name].downcase)
+          elsif command.keyword?("TRANSLATE")
+            original = command.args.match(TRANSLATED)&.[](:original)
+
+            PACK_NAMES.include?(original.to_s.downcase)
+          end
+        end
+
+        def check_langid
+          unless translates_langid?
+            offend(
+              document.line_number_at(0),
+              "this pack never translates `#{LANGID}`, which reverts to `\"en\"` -- so " \
+              "every script branching on `_(\"#{LANGID}\")` takes the English path",
+            )
+          end
+        end
+
+        def translates_langid?
+          document.code_commands.any? do |command|
+            command.keyword?("TRANSLATE") &&
+              command.args.match(TRANSLATED)&.[](:original) == LANGID
+          end
+        end
+    end
+  end
+end
+
+__END__
+
+require_relative "../document"
+
+describe "RemLint::Rules::LocalizationPack" do
+  lint = proc do |text|
+    source = RemLint::Source.new(path: "t.rem", text: text)
+
+    RemLint::Rules::LocalizationPack.new.run(RemLint::Document.new(source))
+  end
+
+  messages = proc { |text| lint.(text).map(&:message) }
+
+  describe "LANGID" do
+    it "reports a pack that never translates it" do
+      messages.(%(TRANSLATE "Monday" "Montag"\n)).first.should.match(
+        /never translates `LANGID`, which reverts to `"en"`/,
+      )
+    end
+
+    it "accepts a pack that does" do
+      text = %(TRANSLATE "LANGID" "de"\nTRANSLATE "Monday" "Montag"\n)
+
+      lint.(text).should.be.empty
+    end
+
+    it "says nothing about a file that translates nothing" do
+      lint.("REM 1 Jan MSG hi\n").should.be.empty
+    end
+
+    it "recognises a pack by the day and month names it sets" do
+      # include/lang/de.rem writes SET $Monday "Montag" rather than TRANSLATE.
+      messages.(%(SET $Monday "Montag"\n)).length.should == 1
+      lint.(%(SET $Monday "Montag"\nTRANSLATE "LANGID" "de"\n)).should.be.empty
+    end
+
+    it "does not count a file that translates a handful of strings" do
+      # include/translations/de/sun.rem is exactly this, and is not a pack.
+      lint.(%(TRANSLATE "Sunrise" "Sonnenaufgang"\nTRANSLATE "Sunset" "Sonnenuntergang"\n))
+        .should.be.empty
+    end
+
+    it "explains the consequence" do
+      messages.(%(TRANSLATE "Monday" "Montag"\n)).first.should.match(
+        /takes the English path/,
+      )
+    end
+  end
+
+  it "says nothing about comments" do
+    lint.(%(# TRANSLATE "Monday" "Montag"\n)).should.be.empty
+  end
+
+  it "reports at info severity" do
+    lint.(%(TRANSLATE "Monday" "Montag"\n)).first.severity.should == "info"
+  end
+end

data/lib/remlint/rules/moon_phase_argument.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require_relative "../rule"
+
+module RemLint
+  module Rules
+    # Moon and season selectors outside their four-element sets.
+    #
+    # `moondate`, `moondatetime` and `moontime` take a phase: 0 new, 1 first
+    # quarter, 2 full, 3 last quarter. `soleq` takes an event: 0 March equinox,
+    # 1 June solstice, 2 September equinox, 3 December solstice. Both are
+    # closed sets of four, so a literal 4 is always wrong and always visible
+    # without running anything.
+    #
+    # Remind agrees -- `moondate(4)` is `Number too high` -- but says so on the
+    # day the line is reached, which for a moon reminder is the day it was
+    # supposed to fire.
+    class MoonPhaseArgument < Rule
+      PHASES = {
+        "moondate"     => "a moon phase",
+        "moondatetime" => "a moon phase",
+        "moontime"     => "a moon phase",
+        "soleq"        => "a solstice or equinox",
+      }.freeze
+
+      MEANINGS = {
+        "a moon phase"          => "0 new, 1 first quarter, 2 full, 3 last quarter",
+        "a solstice or equinox" => "0 March equinox, 1 June solstice, " \
+                                    "2 September equinox, 3 December solstice",
+      }.freeze
+
+      LIMIT = 3
+
+      def self.default_severity
+        "error"
+      end
+
+      def self.description
+        "A moon phase or solstice selector outside the four values it accepts."
+      end
+
+      def check
+        document.logical_lines.each_with_index do |logical_line, index|
+          if document.commands[index].code?
+            check_line(logical_line)
+          end
+        end
+      end
+
+      private
+
+        def check_line(logical_line)
+          tokens = document.tokens_for(logical_line)
+
+          tokens.each_index do |index|
+            selector = literal_selector(tokens, index)
+
+            if selector
+              report(logical_line, tokens[index], selector)
+            end
+          end
+        end
+
+        # `name ( <number>` -- the selector is always the first argument.
+        def literal_selector(tokens, index)
+          token = tokens[index]
+          argument = tokens[index + 2]
+
+          if token.type == :function && PHASES.key?(token.value.downcase) &&
+             tokens[index + 1]&.type == :lparen && argument&.type == :number
+            argument
+          end
+        end
+
+        def report(logical_line, name, argument)
+          value = argument.value.to_i
+
+          if value > LIMIT
+            kind = PHASES.fetch(name.value.downcase)
+
+            offend_at(logical_line, argument.offset, message(name.value, kind, value))
+          end
+        end
+
+        def message(name, kind, value)
+          "`#{name}(#{value})` is outside the four values #{kind} takes " \
+          "(#{MEANINGS.fetch(kind)}); Remind answers `Number too high`"
+        end
+    end
+  end
+end
+
+__END__
+
+require_relative "../document"
+
+describe "RemLint::Rules::MoonPhaseArgument" do
+  lint = proc do |text|
+    source = RemLint::Source.new(path: "t.rem", text: text)
+
+    RemLint::Rules::MoonPhaseArgument.new.run(RemLint::Document.new(source))
+  end
+
+  messages = proc { |text| lint.(text).map(&:message) }
+
+  describe "selectors that exist" do
+    it "accepts the four moon phases" do
+      # include/moonphases.rem writes exactly these.
+      (0..3).each do |phase|
+        lint.("REM [moondatetime(#{phase})] MSG Moon\n").should.be.empty
+      end
+    end
+
+    it "accepts the four solstice and equinox events" do
+      (0..3).each do |event|
+        lint.("REM [datepart(soleq(#{event}, $U))] MSG Season\n").should.be.empty
+      end
+    end
+
+    it "accepts moondate and moontime too" do
+      lint.("MSG [moondate(2)] [moontime(2)]\n").should.be.empty
+    end
+  end
+
+  describe "selectors that do not" do
+    it "reports a moon phase of 4" do
+      messages.("REM [moondatetime(4)] MSG Moon\n").first.should ==
+        "`moondatetime(4)` is outside the four values a moon phase takes " \
+        "(0 new, 1 first quarter, 2 full, 3 last quarter); Remind answers `Number too high`"
+    end
+
+    it "reports a solstice selector of 4" do
+      messages.("MSG [soleq(4, $U)]\n").first.should.match(/a solstice or equinox takes/)
+    end
+
+    it "reports each bad selector on a line" do
+      messages.("MSG [moondate(4)] [moondate(9)]\n").length.should == 2
+    end
+
+    it "points at the argument" do
+      text = "MSG [moondate(4)]\n"
+
+      lint.(text).first.column.should == text.index("4") + 1
+    end
+  end
+
+  it "says nothing about a computed selector" do
+    lint.("MSG [moondate(n)]\n").should.be.empty
+  end
+
+  it "says nothing about another function taking a large number" do
+    lint.("MSG [max(4, 9)]\n").should.be.empty
+  end
+
+  it "says nothing about comments" do
+    lint.("# MSG [moondate(4)]\n").should.be.empty
+  end
+
+  it "reports at error severity" do
+    lint.("MSG [moondate(4)]\n").first.severity.should == "error"
+  end
+end

data/lib/remlint/rules/omit_aware_delta.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require_relative "../rule"
+
+module RemLint
+  module Rules
+    # A single-sign delta in a file with nothing omitted.
+    #
+    # `++n` counts calendar days back from the event; `+n` counts *non-omitted*
+    # days. The distinction is the whole point of the single-sign form, and it
+    # is exactly nothing when the omit context is empty: with no `OMIT`
+    # anywhere, `+n` and `++n` produce identical reminders.
+    #
+    # So a single sign in a file with no omits is one of two things, and both
+    # are worth a look: a `+` that was meant to be `++`, or a reminder that
+    # depends on an `OMIT` somebody forgot to write. The same holds for the
+    # single-tilde back, `~n`.
+    #
+    # Off by default. A file that gets its omits from an `INCLUDE` is correct
+    # and this rule cannot see that -- which is why the check also stays quiet
+    # in any file that includes anything.
+    class OmitAwareDelta < Rule
+      # `+3` and `~3`, but not `++3` or `~~3`, and not an arithmetic `+`.
+      SINGLE = /(?<![+~\d\w])(?<sign>[+~])(?![+~])(?<count>\d+)(?!\S)/
+
+      # `OMIT` is a command; `ADDOMIT` and `OMITFUNC` are clauses on a `REM`,
+      # so both places have to be looked at.
+      OMIT_COMMANDS = %w[OMIT].freeze
+
+      OMIT_CLAUSES = %w[ADDOMIT OMITFUNC].freeze
+
+      INCLUDE_COMMANDS = %w[INCLUDE SYSINCLUDE INCLUDECMD DO].freeze
+
+      def self.enabled_by_default?
+        false
+      end
+
+      def self.default_severity
+        "info"
+      end
+
+      def self.description
+        "A single-sign delta or back in a file that omits nothing."
+      end
+
+      def check
+        if omits? || includes?
+          nil
+        else
+          report_deltas
+        end
+      end
+
+      private
+
+        def omits?
+          document.code_commands.any? do |command|
+            command.keyword?(*OMIT_COMMANDS) ||
+              document.trigger_for(command).include?(*OMIT_CLAUSES)
+          end
+        end
+
+        # A file that includes something may be getting its omits from there.
+        def includes?
+          document.code_commands.any? { |command| command.keyword?(*INCLUDE_COMMANDS) }
+        end
+
+        def report_deltas
+          document.code_commands.each do |command|
+            trigger = document.trigger_for(command)
+
+            if trigger.triggered?
+              scan(command, trigger)
+            end
+          end
+        end
+
+        def scan(command, trigger)
+          limit = trigger.body_offset || command.text.length
+          head = command.text[0...limit].to_s
+
+          head.to_enum(:scan, SINGLE).each do
+            match = Regexp.last_match
+
+            offend_at(command.logical_line, match.begin(0), message(match))
+          end
+        end
+
+        def message(match)
+          sign = match[:sign]
+          doubled = sign * 2
+
+          "`#{sign}#{match[:count]}` counts non-omitted days, and this file omits " \
+          "nothing -- so it is exactly `#{doubled}#{match[:count]}`; either the sign " \
+          "was meant to be doubled or an `OMIT` is missing"
+        end
+    end
+  end
+end
+
+__END__
+
+require_relative "../document"
+
+describe "RemLint::Rules::OmitAwareDelta" do
+  lint = proc do |text|
+    source = RemLint::Source.new(path: "t.rem", text: text)
+
+    RemLint::Rules::OmitAwareDelta.new.run(RemLint::Document.new(source))
+  end
+
+  messages = proc { |text| lint.(text).map(&:message) }
+
+  it "is off unless the configuration asks for it" do
+    RemLint::Rules::OmitAwareDelta.enabled_by_default?.should.be.false
+  end
+
+  it "reports a single-plus delta in a file with no omits" do
+    messages.("REM 16 July +10 MSG hi\n").first.should.match(
+      /counts non-omitted days, and this file omits nothing/,
+    )
+  end
+
+  it "suggests the doubled sign" do
+    messages.("REM 16 July +10 MSG hi\n").first.should.match(/exactly `\+\+10`/)
+  end
+
+  it "reports a single tilde back" do
+    messages.("REM 16 July ~3 MSG hi\n").first.should.match(/exactly `~~3`/)
+  end
+
+  it "accepts a doubled delta" do
+    lint.("REM 16 July ++10 MSG hi\n").should.be.empty
+  end
+
+  it "accepts a doubled back" do
+    lint.("REM 16 July ~~3 MSG hi\n").should.be.empty
+  end
+
+  it "says nothing in a file that omits something" do
+    lint.("OMIT 1 Jan\nREM 16 July +10 MSG hi\n").should.be.empty
+  end
+
+  it "says nothing in a file that uses ADDOMIT" do
+    lint.("REM 1 Apr ADDOMIT MSG x\nREM 16 July +10 MSG hi\n").should.be.empty
+  end
+
+  it "says nothing in a file that includes anything" do
+    # The omits may be in the included file.
+    lint.("INCLUDE defs.rem\nREM 16 July +10 MSG hi\n").should.be.empty
+  end
+
+  it "does not read a delta out of the body" do
+    lint.("REM 16 July MSG the score was +10\n").should.be.empty
+  end
+
+  it "does not read arithmetic as a delta" do
+    lint.("SET a 3 +10\n").should.be.empty
+  end
+
+  it "says nothing about comments" do
+    lint.("# REM 16 July +10 MSG hi\n").should.be.empty
+  end
+
+  it "reports at info severity" do
+    lint.("REM 16 July +10 MSG hi\n").first.severity.should == "info"
+  end
+end

data/lib/remlint/rules/push_vars_missing_name.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require_relative "../rule"
+
+module RemLint
+  module Rules
+    # A variable assigned inside a `PUSH-VARS` block that the `PUSH-VARS` did
+    # not name.
+    #
+    # `PUSH-VARS a b c` saves exactly `a`, `b` and `c`, and `POP-VARS` restores
+    # exactly those. An assignment to anything else inside the block survives
+    # the `POP` -- which is the one thing the block was written to prevent.
+    #
+    # The bare `PUSH-VARS` with no names saves *every* variable, so a block
+    # written that way is never reported: it cannot leak.
+    #
+    # Nothing about this is an error, and nothing reports it. The block looks
+    # like a scope, reads like a scope, and quietly is not one for the variable
+    # somebody added later.
+    class PushVarsMissingName < Rule
+      ASSIGNMENT = /\A(?<name>[A-Za-z_]\w*)\b/
+
+      def self.default_severity
+        "warning"
+      end
+
+      def self.description
+        "A variable SET inside a PUSH-VARS block that the PUSH-VARS never named."
+      end
+
+      def check
+        @stack = []
+
+        document.code_commands.each do |command|
+          dispatch(command)
+        end
+      end
+
+      private
+
+        def dispatch(command)
+          if command.keyword?("PUSH-VARS")
+            @stack.push(saved(command))
+          elsif command.keyword?("POP-VARS")
+            @stack.pop
+          elsif command.keyword?("SET", "UNSET")
+            check_assignment(command)
+          end
+        end
+
+        # The names the PUSH-VARS listed, or nil for the bare form that saves
+        # everything.
+        def saved(command)
+          names = command.args.strip.split(/[\s,]+/).reject(&:empty?)
+
+          if names.empty?
+            nil
+          else
+            names.map(&:downcase)
+          end
+        end
+
+        def check_assignment(command)
+          frame = @stack.last
+          name = assigned_name(command)
+
+          if !@stack.empty? && frame && name && !frame.include?(name.downcase)
+            offend(command.line, message(name, frame), column: command.keyword_column)
+          end
+        end
+
+        # `SET $SysVar` is a different namespace and `POP-VARS` does not carry
+        # it, so only ordinary variables are checked.
+        def assigned_name(command)
+          match = command.args.match(ASSIGNMENT)
+
+          match && match[:name]
+        end
+
+        def message(name, saved)
+          "`#{name}` is not one of the variables this `PUSH-VARS` saved " \
+          "(#{saved.join(', ')}), so the assignment survives the `POP-VARS`"
+        end
+    end
+  end
+end
+
+__END__
+
+require_relative "../document"
+
+describe "RemLint::Rules::PushVarsMissingName" do
+  lint = proc do |text|
+    source = RemLint::Source.new(path: "t.rem", text: text)
+
+    RemLint::Rules::PushVarsMissingName.new.run(RemLint::Document.new(source))
+  end
+
+  messages = proc { |text| lint.(text).map(&:message) }
+
+  it "reports an assignment the PUSH-VARS did not name" do
+    messages.("PUSH-VARS a\nSET b 1\nPOP-VARS\n").first.should ==
+      "`b` is not one of the variables this `PUSH-VARS` saved (a), so the assignment " \
+      "survives the `POP-VARS`"
+  end
+
+  it "accepts an assignment the PUSH-VARS named" do
+    lint.("PUSH-VARS a\nSET a 1\nPOP-VARS\n").should.be.empty
+  end
+
+  it "accepts any of several names" do
+    lint.("PUSH-VARS a b c\nSET b 1\nSET c 2\nPOP-VARS\n").should.be.empty
+  end
+
+  it "accepts names separated by commas" do
+    lint.("PUSH-VARS a, b\nSET b 1\nPOP-VARS\n").should.be.empty
+  end
+
+  it "matches names case-insensitively" do
+    lint.("PUSH-VARS Foo\nSET foo 1\nPOP-VARS\n").should.be.empty
+  end
+
+  it "accepts everything inside a bare PUSH-VARS, which saves the lot" do
+    lint.("PUSH-VARS\nSET anything 1\nPOP-VARS\n").should.be.empty
+  end
+
+  it "says nothing outside a block" do
+    lint.("SET b 1\nPUSH-VARS a\nPOP-VARS\nSET c 2\n").should.be.empty
+  end
+
+  it "reports an UNSET too" do
+    messages.("PUSH-VARS a\nUNSET b\nPOP-VARS\n").length.should == 1
+  end
+
+  it "says nothing about a system variable, which POP-VARS does not carry" do
+    lint.("PUSH-VARS a\nSET $FormWidth 80\nPOP-VARS\n").should.be.empty
+  end
+
+  it "uses the innermost block's list" do
+    lint.("PUSH-VARS a\nPUSH-VARS b\nSET b 1\nPOP-VARS\nPOP-VARS\n").should.be.empty
+  end
+
+  it "reports against the innermost block only" do
+    messages.("PUSH-VARS a\nPUSH-VARS b\nSET a 1\nPOP-VARS\nPOP-VARS\n").length.should == 1
+  end
+
+  it "points at the keyword" do
+    lint.("PUSH-VARS a\n   SET b 1\nPOP-VARS\n").first.column.should == 4
+  end
+
+  it "says nothing about comments" do
+    lint.("PUSH-VARS a\n# SET b 1\nPOP-VARS\n").should.be.empty
+  end
+
+  it "reports at warning severity" do
+    lint.("PUSH-VARS a\nSET b 1\nPOP-VARS\n").first.severity.should == "warning"
+  end
+end