rubocop-dev_doc 0.6.0.beta1 → 0.8.0

data/lib/rubocop/cop/dev_doc/migration/avoid_non_null.rb

@@ -26,6 +26,12 @@ module RuboCop
         #   ❌ Regular column
         #   add_column :users, :profile_completion_rate, :float, null: false
         #
+        #   ❌ Tightening an existing column to NOT NULL
+        #   change_column_null :users, :name, false
+        #
+        #   ❌ Same tightening, via change_column
+        #   change_column :users, :name, :string, null: false
+        #
         #   ✔️ Regular column
         #   add_column :users, :profile_completion_rate, :float
         #
@@ -47,6 +53,12 @@ module RuboCop
         #   integer, so THIS cop cannot detect it and WILL flag it. Disable it on
         #   the line with a brief reason — `-- enum` — so the migration is
         #   self-documenting: a reader sees at a glance that the column is an enum.
+        # - **Boolean columns justified via `DevDoc/Migration/AvoidBooleanColumn`**
+        #   — once the developer has justified a boolean through that cop's
+        #   escape hatch, NULL is outside {true, false} (just as it is outside an
+        #   enum's domain), so `null: false` is required and enforced by the
+        #   sibling cop `DevDoc/Migration/BooleanColumnNotNull`. Disable this cop
+        #   on the line with `-- boolean` so the migration is self-documenting.
         #
         #   ✔️ Required foreign key (never flagged)
         #   t.belongs_to :user, null: false, foreign_key: true
@@ -56,20 +68,41 @@ module RuboCop
         #   add_column :orders, :status, :integer, null: false
         #   # rubocop:enable DevDoc/Migration/AvoidNonNull
         #
+        #   ✔️ Boolean (flagged here — disable with a brief `-- boolean` reason)
+        #   # rubocop:disable DevDoc/Migration/AvoidNonNull -- boolean
+        #   # rubocop:disable DevDoc/Migration/AvoidBooleanColumn -- true binary preference
+        #   add_column :things, :flag, :boolean, null: false
+        #   # rubocop:enable DevDoc/Migration/AvoidBooleanColumn
+        #   # rubocop:enable DevDoc/Migration/AvoidNonNull
+        #
         # NOTE: This cop is deliberately NOT enum-aware. It could read the
         # model's `enum` declarations and skip those columns, but requiring an
         # explicit per-line disable is intentional: it forces the developer to
         # signal that the column is an enum, which documents the migration. A
         # silent skip would hide that intent.
         #
-        # NOTE: This cop only flags `null: false`. It does not flag `null: true`
-        # (redundant but harmless), and it does not require foreign keys to carry
-        # `null: false` — adding it to an FK is encouraged but not enforced here.
+        # NOTE: This cop also flags NOT NULL set on an existing column, by either
+        # API: `change_column_null(table, column, false)` and
+        # `change_column(table, column, type, null: false)`. Both express the same
+        # constraint as `null: false` on a definition (the add-nullable -> backfill
+        # -> tighten step), so a legit enum/boolean tightening disables this cop
+        # inline with `-- enum`/`-- boolean`, exactly as for a new column.
+        #
+        # NOTE: This cop only flags `null: false` (and the equivalent `false` arg
+        # of `change_column_null`). It does not flag `null: true` (redundant but
+        # harmless), and it does not require foreign keys to carry `null: false`
+        # — adding it to an FK is encouraged but not enforced here.
         #
         # @example
         #   # bad
         #   add_column :users, :name, :string, null: false
         #
+        #   # bad (tightening an existing column to NOT NULL)
+        #   change_column_null :users, :name, false
+        #
+        #   # bad (same tightening, via change_column)
+        #   change_column :users, :name, :string, null: false
+        #
         #   # bad (enum without a disable — the cop flags it; disable with `-- enum`)
         #   t.integer :processing_status, null: false
         #
@@ -91,28 +124,56 @@ module RuboCop
             json jsonb bigint
           ].freeze
 
-          RESTRICT_ON_SEND = (COLUMN_METHODS + %i[add_column]).freeze
+          RESTRICT_ON_SEND = (COLUMN_METHODS + %i[add_column change_column change_column_null]).freeze
 
           def_node_matcher :null_false_pair, <<~PATTERN
             (hash <$(pair (sym :null) (false)) ...>)
           PATTERN
 
+          # Matches `change_column_null :table, :column, false` (and the optional
+          # trailing-default 4-arg form). The `false` arg IS the NOT NULL directive
+          # — the same constraint as `null: false` on a definition, just applied to
+          # an existing column via the standard add-nullable -> backfill -> tighten
+          # step. Flagged so the cop cannot be sidestepped by choice of API: a
+          # regular column tightened to NOT NULL is held to the same standard as one
+          # declared NOT NULL up front. A legit enum/boolean tightening resolves at
+          # the disable site, exactly as for a new column.
+          def_node_matcher :change_column_null_false, <<~PATTERN
+            (send _ :change_column_null _ _ $false ...)
+          PATTERN
+
           def on_send(node)
+            flag = offense_node(node)
+            add_offense(flag) if flag
+          end
+
+          private
+
+          # The node whose NOT NULL directive offends: the `false` arg of
+          # `change_column_null`, or the `null: false` pair on a regular column
+          # definition. nil when there is nothing to flag.
+          def offense_node(node)
+            change_column_null_false(node) || column_null_false_pair(node)
+          end
+
+          def column_null_false_pair(node)
             return unless column_method?(node)
 
             options = node.arguments.find(&:hash_type?)
             return unless options
 
-            pair = null_false_pair(options)
-            return unless pair
-
-            add_offense(pair)
+            null_false_pair(options)
           end
 
-          private
-
+          # Methods that define or change a regular column and carry an options
+          # hash where `null:` may appear: the `t.<type>` helpers plus
+          # `add_column`/`change_column`. (`change_column_null` is handled
+          # separately — its NOT NULL directive is a positional `false`, not an
+          # options pair.)
           def column_method?(node)
-            node.method?(:add_column) || COLUMN_METHODS.include?(node.method_name)
+            node.method?(:add_column) ||
+              node.method?(:change_column) ||
+              COLUMN_METHODS.include?(node.method_name)
           end
         end
       end

data/lib/rubocop/cop/dev_doc/migration/boolean_column_not_null.rb

@@ -0,0 +1,122 @@
+module RuboCop
+  module Cop
+    module DevDoc
+      module Migration
+        # Boolean columns must carry `null: false`.
+        #
+        # ## Rationale
+        # `null: false` is reserved for cases where NULL has no meaningful
+        # interpretation — and a justified boolean is one of those cases.
+        # NULL is outside the column's stated domain of {true, false}: it
+        # is neither value, and every read site has to silently coerce it
+        # (`nil || false == false`) or risk a footgun.
+        #
+        # The line is drawn here for standardization and non-subjectivity.
+        # Whether a *regular* column should be present is a business
+        # decision open to debate (see `DevDoc/Migration/AvoidNonNull`),
+        # but once the developer has justified a boolean via
+        # `DevDoc/Migration/AvoidBooleanColumn`'s escape hatch, the
+        # boolean's non-null-ness is objective — it does not depend on
+        # any further business decision — so it is enforced mechanically
+        # rather than argued column-by-column.
+        #
+        # This cop is the inverse of `DevDoc/Migration/AvoidNonNull` for
+        # the boolean case: that cop flags `null: false` on regular
+        # columns (including booleans, which it cannot distinguish from
+        # other types); this cop REQUIRES `null: false` on booleans. The
+        # contradiction is resolved at the disable site: when the
+        # developer disables `AvoidNonNull` on a boolean with `-- boolean`
+        # (alongside the `AvoidBooleanColumn` disable), this cop fires if
+        # `null: false` is missing.
+        #
+        # ## Adding `null: false` to a table with existing rows
+        # Postgres refuses to add a NOT NULL column to a non-empty table
+        # without a backfill. Use the model-validations backfill pattern
+        # (sanctioned by `DevDoc/Migration/AvoidColumnDefault`):
+        #
+        #   def change
+        #     add_column :table, :flag, :boolean
+        #
+        #     reversible do |dir|
+        #       dir.up do
+        #         Table.reset_column_information
+        #         Table.where(flag: nil).find_each do |t|
+        #           t.flag = false
+        #           t.save!
+        #         end
+        #       end
+        #     end
+        #
+        #     # rubocop:disable DevDoc/Migration/AvoidNonNull -- boolean
+        #     change_column_null :table, :flag, false
+        #     # rubocop:enable DevDoc/Migration/AvoidNonNull
+        #   end
+        #
+        # The application layer is the source of truth for the default
+        # value on new records (e.g. via `after_initialize` or a factory).
+        # `default:` in the migration is still disallowed by
+        # `DevDoc/Migration/AvoidColumnDefault`.
+        #
+        # ## Interaction with AvoidBooleanColumn
+        # These two cops fire together on every boolean addition:
+        #
+        # - `AvoidBooleanColumn`: "reconsider using a boolean at all"
+        # - `BooleanColumnNotNull`: "if you do, it must be NOT NULL"
+        #
+        # Satisfy both by either changing the column type (timestamp /
+        # enum / model method) or, for a justified boolean, disabling
+        # `AvoidBooleanColumn` with `-- boolean` AND ensuring `null: false`
+        # is present so this cop does not fire.
+        #
+        # NOTE: This cop catches `t.boolean`, `add_column ..., :boolean`, and
+        # `change_column ..., :boolean` (a type change to boolean) without
+        # `null: false`. It does NOT scan `db/schema.rb` for legacy debt — it
+        # only enforces the invariant on declarations it can see. Existing
+        # nullable booleans are surfaced by inspection, not by this cop.
+        #
+        # @example
+        #   # bad - nullable boolean
+        #   add_column :users, :active, :boolean
+        #
+        #   # bad - nullable boolean in a create_table block
+        #   create_table :things do |t|
+        #     t.boolean :flag
+        #   end
+        #
+        #   # good - boolean carries null: false
+        #   # rubocop:disable DevDoc/Migration/AvoidBooleanColumn -- true binary preference
+        #   add_column :things, :flag, :boolean, null: false
+        #   # rubocop:enable DevDoc/Migration/AvoidBooleanColumn
+        class BooleanColumnNotNull < Base
+          MSG = 'Boolean columns must carry `null: false` — NULL is outside {true, false}. ' \
+                'Backfill existing rows via the model, then `change_column_null`.'.freeze
+
+          def_node_matcher :boolean_column?, <<~PATTERN
+            (send _ {:boolean} ...)
+          PATTERN
+
+          def_node_matcher :add_column_boolean?, <<~PATTERN
+            (send _ :add_column _ _ (sym :boolean) ...)
+          PATTERN
+
+          def_node_matcher :change_column_to_boolean?, <<~PATTERN
+            (send _ :change_column _ _ (sym :boolean) ...)
+          PATTERN
+
+          def_node_matcher :null_false_pair, <<~PATTERN
+            (hash <$(pair (sym :null) (false)) ...>)
+          PATTERN
+
+          def on_send(node)
+            return unless boolean_column?(node) || add_column_boolean?(node) || change_column_to_boolean?(node)
+
+            options = node.arguments.find(&:hash_type?)
+            return if options && null_false_pair(options)
+
+            add_offense(node)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/dev_doc/rails/application_record_transaction.rb

@@ -34,7 +34,10 @@ module RuboCop
         class ApplicationRecordTransaction < Base
           extend AutoCorrector
 
-          ALLOWED_RECEIVERS = %w[ApplicationRecord ActiveRecord::Base].freeze
+          # Source-string comparison, so the cbase-qualified spellings must be
+          # listed too — `::ApplicationRecord.transaction` was a false positive.
+          ALLOWED_RECEIVERS = %w[ApplicationRecord ::ApplicationRecord
+                                 ActiveRecord::Base ::ActiveRecord::Base].freeze
 
           MSG = 'Use `ApplicationRecord.transaction` instead of `%<receiver>s.transaction` outside model files.'.freeze
           RESTRICT_ON_SEND = %i[transaction].freeze

data/lib/rubocop/cop/dev_doc/rails/avoid_rails_callbacks.rb

@@ -115,12 +115,17 @@ module RuboCop
         #     send_confirmation if saved
         #   end
         class AvoidRailsCallbacks < Base
+          # Includes every *_commit shorthand and the underlying set_callback
+          # API — omitting any of them (after_update_commit was missed for a
+          # while) leaves a zero-effort spelling of the same callback.
           CALLBACKS = %i[
-            after_create after_create_commit after_save after_update
-            after_destroy after_commit after_rollback after_initialize
+            after_create after_create_commit after_save after_save_commit
+            after_update after_update_commit after_destroy after_destroy_commit
+            after_commit before_commit after_rollback after_initialize
             after_find after_touch before_create before_save before_update
             before_destroy before_validation after_validation
             around_create around_save around_update around_destroy
+            set_callback
           ].freeze
 
           MSG = 'Avoid `%<method>s` — extract an explicit method (e.g. `save_with_*`) ' \

data/lib/rubocop/cop/dev_doc/rails/bang_save_in_transaction.rb

@@ -64,7 +64,10 @@ module RuboCop
           MSG = 'Use `%<bang>s` inside a `transaction` block, or check its return value. ' \
                 'A non-bang call whose return value is discarded does not roll back the transaction on failure.'.freeze
 
-          FLAGGED_METHODS = %i[save update create].freeze
+          # destroy has the same failure mode: it returns false when a
+          # before_destroy callback aborts, and a discarded false does not
+          # roll the transaction back.
+          FLAGGED_METHODS = %i[save update create destroy].freeze
 
           # Node types whose parent always means the return value is consumed.
           CONSUMING_PARENT_TYPES = %i[
@@ -87,9 +90,11 @@ module RuboCop
 
           private
 
+          # with_lock opens a transaction too, so a discarded non-bang save
+          # inside it fails just as silently.
           def inside_transaction?(node)
             node.each_ancestor(:block).any? do |ancestor|
-              ancestor.method_name == :transaction
+              %i[transaction with_lock].include?(ancestor.method_name)
             end
           end
 

data/lib/rubocop/cop/dev_doc/rails/enum_must_be_symbolized.rb

@@ -32,6 +32,16 @@ module RuboCop
         #   ✔
         #   enum_symbolize :payment_status, :finalize_intent
         #
+        # Enums declared inside a concern's `included do` block are checked the
+        # same way — the pairing must live in the same `included do` block,
+        # which is also where it belongs so every includer gets both:
+        #
+        #   ✔
+        #   included do
+        #     enum :discount_type, DISCOUNT_TYPES
+        #     enum_symbolize :discount_type
+        #   end
+        #
         # @example
         #   # bad
         #   enum :status, { active: 0, archived: 1 }
@@ -51,24 +61,29 @@ module RuboCop
             (send nil? :enum_symbolize $...)
           PATTERN
 
+          def_node_matcher :included_block?, <<~PATTERN
+            (block (send nil? :included) (args) _)
+          PATTERN
+
           def on_class(node)
-            body = node.body
-            return unless body
+            check_body(node.body)
+          end
 
-            statements = body.begin_type? ? body.children : [body]
+          # Concern-declared enums: `included do ... end` runs in the including
+          # class's context, so its statements are checked like a class body.
+          def on_block(node)
+            return unless included_block?(node)
 
-            enum_decls = []
-            symbolized = []
+            check_body(node.body)
+          end
 
-            statements.each do |stmt|
-              next unless stmt.respond_to?(:send_type?) && stmt.send_type?
+          private
 
-              if (name = enum_call(stmt))
-                enum_decls << [name, stmt]
-              elsif (args = enum_symbolize_call(stmt))
-                symbolized.concat(args.select(&:sym_type?).map(&:value))
-              end
-            end
+          def check_body(body)
+            return unless body
+
+            statements = body.begin_type? ? body.children : [body]
+            enum_decls, symbolized = scan(statements)
 
             enum_decls.each do |name, decl|
               next if symbolized.include?(name)
@@ -76,6 +91,20 @@ module RuboCop
               add_offense(decl, message: format(MSG, name: name))
             end
           end
+
+          def scan(statements)
+            sends = statements.select { |stmt| stmt.respond_to?(:send_type?) && stmt.send_type? }
+            enum_decls = sends.filter_map { |stmt| (name = enum_call(stmt)) && [name, stmt] }
+            symbolized = sends.flat_map { |stmt| symbolized_names(stmt) }
+            [enum_decls, symbolized]
+          end
+
+          def symbolized_names(stmt)
+            args = enum_symbolize_call(stmt)
+            return [] unless args
+
+            args.select(&:sym_type?).map(&:value)
+          end
         end
       end
     end

data/lib/rubocop/cop/dev_doc/rails/no_block_predicate_on_relation.rb

@@ -104,7 +104,9 @@ module RuboCop
           MSG = '`%<method>s` with a block loads every row into Ruby. ' \
                 'Push the predicate into SQL with `.where(...)` or a model scope.'.freeze
 
-          RESTRICT_ON_SEND = %i[count reject select find any?].freeze
+          # filter/detect are the Ruby aliases of select/find — leaving them
+          # out would make the alias a zero-cost dodge.
+          RESTRICT_ON_SEND = %i[count reject select filter find detect any?].freeze
 
           # Methods whose return value is known to be a non-Relation collection
           # (Array, Hash, or Enumerator). When a `.select`/`.reject`/etc. with a
@@ -129,7 +131,7 @@ module RuboCop
           ].freeze
 
           def on_send(node)
-            return unless node.block_literal?
+            return unless node.block_literal? || symbol_block_pass?(node)
             return if node.receiver.nil?
             return if excluded_receiver?(node.receiver)
             return if excluded_block?(node)
@@ -139,6 +141,13 @@ module RuboCop
 
           private
 
+          # `reject(&:archived?)` loads every row exactly like the literal
+          # block form — one character shorter, so it must not be a dodge.
+          def symbol_block_pass?(node)
+            last = node.last_argument
+            last&.block_pass_type? && last.children.first&.sym_type?
+          end
+
           def excluded_receiver?(receiver)
             return true if receiver.array_type? || receiver.hash_type?
             return true if receiver.const_type? && screaming_case_const?(receiver)

data/lib/rubocop/cop/dev_doc/rails/no_deliver_later_in_transaction.rb

@@ -55,7 +55,10 @@ module RuboCop
         class NoDeliverLaterInTransaction < Base
           MSG = '`%<method>s` inside a `transaction` block may use stale data. Move it outside the transaction.'.freeze
 
-          CORE_METHODS = %i[deliver_later perform_later].freeze
+          # Also the bang form, the bulk API, and the enqueue primitive that
+          # perform_later wraps — each is an equally easy spelling of the same
+          # premature enqueue.
+          CORE_METHODS = %i[deliver_later deliver_later! perform_later perform_all_later enqueue].freeze
 
           def on_send(node)
             return unless inside_transaction?(node)
@@ -74,9 +77,11 @@ module RuboCop
             cop_config.fetch('KnownAsyncWrappers', [])
           end
 
+          # with_lock opens a transaction too (lock! inside a transaction
+          # block), so an enqueue inside it has the identical hazard.
           def inside_transaction?(node)
             node.each_ancestor(:block).any? do |ancestor|
-              ancestor.method_name == :transaction
+              %i[transaction with_lock].include?(ancestor.method_name)
             end
           end
         end

data/lib/rubocop/cop/dev_doc/rails/no_perform_later_in_model.rb

@@ -47,12 +47,16 @@ module RuboCop
         #     OrderJob.perform_later(self)
         #   end
         class NoPerformLaterInModel < Base
-          MSG = 'Avoid `perform_later` in model files. Call it from the controller, ' \
-                'or use an explicit method name to signal the side effect.'.freeze
-          RESTRICT_ON_SEND = %i[perform_later].freeze
+          MSG = 'Avoid `%<method>s` in model files — it enqueues an ActiveJob (mailer deliveries ' \
+                'included), with the same transaction/stale-data hazard as `perform_later`. Call it ' \
+                'from the controller, or use an explicit method name to signal the side effect.'.freeze
+          # deliver_later is ActiveJob under the hood (MailDeliveryJob) and
+          # enqueue is the primitive perform_later wraps — omitting either
+          # would leave an everyday spelling of the same async enqueue.
+          RESTRICT_ON_SEND = %i[perform_later perform_all_later deliver_later deliver_later! enqueue].freeze
 
           def on_send(node)
-            add_offense(node.loc.selector)
+            add_offense(node.loc.selector, message: format(MSG, method: node.method_name))
           end
         end
       end

data/lib/rubocop/cop/dev_doc/style/avoid_head_response.rb

@@ -60,7 +60,9 @@ module RuboCop
           ].freeze
 
           def on_send(node)
-            return unless node.receiver.nil?
+            # `self.head(...)` is the same controller call — a bare receiver
+            # check would make explicit-self a one-token dodge.
+            return unless node.receiver.nil? || node.receiver.self_type?
 
             status_node = node.arguments.first
             return unless status_node

data/lib/rubocop/cop/dev_doc/style/avoid_send.rb

@@ -62,7 +62,9 @@ module RuboCop
         class AvoidSend < Base
           MSG = "Avoid dynamic `%<method>s` — use bracket notation for model attributes, " \
                 "or a prefix (`obj.send(\"export_\#{x}\")`) to restrict callable methods.".freeze
-          RESTRICT_ON_SEND = %i[send public_send].freeze
+          # `__send__` is the canonical alias — omitting it would leave a
+          # zero-cost dodge for the exact dynamic dispatch this cop restricts.
+          RESTRICT_ON_SEND = %i[send public_send __send__].freeze
 
           def on_send(node)
             return if node.receiver.nil?

data/lib/rubocop/cop/dev_doc/style/literal_operator_in_condition.rb

@@ -0,0 +1,103 @@
+module RuboCop
+  module Cop
+    module DevDoc
+      module Style
+        # Flag `||` between literals in a boolean condition (`if`, `unless`,
+        # `while`, `until`, and ternary). The operator folds to one operand
+        # immediately (`:a || :b` is just `:a`), so the condition is constant —
+        # the branch (or loop body) always runs the same way, and the other
+        # literal is dead.
+        #
+        # ## Rationale
+        # `if :billing || :payments` reads like "either is truthy" but compiles
+        # to `if :billing` — always truthy. The author almost certainly meant a
+        # real comparison (`==`) or a variable, not two literal alternatives.
+        # Unlike `DevDoc/Style/LiteralOrInWhenClause`, a condition has no
+        # comma-form alternative, so the right fix depends on intent and is NOT
+        # autocorrected — the cop only flags.
+        #
+        # Scoped to `||` only: core `Lint/LiteralAsCondition` already catches
+        # literal `&&` chains and single literals, but misses `||` chains and
+        # ternaries — this cop fills exactly that gap with no overlap.
+        #
+        #   ❌ always truthy — :payments is dead
+        #   if :billing || :payments
+        #     charge
+        #   end
+        #
+        #   ✔️ a real comparison
+        #   if status == :billing || status == :payments
+        #     charge
+        #   end
+        #
+        # @example
+        #   # bad
+        #   x = (:a || :b) ? one : two
+        #
+        #   # good
+        #   x = (val == :a || val == :b) ? one : two
+        class LiteralOperatorInCondition < Base
+          MSG = '`%<source>s` always evaluates to `%<result>s`, so this condition is constant.'.freeze
+
+          LITERAL_TYPES = %i[sym str int float true false nil].freeze
+          FALSY_TYPES = %i[false nil].freeze
+
+          # `unless` desugars to `if` and the ternary `? :` is an `if` node, so a
+          # single on_if covers both (plus modifier forms). `until` mirrors
+          # `while` — both expose `condition`.
+          def on_if(node)
+            check(node.condition)
+          end
+
+          def on_while(node)
+            check(node.condition)
+          end
+
+          alias on_until on_while
+
+          private
+
+          def check(condition)
+            inner = unwrap_begin(condition)
+            return unless inner.or_type?
+
+            leaves = flatten_chain(inner)
+            return unless leaves.all? { |leaf| LITERAL_TYPES.include?(leaf.type) }
+
+            add_offense(
+              inner,
+              message: format(MSG, source: inner.source, result: fold(leaves).source)
+            )
+          end
+
+          # The helpers below parallel DevDoc/Style/LiteralOrInWhenClause
+          # (`||`-only here). Lift them into a shared module if a third consumer
+          # appears; duplicated for now to keep that cop untouched.
+
+          # Parentheses wrap a condition in a `begin` node; unwrap it.
+          def unwrap_begin(node)
+            node = node.children.first while node.begin_type?
+            node
+          end
+
+          # Flatten a homogeneous `||` chain into its operand nodes. An operand
+          # wrapped in parentheses arrives as a `begin` node (`(:a || :b) || :c`),
+          # so unwrap before recursing; otherwise the inner chain reads as a
+          # single non-literal leaf and slips past the all-literal check.
+          def flatten_chain(node)
+            node = unwrap_begin(node)
+            return [node] unless node.or_type?
+
+            flatten_chain(node.lhs) + flatten_chain(node.rhs)
+          end
+
+          # The first truthy literal the `||` chain folds to (or its last
+          # operand when the whole chain is nil/false).
+          def fold(leaves)
+            leaves.find { |leaf| !FALSY_TYPES.include?(leaf.type) } || leaves.last
+          end
+        end
+      end
+    end
+  end
+end