reacto 0.1.0 → 1.0.0

data/spec/reacto/trackable/count_spec.rb

@@ -0,0 +1,38 @@
+context Reacto::Trackable do
+  subject(:source) { described_class.enumerable([1, 2, 4, 2]) }
+
+  context '#count' do
+    it 'returns a Trackable, emitting only one value - the number of values ' \
+      'emitted by the caller of this operation' do
+      counting_trackable = source.count
+
+      attach_test_trackers(counting_trackable)
+
+      expect(test_data.size).to be 2
+      expect(test_data.first).to eq(4)
+      expect(test_data.last).to eq('|')
+    end
+
+    it 'returns a Trackable, emitting only one value - the number of values, ' \
+      'equal to the given as argument one, if such is given' do
+      counting_trackable = source.count(2)
+
+      attach_test_trackers(counting_trackable)
+
+      expect(test_data.size).to be 2
+      expect(test_data.first).to eq(2)
+      expect(test_data.last).to eq('|')
+    end
+
+    it 'returns a Trackable, emitting only one value - the number of values, ' \
+      'yielding a true value if a block is given' do
+      counting_trackable = source.count { |v| v.even? }
+
+      attach_test_trackers(counting_trackable)
+
+      expect(test_data.size).to be 2
+      expect(test_data.first).to eq(3)
+      expect(test_data.last).to eq('|')
+    end
+  end
+end

data/spec/reacto/trackable/cycle_spec.rb

@@ -0,0 +1,14 @@
+context Reacto::Trackable do
+  subject(:source) { described_class.enumerable(%w(a b c)) }
+
+  context '#cycle' do
+    it 'emits all the elements of the source repeatedly the given `n` times ' do
+      trackable = source.cycle(3)
+
+      attach_test_trackers(trackable)
+
+      expect(test_data.size).to eq(10)
+      expect(test_data).to eq((%w(a b c) * 3) + %w(|))
+    end
+  end
+end

data/spec/reacto/trackable/delay_each_spec.rb

@@ -0,0 +1,18 @@
+context Reacto::Trackable do
+  context '#delay_each' do
+    it 'emits every notification from the source Trackable, but waits ' \
+      'the given delay seconds for between every emit' do
+      trackable = described_class.enumerable((1..5)).delay_each(0.3)
+
+      trackable.on(
+        value: test_on_value, close: test_on_close, error: test_on_error
+      )
+
+      sleep 1
+      expect(test_data).to eq([1, 2, 3])
+
+      sleep 1
+      expect(test_data).to eq([1, 2, 3, 4, 5, '|'])
+    end
+  end
+end

data/spec/reacto/trackable/depend_on_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 context Reacto::Trackable do
   context '#depend_on' do
     it 'suspends its caller untill the passed Trackable emits its ' \
@@ -18,7 +16,7 @@ context Reacto::Trackable do
       expect(test_data[1].data).to be 10
       expect(test_data[2].value).to be 4
       expect(test_data[2].data).to be 10
-      expect(test_data.last).to be == '|'
+      expect(test_data.last).to eq('|')
     end
 
     it 'it uses the first emitted value for the data from the dependency ' \
@@ -37,13 +35,12 @@ context Reacto::Trackable do
       expect(test_data[1].data).to be 5
       expect(test_data[2].value).to be 4
       expect(test_data[2].data).to be 5
-      expect(test_data.last).to be == '|'
+      expect(test_data.last).to eq('|')
     end
 
     it 'uses the block passed to accumulate the dependency data' do
-      trackable = described_class.enumerable([5, 4]).depend_on(
-        described_class.enumerable((1..10))
-      ) { |prev, v| prev + v }
+      dependency = described_class.enumerable((1..10))
+      trackable = described_class.enumerable([5, 4]).depend_on(dependency, &:+)
 
       attach_test_trackers(trackable)
 
@@ -52,7 +49,7 @@ context Reacto::Trackable do
       expect(test_data[0].data).to be 55
       expect(test_data[1].value).to be 4
       expect(test_data[1].data).to be 55
-      expect(test_data.last).to be == '|'
+      expect(test_data.last).to eq('|')
     end
 
     it 'sends the error if the dependency has an error' do
@@ -64,7 +61,7 @@ context Reacto::Trackable do
       attach_test_trackers(trackable)
 
       expect(test_data.size).to be 1
-      expect(test_data.last).to be == error
+      expect(test_data.last).to eq(error)
     end
   end
 end

data/spec/reacto/trackable/diff_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 context Reacto::Trackable do
   context '#diff' do
     it 'by default emits arrays with two values the - previous and current ' \
@@ -8,15 +6,15 @@ context Reacto::Trackable do
       trackable = source.diff
       trackable.on(value: test_on_value, error: test_on_error)
 
-      expect(test_data).to be == [
+      expect(test_data).to eq([
         [1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7], [7, 8], [8, 9], [9, 10
-      ]]
+      ]])
     end
 
     it 'can be passed a diff function to calculate the difference between ' \
       'the previously emitted value and the current and to emit it' do
       source = described_class.enumerable((1..10))
-      trackable = source.diff(Reacto::NO_VALUE, -> (p, c) { c - p })
+      trackable = source.diff(Reacto::NO_VALUE) { |p, c|  c - p }
       trackable.on(value: test_on_value, error: test_on_error)
 
       expect(test_data).to be == [1] * 9

data/spec/reacto/trackable/drop_errors_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 context Reacto::Trackable do
   context '#drop_errors' do
     it 'drops all the errors from the source and continues' do
@@ -9,7 +7,7 @@ context Reacto::Trackable do
         value: test_on_value, error: test_on_error, close: test_on_close
       )
 
-      expect(test_data).to be == (1..10).to_a + ['|']
+      expect(test_data).to eq((1..10).to_a + ['|'])
     end
   end
 end

data/spec/reacto/trackable/drop_while_spec.rb

@@ -0,0 +1,15 @@
+context Reacto::Trackable do
+  context '#drop_while' do
+    it 'drops elements up to, but not including, the first element for which ' \
+      'the block returns nil or false' do
+      trackable = described_class.enumerable((1..5)).drop_while do |val|
+        val < 4
+      end
+
+      attach_test_trackers(trackable)
+
+      expect(test_data.size).to be(3)
+      expect(test_data).to eq([4, 5, '|'])
+    end
+  end
+end

data/spec/reacto/trackable/each_cons_spec.rb

@@ -0,0 +1,53 @@
+context Reacto::Trackable do
+  context '#each_cons' do
+    subject(:test_source) { described_class.enumerable((1..10)) }
+
+    it 'raises an ArgumentError if the size given as first argument '\
+      'is zero or smaller' do
+      expect do
+        test_source.each_cons(0) do |v|
+          p v
+        end
+      end.to raise_error(ArgumentError).with_message('invalid size')
+    end
+
+    it 'behaves as #each/#on if the size given is 1' do
+      test_data = []
+      test_source.each_cons(1) { |v| test_data << v }
+
+      expect(test_data).to eq((1..10).to_a)
+    end
+
+    it 'calls the given block for each array of consecutive <n> emitted ' \
+      'values' do
+      test_data = []
+      test_source.each_cons(2) { |v| test_data << v }
+
+      expect(test_data).to eq(
+        [
+          [1, 2], [2, 3], [3, 4], [4, 5], [5, 6],
+          [6, 7], [7, 8], [8, 9], [9, 10]
+        ]
+      )
+    end
+
+    it 'returns a Reacto::Subscription' do
+      subscription = test_source.each_cons(3) { |v| test_data << v }
+
+      expect(subscription).to_not be(nil)
+      expect(subscription).to be_kind_of(Reacto::Subscriptions::Subscription)
+    end
+
+    it 'returns a new Trackable with the each_cons behavior ' \
+      'if no block was given' do
+      trackable = test_source.each_cons(4)
+
+      attach_test_trackers(trackable)
+
+      expect(test_data).to eq([
+        [1, 2, 3, 4], [2, 3, 4, 5], [3, 4, 5, 6], [4, 5, 6, 7], [5, 6, 7, 8],
+        [6, 7, 8, 9], [7, 8, 9, 10], '|'
+      ])
+    end
+  end
+end

data/spec/reacto/trackable/each_slice_spec.rb

@@ -0,0 +1,37 @@
+context Reacto::Trackable do
+  context '#each_slice' do
+    subject(:test_source) { described_class.enumerable((1..10)) }
+
+    it 'raises an ArgumentError if the size given as first argument '\
+      'is zero or smaller' do
+      expect do
+        test_source.each_slice(-1) { |v| p v }
+      end.to raise_error(ArgumentError).with_message('invalid size')
+    end
+
+    it 'calls the given block for each slice of <n> emitted values' do
+      test_data = []
+      test_source.each_slice(3) { |v| test_data << v }
+
+      expect(test_data).to eq([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]])
+    end
+
+    it 'returns a Reacto::Subscription' do
+      subscription = test_source.each_slice(3) { |v| test_data << v }
+
+      expect(subscription).to_not be(nil)
+      expect(subscription).to be_kind_of(Reacto::Subscriptions::Subscription)
+    end
+
+    it 'returns a new Trackable with the each_slice behavior ' \
+      'if no block was given' do
+      trackable = test_source.each_slice(1)
+
+      attach_test_trackers(trackable)
+
+      expect(test_data).to eq([
+        [1], [2], [3], [4], [5], [6], [7], [8], [9], [10], '|'
+      ])
+    end
+  end
+end

data/spec/reacto/trackable/each_with_index_spec.rb

@@ -0,0 +1,33 @@
+context Reacto::Trackable do
+  context '#each_with_index' do
+    subject(:test_source) { described_class.enumerable(('A'..'F')) }
+
+    it 'calls the given block with two arguments, the value and its index, ' \
+      'for each emitted value' do
+
+      test_source.each_with_index { |v, i| test_data << [v, i] }
+
+      expect(test_data).to eq([
+        ['A', 0], ['B', 1], ['C', 2], ['D', 3], ['E', 4], ['F', 5]
+      ])
+    end
+
+    it 'returns a Reacto::Subscription' do
+      subscription = test_source.each_with_index { |v, i| test_data << [v, i] }
+
+      expect(subscription).to_not be(nil)
+      expect(subscription).to be_kind_of(Reacto::Subscriptions::Subscription)
+    end
+
+    it 'returns a new Trackable with the each_with_index behavior ' \
+      'if no block was given' do
+      trackable = test_source.each_with_index
+
+      attach_test_trackers(trackable)
+
+      expect(test_data).to eq([
+        ['A', 0], ['B', 1], ['C', 2], ['D', 3], ['E', 4], ['F', 5], '|'
+      ])
+    end
+  end
+end

data/spec/reacto/trackable/each_with_object_spec.rb

@@ -0,0 +1,26 @@
+context Reacto::Trackable do
+  context '#each_with_object' do
+    subject(:test_source) do
+      lyrics = 'I am drinking I am rolling I am hiding I am running'
+      described_class.enumerable(lyrics.split(''))
+    end
+
+    it 'calls the given block for each value emitted by the source ' \
+      'with an arbitrary object given, and emits the initially given object' do
+      trackable = test_source.each_with_object({}) do |v, memo|
+        unless v.strip.empty?
+          memo[v] ||= 0
+          memo[v] += 1
+        end
+      end
+      attach_test_trackers(trackable)
+
+      expect(test_data.size).to eq(2)
+      expect(test_data.first).to eq({
+        'I' => 4, 'a' => 4, 'm' => 4, 'd' => 2, 'r' => 3, 'i' => 6, 'n' => 7,
+        'k' => 1, 'g' => 4, 'o' => 1, 'l' => 2, 'h' => 1, 'u' => 1
+      })
+    end
+
+  end
+end

data/spec/reacto/trackable/entries_spec.rb

@@ -0,0 +1,25 @@
+context Reacto::Trackable do
+  context '#entries' do
+    subject(:test_source) { described_class.enumerable((1..100)) }
+
+    it 'returns an array containing all the values emitted by the source' do
+      result = test_source.entries
+
+      expect(result).to eq((1..100).to_a)
+    end
+
+    it 'returns an array containing the first <n> values emitted by the ' \
+      'source if a number is given' do
+      result = test_source.entries(5)
+
+      expect(result).to eq([1, 2, 3, 4, 5])
+    end
+
+    it 'blocks and waits for the array to be ready even if the source is ' \
+      'executing on background executor' do
+      result = test_source.delay_each(0.2).entries(3)
+
+      expect(result).to eq([1, 2, 3])
+    end
+  end
+end

data/spec/reacto/trackable/execute_on_spec.rb

@@ -0,0 +1,33 @@
+context Reacto::Trackable do
+  subject(:test_source) do
+   described_class.new do |tracker_subscription|
+      tracker_subscription.on_value(32)
+      sleep 1
+
+      tracker_subscription.on_close
+    end
+  end
+
+  context '#execute_on' do
+    it 'executes the whole chain of methods on a background managed thread' do
+      threads = []
+
+      trackable = test_source
+        .act { |n| threads << Thread.current }
+        .map { |v| v / 8 }
+        .execute_on(:background)
+
+      subscription = attach_test_trackers(trackable)
+      trackable.await(subscription)
+
+      expect(test_data).to eq([4, '|'])
+
+      threads = threads.uniq
+      expect(threads.size).to be(1)
+
+      thread = threads.first
+
+      expect(thread).to_not be(Thread.current)
+    end
+  end
+end

data/spec/reacto/trackable/find_index_spec.rb

@@ -0,0 +1,31 @@
+context Reacto::Trackable do
+  subject(:test_source) { described_class.enumerable(('a'..'z')) }
+
+  context '#find_index' do
+    it 'passes each emitted value from the source to block. Emits the ' \
+      'index of the first for which the evaluated value is non-false. ' do
+      trackable = test_source.find_index { |val| val == 'i' || val == 'h' }
+
+      attach_test_trackers(trackable)
+
+      expect(test_data).to eq([7, '|'])
+    end
+
+    it 'compares each emitted value with the given value, if such is given. ' \
+      'Emits the index of the first which is equal to the value, given.' do
+      trackable = test_source.find_index('j')
+
+      attach_test_trackers(trackable)
+
+      expect(test_data).to eq([9, '|'])
+    end
+
+    it 'emits only the close notification if there is no match' do
+      trackable = test_source.find_index('A')
+
+      attach_test_trackers(trackable)
+
+      expect(test_data).to eq(['|'])
+    end
+  end
+end

data/spec/reacto/trackable/find_spec.rb

@@ -0,0 +1,34 @@
+context Reacto::Trackable do
+  context '#find' do
+    subject(:source) { described_class.enumerable([0, 5, 2, 3, 4, 1, 6]) }
+
+    it 'doesn\'t notify with values not passing the filter block' do
+      trackable = source.find { |v| v > 10 }
+      trackable.on(value: test_on_value)
+
+      expect(test_data.size).to be(0)
+    end
+
+    it 'notifies with the first value passing the filter block' do
+      trackable = source.find do |v|
+        v % 2 == 1
+      end
+
+      trackable.on(value: test_on_value)
+
+      expect(test_data.size).to be(1)
+      expect(test_data.first).to be(5)
+    end
+
+    it 'notifies with the given value if value is given and nothing is found' do
+      trackable = source.find(15) do |v|
+        v > 10
+      end
+
+      trackable.on(value: test_on_value)
+
+      expect(test_data.size).to be(1)
+      expect(test_data.first).to be(15)
+    end
+  end
+end