reacto 0.1.0 → 1.0.0

data/spec/reacto/trackable/min_spec.rb

@@ -0,0 +1,19 @@
+context Reacto::Trackable do
+  subject(:source) { described_class.enumerable(%w(albatross dog horse snake)) }
+
+  context '#min' do
+    it 'emits the minimum value emitted by source assuming that all the ' \
+      'values implement Comparable' do
+      attach_test_trackers(source.min)
+
+      expect(test_data).to eq(%w(albatross |))
+    end
+
+    it 'emits the minimum value emitted by source using the block given to ' \
+      'compare the values ' do
+      attach_test_trackers(source.min { |val1, val2| val1.size <=> val2.size })
+
+      expect(test_data).to eq(%w(dog |))
+    end
+  end
+end

data/spec/reacto/trackable/minmax_by_spec.rb

@@ -0,0 +1,12 @@
+context Reacto::Trackable do
+  subject(:source) { described_class.enumerable(%w(albatross dog horse snake)) }
+
+  context '#minmax_by' do
+    it 'emits the values emitted by source that give the minimum value and ' \
+      'the maximum value from the given block. ' do
+      attach_test_trackers(source.minmax_by { |val| val.size })
+
+      expect(test_data).to eq(%w(dog albatross |))
+    end
+  end
+end

data/spec/reacto/trackable/minmax_spec.rb

@@ -0,0 +1,19 @@
+context Reacto::Trackable do
+  subject(:source) { described_class.enumerable(%w(albatross dog horse snake)) }
+
+  context '#minmax' do
+    it 'emits the minimum and then the maximum values emitted by source ' \
+      'assuming that all the values implement Comparable' do
+      attach_test_trackers(source.minmax)
+
+      expect(test_data).to eq(%w(albatross snake |))
+    end
+
+    it 'emits the maximum and then the maximum values emitted by source ' \
+      'using the block given to compare the values ' do
+      attach_test_trackers(source.minmax { |v1, v2| v1.size <=> v2.size })
+
+      expect(test_data).to eq(%w(dog albatross |))
+    end
+  end
+end

data/spec/reacto/trackable/none_spec.rb

@@ -0,0 +1,38 @@
+context Reacto::Trackable do
+  context '#none?' do
+    it 'passes each incoming value to the given block. The resulting ' \
+      'Reacto::Trackable emits only one value - `true` if the block never ' \
+      'returns `true`. Test true.' do
+      trackable = described_class.enumerable((5..10)).none? do |value|
+        value < 5
+      end
+
+      trackable.on(value: test_on_value)
+
+      expect(test_data.size).to be(1)
+      expect(test_data.first).to be(true)
+    end
+
+    it 'passes each incoming value to the given block. The resulting ' \
+      'Reacto::Trackable emits only one value - `true` if the block never ' \
+      'returns `true`. Test false.' do
+      trackable = described_class.enumerable((6..10)).none? do |value|
+        value < 7
+      end
+
+      trackable.on(value: test_on_value)
+
+      expect(test_data.size).to be(1)
+      expect(test_data.first).to be(false)
+    end
+
+    it 'if the block is not given, adds an implicit block of { |obj| obj }' do
+      trackable = described_class.enumerable([nil, nil]).none?
+
+      trackable.on(value: test_on_value)
+
+      expect(test_data.size).to be(1)
+      expect(test_data.first).to be(true)
+    end
+  end
+end

data/spec/reacto/trackable/on_spec.rb

@@ -1,9 +1,7 @@
-require 'spec_helper'
-
 context Reacto::Trackable do
   context '#on' do
     it 'returns a Reacto::Subscription' do
-      actual = described_class.new(Reacto::NO_ACTION).on
+      actual = described_class.new.on
 
       expect(actual).to_not be(nil)
       expect(actual).to be_kind_of(Reacto::Subscriptions::Subscription)
@@ -12,7 +10,16 @@ context Reacto::Trackable do
     context('value') do
       it 'the trackable behavior uses a subscription which `on_value` ' \
         'is the passed value action' do
-        described_class.new(test_behaviour).on(value: test_on_value)
+        described_class.new(&test_behaviour).on(value: test_on_value)
+
+        expect(test_data.size).to be(1)
+        expect(test_data[0]).to be(5)
+      end
+    end
+
+    context 'with block' do
+      it 'behaves as #on value: <lambda>' do
+        described_class.new(&test_behaviour).on(&test_on_value)
 
         expect(test_data.size).to be(1)
         expect(test_data[0]).to be(5)

data/spec/reacto/trackable/one_spec.rb

@@ -0,0 +1,38 @@
+context Reacto::Trackable do
+  context '#one?' do
+    it 'passes each incoming value to the given block. The resulting ' \
+      'Reacto::Trackable emits only one value - `true` if the block returns ' \
+      '`true` exactly once. Test true.' do
+      trackable = described_class.enumerable((5..10)).one? do |value|
+        value < 6
+      end
+
+      trackable.on(value: test_on_value)
+
+      expect(test_data.size).to be(1)
+      expect(test_data.first).to be(true)
+    end
+
+    it 'passes each incoming value to the given block. The resulting ' \
+      'Reacto::Trackable emits only one value - `true` if the block returns ' \
+      '`true` exactly once. Test false.' do
+      trackable = described_class.enumerable((4..10)).one? do |value|
+        value < 6
+      end
+
+      trackable.on(value: test_on_value)
+
+      expect(test_data.size).to be(1)
+      expect(test_data.first).to be(false)
+    end
+
+    it 'if the block is not given, adds an implicit block of { |obj| obj }' do
+      trackable = described_class.enumerable([0, nil, 1]).one?
+
+      trackable.on(value: test_on_value)
+
+      expect(test_data.size).to be(1)
+      expect(test_data.first).to be(false)
+    end
+  end
+end

data/spec/reacto/trackable/partition_spec.rb

@@ -0,0 +1,23 @@
+context Reacto::Trackable do
+  context '#partition' do
+    def expect_values(trackable, label, expected)
+      expect_trackable_values(trackable, expected, label: label)
+    end
+
+    let(:data) { [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5] }
+    subject(:test_source) { described_class.enumerable(data) }
+
+    it 'creates a Reacto::Trackable which emits two LabeledTrackable ' \
+      'instances, the first with label `true`, emitting values for which' \
+      'the given block evaluates to true, the second emitting the rest' do
+      trackable = test_source.partition { |v| v.even? }
+
+      attach_test_trackers(trackable)
+
+      expect(test_data.length).to be(3)
+      expect_values(test_data.first, true, [4, 2, 6])
+      expect_values(test_data[1], false, [3, 1, 1, 5, 9, 5, 3, 5])
+      expect(test_data.last).to eq('|')
+    end
+  end
+end

data/spec/reacto/trackable/prepend_spec.rb

@@ -1,8 +1,6 @@
-require 'spec_helper'
-
 context Reacto::Trackable do
   context '#prepend' do
-    it 'emits the passed enumerable before the values, emited by the caller' do
+    it 'emits the passed enumerable before the values, emitted by the caller' do
       source = described_class.enumerable((1..5))
       trackable = source.prepend((-5..0))
 

data/spec/reacto/trackable/reject_spec.rb

@@ -0,0 +1,21 @@
+context Reacto::Trackable do
+  context '#reject' do
+    it 'notifies with values not passing the filter block' do
+      trackable = source.reject { |v| v % 2 == 0 }
+      trackable.on(value: test_on_value)
+
+      expect(test_data.size).to be(1)
+      expect(test_data.first).to be(5)
+    end
+
+    it 'does not notify with values passing the filter block' do
+      trackable = source.reject do |v|
+        v % 2 == 1
+      end
+
+      trackable.on(value: test_on_value)
+
+      expect(test_data.size).to be(0)
+    end
+  end
+end

data/spec/reacto/trackable/rescue_and_replace_error_spec.rb

@@ -0,0 +1,48 @@
+context Reacto::Trackable do
+  context '#rescue_and_replace_error' do
+    let(:test_error) { StandardError.new('Bang!') }
+
+    subject(:test_source) do
+      described_class.make do |tracker|
+        tracker.on_value('Hi!')
+
+        tracker.on_error(test_error)
+
+        tracker.on_value('Bye.')
+        tracker.on_close
+      end
+    end
+
+    it 'replaces the emitted error with the a new sequence emitted by the ' \
+      'Reacto::Trackable instance, returned by the passed block' do
+
+      trackable = test_source.rescue_and_replace_error do |error|
+        if error.message == 'Bang!'
+          Reacto::Trackable.enumerable(%w(so that's a goodbye then))
+        else
+          Reacto::Trackable.error(error)
+        end
+      end
+
+      attach_test_trackers(trackable)
+
+      expect(test_data).to eq(%w(Hi! so that's a goodbye then |))
+    end
+
+    it 'replaces the emitted error with the a new sequence emitted by the ' \
+      'Reacto::Trackable instance, returned by the passed block. Error case' do
+
+      trackable = test_source.rescue_and_replace_error do |error|
+        if error.message == 'Gang!'
+          Reacto::Trackable.enumerable(%w(so that's a goodbye then))
+        else
+          Reacto::Trackable.error(error)
+        end
+      end
+
+      attach_test_trackers(trackable)
+
+      expect(test_data).to eq(['Hi!', test_error])
+    end
+  end
+end

data/spec/reacto/trackable/rescue_and_replace_error_with_spec.rb

@@ -0,0 +1,26 @@
+context Reacto::Trackable do
+  context '#rescue_and_replace_error_with' do
+    let(:test_error) { StandardError.new('Bang!') }
+
+    subject(:test_source) do
+      described_class.make do |tracker|
+        tracker.on_value('Hi!')
+
+        tracker.on_error(test_error)
+
+        tracker.on_value('Bye.')
+        tracker.on_close
+      end
+    end
+
+    it 'replaces the emitted error with the a new sequence emitted by the ' \
+      'given Reacto::Trackable instance' do
+      trackable = test_source.rescue_and_replace_error_with(
+        Reacto::Trackable.enumerable(%w(so that's a goodbye then))
+      )
+      attach_test_trackers(trackable)
+
+      expect(test_data).to eq(%w(Hi! so that's a goodbye then |))
+    end
+  end
+end

data/spec/reacto/trackable/retry_spec.rb

@@ -0,0 +1,50 @@
+context Reacto::Trackable do
+  context '#retry' do
+    let(:error_checker) do
+      array = []
+      ->() do
+        array << 1
+
+        array.length % 2 == 1
+      end
+    end
+
+    it 're-runs the whole behaviour of the source trackable if there is ' \
+      'an error' do
+      trackable = Reacto::Trackable.make do |tracker|
+        tracker.on_value('Hi!')
+
+        tracker.on_error(StandardError.new('Bang!')) if error_checker.call
+
+        tracker.on_value('Bye.')
+        tracker.on_close
+      end.retry
+
+      trackable.on(
+        value: test_on_value, error: test_on_error, close: test_on_close
+      )
+
+      expect(test_data).to eq(['Hi!', 'Hi!', 'Bye.', '|'])
+    end
+
+    it 'emits the error if it persists the retry count times' do
+      power_error = StandardError.new('Bang! Bang!')
+
+      trackable = Reacto::Trackable.make do |tracker|
+        tracker.on_value('Hi!')
+
+        tracker.on_error(StandardError.new('Bang!')) if error_checker.call
+        tracker.on_error(power_error) if error_checker.call
+
+        tracker.on_value('Bye.')
+        tracker.on_close
+      end.retry(3)
+
+      trackable.on(
+        value: test_on_value, error: test_on_error, close: test_on_close
+      )
+
+      expect(test_data).to eq(['Hi!', 'Hi!', 'Hi!', 'Hi!', power_error])
+    end
+  end
+end

data/spec/reacto/trackable/retry_when_spec.rb

@@ -0,0 +1,33 @@
+context Reacto::Trackable do
+  context '#retry_when' do
+    let(:error_checker) do
+      array = []
+      ->() do
+        array << 1
+
+        array.length % 2 == 1
+      end
+    end
+
+    it 're-runs the whole behaviour of the source trackable if there is ' \
+      'an error and the block passed evaluates to `true`' do
+      power_error = ArgumentError.new('Bang! Bang!')
+
+      trackable = Reacto::Trackable.make do |tracker|
+        tracker.on_value('Hi!')
+
+        tracker.on_error(StandardError.new('Bang!')) if error_checker.call
+        tracker.on_error(power_error) if error_checker.call
+
+        tracker.on_value('Bye.')
+        tracker.on_close
+      end.retry_when { |_error, retries| retries < 4 }
+
+      trackable.on(
+        value: test_on_value, error: test_on_error, close: test_on_close
+      )
+
+      expect(test_data).to eq(['Hi!', 'Hi!', 'Hi!', 'Hi!', 'Hi!', power_error])
+    end
+  end
+end

data/spec/reacto/trackable/select_spec.rb

@@ -1,12 +1,7 @@
-require 'spec_helper'
-
 context Reacto::Trackable do
   context '#select' do
     it 'doesn\'t notify with values not passing the filter block' do
-      trackable = source.select do |v|
-        v % 2 == 0
-      end
-
+      trackable = source.select { |v| v % 2 == 0 }
       trackable.on(value: test_on_value)
 
       expect(test_data.size).to be(0)
@@ -20,7 +15,23 @@ context Reacto::Trackable do
       trackable.on(value: test_on_value)
 
       expect(test_data.size).to be(1)
-      expect(test_data[0]).to be(5)
+      expect(test_data.first).to be(5)
+    end
+
+    context 'with label' do
+      it 'applies the filtering passed only to the emitted values of type ' \
+        'LabeledTrackable with the matching label' do
+        source = described_class.enumerable((1..10)).group_by_label do |value|
+          [(value % 3), value]
+        end
+
+        trackable = source.select(label: 1) { |value| value < 5 }
+        trackable.on(value: test_on_value)
+
+        expect_trackable_values(test_data.first, [1, 4], label: 1)
+        expect_trackable_values(test_data[1], [2, 5, 8], label: 2)
+        expect_trackable_values(test_data.last, [3, 6, 9], label: 0)
+      end
     end
   end
 end

data/spec/reacto/trackable/slice_after_spec.rb

@@ -0,0 +1,38 @@
+context Reacto::Trackable do
+  context '#slice_after' do
+    subject(:test_source) do
+      described_class.enumerable(['A', 'B', 0, 'C', 2, true, false, 3, 'DE'])
+    end
+
+    it 'emits Reacto::Trackable instances emitting slices of the values, ' \
+      'emitted by the source. The slices are determined by the last value ' \
+      'for which <pattern> === value is true' do
+      trackable = test_source.slice_after(Integer)
+
+      attach_test_trackers(trackable)
+
+      expect(test_data.size).to eq(5)
+      expect_trackable_values(test_data.first, ['A', 'B', 0])
+      expect_trackable_values(test_data[1], ['C', 2])
+      expect_trackable_values(test_data[2], [true, false, 3])
+      expect_trackable_values(test_data[3], %w(DE))
+      expect(test_data.last).to eq('|')
+    end
+
+    it 'emits Reacto::Trackable instances emitting slices of the values, ' \
+      'emitted by the source. The slices are determined by the last value ' \
+      'the block given returns true' do
+      trackable = test_source.slice_after do |val|
+        val == false || val == 0
+      end
+
+      attach_test_trackers(trackable)
+
+      expect(test_data.size).to eq(4)
+      expect_trackable_values(test_data.first, ['A', 'B', 0])
+      expect_trackable_values(test_data[1], ['C', 2, true, false])
+      expect_trackable_values(test_data[2], [3, 'DE'])
+      expect(test_data.last).to eq('|')
+    end
+  end
+end