From 82c6acc1534871ab30405364f76b8e3533f2e289 Mon Sep 17 00:00:00 2001 From: Genar Trias Ortiz Date: Wed, 21 Aug 2024 17:17:29 +0200 Subject: [PATCH] remove maybe implementation --- lib/schema_registry/maybe.rb | 86 -------- lib/schema_registry/maybe/absent.rb | 81 -------- lib/schema_registry/maybe/present.rb | 96 --------- spec/maybe_spec.rb | 284 --------------------------- 4 files changed, 547 deletions(-) delete mode 100644 lib/schema_registry/maybe/absent.rb delete mode 100644 lib/schema_registry/maybe/present.rb delete mode 100644 spec/maybe_spec.rb diff --git a/lib/schema_registry/maybe.rb b/lib/schema_registry/maybe.rb index 2ca1182..b100bf1 100644 --- a/lib/schema_registry/maybe.rb +++ b/lib/schema_registry/maybe.rb @@ -20,92 +20,6 @@ module Maybe Value = type_member(:out) { { upper: BasicObject } } - module ClassMethods - extend T::Sig - extend T::Helpers - abstract! - - sig do - type_parameters(:Key) - .params(input: T::Hash[T.type_parameter(:Key), T.untyped]) - .returns(T::Hash[T.type_parameter(:Key), T.untyped]) - end - # You can use this method to easily transform a Hash with `Maybe` values into one without them, - # filtering out `Maybe` instances that are empty and unwrapping the present ones. - # - # Given a hash containing `Maybe` instances, returns a hash with only the values that are present. - # It also unwraps the present values. - # - # For convenience, it also recursively serializes nested T::Structs and strips nested hashes, - # arrays and sets. - # - # ```ruby - # Maybe.strip({ a: Maybe.from(1), b: Maybe.empty, c: Maybe.from(3) }) - # # => { a: 1, c: 3 } - # ``` - def self.strip(input) # rubocop:disable Metrics/PerceivedComplexity - input - .reject { |_key, value| value == empty } - .to_h do |key, value| - unwrapped = value.is_a?(Maybe::Present) ? value.value : value - enumerated = - if unwrapped.is_a?(Array) || unwrapped.is_a?(Set) - unwrapped.map { |v| v.is_a?(T::Struct) ? strip(v.serialize) : strip(v) } - else - unwrapped - end - serialized = enumerated.is_a?(T::Struct) ? enumerated.serialize : enumerated - stripped = serialized.is_a?(Hash) ? strip(serialized) : serialized - - [key, stripped] - end - end - - # Creates an empty instance. - sig { returns(Absent) } - def self.empty - Absent.new - end - - sig { returns(Absent) } - # Creates an empty instance. - # Alias for self.empty - def self.none - empty - end - - sig { returns(Absent) } - # Creates an empty instance. - # Alias for self.empty - def self.absent - empty - end - - sig do - type_parameters(:Value) - .params(value: T.all(BasicObject, T.type_parameter(:Value))) - # .returns(Maybe[T.all(BasicObject, T.type_parameter(:Value))]) - .returns(T.untyped) - end - # Creates an instance containing the specified value. - # Necessary to make this work with sorbet-coerce - def self.new(value) - from(value) - end - - sig do - type_parameters(:Value) - .params(value: T.all(BasicObject, T.type_parameter(:Value))) - .returns(Maybe[T.all(BasicObject, T.type_parameter(:Value))]) - end - # Creates an instance containing the specified value. - def self.from(value) - Present[T.all(BasicObject, T.type_parameter(:Value))].new(value) - end - end - - mixes_in_class_methods(ClassMethods) - sig { abstract.returns(T::Boolean) } # `true` if this `Maybe` contains a value, `false` otherwise. def present?; end diff --git a/lib/schema_registry/maybe/absent.rb b/lib/schema_registry/maybe/absent.rb deleted file mode 100644 index 3bb3bd4..0000000 --- a/lib/schema_registry/maybe/absent.rb +++ /dev/null @@ -1,81 +0,0 @@ -# typed: strict -# frozen_string_literal: true - -module Maybe - # Class used to represent the empty case - class Absent - extend T::Sig - extend T::Generic - include Maybe - final! - - Value = type_member { { fixed: T.noreturn } } - - sig(:final) { override.returns(FalseClass) } - def present? - false - end - - sig(:final) { override.returns(TrueClass) } - def absent? - true - end - - sig(:final) { override.returns(TrueClass) } - def empty? - absent? - end - - sig(:final) do - override - .type_parameters(:Default) - .params(default: T.type_parameter(:Default)) - .returns(T.type_parameter(:Default)) - end - def or_default(default) - default - end - - sig(:final) do - override - .type_parameters(:Return) - .params(_block: T.proc.params(v: Value).returns(T.type_parameter(:Return))) - .returns(T.nilable(T.type_parameter(:Return))) - end - def when_present(&_block) - nil - end - - sig(:final) do - override - .type_parameters(:Return) - .params(_block: T.proc.returns(T.type_parameter(:Return))) - .returns(T.nilable(T.type_parameter(:Return))) - end - def when_absent(&_block) - yield - end - - sig(:final) do - override.params(_block: T.proc.params(value: Value).returns(T::Boolean)).returns(Maybe[Value]) - end - def filter(&_block) - self - end - - sig(:final) do - override - .type_parameters(:Default) - .params(_block: T.proc.params(value: Value).returns(T.type_parameter(:Default))) - .returns(Maybe[T.all(BasicObject, T.type_parameter(:Default))]) - end - def map(&_block) - self - end - - sig(:final) { override.params(other: BasicObject).returns(T::Boolean) } - def ==(other) - self.class === other # rubocop:disable Style/CaseEquality - end - end -end diff --git a/lib/schema_registry/maybe/present.rb b/lib/schema_registry/maybe/present.rb deleted file mode 100644 index 21808e3..0000000 --- a/lib/schema_registry/maybe/present.rb +++ /dev/null @@ -1,96 +0,0 @@ -# typed: strict -# frozen_string_literal: true - -module Maybe - # Class used to represent the case when a value is available - class Present - extend T::Sig - extend T::Generic - include Maybe - final! - - Value = type_member(:out) { { upper: BasicObject } } - - requires_ancestor { Object } - - sig(:final) { params(value: Value).void } - def initialize(value) - @value = value - end - - sig(:final) { override.returns(TrueClass) } - def present? - true - end - - sig(:final) { override.returns(FalseClass) } - def absent? - false - end - - sig(:final) { override.returns(FalseClass) } - def empty? - absent? - end - - sig(:final) do - override.type_parameters(:Default).params(_default: T.type_parameter(:Default)).returns(Value) - end - def or_default(_default) - value - end - - sig(:final) do - override - .type_parameters(:Return) - .params(_block: T.proc.params(v: Value).returns(T.type_parameter(:Return))) - .returns(T.nilable(T.type_parameter(:Return))) - end - def when_present(&_block) - yield value - end - - sig(:final) do - override - .type_parameters(:Return) - .params(_block: T.proc.returns(T.type_parameter(:Return))) - .returns(T.nilable(T.type_parameter(:Return))) - end - def when_absent(&_block) - nil - end - - sig(:final) do - override.params(_block: T.proc.params(value: Value).returns(T::Boolean)).returns(Maybe[Value]) - end - def filter(&_block) - return self if yield value - - Absent.new - end - - sig(:final) do - override - .type_parameters(:Default) - .params( - _block: - T.proc.params(value: Value).returns(T.all(BasicObject, T.type_parameter(:Default))) - ) - .returns(Maybe[T.all(BasicObject, T.type_parameter(:Default))]) - end - def map(&_block) - mapped = yield value - Present[T.all(BasicObject, T.type_parameter(:Default))].new(mapped) - end - - sig(:final) { override.params(other: BasicObject).returns(T::Boolean) } - def ==(other) - return false unless self.class === other # rubocop:disable Style/CaseEquality - - value == other.value - end - - sig(:final) { returns(Value) } - attr_reader :value - end -end diff --git a/spec/maybe_spec.rb b/spec/maybe_spec.rb deleted file mode 100644 index 9928986..0000000 --- a/spec/maybe_spec.rb +++ /dev/null @@ -1,284 +0,0 @@ -# typed: false - -require 'spec_helper' # you are forced to load the whole context for this :/ -require_relative '../lib/schema_registry/maybe' # unit tests are currently not possible - -RSpec.describe Maybe do - let(:present) { Maybe.from(6) } - let(:nilable) { Maybe.from(nil) } - let(:absent) { Maybe.empty } - - describe '#strip' do - let(:input) { { present: Maybe.from(6), absent: Maybe.empty, always: 5 } } - - subject { Maybe.strip(input) } - - it 'removes all absent values, unwraps present `Maybe`s' do - expect(subject).to match({ present: 6, always: 5 }) - end - end - - describe '#present?' do - subject { maybe.present? } - - context 'when a value is present' do - let(:maybe) { present } - - it 'returns true' do - expect(subject).to be true - end - end - - context 'when a `nil` value is present' do - let(:maybe) { nilable } - - it 'returns true' do - expect(subject).to be true - end - end - - context 'when a value is not present' do - let(:maybe) { absent } - - it 'returns false' do - expect(subject).to be false - end - end - end - - describe '#absent?' do - subject { maybe.absent? } - - context 'when a value is present' do - let(:maybe) { present } - - it 'returns false' do - expect(subject).to be false - end - end - - context 'when a `nil` value is present' do - let(:maybe) { nilable } - - it 'returns false' do - expect(subject).to be false - end - end - - context 'when a value is not present' do - let(:maybe) { absent } - - it 'returns true' do - expect(subject).to be true - end - end - end - - describe '#or_default' do - subject { maybe.or_default(default) } - - let(:default) { '1337' } - - context 'when a value is present' do - let(:maybe) { present } - - it 'returns the contained value' do - expect(subject).to be 6 - end - end - - context 'when a `nil` value is present' do - let(:maybe) { nilable } - - it 'returns the contained value' do - expect(subject).to be_nil - end - end - - context 'when a value is not present' do - let(:maybe) { absent } - - it 'returns the default value' do - expect(subject).to be default - end - end - end - - describe '#when_present' do - subject { maybe.when_present { |v| (v || 0) + 1 } } - - context 'when a value is present' do - let(:maybe) { present } - - it 'returns the value returned from the block' do - expect(subject).to be 7 - end - end - - context 'when a `nil` value is present' do - let(:maybe) { nilable } - - it 'returns the value returned from the block' do - expect(subject).to be 1 - end - end - - context 'when a value is not present' do - let(:maybe) { absent } - - it 'returns nil' do - expect(subject).to be_nil - end - end - end - - describe '#when_absent' do - subject { maybe.when_absent { 1 + 1 } } - - context 'when a value is present' do - let(:maybe) { present } - - it 'returns nil' do - expect(subject).to be_nil - end - end - - context 'when a `nil` value is present' do - let(:maybe) { nilable } - - it 'returns nil' do - expect(subject).to be_nil - end - end - - context 'when a value is not present' do - let(:maybe) { absent } - - it 'returns the value returned from the block' do - expect(subject).to be 2 - end - end - end - - describe '#filter' do - subject { maybe.filter { |_e| filter_output } } - - context 'when the filter returns false' do - let(:filter_output) { false } - - context 'and a value is present' do - let(:maybe) { present } - - it 'returns an empty instance' do - expect(subject.absent?).to be true - end - end - - context 'and a `nil` value is present' do - let(:maybe) { nilable } - - it 'returns an empty instance' do - expect(subject.absent?).to be true - end - end - - context 'and a value is not present' do - let(:maybe) { absent } - - it 'returns an empty instance' do - expect(subject.absent?).to be true - end - end - end - - context 'when the filter returns true' do - let(:filter_output) { true } - - context 'and a value is present' do - let(:maybe) { present } - - it 'returns the same instance' do - expect(subject).to be maybe - end - end - - context 'and a `nil` value is present' do - let(:maybe) { nilable } - - it 'returns the same instance' do - expect(subject).to be maybe - end - end - - context 'and a value is not present' do - let(:maybe) { absent } - - it 'returns the same instance' do - expect(subject).to be maybe - end - end - end - end - - describe '#map' do - subject { maybe.map { |e| (e || 0) + 1 } } - - context 'when a value is present' do - let(:maybe) { present } - - it 'returns an instance containing the result of the block' do - expect(subject).to eq Maybe.from(7) - end - end - - context 'when a `nil` value is present' do - let(:maybe) { nilable } - - it 'returns an instance containing the result of the block' do - expect(subject).to eq Maybe.from(1) - end - end - - context 'when a value is not present' do - let(:maybe) { absent } - - it 'returns the same instance' do - expect(subject).to be maybe - end - end - end - - describe '#==' do - subject { first == second } - - context 'when both have values' do - context 'and the values are the same' do - let(:first) { Maybe.from('Potato') } - let(:second) { Maybe.from('Potato') } - - it('returns true') { expect(subject).to be true } - end - - context 'and the values are different' do - let(:first) { Maybe.from('Tomato') } - let(:second) { Maybe.from('Carrot') } - - it('returns false') { expect(subject).to be false } - end - end - - context 'when only one has values' do - let(:first) { Maybe.from('Apricot') } - let(:second) { Maybe.empty } - - it('returns false') { expect(subject).to be false } - end - - context 'when neither has values' do - let(:first) { Maybe.empty } - let(:second) { Maybe.empty } - - it('returns true') { expect(subject).to be true } - end - end -end