fear 2.0.1 → 3.1.0

data/lib/dry/types/fear/option.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-module Dry
-  module Types
-    class Option
-      include Type
-      include ::Dry::Equalizer(:type, :options, inspect: false, immutable: true)
-      include Decorator
-      include Builder
-      include Printable
-
-      # @param [Fear::Option, Object] input
-      #
-      # @return [Fear::Option]
-      #
-      # @api private
-      def call_unsafe(input = Undefined)
-        case input
-        when ::Fear::Option
-          input
-        when Undefined
-          Fear.none
-        else
-          Fear.option(type.call_unsafe(input))
-        end
-      end
-
-      # @param [Fear::Option, Object] input
-      #
-      # @return [Fear::Option]
-      #
-      # @api private
-      def call_safe(input = Undefined)
-        case input
-        when ::Fear::Option
-          input
-        when Undefined
-          Fear.none
-        else
-          Fear.option(type.call_safe(input) { |output = input| return yield(output) })
-        end
-      end
-
-      # @param [Object] input
-      #
-      # @return [Result::Success]
-      #
-      # @api public
-      def try(input = Undefined)
-        result = type.try(input)
-
-        if result.success?
-          Result::Success.new(Fear.option(result.input))
-        else
-          result
-        end
-      end
-
-      # @return [true]
-      #
-      # @api public
-      def default?
-        true
-      end
-
-      # @param [Object] value
-      #
-      # @see Dry::Types::Builder#default
-      #
-      # @raise [ArgumentError] if nil provided as default value
-      #
-      # @api public
-      def default(value)
-        if value.nil?
-          raise ArgumentError, "nil cannot be used as a default of a maybe type"
-        else
-          super
-        end
-      end
-    end
-
-    module Builder
-      # Turn a type into a maybe type
-      #
-      # @return [Option]
-      #
-      # @api public
-      def option
-        Option.new(Types["nil"] | self)
-      end
-    end
-
-    # @api private
-    class Schema
-      class Key
-        # @api private
-        def option
-          __new__(type.option)
-        end
-      end
-    end
-
-    # @api private
-    class Printer
-      MAPPING[Option] = :visit_option
-
-      # @api private
-      def visit_option(maybe)
-        visit(maybe.type) do |type|
-          yield "Fear::Option<#{type}>"
-        end
-      end
-    end
-
-    # Register non-coercible maybe types
-    NON_NIL.each_key do |name|
-      register("option.strict.#{name}", self[name.to_s].option)
-    end
-
-    # Register coercible maybe types
-    COERCIBLE.each_key do |name|
-      register("option.coercible.#{name}", self["coercible.#{name}"].option)
-    end
-  end
-end

data/lib/dry/types/fear.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-require "dry/types"
-require "fear"
-
-Dry::Types.register_extension(:fear_option) do
-  require "dry/types/fear/option"
-end

data/lib/fear/either_pattern_match.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require "fear/pattern_match"
-
-module Fear
-  # Either pattern matcher
-  #
-  # @example
-  #   pattern_match =
-  #     EitherPatternMatch.new
-  #       .right(Integer, ->(x) { x > 2 }) { |x| x * 2 }
-  #       .right(String) { |x| x.to_i * 2 }
-  #       .left(String) { :err }
-  #       .else { 'error '}
-  #
-  #   pattern_match.call(42) => 'NaN'
-  #
-  #  @example the same matcher may be defined using block syntax
-  #    EitherPatternMatch.new do |m|
-  #      m.right(Integer, ->(x) { x > 2 }) { |x| x * 2 }
-  #      m.right(String) { |x| x.to_i * 2 }
-  #      m.left(String) { :err }
-  #      m.else { 'error '}
-  #    end
-  #
-  # @note it has two optimized subclasses +Fear::LeftPatternMatch+ and +Fear::RightPatternMatch+
-  # @api private
-  class EitherPatternMatch < Fear::PatternMatch
-    # Match against +Fear::Right+
-    #
-    # @param conditions [<#==>]
-    # @return [Fear::EitherPatternMatch]
-    def right(*conditions, &effect)
-      branch = Fear.case(Fear::Right, &:right_value).and_then(Fear.case(*conditions, &effect))
-      or_else(branch)
-    end
-    alias success right
-
-    # Match against +Fear::Left+
-    #
-    # @param conditions [<#==>]
-    # @return [Fear::EitherPatternMatch]
-    def left(*conditions, &effect)
-      branch = Fear.case(Fear::Left, &:left_value).and_then(Fear.case(*conditions, &effect))
-      or_else(branch)
-    end
-    alias failure left
-  end
-end
-
-require "fear/left_pattern_match"
-require "fear/right_pattern_match"

data/lib/fear/failure_pattern_match.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module Fear
-  # @api private
-  class FailurePatternMatch < Fear::TryPatternMatch
-    def success(*_conditions)
-      self
-    end
-  end
-
-  private_constant :FailurePatternMatch
-end

data/lib/fear/left_pattern_match.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Fear
-  # @api private
-  class LeftPatternMatch < Fear::EitherPatternMatch
-    def right(*)
-      self
-    end
-    alias success right
-  end
-end

data/lib/fear/none_pattern_match.rb

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

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