spoom 1.8.9 → 1.8.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97cf397397aa58c2322089f795e390e7b7946445966fc341dd6a8566ae9b8ded
-  data.tar.gz: e42da92b60a476c7ed03116b9ce1c780fc59ec133b02ed73a6f501a0bb162359
+  metadata.gz: 4112003bfcd62cb8c66104ac6c773669d20d4a5ab0b070e93a9d7633cdff7126
+  data.tar.gz: 8cee75de87ce5526c8a3e6c1cf7b7d2ae7a0b98b48a1f1ea1250959984d88ca3
 SHA512:
-  metadata.gz: eefa8467cecb02ee37700b60ba0d6570e90650a3a148992aeecf42e605ea51a787dfa4e0b08c31ae4c48f26b715bd13a21aba40197f10f63dfeef935378399e9
-  data.tar.gz: ae699ed2ce340106b923744a6b3583fe32c6ecd67c8b8dca16d750d32f2c13e95c0d11a11410d8587852d1a77caedd974f88ba18cd3a21166486114bacc3135e
+  metadata.gz: e23ea3cf62bc326705b91a7618efc658f7b1bcc1df17532b9f0218766cf61ab807f956751c11389db6317c1885ada0d403d51c8b92d9d0131c0ce5b0c04442c7
+  data.tar.gz: 19bfdcbb7adbb766647ae1619450154587ccb673ad9d84b7a1f070dd3f1f9c9bef3d38f233df3b4f914e7a786832bbfe1b4fd51f972a2a4873c626a0250abbb9

data/lib/spoom/sorbet/metrics/code_metrics_visitor.rb

@@ -76,6 +76,10 @@ module Spoom
           case node.superclass&.slice
           when /^(::)?T::Struct$/
             @counters.increment("t_structs")
+          when /^(::)?T::InexactStruct$/
+            @counters.increment("t_inexact_structs")
+          when /^(::)?T::ImmutableStruct$/
+            @counters.increment("t_immutable_structs")
           when /^(::)?T::Enum$/
             @counters.increment("t_enums")
           end

data/lib/spoom/sorbet/sigils.rb

@@ -51,6 +51,21 @@ module Spoom
           !!strictness && valid_strictness?(strictness)
         end
 
+        # returns true if the passed content contains a valid sigil at or above the passed strictness
+        # internal sigils do not satisfy a minimum strictness
+        #: (String content, String strictness) -> bool
+        def satisfies_minimum_strictness?(content, strictness)
+          return false unless contains_valid_sigil?(content)
+
+          current_strictness = strictness_in_content(content)
+          strictness = strictness.strip
+          return false if current_strictness == STRICTNESS_INTERNAL || strictness == STRICTNESS_INTERNAL
+
+          strictness_index = VALID_STRICTNESS.index(current_strictness)
+          minimum_index = VALID_STRICTNESS.index(strictness)
+          !!strictness_index && !!minimum_index && strictness_index >= minimum_index
+        end
+
         # returns a string which is the passed content but with the sigil updated to a new strictness
         #: (String content, String new_strictness) -> String
         def update_sigil(content, new_strictness)

data/lib/spoom/sorbet/translate/rbs_comments_to_sorbet_sigs.rb

@@ -6,7 +6,9 @@ module Spoom
     module Translate
       module RBSCommentsToSorbetSigs
         class << self
-          RBS_ANNOTATION_MARKERS = [
+          RBS_REWRITE_PATTERN = Regexp.union([
+            "#:",
+            "#|",
             "# @abstract",
             "# @interface",
             "# @sealed",
@@ -15,9 +17,16 @@ module Spoom
             "# @override",
             "# @overridable",
             "# @without_runtime",
-          ].freeze #: Array[String]
-          RBS_REWRITE_PATTERN = Regexp.union(["#:", "#|", *RBS_ANNOTATION_MARKERS]).freeze #: Regexp
-          private_constant :RBS_ANNOTATION_MARKERS, :RBS_REWRITE_PATTERN
+          ]).freeze #: Regexp
+          private_constant :RBS_REWRITE_PATTERN
+
+          # Detects RBS comment markers (`#:`, `#|`, and supported `# @...` annotations).
+          # Use this check to skip parsing files without those markers.
+          # It does not validate RBS syntax or check the `typed:` sigil.
+          #: (String ruby_contents) -> bool
+          def contains_rbs_syntax?(ruby_contents)
+            ruby_contents.match?(RBS_REWRITE_PATTERN)
+          end
 
           #: (
           #|   String ruby_contents,
@@ -34,7 +43,7 @@ module Spoom
             erase_generic_types: false,
             force: false
           )
-            return ruby_contents unless ruby_contents.match?(RBS_REWRITE_PATTERN) &&
+            return ruby_contents unless contains_rbs_syntax?(ruby_contents) &&
               (force || Sigils.contains_valid_sigil?(ruby_contents))
 
             options = Options.new(

data/lib/spoom/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Spoom
-  VERSION = "1.8.9"
+  VERSION = "1.8.11"
 end

data/rbi/spoom.rbi

@@ -672,27 +672,32 @@ class Spoom::Coverage::D3::ColorPalette
   sig { returns(::String) }
   def false_color; end
 
-  def false_color=(_arg0); end
+  sig { params(false_color: ::String).returns(::String) }
+  def false_color=(false_color); end
 
   sig { returns(::String) }
   def ignore_color; end
 
-  def ignore_color=(_arg0); end
+  sig { params(ignore_color: ::String).returns(::String) }
+  def ignore_color=(ignore_color); end
 
   sig { returns(::String) }
   def strict_color; end
 
-  def strict_color=(_arg0); end
+  sig { params(strict_color: ::String).returns(::String) }
+  def strict_color=(strict_color); end
 
   sig { returns(::String) }
   def strong_color; end
 
-  def strong_color=(_arg0); end
+  sig { params(strong_color: ::String).returns(::String) }
+  def strong_color=(strong_color); end
 
   sig { returns(::String) }
   def true_color; end
 
-  def true_color=(_arg0); end
+  sig { params(true_color: ::String).returns(::String) }
+  def true_color=(true_color); end
 end
 
 class Spoom::Coverage::D3::Pie < ::Spoom::Coverage::D3::Base
@@ -939,62 +944,74 @@ class Spoom::Coverage::Snapshot
   sig { returns(::Integer) }
   def calls_typed; end
 
-  def calls_typed=(_arg0); end
+  sig { params(calls_typed: ::Integer).returns(::Integer) }
+  def calls_typed=(calls_typed); end
 
   sig { returns(::Integer) }
   def calls_untyped; end
 
-  def calls_untyped=(_arg0); end
+  sig { params(calls_untyped: ::Integer).returns(::Integer) }
+  def calls_untyped=(calls_untyped); end
 
   sig { returns(::Integer) }
   def classes; end
 
-  def classes=(_arg0); end
+  sig { params(classes: ::Integer).returns(::Integer) }
+  def classes=(classes); end
 
   sig { returns(T.nilable(::String)) }
   def commit_sha; end
 
-  def commit_sha=(_arg0); end
+  sig { params(commit_sha: T.nilable(::String)).returns(T.nilable(::String)) }
+  def commit_sha=(commit_sha); end
 
   sig { returns(T.nilable(::Integer)) }
   def commit_timestamp; end
 
-  def commit_timestamp=(_arg0); end
+  sig { params(commit_timestamp: T.nilable(::Integer)).returns(T.nilable(::Integer)) }
+  def commit_timestamp=(commit_timestamp); end
 
   sig { returns(::Integer) }
   def duration; end
 
-  def duration=(_arg0); end
+  sig { params(duration: ::Integer).returns(::Integer) }
+  def duration=(duration); end
 
   sig { returns(::Integer) }
   def files; end
 
-  def files=(_arg0); end
+  sig { params(files: ::Integer).returns(::Integer) }
+  def files=(files); end
 
   sig { returns(::Integer) }
   def methods_with_sig; end
 
-  def methods_with_sig=(_arg0); end
+  sig { params(methods_with_sig: ::Integer).returns(::Integer) }
+  def methods_with_sig=(methods_with_sig); end
 
   sig { returns(::Integer) }
   def methods_with_sig_excluding_rbis; end
 
-  def methods_with_sig_excluding_rbis=(_arg0); end
+  sig { params(methods_with_sig_excluding_rbis: ::Integer).returns(::Integer) }
+  def methods_with_sig_excluding_rbis=(methods_with_sig_excluding_rbis); end
 
   sig { returns(::Integer) }
   def methods_without_sig; end
 
-  def methods_without_sig=(_arg0); end
+  sig { params(methods_without_sig: ::Integer).returns(::Integer) }
+  def methods_without_sig=(methods_without_sig); end
 
   sig { returns(::Integer) }
   def methods_without_sig_excluding_rbis; end
 
-  def methods_without_sig_excluding_rbis=(_arg0); end
+  sig { params(methods_without_sig_excluding_rbis: ::Integer).returns(::Integer) }
+  def methods_without_sig_excluding_rbis=(methods_without_sig_excluding_rbis); end
 
   sig { returns(::Integer) }
   def modules; end
 
-  def modules=(_arg0); end
+  sig { params(modules: ::Integer).returns(::Integer) }
+  def modules=(modules); end
 
   sig { params(out: T.any(::IO, ::StringIO), colors: T::Boolean, indent_level: ::Integer).void }
   def print(out: T.unsafe(nil), colors: T.unsafe(nil), indent_level: T.unsafe(nil)); end
@@ -1002,27 +1019,32 @@ class Spoom::Coverage::Snapshot
   sig { returns(::Integer) }
   def rbi_files; end
 
-  def rbi_files=(_arg0); end
+  sig { params(rbi_files: ::Integer).returns(::Integer) }
+  def rbi_files=(rbi_files); end
 
   sig { returns(T::Hash[::String, ::Integer]) }
   def sigils; end
 
-  def sigils=(_arg0); end
+  sig { params(sigils: T::Hash[::String, ::Integer]).returns(T::Hash[::String, ::Integer]) }
+  def sigils=(sigils); end
 
   sig { returns(T::Hash[::String, ::Integer]) }
   def sigils_excluding_rbis; end
 
-  def sigils_excluding_rbis=(_arg0); end
+  sig { params(sigils_excluding_rbis: T::Hash[::String, ::Integer]).returns(T::Hash[::String, ::Integer]) }
+  def sigils_excluding_rbis=(sigils_excluding_rbis); end
 
   sig { returns(::Integer) }
   def singleton_classes; end
 
-  def singleton_classes=(_arg0); end
+  sig { params(singleton_classes: ::Integer).returns(::Integer) }
+  def singleton_classes=(singleton_classes); end
 
   sig { returns(::Integer) }
   def timestamp; end
 
-  def timestamp=(_arg0); end
+  sig { params(timestamp: ::Integer).returns(::Integer) }
+  def timestamp=(timestamp); end
 
   sig { returns(T::Hash[::String, T.untyped]) }
   def to_h; end
@@ -1033,12 +1055,14 @@ class Spoom::Coverage::Snapshot
   sig { returns(T.nilable(::String)) }
   def version_runtime; end
 
-  def version_runtime=(_arg0); end
+  sig { params(version_runtime: T.nilable(::String)).returns(T.nilable(::String)) }
+  def version_runtime=(version_runtime); end
 
   sig { returns(T.nilable(::String)) }
   def version_static; end
 
-  def version_static=(_arg0); end
+  sig { params(version_static: T.nilable(::String)).returns(T.nilable(::String)) }
+  def version_static=(version_static); end
 
   class << self
     sig { params(json: ::String).returns(::Spoom::Coverage::Snapshot) }
@@ -1577,7 +1601,8 @@ class Spoom::Deadcode::Remover::NodeContext
   sig { returns(T::Array[::Prism::Node]) }
   def nesting; end
 
-  def nesting=(_arg0); end
+  sig { params(nesting: T::Array[::Prism::Node]).returns(T::Array[::Prism::Node]) }
+  def nesting=(nesting); end
 
   sig { returns(T.nilable(::Prism::Node)) }
   def next_node; end
@@ -2322,7 +2347,8 @@ class Spoom::LSP::SymbolPrinter < ::Spoom::Printer
   sig { returns(T.nilable(::String)) }
   def prefix; end
 
-  def prefix=(_arg0); end
+  sig { params(prefix: T.nilable(::String)).returns(T.nilable(::String)) }
+  def prefix=(prefix); end
 
   sig { params(objects: T::Array[::Spoom::LSP::PrintableSymbol]).void }
   def print_list(objects); end
@@ -2482,7 +2508,8 @@ class Spoom::Model::Class < ::Spoom::Model::Namespace
   sig { returns(T.nilable(::String)) }
   def superclass_name; end
 
-  def superclass_name=(_arg0); end
+  sig { params(superclass_name: T.nilable(::String)).returns(T.nilable(::String)) }
+  def superclass_name=(superclass_name); end
 end
 
 class Spoom::Model::Comment
@@ -2879,7 +2906,8 @@ class Spoom::Printer
   sig { returns(T.any(::IO, ::StringIO)) }
   def out; end
 
-  def out=(_arg0); end
+  sig { params(out: T.any(::IO, ::StringIO)).returns(T.any(::IO, ::StringIO)) }
+  def out=(out); end
 
   sig { params(string: T.nilable(::String)).void }
   def print(string); end
@@ -2974,7 +3002,8 @@ class Spoom::Sorbet::Config
   sig { returns(T::Boolean) }
   def no_stdlib; end
 
-  def no_stdlib=(_arg0); end
+  sig { params(no_stdlib: T::Boolean).returns(T::Boolean) }
+  def no_stdlib=(no_stdlib); end
 
   sig { returns(::String) }
   def options_string; end
@@ -2982,7 +3011,9 @@ class Spoom::Sorbet::Config
   sig { returns(T::Array[::String]) }
   def paths; end
 
-  def paths=(_arg0); end
+  sig { params(paths: T::Array[::String]).returns(T::Array[::String]) }
+  def paths=(paths); end
+
   def typed_overrides; end
   def typed_overrides=(_arg0); end
 
@@ -3216,6 +3247,9 @@ module Spoom::Sorbet::Sigils
     sig { params(path: T.any(::Pathname, ::String)).returns(T.nilable(::String)) }
     def file_strictness(path); end
 
+    sig { params(content: ::String, strictness: ::String).returns(T::Boolean) }
+    def satisfies_minimum_strictness?(content, strictness); end
+
     sig { params(strictness: ::String).returns(::String) }
     def sigil_string(strictness); end
 
@@ -3322,6 +3356,9 @@ end
 
 module Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs
   class << self
+    sig { params(ruby_contents: ::String).returns(T::Boolean) }
+    def contains_rbs_syntax?(ruby_contents); end
+
     sig do
       params(
         ruby_contents: ::String,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spoom
 version: !ruby/object:Gem::Version
-  version: 1.8.9
+  version: 1.8.11
 platform: ruby
 authors:
 - Alexandre Terrasa