sas-linter 0.2.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8179cf3c7d87f82c58c772a5916be519d2a6028c882bbec74de8716ba04acf9b
-  data.tar.gz: 1c6256a8f4e3dea07dcce74aad34f4431d24ee80ad94e41afdaeb71b279a1d08
+  metadata.gz: 4552996a6f33196d26f85d2cd057c525f8aff278b2e4d26791d0295bc5b49ccc
+  data.tar.gz: 72b2f4a69e108b29818cb686b8ffb135768547a0d68a09086a5d4946524af17d
 SHA512:
-  metadata.gz: 43a9b197ef714f8942fc7b1dda78ec62ad5c1d844ff194da6a1dabdf67195eb347a7437542bbdd0c1df70fc3f7c0a6ef9e33e6d05fe1af6b04f4eaa8875cfcab
-  data.tar.gz: 728e57cee72bd5335d715418cec293ea3d890b65bef6944d6fbd85992f972c549662fd398e93b856e3d98c36908aacbcd2654d7a9e1638d0d2be9a332a3170a9
+  metadata.gz: 1efcbb6cf7707971d58ae82089df387a309e5f5941d9a90b72075c1cfa8af660bc21d9089f5d42b72b428b8669535334eb6b1f1bd22967738a58a1057f0d7614
+  data.tar.gz: 6c37528f85bd94d51020b08fb1685a20a1dd1e0eded7a2949c27c57b21b1b4b5204036220826b39e198e6b6c92160634ccbd7bc3b79b657b834a9a1e666233bd

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 eleven 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 thirteen pluggable rules covering structural defects, cosmetic issues, and source-header conventions.
 
 ## Installation
 
@@ -63,6 +63,10 @@ rules:
     enabled: true
     autofix: false             # rule supports autofix; off by default
 
+  inconsistent_variable_case:
+    enabled: true
+    autofix: false             # rewrite every minority casing to the most-common form
+
   variable_value_out_of_known_range:
     enabled: true
     csv_paths:                          # empty list = rule is a no-op
@@ -135,6 +139,7 @@ findings = linter.lint_file("path/to/source.sas")
 | `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 `;`. |
 | `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. |
 
 `bin/sas_lint --list-rules` prints the same set with autofix capability.
 

data/lib/sas_linter/rules/encoding_issues.rb

@@ -286,8 +286,13 @@ class SasLinter
         findings
       end
 
+      # `seq` is ASCII-8BIT (from `pack("C*")`); `encode("UTF-8")` on a
+      # binary string replaces every byte ≥ 0x80 with U+FFFD before
+      # `codepoints` runs. The bytes are already a valid UTF-8 sequence
+      # by construction (caller checked `utf8_sequence_length`), so
+      # reinterpret rather than transcode.
       def codepoint(seq)
-        seq.encode("UTF-8", invalid: :replace, undef: :replace).codepoints.first
+        seq.dup.force_encoding("UTF-8").codepoints.first
       end
 
       # Returns the length (1-4) of a valid UTF-8 sequence starting

data/lib/sas_linter/rules/inconsistent_variable_case.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require_relative "../../sas_linter"
+require "sas_lexer"
+
+class SasLinter
+  module Rules
+    # Flag identifiers that are spelled with inconsistent letter case
+    # across the file. SAS resolves variable references case-insensitively,
+    # so `myVar` and `MyVar` end up bound to the same column — but mixing
+    # the two within one program is sloppy and makes the source harder to
+    # grep, diff, and read.
+    #
+    # The most-used spelling wins; every other casing is reported (and
+    # rewritten when autofix is on). Ties resolve to the first occurrence
+    # so the canonical form is reading-order deterministic.
+    #
+    # Skipped on purpose:
+    #   * identifiers immediately followed by `.` (format references like
+    #     `agecat.`, library references like `work.foo`);
+    #   * identifiers immediately preceded by `.` (the column half of
+    #     `lib.member` / `dataset.col`) — those name a column in another
+    #     dataset, not a variable in the current step;
+    #   * `value` / `invalue` / `picture` themselves and the format name
+    #     directly following them — these are proc-format definitions,
+    #     not variable references. We match locally rather than tracking
+    #     a `proc format ... run;` block because real-world SAS files
+    #     meant to be `%include`d into a caller's data step often omit
+    #     the terminating `run;`, so a state machine would never close.
+    class InconsistentVariableCase < Rule
+      rule_id :inconsistent_variable_case
+      description "Variable identifiers must use one consistent letter case " \
+                  "across the file; mixing `myVar` and `MyVar` is sloppy."
+      severity :warning
+
+      TT = SasLexer::Lexer::TokenType
+
+      # Identifiers that introduce a format / informat / picture
+      # definition in a `proc format` step. The lexer types these as
+      # plain IDENTIFIERs (not keywords), so we recognize them by text.
+      FORMAT_DEF_KEYWORDS = %w[value invalue picture].freeze
+
+      def self.supports_autofix?
+        true
+      end
+
+      def check(tokens, path:, all_tokens: nil, source: nil) # rubocop:disable Lint/UnusedMethodArgument
+        findings = []
+        each_inconsistent_use(tokens) do |token, canonical|
+          findings << finding(
+            line: token[:start_line],
+            column: token[:start_column] + 1,
+            message: "variable `#{token[:text]}` is spelled `#{canonical}` " \
+                     "elsewhere in this file — pick one case and stick with it.",
+            path: path
+          )
+        end
+        findings
+      end
+
+      def autofix(source)
+        return source if source.nil? || source.empty?
+
+        lexer = SasLexer::Lexer.new
+        begin
+          all_tokens = lexer.tokenize(source)
+        ensure
+          lexer.free
+        end
+        tokens = all_tokens.reject do |t|
+          t[:channel] == SasLexer::Lexer::TokenChannel::HIDDEN ||
+            t[:channel] == SasLexer::Lexer::TokenChannel::COMMENT
+        end
+
+        edits = []
+        each_inconsistent_use(tokens) do |token, canonical|
+          edits << [token[:start], token[:end], canonical]
+        end
+
+        # Apply right-to-left so earlier offsets stay valid.
+        out = source.dup
+        edits.sort_by! { |start, _, _| -start }
+        edits.each { |start, finish, repl| out[start...finish] = repl }
+        out
+      end
+
+      private
+
+      # Yields `[token, canonical_form]` for every identifier whose
+      # spelling differs from the file-wide canonical case.
+      def each_inconsistent_use(tokens)
+        groups = collect_variable_uses(tokens)
+
+        groups.each_value do |uses|
+          forms = uses.map { |t| t[:text] }.tally
+          next if forms.size <= 1
+
+          canonical = canonical_form(forms, uses)
+          uses.each do |t|
+            yield t, canonical unless t[:text] == canonical
+          end
+        end
+      end
+
+      # Walk default-channel tokens and bucket eligible IDENTIFIER
+      # uses by lowercase name. Format-related identifiers (see class
+      # docstring) are filtered out by `variable_use?`.
+      def collect_variable_uses(tokens)
+        groups = Hash.new { |h, k| h[k] = [] }
+        tokens.each_with_index do |t, i|
+          next unless t[:type] == TT::IDENTIFIER && variable_use?(tokens, i)
+
+          groups[t[:text].downcase] << t
+        end
+        groups
+      end
+
+      # Reject `format.` / `lib.member` shapes via byte-adjacency to a
+      # `.` token, and `value <fmt-name>` shapes by checking the
+      # neighboring identifier. The lexer emits the dot separately, so
+      # we use `prev.end == t.start` / `t.end == nxt.start` to tell a
+      # truly-adjacent dot from one that just happens to follow after
+      # whitespace.
+      def variable_use?(tokens, i)
+        t = tokens[i]
+        nxt = tokens[i + 1]
+        prev = i.positive? ? tokens[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]
+        return false if FORMAT_DEF_KEYWORDS.include?(t[:text].downcase)
+        return false if prev && prev[:type] == TT::IDENTIFIER &&
+                        FORMAT_DEF_KEYWORDS.include?(prev[:text].downcase)
+
+        true
+      end
+
+      # Most-used spelling wins; ties go to the first occurrence so the
+      # canonical form matches reading order and stays deterministic
+      # across runs.
+      def canonical_form(forms, uses)
+        max_count = forms.values.max
+        winners = forms.select { |_, c| c == max_count }.keys
+        return winners.first if winners.size == 1
+
+        uses.each { |t| return t[:text] if winners.include?(t[:text]) }
+        winners.first
+      end
+    end
+  end
+end

data/lib/sas_linter/version.rb

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

data/lib/sas_linter.rb

@@ -309,3 +309,4 @@ require_relative "sas_linter/rules/malformed_if_condition"
 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"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sas-linter
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.2
 platform: ruby
 authors:
 - Craig McNamara
@@ -64,6 +64,7 @@ files:
 - lib/sas_linter/rules/commented_out_guard.rb
 - lib/sas_linter/rules/encoding_issues.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
 - lib/sas_linter/rules/line_endings.rb
 - lib/sas_linter/rules/malformed_if_condition.rb