barsoom_utils 0.3.0.79 → 0.3.0.82

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d567d7a3ae76f80b86ad642cf590526cb3bc2a2be5b95c94abf8944142a40b15
-  data.tar.gz: 0fd5468990225ed9d0faf43d860b6afe2ccb5b24fb5786077cde7054445ea832
+  metadata.gz: 1757860af2eca9a71fffa1fa0c47a42e572314816f4dcf02d752d60c713ace67
+  data.tar.gz: 54eb7e03409786d5eb87c34affad0a363b2ac3d17ee19ec22c75c800fd171c6d
 SHA512:
-  metadata.gz: ce1a9a7ef20a8f445b8974a3e63b471c1b20ca952f2608e2fb6e35a9f502a8ef961f4d9087dd02cc6e41a6ba9e234df7ba812f6cac42d057d49a3cc00ba02abd
-  data.tar.gz: 787e53e219778ea27306a49758ce0220fbfa1be5e57743f0b5a14a14fe56288d07f914ae885cacf996e2c02dc9ed35151907457b0a0f1f7e4b2fc2bc818c2483
+  metadata.gz: 66619d39cab01f97f5da75ab364f6f5f215f1c7755683518e71fa5d91bd7c3c3689828e0088b2ee562b07cf891a852378e6ee5f1533e4ee6c40103cd28db2f25
+  data.tar.gz: ae669cd31bb669333412b0ea3f1bb6ebca0c584ed602685acf750f32106716fddd412ac657335ba7fc5b0ca32aa20bc4a0d11770746bf0ea8eddef37ddc1908c

data/README.md

@@ -50,6 +50,8 @@ inherit_gem:
     - shared_rubocop.yml
 ```
 
+`shared_rubocop.yml` also loads our custom cops, in `lib/rubocop/cop/barsoom`.
+
 ## Developing
 
 Running tests:

data/VERSION

@@ -1 +1 @@
-0.3.0.79
+0.3.0.82

data/lib/barsoom_utils/rubocop.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+# Custom cops, loaded by shared_rubocop.yml.
+require "rubocop"
+require_relative "../rubocop/cop/barsoom/attr_extras_initialize"
+require_relative "../rubocop/cop/barsoom/inline_private_class_method"

data/lib/rubocop/cop/barsoom/attr_extras_initialize.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+module RuboCop
+  module Cop
+    module Barsoom
+      # Checks for an `initialize` that only assigns each of its arguments to an instance variable of the same name.
+      # attr_extras can define that for you.
+      #
+      # Positional defaults, splats and block arguments are accepted, since attr_extras has no equivalent. So are
+      # keyword defaults other than immutable literals: attr_extras evaluates them once, when the class is loaded.
+      #
+      # @example
+      #   # bad
+      #   def initialize(user, notify:)
+      #     @user = user
+      #     @notify = notify
+      #   end
+      #
+      #   # good
+      #   pattr_initialize :user, [ :notify! ]
+      class AttrExtrasInitialize < Base
+        MSG = "Use attr_extras, e.g. `pattr_initialize`, instead of an `initialize` that only assigns its arguments."
+        SUPPORTED_ARGUMENT_TYPES = %i[arg kwarg kwoptarg].freeze
+        IMMUTABLE_DEFAULT_TYPES = %i[nil true false sym int float].freeze
+
+        requires_gem "attr_extras"
+
+        def on_def(node)
+          return unless node.method?(:initialize)
+          return unless node.each_ancestor(:class, :module, :sclass).first&.class_type?
+          return unless supported_arguments?(node.arguments)
+          return unless only_assigns?(node.body, node.arguments.map(&:name))
+
+          add_offense(node.loc.keyword.join(node.loc.name))
+        end
+
+        private
+
+        def supported_arguments?(arguments)
+          arguments.any? && arguments.all? { |argument|
+            SUPPORTED_ARGUMENT_TYPES.include?(argument.type) &&
+              (!argument.kwoptarg_type? || IMMUTABLE_DEFAULT_TYPES.include?(argument.default_value.type))
+          }
+        end
+
+        def only_assigns?(body, names)
+          return false unless body
+
+          statements = body.begin_type? ? body.children : [ body ]
+          assigned = statements.map { |statement| assigned_argument(statement) }
+
+          assigned.all? && assigned.sort == names.sort
+        end
+
+        def assigned_argument(statement)
+          return unless statement.ivasgn_type? && statement.expression&.lvar_type?
+
+          name = statement.expression.children.first
+          name if statement.name == :"@#{name}"
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/barsoom/inline_private_class_method.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+module RuboCop
+  module Cop
+    module Barsoom
+      # Checks for `private_class_method` listing class methods by name, when they're defined with `def self.` in the
+      # same class body. Putting the modifier before each definition shows at a glance which class methods are private.
+      #
+      # Names not defined that way, e.g. `private_class_method :new`, are accepted. The offense is only corrected when
+      # every listed name is defined in the class body.
+      #
+      # @example
+      #   # bad
+      #   def self.parse(value) = Time.iso8601(value)
+      #
+      #   private_class_method :parse
+      #
+      #   # good
+      #   private_class_method \
+      #   def self.parse(value) = Time.iso8601(value)
+      class InlinePrivateClassMethod < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = "Use `private_class_method \\` before each `def self.` instead of listing the methods by name."
+        RESTRICT_ON_SEND = %i[private_class_method].freeze
+
+        def on_send(node)
+          return if node.receiver || node.arguments.empty? || !node.arguments.all?(&:sym_type?)
+
+          definitions = class_method_definitions(node.parent)
+          names = node.arguments.map(&:value)
+          return if names.none? { |name| definitions.key?(name) }
+
+          add_offense(node) do |corrector|
+            next unless names.all? { |name| definitions.key?(name) }
+
+            names.each do |name|
+              definition = definitions.fetch(name)
+              corrector.insert_before(definition, "private_class_method \\\n#{" " * definition.loc.column}")
+            end
+            corrector.remove(removal_range(node))
+          end
+        end
+
+        private
+
+        def class_method_definitions(body)
+          return {} unless body&.begin_type?
+
+          body.each_child_node(:defs).select { |definition| definition.receiver.self_type? }.to_h { |definition| [ definition.method_name, definition ] }
+        end
+
+        # The whole line, and the blank line above it, so no blank line is left before the class's `end`.
+        def removal_range(node)
+          range = range_by_whole_lines(node.source_range, include_final_newline: true)
+          previous_line = processed_source.lines[node.first_line - 2]
+          previous_line&.strip&.empty? ? range.with(begin_pos: range.begin_pos - previous_line.length - 1) : range
+        end
+      end
+    end
+  end
+end

data/shared_rubocop.yml

@@ -1,5 +1,9 @@
 # Configuration for the Rubocop code linting tool. See README.
 
+# Our custom cops, in lib/rubocop/cop/barsoom.
+require:
+  - barsoom_utils/rubocop
+
 AllCops:
   ActiveSupportExtensionsEnabled: true
   DisabledByDefault: true
@@ -381,3 +385,12 @@ Gemspec/RequireMFA:
 # https://docs.rubocop.org/rubocop/cops_naming.html#namingblockforwarding
 Naming/BlockForwarding:
   Enabled: true
+
+# Allow e.g. `pattr_initialize :user` and disallow an `initialize` that only assigns `@user = user`.
+# Only runs in projects that have attr_extras in their Gemfile.lock.
+Barsoom/AttrExtrasInitialize:
+  Enabled: true
+
+# Allow e.g. `private_class_method \` before `def self.parse` and disallow `private_class_method :parse` further down.
+Barsoom/InlinePrivateClassMethod:
+  Enabled: true

data/shared_rubocop_rails.yml

@@ -7,3 +7,7 @@ Rails/CompactBlank:
 # Allow e.g. `String#end_with?` and disallow `String#ends_with?`.
 Rails/ActiveSupportAliases:
   Enabled: true
+
+# Allow e.g. `list.index_with { value(it) }` and disallow `list.to_h { [it, value(it)] }`.
+Rails/IndexWith:
+  Enabled: true

data/spec/rubocop/cop/barsoom/attr_extras_initialize_spec.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+require "rubocop_helper"
+
+RSpec.describe RuboCop::Cop::Barsoom::AttrExtrasInitialize, :config do
+  let(:gem_versions) { { "attr_extras" => "7.1.0" } }
+
+  it "registers an offense for an initialize that only assigns its positional arguments" do
+    expect_offense(<<~RUBY)
+      class Foo
+        def initialize(bar, baz)
+        ^^^^^^^^^^^^^^ Use attr_extras, e.g. `pattr_initialize`, instead of an `initialize` that only assigns its arguments.
+          @bar = bar
+          @baz = baz
+        end
+      end
+    RUBY
+  end
+
+  it "registers an offense for required keyword arguments" do
+    expect_offense(<<~RUBY)
+      class Foo
+        def initialize(bar, baz:)
+        ^^^^^^^^^^^^^^ Use attr_extras, e.g. `pattr_initialize`, instead of an `initialize` that only assigns its arguments.
+          @bar = bar
+          @baz = baz
+        end
+      end
+    RUBY
+  end
+
+  it "registers an offense for keyword arguments with immutable literal defaults" do
+    expect_offense(<<~RUBY)
+      class Foo
+        def initialize(bar: nil, baz: :qux, limit: 10)
+        ^^^^^^^^^^^^^^ Use attr_extras, e.g. `pattr_initialize`, instead of an `initialize` that only assigns its arguments.
+          @bar = bar
+          @baz = baz
+          @limit = limit
+        end
+      end
+    RUBY
+  end
+
+  it "accepts keyword defaults that attr_extras would evaluate once, at load time" do
+    expect_no_offenses(<<~RUBY)
+      class Foo
+        def initialize(now: Time.now, list: [], name: "x")
+          @now = now
+          @list = list
+          @name = name
+        end
+      end
+    RUBY
+  end
+
+  it "accepts positional defaults, which attr_extras doesn't support" do
+    expect_no_offenses(<<~RUBY)
+      class Foo
+        def initialize(bar, baz = nil)
+          @bar = bar
+          @baz = baz
+        end
+      end
+    RUBY
+  end
+
+  it "accepts splat and block arguments" do
+    expect_no_offenses(<<~RUBY)
+      class Foo
+        def initialize(*bars, **opts, &block)
+          @bars = bars
+          @opts = opts
+          @block = block
+        end
+      end
+    RUBY
+  end
+
+  it "accepts an initialize that does anything besides assigning its arguments" do
+    expect_no_offenses(<<~RUBY)
+      class Foo
+        def initialize(bar, baz)
+          @bar = bar
+          @baz = baz.to_s
+          @qux = []
+        end
+      end
+    RUBY
+  end
+
+  it "accepts an initialize that calls super" do
+    expect_no_offenses(<<~RUBY)
+      class Foo < Base
+        def initialize(bar)
+          super()
+          @bar = bar
+        end
+      end
+    RUBY
+  end
+
+  it "accepts instance variables named differently from the arguments" do
+    expect_no_offenses(<<~RUBY)
+      class Foo
+        def initialize(bar)
+          @baz = bar
+        end
+      end
+    RUBY
+  end
+
+  it "accepts an initialize that leaves an argument unassigned" do
+    expect_no_offenses(<<~RUBY)
+      class Foo
+        def initialize(bar, _baz)
+          @bar = bar
+        end
+      end
+    RUBY
+  end
+
+  it "accepts an initialize without arguments" do
+    expect_no_offenses(<<~RUBY)
+      class Foo
+        def initialize
+        end
+      end
+    RUBY
+  end
+
+  it "accepts an initialize in a module" do
+    expect_no_offenses(<<~RUBY)
+      module Foo
+        def initialize(bar)
+          @bar = bar
+        end
+      end
+    RUBY
+  end
+
+  context "when the project doesn't use attr_extras" do
+    let(:gem_versions) { {} }
+
+    it "accepts the initialize" do
+      expect_no_offenses(<<~RUBY)
+        class Foo
+          def initialize(bar)
+            @bar = bar
+          end
+        end
+      RUBY
+    end
+  end
+end

data/spec/rubocop/cop/barsoom/inline_private_class_method_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+require "rubocop_helper"
+
+RSpec.describe RuboCop::Cop::Barsoom::InlinePrivateClassMethod, :config do
+  let(:ruby_version) { 3.4 }
+
+  it "registers an offense for listing class methods by name, and moves the modifier onto each definition" do
+    expect_offense(<<~RUBY)
+      class Foo
+        def self.call = parse
+
+        def self.parse
+          :parsed
+        end
+
+        def self.verifier = :verifier
+
+        private_class_method :parse, :verifier
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `private_class_method \\` before each `def self.` instead of listing the methods by name.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      class Foo
+        def self.call = parse
+
+        private_class_method \\
+        def self.parse
+          :parsed
+        end
+
+        private_class_method \\
+        def self.verifier = :verifier
+      end
+    RUBY
+  end
+
+  it "registers an offense without correcting it when some of the names aren't defined in the class body" do
+    expect_offense(<<~RUBY)
+      class Foo
+        def self.build = new
+
+        def self.parse = :parsed
+
+        private_class_method :new, :parse
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `private_class_method \\` before each `def self.` instead of listing the methods by name.
+      end
+    RUBY
+
+    expect_no_corrections
+  end
+
+  it "accepts the modifier before the definition" do
+    expect_no_offenses(<<~RUBY)
+      class Foo
+        private_class_method \\
+        def self.parse = :parsed
+
+        private_class_method def self.verifier = :verifier
+      end
+    RUBY
+  end
+
+  it "accepts names that aren't defined with `def self.` in the class body" do
+    expect_no_offenses(<<~RUBY)
+      class Foo
+        def self.build = new
+
+        private_class_method :new
+      end
+    RUBY
+  end
+end

data/spec/rubocop_helper.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+require "rubocop"
+require "rubocop/rspec/support"
+require "barsoom_utils/rubocop"
+
+RSpec.configure do |config|
+  config.include RuboCop::RSpec::ExpectOffense
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: barsoom_utils
 version: !ruby/object:Gem::Version
-  version: 0.3.0.79
+  version: 0.3.0.82
 platform: ruby
 authors:
 - Tomas Skogberg
@@ -29,13 +29,19 @@ files:
 - lib/barsoom_utils.rb
 - lib/barsoom_utils/exception_notifier.rb
 - lib/barsoom_utils/feature_toggle.rb
+- lib/barsoom_utils/rubocop.rb
 - lib/barsoom_utils/spec/debug_helpers.rb
 - lib/barsoom_utils/version.rb
+- lib/rubocop/cop/barsoom/attr_extras_initialize.rb
+- lib/rubocop/cop/barsoom/inline_private_class_method.rb
 - script/test
 - shared_rubocop.yml
 - shared_rubocop_rails.yml
 - spec/exception_notifier_spec.rb
 - spec/feature_toggle_spec.rb
+- spec/rubocop/cop/barsoom/attr_extras_initialize_spec.rb
+- spec/rubocop/cop/barsoom/inline_private_class_method_spec.rb
+- spec/rubocop_helper.rb
 - spec/spec/debug_helpers_spec.rb
 - spec/spec_helper.rb
 homepage: https://dev.auctionet.com/