barsoom_utils 0.2.0.78 → 0.3.0.82

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f10ec24dca48ed3703590008317664ee7993d1efbfd0b3d4c5cc1d876c5712ca
-  data.tar.gz: c9d43fdc45e23e2a267c390007cc5c685273d5da581f8a413fb2da106ec25d08
+  metadata.gz: 1757860af2eca9a71fffa1fa0c47a42e572314816f4dcf02d752d60c713ace67
+  data.tar.gz: 54eb7e03409786d5eb87c34affad0a363b2ac3d17ee19ec22c75c800fd171c6d
 SHA512:
-  metadata.gz: bfb7e4a46b94501ce9d505c0b19b674006f75c48cd3b16f18c7573c6d006ab41f9b3196529a5fa6a383d7c2454a41ac12dcfacd3da05db9e40b19f217715ae32
-  data.tar.gz: f9e748ad9dfb716d217df3420fafb7ac93c859d07b240e24dcd9c668b9ff741f9d6631a6f467abea7ca24a71867e39ed8b37885a4ea53ab15e0ee83f3593b277
+  metadata.gz: 66619d39cab01f97f5da75ab364f6f5f215f1c7755683518e71fa5d91bd7c3c3689828e0088b2ee562b07cf891a852378e6ee5f1533e4ee6c40103cd28db2f25
+  data.tar.gz: ae669cd31bb669333412b0ea3f1bb6ebca0c584ed602685acf750f32106716fddd412ac657335ba7fc5b0ca32aa20bc4a0d11770746bf0ea8eddef37ddc1908c

data/Gemfile

@@ -8,7 +8,6 @@ group :development, :test do
   gem "attr_extras"
   gem "bundler"
   gem "fixme"
-  gem "honeybadger"
   gem "httparty"
   gem "lolcat"
   gem "rake"

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.2.0.78
+0.3.0.82

data/lib/barsoom_utils/exception_notifier.rb

@@ -13,9 +13,7 @@ module BarsoomUtils
 
       ensure_notifier!
 
-      result = Honeybadger.notify(exception, context: context) if defined?(Honeybadger)
-      Sentry.capture_exception(exception, extra: context) if defined?(Sentry)
-      result
+      Sentry.capture_exception(exception, extra: context)
     end
 
     def self.message(message, details_or_context = nil, context_or_nothing = nil)
@@ -32,29 +30,17 @@ module BarsoomUtils
         context = {}
       end
 
-      if defined?(Honeybadger)
-        result = Honeybadger.notify(
-          error_class: message,
-          error_message: (details || "(no message)").to_s,
-          context: context.to_h,
-        )
-      end
-
-      if defined?(Sentry)
-        title = details ? "#{message}: #{details}" : message.to_s
-        Sentry.capture_message(title, extra: context.to_h)
-      end
-
-      result
+      title = details ? "#{message}: #{details}" : message.to_s
+      Sentry.capture_message(title, extra: context.to_h)
     end
 
     private
 
     private_class_method \
     def self.ensure_notifier!
-      return if defined?(Honeybadger) || defined?(Sentry)
+      return if defined?(Sentry)
 
-      raise "Cannot notify: neither Honeybadger nor Sentry is available."
+      raise "Cannot notify: Sentry is not available."
     end
   end
 end

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/exception_notifier_spec.rb

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 require "barsoom_utils/exception_notifier"
-require "honeybadger"
 require "sentry-ruby"
 require "fixme"
 
 RSpec.describe BarsoomUtils::ExceptionNotifier do
   before do
-    allow(Honeybadger).to receive(:notify)
     allow(Sentry).to receive(:capture_exception)
     allow(Sentry).to receive(:capture_message)
   end
@@ -14,17 +12,15 @@ RSpec.describe BarsoomUtils::ExceptionNotifier do
   describe ".notify" do
     let(:ex) { StandardError.new("boom") }
 
-    it "passes an exception to Honeybadger and Sentry" do
+    it "passes an exception to Sentry" do
       BarsoomUtils::ExceptionNotifier.notify(ex)
 
-      expect(Honeybadger).to have_received(:notify).with(ex, context: {})
       expect(Sentry).to have_received(:capture_exception).with(ex, extra: {})
     end
 
     it "can pass through context info" do
       BarsoomUtils::ExceptionNotifier.notify(ex, context: { foo: "bar" })
 
-      expect(Honeybadger).to have_received(:notify).with(ex, context: { foo: "bar" })
       expect(Sentry).to have_received(:capture_exception).with(ex, extra: { foo: "bar" })
     end
 
@@ -33,74 +29,38 @@ RSpec.describe BarsoomUtils::ExceptionNotifier do
         BarsoomUtils::ExceptionNotifier.notify({ foo: "bar" })
       }.to raise_error(/Expected an exception but got:.*foo.*bar/)
 
-      expect(Honeybadger).not_to have_received(:notify)
       expect(Sentry).not_to have_received(:capture_exception)
     end
 
-    it "returns Honeybadger's result" do
-      allow(Honeybadger).to receive(:notify).and_return(:sentinel)
+    it "returns Sentry's result" do
+      allow(Sentry).to receive(:capture_exception).and_return(:sentinel)
 
       expect(BarsoomUtils::ExceptionNotifier.notify(ex)).to eq(:sentinel)
     end
 
-    context "without Sentry" do
-      before { hide_const("Sentry") }
+    it "raises without Sentry" do
+      hide_const("Sentry")
 
-      it "still notifies Honeybadger and raises nothing" do
-        BarsoomUtils::ExceptionNotifier.notify(ex, context: { foo: "bar" })
-
-        expect(Honeybadger).to have_received(:notify).with(ex, context: { foo: "bar" })
-      end
-    end
-
-    context "without Honeybadger" do
-      before { hide_const("Honeybadger") }
-
-      it "still notifies Sentry and raises nothing" do
-        BarsoomUtils::ExceptionNotifier.notify(ex, context: { foo: "bar" })
-
-        expect(Sentry).to have_received(:capture_exception).with(ex, extra: { foo: "bar" })
-      end
-    end
-
-    context "without either notifier" do
-      before do
-        hide_const("Honeybadger")
-        hide_const("Sentry")
-      end
-
-      it "raises" do
-        expect {
-          BarsoomUtils::ExceptionNotifier.notify(ex)
-        }.to raise_error(/neither Honeybadger nor Sentry/)
-      end
+      expect {
+        BarsoomUtils::ExceptionNotifier.notify(ex)
+      }.to raise_error(/Sentry is not available/)
     end
   end
 
   describe ".message" do
-    it "passes a message to Honeybadger and Sentry" do
+    it "passes a message to Sentry" do
       BarsoomUtils::ExceptionNotifier.message("Boom!")
 
-      expect(Honeybadger).to have_received(:notify).with(
-        error_class: "Boom!",
-        error_message: "(no message)",
-        context: {},
-      )
       expect(Sentry).to have_received(:capture_message).with("Boom!", extra: {})
     end
 
     it "can take a custom details string" do
       BarsoomUtils::ExceptionNotifier.message("Boom!", "Details!")
 
-      expect(Honeybadger).to have_received(:notify).with(
-        error_class: "Boom!",
-        error_message: "Details!",
-        context: {},
-      )
       expect(Sentry).to have_received(:capture_message).with("Boom!: Details!", extra: {})
     end
 
-    it "coerces the message to a string for Sentry" do
+    it "coerces the message to a string" do
       BarsoomUtils::ExceptionNotifier.message(:boom)
 
       expect(Sentry).to have_received(:capture_message).with("boom", extra: {})
@@ -109,66 +69,27 @@ RSpec.describe BarsoomUtils::ExceptionNotifier do
     it "can take a context hash" do
       BarsoomUtils::ExceptionNotifier.message("Boom!", foo: "bar")
 
-      expect(Honeybadger).to have_received(:notify).with(
-        error_class: "Boom!",
-        error_message: "(no message)",
-        context: { foo: "bar" },
-      )
       expect(Sentry).to have_received(:capture_message).with("Boom!", extra: { foo: "bar" })
     end
 
     it "can take a custom details string and a context hash" do
       BarsoomUtils::ExceptionNotifier.message("Boom!", "Details!", foo: "bar")
 
-      expect(Honeybadger).to have_received(:notify).with(
-        error_class: "Boom!",
-        error_message: "Details!",
-        context: { foo: "bar" },
-      )
       expect(Sentry).to have_received(:capture_message).with("Boom!: Details!", extra: { foo: "bar" })
     end
 
-    it "returns Honeybadger's result" do
-      allow(Honeybadger).to receive(:notify).and_return(:sentinel)
+    it "returns Sentry's result" do
+      allow(Sentry).to receive(:capture_message).and_return(:sentinel)
 
       expect(BarsoomUtils::ExceptionNotifier.message("Boom!")).to eq(:sentinel)
     end
 
-    context "without Sentry" do
-      before { hide_const("Sentry") }
+    it "raises without Sentry" do
+      hide_const("Sentry")
 
-      it "still notifies Honeybadger and raises nothing" do
-        BarsoomUtils::ExceptionNotifier.message("Boom!", "Details!", foo: "bar")
-
-        expect(Honeybadger).to have_received(:notify).with(
-          error_class: "Boom!",
-          error_message: "Details!",
-          context: { foo: "bar" },
-        )
-      end
-    end
-
-    context "without Honeybadger" do
-      before { hide_const("Honeybadger") }
-
-      it "still notifies Sentry and raises nothing" do
-        BarsoomUtils::ExceptionNotifier.message("Boom!", "Details!", foo: "bar")
-
-        expect(Sentry).to have_received(:capture_message).with("Boom!: Details!", extra: { foo: "bar" })
-      end
-    end
-
-    context "without either notifier" do
-      before do
-        hide_const("Honeybadger")
-        hide_const("Sentry")
-      end
-
-      it "raises" do
-        expect {
-          BarsoomUtils::ExceptionNotifier.message("Boom!")
-        }.to raise_error(/neither Honeybadger nor Sentry/)
-      end
+      expect {
+        BarsoomUtils::ExceptionNotifier.message("Boom!")
+      }.to raise_error(/Sentry is not available/)
     end
   end
 end

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.2.0.78
+  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/