sas-linter 0.2.3 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 144b602b9b4eff14c301d9c04852f07f490e9557802f897eb4dd08acbf3d3fa4
-  data.tar.gz: 4aa7e953e1ed8a05cd1f4b94cf698086438a529604019120be0bcc0bb0530be3
+  metadata.gz: b12c05da17de3409a5eb163f3e3325cb7e2e24770d3de42e01efb786fc796d60
+  data.tar.gz: b14b81be912177959a039484c70ea7bf71f209910cf995822d8083c8d6ea2897
 SHA512:
-  metadata.gz: 74e7303ebdcfcfc616cd6e520f8984494d687b3c0c3af6dcba4efba91f7cbfefd61f511bfa535ae4ee9c4f6a481d4774a96b7a4ff20803ce2768782f2b39f5e6
-  data.tar.gz: 7a1dab42267ac076c9d992d7770871c386d52d6f4c6c2cc088372151b6f586e1ff12b963dcab26a47aa0b427396eef989c9f837805a4183e35c43a734b8fbd41
+  metadata.gz: 5fa28c6588e96bdd973197577e0e3fb1aa689fd641455ed10225f0354e0243e41fdb1e682b20d0de02d2a443b30ae9d263f419a31d42ea12763d91320bef7078
+  data.tar.gz: aa8eb2ffe598911984fd57acff5ea350136865ccc64da7d7003b23033840013ac5c544a9bfd56d7f57bcb67c1f01de5af74c5b32f59d87300eac3525ae9e9bfe

data/README.md

@@ -1,6 +1,6 @@
 # sas-linter
 
-A configurable lint engine for SAS source files. Built on the [`sas-lexer`](https://github.com/mes-amis/sas-lexer-rb) gem (a Ruby FFI binding to Misha Perlov's Rust [`sas-lexer`](https://github.com/mishamsk/sas-lexer)) and ships with thirteen pluggable rules covering structural defects, cosmetic issues, and source-header conventions.
+A configurable lint engine for SAS source files. Built on the [`sas-lexer`](https://github.com/mes-amis/sas-lexer-rb) gem (a Ruby FFI binding to Misha Perlov's Rust [`sas-lexer`](https://github.com/mishamsk/sas-lexer)) and ships with fifteen pluggable rules covering structural defects, cosmetic issues, and source-header conventions.
 
 ## Installation
 
@@ -63,10 +63,17 @@ rules:
     enabled: true
     autofix: false             # rule supports autofix; off by default
 
+  unterminated_comment:
+    enabled: true
+    autofix: false             # append `;` to `**…**` lines whose missing terminator eats the next line
+
   inconsistent_variable_case:
     enabled: true
     autofix: false             # rewrite every minority casing to the most-common form
 
+  format_for_unknown_variable:
+    enabled: true              # skipped automatically when the file uses set/merge/update/infile/input
+
   variable_value_out_of_known_range:
     enabled: true
     csv_paths:                          # empty list = rule is a no-op
@@ -138,8 +145,10 @@ findings = linter.lint_file("path/to/source.sas")
 | `encoding_issues` | Smart-quote / em-dash / Win-1252 byte sequences that confuse downstream tooling. |
 | `malformed_if_condition` | Empty conditions, missing operators, orphan `then`, unbalanced parens, etc. |
 | `missing_assignment_semicolon` | Assignment statements followed by an inline `**` comment but no terminating `;`. |
+| `unterminated_comment` | A standalone `** … **` comment whose missing `;` lets the SAS lexer extend the comment into the next line of real code, silently swallowing it. Autofix appends the `;`. |
 | `variable_value_out_of_known_range` | `if VAR = N` / `if VAR in (...)` literals fall outside the variable's documented acceptable values. Loads the catalog from one or more CSVs with configurable column names and column separator (`,`, `;`, tab). |
 | `inconsistent_variable_case` | Identifier appears with more than one casing in the same file (`myVar` vs `MyVar`). SAS treats both as the same variable; autofix rewrites every minority spelling to the most-common form. Skips proc-format definitions and `format.` / `lib.member` references. |
+| `format_for_unknown_variable` | `format` / `informat` / `attrib` statement assigns a format to a variable that's referenced nowhere else in the file — almost always a typo. Skipped on files that pull in columns via `set` / `merge` / `update` / `infile` / `input`. |
 
 `bin/sas_lint --list-rules` prints the same set with autofix capability.
 

data/lib/sas_linter/rules/format_for_unknown_variable.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require_relative "../../sas_linter"
+require "sas_lexer"
+
+class SasLinter
+  module Rules
+    # Flag `format` / `informat` / `attrib ... format=` statements that
+    # name a variable referenced nowhere else in the file. Almost always
+    # a typo (`attrib totalscore format=flagx.;` when every other use is
+    # `total_score`). SAS itself silently binds the format to a phantom
+    # column and runs; downstream tooling that resolves variable
+    # references (e.g. sas-ruby) refuses to compile such a file.
+    #
+    # The rule is conservative: a file that pulls variables in from an
+    # external source — `set`, `merge`, `update`, `infile`, `input` — is
+    # skipped entirely, since a format target may legitimately name a
+    # column the linter can't see.
+    class FormatForUnknownVariable < Rule
+      rule_id :format_for_unknown_variable
+      description "Variable named in a `format` / `informat` / `attrib` " \
+                  "statement is referenced nowhere else in the file — " \
+                  "almost always a typo."
+      severity :warning
+
+      TT = SasLexer::Lexer::TokenType
+
+      FORMAT_KIND_BY_TYPE = {
+        TT::KW_FORMAT => :format,
+        TT::KW_INFORMAT => :informat,
+        TT::KW_ATTRIB => :attrib
+      }.freeze
+
+      EXTERNAL_INPUT_TYPES = [
+        TT::KW_SET, TT::KW_MERGE, TT::KW_UPDATE, TT::KW_INFILE, TT::KW_INPUT
+      ].freeze
+
+      # Statements that name variables for declaration only — the names
+      # they reference don't count as "real uses" because if a variable
+      # only appears in declaration statements it's still dead code.
+      # Keyword-typed openers:
+      DECLARATION_TYPES = [
+        TT::KW_FORMAT, TT::KW_INFORMAT, TT::KW_ATTRIB,
+        TT::KW_LABEL, TT::KW_LENGTH, TT::KW_KEEP, TT::KW_DROP, TT::KW_ARRAY
+      ].freeze
+
+      # IDENTIFIER-typed openers (the lexer doesn't keyword these):
+      #   `retain` is a data-step declaration;
+      #   `value` / `invalue` / `picture` introduce a `proc format` body.
+      DECLARATION_TEXT = %w[retain value invalue picture].freeze
+
+      def check(tokens, path:, all_tokens: nil, source: nil) # rubocop:disable Lint/UnusedMethodArgument
+        external_input = false
+        targets = []
+        use_names = Set.new
+
+        each_statement(tokens) do |stmt|
+          opener = stmt[0]
+
+          if EXTERNAL_INPUT_TYPES.include?(opener[:type])
+            external_input = true
+            next
+          end
+
+          kind = FORMAT_KIND_BY_TYPE[opener[:type]]
+          if kind
+            collect_targets(stmt, kind, targets)
+            next
+          end
+
+          next if declaration_statement?(opener)
+
+          collect_uses(stmt, use_names)
+        end
+
+        return [] if external_input
+
+        targets.filter_map do |t, kind|
+          next if use_names.include?(t[:text].downcase)
+
+          finding(
+            line: t[:start_line],
+            column: t[:start_column] + 1,
+            message: "`#{kind}` assigns a format to `#{t[:text]}` but " \
+                     "that variable is not referenced anywhere else in " \
+                     "this file — likely a typo.",
+            path: path
+          )
+        end
+      end
+
+      private
+
+      # Yield each `; ... ;` slice (opener at index 0, no trailing `;`).
+      # Stray semicolons produce empty slices and are skipped.
+      def each_statement(tokens)
+        start = 0
+        tokens.each_with_index do |t, i|
+          next unless t[:type] == TT::SEMI
+
+          slice = tokens[start...i]
+          yield slice unless slice.empty?
+          start = i + 1
+        end
+      end
+
+      def declaration_statement?(opener)
+        return true if DECLARATION_TYPES.include?(opener[:type])
+        return true if opener[:type] == TT::IDENTIFIER &&
+                       DECLARATION_TEXT.include?(opener[:text].downcase)
+
+        false
+      end
+
+      def collect_targets(stmt, kind, targets)
+        stmt.each_with_index do |t, i|
+          next unless t[:type] == TT::IDENTIFIER
+          next unless variable_target?(stmt, i)
+
+          targets << [t, kind]
+        end
+      end
+
+      # In `format`/`informat`, the format name is the identifier
+      # byte-adjacent to a following `.` (`date9.`, `flagx.`). In
+      # `attrib`, the format name additionally follows `=`
+      # (`format=flagx.`). Everything else is a variable target.
+      def variable_target?(stmt, i)
+        t = stmt[i]
+        nxt = stmt[i + 1]
+        prev = i.positive? ? stmt[i - 1] : nil
+
+        return false if nxt && nxt[:type] == TT::DOT && nxt[:start] == t[:end]
+        return false if prev && prev[:type] == TT::ASSIGN
+
+        true
+      end
+
+      def collect_uses(stmt, names)
+        stmt.each_with_index do |t, i|
+          next unless t[:type] == TT::IDENTIFIER
+          next unless variable_use?(stmt, i)
+
+          names << t[:text].downcase
+        end
+      end
+
+      # Same exclusions as `inconsistent_variable_case`: byte-adjacent
+      # `<name>.` (format reference) and `<lib>.<member>` second halves
+      # don't name a variable in the current step.
+      def variable_use?(stmt, i)
+        t = stmt[i]
+        nxt = stmt[i + 1]
+        prev = i.positive? ? stmt[i - 1] : nil
+
+        return false if nxt && nxt[:type] == TT::DOT && nxt[:start] == t[:end]
+        return false if prev && prev[:type] == TT::DOT && prev[:end] == t[:start]
+
+        true
+      end
+    end
+  end
+end

data/lib/sas_linter/rules/unterminated_comment.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative "../../sas_linter"
+require "sas_lexer"
+
+class SasLinter
+  module Rules
+    # Flag a `** ... **` comment line whose missing `;` causes the
+    # SAS lexer to extend the comment statement into the following
+    # line(s) of real code, silently swallowing it.
+    #
+    # SAS `*` / `**` comment statements are terminated by the next
+    # `;` — the closing `**` is just prose. So
+    #
+    #     ** SOME COMMENT **
+    #     y = x + 1;
+    #
+    # lexes as a single comment token covering both lines, and the
+    # `y = x + 1;` assignment never executes.
+    #
+    # Detection: a COMMENT-channel `PREDICTED_COMMENT_STAT` token
+    # whose `start_line != end_line` AND whose first source line,
+    # rstripped, ends with `**`. That shape is the boxed-comment
+    # closer the user clearly intended — they only forgot the `;`.
+    # Legitimate multi-line `*...;` prose ends its first line with
+    # plain text, not `**`, so it's left alone.
+    #
+    # Autofix: append `;` to the end of each flagged first line.
+    class UnterminatedComment < Rule
+      rule_id :unterminated_comment
+      description "`**` comment missing its terminating `;` — consumes following code."
+      severity :warning
+
+      TT = SasLexer::Lexer::TokenType
+      COMMENT_CHANNEL = SasLexer::Lexer::TokenChannel::COMMENT
+
+      def self.supports_autofix?
+        true
+      end
+
+      def check(_tokens, path:, all_tokens: nil, source: nil)
+        return [] unless all_tokens && source
+
+        lines = source.split("\n", -1)
+        unterminated_comment_lines(all_tokens, lines).map do |i|
+          finding_for_line(lines[i], i, path)
+        end
+      end
+
+      def autofix(source)
+        return source if source.nil? || source.empty?
+
+        lines = source.split("\n", -1)
+        bad = unterminated_comment_lines(tokenize(source), lines)
+        return source if bad.empty?
+
+        bad.each do |i|
+          lines[i] = "#{lines[i].rstrip};"
+        end
+        lines.join("\n")
+      end
+
+      private
+
+      def finding_for_line(line, idx, path)
+        finding(
+          line: idx + 1,
+          column: line.length - line.lstrip.length + 1,
+          message: "`**` comment missing `;` — consumes the next line of code as comment text.",
+          path: path
+        )
+      end
+
+      def tokenize(source)
+        lexer = SasLexer::Lexer.new
+        begin
+          lexer.tokenize(source)
+        ensure
+          lexer.free
+        end
+      end
+
+      # 0-indexed source lines that hold a `** ... **` comment whose
+      # missing `;` made the lexer extend it into the next line.
+      def unterminated_comment_lines(all_tokens, lines)
+        bad = []
+        all_tokens.each do |t|
+          next unless t[:channel] == COMMENT_CHANNEL
+          next unless t[:type] == TT::PREDICTED_COMMENT_STAT
+          next unless t[:start_line] < t[:end_line]
+
+          first = lines[t[:start_line] - 1] or next
+          next unless first.rstrip.end_with?("**")
+
+          bad << (t[:start_line] - 1)
+        end
+        bad
+      end
+    end
+  end
+end

data/lib/sas_linter/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class SasLinter
-  VERSION = "0.2.3"
+  VERSION = "0.2.5"
 end

data/lib/sas_linter.rb

@@ -310,3 +310,5 @@ require_relative "sas_linter/rules/missing_assignment_semicolon"
 require_relative "sas_linter/rules/variable_value_out_of_known_range"
 require_relative "sas_linter/rules/invalid_numeric_literal"
 require_relative "sas_linter/rules/inconsistent_variable_case"
+require_relative "sas_linter/rules/format_for_unknown_variable"
+require_relative "sas_linter/rules/unterminated_comment"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sas-linter
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.5
 platform: ruby
 authors:
 - Craig McNamara
@@ -63,6 +63,7 @@ files:
 - lib/sas_linter/rules/choose_one_template.rb
 - lib/sas_linter/rules/commented_out_guard.rb
 - lib/sas_linter/rules/encoding_issues.rb
+- lib/sas_linter/rules/format_for_unknown_variable.rb
 - lib/sas_linter/rules/identical_if_else_branches.rb
 - lib/sas_linter/rules/inconsistent_variable_case.rb
 - lib/sas_linter/rules/invalid_numeric_literal.rb
@@ -73,6 +74,7 @@ files:
 - lib/sas_linter/rules/tab_expansion.rb
 - lib/sas_linter/rules/trailing_whitespace.rb
 - lib/sas_linter/rules/unreachable_inner_branch_value.rb
+- lib/sas_linter/rules/unterminated_comment.rb
 - lib/sas_linter/rules/variable_value_out_of_known_range.rb
 - lib/sas_linter/version.rb
 homepage: https://github.com/mes-amis/sas-linter