reacto 0.1.0 → 1.0.0

data/lib/reacto/version.rb

@@ -1,4 +1,4 @@
 module Reacto
-  VERSION = '0.1.0'
+  VERSION = '1.0.0'
 end
 

data/reacto.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Nickolay Tzvetinov - Meddle']
   spec.email         = ['n.tzvetinov@gmail.com']
   spec.description   = 'Concurrent Reactive Programming for Ruby'
-  spec.summary       = 'Concurrent Reactive Programming for Ruby'
+  spec.summary       = 'Reactive Programming for Ruby with some concurrency thrown into the mix.'
   spec.homepage      = 'https://github.com/meddle0x53/reacto'
   spec.license       = 'MIT'
 
@@ -22,6 +22,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'bundler', '~> 1.3'
   spec.add_development_dependency 'rspec', '~> 3.3.0'
 
-  spec.add_dependency 'concurrent-ruby', '~> 1.0.0'
+  spec.add_dependency 'concurrent-ruby', '~> 1.0.2'
 end
-

data/spec/reacto/labeled_trackable_spec.rb

@@ -0,0 +1,17 @@
+context Reacto::LabeledTrackable do
+  subject do
+    described_class.new('label') do |subscriber|
+      subscriber.on_value(5)
+      subscriber.on_value(15)
+      subscriber.on_close
+    end
+  end
+
+  context '#relabel' do
+    it 'creates new LabeledTrackable with label created by the block passed' do
+      trackable = subject.relabel { |label| label.gsub('l', 'r') }
+
+      expect(trackable.label).to eq('raber')
+    end
+  end
+end

data/spec/reacto/trackable/act_spec.rb

@@ -0,0 +1,15 @@
+context Reacto::Trackable do
+  context '#act' do
+    it 'can be used to do something with the currently incloming data, ' \
+      'without changing it (if imuttable), for example logging' do
+      notifications = []
+
+      trackable = described_class.enumerable((1..20)).act do |notification|
+        notifications << notification
+      end
+      trackable.on(value: test_on_value)
+
+      expect(notifications.size).to eq(21)
+    end
+  end
+end

data/spec/reacto/trackable/all_spec.rb

@@ -0,0 +1,38 @@
+context Reacto::Trackable do
+  context '#all?' do
+    it 'passes each incoming value to the given block. The resulting ' \
+      'Reacto::Trackable emits only one value - `true` if the block never ' \
+      'returns `false` or `nil`. Test true.' do
+      trackable = described_class.enumerable((1..5)).all? 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 never ' \
+      'returns `false` or `nil`. Test false.' do
+      trackable = described_class.enumerable((1..7)).all? 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((1..7)).all?
+
+      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/any_spec.rb

@@ -0,0 +1,39 @@
+context Reacto::Trackable do
+  context '#any?' do
+    it 'passes each incoming value to the given block. The resulting ' \
+      'Reacto::Trackable emits only one value - `true` if the block returns ' \
+      'even one `true`. Test true.' do
+      trackable = described_class.enumerable((5..10)).any? 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 ' \
+      'even one `true`. Test false.' do
+      trackable = described_class.enumerable((6..10)).any? 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([nil, nil]).any?
+
+      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/append_spec.rb

@@ -0,0 +1,38 @@
+context Reacto::Trackable do
+  context '#append' do
+    it 'emits a given enumerable after all the values, incoming from the ' \
+      'caller are emitted' do
+      source = described_class.enumerable((1..5))
+      trackable = source.append((6..10))
+
+      trackable.on(value: test_on_value)
+
+      expect(test_data.size).to be(10)
+      expect(test_data).to eq((1..10).to_a)
+    end
+
+    it 'does not append anything if `condition: :source_empty` is given ' \
+      'and the source has emitted values' do
+      source = described_class.enumerable((1..5))
+      trackable = source.append((6..10), condition: :source_empty)
+
+      trackable.on(value: test_on_value)
+
+      expect(test_data.size).to be(5)
+      expect(test_data).to eq((1..5).to_a)
+    end
+
+    it 'emits a given enumerable after the `close` notification, incoming ' \
+      'from the caller is emitted if `condition: :source_empty` is given and ' \
+      'no values were emitted' do
+      source = described_class.close
+      trackable = source.append((6..10), condition: :source_empty)
+
+      trackable.on(value: test_on_value)
+
+      expect(test_data.size).to be(5)
+      expect(test_data).to eq((6..10).to_a)
+    end
+  end
+end
+

data/spec/reacto/trackable/buffer_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 context Reacto::Trackable do
   context '#buffer' do
     context 'count' do
@@ -9,8 +7,9 @@ context Reacto::Trackable do
           value: test_on_value, close: test_on_close, error: test_on_error
         )
 
-        expect(test_data).to be ==
+        expect(test_data).to eq(
           [(1..5).to_a, (6..10).to_a, (11..15).to_a, (16..20).to_a, '|']
+        )
       end
     end
 
@@ -21,15 +20,14 @@ context Reacto::Trackable do
           value: test_on_value, close: test_on_close, error: test_on_error
         )
         trackable.await(subscription)
-        expect(test_data).to be ==
-          [
-            [0, 1, 2, 3],
-            [4, 5, 6, 7, 8],
-            [9, 10, 11, 12, 13],
-            [14, 15, 16, 17, 18],
-            [19],
-            "|"
-        ]
+        expect(test_data).to eq([
+          [0, 1, 2, 3],
+          [4, 5, 6, 7, 8],
+          [9, 10, 11, 12, 13],
+          [14, 15, 16, 17, 18],
+          [19],
+          '|'
+        ])
       end
     end
 
@@ -49,10 +47,8 @@ context Reacto::Trackable do
         trackable.on(
           value: test_on_value, close: test_on_close, error: test_on_error
         )
-        expect(test_data).to be ==
-          [[1, 2, 3], [4, 5], [6], '|']
+        expect(test_data).to eq([[1, 2, 3], [4, 5], [6], '|'])
       end
     end
   end
 end
-

data/spec/reacto/trackable/chunk_spec.rb

@@ -0,0 +1,86 @@
+context Reacto::Trackable do
+  context '#chunk' 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 chunks the incoming values ' \
+      'together based on the return value of the given block. ' \
+      'The chuncks are emitted as LabeledTrackable instances' do
+      trackable = test_source.chunk { |v| v.even? }
+
+      attach_test_trackers(trackable)
+
+      expect(test_data.length).to be(6)
+      expect_values(test_data.first, false, [3, 1])
+      expect_values(test_data[1], true, [4])
+      expect_values(test_data[2], false, [1, 5, 9])
+      expect_values(test_data[3], true, [2, 6])
+      expect_values(test_data[4], false, [5, 3, 5])
+      expect(test_data.last).to eq('|')
+    end
+
+    it 'uses nil as flag to group items' \
+      'together based on the return value of the given block. ' \
+      'The chuncks are emitted as LabeledTrackable instances' do
+      trackable = test_source.chunk { |v| v.even? ? 'even' : nil }
+
+      attach_test_trackers(trackable)
+
+      expect(test_data.length).to be(3)
+      expect_values(test_data.first, 'even', [4])
+      expect_values(test_data[1], 'even', [2, 6])
+      expect(test_data.last).to eq('|')
+    end
+
+    it 'uses :_separator as flag to group items' \
+      'together based on the return value of the given block. ' \
+      'The chuncks are emitted as LabeledTrackable instances' do
+      trackable = test_source.chunk { |v| v.even? ? :_separator : 'odd' }
+
+      attach_test_trackers(trackable)
+
+      expect(test_data.length).to be(4)
+      expect_values(test_data.first, 'odd', [3, 1])
+      expect_values(test_data[1], 'odd', [1, 5, 9])
+      expect_values(test_data[2], 'odd', [5, 3, 5])
+      expect(test_data.last).to eq('|')
+    end
+
+    it 'uses :_alone as flag to emit a LabeledTrackable which emits only one ' \
+      'value, the one marked as :_alone' do
+      trackable = test_source.chunk do |v|
+        v.even? ? :_alone : 'odd'
+      end
+
+      attach_test_trackers(trackable)
+
+      expect(test_data.length).to be(7)
+      expect_values(test_data.first, 'odd', [3, 1])
+      expect_values(test_data[1], :_alone, [4])
+      expect_values(test_data[2], 'odd', [1, 5, 9])
+      expect_values(test_data[3], :_alone, [2])
+      expect_values(test_data[4], :_alone, [6])
+      expect_values(test_data[5], 'odd', [5, 3, 5])
+      expect(test_data.last).to eq('|')
+    end
+
+    it 'emits an error if the label returned by the ckunking function is a ' \
+      'symbol, which starts with `_` and it is not :_separator or :_alone' do
+      trackable = test_source.chunk do |v|
+        v.even? ? :_stuff : 'odd'
+      end
+
+      attach_test_trackers(trackable)
+
+      expect(test_data.length).to be(2)
+      expect_values(test_data.first, 'odd', [3, 1])
+      expect(test_data.last).to eq(RuntimeError.new(
+        'symbols beginning with an underscore are reserved'
+      ))
+    end
+  end
+end

data/spec/reacto/trackable/chunk_while_spec.rb

@@ -0,0 +1,22 @@
+context Reacto::Trackable do
+  context '#chunk_while' do
+
+    let(:data) { [1, 2, 4, 9, 10, 11, 12, 15, 16, 19, 20, 21] }
+    subject(:source_trackable) { described_class.enumerable(data) }
+
+    it 'emits a Trackable for each chunked values. ' \
+      'The beginnings of chunks are defined by the block.' do
+      trackable = source_trackable.chunk_while { |i, j| i + 1 == j }
+
+      attach_test_trackers(trackable)
+
+      expect(test_data.length).to be(6)
+      expect_trackable_values(test_data.first, [1, 2])
+      expect_trackable_values(test_data[1], [4])
+      expect_trackable_values(test_data[2], [9, 10, 11, 12])
+      expect_trackable_values(test_data[3], [15, 16])
+      expect_trackable_values(test_data[4], [19, 20, 21])
+      expect(test_data.last).to eq('|')
+    end
+  end
+end

data/spec/reacto/trackable/class_level/combine_last_spec.rb

@@ -1,9 +1,7 @@
-require 'spec_helper'
-
 context Reacto::Trackable do
   context '.combine_last' do
     it 'combines the notifications of Trackables based on their ' \
-      'sequence number - the first notification of the sources, then ' \
+      'sequence number - the first notifications of the sources, then ' \
       'the next ones and in the end closes if any of the sources closes' do
       trackable1 = described_class.interval(0.3).take(4)
       trackable2 = described_class.interval(0.7, ('a'..'b').each)

data/spec/reacto/trackable/class_level/interval_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 context Reacto::Trackable do
   context '.interval' do
     it 'emits an infinite sequence of number on every n seconds by default' do
@@ -8,7 +6,7 @@ context Reacto::Trackable do
       sleep 1
       subscription.unsubscribe
 
-      expect(test_data).to be == (0..2).to_a
+      expect(test_data).to eq((0..2).to_a)
     end
 
     it 'can use any enumerator to produce the sequence to emit' do
@@ -17,7 +15,7 @@ context Reacto::Trackable do
       sleep 1
       subscription.unsubscribe
 
-      expect(test_data).to be == ('a'..'i').to_a
+      expect(test_data).to include(*('a'..'i').to_a)
     end
 
     it 'handles interval of intervals' do
@@ -28,7 +26,7 @@ context Reacto::Trackable do
 
       trackable.await(subscription)
 
-      expect(test_data).to be == (10..15).to_a + ['|']
+      expect(test_data).to eq((10..15).to_a + ['|'])
     end
 
     it 'can use the immediate executor to block the current thread while ' \
@@ -38,7 +36,7 @@ context Reacto::Trackable do
       )
       subscription = attach_test_trackers(trackable)
 
-      expect(test_data).to be == (1..5).to_a + ['|']
+      expect(test_data).to eq((1..5).to_a + ['|'])
     end
   end
 end

data/spec/reacto/trackable/class_level/make_spec.rb

@@ -2,21 +2,6 @@ require 'spec_helper'
 
 context Reacto::Trackable do
   context '.make' do
-    it 'creates a new trackable with custom behaviour passed as lambda' do
-      behaviour = lambda do |tracker|
-        (1..10).each do |v|
-          tracker.on_value(v)
-        end
-
-        tracker.on_close
-      end
-
-      attach_test_trackers described_class.make(behaviour)
-
-      expect(test_data.size).to be(11)
-      expect(test_data).to be == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, '|']
-    end
-
     it 'creates a new trackable with custom behaviour passed as block' do
       trackable = described_class.make do |tracker|
         (1..10).each do |v|

data/spec/reacto/trackable/{zip_spec.rb → class_level/zip_spec.rb}

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 context Reacto::Trackable do
   context '.zip' do
     it 'combines the first notifications of the source Trackable instances, ' \

data/spec/reacto/trackable/concat_spec.rb

@@ -1,34 +1,34 @@
-require 'spec_helper'
-
 context Reacto::Trackable do
+  subject(:test_source) { described_class.enumerable((1..5)) }
+
   context '#concat' do
     it 'starts emitting the values from the concatenated after emitting the ' \
       'values from the source, then emits a `close` notification' do
-      trackable = source.concat(described_class.enumerable((6..10)))
+      trackable = test_source.concat(described_class.enumerable((6..10)))
       trackable.on(value: test_on_value, close: test_on_close)
 
-      expect(test_data).to be == (5..10).to_a + ['|']
+      expect(test_data).to eq((1..10).to_a + ['|'])
     end
 
     it 'can be chained' do
-      trackable = source
-      .concat(described_class.enumerable((6..8)))
-      .concat(described_class.enumerable((9..10)))
+      trackable = test_source
+        .concat(described_class.enumerable((6..8)))
+        .concat(described_class.enumerable((9..10)))
       trackable.on(value: test_on_value, close: test_on_close)
 
-      expect(test_data).to be == (5..10).to_a + ['|']
+      expect(test_data).to eq((1..10).to_a + ['|'])
     end
 
     it 'closes on error' do
       err = StandardError.new('Hey')
-      trackable = source
-      .concat(described_class.error(err))
-      .concat(described_class.enumerable((9..10)))
+      trackable = test_source
+        .concat(described_class.error(err))
+        .concat(described_class.enumerable((9..10)))
       trackable.on(
         value: test_on_value, close: test_on_close, error: test_on_error
       )
 
-      expect(test_data).to be == [5, err]
+      expect(test_data).to eq([1, 2, 3, 4, 5, err])
     end
   end
 end