fear 2.0.1 → 3.0.0

data/lib/fear/option_pattern_match.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require "fear/pattern_match"
-
-module Fear
-  # Option pattern matcher
-  #
-  # @example
-  #   pattern_match =
-  #     OptionPatternMatch.new
-  #       .some(Integer) { |x| x * 2 }
-  #       .some(String) { |x| x.to_i * 2 }
-  #       .none { 'NaN' }
-  #       .else { 'error '}
-  #
-  #   pattern_match.call(42) => 'NaN'
-  #
-  #  @example the same matcher may be defined using block syntax
-  #    OptionPatternMatch.new do |m|
-  #       m.some(Integer) { |x| x * 2 }
-  #       m.some(String) { |x| x.to_i * 2 }
-  #       m.none { 'NaN' }
-  #       m.else { 'error '}
-  #    end
-  #
-  # @note it has two optimized subclasses +Fear::SomePatternMatch+ and +Fear::NonePatternMatch+
-  # @api private
-  class OptionPatternMatch < Fear::PatternMatch
-    # Match against Some
-    #
-    # @param conditions [<#==>]
-    # @return [Fear::OptionPatternMatch]
-    def some(*conditions, &effect)
-      branch = Fear.case(Fear::Some, &:get).and_then(Fear.case(*conditions, &effect))
-      or_else(branch)
-    end
-
-    # Match against None
-    #
-    # @param effect [Proc]
-    # @return [Fear::OptionPatternMatch]
-    def none(&effect)
-      branch = Fear.case(Fear::None, &effect)
-      or_else(branch)
-    end
-  end
-end
-
-require "fear/some_pattern_match"
-require "fear/none_pattern_match"

data/lib/fear/right_pattern_match.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require "fear/either_pattern_match"
-
-module Fear
-  # @api private
-  class RightPatternMatch < EitherPatternMatch
-    def left(*)
-      self
-    end
-    alias failure left
-  end
-end

data/lib/fear/some_pattern_match.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module Fear
-  # @api private
-  class SomePatternMatch < OptionPatternMatch
-    # @return [Fear::OptionPatternMatch]
-    def none
-      self
-    end
-  end
-
-  private_constant :SomePatternMatch
-end

data/lib/fear/struct.rb

@@ -1,237 +0,0 @@
-# frozen_string_literal: true
-
-require "fear/pattern_match"
-
-module Fear
-  # Structs are like regular classes and good for modeling immutable data.
-  #
-  # A minimal struct requires just a list of attributes:
-  #
-  #     User = Fear::Struct.with_attributes(:id, :email, :admin)
-  #     john = User.new(id: 2, email: 'john@example.com', admin: false)
-  #
-  #     john.email #=> 'john@example.com'
-  #
-  # Instead of `.with_attributes` factory method you can use classic inheritance:
-  #
-  #     class User < Fear::Struct
-  #       attribute :id
-  #       attribute :email
-  #       attribute :admin
-  #     end
-  #
-  # Since structs are immutable, you are not allowed to reassign their attributes
-  #
-  #     john.email = ''john.doe@example.com'' #=> raises NoMethodError
-  #
-  # Two structs of the same type with the same attributes are equal
-  #
-  #     john1 = User.new(id: 2, email: 'john@example.com', admin: false)
-  #     john2 = User.new(id: 2, admin: false, email: 'john@example.com')
-  #     john1 == john2 #=> true
-  #
-  # You can create a shallow copy of a +Struct+ by using copy method optionally changing its attributes.
-  #
-  #     john = User.new(id: 2, email: 'john@example.com', admin: false)
-  #     admin_john = john.copy(admin: true)
-  #
-  #     john.admin #=> false
-  #     admin_john.admin #=> true
-  #
-  class Struct
-    include PatternMatch.mixin
-
-    @attributes = [].freeze
-
-    class << self
-      # @param base [Fear::Struct]
-      # @api private
-      def inherited(base)
-        base.instance_variable_set(:@attributes, attributes)
-      end
-
-      # Defines attribute
-      #
-      # @param name [Symbol]
-      # @return [Symbol] attribute name
-      #
-      # @example
-      #   class User < Fear::Struct
-      #     attribute :id
-      #     attribute :email
-      #   end
-      #
-      def attribute(name)
-        name.to_sym.tap do |symbolized_name|
-          @attributes << symbolized_name
-          attr_reader symbolized_name
-        end
-      end
-
-      # Members of this struct
-      #
-      # @return [<Symbol>]
-      def attributes
-        @attributes.dup
-      end
-
-      # Creates new struct with given attributes
-      # @param members [<Symbol>]
-      # @return [Fear::Struct]
-      #
-      # @example
-      #   User = Fear::Struct.with_attributes(:id, :email, :admin) do
-      #     def admin?
-      #       @admin
-      #     end
-      #   end
-      #
-      def with_attributes(*members, &block)
-        members = members
-        block = block
-
-        Class.new(self) do
-          members.each { |member| attribute(member) }
-          class_eval(&block) if block
-        end
-      end
-    end
-
-    # @param attributes [{Symbol => any}]
-    def initialize(**attributes)
-      _check_missing_attributes!(attributes)
-      _check_unknown_attributes!(attributes)
-
-      @values = members.each_with_object([]) do |name, values|
-        attributes.fetch(name).tap do |value|
-          _set_attribute(name, value)
-          values << value
-        end
-      end
-    end
-
-    # Creates a shallow copy of this struct optionally changing the attributes arguments.
-    # @param attributes [{Symbol => any}]
-    #
-    # @example
-    #   User = Fear::Struct.new(:id, :email, :admin)
-    #   john = User.new(id: 2, email: 'john@example.com', admin: false)
-    #   john.admin #=> false
-    #   admin_john = john.copy(admin: true)
-    #   admin_john.admin #=> true
-    #
-    def copy(**attributes)
-      self.class.new(**to_h.merge(attributes))
-    end
-
-    # Returns the struct attributes as an array of symbols
-    # @return [<Symbol>]
-    #
-    # @example
-    #   User = Fear::Struct.new(:id, :email, :admin)
-    #   john = User.new(email: 'john@example.com', admin: false, id: 2)
-    #   john.attributes #=> [:id, :email, :admin]
-    #
-    def members
-      self.class.attributes
-    end
-
-    # Returns the values for this struct as an Array.
-    # @return [Array]
-    #
-    # @example
-    #   User = Fear::Struct.new(:id, :email, :admin)
-    #   john = User.new(email: 'john@example.com', admin: false, id: 2)
-    #   john.to_a #=> [2, 'john@example.com', false]
-    #
-    def to_a
-      @values.dup
-    end
-
-    # @overload to_h()
-    #   Returns a Hash containing the names and values for the struct's attributes
-    #   @return [{Symbol => any}]
-    #
-    # @overload to_h(&block)
-    #   Applies block to pairs of name name and value and use them to construct hash
-    #   @yieldparam pair [<Symbol, any>] yields pair of name name and value
-    #   @return [{Symbol => any}]
-    #
-    # @example
-    #   User = Fear::Struct.new(:id, :email, :admin)
-    #   john = User.new(email: 'john@example.com', admin: false, id: 2)
-    #   john.to_h #=> {id: 2, email: 'john@example.com', admin: false}
-    #   john.to_h do |key, value|
-    #     [key.to_s, value]
-    #   end #=> {'id' => 2, 'email' => 'john@example.com', 'admin' => false}
-    #
-    def to_h(&block)
-      pairs = members.zip(@values)
-      if block_given?
-        Hash[pairs.map(&block)]
-      else
-        Hash[pairs]
-      end
-    end
-
-    # @param other [any]
-    # @return [Boolean]
-    def ==(other)
-      other.is_a?(other.class) && to_h == other.to_h
-    end
-
-    INSPECT_TEMPLATE = "<#Fear::Struct %{class_name} %{attributes}>"
-    private_constant :INSPECT_TEMPLATE
-
-    # @return [String]
-    #
-    # @example
-    #   User = Fear::Struct.with_attributes(:id, :email)
-    #   user = User.new(id: 2, email: 'john@exmaple.com')
-    #   user.inspect #=> "<#Fear::Struct User id=2, email=>'john@exmaple.com'>"
-    #
-    def inspect
-      attributes = to_h.map { |key, value| "#{key}=#{value.inspect}" }.join(", ")
-
-      format(INSPECT_TEMPLATE, class_name: self.class.name, attributes: attributes)
-    end
-    alias to_s inspect
-
-    MISSING_KEYWORDS_ERROR = "missing keywords: %{keywords}"
-    private_constant :MISSING_KEYWORDS_ERROR
-
-    private def _check_missing_attributes!(provided_attributes)
-      missing_attributes = members - provided_attributes.keys
-
-      unless missing_attributes.empty?
-        raise ArgumentError, format(MISSING_KEYWORDS_ERROR, keywords: missing_attributes.join(", "))
-      end
-    end
-
-    UNKNOWN_KEYWORDS_ERROR = "unknown keywords: %{keywords}"
-    private_constant :UNKNOWN_KEYWORDS_ERROR
-
-    private def _check_unknown_attributes!(provided_attributes)
-      unknown_attributes = provided_attributes.keys - members
-
-      unless unknown_attributes.empty?
-        raise ArgumentError, format(UNKNOWN_KEYWORDS_ERROR, keywords: unknown_attributes.join(", "))
-      end
-    end
-
-    # @return [void]
-    private def _set_attribute(name, value)
-      instance_variable_set(:"@#{name}", value)
-    end
-
-    # @param keys [Hash, nil]
-    # @return [Hash]
-    def deconstruct_keys(keys)
-      if keys
-        to_h.slice(*(self.class.attributes & keys))
-      else
-        to_h
-      end
-    end
-  end
-end

data/lib/fear/success_pattern_match.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Fear
-  # @api private
-  class SuccessPatternMatch < Fear::TryPatternMatch
-    # @param conditions [<#==>]
-    # @return [Fear::TryPatternMatch]
-    def failure(*_conditions)
-      self
-    end
-  end
-
-  private_constant :SuccessPatternMatch
-end

data/lib/fear/try_pattern_match.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require "fear/pattern_match"
-
-module Fear
-  # Try pattern matcher
-  #
-  # @note it has two optimized subclasses +Fear::SuccessPatternMatch+ and +Fear::FailurePatternMatch+
-  # @api private
-  class TryPatternMatch < Fear::PatternMatch
-    # Match against +Fear::Success+
-    #
-    # @param conditions [<#==>]
-    # @return [Fear::TryPatternMatch]
-    def success(*conditions, &effect)
-      branch = Fear.case(Fear::Success, &:get).and_then(Fear.case(*conditions, &effect))
-      or_else(branch)
-    end
-
-    # Match against +Fear::Failure+
-    #
-    # @param conditions [<#==>]
-    # @return [Fear::TryPatternMatch]
-    def failure(*conditions, &effect)
-      branch = Fear.case(Fear::Failure, &:exception).and_then(Fear.case(*conditions, &effect))
-      or_else(branch)
-    end
-  end
-end
-
-require "fear/success_pattern_match"
-require "fear/failure_pattern_match"

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

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require "support/dry_types"
-
-RSpec.describe Dry::Types::Constrained, :option do
-  context "with a option type" do
-    subject(:type) do
-      Dry::Types["nominal.string"].constrained(size: 4).option
-    end
-
-    it_behaves_like "Dry::Types::Nominal without primitive"
-
-    it "passes when constraints are not violated" do
-      expect(type[nil]).to be_none
-      expect(type["hell"]).to be_some_of("hell")
-    end
-
-    it "raises when a given constraint is violated" do
-      expect { type["hel"] }.to raise_error(Dry::Types::ConstraintError, /hel/)
-    end
-  end
-end

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

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-require "support/dry_types"
-
-RSpec.describe Dry::Types::Nominal, :option do
-  describe "with opt-in option types" do
-    context "with strict string" do
-      let(:string) { Dry::Types["option.strict.string"] }
-
-      it_behaves_like "Dry::Types::Nominal without primitive" do
-        let(:type) { string }
-      end
-
-      it "accepts nil" do
-        expect(string[nil]).to be_none
-      end
-
-      it "accepts a string" do
-        expect(string["something"]).to be_some_of("something")
-      end
-    end
-
-    context "with coercible string" do
-      let(:string) { Dry::Types["option.coercible.string"] }
-
-      it_behaves_like "Dry::Types::Nominal without primitive" do
-        let(:type) { string }
-      end
-
-      it "accepts nil" do
-        expect(string[nil]).to be_none
-      end
-
-      it "accepts a string" do
-        expect(string[:something]).to be_some_of("something")
-      end
-    end
-  end
-
-  describe "defining coercible Option String" do
-    let(:option_string) { Dry::Types["coercible.string"].option }
-
-    it_behaves_like "Dry::Types::Nominal without primitive" do
-      let(:type) { option_string }
-    end
-
-    it "accepts nil" do
-      expect(option_string[nil]).to be_none
-    end
-
-    it "accepts an object coercible to a string" do
-      expect(option_string[123]).to be_some_of("123")
-    end
-  end
-
-  describe "defining Option String" do
-    let(:option_string) { Dry::Types["strict.string"].option }
-
-    it_behaves_like "Dry::Types::Nominal without primitive" do
-      let(:type) { option_string }
-    end
-
-    it "accepts nil and returns None instance" do
-      value = option_string[nil]
-
-      expect(value).to be_none
-      expect(value.map(&:downcase).map(&:upcase)).to be_none
-    end
-
-    it "accepts a string and returns Some instance" do
-      value = option_string["SomeThing"]
-
-      expect(value).to be_some_of("SomeThing")
-      expect(value.map(&:downcase).map(&:upcase)).to be_some_of("SOMETHING")
-    end
-  end
-end

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