rspec-path_matchers 0.1.0

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RSpec
+  module PathMatchers
+    module Options
+      # atime: <expected>
+      class Atime
+        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.stat(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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RSpec
+  module PathMatchers
+    module Options
+      # birthtime: <expected>
+      class Birthtime
+        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.stat(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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RSpec
+  module PathMatchers
+    module Options
+      # content: <expected>
+      class Content
+        def self.key = :content
+
+        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?(Regexp) ||
+                    RSpec::PathMatchers.matcher?(expected)
+
+          failure_messages <<
+            "expected `#{key}:` to be a String, Regexp, or Matcher, 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 = File.read(path)
+          case expected
+          when String then match_string(actual, expected, failure_messages)
+          when Regexp then match_regexp(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 content to be #{expected.inspect}"
+        end
+
+        private_class_method def self.match_regexp(actual, expected, failure_messages)
+          return if expected.match?(actual)
+
+          failure_messages << "expected content to match #{expected.inspect}"
+        end
+
+        private_class_method def self.match_matcher(actual, expected, failure_messages)
+          return if expected.matches?(actual)
+
+          failure_messages << "expected content to #{expected.description}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RSpec
+  module PathMatchers
+    module Options
+      # ctime: <expected>
+      class Ctime
+        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.stat(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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RSpec
+  module PathMatchers
+    module Options
+      # group: <expected>
+      class Group
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module RSpec
+  module PathMatchers
+    module Options
+      # json_content: <expected>
+      class JsonContent
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RSpec
+  module PathMatchers
+    module Options
+      # mode: <expected>
+      class Mode
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RSpec
+  module PathMatchers
+    module Options
+      # mtime: <expected>
+      class Mtime
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RSpec
+  module PathMatchers
+    module Options
+      # owner: <expected>
+      class Owner
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RSpec
+  module PathMatchers
+    module Options
+      # size: <expected>
+      class Size
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RSpec
+  module PathMatchers
+    module Options
+      # atime: <expected>
+      class SymlinkAtime
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RSpec
+  module PathMatchers
+    module Options
+      # birthtime: <expected>
+      class SymlinkBirthtime
+        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
+      end
+    end
+  end
+end