fear 0.0.1

data/spec/fear/left_spec.rb

@@ -0,0 +1,79 @@
+RSpec.describe Fear::Left do
+  include Fear::Either::Mixin
+
+  it_behaves_like Fear::RightBiased::Left do
+    let(:left) { described_class.new('value') }
+  end
+
+  describe '#detect' do
+    subject do
+      described_class.new('value').detect(default) { |v| v == 'value' }
+    end
+
+    context 'proc default' do
+      let(:default) { -> { -1 } }
+
+      it 'returns Left of evaluated default' do
+        is_expected.to eq(described_class.new(-1))
+      end
+    end
+
+    context 'default' do
+      let(:default) { -1 }
+
+      it 'return Left of default' do
+        is_expected.to eq(described_class.new(-1))
+      end
+    end
+  end
+
+  describe '#swap' do
+    subject { described_class.new('value').swap }
+    it { is_expected.to eq(Right('value')) }
+  end
+
+  describe '#reduce' do
+    subject do
+      described_class.new('value').reduce(
+        ->(left) { "Left: #{left}" },
+        ->(right) { "Right: #{right}" },
+      )
+    end
+
+    it { is_expected.to eq('Left: value') }
+  end
+
+  describe '#join_right' do
+    subject(:join_right) { either.join_right }
+
+    context 'value is Either' do
+      let(:either) { described_class.new(Left('error')) }
+      it { is_expected.to eq(either) }
+    end
+
+    context 'value s not Either' do
+      let(:either) { Left('error') }
+      it { is_expected.to eq(either) }
+    end
+  end
+
+  describe '#join_left' do
+    context 'value is Either' do
+      subject { either.join_left }
+      let(:either) { described_class.new(value) }
+      let(:value) { Left('error') }
+
+      it 'it returns value' do
+        is_expected.to eq(Left('error'))
+      end
+    end
+
+    context 'value is not Either' do
+      subject { proc { described_class.new('error').join_left } }
+
+      it 'fails with type error' do
+        is_expected.to raise_error(TypeError)
+      end
+    end
+  end
+end

data/spec/fear/none_spec.rb

@@ -0,0 +1,37 @@
+RSpec.describe Fear::None do
+  include Fear::Option::Mixin
+
+  it_behaves_like Fear::RightBiased::Left do
+    let(:left) { described_class.new }
+  end
+
+  subject(:none) { None() }
+
+  specify '#get fails with exception' do
+    expect do
+      none.get
+    end.to raise_error(NoMethodError)
+  end
+
+  specify '#or_nil returns nil' do
+    result = none.or_nil
+
+    expect(result).to eq nil
+  end
+
+  describe '#detect' do
+    subject { none.detect { |value| value > 42 } }
+
+    it 'always return None' do
+      is_expected.to eq(None())
+    end
+  end
+
+  describe '#reject' do
+    subject { none.reject { |value| value > 42 } }
+
+    it 'always return None' do
+      is_expected.to eq(None())
+    end
+  end
+end

data/spec/fear/option_spec.rb

@@ -0,0 +1,32 @@
+RSpec.describe Fear::Option do
+  include Fear::Option::Mixin
+
+  describe 'Option()' do
+    it 'returns Some if value is not nil' do
+      option = Option(double)
+
+      expect(option).to be_kind_of(Fear::Some)
+    end
+
+    it 'returns None if value is nil' do
+      option = Option(nil)
+
+      expect(option).to be_kind_of(Fear::None)
+    end
+  end
+
+  let(:some) { Some(42) }
+  let(:none) { None() }
+
+  describe '#empty?' do
+    context 'Some' do
+      subject { some.empty? }
+      it { is_expected.to eq(false) }
+    end
+
+    context 'None' do
+      subject { none.empty? }
+      it { is_expected.to eq(true) }
+    end
+  end
+end

data/spec/fear/right_biased/left.rb

@@ -0,0 +1,67 @@
+RSpec.shared_examples Fear::RightBiased::Left do
+  describe '#include?' do
+    subject { left }
+    it { is_expected.not_to include('value') }
+  end
+
+  describe '#get_or_else' do
+    context 'with block' do
+      subject { left.get_or_else { 'default' } }
+
+      it 'returns default value' do
+        is_expected.to eq('default')
+      end
+    end
+
+    context 'with default argument' do
+      subject { left.get_or_else('default') }
+
+      it 'returns default value' do
+        is_expected.to eq('default')
+      end
+    end
+  end
+
+  describe '#each' do
+    subject do
+      proc do |block|
+        expect(left.each(&block)).to eq(left)
+      end
+    end
+
+    it 'does not call the block' do
+      is_expected.not_to yield_control
+    end
+  end
+
+  describe '#map' do
+    subject { left.map(&:length) }
+
+    it 'returns self' do
+      is_expected.to eq(left)
+    end
+  end
+
+  describe '#flat_map' do
+    subject { left.flat_map(&:length) }
+
+    it 'returns self' do
+      is_expected.to eq(left)
+    end
+  end
+
+  describe '#to_a' do
+    subject { left.to_a }
+    it { is_expected.to eq([]) }
+  end
+
+  describe '#to_option' do
+    subject { left.to_option }
+    it { is_expected.to eq(Fear::None.new) }
+  end
+
+  describe '#any?' do
+    subject { left.any? { |v| v == 'value' } }
+    it { is_expected.to eq(false) }
+  end
+end

data/spec/fear/right_biased/right.rb

@@ -0,0 +1,93 @@
+RSpec.shared_examples Fear::RightBiased::Right do
+  describe '#include?' do
+    context 'contains value' do
+      subject { right.include?('value') }
+      it { is_expected.to eq(true) }
+    end
+
+    context 'does not contain value' do
+      subject { right.include?('another value') }
+      it { is_expected.to eq(false) }
+    end
+  end
+
+  describe '#get_or_else' do
+    context 'with block' do
+      subject { right.get_or_else { 'default' } }
+
+      it 'returns value' do
+        is_expected.to eq('value')
+      end
+    end
+
+    context 'with default argument' do
+      subject { right.get_or_else('default') }
+
+      it 'returns value' do
+        is_expected.to eq('value')
+      end
+    end
+  end
+
+  describe '#each' do
+    subject do
+      proc do |block|
+        expect(right.each(&block)).to eq(right)
+      end
+    end
+
+    it 'calls the block with value' do
+      is_expected.to yield_with_args('value')
+    end
+  end
+
+  describe '#map' do
+    subject { right.map(&:length) }
+
+    it 'perform transformation' do
+      is_expected.to eq(described_class.new(5))
+    end
+  end
+
+  describe '#flat_map' do
+    context 'block returns neither left, nor right' do
+      subject { proc { right.flat_map { 42 } } }
+
+      it 'fails with TypeError' do
+        is_expected.to raise_error(TypeError)
+      end
+    end
+
+    context 'block returns RightBiased' do
+      subject { right.flat_map { |e| described_class.new("Result: #{e}") } }
+
+      it 'maps to block result' do
+        is_expected.to eq(described_class.new('Result: value'))
+      end
+    end
+  end
+
+  describe '#to_a' do
+    subject { right.to_a }
+    it { is_expected.to eq(['value']) }
+  end
+
+  describe '#to_option' do
+    subject { right.to_option }
+    it { is_expected.to eq(Fear::Some.new('value')) }
+  end
+
+  describe '#any?' do
+    subject { right.any?(&predicate) }
+
+    context 'matches predicate' do
+      let(:predicate) { ->(v) { v == 'value' } }
+      it { is_expected.to eq(true) }
+    end
+
+    context 'does not match predicate' do
+      let(:predicate) { ->(v) { v != 'value' } }
+      it { is_expected.to eq(false) }
+    end
+  end
+end

data/spec/fear/right_spec.rb

@@ -0,0 +1,79 @@
+RSpec.describe Fear::Right do
+  it_behaves_like Fear::RightBiased::Right do
+    let(:right) { described_class.new('value') }
+  end
+
+  let(:right) { described_class.new('value') }
+
+  describe '#detect' do
+    subject { right.detect(default, &predicate) }
+
+    context 'predicate evaluates to true' do
+      let(:predicate) { ->(v) { v == 'value' } }
+      let(:default) { -1 }
+      it { is_expected.to eq(right) }
+    end
+
+    context 'predicate evaluates to false and default is a proc' do
+      let(:predicate) { ->(v) { v != 'value' } }
+      let(:default) { -> { -1 } }
+      it { is_expected.to eq(Fear::Left.new(-1)) }
+    end
+
+    context 'predicate evaluates to false and default is not a proc' do
+      let(:predicate) { ->(v) { v != 'value' } }
+      let(:default) { -1 }
+      it { is_expected.to eq(Fear::Left.new(-1)) }
+    end
+  end
+
+  describe '#swap' do
+    subject { described_class.new('value').swap }
+    it { is_expected.to eq(Fear::Left.new('value')) }
+  end
+
+  describe '#reduce' do
+    subject do
+      described_class.new('value').reduce(
+        ->(left) { "Left: #{left}" },
+        ->(right) { "Right: #{right}" },
+      )
+    end
+
+    it { is_expected.to eq('Right: value') }
+  end
+
+  describe '#join_right' do
+    context 'value is Either' do
+      subject { described_class.new(value).join_right }
+      let(:value) { Fear::Left.new('error') }
+
+      it 'returns value' do
+        is_expected.to eq(value)
+      end
+    end
+
+    context 'value is not Either' do
+      subject { proc { described_class.new('35').join_right } }
+
+      it 'fails with type error' do
+        is_expected.to raise_error(TypeError)
+      end
+    end
+  end
+
+  describe '#join_left' do
+    context 'value is Either' do
+      subject { either.join_left }
+      let(:either) { described_class.new(Fear::Left.new('error')) }
+
+      it { is_expected.to eq(either) }
+    end
+
+    context 'value is not Either' do
+      subject { either.join_left }
+      let(:either) { described_class.new('result') }
+      it { is_expected.to eq(either) }
+    end
+  end
+end

data/spec/fear/some_spec.rb

@@ -0,0 +1,48 @@
+RSpec.describe Fear::Some do
+  include Fear::Option::Mixin
+
+  it_behaves_like Fear::RightBiased::Right do
+    let(:right) { described_class.new('value') }
+  end
+
+  subject(:some) { Some(value) }
+  let(:value) { 42 }
+
+  describe '#detect' do
+    subject { some.detect(&predicate) }
+
+    context 'predicate evaluates to true' do
+      let(:predicate) { ->(v) { v > 40 } }
+      it { is_expected.to eq(some) }
+    end
+
+    context 'predicate evaluates to false' do
+      let(:predicate) { ->(v) { v < 40 } }
+      it { is_expected.to eq(None()) }
+    end
+  end
+
+  describe '#reject' do
+    subject { some.reject(&predicate) }
+
+    context 'predicate evaluates to true' do
+      let(:predicate) { ->(v) { v > 40 } }
+      it { is_expected.to eq(None()) }
+    end
+
+    context 'predicate evaluates to false' do
+      let(:predicate) { ->(v) { v < 40 } }
+      it { is_expected.to eq(some) }
+    end
+  end
+
+  specify '#get returns value' do
+    expect(some.get).to eq value
+  end
+
+  specify '#or_nil returns value' do
+    result = some.or_nil
+
+    expect(result).to eq value
+  end
+end

data/spec/fear/success_spec.rb

@@ -0,0 +1,83 @@
+RSpec.describe Fear::Success do
+  let(:success) { described_class.new('value') }
+
+  it_behaves_like Fear::RightBiased::Right do
+    let(:right) { success }
+
+    describe '#map', 'block fails' do
+      subject(:map) { right.map { fail 'unexpected error' } }
+
+      it { is_expected.to be_kind_of(Fear::Failure) }
+      it { expect { map.get }.to raise_error(RuntimeError, 'unexpected error') }
+    end
+
+    describe '#flat_map', 'block fails' do
+      subject(:flat_map) { right.flat_map { fail 'unexpected error' } }
+
+      it { is_expected.to be_kind_of(Fear::Failure) }
+      it { expect { flat_map.get }.to raise_error(RuntimeError, 'unexpected error') }
+    end
+  end
+
+  describe '#get' do
+    subject { success.get }
+    it { is_expected.to eq('value') }
+  end
+
+  describe '#success?' do
+    subject { success }
+    it { is_expected.to be_success }
+  end
+
+  describe '#or_else' do
+    subject { success.or_else { described_class.new('another value') } }
+    it { is_expected.to eq(success) }
+  end
+
+  describe '#flatten' do
+    subject { described_class.new(value).flatten }
+
+    context 'value is a Success' do
+      let(:value) { described_class.new(42) }
+      it { is_expected.to eq(described_class.new(42)) }
+    end
+
+    context 'value is a Success of Success' do
+      let(:value) { described_class.new(described_class.new(42)) }
+      it { is_expected.to eq(described_class.new(42)) }
+    end
+
+    context 'value is a Success of Failure' do
+      let(:failure) { Fear::Failure.new(RuntimeError.new) }
+      let(:value) { described_class.new(failure) }
+      it { is_expected.to eq(failure) }
+    end
+  end
+
+  describe '#detect' do
+    context 'predicate holds for value' do
+      subject { success.detect { |v| v == 'value' } }
+      it { is_expected.to eq(success) }
+    end
+
+    context 'predicate does not hold for value' do
+      subject { proc { success.detect { |v| v != 'value' }.get } }
+      it { is_expected.to raise_error(Fear::NoSuchElementError, 'Predicate does not hold for `value`') }
+    end
+
+    context 'predicate fails with error' do
+      subject { proc { success.detect { fail 'foo' }.get } }
+      it { is_expected.to raise_error(RuntimeError, 'foo') }
+    end
+  end
+
+  describe '#recover_with' do
+    subject { success.recover_with { |v| Success(v * 2) } }
+    it { is_expected.to eq(success) }
+  end
+
+  describe '#recover' do
+    subject { success.recover { |v| v * 2 } }
+    it { is_expected.to eq(success) }
+  end
+end

data/spec/fear/utils_spec.rb

@@ -0,0 +1,60 @@
+RSpec.describe Fear::Utils do
+  describe '.assert_arg_or_block!' do
+    def assert_arg_or_block!(*args, &block)
+      described_class.assert_arg_or_block!(:the_method, *args, &block)
+    end
+
+    context 'block given, argument does not given' do
+      subject { proc { assert_arg_or_block! {} } }
+
+      it { is_expected.not_to raise_error }
+    end
+
+    context 'argument given, block does not given' do
+      subject { proc { assert_arg_or_block!(42) } }
+
+      it { is_expected.not_to raise_error }
+    end
+
+    context 'argument and block given at the same time' do
+      subject { proc { assert_arg_or_block!(42) {} } }
+
+      it 'fails with argument error' do
+        is_expected.to raise_error(
+          ArgumentError,
+          '#the_method accepts either one argument or block',
+        )
+      end
+    end
+
+    context 'no argument and no block given' do
+      subject { proc { assert_arg_or_block! } }
+
+      it 'fails with argument error' do
+        is_expected.to raise_error(
+          ArgumentError,
+          '#the_method accepts either one argument or block',
+        )
+      end
+    end
+  end
+
+  describe 'assert_type!' do
+    context 'value is of the given type' do
+      subject { proc { described_class.assert_type!(24, Integer) } }
+
+      it { is_expected.not_to raise_error }
+    end
+
+    context 'value is not of the given type' do
+      subject { proc { described_class.assert_type!(24, String) } }
+
+      it 'raises TypeError' do
+        is_expected.to raise_error(
+          TypeError,
+          'expected `24` to be of String class',
+        )
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,77 @@
+# require 'codeclimate-test-reporter'
+# CodeClimate::TestReporter.start
+
+require 'fear'
+require File.expand_path('spec/fear/right_biased/right')
+require File.expand_path('spec/fear/right_biased/left')
+
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 3
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+end