leftovers 0.3.0 → 0.4.0

data/lib/leftovers/file_list.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'fast_ignore'
-require_relative 'file'
 
 module Leftovers
   class FileList < ::FastIgnore

data/lib/leftovers/haml.rb

@@ -4,7 +4,7 @@ module Leftovers
   module Haml
     module_function
 
-    def precompile(file, name) # rubocop:disable Metrics/MethodLength
+    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`

data/lib/leftovers/matcher_builders.rb

@@ -0,0 +1,24 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module MatcherBuilders
+    autoload(:AndNot, "#{__dir__}/matcher_builders/and_not")
+    autoload(:And, "#{__dir__}/matcher_builders/and")
+    autoload(:ArgumentNodeValue, "#{__dir__}/matcher_builders/argument_node_value")
+    autoload(:Name, "#{__dir__}/matcher_builders/name")
+    autoload(:NodeHasArgument, "#{__dir__}/matcher_builders/node_has_argument")
+    autoload(:NodeHasKeywordArgument, "#{__dir__}/matcher_builders/node_has_keyword_argument")
+    autoload(:NodeHasPositionalArgument, "#{__dir__}/matcher_builders/node_has_positional_argument")
+    autoload(:NodeName, "#{__dir__}/matcher_builders/node_name")
+    autoload(:NodePairName, "#{__dir__}/matcher_builders/node_pair_name")
+    autoload(:NodePairValue, "#{__dir__}/matcher_builders/node_pair_value")
+    autoload(:NodePath, "#{__dir__}/matcher_builders/node_path")
+    autoload(:NodeType, "#{__dir__}/matcher_builders/node_type")
+    autoload(:Node, "#{__dir__}/matcher_builders/node")
+    autoload(:Or, "#{__dir__}/matcher_builders/or")
+    autoload(:Path, "#{__dir__}/matcher_builders/path")
+    autoload(:StringPattern, "#{__dir__}/matcher_builders/string_pattern")
+    autoload(:String, "#{__dir__}/matcher_builders/string")
+    autoload(:Unless, "#{__dir__}/matcher_builders/unless")
+  end
+end

data/lib/leftovers/matcher_builders/and.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module MatcherBuilders
+    module And
+      def self.build(matchers)
+        matchers = matchers.compact
+        case matchers.length
+        # :nocov:
+        when 0 then nil
+        # :nocov:
+        when 1 then matchers.first
+        when 2 then ::Leftovers::Matchers::And.new(matchers.first, matchers[1])
+        else ::Leftovers::Matchers::All.new(matchers.dup)
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/matcher_builders/and_not.rb

@@ -0,0 +1,14 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module MatcherBuilders
+    module AndNot
+      def self.build(positive_matcher, negative_matcher)
+        ::Leftovers::MatcherBuilders::And.build([
+          positive_matcher,
+          ::Leftovers::MatcherBuilders::Unless.build(negative_matcher)
+        ])
+      end
+    end
+  end
+end

data/lib/leftovers/matcher_builders/argument_node_value.rb

@@ -0,0 +1,21 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module MatcherBuilders
+    module ArgumentNodeValue
+      def self.build(pattern)
+        ::Leftovers::MatcherBuilders::Or.each_or_self(pattern) do |pat|
+          case pat
+          when ::Integer, true, false, nil
+            ::Leftovers::Matchers::NodeScalarValue.new(pat)
+          when ::String, ::Hash
+            ::Leftovers::MatcherBuilders::NodeName.build(pat)
+          # :nocov:
+          else raise
+            # :nocov:
+          end
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/matcher_builders/name.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module MatcherBuilders
+    module Name
+      def self.build(patterns) # rubocop:disable Metrics/MethodLength
+        ::Leftovers::MatcherBuilders::Or.each_or_self(patterns) do |pat|
+          case pat
+          when nil
+          when ::Array
+            ::Leftovers::MatcherBuilders::Name.build(pat)
+          when ::String
+            ::Leftovers::MatcherBuilders::String.build(pat)
+          when ::Hash
+            unless_arg = pat.delete(:unless_arg)
+
+            ::Leftovers::MatcherBuilders::AndNot.build(
+              ::Leftovers::MatcherBuilders::StringPattern.build(**pat),
+              ::Leftovers::MatcherBuilders::Name.build(unless_arg)
+            )
+          # :nocov:
+          else raise
+            # :nocov:
+          end
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/matcher_builders/node.rb

@@ -0,0 +1,40 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module MatcherBuilders
+    module Node
+      def self.build(pattern)
+        ::Leftovers::MatcherBuilders::Or.each_or_self(pattern) do |pat|
+          case pat
+          when ::String
+            ::Leftovers::MatcherBuilders::NodeName.build(pat)
+          when ::Hash
+            build_from_hash(**pat)
+          # :nocov:
+          else raise
+            # :nocov:
+          end
+        end
+      end
+
+      def self.build_from_hash( # rubocop:disable Metrics/ParameterLists, Metrics/MethodLength
+        names: nil, match: nil, has_prefix: nil, has_suffix: nil,
+        paths: nil,
+        has_arguments: nil,
+        unless_arg: nil
+      )
+        ::Leftovers::MatcherBuilders::And.build([
+          ::Leftovers::MatcherBuilders::NodeName.build([
+            names,
+            { match: match, has_prefix: has_prefix, has_suffix: has_suffix }.compact
+          ]),
+          ::Leftovers::MatcherBuilders::NodePath.build(paths),
+          ::Leftovers::MatcherBuilders::NodeHasArgument.build(has_arguments),
+          ::Leftovers::MatcherBuilders::Unless.build(
+            (::Leftovers::MatcherBuilders::Node.build(unless_arg) if unless_arg)
+          )
+        ])
+      end
+    end
+  end
+end

data/lib/leftovers/matcher_builders/node_has_argument.rb

@@ -0,0 +1,71 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module MatcherBuilders
+    module NodeHasArgument
+      def self.build(patterns) # rubocop:disable Metrics/MethodLength
+        ::Leftovers::MatcherBuilders::Or.each_or_self(patterns) do |pat|
+          case pat
+          when ::String
+            ::Leftovers::MatcherBuilders::NodeHasKeywordArgument.build(pat, nil)
+          when ::Integer
+            ::Leftovers::MatcherBuilders::NodeHasPositionalArgument.build(pat, nil)
+          when ::Hash
+            build_from_hash(**pat)
+          # :nocov:
+          else
+            raise
+            # :nocov:
+          end
+        end
+      end
+
+      def self.separate_argument_types(at) # rubocop:disable Metrics/MethodLength
+        keys = []
+        positions = []
+
+        ::Leftovers.each_or_self(at) do |k|
+          case k
+          when ::String, ::Hash
+            keys << k
+          when ::Integer
+            positions << k
+          # :nocov:
+          else raise
+            # :nocov:
+          end
+        end
+        keys = nil if keys.empty?
+        positions = nil if positions.empty?
+
+        [keys, positions]
+      end
+
+      def self.build_from_hash(at: nil, has_value: nil, has_value_type: nil, unless_arg: nil) # rubocop:disable Metrics/MethodLength
+        keys, positions = separate_argument_types(at)
+
+        value_matcher = ::Leftovers::MatcherBuilders::And.build([
+          ::Leftovers::MatcherBuilders::ArgumentNodeValue.build(has_value),
+          ::Leftovers::MatcherBuilders::NodeType.build(has_value_type)
+        ])
+        matcher = if (keys && positions) || (!keys && !positions)
+          ::Leftovers::MatcherBuilders::Or.build([
+            ::Leftovers::MatcherBuilders::NodeHasKeywordArgument.build(keys, value_matcher),
+            ::Leftovers::MatcherBuilders::NodeHasPositionalArgument.build(positions, value_matcher)
+          ])
+        elsif keys
+          ::Leftovers::MatcherBuilders::NodeHasKeywordArgument.build(keys, value_matcher)
+        elsif positions
+          ::Leftovers::MatcherBuilders::NodeHasPositionalArgument.build(positions, value_matcher)
+          # :nocov:
+        else raise
+          # :nocov:
+        end
+
+        ::Leftovers::MatcherBuilders::AndNot.build(
+          matcher, ::Leftovers::MatcherBuilders::NodeHasArgument.build(unless_arg)
+        )
+      end
+    end
+  end
+end

data/lib/leftovers/matcher_builders/node_has_keyword_argument.rb

@@ -0,0 +1,22 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module MatcherBuilders
+    module NodeHasKeywordArgument
+      def self.build(keywords, value_matcher)
+        value_matcher = ::Leftovers::MatcherBuilders::NodePairValue.build(value_matcher)
+        keyword_matcher = ::Leftovers::MatcherBuilders::NodePairName.build(keywords)
+
+        pair_matcher = ::Leftovers::MatcherBuilders::And.build([
+          keyword_matcher, value_matcher
+        ])
+        # :nocov:
+        raise unless pair_matcher
+
+        # :nocov:
+
+        ::Leftovers::Matchers::NodeHasAnyKeywordArgument.new(pair_matcher)
+      end
+    end
+  end
+end

data/lib/leftovers/matcher_builders/node_has_positional_argument.rb

@@ -0,0 +1,24 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module MatcherBuilders
+    module NodeHasPositionalArgument
+      def self.build(positions, value_matcher) # rubocop:disable Metrics/MethodLength
+        if positions && value_matcher
+          ::Leftovers::MatcherBuilders::Or.each_or_self(positions) do |position|
+            ::Leftovers::Matchers::NodeHasPositionalArgumentWithValue.new(position, value_matcher)
+          end
+        elsif positions
+          position = positions.is_a?(Array) ? positions.min : positions
+
+          ::Leftovers::Matchers::NodeHasPositionalArgument.new(position)
+        elsif value_matcher
+          ::Leftovers::Matchers::NodeHasAnyPositionalArgumentWithValue.new(value_matcher)
+        # :nocov:
+        else raise
+          # :nocov:
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/matcher_builders/node_name.rb

@@ -0,0 +1,15 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module MatcherBuilders
+    module NodeName
+      def self.build(name_pattern)
+        matcher = ::Leftovers::MatcherBuilders::Name.build(name_pattern)
+
+        return unless matcher
+
+        ::Leftovers::Matchers::NodeName.new(matcher)
+      end
+    end
+  end
+end

data/lib/leftovers/matcher_builders/node_pair_name.rb

@@ -0,0 +1,18 @@
+# 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/matcher_builders/node_pair_value.rb

@@ -0,0 +1,16 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module MatcherBuilders
+    module NodePairValue
+      def self.build(value_matcher)
+        return unless value_matcher
+
+        ::Leftovers::MatcherBuilders::And.build([
+          ::Leftovers::Matchers::NodeType.new(:pair),
+          ::Leftovers::Matchers::NodePairValue.new(value_matcher)
+        ])
+      end
+    end
+  end
+end

data/lib/leftovers/matcher_builders/node_path.rb

@@ -0,0 +1,14 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module MatcherBuilders
+    module NodePath
+      def self.build(path_pattern)
+        matcher = ::Leftovers::MatcherBuilders::Path.build(path_pattern)
+        return unless matcher
+
+        ::Leftovers::Matchers::NodePath.new(matcher)
+      end
+    end
+  end
+end

data/lib/leftovers/matcher_builders/node_type.rb

@@ -0,0 +1,28 @@
+# frozen-string-literal: true
+
+require 'set'
+
+module Leftovers
+  module MatcherBuilders
+    module NodeType
+      def self.build(types_pattern)
+        ::Leftovers::MatcherBuilders::Or.each_or_self(types_pattern) do |type|
+          case type
+          when 'Symbol' then ::Leftovers::Matchers::NodeType.new(:sym)
+          when 'String' then ::Leftovers::Matchers::NodeType.new(:str)
+          when 'Integer' then ::Leftovers::Matchers::NodeType.new(:int)
+          when 'Float' then ::Leftovers::Matchers::NodeType.new(:float)
+          # these would be neat but i can't think of a use-case
+          # when 'Array' then :array
+          # when 'Hash' then :hash
+          # when 'Method' then Set[:send, :csend, :def]
+          # when 'Constant' then Set[:const, :class, :module]
+          # :nocov:
+          else raise
+            # :nocov:
+          end
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/matcher_builders/or.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Leftovers
+  module MatcherBuilders
+    module Or
+      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(matchers)
+        matchers = compact(matchers)
+        case matchers.length
+          # :nocov:
+        when 0 then nil
+          # :nocov:
+        when 1 then matchers.first
+        when 2 then ::Leftovers::Matchers::Or.new(matchers.first, matchers[1])
+        else ::Leftovers::Matchers::Any.new(matchers.dup)
+        end
+      end
+
+      def self.flatten(value) # rubocop:disable Metrics/MethodLength
+        case value
+        when ::Leftovers::Matchers::Or
+          [*flatten(value.lhs), *flatten(value.rhs)]
+        when ::Leftovers::Matchers::Any
+          flatten(value.matchers)
+        when Array
+          ret = value.map { |v| flatten(v) }
+          ret.flatten!(1)
+          ret
+        else
+          value
+        end
+      end
+
+      def self.compact(matchers) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/AbcSize,
+        return matchers if matchers.length <= 1
+
+        set = Set.new
+        regexps = []
+        uncompactable = []
+
+        matchers = flatten(matchers)
+
+        matchers.each do |matcher|
+          case matcher
+          when nil then nil
+          when ::Integer, ::Symbol then set << matcher
+          # when ::Set then set.merge(matcher) # may not be necessary
+          when ::Regexp then regexps << matcher
+          else uncompactable << matcher
+          end
+        end
+
+        set = set.first if set.length <= 1
+        regexps = if regexps.length <= 1
+          regexps.first
+        else
+          Regexp.union(regexps)
+        end
+
+        [set, regexps].compact.concat(uncompactable)
+      end
+    end
+  end
+end