reacto 0.1.0 → 1.0.0

data/spec/reacto/trackable/first_spec.rb

@@ -0,0 +1,36 @@
+context Reacto::Trackable do
+  context '#first' do
+    subject(:test_source) { described_class.enumerable((1..100)) }
+
+    it 'emits only the first element emitted by the source' do
+      trackable = test_source.first
+
+      attach_test_trackers(trackable)
+
+      expect(test_data).to eq([1, '|'])
+    end
+
+    it 'emits only the first <n> element emitted by the source ' \
+      'if <n> is given' do
+      trackable = test_source.first(5)
+
+      attach_test_trackers(trackable)
+
+      expect(test_data).to eq([1, 2, 3, 4, 5, '|'])
+    end
+
+    it 'raises an ArgumentError if <n> is given and is bellow zero' do
+      expect do
+        test_data.first(-2)
+      end.to raise_error(ArgumentError).with_message('negative array size')
+    end
+
+    it 'emits only the close notification if <n> is given and is zero' do
+      trackable = test_source.first(0)
+
+      attach_test_trackers(trackable)
+
+      expect(test_data).to eq(['|'])
+    end
+  end
+end

data/spec/reacto/trackable/flat_map_latest_spec.rb

@@ -1,8 +1,8 @@
-require 'spec_helper'
-
 context Reacto::Trackable do
-  context 'flat_map_latest' do
-    it 'TODO' do
+  context '#flat_map_latest' do
+    it 'emits the elements of the first returned Trackable from the block ' \
+      'until the block returns the next one. Then it switches to emitting ' \
+      'from the next' do
       trackable = described_class.interval(1).take(3).flat_map_latest do |val|
         Reacto::Trackable.interval(0.3, (val..7).to_enum)
       end
@@ -12,7 +12,7 @@ context Reacto::Trackable do
       )
 
       trackable.await(subscription)
-      expect(test_data).to be == [0, 1, 2, 1, 2, 3, 2, 3, 4, 5, 6, 7, '|']
+      expect(test_data).to eq([0, 1, 2, 1, 2, 3, 2, 3, 4, 5, 6, 7, '|'])
     end
   end
 end

data/spec/reacto/trackable/flat_map_spec.rb

@@ -14,5 +14,30 @@ context Reacto::Trackable do
       )
       expect(test_data).to be == [1, 2, 2, 3, 3, 4, 4, 5, 5, 6, '|']
     end
+
+    context 'with label' do
+      it 'applies the transformation passed only to the values of ' \
+        'the incoming values of type LabeledTrackable with matching label' do
+        trackable =
+          Reacto::Trackable.enumerable((1..10).each).group_by_label do |value|
+            [(value % 3), value]
+          end
+
+        trackable = trackable.flat_map(label: 1) do |value|
+          Reacto::Trackable.enumerable((value..10))
+        end
+
+        trackable.on(value: test_on_value)
+
+        labeled_trackable = test_data.first
+        expect(labeled_trackable.label).to eq(1)
+
+        labeled_data = []
+        labeled_trackable.on(value: ->(v) { labeled_data << v })
+
+        expected = [(1..10), (4..10), (7..10)].map(&:to_a).flatten + [10]
+        expect(labeled_data).to eq(expected)
+      end
+    end
   end
 end

data/spec/reacto/trackable/flatten_labeled_spec.rb

@@ -0,0 +1,48 @@
+context Reacto::Trackable do
+  context '#flatten_labeled' do
+    it 'transfomrs the LabeledTrackable instances emitted into objects with' \
+      'two attributes - label the label of the LabeledTrackable and value -' \
+      'the first value of emitted by the LabeledTrackable' do
+      trackable = described_class.enumerable((1..10)).group_by_label do |value|
+        [(value % 3), value]
+      end
+      trackable = trackable.flatten_labeled
+
+      trackable.on(value: test_on_value)
+
+      expect(test_data.count).to eq(3)
+      expect(test_data.map(&:value)).to eq([1, 2, 3])
+    end
+
+    it 'transfomrs the LabeledTrackable instances emitted into objects with' \
+      'two attributes - label the label of the LabeledTrackable and value -' \
+      'the last value computed by the passed accumulator block' do
+      trackable = described_class.enumerable((1..10)).group_by_label do |value|
+        [(value % 3), value]
+      end
+      trackable = trackable.flatten_labeled { |prev, curr| prev + curr }
+
+      trackable.on(value: test_on_value)
+
+      expect(test_data.count).to eq(3)
+      expect(test_data.map(&:value)).to eq([22, 15, 18])
+    end
+
+    it 'transfomrs the LabeledTrackable instances emitted into objects with' \
+      'two attributes - label the label of the LabeledTrackable and value -' \
+      'the last value computed by the passed accumulator block, using the ' \
+      'passed initial value' do
+      trackable = described_class.enumerable((1..10)).group_by_label do |value|
+        [(value % 3), value]
+      end
+      trackable = trackable.flatten_labeled(initial: -10) do |prev, curr|
+        prev + curr
+      end
+
+      trackable.on(value: test_on_value)
+
+      expect(test_data.count).to eq(3)
+      expect(test_data.map(&:value)).to eq([12, 5, 8])
+    end
+  end
+end

data/spec/reacto/trackable/grep_spec.rb

@@ -0,0 +1,29 @@
+context Reacto::Trackable do
+  context '#grep' do
+    subject(:test_source) { described_class.enumerable((1..100)) }
+
+    it 'returns a Reacto::Trackable emitting every value emitted by the ' \
+      'source for which the given <pattern> === value' do
+      trackable = test_source.grep(38..44)
+
+      attach_test_trackers(trackable)
+
+      expect(test_data).to eq([38, 39, 40, 41, 42, 43, 44, '|'])
+    end
+
+    subject(:test_source2) do
+      described_class.enumerable([
+        'HEY', 'FIND_ME', 'YO', 'FIND_HER', 'FIND_IT', 'FOUND_ME', 'NO_WAY'
+      ])
+    end
+
+    it 'passes each matching value to the optional block, if supplied and ' \
+      'the reuslts from it are emitted' do
+      trackable = test_source2.grep(/FIND/) { |v| v[-1] }
+
+      attach_test_trackers(trackable)
+
+      expect(test_data).to eq(%w(E R T |))
+    end
+  end
+end

data/spec/reacto/trackable/grep_v_spec.rb

@@ -0,0 +1,23 @@
+context Reacto::Trackable do
+  context '#grep_v' do
+    subject(:test_source) { described_class.enumerable((1..10)) }
+
+    it 'returns a Reacto::Trackable emitting every value emitted by the ' \
+      'source for which the given <pattern> === value returns false' do
+      trackable = test_source.grep_v(2..5)
+
+      attach_test_trackers(trackable)
+
+      expect(test_data).to eq([1, 6, 7, 8, 9, 10, '|'])
+    end
+
+    it 'passes each not matching value to the optional block, if supplied ' \
+      'and the reuslts from it are emitted' do
+      trackable = test_source.grep_v(2..7) { |v| v.even? }
+
+      attach_test_trackers(trackable)
+
+      expect(test_data).to eq([false, true, false, true, '|'])
+    end
+  end
+end

data/spec/reacto/trackable/{label_spec.rb → group_by_label_spec.rb}

@@ -1,12 +1,11 @@
 context Reacto::Trackable do
-  context '#label' do
+  context '#group_by_label' do
     it 'transforms each of the values emitted by the source into ' \
       'LabeledTrackable instances, using the passed function to get their ' \
       'labels and values to emit' do
-        trackable =
-          Reacto::Trackable.enumerable((1..10).each).label do |value|
-            [(value % 3), value]
-          end
+      trackable = described_class.enumerable((1..10)).group_by_label do |value|
+        [(value % 3), value]
+      end
 
       trackable.on(value: test_on_value)
 
@@ -24,12 +23,6 @@ context Reacto::Trackable do
       two.on(value: ->(v) { two_array << v })
       expect(two_array).to eq([2, 5, 8])
 
-      two = test_data[1]
-      expect(two.label).to eq(2)
-      two_array = []
-      two.on(value: ->(v) { two_array << v })
-      expect(two_array).to eq([2, 5, 8])
-
       zero = test_data.last
       expect(zero.label).to eq(0)
       zero_array = []

data/spec/reacto/trackable/include_spec.rb

@@ -0,0 +1,23 @@
+context Reacto::Trackable do
+  context '#include?' do
+    subject(:test_source) { described_class.enumerable((1..10)) }
+
+    it 'it creates a Reacto::Trackable emitting only one value : `true` if ' \
+      'the object given is emitted by the source' do
+      trackable = test_source.include?(5)
+
+      attach_test_trackers(trackable)
+
+      expect(test_data).to eq([true, '|'])
+    end
+
+    it 'it creates a Reacto::Trackable emitting only one value : `false` if ' \
+      'the object given is not emitted by the source' do
+      trackable = test_source.include?(15)
+
+      attach_test_trackers(trackable)
+
+      expect(test_data).to eq([false, '|'])
+    end
+  end
+end

data/spec/reacto/trackable/inject_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 context Reacto::Trackable do
   context '#inject' do
     let(:test_behaviour) do
@@ -23,6 +21,18 @@ context Reacto::Trackable do
       expect(test_data).to be == [16, 23, 2037]
     end
 
+    it 'keeps the same results for multiple subscriptions' do
+      trackable = source.inject(0) do |prev, v|
+        prev + v
+      end
+      trackable.on(value: test_on_value)
+      trackable.on(value: test_on_value)
+      trackable.on(value: test_on_value)
+
+      expect(test_data.size).to be(9)
+      expect(test_data).to be == [16, 23, 2037] * 3
+    end
+
     it 'sends the values created by applying the `inject` operation on the ' \
       'last value and current value, using for first value ' \
       'the first emitted by the source if no initial value provided' do
@@ -36,7 +46,7 @@ context Reacto::Trackable do
     end
 
     it 'sends the initial value if no value is emitted' do
-      source = described_class.new(-> (t) { t.on_close })
+      source = described_class.new(&-> (t) { t.on_close })
       trackable = source.inject(0) do |prev, v|
         prev + v
       end
@@ -47,7 +57,7 @@ context Reacto::Trackable do
     end
 
     it 'sends nothing if no initial value and no value emitted' do
-      source = described_class.new(-> (t) { t.on_close })
+      source = described_class.new(&-> (t) { t.on_close })
       trackable = source.inject do |prev, v|
         prev + v
       end
@@ -55,5 +65,21 @@ context Reacto::Trackable do
 
       expect(test_data.size).to be(0)
     end
+
+    context 'with label' do
+      it 'applies the  accumulation 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.inject(12, label: 0) { |prev, curr| prev + curr }
+        trackable.on(value: test_on_value)
+
+        expect_trackable_values(test_data.first, [1, 4, 7, 10], label: 1)
+        expect_trackable_values(test_data[1], [2, 5, 8], label: 2)
+        expect_trackable_values(test_data.last, [15, 21, 30], label: 0)
+      end
+    end
   end
 end

data/spec/reacto/trackable/lift_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 context Reacto::Trackable do
   context '#lift' do
     it 'applies a transformation to the trackable behaviour' do
@@ -13,7 +11,7 @@ context Reacto::Trackable do
       lifted_trackable.on(value: test_on_value)
 
       expect(test_data.size).to be(1)
-      expect(test_data[0]).to be(25)
+      expect(test_data.first).to be(25)
     end
   end
 end

data/spec/reacto/trackable/map_spec.rb

@@ -17,7 +17,7 @@ context Reacto::Trackable do
         subscriber.on_value(4)
         subscriber.on_error(StandardError.new('error'))
       end
-      trackable = source.map(-> (v) { v }, error: -> (e) { 5 })
+      trackable = source.map(error: -> (e) { 5 }, &-> (v) { v })
 
       trackable.on(value: test_on_value, error: test_on_error)
 
@@ -28,11 +28,25 @@ context Reacto::Trackable do
     it 'emits what is produced by the passed `close` function before close' do
       trackable =
         described_class.enumerable((1..5)).map(close: ->() { 10 }) do |v|
-        v
+          v
         end
 
       trackable.on(value: test_on_value, close: test_on_close)
-      expect(test_data).to be == (1..5).to_a + [10, '|']
+      expect(test_data).to eq((1..5).to_a + [10, '|'])
+    end
+
+    context 'with label' do
+      it 'applies the mapping passed only to the incoming 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.map(label: 1, close: -> { 4 }) { |value| value / 3 }
+        trackable.on(value: test_on_value)
+
+        expect_trackable_values(test_data.first, [0, 1, 2, 3, 4], label: 1)
+      end
     end
   end
 end

data/spec/reacto/trackable/max_by_spec.rb

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

data/spec/reacto/trackable/max_spec.rb

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

data/spec/reacto/trackable/merge_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 context Reacto::Trackable do
   context '#merge' do
     it 'merges the passed trackable\'s emitions with the source ones' do
@@ -12,8 +10,9 @@ context Reacto::Trackable do
       )
       trackable.await(subscription)
 
-      expect(test_data).to be ==
-        ["0a", "0b", "1a", "2a", "1b", "3a", "4a", "2b", "3b", "|"]
+      expect(test_data).to eq(
+        ['0a', '0b', '1a', '2a', '1b', '3a', '4a', '2b', '3b', '|']
+      )
     end
 
     it 'finishes with the error if `delay_error` is true' do
@@ -32,9 +31,9 @@ context Reacto::Trackable do
       )
       trackable.await(subscription, 2)
 
-      expect(test_data).to be ==
-        ["0a", "0b", "1a", "2a", "1b", "2b", "3b", err]
-
+      expect(test_data).to eq(
+        ['0a', '0b', '1a', '2a', '1b', '2b', '3b', err]
+      )
     end
   end
 end

data/spec/reacto/trackable/min_by_spec.rb

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