remlint 0.1.0

data/lib/remlint/rules/coordinate_not_string.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require_relative "../rule"
+require_relative "../expr_lexer"
+
+module RemLint
+  module Rules
+    # `$Latitude` or `$Longitude` set to something that is not a string.
+    #
+    # Remind has no floating-point type. A coordinate therefore has to arrive
+    # as a STRING and be parsed from it -- `SET $Latitude "45.42"`, with the
+    # quotes. `SET $Latitude 45.42` is not a near miss with a rounding error in
+    # it; `45.42` is not a Remind literal at all.
+    #
+    # `examples/astro` gets this right the hard way, threading the values in
+    # from the shell as strings:
+    #
+    #   remind -g "-i\$Latitude=\"$latitude\"" ...
+    #
+    # The failure is quiet and confident. Remind falls back or truncates, and
+    # then reports sunrise and sunset times that look entirely plausible and
+    # are for somewhere else.
+    class CoordinateNotString < Rule
+      COORDINATES = %w[latitude longitude].freeze
+
+      # `SET $Latitude <value>`, with the value running to end of line.
+      ASSIGNMENT = /\A\$(?<name>\w+)\s+(?<value>.+)\z/m
+
+      def self.default_severity
+        "error"
+      end
+
+      def self.description
+        "$Latitude or $Longitude set to something other than a string."
+      end
+
+      def check
+        document.code_commands.each do |command|
+          if command.keyword?("SET")
+            check_assignment(command)
+          end
+        end
+      end
+
+      private
+
+        def check_assignment(command)
+          match = command.args.match(ASSIGNMENT)
+
+          if match && COORDINATES.include?(match[:name].downcase)
+            check_value(command, match)
+          end
+        end
+
+        def check_value(command, match)
+          value = match[:value].strip
+          tokens = ExprLexer.significant(value)
+
+          if literal_non_string?(tokens)
+            offend(
+              command.line,
+              "`$#{match[:name]}` takes a STRING -- Remind has no floating-point " \
+              "type, so write `\"#{value}\"`",
+              column: command.keyword_column,
+            )
+          end
+        end
+
+        # Only a literal is reported. A single string token is right; a single
+        # bracketed or computed value cannot be judged without running it, and
+        # `[latitude_from_gps()]` is a perfectly good way to set this.
+        def literal_non_string?(tokens)
+          types = tokens.map(&:type)
+
+          types.first != :string &&
+            !types.include?(:lbracket) &&
+            !types.include?(:function) &&
+            !types.include?(:name)
+        end
+    end
+  end
+end
+
+__END__
+
+require_relative "../document"
+
+describe "RemLint::Rules::CoordinateNotString" do
+  lint = proc do |text|
+    source = RemLint::Source.new(path: "t.rem", text: text)
+
+    RemLint::Rules::CoordinateNotString.new.run(RemLint::Document.new(source))
+  end
+
+  messages = proc { |text| lint.(text).map(&:message) }
+
+  describe "coordinates written as numbers" do
+    it "reports a bare decimal" do
+      messages.("SET $Latitude 45.42\n").first.should ==
+        %(`$Latitude` takes a STRING -- Remind has no floating-point type, so write `"45.42"`)
+    end
+
+    it "reports a negative decimal" do
+      messages.("SET $Longitude -75.69\n").length.should == 1
+    end
+
+    it "reports a bare integer" do
+      messages.("SET $Latitude 45\n").length.should == 1
+    end
+
+    it "reports both coordinates" do
+      messages.("SET $Latitude 45.42\nSET $Longitude -75.69\n").length.should == 2
+    end
+
+    it "matches the variable name case-insensitively" do
+      messages.("SET $latitude 45.42\n").length.should == 1
+      messages.("SET $LONGITUDE 45.42\n").length.should == 1
+    end
+
+    it "points at the keyword" do
+      lint.("   SET $Latitude 45.42\n").first.column.should == 4
+    end
+  end
+
+  describe "coordinates written correctly" do
+    it "accepts a double-quoted string" do
+      lint.(%(SET $Latitude "45.42"\n)).should.be.empty
+    end
+
+    it "accepts a negative value in a string" do
+      lint.(%(SET $Longitude "-75.69"\n)).should.be.empty
+    end
+
+    it "accepts the degrees-minutes-seconds string form" do
+      lint.(%(SET $Latitude "45 25 12"\n)).should.be.empty
+    end
+  end
+
+  describe "values it cannot judge" do
+    it "says nothing about a pasted expression" do
+      lint.("SET $Latitude [gps_latitude()]\n").should.be.empty
+    end
+
+    it "says nothing about a function call" do
+      lint.("SET $Latitude coerce(\"STRING\", x)\n").should.be.empty
+    end
+
+    it "says nothing about a variable" do
+      # examples/astro feeds these in with remind -i$Latitude="..."
+      lint.("SET $Latitude mylat\n").should.be.empty
+    end
+  end
+
+  describe "what it leaves alone" do
+    it "says nothing about other system variables" do
+      lint.("SET $FormWidth 80\n").should.be.empty
+    end
+
+    it "says nothing about an ordinary variable of the same name" do
+      lint.("SET Latitude 45.42\n").should.be.empty
+    end
+
+    it "says nothing about a command that is not SET" do
+      lint.("MSG Latitude is [$Latitude]\n").should.be.empty
+    end
+
+    it "says nothing about comments" do
+      lint.("# SET $Latitude 45.42\n").should.be.empty
+    end
+  end
+
+  it "reports at error severity" do
+    lint.("SET $Latitude 45.42\n").first.severity.should == "error"
+  end
+end

data/lib/remlint/rules/dangling_continuation.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require_relative "../rule"
+
+module RemLint
+  module Rules
+    # Backslashes that look like line continuations and are not.
+    #
+    # Remind continues a line only when the backslash is the final character of
+    # it (src/files.c: `if (l && (DBufValue(&buf)[l-1] == '\\'))`). One
+    # invisible space after the backslash and the continuation silently stops
+    # being one -- the command is cut in half, the first half usually still
+    # parses as something, and the error surfaces somewhere else entirely.
+    #
+    # Both halves of that are worth reporting:
+    #
+    #   backslash then whitespace  the join you meant did not happen
+    #   backslash at end of file   the command you opened never closed
+    class DanglingContinuation < Rule
+      SWALLOWED = /\\[ \t]+\z/
+
+      SWALLOWED_MESSAGE =
+        "Backslash followed by whitespace does not continue the line; " \
+        "the backslash must be the last character"
+
+      UNTERMINATED_MESSAGE = "File ends inside a line continuation"
+
+      def self.default_severity
+        "error"
+      end
+
+      def self.description
+        "A backslash that looks like a line continuation but is not one."
+      end
+
+      def check
+        check_swallowed
+        check_unterminated
+      end
+
+      private
+
+        def check_swallowed
+          document.each_raw_line do |raw, line|
+            body = raw.chomp
+            match = body.match(SWALLOWED)
+
+            if match
+              offend(line, SWALLOWED_MESSAGE, column: match.begin(0) + 1)
+            end
+          end
+        end
+
+        # The joiner emits a command left open at end of file rather than
+        # dropping it, precisely so this can be said out loud.
+        def check_unterminated
+          last = document.logical_lines.last
+
+          if last && last.raw.chomp.end_with?("\\")
+            offend(last.last_line, UNTERMINATED_MESSAGE)
+          end
+        end
+    end
+  end
+end
+
+__END__
+
+require_relative "../document"
+
+describe "RemLint::Rules::DanglingContinuation" do
+  lint = proc do |text|
+    source = RemLint::Source.new(path: "t.rem", text: text)
+
+    RemLint::Rules::DanglingContinuation.new.run(RemLint::Document.new(source))
+  end
+
+  describe "a backslash followed by whitespace" do
+    it "is reported" do
+      offenses = lint.("SET x 1 + \\ \n2\n")
+
+      offenses.length.should == 1
+      offenses.first.line.should == 1
+      offenses.first.message.should.match(/does not continue/)
+    end
+
+    it "points at the backslash, not at the whitespace" do
+      lint.("SET x 1 + \\ \n2\n").first.column.should == 11
+    end
+
+    it "is reported for a trailing tab too" do
+      lint.("SET x 1 + \\\t\n2\n").length.should == 1
+    end
+
+    it "reports at error severity" do
+      lint.("SET x \\ \n").first.severity.should == "error"
+    end
+  end
+
+  describe "a real continuation" do
+    it "is left alone" do
+      lint.("SET x 1 + \\\n    2\n").should.be.empty
+    end
+
+    it "is left alone even several lines deep" do
+      lint.("SET x IIF(a, \\\n   b, \\\n   c)\n").should.be.empty
+    end
+  end
+
+  describe "a file that ends inside a continuation" do
+    it "is reported on the last line" do
+      offenses = lint.("MSG hi\nSET x 1 + \\\n")
+
+      offenses.map(&:message).should == ["File ends inside a line continuation"]
+      offenses.first.line.should == 2
+    end
+
+    it "is reported even when the file has no trailing newline" do
+      lint.("SET x 1 + \\").length.should == 1
+    end
+
+    it "reports the last physical line of a multi-line command" do
+      lint.("SET x 1 + \\\n    2 + \\\n").first.line.should == 2
+    end
+  end
+
+  it "says nothing about a file with no backslashes at all" do
+    lint.("MSG one\nMSG two\n").should.be.empty
+  end
+
+  it "says nothing about a backslash in the middle of a line" do
+    lint.(%(MSG a \\" b\n)).should.be.empty
+  end
+end

data/lib/remlint/rules/date_out_of_range.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require_relative "../rule"
+require_relative "../date_literal"
+
+module RemLint
+  module Rules
+    # Dates outside the range Remind can represent.
+    #
+    # Remind counts days from `BASE`, which is 1990, and represents
+    # `YR_RANGE` years, which is 4000 (src/custom.h.in). So 1990-01-01 to
+    # 5990-12-31 is not a policy, it is the type. A date below the floor cannot
+    # be stored at all.
+    #
+    # Three of the book's rules asked for a slice of this each --
+    # `TriggerComponentRange`, `DateConstantBeforeEpoch`,
+    # `DateOutsideRepresentableRange` -- and Appendix B's own note suggested
+    # collecting them. One rule keeps the message identical wherever the date
+    # was written.
+    #
+    # Two shapes are checked: a spelled-out date in a trigger, and a
+    # single-quoted date constant in an expression. A day of 32 or a month
+    # nobody has is caught by the same walk.
+    class DateOutOfRange < Rule
+      FIRST_YEAR = DateLiteral::EPOCH_YEAR
+      LAST_YEAR = DateLiteral::LAST_YEAR
+
+      # `'1970-01-01'`, `'2027-13-01'` -- a date constant, which the lexer
+      # hands over whole.
+      CONSTANT = %r{\A'(?<year>\d{4})[-/](?<month>\d{1,2})[-/](?<day>\d{1,2})}
+
+      DAYS_IN_MONTH = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31].freeze
+
+      def self.default_severity
+        "error"
+      end
+
+      def self.description
+        "A date outside 1990-01-01 to 5990-12-31, or with an impossible component."
+      end
+
+      def check
+        document.logical_lines.each_with_index do |logical_line, index|
+          if document.commands[index].code?
+            check_constants(logical_line)
+          end
+        end
+      end
+
+      private
+
+        def check_constants(logical_line)
+          document.tokens_for(logical_line).each do |token|
+            match = token.type == :string && token.value.match(CONSTANT)
+
+            if match
+              report(logical_line, token, match)
+            end
+          end
+        end
+
+        def report(logical_line, token, match)
+          year = match[:year].to_i
+          month = match[:month].to_i
+          day = match[:day].to_i
+          complaint = fault(year, month, day)
+
+          if complaint
+            offend_at(logical_line, token.offset, "`#{token.value}` #{complaint}")
+          end
+        end
+
+        def fault(year, month, day)
+          if year < FIRST_YEAR
+            "is before #{FIRST_YEAR}-01-01, which is the earliest date Remind represents"
+          elsif year > LAST_YEAR
+            "is after #{LAST_YEAR}-12-31, which is the latest date Remind represents"
+          else
+            component_fault(month, day)
+          end
+        end
+
+        def component_fault(month, day)
+          if month < 1 || month > 12
+            "has month #{month}"
+          elsif day < 1 || day > DAYS_IN_MONTH[month - 1]
+            "has day #{day} in a month with #{DAYS_IN_MONTH[month - 1]}"
+          end
+        end
+    end
+  end
+end
+
+__END__
+
+require_relative "../document"
+
+describe "RemLint::Rules::DateOutOfRange" do
+  lint = proc do |text|
+    source = RemLint::Source.new(path: "t.rem", text: text)
+
+    RemLint::Rules::DateOutOfRange.new.run(RemLint::Document.new(source))
+  end
+
+  messages = proc { |text| lint.(text).map(&:message) }
+
+  describe "dates Remind cannot represent" do
+    it "reports one before the epoch" do
+      messages.("SET a '1970-01-01'\n").first.should ==
+        "`'1970-01-01'` is before 1990-01-01, which is the earliest date Remind represents"
+    end
+
+    it "reports one after the last year" do
+      messages.("SET a '9999-01-01'\n").first.should.match(/is after 5990-12-31/)
+    end
+
+    it "accepts the first representable date" do
+      lint.("SET a '1990-01-01'\n").should.be.empty
+    end
+
+    it "accepts the last representable year" do
+      lint.("SET a '5990-12-31'\n").should.be.empty
+    end
+  end
+
+  describe "impossible components" do
+    it "reports a month of 13" do
+      messages.("SET a '2027-13-01'\n").first.should.match(/has month 13/)
+    end
+
+    it "reports a month of 0" do
+      messages.("SET a '2027-00-01'\n").first.should.match(/has month 0/)
+    end
+
+    it "reports a day past the length of its month" do
+      messages.("SET a '2027-02-30'\n").first.should.match(/has day 30 in a month with 29/)
+      messages.("SET a '2027-04-31'\n").first.should.match(/has day 31 in a month with 30/)
+    end
+
+    it "accepts 29 February, which some years have" do
+      lint.("SET a '2028-02-29'\n").should.be.empty
+    end
+
+    it "accepts the last day of a 31-day month" do
+      lint.("SET a '2027-01-31'\n").should.be.empty
+    end
+  end
+
+  it "accepts the slash separator" do
+    lint.("SET a '2027/01/31'\n").should.be.empty
+    messages.("SET a '1970/01/01'\n").length.should == 1
+  end
+
+  it "reports every bad constant on a line" do
+    messages.("IF ['1970-01-01' < '9999-01-01']\n").length.should == 2
+  end
+
+  it "says nothing about a datetime constant in range" do
+    lint.("SET a '2027-01-01@14:33'\n").should.be.empty
+  end
+
+  it "says nothing about an ordinary string that looks like a date" do
+    # Double quotes make it a STRING, not a DATE.
+    lint.(%(SET a "1970-01-01"\n)).should.be.empty
+  end
+
+  it "says nothing about comments" do
+    lint.("# SET a '1970-01-01'\n").should.be.empty
+  end
+
+  it "points at the constant" do
+    text = "SET a '1970-01-01'\n"
+
+    lint.(text).first.column.should == text.index("'") + 1
+  end
+
+  it "reports at error severity" do
+    lint.("SET a '1970-01-01'\n").first.severity.should == "error"
+  end
+end

data/lib/remlint/rules/debug_command.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require_relative "../rule"
+
+module RemLint
+  module Rules
+    # `DEBUG` flags that do nothing, and `DEBUG` flags left switched on.
+    #
+    # `DoDebug` in src/main.c reads the argument character by character: `+`
+    # turns flags on, `-` turns them off, and thirteen letters name a flag.
+    # Anything else reaches a `default:` branch that warns -- but only at
+    # warning level 05.02.03, so a script that has not raised the level gets a
+    # debug session that quietly does nothing.
+    #
+    # The other half matters more in a repository than at a terminal. Debug
+    # output is voluminous and goes to standard error, so a `DEBUG +x` that was
+    # never matched by a `DEBUG -x` turns every later run into a trace log --
+    # including the one under cron, which mails it to somebody.
+    class DebugCommand < Rule
+      # The flag letters `DoDebug` switches on, case-insensitive.
+      FLAGS = %w[p e q s h x t v l f n u z].freeze
+
+      SIGNS = %w[+ -].freeze
+
+      def self.default_severity
+        "warning"
+      end
+
+      def self.description
+        "A DEBUG flag Remind does not define, or one switched on and never off."
+      end
+
+      def check
+        left_on = {}
+
+        document.code_commands.each do |command|
+          if command.keyword?("DEBUG")
+            scan(command, left_on)
+          end
+        end
+
+        report_left_on(left_on)
+      end
+
+      private
+
+        def scan(command, left_on)
+          sign = "+"
+
+          command.args.each_char.with_index do |character, index|
+            sign = step(
+              command,
+              character,
+              sign,
+              index,
+              left_on,
+            )
+          end
+        end
+
+        def step(command, character, sign, index, left_on)
+          if SIGNS.include?(character)
+            character
+          elsif character.match?(/\s/)
+            sign
+          else
+            record(
+              command,
+              character,
+              sign,
+              index,
+              left_on,
+            )
+            sign
+          end
+        end
+
+        def record(command, character, sign, index, left_on)
+          if FLAGS.include?(character.downcase)
+            track(
+              command,
+              character.downcase,
+              sign,
+              left_on,
+            )
+          else
+            report_unknown(command, character, index)
+          end
+        end
+
+        def track(command, flag, sign, left_on)
+          if sign == "+"
+            left_on[flag] ||= command
+          else
+            left_on.delete(flag)
+          end
+        end
+
+        def report_unknown(command, character, index)
+          offend(
+            command.line,
+            "`#{character}` is not a DEBUG flag; Remind defines #{FLAGS.join(', ')}",
+            column: command.args_offset + index + 1,
+          )
+        end
+
+        def report_left_on(left_on)
+          left_on.each do |flag, command|
+            offend(
+              command.line,
+              "`DEBUG +#{flag}` is never matched by a `DEBUG -#{flag}`; debug output " \
+              "goes to standard error on every later run, including the one under cron",
+              column: command.keyword_column,
+            )
+          end
+        end
+    end
+  end
+end
+
+__END__
+
+require_relative "../document"
+
+describe "RemLint::Rules::DebugCommand" do
+  lint = proc do |text|
+    source = RemLint::Source.new(path: "t.rem", text: text)
+
+    RemLint::Rules::DebugCommand.new.run(RemLint::Document.new(source))
+  end
+
+  messages = proc { |text| lint.(text).map(&:message) }
+
+  describe "unknown flags" do
+    it "reports a letter Remind does not define" do
+      messages.("DEBUG +w\nDEBUG -w\n").first.should.match(/`w` is not a DEBUG flag/)
+    end
+
+    it "lists the flags Remind does define" do
+      messages.("DEBUG +w\nDEBUG -w\n").first.should.match(/p, e, q, s, h, x, t, v, l, f, n, u, z/)
+    end
+
+    it "accepts every flag Remind defines" do
+      lint.("DEBUG +peqshxtvlfnuz\nDEBUG -peqshxtvlfnuz\n").should.be.empty
+    end
+
+    it "accepts them in upper case" do
+      lint.("DEBUG +X\nDEBUG -X\n").should.be.empty
+    end
+  end
+
+  describe "flags left on" do
+    it "reports a flag switched on and never off" do
+      messages.("DEBUG +x\n").first.should.match(/never matched by a `DEBUG -x`/)
+    end
+
+    it "accepts a flag switched on and then off" do
+      lint.("DEBUG +x\nMSG hi\nDEBUG -x\n").should.be.empty
+    end
+
+    it "accepts several flags switched on and off together" do
+      lint.("DEBUG +xt\nMSG hi\nDEBUG -xt\n").should.be.empty
+    end
+
+    it "reports each flag left on" do
+      lint.("DEBUG +xt\n").length.should == 2
+    end
+
+    it "handles a sign that applies to several letters" do
+      lint.("DEBUG +xt -x\nDEBUG -t\n").should.be.empty
+    end
+
+    it "reports the line the flag was switched on" do
+      lint.("MSG hi\nDEBUG +x\n").first.line.should == 2
+    end
+  end
+
+  it "says nothing about a file with no DEBUG at all" do
+    lint.("MSG hi\n").should.be.empty
+  end
+
+  it "says nothing about comments" do
+    lint.("# DEBUG +w\n").should.be.empty
+  end
+
+  it "reports at warning severity" do
+    lint.("DEBUG +x\n").first.severity.should == "warning"
+  end
+end