leftovers 0.11.1 → 0.12.0

data/lib/leftovers/precompilers.rb

@@ -2,19 +2,14 @@
 
 module Leftovers
   module Precompilers
-    autoload(:ERB, "#{__dir__}/precompilers/erb")
-    autoload(:Haml, "#{__dir__}/precompilers/haml")
-    autoload(:JSON, "#{__dir__}/precompilers/json")
-    autoload(:Precompiler, "#{__dir__}/precompilers/precompiler")
-    autoload(:Slim, "#{__dir__}/precompilers/slim")
-    autoload(:YAML, "#{__dir__}/precompilers/yaml")
+    include Autoloader
 
     class << self
       def build(precompilers)
         precompilers.group_by { |p| build_precompiler(p[:format]) }.map do |format, precompiler|
           Precompiler.new(
             format,
-            Leftovers::MatcherBuilders::Path.build(precompiler.flat_map { |p| p[:paths] })
+            MatcherBuilders::Path.build(precompiler.flat_map { |p| p[:paths] })
           )
         end
       end
@@ -23,14 +18,14 @@ module Leftovers
 
       def build_precompiler(format)
         case format
-        when :erb then ::Leftovers::Precompilers::ERB
-        when :haml then ::Leftovers::Precompilers::Haml
-        when :json then ::Leftovers::Precompilers::JSON
-        when :slim then ::Leftovers::Precompilers::Slim
-        when :yaml then ::Leftovers::Precompilers::YAML
-        when Hash then constantize_precompiler(format[:custom])
+        when :erb then ERB
+        when :haml then Haml
+        when :json then JSON
+        when :slim then Slim
+        when :yaml then YAML
+        when ::Hash then constantize_precompiler(format[:custom])
           # :nocov:
-        else raise Leftovers::UnexpectedCase, "Unhandled value #{format}"
+        else raise UnexpectedCase, "Unhandled value #{format}"
           # :nocov:
         end
       end
@@ -38,9 +33,9 @@ module Leftovers
       def constantize_precompiler(precompiler)
         precompiler = "::#{precompiler}" unless precompiler.start_with?('::')
 
-        Object.const_get(precompiler, false)
+        ::Object.const_get(precompiler, false)
       rescue ::NameError
-        Leftovers.error <<~MESSAGE
+        ::Leftovers.error <<~MESSAGE
           Tried using #{precompiler}, but it wasn't available.
           add its path to `requires:` in your .leftovers.yml
         MESSAGE

data/lib/leftovers/processor_builders/action.rb

@@ -5,13 +5,12 @@ module Leftovers
     module Action
       class << self
         def build(patterns, final_processor)
-          ::Leftovers::ProcessorBuilders::Each.each_or_self(patterns) do |pattern|
+          Each.each_or_self(patterns) do |pattern|
             case pattern
-            when ::String, ::Integer
-              ::Leftovers::ProcessorBuilders::Argument.build(pattern, final_processor)
+            when ::String, ::Integer then Argument.build(pattern, final_processor)
             when ::Hash then build_from_hash_value(**pattern, final_processor: final_processor)
             # :nocov:
-            else raise Leftovers::UnexpectedCase, "Unhandled value #{pattern.inspect}"
+            else raise UnexpectedCase, "Unhandled value #{pattern.inspect}"
               # :nocov:
             end
           end
@@ -32,7 +31,7 @@ module Leftovers
           unless_arg: nil, all: nil, any: nil,
           **transform_args
         )
-          processor = ::Leftovers::ProcessorBuilders::TransformSet.build(
+          processor = TransformSet.build(
             transform_args, final_processor
           )
           processor = build_nested(nested, processor) if nested
@@ -48,31 +47,28 @@ module Leftovers
         private
 
         def build_nested(nested, processor)
-          ::Leftovers::ProcessorBuilders::Each.build([
-            ::Leftovers::ProcessorBuilders::Action.build(nested, processor),
-            processor
-          ])
+          Each.build([Action.build(nested, processor), processor])
         end
 
         def build_sources(arguments, keywords, itself, receiver, value, processor) # rubocop:disable Metrics/ParameterLists
-          ::Leftovers::ProcessorBuilders::Each.build([
-            ::Leftovers::ProcessorBuilders::Argument.build(arguments, processor),
-            ::Leftovers::ProcessorBuilders::Keyword.build(keywords, processor),
-            ::Leftovers::ProcessorBuilders::Itself.build(itself, processor),
-            ::Leftovers::ProcessorBuilders::Receiver.build(receiver, processor),
-            ::Leftovers::ProcessorBuilders::Value.build(value, processor)
+          Each.build([
+            Argument.build(arguments, processor),
+            Keyword.build(keywords, processor),
+            Itself.build(itself, processor),
+            Receiver.build(receiver, processor),
+            Value.build(value, processor)
           ])
         end
 
         def build_recursive(processor)
-          recursive_placeholder = ::Leftovers::Processors::Placeholder.new
-          processor = ::Leftovers::ProcessorBuilders::Each.build([recursive_placeholder, processor])
+          recursive_placeholder = Processors::Placeholder.new
+          processor = Each.build([recursive_placeholder, processor])
 
           [recursive_placeholder, processor]
         end
 
         def build_matcher(has_arguments, has_receiver, unless_arg, all, any, processor) # rubocop:disable Metrics/ParameterLists
-          matcher = Leftovers::MatcherBuilders::Node.build_from_hash(
+          matcher = MatcherBuilders::Node.build_from_hash(
             has_arguments: has_arguments,
             has_receiver: has_receiver,
             unless_arg: unless_arg,
@@ -82,7 +78,7 @@ module Leftovers
 
           return processor unless matcher
 
-          ::Leftovers::Processors::MatchMatchedNode.new(matcher, processor)
+          Processors::MatchMatchedNode.new(matcher, processor)
         end
       end
     end

data/lib/leftovers/processor_builders/add_prefix.rb

@@ -7,9 +7,9 @@ module Leftovers
         def build(argument, then_processor)
           case argument
           when ::Hash then build_hash(argument, then_processor)
-          when ::String then ::Leftovers::Processors::AddPrefix.new(argument, then_processor)
+          when ::String then Processors::AddPrefix.new(argument, then_processor)
             # :nocov:
-          else raise Leftovers::UnexpectedCase, "Unhandled value #{argument.inspect}"
+          else raise UnexpectedCase, "Unhandled value #{argument.inspect}"
             # :nocov:
           end
         end
@@ -17,10 +17,8 @@ module Leftovers
         private
 
         def build_hash(argument, then_processor)
-          dynamic_prefix = ::Leftovers::ProcessorBuilders::Action.build(
-            argument, ::Leftovers::Processors::AppendSym
-          )
-          ::Leftovers::Processors::AddDynamicPrefix.new(dynamic_prefix, then_processor)
+          dynamic_prefix = Action.build(argument, Processors::AppendSym)
+          Processors::AddDynamicPrefix.new(dynamic_prefix, then_processor)
         end
       end
     end

data/lib/leftovers/processor_builders/add_suffix.rb

@@ -7,9 +7,9 @@ module Leftovers
         def build(argument, then_processor)
           case argument
           when ::Hash then build_hash(argument, then_processor)
-          when ::String then ::Leftovers::Processors::AddSuffix.new(argument, then_processor)
+          when ::String then Processors::AddSuffix.new(argument, then_processor)
             # :nocov:
-          else raise Leftovers::UnexpectedCase, "Unhandled value #{argument.inspect}"
+          else raise UnexpectedCase, "Unhandled value #{argument.inspect}"
             # :nocov:
           end
         end
@@ -17,10 +17,8 @@ module Leftovers
         private
 
         def build_hash(argument, then_processor)
-          dynamic_suffix = ::Leftovers::ProcessorBuilders::Action.build(
-            argument, ::Leftovers::Processors::AppendSym
-          )
-          ::Leftovers::Processors::AddDynamicSuffix.new(dynamic_suffix, then_processor)
+          dynamic_suffix = Action.build(argument, Processors::AppendSym)
+          Processors::AddDynamicSuffix.new(dynamic_suffix, then_processor)
         end
       end
     end

data/lib/leftovers/processor_builders/argument.rb

@@ -5,19 +5,16 @@ module Leftovers
     module Argument
       class << self
         def build(patterns, processor) # rubocop:disable Metrics/MethodLength
-          ::Leftovers::ProcessorBuilders::Each.each_or_self(patterns) do |pat|
+          Each.each_or_self(patterns) do |pat|
             case pat
-            when ::Integer then ::Leftovers::Processors::PositionalArgument.new(pat, processor)
-            when '*' then ::Leftovers::Processors::EachPositionalArgument.new(processor)
-            when '**' then ::Leftovers::Processors::EachKeywordArgument.new(processor)
-            when /\A(\d+)\+\z/
-              ::Leftovers::Processors::EachPositionalArgumentFrom.new(pat.to_i, processor)
-            when ::String
-              ::Leftovers::ProcessorBuilders::KeywordArgument.build(pat, processor)
-            when ::Hash
-              build_hash(processor, pat)
+            when ::Integer then Processors::PositionalArgument.new(pat, processor)
+            when '*' then Processors::EachPositionalArgument.new(processor)
+            when '**' then Processors::EachKeywordArgument.new(processor)
+            when /\A(\d+)\+\z/ then Processors::EachPositionalArgumentFrom.new(pat.to_i, processor)
+            when ::String then KeywordArgument.build(pat, processor)
+            when ::Hash then build_hash(processor, pat)
               # :nocov:
-            else raise Leftovers::UnexpectedCase, "Unhandled value #{pat.inspect}"
+            else raise UnexpectedCase, "Unhandled value #{pat.inspect}"
               # :nocov:
             end
           end
@@ -26,10 +23,8 @@ module Leftovers
         private
 
         def build_hash(then_processor, pat)
-          ::Leftovers::Processors::KeywordArgument.new(
-            ::Leftovers::MatcherBuilders::NodePairKey.build(
-              ::Leftovers::MatcherBuilders::Node.build_from_hash(**pat)
-            ),
+          Processors::KeywordArgument.new(
+            MatcherBuilders::NodePairKey.build(MatcherBuilders::Node.build_from_hash(**pat)),
             then_processor
           )
         end

data/lib/leftovers/processor_builders/dynamic.rb

@@ -1,11 +1,11 @@
-# frozen-string-literal: true
+# frozen_string_literal: true
 
 module Leftovers
   module ProcessorBuilders
     module Dynamic
       class << self
         def build(dynamic_rules)
-          ::Leftovers::ProcessorBuilders::Each.each_or_self(dynamic_rules) do |dynamic|
+          Each.each_or_self(dynamic_rules) do |dynamic|
             build_processors(**dynamic)
           end
         end
@@ -17,41 +17,23 @@ module Leftovers
           set_privacy: nil, set_default_privacy: nil,
           eval: nil, **matcher_rules
         )
-          matcher = ::Leftovers::MatcherBuilders::Node.build(**matcher_rules)
+          matcher = MatcherBuilders::Node.build_from_hash(**matcher_rules)
 
-          processor = ::Leftovers::ProcessorBuilders::Each.build([
-            build_call_action(call),
-            build_define_action(define),
+          processor = Each.build([
+            Action.build(call, Processors::AddCall),
+            Action.build(define, Processors::AddDefinitionNode),
             build_set_privacy_action(set_privacy),
             build_set_default_privacy_action(set_default_privacy),
-            build_eval_action(eval)
+            Action.build(eval, Processors::Eval)
           ])
 
-          ::Leftovers::Processors::MatchMatchedNode.new(matcher, processor)
-        end
-
-        def build_call_action(call)
-          ::Leftovers::ProcessorBuilders::Action.build(
-            call, ::Leftovers::Processors::AddCall
-          )
-        end
-
-        def build_define_action(define)
-          ::Leftovers::ProcessorBuilders::Action.build(
-            define, ::Leftovers::Processors::AddDefinitionNode
-          )
-        end
-
-        def build_eval_action(eval)
-          ::Leftovers::ProcessorBuilders::Action.build(
-            eval, ::Leftovers::Processors::Eval
-          )
+          Processors::MatchMatchedNode.new(matcher, processor)
         end
 
         def build_set_privacy_action(set_privacies)
-          ::Leftovers::ProcessorBuilders::Each.each_or_self(set_privacies) do |set_privacy|
-            processor = ::Leftovers::Processors::SetPrivacy.new(set_privacy.delete(:to))
-            ::Leftovers::ProcessorBuilders::Action.build_from_hash_value(
+          Each.each_or_self(set_privacies) do |set_privacy|
+            processor = Processors::SetPrivacy.new(set_privacy.delete(:to))
+            Action.build_from_hash_value(
               **set_privacy, final_processor: processor
             )
           end
@@ -60,7 +42,7 @@ module Leftovers
         def build_set_default_privacy_action(set_default_privacy)
           return unless set_default_privacy
 
-          ::Leftovers::Processors::SetDefaultPrivacy.new(set_default_privacy)
+          Processors::SetDefaultPrivacy.new(set_default_privacy)
         end
       end
     end

data/lib/leftovers/processor_builders/each.rb

@@ -3,105 +3,92 @@
 module Leftovers
   module ProcessorBuilders
     class Each
-      def self.build(processors)
-        self[:each].build(processors)
-      end
-
-      def self.each_or_self(value, &block)
-        self[:each].each_or_self(value, &block)
-      end
-
-      def self.[](processor_name)
-        @each ||= {
-          each: new(::Leftovers::Processors::Each),
-          each_for_definition_set: new(::Leftovers::Processors::EachForDefinitionSet)
-        }
-
-        @each.fetch(processor_name)
-      end
+      class << self
+        def each_or_self(value, &block)
+          case value
+          when nil then nil
+          when ::Array then build(value.map(&block))
+          else build([yield(value)])
+          end
+        end
 
-      def initialize(processor_class = ::Leftovers::Processors::Each)
-        @processor_class = processor_class
-      end
+        def build(processors)
+          processors = compact(processors)
 
-      def each_or_self(value, &block)
-        case value
-        when nil then nil
-        when Array then build(value.map(&block))
-        else build([yield(value)])
+          case processors.length
+          # :nocov:
+          when 0 then raise UnexpectedCase, "Unhandled value #{processors.inspect}"
+          # :nocov:
+          when 1 then processors.first
+          else processor_class.new(processors)
+          end
         end
-      end
 
-      def build(processors)
-        processors = compact(processors)
+        private
 
-        case processors.length
-        # :nocov:
-        when 0 then raise Leftovers::UnexpectedCase, "Unhandled value #{processors.inspect}"
-        # :nocov:
-        when 1 then processors.first
-        else @processor_class.new(processors)
+        def processor_class
+          Processors::Each
         end
-      end
 
-      def flatten(processors)
-        case processors
-        when ::Leftovers::Processors::Each, @processor_class
-          flatten(processors.processors)
-        when Array
-          processors.flat_map { |v| flatten(v) }
-        when ::Leftovers::Processors::MatchCurrentNode, ::Leftovers::Processors::MatchMatchedNode
-          flatten_matchers(processors)
-        else
-          [processors]
+        def flatten(processors)
+          case processors
+          when Processors::Each, processor_class
+            flatten(processors.processors)
+          when ::Array
+            processors.flat_map { |v| flatten(v) }
+          when Processors::MatchCurrentNode, Processors::MatchMatchedNode
+            flatten_matchers(processors)
+          else
+            [processors]
+          end
         end
-      end
 
-      def flatten_matchers(processor)
-        then_processors = flatten(processor.then_processor)
-        return [processor] if then_processors.length <= 1
+        def flatten_matchers(processor)
+          then_processors = flatten(processor.then_processor)
+          return [processor] if then_processors.length <= 1
 
-        then_processors.map do |then_processor|
-          processor.class.new(processor.matcher, then_processor)
+          then_processors.map do |then_processor|
+            processor.class.new(processor.matcher, then_processor)
+          end
         end
-      end
 
-      def compact_matchers_with_same_processor(matchers)
-        matchers.group_by(&:then_processor).map do |then_processor, group|
-          next group.first unless group.length > 1
+        def compact_matchers_with_same_processor(matchers)
+          matchers.group_by(&:then_processor).map do |then_processor, group|
+            next group.first unless group.length > 1
 
-          group.first.class.new(
-            ::Leftovers::MatcherBuilders::Or.build(group.map(&:matcher)),
-            then_processor
-          )
+            group.first.class.new(
+              MatcherBuilders::Or.build(group.map(&:matcher)),
+              then_processor
+            )
+          end
         end
-      end
 
-      def compact_matchers_with_same_matcher(matchers)
-        matchers.group_by(&:matcher).map do |matcher, group|
-          next group.first unless group.length > 1
+        def compact_matchers_with_same_matcher(matchers)
+          matchers.group_by(&:matcher).map do |matcher, group|
+            next group.first unless group.length > 1
 
-          group.first.class.new(matcher, build(group.map(&:then_processor)))
+            group.first.class.new(matcher, build(group.map(&:then_processor)))
+          end
         end
-      end
 
-      def compact_matchers(matchers)
-        return [] unless matchers
+        def compact_matchers(matchers)
+          return [] unless matchers
 
-        matchers = compact_matchers_with_same_processor(matchers)
-        compact_matchers_with_same_matcher(matchers)
-      end
+          matchers = compact_matchers_with_same_processor(matchers)
+          compact_matchers_with_same_matcher(matchers)
+        end
 
-      def compact(processors)
-        processors = flatten(processors).compact
+        def compact(processors)
+          processors = flatten(processors).compact
 
-        return processors if processors.length <= 1
+          return processors if processors.length <= 1
 
-        group = processors.group_by(&:class)
+          group = processors.group_by(&:class)
 
-        compact_matchers(group.delete(::Leftovers::Processors::MatchCurrentNode)) +
-          compact_matchers(group.delete(::Leftovers::Processors::MatchMatchedNode)) +
-          group.values.flatten(1)
+          compact_matchers(group.delete(Processors::MatchCurrentNode)) +
+            compact_matchers(group.delete(Processors::MatchMatchedNode)) +
+            group.values.flatten(1)
+        end
       end
     end
   end

data/lib/leftovers/processor_builders/each_for_definition_set.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ProcessorBuilders
+    class EachForDefinitionSet < Each
+      class << self
+        private
+
+        def processor_class
+          Processors::EachForDefinitionSet
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/processor_builders/itself.rb

@@ -3,10 +3,8 @@
 module Leftovers
   module ProcessorBuilders
     module Itself
-      def self.build(value, then_processor)
-        return unless value
-
-        ::Leftovers::Processors::Itself.new(then_processor)
+      def self.build(true_arg, then_processor)
+        Processors::Itself.new(then_processor) if true_arg
       end
     end
   end

data/lib/leftovers/processor_builders/keyword.rb

@@ -9,15 +9,15 @@ module Leftovers
         then_processor = case value
         when true, '**' then then_processor
         when ::String, ::Hash, ::Array
-          ::Leftovers::Processors::MatchCurrentNode.new(
-            ::Leftovers::MatcherBuilders::NodeName.build(value), then_processor
+          Processors::MatchCurrentNode.new(
+            MatcherBuilders::NodeName.build(value), then_processor
           )
         # :nocov:
-        else raise Leftovers::UnexpectedCase, "Unhandled value #{value.inspect}"
+        else raise UnexpectedCase, "Unhandled value #{value.inspect}"
           # :nocov:
         end
 
-        ::Leftovers::Processors::EachKeyword.new(then_processor)
+        Processors::EachKeyword.new(then_processor)
       end
     end
   end

data/lib/leftovers/processor_builders/keyword_argument.rb

@@ -1,12 +1,12 @@
-# frozen-string-literal: true
+# frozen_string_literal: true
 
 module Leftovers
   module ProcessorBuilders
     module KeywordArgument
       def self.build(pattern, then_processor)
-        ::Leftovers::Processors::KeywordArgument.new(
-          ::Leftovers::MatcherBuilders::NodePairKey.build(
-            ::Leftovers::MatcherBuilders::NodeName.build(pattern)
+        Processors::KeywordArgument.new(
+          MatcherBuilders::NodePairKey.build(
+            MatcherBuilders::NodeName.build(pattern)
           ),
           then_processor
         )

data/lib/leftovers/processor_builders/receiver.rb

@@ -3,10 +3,8 @@
 module Leftovers
   module ProcessorBuilders
     module Receiver
-      def self.build(value, then_processor)
-        return unless value
-
-        ::Leftovers::Processors::Receiver.new(then_processor)
+      def self.build(true_arg, then_processor)
+        Processors::Receiver.new(then_processor) if true_arg
       end
     end
   end

data/lib/leftovers/processor_builders/transform.rb

@@ -1,61 +1,38 @@
-# frozen-string-literal: true
+# frozen_string_literal: true
 
 module Leftovers
   module ProcessorBuilders
     module Transform
       def self.build(transform, arguments, then_processor) # rubocop:disable Metrics
         case transform
-        when :original, nil
-          then_processor
-        when :downcase
-          ::Leftovers::Processors::Downcase.new(then_processor)
-        when :upcase
-          ::Leftovers::Processors::Upcase.new(then_processor)
-        when :capitalize
-          ::Leftovers::Processors::Capitalize.new(then_processor)
-        when :swapcase
-          ::Leftovers::Processors::Swapcase.new(then_processor)
-        when :pluralize
-          ::Leftovers::Processors::Pluralize.new(then_processor)
-        when :singularize
-          ::Leftovers::Processors::Singularize.new(then_processor)
-        when :camelize
-          ::Leftovers::Processors::Camelize.new(then_processor)
-        when :titleize
-          ::Leftovers::Processors::Titleize.new(then_processor)
-        when :demodulize
-          ::Leftovers::Processors::Demodulize.new(then_processor)
-        when :deconstantize
-          ::Leftovers::Processors::Deconstantize.new(then_processor)
-        when :parameterize
-          ::Leftovers::Processors::Parameterize.new(then_processor)
-        when :underscore
-          ::Leftovers::Processors::Underscore.new(then_processor)
-        when :transforms
-          ::Leftovers::ProcessorBuilders::TransformSet.build(arguments, then_processor)
+        when :original, nil then then_processor
+        when :downcase then Processors::Downcase.new(then_processor)
+        when :upcase then Processors::Upcase.new(then_processor)
+        when :capitalize then Processors::Capitalize.new(then_processor)
+        when :swapcase then Processors::Swapcase.new(then_processor)
+        when :pluralize then Processors::Pluralize.new(then_processor)
+        when :singularize then Processors::Singularize.new(then_processor)
+        when :camelize then Processors::Camelize.new(then_processor)
+        when :titleize then Processors::Titleize.new(then_processor)
+        when :demodulize then Processors::Demodulize.new(then_processor)
+        when :deconstantize then Processors::Deconstantize.new(then_processor)
+        when :parameterize then Processors::Parameterize.new(then_processor)
+        when :underscore then Processors::Underscore.new(then_processor)
+        when :transforms then TransformSet.build(arguments, then_processor)
         else
-          ::Leftovers::ProcessorBuilders::Each.each_or_self(arguments) do |argument|
+          Each.each_or_self(arguments) do |arg|
             case transform
-            when :split
-              ::Leftovers::Processors::Split.new(argument, then_processor)
-            when :delete_before
-              ::Leftovers::Processors::DeleteBefore.new(argument, then_processor)
-            when :delete_before_last
-              ::Leftovers::Processors::DeleteBeforeLast.new(argument, then_processor)
-            when :delete_after
-              ::Leftovers::Processors::DeleteAfter.new(argument, then_processor)
-            when :delete_after_last
-              ::Leftovers::Processors::DeleteAfterLast.new(argument, then_processor)
-            when :add_prefix
-              ::Leftovers::ProcessorBuilders::AddPrefix.build(argument, then_processor)
-            when :add_suffix
-              ::Leftovers::ProcessorBuilders::AddSuffix.build(argument, then_processor)
-            when :delete_prefix
-              ::Leftovers::Processors::DeletePrefix.new(argument, then_processor)
-            when :delete_suffix
-              ::Leftovers::Processors::DeleteSuffix.new(argument, then_processor)
+            when :split then Processors::Split.new(arg, then_processor)
+            when :delete_before then Processors::DeleteBefore.new(arg, then_processor)
+            when :delete_before_last then Processors::DeleteBeforeLast.new(arg, then_processor)
+            when :delete_after then Processors::DeleteAfter.new(arg, then_processor)
+            when :delete_after_last then Processors::DeleteAfterLast.new(arg, then_processor)
+            when :add_prefix then AddPrefix.build(arg, then_processor)
+            when :add_suffix then AddSuffix.build(arg, then_processor)
+            when :delete_prefix then Processors::DeletePrefix.new(arg, then_processor)
+            when :delete_suffix then Processors::DeleteSuffix.new(arg, then_processor)
             # :nocov:
-            else raise Leftovers::UnexpectedCase, "Unhandled value #{transform.to_s.inspect}"
+            else raise UnexpectedCase, "Unhandled value #{transform.to_s.inspect}"
               # :nocov:
             end
           end