require_relative '../test_helper'

module Paths
  class MatcherTest < Minitest::Test
    describe IOStreams::Paths::Matcher do
      let :cases do
        [
          {
            path:             "/path/work",
            pattern:          "a/b/c/**/*",
            expected_path:    "/path/work/a/b/c",
            expected_pattern: "**/*",
            recursive:        true,
            matches:          %w[/path/work/a/b/c/any/file /path/work/a/b/c/other/file /path/work/a/b/c/sub/.name],
            not_matches:      %w[/path/work/a/b/c/.profile]
          },
          {path: "/path/work", pattern: "a/b/c?/**/*", expected_path: "/path/work/a/b", expected_pattern: "c?/**/*", recursive: true},
          {path: "/path/work", pattern: "**/*", expected_path: "/path/work", expected_pattern: "**/*", recursive: true},
          # Case-insensitive exists that returns the actual file name.
          {path: "/path/work", pattern: "a/b/file.txt", expected_path: "/path/work/a/b/file.txt", expected_pattern: nil, recursive: false},
          {
            path:             "/path/work",
            pattern:          "a/b/file*{zip,gz}",
            expected_path:    "/path/work/a/b",
            expected_pattern: "file*{zip,gz}",
            recursive:        false,
            matches:          %w[/path/work/a/b/file.GZ /path/work/a/b/FILE.ZIP /path/work/a/b/file123.zIp],
            not_matches:      %w[/path/work/a/b/.profile /path/work/a/b/filter.zip],
            case_sensitive:   false
          },
          {
            path:             "/path/work",
            pattern:          "a/b/file*{zip,gz}",
            expected_path:    "/path/work/a/b",
            expected_pattern: "file*{zip,gz}",
            recursive:        false,
            matches:          %w[/path/work/a/b/file.gz /path/work/a/b/file.zip],
            not_matches:      %w[/path/work/a/b/file.GZ /path/work/a/b/FILE.ZIP],
            case_sensitive:   true
          },
          {path: "/path/work", pattern: "file.txt", expected_path: "/path/work/file.txt", expected_pattern: nil, recursive: false},
          {path: "/path/work", pattern: "*", expected_path: "/path/work", expected_pattern: "*", recursive: false},
        ]
      end
      # , case_sensitive: false, hidden: false

      describe '#recursive?' do
        it 'identifies recursive paths correctly' do
          cases.each do |test_case|
            path    = IOStreams.path(test_case[:path])
            matcher = IOStreams::Paths::Matcher.new(path, test_case[:pattern])
            assert_equal test_case[:recursive], matcher.recursive?, test_case
          end
        end
      end

      describe "#path?" do
        it 'optimizes path correctly' do
          cases.each do |test_case|
            path    = IOStreams.path(test_case[:path])
            matcher = IOStreams::Paths::Matcher.new(path, test_case[:pattern])
            assert_equal test_case[:expected_path], matcher.path.to_s, test_case
          end
        end
      end

      describe "#pattern" do
        it 'optimizes pattern correctly' do
          cases.each do |test_case|
            path    = IOStreams.path(test_case[:path])
            matcher = IOStreams::Paths::Matcher.new(path, test_case[:pattern])
            if test_case[:expected_pattern].nil?
              assert_nil matcher.pattern, test_case
            else
              assert_equal test_case[:expected_pattern], matcher.pattern, test_case
            end
          end
        end
      end

      describe "#match?" do
        it 'matches' do
          cases.each do |test_case|
            path           = IOStreams.path(test_case[:path])
            case_sensitive = test_case.fetch(:case_sensitive, false)
            matcher        = IOStreams::Paths::Matcher.new(path, test_case[:pattern], case_sensitive: case_sensitive)
            next unless test_case[:matches]

            test_case[:matches].each do |file_name|
              assert matcher.match?(file_name), test_case.merge(file_name: file_name)
            end
          end
        end

        it 'should not match' do
          cases.each do |test_case|
            path           = IOStreams.path(test_case[:path])
            case_sensitive = test_case.fetch(case_sensitive, :false)
            matcher        = IOStreams::Paths::Matcher.new(path, test_case[:pattern], case_sensitive: case_sensitive)
            next unless test_case[:not_matches]

            test_case[:not_matches].each do |file_name|
              refute matcher.match?(file_name), test_case.merge(file_name: file_name)
            end
          end
        end
      end

    end
  end
end