rspec-path_matchers 0.1.1 → 0.2.0

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

@@ -1,62 +1,15 @@
 # frozen_string_literal: true
 
+require_relative 'etc_base'
+
 module RSpec
   module PathMatchers
     module Options
       # group: <expected>
-      class Group
+      class Group < EtcBase
         def self.key = :group
-
-        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.getgrgid(File.stat(path).gid).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?(:getgrgid)
-
-          # If the platform doesn't support Group checks, warn the user and skip the check
-          message = 'WARNING: Group 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 group 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 group to #{expected.description}, but was #{actual.inspect}"
-        end
+        def self.stat_attribute = :gid
+        def self.etc_method = :getgrgid
       end
     end
   end

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

@@ -2,41 +2,17 @@
 
 require 'json'
 
+require_relative 'parsed_content_base'
+
 module RSpec
   module PathMatchers
     module Options
       # json_content: <expected>
-      class JsonContent
+      class JsonContent < ParsedContentBase
         def self.key = :json_content
-
-        def self.description(expected)
-          return 'be json 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)
-          actual = JSON.parse(File.read(path))
-
-          return if expected == true
-
-          failure_messages << "expected JSON content to #{expected.description}" unless expected.matches?(actual)
-        rescue JSON::ParserError => e
-          failure_messages << "expected valid JSON content, but got error: #{e.message}"
-        end
+        private_class_method def self.content_type  = 'JSON'
+        private_class_method def self.parse(string) = JSON.parse(string)
+        private_class_method def self.parsing_error = JSON::ParserError
       end
     end
   end

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

@@ -1,50 +1,16 @@
 # frozen_string_literal: true
 
+require_relative 'file_stat_base'
+
 module RSpec
   module PathMatchers
     module Options
       # mode: <expected>
-      class Mode
+      class Mode < FileStatBase
         def self.key = :mode
-
-        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 matches the expected mode
-        # @param path [String] the path of the entry to check
-        # @return [String, nil]
-        #
-        def self.match(path, expected, failure_messages)
-          actual = File.stat(path).mode.to_s(8)[-4..] # Get the last 4 characters of the octal mode
-          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 mode 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 mode to #{expected.description}, but was #{actual.inspect}"
-        end
+        def self.stat_attribute = :mode
+        def self.valid_expected_types = [String]
+        def self.fetch_actual(path, _failures) = File.stat(path).mode.to_s(8)[-4..]
       end
     end
   end

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

@@ -1,50 +1,16 @@
 # frozen_string_literal: true
 
+require_relative 'file_stat_base'
+
 module RSpec
   module PathMatchers
     module Options
-      # mtime: <expected>
-      class Mtime
+      # Inherits all logic from FileStatOption
+      class Mtime < 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.stat(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
       end
     end
   end

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

@@ -1,62 +1,15 @@
 # frozen_string_literal: true
 
+require_relative 'etc_base'
+
 module RSpec
   module PathMatchers
     module Options
-      # owner: <expected>
-      class Owner
+      # group: <expected>
+      class Owner < 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.stat(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_attribute = :uid
+        def self.etc_method = :getpwuid
       end
     end
   end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module RSpec
+  module PathMatchers
+    module Options
+      # Base class for options that parse file content like JSON, and YAML
+      class ParsedContentBase < Base
+        def self.valid_expected_types = [TrueClass]
+
+        # Reads and parses the file content
+        #
+        # This method will rescue any parsing errors (e.g., `JSON::ParserError`)
+        # and add a descriptive failure instead of crashing.
+        #
+        # @param (see RSpec::PathMatchers::Options::Base.fetch_actual)
+        #
+        # @return [Object, FETCH_ERROR] The parsed content (e.g., a Hash) or FETCH_ERROR.
+        #
+        def self.fetch_actual(path, failures)
+          parse(File.read(path))
+        rescue parsing_error => e
+          message = "expected valid #{content_type} content, but got error: #{e.message}"
+          add_failure(message, failures)
+          FETCH_ERROR
+        end
+
+        # This is the `xxxx_content: true` case. A successful fetch_actual is sufficient
+        def self.match_literal(_actual, _expected, _failures); end
+
+        # Compares the parsed content against the given RSpec matcher.
+        #
+        # @param (see RSpec::PathMatchers::Options::Base.match_matcher)
+        #
+        # @return [void]
+        #
+        def self.match_matcher(actual, expected, failures)
+          return if expected.matches?(actual)
+
+          message = "expected #{content_type} content to #{expected.description}"
+          add_failure(message, failures)
+        end
+
+        # Provides a human-readable description for the option
+        #
+        # Returns a special message for the `json_content: true` case.
+        #
+        def self.description(expected)
+          expected == true ? "be #{content_type.downcase} content" : super
+        end
+
+        private_class_method def self.content_type
+          raise NotImplementedError, 'Subclasses must implement ParsedContentBase.content_type'
+        end
+
+        private_class_method def self.parse(string)
+          raise NotImplementedError, 'Subclasses must implement ParsedContentBase.parse'
+        end
+
+        private_class_method def self.parsing_error
+          raise NotImplementedError, 'Subclasses must implement ParsedContentBase.parsing_error'
+        end
+      end
+    end
+  end
+end

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

@@ -1,50 +1,15 @@
 # frozen_string_literal: true
 
+require_relative 'file_stat_base'
+
 module RSpec
   module PathMatchers
     module Options
       # size: <expected>
-      class Size
+      class Size < FileStatBase
         def self.key = :size
-
-        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?(Integer) ||
-                    RSpec::PathMatchers.matcher?(expected)
-
-          failure_messages <<
-            "expected `#{key}:` to be a Matcher or an Integer, 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.size(path)
-          case expected
-          when Integer then match_integer(actual, expected, failure_messages)
-          else              match_matcher(actual, expected, failure_messages)
-          end
-        end
-
-        # private methods
-
-        private_class_method def self.match_integer(actual, expected, failure_messages)
-          return if expected == actual
-
-          failure_messages << "expected size 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 size to #{expected.description}, but was #{actual.inspect}"
-        end
+        def self.stat_attribute = :size
+        def self.valid_expected_types = [Integer]
       end
     end
   end

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

@@ -1,50 +1,17 @@
 # frozen_string_literal: true
 
+require_relative 'file_stat_base'
+
 module RSpec
   module PathMatchers
     module Options
       # atime: <expected>
-      class SymlinkAtime
+      class SymlinkAtime < FileStatBase
         def self.key = :atime
-
-        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 expected value matches the actual value
-        # @param path [String] the path of the entry to check
-        # @return [String, nil]
-        #
-        def self.match(path, expected, failure_messages)
-          actual = File.lstat(path).atime
-          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 #{key} 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 #{key} to #{expected.description}, but was #{actual.inspect}"
-        end
+        def self.stat_attribute = :atime
+        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_birthtime.rb

@@ -1,59 +1,17 @@
 # frozen_string_literal: true
 
+require_relative 'file_stat_base'
+
 module RSpec
   module PathMatchers
     module Options
       # birthtime: <expected>
-      class SymlinkBirthtime
+      class SymlinkBirthtime < FileStatBase
         def self.key = :birthtime
-
-        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 expected birthtime matches the actual birthtime
-        # @param path [String] the path of the entry to check
-        # @param expected [Object] the expected value to match against the actual value
-        # @param failure_messages [Array<String>] the array to append failure messages to
-        # @return [Void]
-        #
-        def self.match(path, expected, failure_messages) # rubocop:disable Metrics/MethodLength
-          begin
-            actual = File.lstat(path).birthtime
-          rescue NotImplementedError
-            message = "WARNING: #{key} expectations are not supported for #{path} and will be skipped"
-            RSpec.configuration.reporter.message(message)
-            return
-          end
-
-          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 #{key} 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 #{key} to #{expected.description}, but was #{actual.inspect}"
-        end
+        def self.stat_attribute = :birthtime
+        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_ctime.rb

@@ -1,50 +1,17 @@
 # frozen_string_literal: true
 
+require_relative 'file_stat_base'
+
 module RSpec
   module PathMatchers
     module Options
       # ctime: <expected>
-      class SymlinkCtime
+      class SymlinkCtime < FileStatBase
         def self.key = :ctime
-
-        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).ctime
-          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 ctime 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 ctime to #{expected.description}, but was #{actual.inspect}"
-        end
+        def self.stat_attribute = :ctime
+        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_group.rb

@@ -1,62 +1,16 @@
 # frozen_string_literal: true
 
+require_relative 'etc_base'
+
 module RSpec
   module PathMatchers
     module Options
       # group: <expected>
-      class SymlinkGroup
+      class SymlinkGroup < EtcBase
         def self.key = :group
-
-        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 group
-        # @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.getgrgid(File.lstat(path).gid).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?(:getgrgid)
-
-          # If the platform doesn't support Group checks, warn the user and skip the check
-          message = 'WARNING: Group 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 group 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 group to #{expected.description}, but was #{actual.inspect}"
-        end
+        def self.stat_source_method = :lstat
+        def self.stat_attribute = :gid
+        def self.etc_method = :getgrgid
       end
     end
   end