type_toolkit 0.0.5 → 0.0.7

data/spec/rubocop/cop/type_toolkit/prefer_not_nil_spec.rb

@@ -0,0 +1,464 @@
+# typed: true
+# frozen_string_literal: true
+
+require "spec_helper"
+require "rubocop"
+require "rubocop/minitest/assert_offense"
+require "rubocop-type_toolkit"
+
+module RuboCop
+  module Cop
+    module TypeToolkit
+      class PreferNotNilSpec < ::Minitest::Spec
+        include RuboCop::Minitest::AssertOffense
+
+        MSG = "TypeToolkit/PreferNotNil: #{format(PreferNotNil::MSG, method: :must)}"
+        BECAUSE_MSG = "TypeToolkit/PreferNotNil: #{format(PreferNotNil::MSG, method: :must_because)}"
+
+        before do
+          @cop = PreferNotNil.new
+        end
+
+        it "autocorrects T.must" do
+          assert_offense(<<~RUBY)
+            value = T.must(foo)
+                    ^^^^^^^^^^^ #{MSG}
+          RUBY
+
+          assert_correction(<<~RUBY)
+            value = foo.not_nil!
+          RUBY
+        end
+
+        it "autocorrects ::T.must" do
+          assert_offense(<<~RUBY)
+            value = ::T.must(foo)
+                    ^^^^^^^^^^^^^ #{MSG}
+          RUBY
+
+          assert_correction(<<~RUBY)
+            value = foo.not_nil!
+          RUBY
+        end
+
+        it "autocorrects inside string interpolation" do
+          assert_offense(<<~RUBY)
+            string = "\#{T.must(foo)}"
+                        ^^^^^^^^^^^ #{MSG}
+          RUBY
+
+          assert_correction(<<~RUBY)
+            string = "\#{foo.not_nil!}"
+          RUBY
+        end
+
+        it "preserves the precedence of conditional and range expressions" do
+          assert_offense(<<~RUBY)
+            conditional = T.must(condition ? foo : bar)
+                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ #{MSG}
+            range = T.must(foo..bar)
+                    ^^^^^^^^^^^^^^^^ #{MSG}
+          RUBY
+
+          assert_correction(<<~RUBY)
+            conditional = (condition ? foo : bar).not_nil!
+            range = (foo..bar).not_nil!
+          RUBY
+        end
+
+        it "parenthesizes every expression that requires it" do
+          assert_offense(<<~RUBY)
+            operator = T.must(foo + bar)
+                       ^^^^^^^^^^^^^^^^^ #{MSG}
+            logical = T.must(foo || bar)
+                      ^^^^^^^^^^^^^^^^^^ #{MSG}
+            grouped = T.must((foo || bar))
+                      ^^^^^^^^^^^^^^^^^^^^ #{MSG}
+            assignment = T.must(foo = bar)
+                         ^^^^^^^^^^^^^^^^^ #{MSG}
+            block_value = T.must(foo { bar })
+                          ^^^^^^^^^^^^^^^^^^^ #{MSG}
+            block_with_arguments = T.must(foo(arg) { |value| value })
+                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ #{MSG}
+            defined_value = T.must(defined?(foo))
+                            ^^^^^^^^^^^^^^^^^^^^^ #{MSG}
+            def example
+              T.must(yield foo)
+              ^^^^^^^^^^^^^^^^^ #{MSG}
+            end
+            def implicit_super
+              T.must(super)
+              ^^^^^^^^^^^^^ #{MSG}
+            end
+            def explicit_super
+              T.must(super(foo))
+              ^^^^^^^^^^^^^^^^^^ #{MSG}
+            end
+          RUBY
+
+          assert_correction(<<~RUBY)
+            operator = (foo + bar).not_nil!
+            logical = (foo || bar).not_nil!
+            grouped = (foo || bar).not_nil!
+            assignment = (foo = bar).not_nil!
+            block_value = foo { bar }.not_nil!
+            block_with_arguments = foo(arg) { |value| value }.not_nil!
+            defined_value = (defined?(foo)).not_nil!
+            def example
+              (yield foo).not_nil!
+            end
+            def implicit_super
+              (super).not_nil!
+            end
+            def explicit_super
+              (super(foo)).not_nil!
+            end
+          RUBY
+        end
+
+        it "preserves the precedence of command calls" do
+          assert_offense(<<~RUBY)
+            value = T.must(fetch value)
+                    ^^^^^^^^^^^^^^^^^^^ #{MSG}
+          RUBY
+
+          assert_correction(<<~RUBY)
+            value = (fetch value).not_nil!
+          RUBY
+        end
+
+        it "autocorrects multiline command calls" do
+          assert_offense(<<~RUBY)
+            T.must foo
+            ^^^^^^^^^^ #{MSG}
+              .bar
+          RUBY
+
+          assert_correction(<<~RUBY)
+            foo
+              .bar.not_nil!
+          RUBY
+        end
+
+        it "does not add unnecessary parentheses to parenthesized calls" do
+          assert_offense(<<~RUBY)
+            value = T.must(fetch(value))
+                    ^^^^^^^^^^^^^^^^^^^^ #{MSG}
+          RUBY
+
+          assert_correction(<<~RUBY)
+            value = fetch(value).not_nil!
+          RUBY
+        end
+
+        it "parenthesizes bracket method calls only when required" do
+          assert_offense(<<~RUBY)
+            bracketed = T.must(foo[bar]).foo
+                        ^^^^^^^^^^^^^^^^ #{MSG}
+            explicit = T.must(foo.[](bar)).foo
+                       ^^^^^^^^^^^^^^^^^^^ #{MSG}
+            command = T.must(foo.[] bar).foo
+                      ^^^^^^^^^^^^^^^^^^ #{MSG}
+          RUBY
+
+          assert_correction(<<~RUBY)
+            bracketed = foo[bar].not_nil!.foo
+            explicit = foo.[](bar).not_nil!.foo
+            command = (foo.[] bar).not_nil!.foo
+          RUBY
+        end
+
+        it "does not group an argument that makes the call multiline" do
+          assert_offense(<<~RUBY)
+            T.must(foo
+            ^^^^^^^^^^ #{MSG}
+              .bar)
+          RUBY
+
+          assert_correction(<<~RUBY)
+            foo
+              .bar.not_nil!
+          RUBY
+        end
+
+        it "preserves a multiline receiver without parentheses" do
+          assert_offense(<<~RUBY)
+            T.must(
+            ^^^^^^^ #{MSG}
+              foo.
+                bar
+            )
+          RUBY
+
+          assert_correction(<<~RUBY)
+            foo.
+                bar.not_nil!
+          RUBY
+        end
+
+        it "preserves comments in multiline calls" do
+          assert_offense(<<~RUBY)
+            value = T.must(
+                    ^^^^^^^ #{MSG}
+              # Proven non-nil by validation.
+              foo,
+            )
+          RUBY
+
+          assert_correction(<<~RUBY)
+            value = (
+              # Proven non-nil by validation.
+              foo
+            ).not_nil!
+          RUBY
+        end
+
+        it "drops unnecessary grouping from multiline calls without comments" do
+          assert_offense(<<~RUBY)
+            first = T .must(
+                    ^^^^^^^^ #{MSG}
+              foo,
+            )
+            second = T
+                     ^ #{MSG}
+              .must(
+                bar,
+              )
+          RUBY
+
+          assert_correction(<<~RUBY)
+            first = foo.not_nil!
+            second = bar.not_nil!
+          RUBY
+        end
+
+        it "preserves a multiline call chain without parentheses" do
+          assert_offense(<<~RUBY)
+            variant = T.must(
+                      ^^^^^^^ #{MSG}
+              InventoryItemVariant.preload(:variant).where(inventory_item_id: @inventory_item_id).first!.variant
+            )
+          RUBY
+
+          assert_correction(<<~RUBY)
+            variant = InventoryItemVariant.preload(:variant).where(inventory_item_id: @inventory_item_id).first!.variant.not_nil!
+          RUBY
+        end
+
+        it "removes a trailing comma before an inline comment" do
+          assert_offense(<<~RUBY)
+            value = T.must(
+                    ^^^^^^^ #{MSG}
+              foo, # Proven non-nil.
+            )
+          RUBY
+
+          assert_correction(<<~RUBY)
+            value = (
+              foo # Proven non-nil.
+            ).not_nil!
+          RUBY
+        end
+
+        it "preserves grouping around heredocs in multiline calls" do
+          assert_offense(<<~RUBY)
+            value = T.must(
+                    ^^^^^^^ #{MSG}
+              <<~TEXT
+                hello
+              TEXT
+            )
+          RUBY
+
+          assert_correction(<<~RUBY)
+            value = (
+              <<~TEXT
+                hello
+              TEXT
+            ).not_nil!
+          RUBY
+        end
+
+        it "preserves grouping around nested heredocs in multiline calls" do
+          assert_offense(<<~RUBY)
+            value = T.must(
+                    ^^^^^^^ #{MSG}
+              foo(<<~TEXT)
+                hello
+              TEXT
+            )
+          RUBY
+
+          assert_correction(<<~RUBY)
+            value = (
+              foo(<<~TEXT)
+                hello
+              TEXT
+            ).not_nil!
+          RUBY
+        end
+
+        it "preserves grouping around a heredoc T.must nested in another call" do
+          assert_offense(<<~RUBY)
+            value = foo(
+              T.must(
+              ^^^^^^^ #{MSG}
+                <<~TEXT
+                  hello
+                TEXT
+              )
+            )
+          RUBY
+
+          assert_correction(<<~RUBY)
+            value = foo(
+              (
+                <<~TEXT
+                  hello
+                TEXT
+              ).not_nil!
+            )
+          RUBY
+        end
+
+        it "autocorrects nested T.must calls" do
+          assert_offense(<<~RUBY)
+            value = T.must(T.must(foo).bar)
+                    ^^^^^^^^^^^^^^^^^^^^^^^ #{MSG}
+                           ^^^^^^^^^^^ #{MSG}
+          RUBY
+
+          assert_correction(<<~RUBY)
+            value = foo.not_nil!.bar.not_nil!
+          RUBY
+        end
+
+        it "autocorrects three nested T.must calls" do
+          assert_offense(<<~RUBY)
+            value = T.must(T.must(T.must(foo).bar).baz)
+                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ #{MSG}
+                           ^^^^^^^^^^^^^^^^^^^^^^^ #{MSG}
+                                  ^^^^^^^^^^^ #{MSG}
+          RUBY
+
+          assert_correction(<<~RUBY)
+            value = foo.not_nil!.bar.not_nil!.baz.not_nil!
+          RUBY
+        end
+
+        it "reports heredoc reasons without leaving orphaned heredoc bodies" do
+          assert_offense(<<~RUBY)
+            value = T.must_because(foo) { <<~REASON }
+                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ #{BECAUSE_MSG}
+              Proven non-nil.
+            REASON
+          RUBY
+
+          assert_no_corrections
+        end
+
+        it "preserves the reason without attaching the block to the corrected call" do
+          assert_offense(<<~RUBY)
+            value = T.must_because(foo) { "reason" }.bar
+                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ #{BECAUSE_MSG}
+          RUBY
+
+          assert_correction(<<~RUBY)
+            value = (
+              # reason
+              foo.not_nil!
+            ).bar
+          RUBY
+        end
+
+        it "preserves multiline reasons and argument comments" do
+          assert_offense(<<~RUBY)
+            value = ::T.must_because(
+                    ^^^^^^^^^^^^^^^^^ #{BECAUSE_MSG}
+              # Validated earlier.
+              foo,
+            ) do
+              # Explain the invariant.
+              "validated for \#{user}"
+            end
+          RUBY
+
+          assert_correction(<<~RUBY)
+            value = (
+              # # Explain the invariant.
+              # validated for \#{user}
+              # Validated earlier.
+              foo
+            ).not_nil!
+          RUBY
+        end
+
+        it "keeps trailing arguments and string interpolation outside the reason comment" do
+          assert_offense(<<~'RUBY', message: BECAUSE_MSG)
+            values = [T.must_because(foo) { 'reason' }, bar]
+                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ %{message}
+            text = "#{T.must_because(foo) { "reason" }}"
+                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ %{message}
+          RUBY
+
+          assert_correction(<<~'RUBY')
+            values = [(
+              # reason
+              foo.not_nil!
+            ), bar]
+            text = "#{(
+              # reason
+              foo.not_nil!
+            )}"
+          RUBY
+        end
+
+        it "corrects mixed nested assertions without overlapping edits" do
+          assert_offense(<<~RUBY)
+            value = T.must(T.must_because(T.must(foo)) { "reason" })
+                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ #{MSG}
+                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ #{BECAUSE_MSG}
+                                          ^^^^^^^^^^^ #{MSG}
+          RUBY
+
+          assert_correction(<<~RUBY)
+            value = (
+              # reason
+              foo.not_nil!.not_nil!
+            ).not_nil!
+          RUBY
+        end
+
+        it "comments out assertions in the reason rather than correcting them" do
+          assert_offense(<<~RUBY)
+            value = T.must_because(foo) { T.must(bar) }
+                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ #{BECAUSE_MSG}
+                                          ^^^^^^^^^^^ #{MSG}
+          RUBY
+
+          assert_correction(<<~RUBY)
+            value = (
+              # T.must(bar)
+              foo.not_nil!
+            )
+          RUBY
+        end
+
+        it "ignores other receivers, methods, and argument counts" do
+          assert_no_offenses(<<~RUBY)
+            Other::T.must(foo)
+            object.must(foo)
+            T.let(foo, String)
+            T.must(foo, bar)
+            T.must(*values)
+            Other::T.must_because(foo) { "reason" }
+            object.must_because(foo) { "reason" }
+            T.must_because(foo, bar) { "reason" }
+            T.must_because(*values) { "reason" }
+            T.must_because(foo, &reason)
+          RUBY
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -6,3 +6,17 @@ require "type_toolkit"
 
 require "minitest/autorun"
 require "minitest/spec"
+
+module Minitest
+  class Spec
+    #: () { () -> void } -> TypeToolkit::AbstractMethodNotImplementedError
+    def assert_abstract(&block)
+      assert_raises(TypeToolkit::AbstractMethodNotImplementedError, &block)
+    end
+  end
+end
+
+#: -> bot
+def assert_never_called!
+  raise Minitest::Assertion, "This should never be called"
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: type_toolkit
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.7
 platform: ruby
 authors:
 - Alexander Momchilov
@@ -52,12 +52,27 @@ files:
 - ".ruby-version"
 - README.md
 - Rakefile
+- benchmark/.rubocop.yml
+- benchmark/abstract_methods_benchmark.rb
+- benchmark/interface_startup_performance.rb
+- benchmark/module_benchmark.rb
 - config/default.yml
+- docs/design/inherited_implementation_problem.md
+- docs/design/self_dot_methods.md
 - lib/rubocop-type_toolkit.rb
 - lib/rubocop/cop/type_toolkit/dont_expect_unexpected_nil.rb
 - lib/rubocop/cop/type_toolkit/plugin.rb
+- lib/rubocop/cop/type_toolkit/prefer_not_nil.rb
 - lib/type_toolkit.rb
+- lib/type_toolkit/abstract_method_receiver.rb
+- lib/type_toolkit/dsl.rb
+- lib/type_toolkit/ext/method.rb
+- lib/type_toolkit/ext/module.rb
 - lib/type_toolkit/ext/nil_assertions.rb
+- lib/type_toolkit/has_abstract_methods.rb
+- lib/type_toolkit/interface.rb
+- lib/type_toolkit/method_def_recorder.rb
+- lib/type_toolkit/method_patch.rb
 - lib/type_toolkit/version.rb
 - sig/type_toolkit.rbs
 - sorbet/config
@@ -66,12 +81,13 @@ files:
 - sorbet/rbi/annotations/rainbow.rbi
 - sorbet/rbi/gems/.gitattributes
 - sorbet/rbi/gems/ast@2.4.3.rbi
+- sorbet/rbi/gems/benchmark-ips@2.14.0.rbi
 - sorbet/rbi/gems/benchmark@0.5.0.rbi
 - sorbet/rbi/gems/date@3.5.1.rbi
-- sorbet/rbi/gems/erb@6.0.1.rbi
+- sorbet/rbi/gems/erb@6.0.1.1.rbi
 - sorbet/rbi/gems/erubi@1.13.1.rbi
 - sorbet/rbi/gems/io-console@0.8.2.rbi
-- sorbet/rbi/gems/json@2.18.1.rbi
+- sorbet/rbi/gems/json@2.19.9.rbi
 - sorbet/rbi/gems/language_server-protocol@3.17.0.5.rbi
 - sorbet/rbi/gems/lint_roller@1.1.0.rbi
 - sorbet/rbi/gems/logger@1.7.0.rbi
@@ -107,15 +123,19 @@ files:
 - sorbet/rbi/gems/unicode-display_width@3.2.0.rbi
 - sorbet/rbi/gems/unicode-emoji@4.2.0.rbi
 - sorbet/rbi/gems/yard-sorbet@0.9.0.rbi
-- sorbet/rbi/gems/yard@0.9.38.rbi
+- sorbet/rbi/gems/yard@0.9.44.rbi
+- sorbet/rbi/shims/core.rbi
 - sorbet/rbi/shims/minitest.rbi
 - sorbet/rbi/shims/rubocop_minitest.rbi
 - sorbet/rbi/todo.rbi
 - sorbet/tapioca/config.yml
 - sorbet/tapioca/require.rb
 - spec/.rubocop.yml
+- spec/interface_spec.rb
+- spec/misc/how_method_added_hooks_work_spec.rb
 - spec/nil_assertions_spec.rb
 - spec/rubocop/cop/type_toolkit/dont_expect_unexpected_nil_spec.rb
+- spec/rubocop/cop/type_toolkit/prefer_not_nil_spec.rb
 - spec/spec_helper.rb
 - spec/type_toolkit_spec.rb
 homepage: https://github.com/Shopify/type_kit