reacto 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1ce8f7dd2f7b2c680f62228680fe2dc6fcfbe5b5
-  data.tar.gz: 5518ae7b29f652786d20016dc3018b3d44975d8a
+  metadata.gz: 98fb0c0ff41e6efde1e6c11574dd9be835684b9d
+  data.tar.gz: b1f541bb712c8add903faa427b739bf8d8846bdd
 SHA512:
-  metadata.gz: 16ea2d612d86393abfdc70c72f78369beb436a9ed14791a907e2a5771cc593bb941779bcef49b2906ad523b65e884d32fc7df6971a4ee9e7bee9da3c2c4f32f7
-  data.tar.gz: 747d7487a69e971d63fd100db3def9e147e0596b2d337714c3673d849705710e498bacb97ec24064ac5eb68d3cb5d2b60172f0202000e6aee207e7a7444926a7
+  metadata.gz: e8492c6d0751362a31a6b2610ad5ceb16b168adf13ef4be8b53aac834fece5761aed037e334035ec2ed150eb5e6fc2fdefe8eb09da0e23ae2d1c72037b8f5e13
+  data.tar.gz: 4bb888957bb7241ca42c8955d001c5fd32feb3f047b15c01dac0c28c88757dd055139316be71401da0e17318d58829334857980c182d139015284604c2ca4ce0

data/Gemfile.lock

@@ -1,13 +1,13 @@
 PATH
   remote: .
   specs:
-    reacto (0.0.1)
+    reacto (0.1.0)
       concurrent-ruby (~> 1.0.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    concurrent-ruby (1.0.1)
+    concurrent-ruby (1.0.2)
     diff-lcs (1.2.5)
     rspec (3.3.0)
       rspec-core (~> 3.3.0)

data/README.md

@@ -1,4 +1,4 @@
-# reacto
+# Reacto
 
 Reactive Programming for Ruby with some concurrency thrown into the mix!
 
@@ -10,7 +10,7 @@ If you use `bundler` just add this line to your `Gemfile`:
 gem 'reacto'
 ```
 
-Alternatively you can instal the gem with `gem install reacto` or clone this
+Alternatively you can install the gem with `gem install reacto` or clone this
 repository and play with it!
 
 ## Why?
@@ -18,21 +18,72 @@ repository and play with it!
 Because it is very cool to be reactive these days!
 Seriously - to be reactive means that your code is able to react on changes
 happening in various places right away. For example third party data sources or
-other parts of the code. It helps writing multy-component apps which could
-handle failures and still be availale.
+other parts of the code. It helps writing multi-component apps which could
+handle failures and still be available.
 
-Of course there are other implemenations of reactive programming for ruby:
+Of course there are other implementations of reactive programming for ruby:
 
-* [RxRuby](https://github.com/ReactiveX/RxRuby) : Very powerful implemenation
+* [RxRuby](https://github.com/ReactiveX/RxRuby) : Very powerful implementation
   of RX. Handles concurrency and as a whole has more features than `Reacto`.
   So why `Reacto`? `Reacto` has simpler interface it is native Ruby lib and
   is easier to use it. The goal of `Reacto` is to be competitor to `RxRuby`
   in the ruby world.
-  Still the author of reacto is big fan of `RX` especially `RxJava`. He even has
+  Still the author of Reacto is big fan of `RX` especially `RxJava`. He even has
   a book on the topic using `RxJava` :
   [Learning Reactive Programming with Java 8](https://www.packtpub.com/application-development/learning-reactive-programming-java-8)
 * [Frappuccino](https://github.com/steveklabnik/frappuccino) : Very cool lib,
-  easy to use and simply beautiful. The only drawback - it is a bit limitted :
+  easy to use and simply beautiful. The only drawback - it is a bit limited :
   no concurrency and small set of operators.
   But if you don't need more complicated operators it is the best.
-  The author of `Reacto` highy recommends it.
+  The author of `Reacto` highly recommends it.
+
+## Usage
+
+### Simple Trackables
+
+The main entry point to the lib is the `Reacto::Trackable` class.
+It is something you can track for notifications. Usually A `Reacto::Trackable`
+implemenation is pushing notifications to some notification tracker.
+It depends on the source. We can have some remote streaming service as a source,
+or an synchronous HTTP request or some process pushing updates to another.
+Of course the source can be very simple, for example a single value:
+
+```ruby
+  trackable = Reacto::Trackable.value(5)
+```
+
+This value won't be emitted as notification until there is no tracker (listener)
+attached to the `trackable` - so this `trackable` instance is lazy - won't do
+anything until necessary.
+
+```ruby
+  trackable.on(value: ->(v) { puts v })
+
+  # => 5
+```
+
+This line attaches a notification tracker to the `trackable` - a lambda that
+should be called when the `trackable` emits any value. This example is very
+simple and the `trackable` emits only one value - `5` when a tracker is attached
+to it so the lambda will be called and the value will be printed.
+
+### Programming Trackable behavior
+
+A `Reacto::Trackable` can have custom behavior, defining what and when should
+be sent:
+
+```ruby
+  trackable = Reacto::Trackable.make do |tracker|
+    tracker.on_value('You say yes')
+    tracker.on_value('I say no')
+
+    sleep 1
+    tracker.on_value('You say stop and I say go go go, oh no')
+    tracker.on_close
+  end
+```
+
+When a tracker is attached this behavior will become active and the tracker
+will receive the first two sentences as values, then, after one second the third
+one and then a closing notification.
+

data/doc/create_and_user_trackables.md

@@ -0,0 +1 @@
+# Create And Use `Reacto::Trackable` objects.

data/lib/reacto.rb

@@ -4,6 +4,8 @@ require 'reacto/constants'
 require 'reacto/subscriptions'
 require 'reacto/tracker'
 require 'reacto/trackable'
+require 'reacto/shared_trackable'
+require 'reacto/labeled_trackable'
 
 module Reacto
 

data/lib/reacto/labeled_trackable.rb

@@ -0,0 +1,13 @@
+require 'reacto/trackable'
+
+module Reacto
+  class LabeledTrackable < Trackable
+    attr_reader :label
+
+    def initialize(label, executor = nil, behaviour = NO_ACTION, &block)
+      super(behaviour, executor, &block)
+
+      @label = label
+    end
+  end
+end

data/lib/reacto/operations.rb

@@ -1,4 +1,5 @@
 require 'reacto/operations/map'
+require 'reacto/operations/wrap'
 require 'reacto/operations/select'
 require 'reacto/operations/inject'
 require 'reacto/operations/diff'
@@ -17,3 +18,6 @@ require 'reacto/operations/throttle'
 require 'reacto/operations/flat_map'
 require 'reacto/operations/flat_map_latest'
 require 'reacto/operations/cache'
+require 'reacto/operations/depend_on'
+require 'reacto/operations/label'
+require 'reacto/operations/act'

data/lib/reacto/operations/concat.rb

@@ -12,7 +12,7 @@ module Reacto
         Subscriptions::OperationSubscription.new(
           tracker,
           close: -> () { @trackable.send(:do_track, tracker) },
-          error: -> (e) { 
+          error: -> (e) {
             tracker.on_error(e)
             @trackable.send(:do_track, tracker)
           }

data/lib/reacto/operations/depend_on.rb

@@ -0,0 +1,103 @@
+require 'reacto/constants'
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class DependOn
+      def initialize(trackable, key: :data, accumulator: nil)
+        @key = key
+        @trackable =
+          if accumulator.nil?
+            trackable.first
+          else
+            trackable.inject(NO_VALUE, accumulator)
+          end
+
+        @lock = Mutex.new
+
+        @close = false
+        @error = nil
+      end
+
+      def buffer
+        @buffer ||= []
+      end
+
+      def flush(error = nil)
+        unless error.nil?
+          @tracker.on_error(error)
+          return
+        end
+
+        buffer.each do |val|
+          @tracker.on_value(
+            OpenStruct.new({ value: val }.merge(@key => @result))
+          )
+        end
+
+        @tracker.on_close if @close
+        @tracker.on_error(@error) if @error
+      end
+
+      def check_ready_and_track(tracker)
+        depend_value = ->(v) { @result = v }
+        depend_error = ->(e) { flush(e) }
+        depend_close = -> { flush }
+
+        if @subscription.nil?
+          @tracker = tracker
+          @subscription = @trackable.on(
+            value: depend_value, error: depend_error, close: depend_close
+          )
+        end
+      end
+
+      def call(tracker)
+        value = ->(v) do
+          if @result.nil?
+            @lock.synchronize do
+              buffer << v
+
+              check_ready_and_track(tracker)
+            end
+          else
+            tracker.on_value(
+              OpenStruct.new({ value: v }.merge(@key => @result))
+            )
+          end
+        end
+
+        error = ->(e) do
+          if @result.nil?
+            @lock.synchronize do
+              @error = e
+
+              check_ready_and_track(tracker)
+            end
+          else
+            tracker.on_error(e)
+          end
+        end
+
+        close = -> do
+          if @result.nil?
+            @lock.synchronize do
+              @close = true
+
+              check_ready_and_track(tracker)
+            end
+          else
+            tracker.on_close
+          end
+        end
+
+        Subscriptions::OperationSubscription.new(
+          tracker,
+          value: value,
+          error: error,
+          close: close
+        )
+      end
+    end
+  end
+end

data/lib/reacto/operations/diff.rb

@@ -33,4 +33,3 @@ module Reacto
     end
   end
 end
-

data/lib/reacto/operations/flat_map.rb

@@ -17,6 +17,7 @@ module Reacto
         end
 
         close = lambda do
+          subscription.source_closed = true
           return unless subscription.closed?
 
           tracker.on_close
@@ -29,4 +30,3 @@ module Reacto
     end
   end
 end
-

data/lib/reacto/operations/flat_map_latest.rb

@@ -13,14 +13,15 @@ module Reacto
         value = lambda do |v|
           trackable = @transform.call(v)
 
-          sub = subscription.subscription!
-
           @last_active.unsubscribe if @last_active
+
+          sub = subscription.subscription!
           trackable.do_track sub
           @last_active = sub
         end
 
         close = lambda do
+          subscription.source_closed = true
           return unless subscription.closed?
 
           tracker.on_close
@@ -33,5 +34,3 @@ module Reacto
     end
   end
 end
-
-

data/lib/reacto/operations/label.rb

@@ -0,0 +1,48 @@
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class Label
+      def initialize(chose_label, executor = nil)
+        @chose_label = chose_label
+        @executor = executor
+
+        @labeled_values = {}
+      end
+
+      def call(tracker)
+        value = lambda do |v|
+          label, val = @chose_label.call(v)
+
+          @labeled_values[label] ||= []
+          @labeled_values[label] << val
+        end
+
+        close = lambda do
+          emit_values(tracker)
+          tracker.on_close
+        end
+
+        error = lambda do |err|
+          emit_values(tracker)
+          tracker.on_error(err)
+        end
+
+        Subscriptions::OperationSubscription.new(
+          tracker, value: value, error: error, close: close
+        )
+      end
+
+      def emit_values(tracker)
+        @labeled_values.each do |label, values|
+          trackable =
+            LabeledTrackable.new(label, @executor) do |subscriber|
+              values.each { |val| subscriber.on_value(val) }
+              subscriber.on_close
+            end
+          tracker.on_value(trackable)
+        end
+      end
+    end
+  end
+end

data/lib/reacto/operations/last.rb

@@ -28,4 +28,3 @@ module Reacto
     end
   end
 end
-

data/lib/reacto/operations/wrap.rb

@@ -0,0 +1,33 @@
+require 'ostruct'
+
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class Wrap
+      def initialize(args)
+        if args.key?(:value)
+          fail ArgumentError, "'value' is not valid key in the wrapping object"
+        end
+
+        if args.key?(:error)
+          fail ArgumentError, "'error' is not valid key in the wrapping object"
+        end
+
+        @args = args
+      end
+
+      def call(tracker)
+        value = ->(v) do
+          data = @args.each_with_object({}) do |(key, val), obj|
+            obj[key] = (val.respond_to? :call) ? val.call(v) : val
+          end
+
+          tracker.on_value OpenStruct.new({ value: v }.merge(data))
+        end
+
+        Subscriptions::OperationSubscription.new(tracker, value: value)
+      end
+    end
+  end
+end

data/lib/reacto/resources.rb

@@ -1 +1,2 @@
 require 'reacto/resources/executor_resource'
+require 'reacto/resources/shared_resource'

data/lib/reacto/resources/executor_resource.rb

@@ -5,6 +5,7 @@ module Reacto
         @executor = executor
         @threads = threads
       end
+
       def cleanup
         @executor.shutdown unless @executor.nil?
         @executor = nil

data/lib/reacto/resources/shared_resource.rb

@@ -0,0 +1,14 @@
+module Reacto
+  module Resources
+    class SharedResource
+      def initialize(trackable)
+        @trackable = trackable
+      end
+
+      def cleanup
+        @trackable.off
+        @trackable = nil
+      end
+    end
+  end
+end

data/lib/reacto/shared_trackable.rb

@@ -0,0 +1,56 @@
+require 'reacto/trackable'
+
+module Reacto
+  class SharedTrackable < Trackable
+    def initialize(
+      behaviour = NO_ACTION, executor = nil, activate_on_subscribe = false,
+      &block
+    )
+      super(behaviour, executor, &block)
+
+      @activate_on_subscribe = activate_on_subscribe
+      @active = false
+    end
+
+    def off(notification_tracker = nil)
+      shared_subscription.subscriptions.reject! do |subscription|
+        !subscription.subscribed?
+      end
+
+      return if shared_subscription.subscriptions.count > 0
+
+      shared_subscription.unsubscribe
+      @shared_subscription = nil
+      @active = false
+    end
+
+    def track(notification_tracker)
+      subscription =
+        Subscriptions::TrackerSubscription.new(notification_tracker, self)
+
+      shared_subscription.add(subscription)
+      activate! if @activate_on_subscribe
+
+      Subscriptions::SubscriptionWrapper.new(subscription)
+    end
+
+    def activate!
+      return if @shared_subscription.nil?
+      return if @active
+
+      @active = true
+      do_track(shared_subscription)
+
+      self
+    end
+
+    def activate_on_subscribe
+    end
+
+    private
+
+    def shared_subscription
+      @shared_subscription ||= Subscriptions.shared_subscription(self)
+    end
+  end
+end

data/lib/reacto/subscriptions.rb

@@ -9,6 +9,8 @@ require 'reacto/subscriptions/combining_last_subscription'
 require 'reacto/subscriptions/zipping_subscription'
 require 'reacto/subscriptions/flat_map_subscription'
 
+require 'reacto/resources/shared_resource'
+
 module Reacto
   module Subscriptions
     class << self
@@ -22,6 +24,10 @@ module Reacto
           error: -> (_e) { block.call }
         )
       end
+
+      def shared_subscription(trackable)
+        SimpleSubscription.new
+      end
     end
   end
 end

data/lib/reacto/subscriptions/flat_map_subscription.rb

@@ -4,8 +4,12 @@ require 'reacto/subscriptions/composite_subscription'
 module Reacto
   module Subscriptions
     class FlatMapSubscription < CompositeSubscription
+      attr_accessor :source_closed
+
       def initialize(subscriber)
         super(nil, subscriber)
+
+        @source_closed = false
       end
 
       def waiting?
@@ -17,8 +21,9 @@ module Reacto
       end
 
       def on_close
+        return unless source_closed
         return unless subscribed?
-        return unless @subscriptions.any? { |s| !s.closed? }
+        return unless @subscriptions.all? { |s| s.closed? }
 
         @subscriber.on_close
         unsubscribe

data/lib/reacto/subscriptions/inner_subscription.rb

@@ -35,6 +35,11 @@ module Reacto
         super(open: open, value: value, error: error, close: close)
       end
 
+      def unsubscribe
+        @closed = true
+        super
+      end
+
       def active?
         @active
       end

data/lib/reacto/subscriptions/simple_subscription.rb

@@ -6,6 +6,8 @@ module Reacto
     class SimpleSubscription
       include Subscription
 
+      attr_reader :subscriptions
+
       def initialize(
         open: NO_ACTION,
         value: NO_ACTION,
@@ -77,4 +79,3 @@ module Reacto
     end
   end
 end
-

data/lib/reacto/subscriptions/tracker_subscription.rb

@@ -20,6 +20,7 @@ module Reacto
 
       def unsubscribe
         @subscriptions.each(&:unsubscribe)
+        return unless subscribed?
 
         @trackable.off(@notification_tracker)
 

data/lib/reacto/trackable.rb

@@ -1,4 +1,5 @@
 require 'concurrent'
+require 'ostruct'
 
 require 'reacto/constants'
 require 'reacto/behaviours'
@@ -8,6 +9,7 @@ require 'reacto/operations'
 require 'reacto/executors'
 require 'reacto/resources'
 
+# TODO: Refactor the constructors and the factory methods
 module Reacto
   class Trackable
     TOPICS = [:open, :value, :error, :close]
@@ -89,12 +91,13 @@ module Reacto
           end
         else
           make do |tracker|
+            Thread::abort_on_exception = true
+
             queue = Queue.new
             task = Concurrent::TimerTask.new(execution_interval: interval) do
               queue.push('ready')
             end
 
-            Thread::abort_on_exception = true
             thread = Thread.new do
               begin
                 loop do
@@ -179,7 +182,7 @@ module Reacto
       track(Tracker.new(trackers))
     end
 
-    def off(notification_tracker)
+    def off(notification_tracker = nil)
       # Clean-up logic
     end
 
@@ -194,7 +197,7 @@ module Reacto
 
     def lift(operation = nil, &block)
       operation = block_given? ? block : operation
-      Trackable.new(nil, @executor) do |tracker_subscription|
+      self.class.new(nil, @executor) do |tracker_subscription|
         begin
           modified = operation.call(tracker_subscription)
           lift_behaviour(modified) unless modified == NOTHING
@@ -218,6 +221,10 @@ module Reacto
       ))
     end
 
+    def wrap(**args)
+      lift(Operations::Wrap.new(args))
+    end
+
     def select(filter = nil, &block)
       lift(Operations::Select.new(block_given? ? block : filter))
     end
@@ -291,12 +298,28 @@ module Reacto
       lift(Operations::Cache.new(type: type, **settings))
     end
 
+    def depend_on(trackable, key: :data, accumulator: nil, &block)
+      lift(Operations::DependOn.new(
+        trackable, key: key, accumulator: (block_given? ? block : accumulator)
+      ))
+    end
+
+    def label(labeling_action = nil, executor: nil, &block)
+      lift(Operations::Label.new(
+        block_given? ? block : labeling_action, executor
+      ))
+    end
+
+    def act(action = NO_ACTION, on: Operations::Act::ALL, &block)
+      lift(Operations::Act.new(block_given? ? block : action, on))
+    end
+
     def track_on(executor)
       lift(Operations::TrackOn.new(executor))
     end
 
     def execute_on(executor)
-      Trackable.new(@behaviour, executor)
+      self.class.new(@behaviour, executor)
     end
 
     def await(subscription, timeout = nil)

data/lib/reacto/version.rb

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

data/spec/reacto/shared_trackable_spec.rb

@@ -0,0 +1,38 @@
+context Reacto::SharedTrackable do
+  subject do
+    described_class.interval(0.3).take(10)
+  end
+
+  context '#track' do
+    it 'does not activate the behaviour' do
+      attach_test_trackers(subject)
+
+      sleep 1
+      expect(test_data).to be_empty
+    end
+  end
+
+  context '#activate!' do
+    it 'activates the Trackable behavior, all the assigned trackers receive ' \
+      'the same notifications' do
+      attach_test_trackers(subject)
+
+      additional_test_data = []
+      subject.on(value: ->(v) { additional_test_data << v })
+      subject.activate!
+
+      sleep 1
+      expect(test_data).to be == (0..2).to_a
+      expect(additional_test_data).to be == (0..2).to_a
+
+      yet_another_test_data = []
+      subject.on(value: ->(v) { yet_another_test_data << v })
+
+      sleep 1
+
+      expect(test_data).to be == (0..5).to_a
+      expect(additional_test_data).to be == (0..5).to_a
+      expect(yet_another_test_data).to be == (3..5).to_a
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+context Reacto::Trackable do
+  context '.combine' do
+    it 'combines the notifications of Trackables with different number of ' \
+      'notifications using the passed combinator' do
+      trackable1 = described_class.interval(0.3).take(4)
+      trackable2 = described_class.interval(0.7, ('a'..'b').each)
+      trackable3 = described_class.interval(0.5, ('A'..'C').each)
+
+      trackable = described_class.combine(
+        trackable1, trackable2, trackable3
+      ) do |v1, v2, v3|
+        "#{v1} : #{v2} : #{v3}"
+      end
+
+      subscription = attach_test_trackers(trackable)
+      trackable.await(subscription)
+
+      expect(test_data).to be == [
+        '1 : a : A', '2 : a : A', '2 : a : B', '3 : a : B',
+        '3 : b : B', '3 : b : C', '|'
+      ]
+    end
+  end
+end

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

@@ -3,12 +3,12 @@ require 'spec_helper'
 context Reacto::Trackable do
   context '.interval' do
     it 'emits an infinite sequence of number on every n seconds by default' do
-      trackable = described_class.interval(0.1)
+      trackable = described_class.interval(0.3)
       subscription = attach_test_trackers(trackable)
       sleep 1
       subscription.unsubscribe
 
-      expect(test_data).to be == (0..8).to_a
+      expect(test_data).to be == (0..2).to_a
     end
 
     it 'can use any enumerator to produce the sequence to emit' do
@@ -20,6 +20,17 @@ context Reacto::Trackable do
       expect(test_data).to be == ('a'..'i').to_a
     end
 
+    it 'handles interval of intervals' do
+      trackable = described_class.interval(0.5, (5..5).each)
+        .map { |v| v * 2 }
+        .flat_map { |v| Reacto::Trackable.interval(0.1, (v..15).each) }
+      subscription = attach_test_trackers(trackable)
+
+      trackable.await(subscription)
+
+      expect(test_data).to be == (10..15).to_a + ['|']
+    end
+
     it 'can use the immediate executor to block the current thread while ' \
       'emitting' do
       trackable = described_class.interval(

data/spec/reacto/trackable/depend_on_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+context Reacto::Trackable do
+  context '#depend_on' do
+    it 'suspends its caller untill the passed Trackable emits its ' \
+      'notifications and wraps the value of the caller with the accumulated ' \
+      'data of these notifications' do
+      trackable = described_class.enumerable([1, 5, 4]).depend_on(
+        described_class.value(10)
+      )
+
+      attach_test_trackers(trackable)
+
+      expect(test_data.size).to be 4
+      expect(test_data[0].value).to be 1
+      expect(test_data[0].data).to be 10
+      expect(test_data[1].value).to be 5
+      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 == '|'
+    end
+
+    it 'it uses the first emitted value for the data from the dependency ' \
+      'if no accumulator lambda/block is passed.' do
+      trackable = described_class.enumerable([1, 5, 4]).depend_on(
+        described_class.interval(0.4, [5, 10].each)
+      )
+
+      subscription = attach_test_trackers(trackable)
+      trackable.await(subscription)
+
+      expect(test_data.size).to be 4
+      expect(test_data[0].value).to be 1
+      expect(test_data[0].data).to be 5
+      expect(test_data[1].value).to be 5
+      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 == '|'
+    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 }
+
+      attach_test_trackers(trackable)
+
+      expect(test_data.size).to be 3
+      expect(test_data[0].value).to be 5
+      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 == '|'
+    end
+
+    it 'sends the error if the dependency has an error' do
+      error = StandardError.new('Error!')
+      trackable = described_class.enumerable([5, 4]).depend_on(
+        described_class.value(55).concat(described_class.error(error))
+      )
+
+      attach_test_trackers(trackable)
+
+      expect(test_data.size).to be 1
+      expect(test_data.last).to be == error
+    end
+  end
+end

data/spec/reacto/trackable/label_spec.rb

@@ -0,0 +1,40 @@
+context Reacto::Trackable do
+  context '#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.on(value: test_on_value)
+
+      expect(test_data.count).to eq(3)
+
+      one = test_data.first
+      expect(one.label).to eq(1)
+      one_array = []
+      one.on(value: ->(v) { one_array << v })
+      expect(one_array).to eq([1, 4, 7, 10])
+
+      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])
+
+      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 = []
+      zero.on(value: ->(v) { zero_array << v })
+      expect(zero_array).to eq([3, 6, 9])
+    end
+  end
+end

data/spec/reacto/trackable/lift_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+context Reacto::Trackable do
+  context '#lift' do
+    it 'applies a transformation to the trackable behaviour' do
+      lifted_trackable = source.lift do |tracker_subscription|
+        Reacto::Subscriptions::OperationSubscription.new(
+          tracker_subscription,
+          value: -> (v) { tracker_subscription.on_value(v * v) }
+        )
+      end
+
+      lifted_trackable.on(value: test_on_value)
+
+      expect(test_data.size).to be(1)
+      expect(test_data[0]).to be(25)
+    end
+  end
+end

data/spec/reacto/trackable/map_spec.rb

@@ -0,0 +1,38 @@
+context Reacto::Trackable do
+  context '#map' do
+    it 'transforms the value of the source Trackable using the passed ' \
+      'transformation' do
+      trackable = source.map do |v|
+        v * v * v
+      end
+
+      trackable.on(value: test_on_value)
+
+      expect(test_data.size).to be(1)
+      expect(test_data[0]).to be(125)
+    end
+
+    it 'transforms errors, if error transformation is passed' do
+      source = described_class.make do |subscriber|
+        subscriber.on_value(4)
+        subscriber.on_error(StandardError.new('error'))
+      end
+      trackable = source.map(-> (v) { v }, error: -> (e) { 5 })
+
+      trackable.on(value: test_on_value, error: test_on_error)
+
+      expect(test_data.size).to be(2)
+      expect(test_data).to be == [4, 5]
+    end
+
+    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
+        end
+
+      trackable.on(value: test_on_value, close: test_on_close)
+      expect(test_data).to be == (1..5).to_a + [10, '|']
+    end
+  end
+end

data/spec/reacto/trackable/on_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+context Reacto::Trackable do
+  context '#on' do
+    it 'returns a Reacto::Subscription' do
+      actual = described_class.new(Reacto::NO_ACTION).on
+
+      expect(actual).to_not be(nil)
+      expect(actual).to be_kind_of(Reacto::Subscriptions::Subscription)
+    end
+
+    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)
+
+        expect(test_data.size).to be(1)
+        expect(test_data[0]).to be(5)
+      end
+    end
+  end
+end

data/spec/reacto/trackable/prepend_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+context Reacto::Trackable do
+  context '#prepend' do
+    it 'emits the passed enumerable before the values, emited by the caller' do
+      source = described_class.enumerable((1..5))
+      trackable = source.prepend((-5..0))
+
+      trackable.on(value: test_on_value)
+
+      expect(test_data.size).to be(11)
+      expect(test_data).to be == (-5..5).to_a
+    end
+  end
+end

data/spec/reacto/trackable/select_spec.rb

@@ -0,0 +1,26 @@
+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.on(value: test_on_value)
+
+      expect(test_data.size).to be(0)
+    end
+
+    it 'notifies with values passing the filter block' do
+      trackable = source.select do |v|
+        v % 2 == 1
+      end
+
+      trackable.on(value: test_on_value)
+
+      expect(test_data.size).to be(1)
+      expect(test_data[0]).to be(5)
+    end
+  end
+end

data/spec/reacto/{executors_and_trackable_spec.rb → trackable/track_on_spec.rb}

@@ -25,3 +25,4 @@ context Reacto::Trackable do
     end
   end
 end
+

data/spec/reacto/trackable/wrap_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+context Reacto::Trackable do
+  context '#wrap' do
+    it 'wraps the incomming value in object with field `value` - the value' \
+      ' and the specified fields' do
+      now = Time.now
+      trackable = described_class.enumerable([1, 2]).wrap(now: now)
+
+      trackable.on(value: test_on_value)
+
+      expect(test_data.size).to be 2
+      expect(test_data.first.value).to be 1
+      expect(test_data.first.now).to be now
+      expect(test_data.last.value).to be 2
+      expect(test_data.last.now).to be now
+    end
+
+    it 'wraps the incomming value in object with field `value` - the value' \
+      ' and the specified fields if some of the field values are lambdas, ' \
+      'they are called with passed parameter - the incoming value' do
+      now = Time.now
+      trackable = described_class.enumerable([1, 2]).wrap(
+        now: now, bau: ->(v) { v * 2 }
+      )
+
+      trackable.on(value: test_on_value)
+
+      expect(test_data.size).to be 2
+      expect(test_data.first.value).to be 1
+      expect(test_data.first.now).to be now
+      expect(test_data.first.bau).to be 2
+      expect(test_data.last.value).to be 2
+      expect(test_data.last.now).to be now
+      expect(test_data.last.bau).to be 4
+    end
+
+    it 'raises an ArgumentError if the hash passed has a `value` key' do
+      expect { described_class.enumerable([1, 2]).wrap(value: 4) }.to(
+        raise_error(ArgumentError).with_message(
+          "'value' is not valid key in the wrapping object"
+        )
+      )
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reacto
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Nickolay Tzvetinov - Meddle
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-20 00:00:00.000000000 Z
+date: 2016-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -64,16 +64,19 @@ files:
 - Gemfile
 - Gemfile.lock
 - README.md
+- doc/create_and_user_trackables.md
 - lib/reacto.rb
 - lib/reacto/behaviours.rb
 - lib/reacto/cache/file.rb
 - lib/reacto/cache/memory.rb
 - lib/reacto/constants.rb
 - lib/reacto/executors.rb
+- lib/reacto/labeled_trackable.rb
 - lib/reacto/operations.rb
 - lib/reacto/operations/buffer.rb
 - lib/reacto/operations/cache.rb
 - lib/reacto/operations/concat.rb
+- lib/reacto/operations/depend_on.rb
 - lib/reacto/operations/diff.rb
 - lib/reacto/operations/drop.rb
 - lib/reacto/operations/drop_errors.rb
@@ -81,6 +84,7 @@ files:
 - lib/reacto/operations/flat_map_latest.rb
 - lib/reacto/operations/flatten.rb
 - lib/reacto/operations/inject.rb
+- lib/reacto/operations/label.rb
 - lib/reacto/operations/last.rb
 - lib/reacto/operations/map.rb
 - lib/reacto/operations/merge.rb
@@ -90,8 +94,11 @@ files:
 - lib/reacto/operations/throttle.rb
 - lib/reacto/operations/track_on.rb
 - lib/reacto/operations/uniq.rb
+- lib/reacto/operations/wrap.rb
 - lib/reacto/resources.rb
 - lib/reacto/resources/executor_resource.rb
+- lib/reacto/resources/shared_resource.rb
+- lib/reacto/shared_trackable.rb
 - lib/reacto/subscriptions.rb
 - lib/reacto/subscriptions/buffered_subscription.rb
 - lib/reacto/subscriptions/combining_last_subscription.rb
@@ -110,11 +117,12 @@ files:
 - lib/reacto/tracker.rb
 - lib/reacto/version.rb
 - reacto.gemspec
-- spec/reacto/create_trackable_spec.rb
-- spec/reacto/executors_and_trackable_spec.rb
 - spec/reacto/operations/track_on_spec.rb
+- spec/reacto/shared_trackable_spec.rb
 - spec/reacto/trackable/buffer_spec.rb
 - spec/reacto/trackable/cache_spec.rb
+- spec/reacto/trackable/class_level/combine_last_spec.rb
+- spec/reacto/trackable/class_level/combine_spec.rb
 - spec/reacto/trackable/class_level/enumerable_spec.rb
 - spec/reacto/trackable/class_level/error_spec.rb
 - spec/reacto/trackable/class_level/interval_spec.rb
@@ -123,18 +131,26 @@ files:
 - spec/reacto/trackable/class_level/never_spec.rb
 - spec/reacto/trackable/class_level/value_spec.rb
 - spec/reacto/trackable/concat_spec.rb
+- spec/reacto/trackable/depend_on_spec.rb
 - spec/reacto/trackable/diff_spec.rb
 - spec/reacto/trackable/drop_errors_spec.rb
 - spec/reacto/trackable/flat_map_latest_spec.rb
 - spec/reacto/trackable/flat_map_spec.rb
 - spec/reacto/trackable/flatten_spec.rb
 - spec/reacto/trackable/inject_spec.rb
+- spec/reacto/trackable/label_spec.rb
+- spec/reacto/trackable/lift_spec.rb
+- spec/reacto/trackable/map_spec.rb
 - spec/reacto/trackable/merge_spec.rb
+- spec/reacto/trackable/on_spec.rb
 - spec/reacto/trackable/positional_filtering_spec.rb
+- spec/reacto/trackable/prepend_spec.rb
+- spec/reacto/trackable/select_spec.rb
 - spec/reacto/trackable/throttle_spec.rb
+- spec/reacto/trackable/track_on_spec.rb
 - spec/reacto/trackable/uniq_spec.rb
+- spec/reacto/trackable/wrap_spec.rb
 - spec/reacto/trackable/zip_spec.rb
-- spec/reacto/trackable_spec.rb
 - spec/spec_helper.rb
 - spec/support/helpers.rb
 homepage: https://github.com/meddle0x53/reacto
@@ -162,11 +178,12 @@ signing_key:
 specification_version: 4
 summary: Concurrent Reactive Programming for Ruby
 test_files:
-- spec/reacto/create_trackable_spec.rb
-- spec/reacto/executors_and_trackable_spec.rb
 - spec/reacto/operations/track_on_spec.rb
+- spec/reacto/shared_trackable_spec.rb
 - spec/reacto/trackable/buffer_spec.rb
 - spec/reacto/trackable/cache_spec.rb
+- spec/reacto/trackable/class_level/combine_last_spec.rb
+- spec/reacto/trackable/class_level/combine_spec.rb
 - spec/reacto/trackable/class_level/enumerable_spec.rb
 - spec/reacto/trackable/class_level/error_spec.rb
 - spec/reacto/trackable/class_level/interval_spec.rb
@@ -175,17 +192,25 @@ test_files:
 - spec/reacto/trackable/class_level/never_spec.rb
 - spec/reacto/trackable/class_level/value_spec.rb
 - spec/reacto/trackable/concat_spec.rb
+- spec/reacto/trackable/depend_on_spec.rb
 - spec/reacto/trackable/diff_spec.rb
 - spec/reacto/trackable/drop_errors_spec.rb
 - spec/reacto/trackable/flat_map_latest_spec.rb
 - spec/reacto/trackable/flat_map_spec.rb
 - spec/reacto/trackable/flatten_spec.rb
 - spec/reacto/trackable/inject_spec.rb
+- spec/reacto/trackable/label_spec.rb
+- spec/reacto/trackable/lift_spec.rb
+- spec/reacto/trackable/map_spec.rb
 - spec/reacto/trackable/merge_spec.rb
+- spec/reacto/trackable/on_spec.rb
 - spec/reacto/trackable/positional_filtering_spec.rb
+- spec/reacto/trackable/prepend_spec.rb
+- spec/reacto/trackable/select_spec.rb
 - spec/reacto/trackable/throttle_spec.rb
+- spec/reacto/trackable/track_on_spec.rb
 - spec/reacto/trackable/uniq_spec.rb
+- spec/reacto/trackable/wrap_spec.rb
 - spec/reacto/trackable/zip_spec.rb
-- spec/reacto/trackable_spec.rb
 - spec/spec_helper.rb
 - spec/support/helpers.rb

data/spec/reacto/trackable_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-
-context Reacto::Trackable do
-  context '.new' do
-    it 'supports behavior invoked on tracking, passed as block' do
-      trackable = described_class.new do |tracker_subscription|
-        tracker_subscription.on_value(4)
-        tracker_subscription.on_close
-      end
-
-      trackable.on(value: test_on_value)
-      expect(test_data.size).to be(1)
-      expect(test_data[0]).to be(4)
-    end
-  end
-end