rubocop-shopify 3.0.1 → 3.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5dbd67ae9f8f0b6a21dc141c0576ceeedad5807e2a9090e8f6703517cb8697cc
-  data.tar.gz: e2a6435804ceb46bc365409230633d20b16c33d7a3510a06fdf6ea1fde2c0913
+  metadata.gz: '0885f64f2574e1f3db7bb466fb9dcdbc1c0f1fbaf29336c209e666b10fc9104b'
+  data.tar.gz: b0a2e7bbef8f68e98c15348689d1c20433ea2da70c7727146b095028ae22992d
 SHA512:
-  metadata.gz: e36467516497260c536674f8b40e2a09a9d258cb1e25fe99076409a643c2bdc8cad84862eed8c56ba7d0fe6aa5a20488e7ec798631ded20f1a9ba04a06ddce57
-  data.tar.gz: a0445310d57d1f0cdc85193149c19cd2a5f1c161124c0c546bf1c60187c7778f0b29503bb3c384dac97cce9bf5b74219a47a210c7514b0504dba44cbab31cb35
+  metadata.gz: e352f773f31c7846508a1033019a098a7d45f72220a4ca55c81f5be24e1b74e1d5f53f61bbbff03311d62f5c495e7236aa9d8502ad0eb1bac0d4cafceb6fed45
+  data.tar.gz: 5c6ca00c17a0a0c465bb2093368fd37fc473a807f6b7db21eaddd57d1aa1aaab4a149304a92f256b2b3abf6500eebf481abaed6d406b5ea464ebd4b085f7a43f

data/config/default.yml

@@ -2,3 +2,8 @@ Lint/NoReturnInMemoization:
   Enabled: true
   VersionAdded: "3.0.0"
   Description: "Checks for the use of a `return` with a value in `begin..end` blocks in the context of instance variable assignment such as memoization."
+
+Style/ProcCaseWhen:
+  Enabled: true
+  VersionAdded: "3.0.2"
+  Description: "Checks for `case`/`when` where every `when` is a proc or value literal: each inline proc literal allocates a new `Proc` every time the `case` runs and adds `Proc#call` overhead, for what is just a harder-to-read `if`/`elsif` tree."

data/lib/rubocop/cop/style/proc_case_when.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for `case` statements whose `when` conditions are only proc/lambda
+      # literals and value literals (with at least one proc).
+      #
+      # Such a `case` is just a harder-to-read `if`/`elsif` tree with a needless
+      # performance cost: a `when` clause matches using `pattern === subject`,
+      # and for a proc `Proc#===` is an alias for `Proc#call`. Every inline proc
+      # literal therefore allocates a brand new `Proc` object each time the
+      # `case` is evaluated (on a hot path, once per branch per call) and adds
+      # `Proc#call` indirection, where an `if`/`elsif` allocates nothing. For a
+      # value literal (number, string, symbol, `nil`, `true`, `false`) `===` is
+      # `==`, so the whole statement is exactly equivalent to `if`/`elsif` using
+      # `Proc#call` and `==`. Use `if`/`elsif` instead.
+      #
+      # Constants assigned a proc literal or a value literal *in the same file*
+      # are resolved and treated as such. Constants defined in other files cannot
+      # be resolved: a bare `when SOME_CONST` is indistinguishable from matching
+      # against a class, so those are left alone to avoid flagging idiomatic
+      # `case obj when SomeClass`.
+      #
+      # Cases that use class, range, or regexp patterns are also left alone:
+      # those rely on `===` in ways that read far worse as `if` conditions
+      # (`is_a?`, `cover?`, `match?`), which is exactly what `case` is for.
+      #
+      # @example
+      #
+      #   # bad - every `when` is a proc (a new proc is allocated on each call)
+      #   case value
+      #   when ->(x) { x > 10 } then :big
+      #   when ->(x) { x < 0 }  then :negative
+      #   else :other
+      #   end
+      #
+      #   # bad - only procs and value literals (including value-literal constants)
+      #   NAME = "widget"
+      #   case value
+      #   when NAME             then :named
+      #   when ->(x) { x > 10 } then :big
+      #   end
+      #
+      #   # good - no proc allocation, and easier to read
+      #   if value > 10
+      #     :big
+      #   elsif value < 0
+      #     :negative
+      #   else
+      #     :other
+      #   end
+      #
+      #   # good - a class/range/regexp pattern makes `case` the clearer choice,
+      #   # even alongside a proc.
+      #   case value
+      #   when Integer          then :int
+      #   when ->(x) { x > 10 } then :big
+      #   end
+      class ProcCaseWhen < ::RuboCop::Cop::Base
+        MSG = "Avoid a `case`/`when` where every `when` is a proc or value " \
+          "literal: each proc literal allocates a new `Proc` every time the " \
+          "`case` is evaluated and adds `Proc#call` overhead, and the whole " \
+          "thing is just a harder-to-read `if`/`elsif` tree. Use `if`/`elsif` " \
+          "instead."
+
+        # Matches `->(x) {}`, `lambda {}`, `proc {}` and `Proc.new {}`, including
+        # their numbered-parameter (`_1`) block variants.
+        # @!method proc_literal?(node)
+        def_node_matcher :proc_literal?, <<~PATTERN
+          {
+            ({block numblock} (send nil? {:lambda :proc}) ...)
+            ({block numblock} (send (const {nil? cbase} :Proc) :new) ...)
+          }
+        PATTERN
+
+        def on_new_investigation
+          super
+          @constant_kinds = collect_constant_kinds
+        end
+
+        def on_case(node)
+          # `case` without a subject evaluates each `when` for truthiness rather
+          # than with `===`, so procs there are not used as matchers.
+          return unless node.condition
+
+          kinds = node.when_branches.flat_map(&:conditions).map { |condition| kind_of(condition) }
+          # Require at least one proc; a case of only value literals is a fine
+          # dispatch and out of scope here.
+          return unless kinds.include?(:proc)
+          # Bail out if any condition is something other than a proc or a value
+          # literal (e.g. a class, range, regexp, or an unresolvable constant),
+          # where `case` reads better than the equivalent `if`.
+          return unless kinds.all? { |kind| kind == :proc || kind == :value }
+
+          add_offense(node)
+        end
+
+        private
+
+        # Classifies a `when` condition (or a constant's assigned value) as a
+        # proc, a value literal, or `:other` (anything we should not rewrite).
+        def kind_of(node)
+          # Unwrap a trailing `.freeze` so `FOO = "bar".freeze` counts as a value.
+          node = node.receiver if node.send_type? && node.method?(:freeze) && node.receiver
+
+          if proc_literal?(node)
+            :proc
+          elsif node.basic_literal?
+            :value
+          elsif node.const_type?
+            # `@constant_kinds` is still nil while being built; an unresolved
+            # constant is treated as `:other` (conservative).
+            (@constant_kinds || {}).fetch(node.short_name, :other)
+          else
+            :other
+          end
+        end
+
+        # Maps the short (demodulized) name of every constant assigned in this
+        # file to its kind, so bare `when CONST` references can be resolved.
+        def collect_constant_kinds
+          kinds = {}
+          ast = processed_source.ast
+          return kinds unless ast
+
+          ast.each_node(:casgn) do |casgn|
+            value = casgn.children[2]
+            next unless value
+
+            kinds[casgn.name] = kind_of(value)
+          end
+          kinds
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/shopify/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Shopify
-    VERSION = "3.0.1"
+    VERSION = "3.0.2"
   end
 end

data/lib/rubocop-shopify.rb

@@ -4,3 +4,4 @@ require "rubocop/shopify/version"
 require "rubocop/shopify/plugin"
 
 require "rubocop/cop/lint/no_return_in_memoization"
+require "rubocop/cop/style/proc_case_when"

data/rubocop.yml

@@ -1196,9 +1196,6 @@ Style/RedundantFilterChain:
 Style/RedundantFormat:
   Enabled: false
 
-Style/RedundantFreeze:
-  Enabled: false
-
 Style/RedundantHeredocDelimiterQuotes:
   Enabled: false
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-shopify
 version: !ruby/object:Gem::Version
-  version: 3.0.1
+  version: 3.0.2
 platform: ruby
 authors:
 - Shopify Engineering
@@ -55,6 +55,7 @@ files:
 - config/default.yml
 - lib/rubocop-shopify.rb
 - lib/rubocop/cop/lint/no_return_in_memoization.rb
+- lib/rubocop/cop/style/proc_case_when.rb
 - lib/rubocop/shopify/plugin.rb
 - lib/rubocop/shopify/version.rb
 - lib/tasks/config.rake
@@ -63,7 +64,7 @@ homepage: https://shopify.github.io/ruby-style-guide/
 licenses:
 - MIT
 metadata:
-  source_code_uri: https://github.com/Shopify/ruby-style-guide/tree/v3.0.1
+  source_code_uri: https://github.com/Shopify/ruby-style-guide/tree/v3.0.2
   allowed_push_host: https://rubygems.org
   default_lint_roller_plugin: RuboCop::Shopify::Plugin
 rdoc_options: []