leftovers 0.2.3 → 0.4.3

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

data/lib/leftovers/matcher_builders/path.rb

@@ -0,0 +1,15 @@
+# frozen-string-literal: true
+
+require 'fast_ignore'
+
+module Leftovers
+  module MatcherBuilders
+    module Path
+      def self.build(path_pattern)
+        return if path_pattern.nil? || path_pattern.empty?
+
+        ::FastIgnore.new(include_rules: path_pattern, gitignore: false, root: Leftovers.pwd)
+      end
+    end
+  end
+end

data/lib/leftovers/matcher_builders/string.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module MatcherBuilders
+    module String
+      def self.build(pattern)
+        pattern.to_sym
+      end
+    end
+  end
+end

data/lib/leftovers/matcher_builders/string_pattern.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module MatcherBuilders
+    module StringPattern
+      def self.build(match: nil, has_prefix: nil, has_suffix: nil)
+        if match
+          /\A#{match}\z/
+        elsif has_prefix && has_suffix
+          /\A#{::Regexp.escape(has_prefix)}.*#{::Regexp.escape(has_suffix)}\z/
+        elsif has_prefix
+          /\A#{::Regexp.escape(has_prefix)}/
+        elsif has_suffix
+          /#{::Regexp.escape(has_suffix)}\z/
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/matcher_builders/unless.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module MatcherBuilders
+    module Unless
+      def self.build(matcher)
+        return unless matcher
+
+        ::Leftovers::Matchers::Not.new(matcher)
+      end
+    end
+  end
+end

data/lib/leftovers/matchers.rb

@@ -0,0 +1,26 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module Matchers
+    autoload(:All, "#{__dir__}/matchers/all")
+    autoload(:And, "#{__dir__}/matchers/and")
+    autoload(:Any, "#{__dir__}/matchers/any")
+    autoload(:NodeHasAnyKeywordArgument, "#{__dir__}/matchers/node_has_any_keyword_argument")
+    autoload(
+      :NodeHasAnyPositionalArgumentWithValue,
+      "#{__dir__}/matchers/node_has_any_positional_argument_with_value"
+    )
+    autoload(
+      :NodeHasPositionalArgumentWithValue,
+      "#{__dir__}/matchers/node_has_positional_argument_with_value"
+    )
+    autoload(:NodeHasPositionalArgument, "#{__dir__}/matchers/node_has_positional_argument")
+    autoload(:NodeName, "#{__dir__}/matchers/node_name")
+    autoload(:NodePairValue, "#{__dir__}/matchers/node_pair_value")
+    autoload(:NodePath, "#{__dir__}/matchers/node_path")
+    autoload(:NodeScalarValue, "#{__dir__}/matchers/node_scalar_value")
+    autoload(:NodeType, "#{__dir__}/matchers/node_type")
+    autoload(:Not, "#{__dir__}/matchers/not")
+    autoload(:Or, "#{__dir__}/matchers/or")
+  end
+end

data/lib/leftovers/matchers/all.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Matchers
+    class All
+      # :nocov:
+      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
+      # :nocov:
+
+      def initialize(matchers)
+        @matchers = matchers
+
+        freeze
+      end
+
+      def ===(value)
+        @matchers.all? do |matcher|
+          matcher === value
+        end
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/matchers/and.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Matchers
+    class And
+      # :nocov:
+      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
+      # :nocov:
+
+      def initialize(lhs, rhs)
+        @lhs = lhs
+        @rhs = rhs
+
+        freeze
+      end
+
+      def ===(value)
+        @lhs === value && @rhs === value
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/matchers/any.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Matchers
+    class Any
+      # :nocov:
+      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
+      # :nocov:
+
+      attr_reader :matchers
+
+      def initialize(matchers)
+        @matchers = matchers
+
+        freeze
+      end
+
+      def ===(value)
+        @matchers.any? do |matcher|
+          matcher === value
+        end
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/matchers/node_has_any_keyword_argument.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Matchers
+    class NodeHasAnyKeywordArgument
+      # :nocov:
+      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
+      # :nocov:
+
+      def initialize(pair_matcher)
+        @pair_matcher = pair_matcher
+
+        freeze
+      end
+
+      def ===(node)
+        kwargs = node.kwargs
+        return false unless kwargs
+
+        kwargs.children.any? do |pair|
+          @pair_matcher === pair
+        end
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/matchers/node_has_any_positional_argument_with_value.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Matchers
+    class NodeHasAnyPositionalArgumentWithValue
+      # :nocov:
+      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
+      # :nocov:
+
+      def initialize(matcher)
+        @matcher = matcher
+
+        freeze
+      end
+
+      def ===(node)
+        node.positional_arguments.any? do |value|
+          @matcher === value
+        end
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/matchers/node_has_positional_argument.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Matchers
+    class NodeHasPositionalArgument
+      # :nocov:
+      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
+      # :nocov:
+
+      def initialize(position)
+        @position = position
+
+        freeze
+      end
+
+      def ===(node)
+        node.positional_arguments[@position]
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/matchers/node_has_positional_argument_with_value.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Matchers
+    class NodeHasPositionalArgumentWithValue
+      # :nocov:
+      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
+      # :nocov:
+
+      def initialize(position, matcher)
+        @position = position
+        @matcher = matcher
+
+        freeze
+      end
+
+      def ===(node)
+        value_node = node.positional_arguments[@position]
+        @matcher === value_node if value_node
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/matchers/node_name.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Matchers
+    class NodeName
+      # :nocov:
+      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
+      # :nocov:
+
+      def initialize(name_matcher)
+        @name_matcher = name_matcher
+
+        freeze
+      end
+
+      def ===(node)
+        @name_matcher === node.name
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/matchers/node_pair_value.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Matchers
+    class NodePairValue
+      # :nocov:
+      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
+      # :nocov:
+
+      def initialize(value_matcher)
+        @value_matcher = value_matcher
+
+        freeze
+      end
+
+      def ===(node)
+        @value_matcher === node.second
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/matchers/node_path.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Matchers
+    class NodePath
+      # :nocov:
+      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
+      # :nocov:
+
+      def initialize(path_matcher)
+        @path_matcher = path_matcher
+
+        freeze
+      end
+
+      def ===(node)
+        @path_matcher === node.path
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/matchers/node_scalar_value.rb

@@ -0,0 +1,25 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module Matchers
+    class NodeScalarValue
+      # :nocov:
+      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
+      # :nocov:
+
+      def initialize(matcher)
+        @matcher = matcher
+
+        freeze
+      end
+
+      def ===(node)
+        return false unless node.scalar?
+
+        @matcher === node.to_scalar_value
+      end
+
+      freeze
+    end
+  end
+end