fear 1.2.0 → 2.0.0

data/spec/fear/extractor/value_matcher_number_spec.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Fear::Extractor::ValueMatcher, "Number" do
-  let(:parser) { Fear::Extractor::GrammarParser.new }
-  let(:matcher) { parser.parse(pattern).to_matcher }
-
-  describe "#defined_at?" do
-    subject { matcher }
-
-    context "Integer" do
-      let(:pattern) { "1" }
-
-      it { is_expected.to be_defined_at(1) }
-      it { is_expected.to be_defined_at(1.0) }
-      it { is_expected.not_to be_defined_at(2) }
-      it { is_expected.not_to be_defined_at("1") }
-    end
-
-    context "Float" do
-      context "against float" do
-        let(:pattern) { "1.2" }
-
-        it { is_expected.to be_defined_at(1.2) }
-        it { is_expected.not_to be_defined_at(1.3) }
-      end
-
-      context "against integer" do
-        let(:pattern) { "1.0" }
-
-        it { is_expected.to be_defined_at(1) }
-        it { is_expected.not_to be_defined_at(2) }
-        it { is_expected.not_to be_defined_at("1") }
-      end
-    end
-  end
-
-  describe "#call" do
-    subject { matcher.(other) }
-
-    let(:pattern) { "1.0" }
-
-    context "defined" do
-      let(:other) { 1 }
-
-      it { is_expected.to eq({}) }
-    end
-  end
-
-  describe "#failure_reason" do
-    subject { matcher.failure_reason(other) }
-
-    let(:pattern) { "1.0" }
-
-    context "match integer" do
-      let(:other) { 1 }
-      let(:pattern) { "1" }
-
-      it { is_expected.to eq(Fear.none) }
-    end
-
-    context "match float" do
-      let(:other) { 1.0 }
-      let(:pattern) { "1" }
-
-      it { is_expected.to eq(Fear.none) }
-    end
-
-    context "does not match another integer" do
-      let(:other) { 2 }
-      let(:pattern) { "1" }
-
-      it { is_expected.to eq(Fear.some(<<~ERROR.strip)) }
-        Expected `2` to match:
-        1
-        ^
-      ERROR
-    end
-  end
-end

data/spec/fear/extractor/value_matcher_string_spec.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Fear::Extractor::ValueMatcher, "String" do
-  let(:parser) { Fear::Extractor::GrammarParser.new }
-  let(:matcher) { parser.parse(pattern).to_matcher }
-
-  describe "#defined_at?" do
-    subject { matcher }
-
-    context "double quotas" do
-      let(:pattern) { %("foo") }
-
-      it { is_expected.to be_defined_at("foo") }
-      it { is_expected.not_to be_defined_at("boo") }
-      it { is_expected.not_to be_defined_at(2) }
-
-      context "single quotes inside" do
-        let(:pattern) { %("f'o'o") }
-
-        it { is_expected.to be_defined_at(%(f'o'o)) }
-        it { is_expected.not_to be_defined_at(%(f"o"o)) }
-      end
-
-      context "escaped double quotes inside" do
-        let(:pattern) { '"f\"oo"' }
-
-        it { is_expected.to be_defined_at('f"oo') }
-        it { is_expected.not_to be_defined_at("f'oo") }
-      end
-    end
-
-    context "single quotas" do
-      let(:pattern) { %('foo') }
-
-      it { is_expected.to be_defined_at("foo") }
-      it { is_expected.not_to be_defined_at("boo") }
-      it { is_expected.not_to be_defined_at(2) }
-
-      context "double quotes inside" do
-        let(:pattern) { %('f"o"o') }
-
-        it { is_expected.to be_defined_at(%(f"o"o)) }
-        it { is_expected.not_to be_defined_at(%(f'o'o)) }
-      end
-
-      context "escaped single quotes inside" do
-        let(:pattern) { "'f\\'oo'" }
-
-        it { is_expected.to be_defined_at("f\\'oo") }
-        it { is_expected.not_to be_defined_at("f'oo") }
-      end
-    end
-  end
-
-  describe "#call" do
-    subject { matcher.(other) }
-
-    let(:pattern) { '"foo"' }
-
-    context "defined" do
-      let(:other) { "foo" }
-
-      it { is_expected.to eq({}) }
-    end
-  end
-
-  describe "#failure_reason" do
-    subject { matcher.failure_reason(other) }
-
-    context "match" do
-      let(:other) { "foo" }
-      let(:pattern) { '"foo"' }
-
-      it { is_expected.to eq(Fear.none) }
-    end
-
-    context "does not match" do
-      let(:other) { "bar" }
-      let(:pattern) { '"foo"' }
-
-      it { is_expected.to eq(Fear.some(<<~ERROR.strip)) }
-        Expected `"bar"` to match:
-        "foo"
-        ^
-      ERROR
-    end
-  end
-end

data/spec/fear/extractor/value_matcher_symbol_spec.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Fear::Extractor::ValueMatcher, "Symbol" do
-  let(:parser) { Fear::Extractor::GrammarParser.new }
-  let(:matcher) { parser.parse(pattern).to_matcher }
-
-  describe "#defined_at?" do
-    subject { matcher }
-
-    context "no quotas" do
-      let(:pattern) { ":foo" }
-
-      it { is_expected.to be_defined_at(:foo) }
-      it { is_expected.not_to be_defined_at("foo") }
-      it { is_expected.not_to be_defined_at(:boo) }
-      it { is_expected.not_to be_defined_at(2) }
-    end
-
-    context "double quotas" do
-      let(:pattern) { %(:"foo") }
-
-      it { is_expected.to be_defined_at(:foo) }
-      it { is_expected.not_to be_defined_at("foo") }
-      it { is_expected.not_to be_defined_at(:boo) }
-      it { is_expected.not_to be_defined_at(2) }
-    end
-
-    context "single quotas" do
-      let(:pattern) { %(:'foo') }
-
-      it { is_expected.to be_defined_at(:foo) }
-      it { is_expected.not_to be_defined_at("foo") }
-      it { is_expected.not_to be_defined_at(:boo) }
-      it { is_expected.not_to be_defined_at(2) }
-    end
-  end
-
-  describe "#call" do
-    subject { matcher.(other) }
-
-    let(:pattern) { ":foo" }
-
-    context "defined" do
-      let(:other) { :foo }
-
-      it { is_expected.to eq({}) }
-    end
-  end
-
-  describe "#failure_reason" do
-    subject { matcher.failure_reason(other) }
-
-    context "match" do
-      let(:other) { :foo }
-      let(:pattern) { ":foo" }
-
-      it { is_expected.to eq(Fear.none) }
-    end
-
-    context "does not match" do
-      let(:other) { :bar }
-      let(:pattern) { ":foo" }
-
-      it { is_expected.to eq(Fear.some(<<~ERROR.strip)) }
-        Expected `:bar` to match:
-        :foo
-        ^
-      ERROR
-    end
-  end
-end

data/spec/fear/extractor_api_spec.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Fear::ExtractorApi do
-  def assert(value)
-    expect(value).to eq(true)
-  end
-
-  def assert_not(value)
-    expect(value).not_to eq(true)
-  end
-
-  def assert_invalid_syntax
-    expect do
-      yield
-    end.to raise_error(Fear::PatternSyntaxError)
-  end
-
-  def assert_valid_syntax
-    expect { yield }.not_to raise_error
-  end
-
-  specify "Array" do
-    assert(Fear["[]"] === [])
-    assert_not(Fear["[]"] === [1])
-    assert(Fear["[1]"] === [1])
-    assert_not(Fear["[1]"] === [1, 2])
-    assert_not(Fear["[1]"] === [2])
-    assert(Fear["[1, 2]"] === [1, 2])
-    assert_not(Fear["[1, 2]"] === [1, 3])
-    assert_not(Fear["[1, 2]"] === [1, 2, 4])
-    assert_not(Fear["[1, 2]"] === [1])
-    assert(Fear["[*]"] === [])
-    assert(Fear["[*]"] === [1, 2])
-    assert_not(Fear["[1, *]"] === [])
-    assert(Fear["[1, *]"] === [1])
-    assert(Fear["[1, *]"] === [1, 2])
-    assert(Fear["[1, *]"] === [1, 2, 3])
-    assert(Fear["[[1]]"] === [[1]])
-    assert(Fear["[[1],2]"] === [[1], 2])
-    assert(Fear["[[1],*]"] === [[1], 2])
-    assert(Fear["[[*],*]"] === [[1], 2])
-    assert_invalid_syntax { Fear["[*, 2]"] }
-    assert_invalid_syntax { Fear["[*, ]"] }
-    assert_invalid_syntax { Fear["[1, *, ]"] }
-    assert_invalid_syntax { Fear["[1, *, 2]"] }
-    assert_invalid_syntax { Fear["[1, *, *]"] }
-    assert_invalid_syntax { Fear["[*, *]"] }
-    assert(Fear["[a, b]"] === [1, 2])
-    assert_not(Fear["[a, b, c]"] === [1, 2])
-    assert(Fear["[a, b, _]"] === [1, 2, 3])
-    assert(Fear["[a, b, *c]"] === [1, 2])
-    assert_not(Fear["[a, b, c, *d]"] === [1, 2])
-  end
-
-  specify "String" do
-    assert(Fear['"foo"'] === "foo")
-    assert(Fear['"f\"oo"'] === 'f"oo')
-    assert_not(Fear['"foo"'] === "bar")
-    assert(Fear["'foo'"] === "foo")
-    assert_not(Fear["'foo'"] === "bar")
-  end
-
-  specify "Symbol" do
-    assert(Fear[':"foo"'] === :foo)
-    assert(Fear[":'foo'"] === :foo)
-    assert(Fear[":foo"] === :foo)
-    assert_not(Fear[":foo"] === :bar)
-  end
-
-  specify "Boolean" do
-    assert(Fear["true"] === true)
-    assert(Fear["false"] === false)
-    assert_not(Fear["true"] === false)
-    assert_not(Fear["false"] === true)
-  end
-
-  specify "Nil" do
-    assert(Fear["nil"] === nil) # rubocop:disable Style/NilComparison
-    assert_not(Fear["nil"] === 42)
-  end
-
-  specify "_" do
-    assert(Fear["_"] === nil) # rubocop:disable Style/NilComparison
-    assert(Fear["_"] === true)
-    assert(Fear["_"] === false)
-    assert(Fear["_"] === 42)
-    assert(Fear["_"] === "foo")
-    assert(Fear["_"] === [42])
-  end
-
-  specify "type matching" do
-    class Foo
-      class Bar
-      end
-    end
-
-    assert(Fear["Integer"] === 3)
-    assert_not(Fear["Integer"] === "3")
-    assert(Fear["Numeric"] === 3)
-    assert(Fear["Foo::Bar"] === Foo::Bar.new)
-    assert(Fear["var : Integer"] === 3)
-    assert_not(Fear["var : Integer"] === "3")
-  end
-
-  specify "capture matcher" do
-    assert(Fear["array @ [head : Integer, *tail]"] === [1, 2])
-    assert_not(Fear["array @ [head : Integer, *tail]"] === ["1", 2])
-  end
-
-  specify "extractor" do
-    assert_valid_syntax { Fear["Foo(a, b : Integer)"] }
-    assert(Fear["Fear::Some(a : Integer)"] === Fear.some(42))
-    assert_not(Fear["Fear::Some(a : Integer)"] === Fear.some("foo"))
-  end
-end

data/spec/fear/extractor_spec.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Fear::Extractor do
-  describe ".register_extractor" do
-    Foo = ::Struct.new(:v1, :v2)
-    let(:matcher) do
-      Fear.matcher do |m|
-        m.case(Fear["Foo(43, second : Integer)"]) { |second| "43 and #{second}" }
-        m.case(Fear["Foo(42, second : Integer)"]) { |second| "42 and #{second}" }
-        m.else { "no match" }
-      end
-    end
-
-    let(:extractor) do
-      Fear.case(Foo) { |foo| [foo.v1, foo.v2] }.lift
-    end
-
-    context "extractor not registered" do
-      it "raise Fear::Extractor::ExtractorNotFound" do
-        expect do
-          described_class.find_extractor("UnknownExtractor")
-        end.to raise_error(Fear::Extractor::ExtractorNotFound)
-      end
-    end
-
-    context "register by name" do
-      let(:extractor) { ->(*) { Fear.some("matched") } }
-
-      before do
-        described_class.register_extractor(
-          "ExtractorRegisteredByName",
-          "ExtractorRegisteredByName2",
-          extractor,
-        )
-      end
-
-      it "returns extractor" do
-        expect(described_class.find_extractor("ExtractorRegisteredByName")).to eq(extractor)
-        expect(described_class.find_extractor("ExtractorRegisteredByName2")).to eq(extractor)
-      end
-    end
-
-    context "register by class" do
-      let(:extractor) { ->(*) { Fear.some("matched") } }
-      ExtractorRegisteredByClass = Class.new
-
-      before do
-        described_class.register_extractor(
-          ExtractorRegisteredByClass,
-          "ExtractorRegisteredByClass2",
-          extractor,
-        )
-      end
-
-      it "returns extractor" do
-        expect(described_class.find_extractor("ExtractorRegisteredByClass")).to eq(extractor)
-        expect(described_class.find_extractor("ExtractorRegisteredByClass2")).to eq(extractor)
-      end
-    end
-  end
-end