kube_schema 1.11.0 → 2.0.0

data/cops/no_conditional_assignment.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+# Bans assigning a conditional expression to a variable.
+#
+# @example
+#   status = case task.state                  # NO
+#            when :done then :ok
+#            else :pending
+#            end
+#   obj.status = cond ? :ok : :pending        # NO
+#
+# @example
+#   status = :pending                         # YES
+#   case task.state
+#   when :done
+#     status = :ok
+#   end
+module RuboCop
+  module Cop
+    module Local
+      class NoConditionalAssignment < Base
+        extend AutoCorrector
+
+        MSG = "Do not assign a `%<keyword>s` expression to a variable; " \
+              "assign inside each branch of the %<keyword>s."
+
+        CONDITIONAL_TYPES = %i[if case case_match].freeze
+
+        def on_lvasgn(node)
+          check(node, node.children.last)
+        end
+        alias on_ivasgn on_lvasgn
+        alias on_cvasgn on_lvasgn
+        alias on_gvasgn on_lvasgn
+        alias on_casgn on_lvasgn
+        alias on_op_asgn on_lvasgn
+        alias on_or_asgn on_lvasgn
+        alias on_and_asgn on_lvasgn
+        alias on_masgn on_lvasgn
+
+        def on_send(node)
+          if node.assignment_method?
+            check(node, node.last_argument)
+          end
+        end
+
+        private
+
+          def check(node, rhs)
+            if conditional?(rhs)
+              add_offense(node, message: format(MSG, keyword: keyword(rhs))) do |corrector|
+                if safe_to_push_inside?(node, rhs)
+                  corrector.replace(node, pushed_inside(node, rhs))
+                end
+              end
+            end
+          end
+
+          # The rewrite repeats the target per branch, so it must be side-effect free, on its own line, and free of heredocs.
+          def safe_to_push_inside?(node, rhs)
+            # `case/in` pattern matching is left alone — its branch headers are patterns, not expressions.
+            rhs.type != :case_match &&
+              own_line?(node) &&
+              simple_target?(node) &&
+              !contains_heredoc?(node) &&
+              branches(rhs).all? { |_cond, body| body.nil? || !body.source.include?("\n") }
+          end
+
+          def simple_target?(node)
+            case node.type
+            when :lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn
+              true
+            when :send
+              node.assignment_method? && node.arguments.one? && node.receiver&.type == :send &&
+                node.receiver.arguments.empty?
+            else
+              false
+            end
+          end
+
+          def own_line?(node)
+            line = processed_source.lines[node.first_line - 1].to_s
+            line[0...node.loc.column].strip.empty?
+          end
+
+          def contains_heredoc?(node)
+            node.each_descendant(:str, :dstr, :xstr).any? { |n| n.respond_to?(:heredoc?) && n.heredoc? }
+          end
+
+          # The assignment prefix repeated in every branch — "x = ", "@y = ", "obj.z = ".
+          def target_source(node)
+            if node.type == :send
+              "#{node.receiver.source}.#{node.method_name.to_s.chomp('=')} = "
+            else
+              "#{node.children.first} = "
+            end
+          end
+
+          # [[condition, body], ...] in source order; a nil condition is the `else`.
+          def branches(rhs)
+            if rhs.type == :if
+              if_branches(rhs)
+            else
+              case_branches(rhs)
+            end
+          end
+
+          def if_branches(node, acc = [])
+            cond, then_body, else_body = *node
+            acc << [cond.source, then_body]
+
+            if else_body&.type == :if && !else_body.ternary?
+              if_branches(else_body, acc)
+            else
+              acc << [nil, else_body]
+            end
+
+            acc
+          end
+
+          def case_branches(node)
+            node.when_branches.map { |w| [w, w.body] } + [[nil, node.else_branch]]
+          end
+
+          def pushed_inside(node, rhs)
+            indent = " " * node.loc.column
+            target = target_source(node)
+
+            if rhs.type == :if
+              rendered_if(rhs, indent, target)
+            else
+              rendered_case(rhs, indent, target)
+            end
+          end
+
+          def rendered_if(rhs, indent, target)
+            parts = if_branches(rhs).each_with_index.map { |(cond, body), i|
+              if cond.nil?
+                header = "#{indent}else"
+              elsif i.zero?
+                header = "#{indent}if #{cond}"
+              else
+                header = "#{indent}elsif #{cond}"
+              end
+
+              "#{header}\n#{indent}  #{target}#{body ? body.source : 'nil'}"
+            }
+
+            # The replacement begins at the node's own column, so the first line must NOT carry the indent again.
+            "#{parts.join("\n").sub(/\A#{indent}/, '')}\n#{indent}end"
+          end
+
+          def rendered_case(rhs, indent, target)
+            head = ["case", rhs.condition&.source].compact.join(" ")
+
+            parts = rhs.when_branches.map { |w|
+              conditions = w.conditions.map(&:source).join(", ")
+              "#{indent}when #{conditions}\n#{indent}  #{target}#{w.body ? w.body.source : 'nil'}"
+            }
+            else_body = rhs.else_branch
+            parts << "#{indent}else\n#{indent}  #{target}#{else_body ? else_body.source : 'nil'}"
+
+            "#{head}\n#{parts.join("\n")}\n#{indent}end"
+          end
+
+          def conditional?(rhs)
+            rhs.is_a?(RuboCop::AST::Node) &&
+              CONDITIONAL_TYPES.include?(rhs.type)
+          end
+
+          # `keyword` is "" on a ternary — it has no `if` token to point at.
+          def keyword(rhs)
+            if rhs.type == :if
+              if rhs.ternary?
+                "ternary"
+              else
+                rhs.keyword
+              end
+            else
+              "case"
+            end
+          end
+      end
+    end
+  end
+end

data/cops/no_console_logging.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# Bans logging straight at the `Console` singleton.
+#
+# @example
+#   Console.info(self, "started", id: 1)          # NO
+#   Console.logger.warn(self, "slow")             # NO
+#   Console.debug(self) { "expensive" }           # NO
+#
+# @example
+#   Rails.logger.info("started")                  # YES
+module RuboCop
+  module Cop
+    module Local
+      class NoConsoleLogging < Base
+        MSG = "Do not log through `Console` directly; use `Rails.logger.%<level>s` " \
+              "so logging goes through Console::Adapter::Rails (tags, silencing, config)."
+
+        MSG_LOGGER = "Do not reach for `Console.logger`; use `Rails.logger`, which " \
+                     "console-adapter-rails already backs with Console."
+
+        # Console's severity methods, plus `call`, its lowest-level entry point.
+        LEVELS = %i[debug info warn error fatal call].freeze
+
+        def on_send(node)
+          if console_logger?(node)
+            add_offense(node, message: MSG_LOGGER)
+          elsif LEVELS.include?(node.method_name) && console_receiver?(node.receiver)
+            add_offense(node, message: format(MSG, level: node.method_name))
+          end
+        end
+
+        private
+
+          # `Console.logger`, but NOT the `Console.logger` inside a `Console.logger.info(...)` — that whole call is reported once, as a level offence, rather than twice.
+          def console_logger?(node)
+            node.method_name == :logger &&
+              const_console?(node.receiver) &&
+              !level_call_on?(node)
+          end
+
+          # Is `node` the receiver of a level call, i.e. the `Console.logger` in `Console.logger.info(...)`?
+          def level_call_on?(node)
+            parent = node.parent
+
+            parent&.send_type? && parent.receiver.equal?(node) && LEVELS.include?(parent.method_name)
+          end
+
+          # The receiver of a level call: `Console` itself or `Console.logger`.
+          def console_receiver?(receiver)
+            const_console?(receiver) ||
+              (receiver&.send_type? && receiver.method_name == :logger && const_console?(receiver.receiver))
+          end
+
+          # `Console` or `::Console` — and nothing nested, so a `Foo::Console` of your own is left alone.
+          def const_console?(node)
+            node&.const_type? && node.short_name == :Console && (node.namespace.nil? || node.namespace.cbase_type?)
+          end
+      end
+    end
+  end
+end

data/cops/no_modifier_if.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# Bans the modifier `if` / `unless` form.
+#
+# @example
+#   return true if task.state_task_completed?     # NO
+#
+# @example
+#   if task.state_task_completed?                 # YES
+#     return true
+#   end
+module RuboCop
+  module Cop
+    module Local
+      class NoModifierIf < Base
+        extend AutoCorrector
+
+        MSG = "Do not use modifier `%<keyword>s`; use the full `%<keyword>s ... end` block form."
+
+        def on_if(node)
+          if node.modifier_form?
+            add_offense(node, message: format(MSG, keyword: node.keyword)) do |corrector|
+              if safe_to_unwrap?(node)
+                corrector.replace(node, block_form(node))
+              end
+            end
+          end
+        end
+
+        private
+
+          # A modifier that is not the whole statement, or that contains a heredoc, is left alone.
+          def safe_to_unwrap?(node)
+            own_line?(node) && !contains_heredoc?(node)
+          end
+
+          def own_line?(node)
+            line = processed_source.lines[node.first_line - 1].to_s
+            line[0...node.loc.column].strip.empty?
+          end
+
+          def contains_heredoc?(node)
+            node.each_descendant(:str, :dstr, :xstr).any? { |n| n.respond_to?(:heredoc?) && n.heredoc? }
+          end
+
+          def block_form(node)
+            indent = " " * node.loc.column
+            body   = node.if_branch || node.else_branch
+
+            "#{node.keyword} #{node.condition.source}\n" \
+              "#{reindent(body, indent)}\n" \
+              "#{indent}end"
+          end
+
+          # Move the body to a new indent, shifting later lines by the delta so the body's shape survives.
+          def reindent(node, indent)
+            target = indent.length + 2
+            delta  = target - node.loc.column
+            lines  = node.source.lines
+
+            rest = lines[1..].to_a.map { |line|
+              if delta.negative?
+                line.chomp.sub(/\A {0,#{-delta}}/, "")
+              else
+                "#{' ' * delta}#{line.chomp}"
+              end
+            }
+
+            [("#{' ' * target}#{lines.first.chomp}")].concat(rest).join("\n")
+          end
+      end
+    end
+  end
+end

data/cops/no_return.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+# Bans the `return` keyword. A method's last expression is its return value;
+# early exits must be expressed through `if` / `unless` / `case` structure,
+# not by short-circuiting out of the middle of a block.
+#
+# Autocorrection handles ONE shape — the guard clause at the top level of a
+# method body:
+#
+#   if cond          →    if cond
+#     return X              X
+#   end                   else
+#   rest                    rest
+#                         end
+#
+# Everything else (a `return` inside a block, a loop, or a `rescue`) is left
+# alone: unwinding those changes which construct the value escapes from, and
+# there is no rewrite that is correct without reading the surrounding intent.
+module RuboCop
+  module Cop
+    module Local
+      class NoReturn < Base
+        extend AutoCorrector
+
+        MSG = "Do not use `return`; let the method's last expression be the return value."
+
+        def on_new_investigation
+          super
+          # One guard per body per pass — two corrections inside the same body
+          # would overlap and clobber each other. `rubocop -a` re-runs the cop
+          # until it stops changing anything, so chained guards still unwind,
+          # one per pass.
+          @corrected_bodies = {}
+        end
+
+        def on_return(node)
+          add_offense(node) do |corrector|
+            guard = correctable_guard(node)
+            if guard
+              body, index = guard
+              if @corrected_bodies[body.object_id].nil?
+                @corrected_bodies[body.object_id] = true
+                corrector.replace(replaced_range(body, index), rewritten(body, index))
+              end
+            end
+          end
+        end
+
+        private
+
+          # Returns [body_node, index_of_guard] when +node+ is the whole body of
+          # an `if`/`unless` that is itself a plain statement in a method body
+          # with at least one statement after it. Otherwise nil.
+          def correctable_guard(node)
+            if_node = node.parent
+
+            if if_node.nil? || if_node.type != :if || if_node.modifier_form? ||
+               if_node.ternary? || if_node.elsif? || node != if_node.if_branch ||
+               if_node.else_branch
+              nil
+            else
+              body = if_node.parent
+              if body.nil? || body.type != :begin || !tail_position?(body)
+                nil
+              else
+                index = body.children.index(if_node)
+                if index.nil? || index == body.children.size - 1
+                  nil
+                else
+                  [body, index]
+                end
+              end
+            end
+          end
+
+          # "Everything after the guard" is only the method's value if this
+          # statement list is in TAIL position — the method body itself, or a
+          # branch of a conditional that is itself in tail position (which is
+          # what a chain of guards unwinds into, one pass at a time).
+          #
+          # Recursion stops at anything else, and in particular at a `block`: a
+          # `return` inside one exits the enclosing METHOD, not the block, so
+          # turning it into a trailing value would change what the block yields.
+          # `rescue` / `ensure` bodies stop it too.
+          def tail_position?(node)
+            parent = node.parent
+
+            if parent.nil?
+              false
+            elsif %i[def defs].include?(parent.type)
+              parent.body == node
+            elsif parent.type == :if && !parent.ternary?
+              (node == parent.if_branch || node == parent.else_branch) && tail_position?(parent)
+            elsif parent.type == :begin
+              node == parent.children.last && tail_position?(parent)
+            else
+              false
+            end
+          end
+
+          def replaced_range(body, index)
+            body.children[index].source_range.join(body.children.last.source_range)
+          end
+
+          def rewritten(body, index)
+            if_node = body.children[index]
+            indent  = " " * if_node.loc.column
+            guarded = if_node.if_branch.children.first # the return's value, or nil
+            rest    = body.children[(index + 1)..]
+
+            if guarded
+              guard_value = reindent(guarded, indent)
+            else
+              guard_value = "#{indent}  nil"
+            end
+            rest_source = rest.map { |s| reindent(s, indent) }.join("\n")
+
+            # `unless cond / return X / end` means "X unless cond", so the
+            # branches swap rather than the condition being negated.
+            if if_node.keyword == "unless"
+              first, second = rest_source, guard_value
+            else
+              first, second = guard_value, rest_source
+            end
+
+            "if #{if_node.condition.source}\n#{first}\n#{indent}else\n#{second}\n#{indent}end"
+          end
+
+          # Move a statement to a new indent. Only line 1 is positioned
+          # absolutely — `source` has already stripped its leading whitespace.
+          # Lines 2..n still carry their ORIGINAL absolute indentation, so they
+          # get shifted by the delta instead, which is what keeps a multi-line
+          # body's internal shape intact.
+          def reindent(node, indent)
+            target = indent.length + 2
+            delta  = target - node.loc.column
+            lines  = node.source.lines
+
+            rest = lines[1..].to_a.map { |line|
+              if delta.negative?
+                line.chomp.sub(/\A {0,#{-delta}}/, "")
+              else
+                "#{' ' * delta}#{line.chomp}"
+              end
+            }
+
+            [("#{' ' * target}#{lines.first.chomp}")].concat(rest).join("\n")
+          end
+      end
+    end
+  end
+end