leftovers 0.8.0 → 0.11.0

data/lib/leftovers/matcher_builders/node_pair_name.rb

@@ -1,18 +0,0 @@
-# frozen-string-literal: true
-
-module Leftovers
-  module MatcherBuilders
-    module NodePairName
-      def self.build(name_pattern)
-        matcher = ::Leftovers::MatcherBuilders::Name.build(name_pattern)
-
-        return unless matcher
-
-        ::Leftovers::MatcherBuilders::And.build([
-          ::Leftovers::Matchers::NodeType.new(:pair),
-          ::Leftovers::Matchers::NodeName.new(matcher)
-        ])
-      end
-    end
-  end
-end

data/lib/leftovers/matchers/predicate.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module Matchers
-    class Predicate
-      def initialize(predicate)
-        @predicate = predicate
-
-        freeze
-      end
-
-      def ===(node)
-        node.send(@predicate)
-      end
-
-      freeze
-    end
-  end
-end

data/lib/leftovers/processor_builders/each_action.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module ProcessorBuilders
-    module EachAction
-      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 build(processors)
-          processors = compact(processors)
-
-          case processors.length
-          # :nocov:
-          when 0 then raise Leftovers::UnexpectedCase, "Unhandled value #{processors.inspect}"
-          # :nocov:
-          when 1 then processors.first
-          else ::Leftovers::ValueProcessors::Each.new(processors)
-          end
-        end
-
-        private
-
-        def flatten(value)
-          case value
-          when ::Leftovers::ValueProcessors::Each
-            value.processors.flat_map { |v| flatten(v) }
-          when Array
-            value.flat_map { |v| flatten(v) }
-          else
-            value
-          end
-        end
-
-        def compact(processors)
-          return processors if processors.length <= 1
-
-          processors = flatten(processors)
-          processors.compact!
-
-          processors
-        end
-      end
-    end
-  end
-end

data/lib/leftovers/processor_builders/each_dynamic.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module ProcessorBuilders
-    module EachDynamic
-      def self.each_or_self(value, &block)
-        case value
-        when nil then ::Leftovers::DynamicProcessors::Null
-        when Array then build(value.map(&block))
-        else build([yield(value)])
-        end
-      end
-
-      def self.build(processors)
-        processors = compact(processors)
-
-        case processors.length
-        # :nocov:
-        when 0 then raise Leftovers::UnexpectedCase, "Unhandled value #{processors.inspect}"
-        # :nocov:
-        when 1 then processors.first
-        else ::Leftovers::DynamicProcessors::Each.new(processors)
-        end
-      end
-
-      def self.flatten(value)
-        case value
-        when ::Leftovers::DynamicProcessors::Each
-          value.processors.flat_map { |v| flatten(v) }
-        when Array
-          value.flat_map { |v| flatten(v) }
-        else
-          value
-        end
-      end
-
-      def self.compact(processors)
-        return processors if processors.length <= 1
-
-        processors = flatten(processors)
-
-        processors.reject! do |p|
-          p == ::Leftovers::DynamicProcessors::Null
-        end
-
-        processors
-      end
-    end
-  end
-end

data/lib/leftovers/processor_builders/each_for_definition_set.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module ProcessorBuilders
-    module EachForDefinitionSet
-      class << self
-        def each_or_self(value, &block)
-          case value
-          # :nocov:
-          when nil then raise Leftovers::UnexpectedCase, "Unhandled value #{value.inspect}"
-          # :nocov:
-          when Array then build(value.map(&block))
-          else build([yield(value)])
-          end
-        end
-
-        def build(processors)
-          processors = compact(processors)
-
-          case processors.length
-          # :nocov:
-          when 0 then raise Leftovers::UnexpectedCase, "Unhandled value #{processors.inspect}"
-          # :nocov:
-          when 1 then processors.first
-          else ::Leftovers::ValueProcessors::EachForDefinitionSet.new(processors)
-          end
-        end
-
-        private
-
-        def compact(processors)
-          processors.flatten!
-          processors.compact!
-
-          processors
-        end
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors/add_dynamic_prefix.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module ValueProcessors
-    class AddDynamicPrefix
-      def initialize(prefix_processor, then_processor)
-        @prefix_processor = prefix_processor
-        @then_processor = then_processor
-
-        freeze
-      end
-
-      def process(str, node, method_node)
-        return unless str
-
-        prefixes = @prefix_processor.process(nil, method_node, method_node)
-
-        Leftovers.map_or_self(prefixes) do |prefix|
-          @then_processor.process("#{prefix}#{str}", node, method_node)
-        end
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors/add_dynamic_suffix.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module ValueProcessors
-    class AddDynamicSuffix
-      def initialize(suffix_processor, then_processor)
-        @suffix_processor = suffix_processor
-        @then_processor = then_processor
-
-        freeze
-      end
-
-      def process(str, node, method_node)
-        return unless str
-
-        suffixes = @suffix_processor.process(nil, method_node, method_node)
-
-        Leftovers.map_or_self(suffixes) do |suffix|
-          @then_processor.process("#{str}#{suffix}", node, method_node)
-        end
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors/delete_before.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module ValueProcessors
-    class DeleteBefore
-      def initialize(delete_before, then_processor)
-        @delete_before = delete_before
-        @then_processor = then_processor
-
-        freeze
-      end
-
-      def process(str, node, method_node)
-        return unless str
-
-        # TODO: investigate index
-        str = str.split(@delete_before, 2)[1] || str
-        @then_processor.process(str, node, method_node)
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors/each.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module ValueProcessors
-    class Each
-      attr_reader :processors
-
-      def initialize(processors)
-        @processors = processors
-
-        freeze
-      end
-
-      def process(str, node, method_node)
-        Leftovers.map_or_self(@processors) do |processor|
-          processor.process(str, node, method_node)
-        end
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors/each_for_definition_set.rb

@@ -1,23 +0,0 @@
-# frozen-string-literal: true
-
-module Leftovers
-  module ValueProcessors
-    class EachForDefinitionSet
-      def initialize(then_processors)
-        @then_processors = then_processors
-
-        freeze
-      end
-
-      def process(str, node, method_node)
-        definitions = Leftovers.map_or_self(@then_processors) do |then_processor|
-          then_processor.process(str, node, method_node)
-        end
-
-        return definitions unless definitions.is_a?(Array)
-
-        ::Leftovers::DefinitionNodeSet.new(definitions)
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors/each_keyword.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module ValueProcessors
-    class EachKeyword
-      def initialize(then_processor)
-        @then_processor = then_processor
-
-        freeze
-      end
-
-      def process(_str, node, method_node)
-        kwargs = node.kwargs
-        return unless kwargs
-
-        Leftovers.map_or_self(kwargs.children) do |pair|
-          next unless pair.type == :pair
-
-          argument_node = pair.first
-          str = argument_node.to_s if argument_node.string_or_symbol?
-
-          @then_processor.process(str, argument_node, method_node)
-        end
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors/each_keyword_argument.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module ValueProcessors
-    class EachKeywordArgument
-      def initialize(then_processor)
-        @then_processor = then_processor
-
-        freeze
-      end
-
-      def process(_str, node, method_node)
-        kwargs = node.kwargs
-        return unless kwargs
-
-        Leftovers.map_or_self(kwargs.children) do |pair|
-          next unless pair.type == :pair
-
-          argument_node = pair.second
-          str = argument_node.to_s if argument_node.string_or_symbol?
-
-          @then_processor.process(str, argument_node, method_node)
-        end
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors/each_positional_argument.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module ValueProcessors
-    class EachPositionalArgument
-      def initialize(then_processor)
-        @then_processor = then_processor
-
-        freeze
-      end
-
-      def process(_str, node, method_node)
-        positional_arguments = node.positional_arguments
-
-        return unless positional_arguments
-
-        Leftovers.map_or_self(positional_arguments) do |argument_node|
-          str = argument_node.to_s if argument_node.string_or_symbol_or_def?
-
-          @then_processor.process(str, argument_node, method_node)
-        end
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors/itself.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module ValueProcessors
-    class Itself
-      def initialize(then_processor)
-        @then_processor = then_processor
-
-        freeze
-      end
-
-      def process(_str, node, method_node)
-        @then_processor.process(method_node.to_s, node, method_node)
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors/keyword.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module ValueProcessors
-    class Keyword
-      def initialize(matcher, then_processor)
-        @matcher = matcher
-        @then_processor = then_processor
-
-        freeze
-      end
-
-      def process(_str, node, method_node)
-        kwargs = node.kwargs
-        return unless kwargs
-
-        Leftovers.map_or_self(kwargs.children) do |pair|
-          next unless @matcher === pair
-
-          argument_node = pair.first
-          str = argument_node.to_s if argument_node.string_or_symbol?
-
-          @then_processor.process(str, argument_node, method_node)
-        end
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors/keyword_argument.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module ValueProcessors
-    class KeywordArgument
-      def initialize(matcher, then_processor)
-        @matcher = matcher
-        @then_processor = then_processor
-
-        freeze
-      end
-
-      def process(_str, node, method_node)
-        kwargs = node.kwargs
-        return unless kwargs
-
-        Leftovers.map_or_self(kwargs.children) do |pair|
-          next unless @matcher === pair
-
-          argument_node = pair.second
-          str = argument_node.to_s if argument_node.string_or_symbol?
-
-          @then_processor.process(str, argument_node, method_node)
-        end
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors/return_definition_node.rb

@@ -1,14 +0,0 @@
-# frozen-string-literal: true
-
-module Leftovers
-  module ValueProcessors
-    module ReturnDefinitionNode
-      def self.process(str, node, _method_node)
-        return unless str
-        return if str.empty?
-
-        Leftovers::DefinitionNode.new(node, name: str.to_sym)
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors/return_sym.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module ValueProcessors
-    module ReturnSym
-      def self.process(str, _node, _method_node)
-        return unless str
-        return if str.empty?
-
-        str.to_sym
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors.rb

@@ -1,40 +0,0 @@
-# frozen-string-literal: true
-
-module Leftovers
-  module ValueProcessors
-    autoload(:AddDynamicPrefix, "#{__dir__}/value_processors/add_dynamic_prefix")
-    autoload(:AddDynamicSuffix, "#{__dir__}/value_processors/add_dynamic_suffix")
-    autoload(:AddPrefix, "#{__dir__}/value_processors/add_prefix")
-    autoload(:AddSuffix, "#{__dir__}/value_processors/add_suffix")
-    autoload(:Camelize, "#{__dir__}/value_processors/camelize")
-    autoload(:Capitalize, "#{__dir__}/value_processors/capitalize")
-    autoload(:Deconstantize, "#{__dir__}/value_processors/deconstantize")
-    autoload(:DeleteAfter, "#{__dir__}/value_processors/delete_after")
-    autoload(:DeleteBefore, "#{__dir__}/value_processors/delete_before")
-    autoload(:DeletePrefix, "#{__dir__}/value_processors/delete_prefix")
-    autoload(:DeleteSuffix, "#{__dir__}/value_processors/delete_suffix")
-    autoload(:Demodulize, "#{__dir__}/value_processors/demodulize")
-    autoload(:Downcase, "#{__dir__}/value_processors/downcase")
-    autoload(:EachForDefinitionSet, "#{__dir__}/value_processors/each_for_definition_set")
-    autoload(:EachKeyword, "#{__dir__}/value_processors/each_keyword")
-    autoload(:EachKeywordArgument, "#{__dir__}/value_processors/each_keyword_argument")
-    autoload(:EachPositionalArgument, "#{__dir__}/value_processors/each_positional_argument")
-    autoload(:Each, "#{__dir__}/value_processors/each")
-    autoload(:Itself, "#{__dir__}/value_processors/itself")
-    autoload(:Keyword, "#{__dir__}/value_processors/keyword")
-    autoload(:KeywordArgument, "#{__dir__}/value_processors/keyword_argument")
-    autoload(:Parameterize, "#{__dir__}/value_processors/parameterize")
-    autoload(:Placeholder, "#{__dir__}/value_processors/placeholder")
-    autoload(:Pluralize, "#{__dir__}/value_processors/pluralize")
-    autoload(:PositionalArgument, "#{__dir__}/value_processors/positional_argument")
-    autoload(:ReplaceValue, "#{__dir__}/value_processors/replace_value")
-    autoload(:ReturnDefinitionNode, "#{__dir__}/value_processors/return_definition_node")
-    autoload(:ReturnSym, "#{__dir__}/value_processors/return_sym")
-    autoload(:Singularize, "#{__dir__}/value_processors/singularize")
-    autoload(:Split, "#{__dir__}/value_processors/split")
-    autoload(:Swapcase, "#{__dir__}/value_processors/swapcase")
-    autoload(:Titleize, "#{__dir__}/value_processors/titleize")
-    autoload(:Underscore, "#{__dir__}/value_processors/underscore")
-    autoload(:Upcase, "#{__dir__}/value_processors/upcase")
-  end
-end