rspec-path_matchers 0.1.0

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RSpec
+  module PathMatchers
+    module Options
+      # target_exist: <expected>
+      class SymlinkTargetExist
+        def self.key = :target_exist?
+
+        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}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RSpec
+  module PathMatchers
+    module Options
+      # target_type: <expected>
+      class SymlinkTargetType
+        def self.key = :target_type
+
+        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]
+        #
+        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}"
+        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/yaml_content.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module RSpec
+  module PathMatchers
+    module Options
+      # yaml_content: <expected>
+      class YamlContent
+        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
+      end
+    end
+  end
+end

data/lib/rspec/path_matchers/options.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RSpec
+  module PathMatchers
+    module Options
+      # The value used to indicate that an option was not given by the user
+      NOT_GIVEN = Object.new.freeze
+    end
+  end
+end
+
+# Load all option classes
+require_relative 'options/atime'
+require_relative 'options/birthtime'
+require_relative 'options/content'
+require_relative 'options/ctime'
+require_relative 'options/group'
+require_relative 'options/json_content'
+require_relative 'options/mode'
+require_relative 'options/mtime'
+require_relative 'options/owner'
+require_relative 'options/size'
+require_relative 'options/yaml_content'
+
+require_relative 'options/symlink_atime'
+require_relative 'options/symlink_birthtime'
+require_relative 'options/symlink_ctime'
+require_relative 'options/symlink_group'
+require_relative 'options/symlink_mtime'
+require_relative 'options/symlink_owner'
+require_relative 'options/symlink_target'
+require_relative 'options/symlink_target_exist'
+require_relative 'options/symlink_target_type'

data/lib/rspec/path_matchers/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RSpec
+  module PathMatchers
+    VERSION = '0.1.0'
+  end
+end

data/lib/rspec/path_matchers.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'rspec'
+
+module RSpec
+  # RSpec::PathMatchers is a collection of matchers for testing directory entries
+  module PathMatchers
+    # Returns true if object is a matcher
+    def self.matcher?(object)
+      object.respond_to?(:matches?) && object.respond_to?(:description)
+    end
+  end
+end
+
+require_relative 'path_matchers/version'
+require_relative 'path_matchers/options'
+
+require_relative 'path_matchers/matchers/have_file'
+require_relative 'path_matchers/matchers/have_directory'
+require_relative 'path_matchers/matchers/have_symlink'
+require_relative 'path_matchers/matchers/have_no_entry'
+
+def have_file(name, **options_hash) # rubocop:disable Naming/PredicatePrefix
+  RSpec::PathMatchers::Matchers::HaveFile.new(name, **options_hash)
+end
+
+def have_dir(name, **options_hash, &) # rubocop:disable Naming/PredicatePrefix
+  RSpec::PathMatchers::Matchers::HaveDirectory.new(name, **options_hash, &)
+end
+
+def have_symlink(name, **options_hash) # rubocop:disable Naming/PredicatePrefix
+  RSpec::PathMatchers::Matchers::HaveSymlink.new(name, **options_hash)
+end

data/package.json

@@ -0,0 +1,11 @@
+{
+  "devDependencies": {
+    "@commitlint/cli": "^19.5.0",
+    "@commitlint/config-conventional": "^19.5.0",
+    "husky": "^9.1.0"
+  },
+  "scripts": {
+    "postinstall": "husky",
+    "prepare": "husky"
+  }
+}

data/release-please-config.json

@@ -0,0 +1,36 @@
+{
+  "packages": {
+    ".": {
+      "release-type": "ruby",
+      "package-name": "rspec-path_matchers",
+      "changelog-path": "CHANGELOG.md",
+      "version-file": "lib/rspec/path_matchers/version.rb",
+      "bump-minor-pre-major": true,
+      "bump-patch-for-minor-pre-major": true,
+      "draft": false,
+      "prerelease": false,
+      "include-component-in-tag": false,
+      "pull-request-title-pattern": "chore: release v${version}",
+      "changelog-sections": [
+        { "type": "feat",     "section": "Features",      "hidden": false },
+        { "type": "fix",      "section": "Bug Fixes",     "hidden": false },
+        { "type": "build",    "section": "Other Changes", "hidden": false },
+        { "type": "chore",    "section": "Other Changes", "hidden": false },
+        { "type": "ci",       "section": "Other Changes", "hidden": false },
+        { "type": "docs",     "section": "Other Changes", "hidden": false },
+        { "type": "perf",     "section": "Other Changes", "hidden": false },
+        { "type": "refactor", "section": "Other Changes", "hidden": false },
+        { "type": "revert",   "section": "Other Changes", "hidden": false },
+        { "type": "style",    "section": "Other Changes", "hidden": false },
+        { "type": "test",     "section": "Other Changes", "hidden": false }
+      ]
+    }
+  },
+  "initial-version": "0.1.0",
+  "plugins": [
+    {
+      "type": "sentence-case"
+    }
+  ],
+  "$schema": "https://raw.githubusercontent.com/googleapis/release-please/main/schemas/config.json"
+}