fear 2.0.1 → 3.1.0

data/spec/dry/types/fear/option/default_spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require "support/dry_types"
-
-RSpec.describe Dry::Types::Nominal, "#default", :option do
-  context "with a maybe" do
-    subject(:type) { Dry::Types["strict.integer"].option }
-
-    it_behaves_like "Dry::Types::Nominal without primitive" do
-      let(:type) { Dry::Types["strict.integer"].option.default(0) }
-    end
-
-    it "does not allow nil" do
-      expect { type.default(nil) }.to raise_error(ArgumentError, /nil/)
-    end
-
-    it "accepts a non-nil value" do
-      expect(type.default(0)[0]).to be_some_of(0)
-    end
-  end
-end

data/spec/dry/types/fear/option/hash_spec.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require "support/dry_types"
-
-RSpec.describe Dry::Types::Hash, :option do
-  let(:email) { Dry::Types["option.strict.string"] }
-
-  context "Symbolized constructor" do
-    subject(:hash) do
-      Dry::Types["nominal.hash"].schema(
-        name: "string",
-        email: email,
-      ).with_key_transform(&:to_sym)
-    end
-
-    describe "#[]" do
-      it "sets None as a default value for option" do
-        result = hash["name" => "Jane"]
-
-        expect(result[:email]).to be_none
-      end
-    end
-  end
-
-  context "Schema constructor" do
-    subject(:hash) do
-      Dry::Types["nominal.hash"].schema(
-        name: "string",
-        email: email,
-      )
-    end
-
-    describe "#[]" do
-      it "sets None as a default value for option types" do
-        result = hash[name: "Jane"]
-
-        expect(result[:email]).to be_none
-      end
-    end
-  end
-
-  context "Strict with defaults" do
-    subject(:hash) do
-      Dry::Types["nominal.hash"].schema(
-        name: "string",
-        email: email,
-      )
-    end
-
-    describe "#[]" do
-      it "sets None as a default value for option types" do
-        result = hash[name: "Jane"]
-
-        expect(result[:email]).to be_none
-      end
-    end
-  end
-end

data/spec/dry/types/fear/option/option_spec.rb

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-require "support/dry_types"
-
-RSpec.describe Dry::Types::Nominal, "#option", :option do
-  context "with a nominal" do
-    subject(:type) { Dry::Types["nominal.string"].option }
-
-    it_behaves_like "Dry::Types::Nominal without primitive"
-
-    it "returns None when value is nil" do
-      expect(type[nil]).to be_none
-    end
-
-    it "returns Some when value exists" do
-      expect(type["hello"]).to be_some_of("hello")
-    end
-
-    it "returns original if input is already a option" do
-      expect(type[Fear.some("hello")]).to be_some_of("hello")
-    end
-
-    it "aliases #[] as #call" do
-      expect(type.("hello")).to be_some_of("hello")
-    end
-
-    it "does not have primitive" do
-      expect(type).to_not respond_to(:primitive)
-    end
-  end
-
-  context "with a strict type" do
-    subject(:type) { Dry::Types["strict.integer"].option }
-
-    it_behaves_like "Dry::Types::Nominal without primitive"
-
-    it "returns None when value is nil" do
-      expect(type[nil]).to be_none
-    end
-
-    it "returns Some when value exists" do
-      expect(type[231]).to be_some_of(231)
-    end
-  end
-
-  context "with a sum" do
-    subject(:type) { Dry::Types["nominal.bool"].option }
-
-    it_behaves_like "Dry::Types::Nominal without primitive"
-
-    it "returns None when value is nil" do
-      expect(type[nil]).to be_none
-    end
-
-    it "returns Some when value exists" do
-      expect(type[true]).to be_some_of(true)
-      expect(type[false]).to be_some_of(false)
-    end
-
-    it "does not have primitive" do
-      expect(type).to_not respond_to(:primitive)
-    end
-  end
-
-  context "with keys" do
-    subject(:type) do
-      Dry::Types["hash"].schema(foo: Dry::Types["integer"]).key(:foo)
-    end
-
-    it "gets wrapped by key type" do
-      expect(type.option).to be_a(Dry::Types::Schema::Key)
-      expect(type.option[nil]).to be_none
-      expect(type.option[1]).to be_some_of(1)
-    end
-  end
-
-  describe "#try" do
-    subject(:type) { Dry::Types["coercible.integer"].option }
-
-    it "maps successful result" do
-      expect(type.try("1")).to eq(Dry::Types::Result::Success.new(Fear.some(1)))
-      expect(type.try(nil)).to eq(Dry::Types::Result::Success.new(Fear.none))
-      expect(type.try("a")).to be_a(Dry::Types::Result::Failure)
-    end
-  end
-
-  describe "#call" do
-    describe "safe calls" do
-      subject(:type) { Dry::Types["coercible.integer"].option }
-
-      specify do
-        expect(type.("a") { :fallback }).to be(:fallback)
-        expect(type.(Fear.some(1)) { :fallback }).to eq(Fear.some(1))
-      end
-    end
-  end
-end

data/spec/struct_pattern_matching_spec.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Fear::Struct do
-  describe "pattern matching" do
-    subject do
-      case struct
-      in Fear::Struct(a: 42)
-        "a = 42"
-      in Fear::Struct(a: 43, **rest)
-        "a = 43, #{rest}"
-      in Fear::Struct(a:)
-        "a = #{a}"
-      end
-    end
-
-    let(:struct_class) { described_class.with_attributes(:a, :b) }
-
-    context "when match single value" do
-      let(:struct) { struct_class.new(b: 43, a: 42) }
-
-      it { is_expected.to eq("a = 42") }
-    end
-
-    context "when match single value and capture the rest" do
-      let(:struct) { struct_class.new(b: 42, a: 43) }
-
-      it { is_expected.to eq("a = 43, {:b=>42}") }
-    end
-
-    context "when capture a value" do
-      let(:struct) { struct_class.new(b: 45, a: 44) }
-
-      it { is_expected.to eq("a = 44") }
-    end
-  end
-end

data/spec/struct_spec.rb

@@ -1,194 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Fear::Struct do
-  describe ".with_attributes" do
-    context "same arguments" do
-      subject { struct_class.new(a: 42, b: 43) }
-
-      let(:struct_class) { described_class.with_attributes(:a, :b) }
-
-      it { is_expected.to have_attributes(a: 42, b: 43) }
-    end
-
-    context "string arguments" do
-      subject { -> { struct_class.new("a" => 42, "b" => 43) } }
-
-      let(:struct_class) { described_class.with_attributes(:a, :b) }
-
-      it { is_expected.to raise_error(ArgumentError) }
-    end
-
-    context "extra argument" do
-      subject { -> { struct_class.new(a: 42, b: 41, c: 43, d: 44) } }
-
-      let(:struct_class) { described_class.with_attributes(:a, :b) }
-
-      it { is_expected.to raise_error(ArgumentError, "unknown keywords: c, d") }
-    end
-
-    context "missing argument" do
-      subject { -> { struct_class.new } }
-
-      let(:struct_class) { described_class.with_attributes(:a, :b) }
-
-      it { is_expected.to raise_error(ArgumentError, "missing keywords: a, b") }
-    end
-
-    context "inheritance" do
-      let(:parent_struct) { described_class.with_attributes(:a, :b) }
-
-      it "does not change parent attributes" do
-        expect do
-          parent_struct.with_attributes(:c)
-        end.not_to change { parent_struct.attributes }.from([:a, :b])
-      end
-
-      it "extends parent attributes" do
-        child_struct = parent_struct.with_attributes(:c)
-        expect(child_struct.attributes).to eq([:a, :b, :c])
-      end
-    end
-
-    context "with block" do
-      subject { struct_class.new(a: 42, b: 43).a_plus_b }
-
-      let(:struct_class) do
-        described_class.with_attributes(:a, :b) do
-          def a_plus_b
-            a + b
-          end
-        end
-      end
-
-      it "evaluates block in context of struct" do
-        is_expected.to eq(85)
-      end
-    end
-  end
-
-  describe "#==" do
-    context "with members" do
-      let(:struct_class) { described_class.with_attributes(:a, :b) }
-
-      context "same class and members" do
-        subject { struct_class.new(a: 42, b: 43) == struct_class.new(a: 42, b: 43) } # rubocop: disable Lint/BinaryOperatorWithIdenticalOperands
-
-        it { is_expected.to eq(true) }
-      end
-
-      context "same class and different members" do
-        subject { struct_class.new(a: 42, b: 43) == struct_class.new(a: 42, b: 0) }
-
-        it { is_expected.to eq(false) }
-      end
-
-      context "different class and same members" do
-        subject { struct_class.new(a: 42, b: 43) == struct_class_1.new(a: 42, b: 43) }
-
-        let(:struct_class_1) { described_class.with_attributes(:a, :b) }
-
-        it { is_expected.to eq(true) }
-      end
-
-      context "different class and different members" do
-        subject { struct_class.new(a: 42, b: 43) == struct_class.new(a: 42, b: 0) }
-
-        let(:struct_class_1) { described_class.with_attributes(:a, :b) }
-
-        it { is_expected.to eq(false) }
-      end
-    end
-  end
-
-  describe "#members" do
-    let(:struct) { struct_class.new(b: 43, a: 42) }
-    let(:struct_class) { described_class.with_attributes(:a, :b) }
-
-    it "returns members in the order they defined" do
-      expect(struct.members).to eq([:a, :b])
-    end
-
-    it "is immutable" do
-      expect { struct.members << :c }.not_to change { struct.members }.from([:a, :b])
-    end
-  end
-
-  describe "#to_a" do
-    let(:struct) { struct_class.new(b: 43, a: 42) }
-    let(:struct_class) { described_class.with_attributes(:a, :b) }
-
-    it "returns members values in the order they defined" do
-      expect(struct.to_a).to eq([42, 43])
-    end
-
-    it "is immutable" do
-      expect { struct.to_a << 44 }.not_to change { struct.to_a }.from([42, 43])
-    end
-  end
-
-  describe "#to_h" do
-    let(:struct_class) { described_class.with_attributes(:a, :b) }
-
-    context "without block" do
-      let(:struct) { struct_class.new(b: 43, a: 42) }
-
-      it "returns a Hash containing the names and values for the structs members" do
-        expect(struct.to_h).to eq(a: 42, b: 43)
-      end
-
-      it "is immutable" do
-        expect { struct.to_h.merge(c: 44) }.not_to change { struct.to_h }.from(a: 42, b: 43)
-      end
-    end
-
-    context "with block" do
-      subject do
-        struct.to_h do |key, value|
-          [key.upcase, value / 2]
-        end
-      end
-      let(:struct) { struct_class.new(b: 2, a: 4) }
-
-      it "returns a Hash containing the names and values for the structs members" do
-        is_expected.to eq(A: 2, B: 1)
-      end
-    end
-  end
-
-  describe "#copy" do
-    let(:struct_class) { described_class.with_attributes(:a, :b) }
-    let(:struct) { struct_class.new(b: 43, a: 42) }
-
-    context "attributes given" do
-      subject { struct.copy(b: 44) }
-
-      it { is_expected.to eq(struct_class.new(a: 42, b: 44)) }
-    end
-
-    context "string attributes" do
-      subject { -> { struct.copy("a" => 44) } }
-
-      it { is_expected.to raise_error(ArgumentError) }
-    end
-
-    context "no attributes given" do
-      subject { struct.copy == struct }
-
-      it { is_expected.to eq(true) }
-    end
-  end
-
-  describe "#inspect" do
-    subject { StrInspect.new(a: 2, b: nil).inspect }
-    StrInspect = Fear::Struct.with_attributes(:a, :b)
-
-    it { is_expected.to eq("<#Fear::Struct StrInspect a=2, b=nil>") }
-  end
-
-  describe "#inspect" do
-    subject { StrToS.new(a: 2, b: nil).inspect }
-    StrToS = Fear::Struct.with_attributes(:a, :b)
-
-    it { is_expected.to eq("<#Fear::Struct StrToS a=2, b=nil>") }
-  end
-end

data/spec/support/dry_types.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-require "dry/types/fear"
-require "dry/types/spec/types"
-
-Dry::Types.load_extensions(:fear_option)