leftovers 0.6.0 → 0.9.0

data/lib/leftovers/dynamic_processors/definition.rb

@@ -1,22 +0,0 @@
-# frozen-string-literal: true
-
-module Leftovers
-  module DynamicProcessors
-    class Definition
-      def initialize(matcher, processor)
-        @matcher = matcher
-        @processor = processor
-      end
-
-      def process(node, file)
-        return if node.keep_line?
-        return unless @matcher === node
-
-        definition = @processor.process(nil, node, node)
-        return unless definition
-
-        file.definitions << definition
-      end
-    end
-  end
-end

data/lib/leftovers/dynamic_processors/each.rb

@@ -1,19 +0,0 @@
-# frozen-string-literal: true
-
-module Leftovers
-  module DynamicProcessors
-    class Each
-      attr_reader :processors
-
-      def initialize(processors)
-        @processors = processors
-      end
-
-      def process(node, file)
-        @processors.each do |processor|
-          processor.process(node, file)
-        end
-      end
-    end
-  end
-end

data/lib/leftovers/dynamic_processors/null.rb

@@ -1,9 +0,0 @@
-# frozen-string-literal: true
-
-module Leftovers
-  module DynamicProcessors
-    module Null
-      def self.process(_node, _file); end
-    end
-  end
-end

data/lib/leftovers/dynamic_processors.rb

@@ -1,11 +0,0 @@
-# frozen-string-literal: true
-
-module Leftovers
-  module DynamicProcessors
-    autoload(:CallDefinition, "#{__dir__}/dynamic_processors/call_definition")
-    autoload(:Call, "#{__dir__}/dynamic_processors/call")
-    autoload(:Definition, "#{__dir__}/dynamic_processors/definition")
-    autoload(:Each, "#{__dir__}/dynamic_processors/each")
-    autoload(:Null, "#{__dir__}/dynamic_processors/null")
-  end
-end

data/lib/leftovers/erb.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require 'erb'
-
-module Leftovers
-  class ERB < ::ERB::Compiler
-    def self.precompile(erb, _name)
-      @compiler ||= new('-')
-      @compiler.compile(erb).first
-    end
-
-    def add_insert_cmd(out, content) # leftovers:keep
-      out.push("\n#{content}\n")
-    end
-
-    def add_put_cmd(out, _content) # leftovers:keep
-      out.push("\n")
-    end
-  end
-end

data/lib/leftovers/haml.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module Haml
-    module_function
-
-    def precompile(file, name)
-      return '' unless Leftovers.try_require('haml', message: <<~MESSAGE) # rubocop:disable Layout/EmptyLineAfterGuardClause
-        Skipped parsing #{name.relative_path}, because the haml gem was not available
-        `gem install haml`
-      MESSAGE
-
-      begin
-        ::Haml::Engine.new(file).precompiled
-      rescue ::Haml::SyntaxError => e
-        Leftovers.warn "#{e.class}: #{e.message} #{name.relative_path}:#{e.line}"
-        ''
-      end
-    end
-  end
-end

data/lib/leftovers/json.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-
-module Leftovers
-  module JSON
-    class << self
-      def precompile(json, name)
-        "__leftovers_document(#{to_ruby_argument(::JSON.parse(json))})"
-      rescue ::JSON::ParserError => e
-        Leftovers.warn "#{e.class}: (#{name.relative_path}): #{e.message}"
-        ''
-      end
-
-      private
-
-      def to_ruby_argument(value)
-        ruby = value.inspect
-        return ruby unless value.is_a?(Array)
-
-        ruby.delete_prefix!('[')
-        ruby.delete_suffix!(']')
-
-        ruby
-      end
-    end
-  end
-end

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
-      def self.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 self.build(processors)
-        processors = compact(processors)
-
-        case processors.length
-        # :nocov:
-        when 0 then raise
-        # :nocov:
-        when 1 then processors.first
-        else ::Leftovers::ValueProcessors::Each.new(processors)
-        end
-      end
-
-      def self.flatten(value) # rubocop:disable Metrics/MethodLength
-        case value
-        when ::Leftovers::ValueProcessors::Each
-          ret = value.processors.map { |v| flatten(v) }
-          ret.flatten!(1)
-          ret
-        when Array
-          ret = value.map { |v| flatten(v) }
-          ret.flatten!(1)
-          ret
-        else
-          value
-        end
-      end
-
-      def self.compact(processors)
-        return processors if processors.length <= 1
-
-        processors = flatten(processors)
-        processors.compact!
-
-        processors
-      end
-    end
-  end
-end

data/lib/leftovers/processor_builders/each_dynamic.rb

@@ -1,54 +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
-        # :nocov:
-        when 1 then processors.first
-        else ::Leftovers::DynamicProcessors::Each.new(processors)
-        end
-      end
-
-      def self.flatten(value) # rubocop:disable Metrics/MethodLength
-        case value
-        when ::Leftovers::DynamicProcessors::Each
-          ret = value.processors.map { |v| flatten(v) }
-          ret.flatten!(1)
-          ret
-        when Array
-          ret = value.map { |v| flatten(v) }
-          ret.flatten!(1)
-          ret
-        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,36 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module ProcessorBuilders
-    module EachForDefinitionSet
-      def self.each_or_self(value, &block)
-        case value
-        # :nocov:
-        when nil then raise
-        # :nocov:
-        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
-        # :nocov:
-        when 1 then processors.first
-        else ::Leftovers::ValueProcessors::EachForDefinitionSet.new(processors)
-        end
-      end
-
-      def self.compact(processors)
-        processors.flatten!
-        processors.compact!
-
-        processors
-      end
-    end
-  end
-end

data/lib/leftovers/slim.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  module Slim
-    module_function
-
-    def precompile(file, name)
-      return '' unless Leftovers.try_require('slim', message: <<~MESSAGE) # rubocop:disable Layout/EmptyLineAfterGuardClause
-        Skipped parsing #{name.relative_path}, because the slim gem was not available
-        `gem install slim`
-      MESSAGE
-
-      begin
-        ::Slim::Engine.new(file: file).call(file)
-      rescue ::Slim::Parser::SyntaxError => e
-        Leftovers.warn "#{e.class}: \"#{e.error}\" #{name.relative_path}:#{e.lineno}:#{e.column}"
-        ''
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors/add_dynamic_prefix.rb

@@ -1,31 +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) # rubocop:disable Metrics/MethodLength
-        return unless str
-
-        prefixes = @prefix_processor.process(nil, method_node, method_node)
-        if prefixes.is_a?(Array)
-          prefixes.flatten!
-          prefixes.compact!
-          prefixes.uniq!
-
-          prefixes.map do |prefix|
-            @then_processor.process("#{prefix}#{str}", node, method_node)
-          end
-        else
-          @then_processor.process("#{prefixes}#{str}", node, method_node)
-        end
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors/add_dynamic_suffix.rb

@@ -1,31 +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) # rubocop:disable Metrics/MethodLength
-        return unless str
-
-        suffixes = @suffix_processor.process(nil, method_node, method_node)
-        if suffixes.is_a?(Array)
-          suffixes.flatten!
-          suffixes.compact!
-          suffixes.uniq!
-
-          suffixes.map do |suffix|
-            @then_processor.process("#{str}#{suffix}", node, method_node)
-          end
-        else
-          @then_processor.process("#{str}#{suffixes}", 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)
-        @processors.flat_map do |processor|
-          processor.process(str, node, method_node)
-        end
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors/each_for_definition_set.rb

@@ -1,29 +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 = @then_processors.map do |then_processor|
-          processed = then_processor.process(str, node, method_node)
-          return if processed == :keep # rubocop:disable Lint/NonLocalExitFromIterator
-
-          processed
-        end
-
-        definitions.flatten!
-        definitions.compact!
-
-        return definitions.first if definitions.length <= 1
-
-        ::Leftovers::DefinitionSet.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
-
-        kwargs.children.map 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
-
-        kwargs.children.map 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,24 +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
-
-        positional_arguments.map do |argument_node|
-          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/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,32 +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
-
-        result = []
-
-        kwargs.children.each do |pair|
-          next unless @matcher === pair
-
-          argument_node = pair.first
-          str = argument_node.to_s
-
-          result << @then_processor.process(str, argument_node, method_node)
-        end
-
-        result
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors/return_definition.rb

@@ -1,22 +0,0 @@
-# frozen-string-literal: true
-
-module Leftovers
-  module ValueProcessors
-    module ReturnDefinition
-      def self.process(str, node, method_node)
-        return unless str
-        return if str.empty?
-
-        str_node = Leftovers::DefinitionNode.new(str.to_sym, method_node.path)
-
-        return :keep if ::Leftovers.config.keep === str_node
-
-        Leftovers::Definition.new(
-          str_node.name,
-          location: node.loc.expression,
-          test: method_node.test_line? || ::Leftovers.config.test_only === str_node
-        )
-      end
-    end
-  end
-end

data/lib/leftovers/value_processors/return_string.rb

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