leftovers 0.2.2 → 0.4.2

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

data/lib/leftovers/matchers/node_type.rb

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

data/lib/leftovers/matchers/not.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Matchers
+    class Not
+      # :nocov:
+      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
+      # :nocov:
+
+      def initialize(matcher)
+        @matcher = matcher
+
+        freeze
+      end
+
+      def ===(value)
+        !(@matcher === value)
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/matchers/or.rb

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