rspec-path_matchers 0.1.1 → 0.2.1

data/lib/rspec/path_matchers/options/symlink_mtime.rb

@@ -1,50 +1,17 @@
 # frozen_string_literal: true
 
+require_relative 'file_stat_base'
+
 module RSpec
   module PathMatchers
     module Options
       # mtime: <expected>
-      class SymlinkMtime
+      class SymlinkMtime < FileStatBase
         def self.key = :mtime
-
-        def self.description(expected)
-          RSpec::PathMatchers.matcher?(expected) ? expected.description : expected.inspect
-        end
-
-        def self.validate_expected(expected, failure_messages)
-          return if expected == NOT_GIVEN ||
-                    expected.is_a?(Time) || expected.is_a?(DateTime) ||
-                    RSpec::PathMatchers.matcher?(expected)
-
-          failure_messages <<
-            "expected `#{key}:` to be a Matcher, Time, or DateTime, but was #{expected.inspect}"
-        end
-
-        # Returns nil if the path matches the expected size
-        # @param path [String] the path of the entry to check
-        # @return [String, nil]
-        #
-        def self.match(path, expected, failure_messages)
-          actual = File.lstat(path).mtime
-          case expected
-          when Time, DateTime then match_time(actual, expected, failure_messages)
-          else                     match_matcher(actual, expected, failure_messages)
-          end
-        end
-
-        # private methods
-
-        private_class_method def self.match_time(actual, expected, failure_messages)
-          return if expected.to_time == actual
-
-          failure_messages << "expected mtime to be #{expected.to_time.inspect}, but was #{actual.inspect}"
-        end
-
-        private_class_method def self.match_matcher(actual, expected, failure_messages)
-          return if expected.matches?(actual)
-
-          failure_messages << "expected mtime to #{expected.description}, but was #{actual.inspect}"
-        end
+        def self.stat_attribute = :mtime
+        def self.valid_expected_types = [Time, DateTime]
+        def self.normalize_expected_literal(expected) = expected.to_time
+        def self.stat_source_method = :lstat
       end
     end
   end

data/lib/rspec/path_matchers/options/symlink_owner.rb

@@ -1,62 +1,16 @@
 # frozen_string_literal: true
 
+require_relative 'etc_base'
+
 module RSpec
   module PathMatchers
     module Options
-      # owner: <expected>
-      class SymlinkOwner
+      # group: <expected>
+      class SymlinkOwner < EtcBase
         def self.key = :owner
-
-        def self.description(expected)
-          RSpec::PathMatchers.matcher?(expected) ? expected.description : expected.inspect
-        end
-
-        def self.validate_expected(expected, failure_messages)
-          return if expected == NOT_GIVEN ||
-                    expected.is_a?(String) ||
-                    RSpec::PathMatchers.matcher?(expected)
-
-          failure_messages <<
-            "expected `#{key}:` to be a Matcher or a String, but was #{expected.inspect}"
-        end
-
-        # Returns nil if the path is owned by the expected owner
-        # @param path [String] the path of the entry to check
-        # @return [String, nil]
-        #
-        def self.match(path, expected, failure_messages)
-          return if unsupported_platform?
-
-          actual = Etc.getpwuid(File.lstat(path).uid).name
-
-          case expected
-          when String then match_string(actual, expected, failure_messages)
-          else             match_matcher(actual, expected, failure_messages)
-          end
-        end
-
-        # private methods
-
-        private_class_method def self.unsupported_platform?
-          return false if Etc.respond_to?(:getpwuid)
-
-          # If the platform doesn't support ownership, warn the user and skip the check
-          message = 'WARNING: Owner expectations are not supported on this platform and will be skipped.'
-          RSpec.configuration.reporter.message(message)
-          true
-        end
-
-        private_class_method def self.match_string(actual, expected, failure_messages)
-          return if expected == actual
-
-          failure_messages << "expected owner to be #{expected.inspect}, but was #{actual.inspect}"
-        end
-
-        private_class_method def self.match_matcher(actual, expected, failure_messages)
-          return if expected.matches?(actual)
-
-          failure_messages << "expected owner to #{expected.description}, but was #{actual.inspect}"
-        end
+        def self.stat_source_method = :lstat
+        def self.stat_attribute = :uid
+        def self.etc_method = :getpwuid
       end
     end
   end

data/lib/rspec/path_matchers/options/symlink_target.rb

@@ -1,53 +1,16 @@
 # frozen_string_literal: true
 
+require_relative 'base'
+
 module RSpec
   module PathMatchers
     module Options
       # target: <expected>
-      class SymlinkTarget
+      class SymlinkTarget < Base
         def self.key = :target
-
-        def self.description(expected)
-          RSpec::PathMatchers.matcher?(expected) ? expected.description : expected.inspect
-        end
-
-        def self.validate_expected(expected, failure_messages)
-          return if expected == NOT_GIVEN ||
-                    expected.is_a?(String) ||
-                    RSpec::PathMatchers.matcher?(expected)
-
-          failure_messages <<
-            "expected `#{key}:` to be a Matcher or a String, but was #{expected.inspect}"
-        end
-
-        # Populates failure_messages if expected value does not match actual value
-        # @param path [String] the path of the entry to check
-        # @param expected [Object] the expected value
-        # @param failure_messages [Array<String>] the array to populate with failure messages
-        # @return [Void]
-        #
-        def self.match(path, expected, failure_messages)
-          actual = File.readlink(path)
-
-          case expected
-          when String then match_string(actual, expected, failure_messages)
-          else             match_matcher(actual, expected, failure_messages)
-          end
-        end
-
-        # private methods
-
-        private_class_method def self.match_string(actual, expected, failure_messages)
-          return if expected == actual
-
-          failure_messages << "expected #{key} to be #{expected.inspect}, but was #{actual.inspect}"
-        end
-
-        private_class_method def self.match_matcher(actual, expected, failure_messages)
-          return if expected.matches?(actual)
-
-          failure_messages << "expected #{key} to #{expected.description}, but was #{actual.inspect}"
-        end
+        def self.valid_expected_types = [String]
+        def self.normalize_expected_literal(expected) = expected.to_s
+        def self.fetch_actual(path, _failures) = File.readlink(path)
       end
     end
   end

data/lib/rspec/path_matchers/options/symlink_target_exist.rb

@@ -1,52 +1,17 @@
 # frozen_string_literal: true
 
+require_relative 'base'
+
 module RSpec
   module PathMatchers
     module Options
       # target_exist: <expected>
-      class SymlinkTargetExist
+      class SymlinkTargetExist < Base
         def self.key = :target_exist
+        def self.valid_expected_types = [TrueClass, FalseClass]
 
-        def self.description(expected)
-          RSpec::PathMatchers.matcher?(expected) ? expected.description : expected.to_s
-        end
-
-        def self.validate_expected(expected, failure_messages)
-          return if expected == NOT_GIVEN ||
-                    expected.is_a?(TrueClass) || expected.is_a?(FalseClass) ||
-                    RSpec::PathMatchers.matcher?(expected)
-
-          failure_messages <<
-            "expected `#{key}:` to be a Matcher, true, or false but was #{expected.inspect}"
-        end
-
-        # Populates failure_messages if expected value does not match actual value
-        # @param path [String] the path of the entry to check
-        # @param expected [Object] the expected value
-        # @param failure_messages [Array<String>] the array to populate with failure messages
-        # @return [Void]
-        #
-        def self.match(path, expected, failure_messages)
-          actual = File.exist?(File.expand_path(File.readlink(path), File.dirname(path)))
-
-          case expected
-          when true, false then match_boolean(actual, expected, failure_messages)
-          else                  match_matcher(actual, expected, failure_messages)
-          end
-        end
-
-        # private methods
-
-        private_class_method def self.match_boolean(actual, expected, failure_messages)
-          return if expected == actual
-
-          failure_messages << "expected #{key} to be #{expected.inspect}, but was #{actual.inspect}"
-        end
-
-        private_class_method def self.match_matcher(actual, expected, failure_messages)
-          return if expected.matches?(actual)
-
-          failure_messages << "expected #{key} to #{expected.description}, but was #{actual.inspect}"
+        def self.fetch_actual(path, _failures) # rubocop:disable Naming/PredicateMethod
+          File.exist?(File.expand_path(File.readlink(path), File.dirname(path)))
         end
       end
     end

data/lib/rspec/path_matchers/options/symlink_target_type.rb

@@ -1,57 +1,34 @@
 # frozen_string_literal: true
 
+require_relative 'base'
+
 module RSpec
   module PathMatchers
     module Options
       # target_type: <expected>
-      class SymlinkTargetType
+      #
+      # Checks the type of the entry a symlink points to (e.g., 'file', 'directory').
+      #
+      class SymlinkTargetType < Base
         def self.key = :target_type
+        def self.valid_expected_types = [String, Symbol]
+        def self.normalize_expected_literal(expected) = expected.to_s
 
-        def self.description(expected)
-          RSpec::PathMatchers.matcher?(expected) ? expected.description : expected.inspect
-        end
-
-        def self.validate_expected(expected, failure_messages)
-          return if expected == NOT_GIVEN ||
-                    expected.is_a?(String) || expected.is_a?(Symbol) ||
-                    RSpec::PathMatchers.matcher?(expected)
-
-          failure_messages <<
-            "expected `#{key}:` to be a Matcher, a String, or a Symbol but was #{expected.inspect}"
-        end
-
-        # Populates failure_messages if expected value does not match actual value
-        # @param path [String] the path of the entry to check
-        # @param expected [Object] the expected value
-        # @param failure_messages [Array<String>] the array to populate with failure messages
-        # @return [Void]
+        # Overrides the base match method to gracefully handle dangling symlinks
         #
-        def self.match(path, expected, failure_messages)
-          begin
-            actual = File.ftype(File.expand_path(File.readlink(path), File.dirname(path)))
-          rescue Errno::ENOENT => e
-            failure_messages << "expected the symlink target to exist, but got error: #{e.message}"
-            return
-          end
-
-          case expected
-          when String, Symbol then match_string(actual, expected, failure_messages)
-          else                     match_matcher(actual, expected, failure_messages)
-          end
-        end
-
-        # private methods
-
-        private_class_method def self.match_string(actual, expected, failure_messages)
-          return if expected.to_s == actual
-
-          failure_messages << "expected #{key} to be #{expected.to_s.inspect}, but was #{actual.inspect}"
+        # If `File.ftype` fails because the target doesn't exist, it adds a
+        # descriptive failure instead of crashing.
+        #
+        def self.match(path, expected, failures)
+          super
+        rescue Errno::ENOENT => e
+          message = "expected the symlink target to exist, but got error: #{e.message}"
+          add_failure(message, failures)
+          nil
         end
 
-        private_class_method def self.match_matcher(actual, expected, failure_messages)
-          return if expected.matches?(actual)
-
-          failure_messages << "expected #{key} to #{expected.description}, but was #{actual.inspect}"
+        def self.fetch_actual(path, _failures)
+          File.ftype(File.expand_path(File.readlink(path), File.dirname(path)))
         end
       end
     end

data/lib/rspec/path_matchers/options/yaml_content.rb

@@ -2,42 +2,17 @@
 
 require 'yaml'
 
+require_relative 'parsed_content_base'
+
 module RSpec
   module PathMatchers
     module Options
       # yaml_content: <expected>
-      class YamlContent
+      class YamlContent < ParsedContentBase
         def self.key = :yaml_content
-
-        def self.description(expected)
-          return 'be yaml content' if expected == true
-
-          expected.description
-        end
-
-        def self.validate_expected(expected, failure_messages)
-          return if expected == NOT_GIVEN ||
-                    expected == true ||
-                    RSpec::PathMatchers.matcher?(expected)
-
-          failure_messages <<
-            "expected `#{key}:` to be a Matcher or true, but was #{expected.inspect}"
-        end
-
-        # Returns nil if the path matches the expected content
-        # @param path [String] the path of the entry to check
-        # @return [String, nil]
-        #
-        def self.match(path, expected, failure_messages)
-          require 'yaml'
-          actual = YAML.safe_load_file(path)
-
-          return if expected == true
-
-          failure_messages << "expected YAML content to #{expected.description}" unless expected.matches?(actual)
-        rescue Psych::SyntaxError => e
-          failure_messages << "expected valid YAML content, but got error: #{e.message}"
-        end
+        private_class_method def self.content_type  = 'YAML'
+        private_class_method def self.parse(string) = YAML.safe_load(string)
+        private_class_method def self.parsing_error = Psych::SyntaxError
       end
     end
   end

data/lib/rspec/path_matchers/options.rb

@@ -5,6 +5,7 @@ module RSpec
     module Options
       # The value used to indicate that an option was not given by the user
       NOT_GIVEN = Object.new.freeze
+      FETCH_ERROR = Object.new.freeze
     end
   end
 end

data/lib/rspec/path_matchers/refinements.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RSpec
+  module PathMatchers
+    # Refinements for various classes used in RSpec::PathMatchers
+    module Refinements
+      # Refinements for Array to provide a `to_sentence` method
+      #
+      # @example
+      #   using RSpec::PathMatchers::Refinements::ArrayRefinements
+      #
+      module ArrayRefinements
+        DEFAULT_SENTENCE_OPTIONS = Data.define(:conjunction, :delimiter, :oxford) do
+          def initialize(conjunction: 'and', delimiter: ',', oxford: true)
+            super
+          end
+
+          def two_word_connector
+            "#{delimiter} "
+          end
+
+          def last_word_connector
+            oxford ? "#{delimiter} #{conjunction} " : " #{conjunction} "
+          end
+        end.new
+
+        refine Array do
+          # Converts an array to a sentence with proper conjunctions and delimiters
+          #
+          # @example
+          #   using RSpec::PathMatchers::Refinements::ArrayRefinements
+          #   [].to_sentence # => ''
+          #   ['apple'].to_sentence # => 'apple'
+          #   ['apple', 'banana'].to_sentence # => 'apple and banana'
+          #   ['apple', 'banana', 'cherry'].to_sentence # => 'apple, banana, and cherry'
+          #
+          # @example using a different conjunction
+          #   using RSpec::PathMatchers::Refinements::ArrayRefinements
+          #   ['apple', 'banana', 'cherry'].to_sentence(conjunction: 'or')
+          #   #=> 'apple, banana, or cherry'
+          #
+          # @example using a different delimiter
+          #   using RSpec::PathMatchers::Refinements::ArrayRefinements
+          #   ['apple', 'banana', 'cherry'].to_sentence(delimiter: ';')
+          #   #=> 'apple; banana; and cherry'
+          #
+          # @example without the Oxford comma
+          #   using RSpec::PathMatchers::Refinements::ArrayRefinements
+          #   ['apple', 'banana', 'cherry'].to_sentence(oxford: false)
+          #   #=> 'apple, banana and cherry'
+          #
+          # @param options_hash [Hash] Options to customize the sentence format
+          #
+          # @option options_hash [String] :conjunction ('and') The word to use
+          #   before the last item in the sentence
+          #
+          # @option options_hash [String] :delimiter (',') The delimiter to use
+          #   between items in the sentence when there are three or more items
+          #
+          # @option options_hash [Boolean] :oxford (true) Whether to use the
+          #   Oxford comma before the conjunction
+          #
+          # @return [String] The array converted to a sentence
+          #
+          def to_sentence(options_hash = {})
+            options = DEFAULT_SENTENCE_OPTIONS.with(**options_hash)
+
+            case length
+            when 0 then ''
+            when 1 then first.to_s
+            when 2 then join(" #{options.conjunction} ")
+            else "#{self[0..-2].join(options.two_word_connector)}#{options.last_word_connector}#{last}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/path_matchers/version.rb

@@ -2,6 +2,6 @@
 
 module RSpec
   module PathMatchers
-    VERSION = '0.1.1'
+    VERSION = '0.2.1'
   end
 end