sas-linter 0.2.2 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4552996a6f33196d26f85d2cd057c525f8aff278b2e4d26791d0295bc5b49ccc
-  data.tar.gz: 72b2f4a69e108b29818cb686b8ffb135768547a0d68a09086a5d4946524af17d
+  metadata.gz: b10cf15e62fe7e0a81d8f9d2e2c9eb61af36ee00d10f32e9ce8354a7ebe3e40f
+  data.tar.gz: 9abe8249ab9d968fdc8aefe558dcdad321ba2879abe4bf08374b9ec998eecb5f
 SHA512:
-  metadata.gz: 1efcbb6cf7707971d58ae82089df387a309e5f5941d9a90b72075c1cfa8af660bc21d9089f5d42b72b428b8669535334eb6b1f1bd22967738a58a1057f0d7614
-  data.tar.gz: 6c37528f85bd94d51020b08fb1685a20a1dd1e0eded7a2949c27c57b21b1b4b5204036220826b39e198e6b6c92160634ccbd7bc3b79b657b834a9a1e666233bd
+  metadata.gz: 38e745b6f3ec4c8a7cc2ce3c23883569bcd931d88d6f9dc0a6c2288ed7f0b39f199e066340e780e8556d0ceeaa7bfeb149185ef2d458f58574281c54dbbf60d3
+  data.tar.gz: 8e6b5f2751eb5b3b9e50b80f0476f953519763a321fba4dd17ce219d891a84a3f0fe3c1ea1fbc3c18f4a698bc0655ef794ff2ef71d1d859aa23195a9119d41bd

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 fourteen pluggable rules covering structural defects, cosmetic issues, and source-header conventions.
 
 ## Installation
 
@@ -67,6 +67,9 @@ rules:
     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
@@ -140,6 +143,7 @@ findings = linter.lint_file("path/to/source.sas")
 | `missing_assignment_semicolon` | Assignment statements followed by an inline `**` comment but no terminating `;`. |
 | `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/inconsistent_variable_case.rb

@@ -61,9 +61,19 @@ class SasLinter
       def autofix(source)
         return source if source.nil? || source.empty?
 
+        # If a previous rule's autofix returned ASCII-8BIT (e.g.
+        # EncodingIssues#autofix walks bytes and returns binary), tag
+        # it UTF-8 before slicing. The lexer treats the bytes as UTF-8
+        # and reports character offsets either way; only Ruby's
+        # `String#[]=` cares about the encoding label, and it indexes
+        # by bytes for ASCII-8BIT but by characters for UTF-8 — so a
+        # binary tag plus any multi-byte sequence earlier in the file
+        # would shift every replacement by the byte/char gap.
+        src = source.encoding == Encoding::UTF_8 ? source : source.dup.force_encoding("UTF-8")
+
         lexer = SasLexer::Lexer.new
         begin
-          all_tokens = lexer.tokenize(source)
+          all_tokens = lexer.tokenize(src)
         ensure
           lexer.free
         end
@@ -78,7 +88,7 @@ class SasLinter
         end
 
         # Apply right-to-left so earlier offsets stay valid.
-        out = source.dup
+        out = src.dup
         edits.sort_by! { |start, _, _| -start }
         edits.each { |start, finish, repl| out[start...finish] = repl }
         out

data/lib/sas_linter/version.rb

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

data/lib/sas_linter.rb

@@ -310,3 +310,4 @@ 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"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sas-linter
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.4
 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