tina4ruby 3.13.90 → 3.13.91

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bcacb51cc9aec287d69bb3d18d0d5736d4e72fd9f25e4b28145af7a8c3e69245
-  data.tar.gz: 5cbe29c5b764594b014c386ab1df06e93d67cc8ad79ee321a2d5c03c5383cc73
+  metadata.gz: 3df8f30ccbf4fc6d984ec4af8fa3262045b16ac1f05c7516f6a6818691fad547
+  data.tar.gz: 1236689bdee9821f1994bc27d1a69684fd312cc774f33a2bba6b10fa57bd86d8
 SHA512:
-  metadata.gz: b01320730d284fb8f8babdefdcd6c26fc3a4ae29e5ee3a2f700320276a1d211d5d3e88fc0c8de4e1722af814a60333a4056041428fd387ec70446b50f066a208
-  data.tar.gz: 32077d83e0b6c457656915818683193f8a4ef9b3dfd505e3035d97f7b835b979d29a536f6993aa85d987138e9fe1aa229d1d002fec769879fb0c4ca1dbaef2fa
+  metadata.gz: c51b11ed1b2c9361c162ab6d54f999381d13b8b6be74f4cd94ebfa0d72492f0805f9428e9080ee06b2eb6efd52dc5fd72e1a9d073743d5ad03ec9582c3894b8b
+  data.tar.gz: 4f8265ec9da1f6bd427ed844d808e4e2c67ee55ec934a0d24ea37f40b1a88861ce86bc9c09b162cd534f6d879825ed31a05e0baf32e73322ea8584097d9b8346

data/lib/tina4/metrics.rb

@@ -254,7 +254,7 @@ module Tina4
         end
 
         lines = source.lines.map(&:chomp)
-        loc = lines.count { |l| !l.strip.empty? && !l.strip.start_with?('#') }
+        loc = lines.count { |l| _code_line?(l) }
 
         # Extract imports (require/require_relative)
         imports = _extract_imports(lines)
@@ -509,7 +509,7 @@ module Tina4
       end
 
       lines = source.lines.map(&:chomp)
-      loc = lines.count { |l| !l.strip.empty? && !l.strip.start_with?('#') }
+      loc = lines.count { |l| _code_line?(l) }
 
       functions = _extract_functions(source, tokens, lines)
       functions.sort_by! { |f| -f["complexity"] }
@@ -763,6 +763,17 @@ module Tina4
       buffers
     end
 
+    # True for a line that counts toward LOC: not blank, not a comment.
+    #
+    # The single definition of the rule. Method LOC used to ignore it and return a
+    # raw line span while file LOC excluded blanks and comments, so `loc` meant
+    # two different things in one payload - the dashboard sized bubbles in one
+    # unit and printed the method table in the other.
+    def self._code_line?(line)
+      stripped = line.strip
+      !stripped.empty? && !stripped.start_with?("#")
+    end
+
     def self._extract_functions(source, _tokens, _lines)
       functions = []
       # Operate on a neutralised copy: string/regex/comment CONTENT is blanked
@@ -811,7 +822,9 @@ module Tina4
             # Find method end and calculate LOC
             method_start = i
             method_end = _find_method_end(lines, i)
-            method_loc = method_end - method_start + 1
+            # Code lines over the method's span, by the same rule as file LOC.
+            # Floor of 1: a one-line body must never report 0.
+            method_loc = [1, lines[method_start..method_end].count { |l| _code_line?(l) }].max
 
             # Calculate complexity for this method's body
             method_lines = lines[method_start..method_end]
@@ -842,6 +855,51 @@ module Tina4
         i += 1
       end
 
+      _charge_nested_complexity_to_the_nested_function(functions)
+    end
+
+    # Stop a function being charged for the complexity of the functions nested
+    # inside it.
+    #
+    # Each function's raw score is measured over its whole span, so a branch
+    # inside a nested function landed on BOTH that function and every function
+    # enclosing it. The over-count compounded with depth: a wrapper around twenty
+    # inner handlers absorbed the entire file's complexity and topped the
+    # offenders list, hiding the genuine hot spots.
+    #
+    # The correction is exact. A raw score is 1 + every decision in the span, so
+    # (raw - 1) is the total decision count of a function's whole subtree.
+    # Subtracting that for each DIRECT child leaves the function's own branches:
+    #
+    #   own(F) = raw(F) - sum over direct children C of (raw(C) - 1)
+    #
+    # Blocks and lambdas are deliberately unaffected: they are not reported as
+    # functions of their own, so nothing subtracts them and their decisions stay
+    # with the method that contains them - moved, never lost.
+    def self._charge_nested_complexity_to_the_nested_function(functions)
+      return functions if functions.length < 2
+
+      last_line = ->(f) { f["line"] + [1, f["loc"]].max - 1 }
+      contains = ->(outer, inner) do
+        inner["line"] > outer["line"] && last_line.call(inner) <= last_line.call(outer)
+      end
+
+      raw = functions.map { |f| f["complexity"] }
+      functions.each_with_index do |outer, i|
+        subtract = 0
+        functions.each_with_index do |inner, j|
+          next if i == j || !contains.call(outer, inner)
+
+          # Direct child only: skip it if another function sits between the two,
+          # or its complexity would be subtracted twice.
+          nested_deeper = functions.each_with_index.any? do |mid, k|
+            k != i && k != j && contains.call(outer, mid) && contains.call(mid, inner)
+          end
+          subtract += raw[j] - 1 unless nested_deeper
+        end
+        outer["complexity"] = [1, raw[i] - subtract].max
+      end
+
       functions
     end