rubocop-nathank 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d1cbe27ef830beab287c9fe5f094cb0779bd11624b305c70c5dc9cf213c06693
+  data.tar.gz: d2056f2799a73989349c29d89cde6437d79d4084043325176bb6162ddc55c20f
+SHA512:
+  metadata.gz: f56ce9201f12e91a550d6024fdeffb1d7bef352e1424b1577ddc6b6cfa17cbfc6566d9ec2536cc12cea23c94df7e4f68b2cf20216fe1726e35dd3e7e0053fd62
+  data.tar.gz: b5c2e4a4460a4c06713cd78f98bd04688cac75acdce2faf4d08c13d4f598021720b69b4557ca9acae7aa022b193d133c92f6fdc61626cac251d2961dd98df6a9

data/CHANGELOG.md

@@ -0,0 +1,30 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [1.0.0] - 2026-10-27
+
+### Added
+
+- `lib/rubocop/nathank.rb` now `require "rubocop"` itself, so loading the plugin
+  no longer assumes RuboCop has already been required.
+
+### Changed
+
+- Gem renamed from `rubocop-nathan-k` to `rubocop-nathank`. Update `bundle add`
+  and the `plugins:` entry in `.rubocop.yml` to the new name.
+- Department renamed from `NathanK` to `Nathank`. Rename any `.rubocop.yml`
+  entries accordingly: `Nathank/BeginBlockAssignment`, `Nathank/CommentStructure`,
+  `Nathank/NoConditionalAssignment`, `Nathank/NoModifierIf`, `Nathank/NoReturn`,
+  `Nathank/SingleLineMethodsForEvents`, `Nathank/UseTap`.
+- Namespace renamed from `RuboCop::NathanK` to `RuboCop::Nathank`; the
+  lint_roller plugin class is now `RuboCop::Nathank::Plugin`, referenced by the
+  gemspec's `default_lint_roller_plugin` metadata.
+
+[Unreleased]: https://github.com/n-at-han-k/rubocop-nathank/compare/v1.0.0...HEAD
+[1.0.0]: https://github.com/n-at-han-k/rubocop-nathank/releases/tag/v1.0.0

data/lib/rubocop/nathank/begin_block_assignment.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# Released under the Apache License, Version 2.0.
+# Copyright, 2026, by General Intelligence Systems.
+
+# Flags a `begin ... end` assigned to a variable.
+#
+# @example
+#   begin
+#     lvar = ...
+#   end
+
+require_relative "support/prism_source"
+
+module RuboCop
+  module Nathank
+    class BeginBlockAssignment < ::RuboCop::Cop::Base
+      include PrismSource
+
+      MSG = "Do not assign a `begin...end` expression to a variable; " \
+            "move the assignment inside the begin block."
+
+      # Every way a variable is written to with a single value on the right.
+      WRITES = [
+        ::Prism::LocalVariableWriteNode,
+        ::Prism::InstanceVariableWriteNode,
+        ::Prism::ClassVariableWriteNode,
+        ::Prism::GlobalVariableWriteNode,
+      ].freeze
+
+      def on_new_investigation
+        self.prism_each(*WRITES).each do |node|
+          if node.value.is_a?(::Prism::BeginNode)
+            add_offense(self.prism_node_range(node))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/nathank/comment_structure.rb

@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+# Released under the Apache License, Version 2.0.
+# Copyright, 2026, by General Intelligence Systems.
+
+# Checks the structure of a comment, which decode parses into three parts: the summary, the annotations, and the summary belonging to each annotation.
+#
+# @example
+#   # Connect to the given endpoint, returning the HTTP client and reference.   <- summary
+#   # @parameter endpoint [Endpoint] used to connect to the remote system.      <- annotation
+#   # @returns [Tuple(Client, Reference)] the client and reference.
+#
+# Four things are checked, each measured against how async-rest, async-discord and async-ollama document themselves:
+#
+# A paragraph occupies one line. None of the 99 summary paragraphs in those three projects is wrapped, and async-rest's run to 544 characters.
+#
+# A summary is short, and no longer than the code it describes earns. Across 76 documented methods the median summary is 4 to 9 words whatever the length of the method, so the allowance starts at ten words and grows by three per line of body, to a ceiling of thirty.
+#
+# A module's summary is ten words or fewer. The only commented module in async-rest is exactly ten.
+#
+# A documented method says what it takes and returns. A summary with no annotations describes the method in prose and leaves the signature undocumented, which is what annotations are for. A method with no comment at all is not this cop's business: that is documentation coverage, which decode reports on separately.
+#
+# Nothing here is corrected automatically. A comment which breaks these rules has to be rewritten rather than reflowed, and a correction which only moved the words around would hide that.
+#
+# Each check is configured on its own, because they are not all worth applying everywhere:
+#
+# @example
+#   Local/CommentStructure:
+#     Annotations:
+#       Include:
+#         - "lib/**/*.rb"
+#     Length:
+#       Exclude:
+#         - "bin/**/*"
+#     Wrapping:
+#       Enabled: true
+#
+# A check with no `Include` runs everywhere; given one, it runs only where a path matches. `Exclude` then removes paths from whatever is left. `Annotations` defaults to `lib` alone: a script in `bin` and a case in `test` have no interface for anyone else to call, so annotating them documents nothing.
+#
+# What a declaration says is read from the run of comment lines touching it. Where an offence is reported is read from the wider span the library attributes to the declaration, less any magic comment, because decode reports a part's position within that span rather than the line it came from.
+
+require "decode/language/ruby/generic"
+
+require_relative "support/prism_source"
+
+module RuboCop
+  module Nathank
+    class CommentStructure < ::RuboCop::Cop::Base
+      include PrismSource
+
+      MSG_WRAPPED_SUMMARY = "Do not wrap a summary paragraph: a paragraph is one line, however long."
+
+      MSG_WRAPPED_ANNOTATION = "Do not wrap the summary of `@%<directive>s`: an annotation's summary is one line."
+
+      MSG_TOO_LONG = "This summary is %<words>d words; %<allowed>d is the most %<subject>s may have."
+
+      MSG_NO_ANNOTATIONS = "This method is described in prose but its parameters and return value are not: document them with annotations, or say nothing."
+
+      TAGS = Decode::Language::Ruby::Generic::TAGS
+
+      # Each check, and the paths it applies to when the configuration names none.
+      CHECKS = {
+        "Wrapping" => nil,
+        "Length" => nil,
+        "Annotations" => ["lib/**/*.rb"].freeze,
+      }.freeze
+
+      GLOB = File::FNM_PATHNAME | File::FNM_EXTGLOB
+
+      HEADER = /\A#\s*(frozen_string_literal:|Released under|Copyright,|!)/
+
+      # What a Ruby file says to the interpreter rather than to a reader.
+      MAGIC = /\A#\s*(frozen_string_literal:|encoding:|coding:|warn_indent:|shareable_constant_value:|!|-\*-)/
+
+      TERMINAL = [".", ":", "?", "!"].freeze
+
+      # Multi-line content is the point of these, so their summaries are left alone.
+      FREEFORM = [Decode::Comment::Example].freeze
+
+      def on_new_investigation
+        if self.applies?("Wrapping")
+          self.blocks.each do |block|
+            self.check_wrapping(block)
+          end
+        end
+
+        if self.applies?("Length")
+          self.prism_each(::Prism::ModuleNode).each do |node|
+            self.check_summary(node, "a module summary", self.cop_config.fetch("ModuleWords", 10))
+          end
+
+          self.prism_each(::Prism::ClassNode).each do |node|
+            self.check_summary(node, "a class summary", self.cop_config.fetch("MaximumWords", 30))
+          end
+        end
+
+        self.prism_each(::Prism::DefNode).each do |node|
+          self.check_method(node)
+        end
+      end
+
+      private
+
+      # Whether a check applies to the file being inspected.
+      def applies?(check)
+        configuration = self.cop_config[check] || {}
+
+        if configuration["Enabled"] == false
+          false
+        else
+          path = ::RuboCop::PathUtil.relative_path(processed_source.file_path.to_s)
+
+          included = configuration["Include"] || CHECKS.fetch(check)
+          excluded = configuration["Exclude"] || []
+
+          self.matches?(path, included, true) and !self.matches?(path, excluded, false)
+        end
+      end
+
+      # @parameter default [Boolean] what an absent or empty list of patterns means.
+      def matches?(path, patterns, default)
+        if patterns.nil? or patterns.empty?
+          default
+        else
+          patterns.any?{|pattern| File.fnmatch?(pattern, path, GLOB)}
+        end
+      end
+
+      def check_method(node)
+        lines = node.location.end_line - node.location.start_line + 1
+        base = self.cop_config.fetch("BaseWords", 10)
+        per_line = self.cop_config.fetch("WordsPerLine", 3)
+        ceiling = self.cop_config.fetch("MaximumWords", 30)
+
+        allowed = [base + (per_line * lines), ceiling].min
+
+        if self.applies?("Length")
+          self.check_summary(node, "a summary of #{lines} #{lines == 1 ? "line" : "lines"} of code", allowed)
+        end
+
+        if self.applies?("Annotations")
+          self.check_annotations(node)
+        end
+      end
+
+      # The comment which documents a declaration, as the parts decode reads it as.
+      def parts_of(node)
+        comments = self.documenting(node)
+
+        if comments.empty?
+          nil
+        else
+          self.parse(comments)
+        end
+      end
+
+      # The comment above a declaration, without the file's own header.
+      def documenting(node)
+        self.prism_leading_comments(node).reject{|comment| self.prism_source(comment).match?(HEADER)}
+      end
+
+      # Every comment the declaration owns, which is what the parts are indexed against.
+      def owned(node)
+        self.prism_owned_comments(node).drop_while{|comment| self.prism_source(comment).match?(MAGIC)}
+      end
+
+      def check_summary(node, subject, allowed)
+        parts = self.parts_of(node)
+
+        if parts
+          summary = parts.map(&:first).grep(Decode::Comment::Text)
+          words = summary.sum{|text| text.line.split.size}
+
+          if words > allowed
+            message = format(MSG_TOO_LONG, words: words, allowed: allowed, subject: subject)
+
+            add_offense(self.summary_range(node, parts, summary.first), message: message)
+          end
+        end
+      end
+
+      def check_annotations(node)
+        parts = self.parts_of(node)
+
+        if parts and parts.any?{|part, _| part.is_a?(Decode::Comment::Text)}
+          annotations = parts.map(&:first).reject{|part| part.is_a?(Decode::Comment::Text)}
+
+          if annotations.empty?
+            add_offense(self.prism_range(node.name_loc), message: MSG_NO_ANNOTATIONS)
+          end
+        end
+      end
+
+      # Consecutive comment lines: a block is what documents one thing, so a wrap can only happen inside one.
+      def blocks
+        [].tap do |found|
+          current = []
+
+          self.prism_comments.each do |comment|
+            text = self.prism_source(comment)
+
+            if text.match?(HEADER) or text.start_with?("# rubocop:")
+              next
+            end
+
+            if current.empty? or comment.location.start_line == current.last.location.start_line + 1
+              current << comment
+            else
+              found << current
+              current = [comment]
+            end
+          end
+
+          unless current.empty?
+            found << current
+          end
+        end
+      end
+
+      def check_wrapping(block)
+        nodes = self.parse(block)
+
+        nodes.each_with_index do |(node, lines), index|
+          if node.is_a?(Decode::Comment::Text)
+            following = nodes[index + 1]&.first
+
+            if following.is_a?(Decode::Comment::Text) and !self.terminated?(node.line)
+              add_offense(self.prism_range(block[lines.first.first].location), message: MSG_WRAPPED_SUMMARY)
+            end
+          elsif !FREEFORM.include?(node.class)
+            summary = lines.drop(1).reject{|line| line.last.strip.start_with?("@")}
+
+            if summary.size > 1
+              message = format(MSG_WRAPPED_ANNOTATION, directive: node.directive)
+
+              add_offense(self.prism_range(block[summary.first.first].location), message: message)
+            end
+          end
+        end
+      end
+
+      # decode consumes the lines it parses and does not report where they came from, so they are handed over through something which records what it gave away.
+      def parse(block)
+        source = Consumable.new(block.each_with_index.map{|comment, index| [index, self.text_of(comment)]})
+        nodes = []
+        cursor = 0
+
+        TAGS.parse(source) do |node|
+          if node
+            nodes << [node, source.log[cursor..]]
+            cursor = source.log.size
+          end
+        end
+
+        nodes
+      end
+
+      # The comment without its `#`, keeping the indentation which tells decode what is nested.
+      def text_of(comment)
+        self.prism_source(comment).sub(/\A#\s?/, "")
+      end
+
+      # Where to report a summary which is too long: the comment line it starts on, or the declaration itself when the summary cannot be traced back to one.
+      def summary_range(node, parts, text)
+        comments = self.owned(node)
+        entry = text && parts.find{|part, _| part.equal?(text)}
+
+        if entry and comments[entry.last.first.first]
+          self.prism_range(comments[entry.last.first.first].location)
+        else
+          self.prism_node_range(node)
+        end
+      end
+
+      def terminated?(line)
+        text = line.strip
+
+        text.empty? or TERMINAL.any?{|mark| text.end_with?(mark)}
+      end
+
+      # What decode shifts lines off, which remembers them.
+      class Consumable
+        def initialize(entries)
+          @entries = entries
+          @log = []
+        end
+
+        attr :log
+
+        def first = @entries.first&.last
+
+        def shift
+          entry = @entries.shift
+
+          if entry
+            @log << entry
+            entry.last
+          end
+        end
+
+        def empty? = @entries.empty?
+      end
+    end
+  end
+end

data/lib/rubocop/nathank/config.yaml

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# This is the default configuration file for rubocop-nathank.
+# You can override any of these settings in your .rubocop.yml file.
+
+Nathank/BeginBlockAssignment:
+  Description: "Bans assigning a `begin...end` expression; the assignment goes inside the block."
+  Enabled: true
+  VersionAdded: "0.1.0"
+
+Nathank/CommentStructure:
+  Description: "How a comment is built: unwrapped paragraphs, a summary no longer than the code earns, and annotations on a documented interface."
+  Enabled: true
+  VersionAdded: "0.1.0"
+  MaximumWords: 30
+  BaseWords: 10
+  WordsPerLine: 3
+  ModuleWords: 10
+  Wrapping:
+    Enabled: true
+  Length:
+    Enabled: true
+  Annotations:
+    Enabled: true
+    Include:
+      - "lib/**/*.rb"
+      - "fixtures/**/*.rb"
+
+Nathank/NoConditionalAssignment:
+  Description: "Bans assigning an `if` / `case` expression; assign inside each branch instead."
+  Enabled: true
+  VersionAdded: "0.1.0"
+
+Nathank/NoModifierIf:
+  Description: "Bans modifier `if` / `unless`, so a guard cannot hide off the right edge of a long line."
+  Enabled: true
+  VersionAdded: "0.1.0"
+
+Nathank/NoReturn:
+  Description: "Bans `return`. The method's last expression is its return value, and guards are structural."
+  Enabled: true
+  VersionAdded: "0.1.0"
+
+Nathank/SingleLineMethodsForEvents:
+  Description: "A one-expression method body uses the endless form."
+  Enabled: true
+  VersionAdded: "0.1.0"
+
+Nathank/UseTap:
+  Description: "Requires `tap` where a method assigns a local on its first line and returns it on its last."
+  Enabled: true
+  VersionAdded: "0.1.0"

data/lib/rubocop/nathank/no_conditional_assignment.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+# Released under the Apache License, Version 2.0.
+# Copyright, 2026, by General Intelligence Systems.
+
+# Bans assigning an `if` / `unless` / `case` expression.
+#
+# @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
+
+require_relative "support/prism_source"
+
+module RuboCop
+  module Nathank
+    class NoConditionalAssignment < ::RuboCop::Cop::Base
+      include PrismSource
+      extend ::RuboCop::Cop::AutoCorrector
+
+      MSG = "Do not assign a `%<keyword>s` expression to a variable; " \
+            "assign inside each branch of the %<keyword>s."
+
+      # Every way a name is written to with a single value on the right.
+      WRITES = [
+        ::Prism::ClassVariableAndWriteNode,
+        ::Prism::ClassVariableOperatorWriteNode,
+        ::Prism::ClassVariableOrWriteNode,
+        ::Prism::ClassVariableWriteNode,
+        ::Prism::ConstantAndWriteNode,
+        ::Prism::ConstantOperatorWriteNode,
+        ::Prism::ConstantOrWriteNode,
+        ::Prism::ConstantPathAndWriteNode,
+        ::Prism::ConstantPathOperatorWriteNode,
+        ::Prism::ConstantPathOrWriteNode,
+        ::Prism::ConstantPathWriteNode,
+        ::Prism::ConstantWriteNode,
+        ::Prism::GlobalVariableAndWriteNode,
+        ::Prism::GlobalVariableOperatorWriteNode,
+        ::Prism::GlobalVariableOrWriteNode,
+        ::Prism::GlobalVariableWriteNode,
+        ::Prism::InstanceVariableAndWriteNode,
+        ::Prism::InstanceVariableOperatorWriteNode,
+        ::Prism::InstanceVariableOrWriteNode,
+        ::Prism::InstanceVariableWriteNode,
+        ::Prism::LocalVariableAndWriteNode,
+        ::Prism::LocalVariableOperatorWriteNode,
+        ::Prism::LocalVariableOrWriteNode,
+        ::Prism::LocalVariableWriteNode,
+        ::Prism::MultiWriteNode,
+      ].freeze
+
+      # The writes whose target is a plain name, and so can be repeated in every branch.
+      SIMPLE = [
+        ::Prism::ClassVariableWriteNode,
+        ::Prism::ConstantWriteNode,
+        ::Prism::GlobalVariableWriteNode,
+        ::Prism::InstanceVariableWriteNode,
+        ::Prism::LocalVariableWriteNode,
+      ].freeze
+
+      CONDITIONALS = [
+        ::Prism::CaseMatchNode,
+        ::Prism::CaseNode,
+        ::Prism::IfNode,
+        ::Prism::UnlessNode,
+      ].freeze
+
+      def on_new_investigation
+        self.prism_each(*WRITES).each do |node|
+          self.check(node, node.value)
+        end
+
+        self.prism_each(::Prism::CallNode).each do |node|
+          if self.assignment_method?(node)
+            self.check(node, self.last_argument(node))
+          end
+        end
+      end
+
+      private
+
+      def check(node, rhs)
+        if self.conditional?(rhs)
+          range = self.prism_node_range(node)
+
+          add_offense(range, message: format(MSG, keyword: self.keyword(rhs))) do |corrector|
+            if self.safe_to_push_inside?(node, rhs)
+              corrector.replace(range, self.pushed_inside(node, rhs))
+            end
+          end
+        end
+      end
+
+      def conditional?(rhs)
+        !rhs.nil? && CONDITIONALS.any?{|klass| rhs.is_a?(klass)}
+      end
+
+      # `obj.status = value` is a call whose name ends in `=`.
+      def assignment_method?(node)
+        node.name.to_s.end_with?("=") && !node.name.to_s.end_with?("==") && !node.arguments.nil?
+      end
+
+      def last_argument(node)
+        node.arguments&.arguments&.last
+      end
+
+      # The target must be re-evaluable without side effects.
+      def safe_to_push_inside?(node, rhs)
+        # `case/in` pattern matching is left alone — its branch headers are patterns, not expressions, and reproducing them is a different job.
+        !rhs.is_a?(::Prism::CaseMatchNode) &&
+          self.own_line?(node) &&
+          self.simple_target?(node) &&
+          !self.prism_heredoc?(node) &&
+          self.branches(rhs).all?{|_condition, body| body.nil? || !self.prism_source(body).include?("\n")}
+      end
+
+      def simple_target?(node)
+        if SIMPLE.any?{|klass| node.is_a?(klass)}
+          true
+        elsif node.is_a?(::Prism::CallNode)
+          receiver = node.receiver
+
+          node.arguments&.arguments&.one? &&
+            receiver.is_a?(::Prism::CallNode) &&
+            (receiver.arguments.nil? || receiver.arguments.arguments.empty?)
+        else
+          false
+        end
+      end
+
+      def own_line?(node)
+        line = processed_source.lines[node.location.start_line - 1].to_s
+
+        line[0...self.prism_column(node)].strip.empty?
+      end
+
+      # The assignment prefix repeated in every branch — "x = ", "@y = ", "obj.z = ".
+      def target_source(node)
+        if node.is_a?(::Prism::CallNode)
+          "#{self.prism_source(node.receiver)}.#{node.name.to_s.chomp("=")} = "
+        else
+          "#{node.name} = "
+        end
+      end
+
+      # Each branch as `[condition_source, body_node]`, in source order.
+      def branches(rhs)
+        if rhs.is_a?(::Prism::CaseNode) || rhs.is_a?(::Prism::CaseMatchNode)
+          self.case_branches(rhs)
+        else
+          self.if_branches(rhs)
+        end
+      end
+
+      def if_branches(node, acc = [])
+        acc << [self.prism_source(node.predicate), node.statements]
+
+        following = self.else_branch(node)
+
+        if following.is_a?(::Prism::IfNode) && !self.ternary?(following)
+          self.if_branches(following, acc)
+        else
+          acc << [nil, following.is_a?(::Prism::ElseNode) ? following.statements : following]
+        end
+
+        acc
+      end
+
+      def case_branches(node)
+        node.conditions.map{|when_node| [when_node, when_node.statements]} +
+          [[nil, node.else_clause&.statements]]
+      end
+
+      # What follows the then-branch: an `else`, or a chained `elsif`.
+      def else_branch(node)
+        if node.is_a?(::Prism::UnlessNode)
+          node.else_clause
+        else
+          node.subsequent
+        end
+      end
+
+      def pushed_inside(node, rhs)
+        indent = " " * self.prism_column(node)
+        target = self.target_source(node)
+
+        if rhs.is_a?(::Prism::CaseNode)
+          self.rendered_case(rhs, indent, target)
+        else
+          self.rendered_if(rhs, indent, target)
+        end
+      end
+
+      def rendered_if(rhs, indent, target)
+        parts = self.if_branches(rhs).each_with_index.map{|(condition, body), index|
+          if condition.nil?
+            header = "#{indent}else"
+          elsif index.zero?
+            header = "#{indent}if #{condition}"
+          else
+            header = "#{indent}elsif #{condition}"
+          end
+
+          "#{header}\n#{indent}  #{target}#{body ? self.prism_source(body) : "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.predicate && self.prism_source(rhs.predicate)].compact.join(" ")
+
+        parts = rhs.conditions.map{|when_node|
+          conditions = when_node.conditions.map{|condition| self.prism_source(condition)}.join(", ")
+
+          "#{indent}when #{conditions}\n#{indent}  #{target}#{when_node.statements ? self.prism_source(when_node.statements) : "nil"}"
+        }
+        else_body = rhs.else_clause&.statements
+        parts << "#{indent}else\n#{indent}  #{target}#{else_body ? self.prism_source(else_body) : "nil"}"
+
+        "#{head}\n#{parts.join("\n")}\n#{indent}end"
+      end
+
+      # A ternary has no keyword at all.
+      def ternary?(node)
+        node.is_a?(::Prism::IfNode) && node.if_keyword_loc.nil?
+      end
+
+      # `keyword` is "ternary" on a ternary — it has no `if` token to point at.
+      def keyword(rhs)
+        if rhs.is_a?(::Prism::IfNode)
+          if self.ternary?(rhs)
+            "ternary"
+          else
+            "if"
+          end
+        elsif rhs.is_a?(::Prism::UnlessNode)
+          "unless"
+        else
+          "case"
+        end
+      end
+    end
+  end
+end