reacto 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8c3be32892f6d090d99fad277060c0a6594eff2f
-  data.tar.gz: 8cf5362fb0e3a1de7d6a7ab8c30fa6afd78cba97
+  metadata.gz: 1ce8f7dd2f7b2c680f62228680fe2dc6fcfbe5b5
+  data.tar.gz: 5518ae7b29f652786d20016dc3018b3d44975d8a
 SHA512:
-  metadata.gz: 60e81798750a652579e0834810f80352c0c6fb3418c35f062ee82efd26f2ec44f9211e149324ec5da9b6e4547aaca700bac123aef4333725ee2a19eb3c63812e
-  data.tar.gz: bc7528738e9e26c73eb513075c6ebea36870eb9c0d396672391130abfdf1862ed0a44dd1b7db751e1fcf9617ad6d432a5c558fe825e996c36535cdd207ea386a
+  metadata.gz: 16ea2d612d86393abfdc70c72f78369beb436a9ed14791a907e2a5771cc593bb941779bcef49b2906ad523b65e884d32fc7df6971a4ee9e7bee9da3c2c4f32f7
+  data.tar.gz: 747d7487a69e971d63fd100db3def9e147e0596b2d337714c3673d849705710e498bacb97ec24064ac5eb68d3cb5d2b60172f0202000e6aee207e7a7444926a7

data/.rspec

@@ -1,2 +1,3 @@
 --color
 --require spec_helper
+--order rand

data/Gemfile.lock

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

data/README.md

@@ -1 +1,38 @@
 # reacto
+
+Reactive Programming for Ruby with some concurrency thrown into the mix!
+
+## How to install?
+
+If you use `bundler` just add this line to your `Gemfile`:
+
+```ruby
+gem 'reacto'
+```
+
+Alternatively you can instal the gem with `gem install reacto` or clone this
+repository and play with it!
+
+## Why?
+
+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.
+
+Of course there are other implemenations of reactive programming for ruby:
+
+* [RxRuby](https://github.com/ReactiveX/RxRuby) : Very powerful implemenation
+  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
+  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 :
+  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.

data/lib/reacto/cache/file.rb

@@ -0,0 +1,103 @@
+require 'yaml'
+require 'reacto/cache/memory'
+
+module Reacto
+  module Cache
+    class File
+      attr_reader :location, :ttl
+      attr_reader :data
+
+      def initialize(location: nil, ttl: 60)
+        @location = location
+        @ttl = ttl
+
+        if @location.nil?
+          fail(
+            ArgumentError, 'File location is mandatory while using file cache!'
+          )
+        end
+      end
+
+      def ready?
+        return data.ready? unless data.nil?
+
+        fresh?
+      end
+
+      def each
+        return unless ready?
+        deserialize
+
+        data.each do |value|
+          yield value
+        end
+      end
+
+      def error?
+        return false unless ready?
+        deserialize
+
+        data.error?
+      end
+
+      def closed?
+        return false unless ready?
+        deserialize
+
+        data.closed?
+      end
+
+      def error
+        return false unless ready?
+        deserialize
+
+        data.error
+      end
+
+      def on_value(value)
+        init_data
+
+        data.on_value(value)
+      end
+
+      def on_error(error)
+        init_data
+
+        data.on_error(error)
+        serialize
+      end
+
+      def on_close
+        init_data
+
+        data.on_close
+        serialize
+      end
+
+      private
+
+      def fresh?
+        ::File.file?(location) && (Time.now - ::File.mtime(location)) <= ttl
+      end
+
+      def init_data
+        @data ||= Memory.new
+      end
+
+      def deserialize
+        return unless fresh?
+
+        @data ||= YAML::load(::File.read(location))
+      end
+
+      def serialize
+        return if data.nil?
+
+        ::File.open(location, 'w') do |f|
+          f.write(YAML::dump(data))
+        end
+      end
+    end
+  end
+end
+

data/lib/reacto/cache/memory.rb

@@ -0,0 +1,44 @@
+module Reacto
+  module Cache
+    class Memory
+      def initialize(_ = nil)
+        @values = []
+        @closed = false
+      end
+
+      def each
+        @values.each do |value|
+          yield value
+        end
+      end
+
+      def ready?
+        error? || closed?
+      end
+
+      def error?
+        @error != nil
+      end
+
+      def closed?
+        @closed
+      end
+
+      def error
+        @error
+      end
+
+      def on_value(value)
+        @values << value
+      end
+
+      def on_error(error)
+        @error = error
+      end
+
+      def on_close
+        @closed = true
+      end
+    end
+  end
+end

data/lib/reacto/operations/cache.rb

@@ -0,0 +1,53 @@
+require 'reacto/constants'
+require 'reacto/subscriptions/operation_subscription'
+require 'reacto/cache/memory'
+require 'reacto/cache/file'
+
+module Reacto
+  module Operations
+    class Cache
+      TYPES = {
+        memory: Reacto::Cache::Memory,
+        file: Reacto::Cache::File
+      }
+
+      def initialize(type: :memory, **settings)
+        type = TYPES[type] if TYPES.key?(type)
+
+        @cache = type.new(**settings)
+      end
+
+      def call(tracker)
+        if @cache.ready?
+          @cache.each do |value|
+            tracker.on_value(value)
+          end
+
+          if @cache.error?
+            tracker.on_error(@cache.error)
+          else
+            tracker.on_close
+          end
+
+          NOTHING
+        else
+          Subscriptions::OperationSubscription.new(
+            tracker,
+            value: -> (v) do
+              @cache.on_value(v)
+              tracker.on_value(v)
+            end,
+            error: -> (e) do
+              @cache.on_error(e)
+              tracker.on_error(e)
+            end,
+            close: -> () do
+              @cache.on_close
+              tracker.on_close
+            end
+          )
+        end
+      end
+    end
+  end
+end

data/lib/reacto/operations.rb

@@ -16,9 +16,4 @@ require 'reacto/operations/flatten'
 require 'reacto/operations/throttle'
 require 'reacto/operations/flat_map'
 require 'reacto/operations/flat_map_latest'
-
-module Reacto
-  module Operations
-  end
-end
-
+require 'reacto/operations/cache'

data/lib/reacto/resources/executor_resource.rb

@@ -6,7 +6,7 @@ module Reacto
         @threads = threads
       end
       def cleanup
-        @executor.shutdown
+        @executor.shutdown unless @executor.nil?
         @executor = nil
 
         @threads.each do |thread|

data/lib/reacto/subscriptions/composite_subscription.rb

@@ -42,6 +42,7 @@ module Reacto
         return unless subscribed?
         return if waiting?
 
+
         on_value_subscriptions(val)
         after_on_value(val)
       end
@@ -69,7 +70,7 @@ module Reacto
 
       def on_close
         return unless subscribed?
-        return unless @subscriptions.any? { |s| !s.closed? }
+        return if @subscriptions.any? { |s| !s.closed? }
 
         @subscriber.on_close
         unsubscribe

data/lib/reacto/subscriptions/flat_map_subscription.rb

@@ -15,6 +15,14 @@ module Reacto
       def on_value_subscriptions(v)
         @subscriber.on_value(v)
       end
+
+      def on_close
+        return unless subscribed?
+        return unless @subscriptions.any? { |s| !s.closed? }
+
+        @subscriber.on_close
+        unsubscribe
+      end
     end
   end
 end

data/lib/reacto/subscriptions/simple_subscription.rb

@@ -62,7 +62,7 @@ module Reacto
       def on_error(e)
         return unless subscribed?
 
-        @error.call(error)
+        @error.call(e)
         @subscriptions.each { |s| s.on_error(e) }
         unsubscribe
       end

data/lib/reacto/trackable.rb

@@ -1,5 +1,6 @@
 require 'concurrent'
 
+require 'reacto/constants'
 require 'reacto/behaviours'
 require 'reacto/subscriptions'
 require 'reacto/tracker'
@@ -92,6 +93,8 @@ module Reacto
             task = Concurrent::TimerTask.new(execution_interval: interval) do
               queue.push('ready')
             end
+
+            Thread::abort_on_exception = true
             thread = Thread.new do
               begin
                 loop do
@@ -193,7 +196,8 @@ module Reacto
       operation = block_given? ? block : operation
       Trackable.new(nil, @executor) do |tracker_subscription|
         begin
-          lift_behaviour(operation.call(tracker_subscription))
+          modified = operation.call(tracker_subscription)
+          lift_behaviour(modified) unless modified == NOTHING
         rescue Exception => e
           tracker_subscription.on_error(e)
         end
@@ -282,6 +286,11 @@ module Reacto
       lift(Operations::Throttle.new(delay))
     end
 
+    def cache(type: :memory, **settings)
+      settings ||= {}
+      lift(Operations::Cache.new(type: type, **settings))
+    end
+
     def track_on(executor)
       lift(Operations::TrackOn.new(executor))
     end

data/lib/reacto/version.rb

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

data/spec/reacto/create_trackable_spec.rb

@@ -1,216 +1,6 @@
 require 'spec_helper'
 
 context Reacto::Trackable do
-  context '.error' do
-    it 'creates a new trackable emitting only the error passed' do
-      err = StandardError.new('Errrr')
-      attach_test_trackers described_class.error(err)
-
-      expect(test_data).to be == [err]
-    end
-  end
-
-  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|
-          tracker.on_value(v)
-        end
-
-        tracker.on_close
-      end
-      attach_test_trackers trackable
-
-      expect(test_data.size).to be(11)
-      expect(test_data).to be == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, '|']
-    end
-
-    it 'does not emit anything once it is closed' do
-      trackable = described_class.make do |tracker|
-        (1..5).each do |v|
-          tracker.on_value(v)
-        end
-
-        tracker.on_close
-
-        (1..5).each do |v|
-          tracker.on_value(v)
-        end
-      end
-      attach_test_trackers trackable
-
-      expect(test_data.size).to be(6)
-      expect(test_data).to be == [1, 2, 3, 4, 5, '|']
-    end
-
-    it 'does not emit anything once it has an error' do
-      trackable = described_class.make do |tracker|
-        (1..5).each do |v|
-          tracker.on_value(v)
-        end
-
-        tracker.on_error('error')
-
-        (1..5).each do |v|
-          tracker.on_value(v)
-        end
-      end
-      attach_test_trackers trackable
-
-      expect(test_data.size).to be(6)
-      expect(test_data).to be == [1, 2, 3, 4, 5, 'error']
-    end
-
-    it 'emits the same behaviour for every subscribe' do
-      trackable = described_class.make do |tracker|
-        (1..5).each do |v|
-          tracker.on_value(v)
-        end
-
-        tracker.on_close
-      end
-      attach_test_trackers trackable
-      attach_test_trackers trackable
-
-      expect(test_data.size).to be(12)
-      expect(test_data).to be == [1, 2, 3, 4, 5, '|', 1, 2, 3, 4, 5, '|']
-    end
-  end
-
-  context '.later' do
-    it 'emits the passed value after the passed time runs out and then emits ' \
-      'a close notification' do
-      trackable = described_class.later(0.2, 5)
-      subscription = attach_test_trackers(trackable)
-
-      expect(test_data).to be_empty
-      trackable.await(subscription)
-      expect(test_data).to be == [5, '|']
-    end
-
-    it 'it can use a specific executor' do
-      trackable = described_class.later(
-        0.2, 5, executor: Reacto::Executors.immediate
-      )
-      subscription = attach_test_trackers(trackable)
-      expect(test_data).to be == [5, '|']
-    end
-  end
-
-  context '.interval' do
-    it 'emits an infinite sequence of number on every n seconds by default' do
-      trackable = described_class.interval(0.1)
-      subscription = attach_test_trackers(trackable)
-      sleep 1
-      subscription.unsubscribe
-
-      expect(test_data).to be == (0..8).to_a
-    end
-
-    it 'can use any enumerator to produce the sequence to emit' do
-      trackable = described_class.interval(0.1, ('a'..'z').each)
-      subscription = attach_test_trackers(trackable)
-      sleep 1
-      subscription.unsubscribe
-
-      expect(test_data).to be == ('a'..'i').to_a
-    end
-
-    it 'can use the immediate executor to block the current thread while ' \
-      'emitting' do
-      trackable = described_class.interval(
-        0.1, (1..5).each, executor: Reacto::Executors.immediate
-      )
-      subscription = attach_test_trackers(trackable)
-
-      expect(test_data).to be == (1..5).to_a + ['|']
-    end
-  end
-
-  context '.value' do
-    it 'emits only the passed value and then closes' do
-      trackable = described_class.value(5)
-      subscription = attach_test_trackers(trackable)
-
-      expect(test_data).to be == [5, '|']
-    end
-  end
-
-  context '.enumerable' do
-    it 'emits the whole enumerable one-by-one and then closes' do
-      trackable = described_class.enumerable([1, 3, 5, 6, 7, 8])
-      subscription = attach_test_trackers(trackable)
-
-      expect(test_data).to be == [1, 3, 5, 6, 7, 8, '|']
-    end
-
-    it 'on error it emits all til the error and the error' do
-      class PositiveArray
-        include Enumerable
-
-        def error
-          @error ||= StandardError.new('Bad.')
-        end
-
-        def initialize(*members)
-          @members = members
-        end
-
-        def each(&block)
-          @members.each do |member|
-            raise error if member < 0
-            block.call(member)
-          end
-        end
-      end
-
-      enumerable = PositiveArray.new(2, 3, -4, 3, 6)
-      trackable = described_class.enumerable(enumerable)
-      subscription = attach_test_trackers(trackable)
-
-      expect(test_data).to be == [2, 3, enumerable.error]
-
-    end
-  end
-
-  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
-
   context '.combine_last' do
     it 'combines the notifications of Trackables based on their ' \
       'sequence number - the first notification of the sources, then ' \

data/spec/reacto/executors_and_trackable_spec.rb

@@ -1,11 +1,6 @@
 require 'spec_helper'
 
 context Reacto::Trackable do
-
-  let(:test_data) { [] }
-  let(:test_on_value) { -> (v) { test_data << v }}
-  let(:test_on_close) { -> () { test_data << '|' }}
-
   subject do
    described_class.new do |tracker_subscription|
       tracker_subscription.on_value(16)

data/spec/reacto/trackable/cache_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+context Reacto::Trackable do
+  let(:source_updates) { [] }
+  let(:source) do
+    Reacto::Trackable.make do |tracker|
+      source_updates << true
+
+      tracker.on_value(3)
+      tracker.on_value(4)
+      tracker.on_value(5)
+      tracker.on_close
+    end
+  end
+
+  def check_cache(trackable)
+    trackable.on(value: test_on_value, close: test_on_close)
+    expect(test_data).to be == [3, 4, 5, '|']
+    expect(source_updates).to be == [true]
+
+    trackable.on(value: test_on_value, close: test_on_close)
+    expect(test_data).to be == [3, 4, 5, '|', 3, 4, 5, '|']
+    expect(source_updates).to be == [true]
+  end
+
+  context '#cache' do
+    context 'memory' do
+      it 'caches all the values received before the closing notifincation and ' \
+        'replayes them on subsequent subscriptions' do
+        check_cache(source.cache)
+      end
+    end
+
+    context 'file' do
+      after(:each) do
+        File.delete('tmp/test.cache')
+      end
+
+      it 'caches all the values received before the closing notifincation and ' \
+        'replayes them on subsequent subscriptions' do
+        check_cache(source.cache(type: :file, location: 'tmp/test.cache'))
+      end
+
+      it 'uses the cache only if it is fresh' do
+        trackable1 =
+          source.cache(type: :file, location: 'tmp/test.cache', ttl: 0.5)
+
+        check_cache(trackable1)
+
+        trackable2 =
+          source.cache(type: :file, location: 'tmp/test.cache', ttl: 0.5)
+        trackable2.on
+        expect(source_updates).to be == [true]
+
+        sleep(1)
+
+        trackable3 =
+          source.cache(type: :file, location: 'tmp/test.cache', ttl: 0.5)
+        trackable3.on
+        expect(source_updates).to be == [true] * 2
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+context Reacto::Trackable do
+  context '.enumerable' do
+    it 'emits the whole enumerable one-by-one and then closes' do
+      trackable = described_class.enumerable([1, 3, 5, 6, 7, 8])
+      subscription = attach_test_trackers(trackable)
+
+      expect(test_data).to be == [1, 3, 5, 6, 7, 8, '|']
+    end
+
+    it 'on error it emits all til the error and the error' do
+      class PositiveArray
+        include Enumerable
+
+        def error
+          @error ||= StandardError.new('Bad.')
+        end
+
+        def initialize(*members)
+          @members = members
+        end
+
+        def each(&block)
+          @members.each do |member|
+            raise error if member < 0
+            block.call(member)
+          end
+        end
+      end
+
+      enumerable = PositiveArray.new(2, 3, -4, 3, 6)
+      trackable = described_class.enumerable(enumerable)
+      subscription = attach_test_trackers(trackable)
+
+      expect(test_data).to be == [2, 3, enumerable.error]
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+context Reacto::Trackable do
+  context '.error' do
+    it 'creates a new trackable emitting only the error passed' do
+      err = StandardError.new('Errrr')
+      attach_test_trackers described_class.error(err)
+
+      expect(test_data).to be == [err]
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+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)
+      subscription = attach_test_trackers(trackable)
+      sleep 1
+      subscription.unsubscribe
+
+      expect(test_data).to be == (0..8).to_a
+    end
+
+    it 'can use any enumerator to produce the sequence to emit' do
+      trackable = described_class.interval(0.1, ('a'..'z').each)
+      subscription = attach_test_trackers(trackable)
+      sleep 1
+      subscription.unsubscribe
+
+      expect(test_data).to be == ('a'..'i').to_a
+    end
+
+    it 'can use the immediate executor to block the current thread while ' \
+      'emitting' do
+      trackable = described_class.interval(
+        0.1, (1..5).each, executor: Reacto::Executors.immediate
+      )
+      subscription = attach_test_trackers(trackable)
+
+      expect(test_data).to be == (1..5).to_a + ['|']
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+context Reacto::Trackable do
+  context '.later' do
+    it 'emits the passed value after the passed time runs out and then emits ' \
+      'a close notification' do
+      trackable = described_class.later(0.2, 5)
+      subscription = attach_test_trackers(trackable)
+
+      expect(test_data).to be_empty
+      trackable.await(subscription)
+      expect(test_data).to be == [5, '|']
+    end
+
+    it 'it can use a specific executor' do
+      trackable = described_class.later(
+        0.2, 5, executor: Reacto::Executors.immediate
+      )
+      subscription = attach_test_trackers(trackable)
+      expect(test_data).to be == [5, '|']
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+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|
+          tracker.on_value(v)
+        end
+
+        tracker.on_close
+      end
+      attach_test_trackers trackable
+
+      expect(test_data.size).to be(11)
+      expect(test_data).to be == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, '|']
+    end
+
+    it 'does not emit anything once it is closed' do
+      trackable = described_class.make do |tracker|
+        (1..5).each do |v|
+          tracker.on_value(v)
+        end
+
+        tracker.on_close
+
+        (1..5).each do |v|
+          tracker.on_value(v)
+        end
+      end
+      attach_test_trackers trackable
+
+      expect(test_data.size).to be(6)
+      expect(test_data).to be == [1, 2, 3, 4, 5, '|']
+    end
+
+    it 'does not emit anything once it has an error' do
+      trackable = described_class.make do |tracker|
+        (1..5).each do |v|
+          tracker.on_value(v)
+        end
+
+        tracker.on_error('error')
+
+        (1..5).each do |v|
+          tracker.on_value(v)
+        end
+      end
+      attach_test_trackers trackable
+
+      expect(test_data.size).to be(6)
+      expect(test_data).to be == [1, 2, 3, 4, 5, 'error']
+    end
+
+    it 'emits the same behaviour for every subscribe' do
+      trackable = described_class.make do |tracker|
+        (1..5).each do |v|
+          tracker.on_value(v)
+        end
+
+        tracker.on_close
+      end
+      attach_test_trackers trackable
+      attach_test_trackers trackable
+
+      expect(test_data.size).to be(12)
+      expect(test_data).to be == [1, 2, 3, 4, 5, '|', 1, 2, 3, 4, 5, '|']
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+context Reacto::Trackable do
+  context '.value' do
+    it 'emits only the passed value and then closes' do
+      trackable = described_class.value(5)
+      subscription = attach_test_trackers(trackable)
+
+      expect(test_data).to be == [5, '|']
+    end
+  end
+end

data/spec/reacto/trackable_spec.rb

@@ -13,39 +13,4 @@ context Reacto::Trackable do
       expect(test_data[0]).to be(4)
     end
   end
-
-  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
-
-  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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reacto
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Nickolay Tzvetinov - Meddle
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-10 00:00:00.000000000 Z
+date: 2016-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,10 +66,13 @@ files:
 - README.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/operations.rb
 - lib/reacto/operations/buffer.rb
+- lib/reacto/operations/cache.rb
 - lib/reacto/operations/concat.rb
 - lib/reacto/operations/diff.rb
 - lib/reacto/operations/drop.rb
@@ -111,7 +114,14 @@ files:
 - spec/reacto/executors_and_trackable_spec.rb
 - spec/reacto/operations/track_on_spec.rb
 - spec/reacto/trackable/buffer_spec.rb
+- spec/reacto/trackable/cache_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
+- spec/reacto/trackable/class_level/later_spec.rb
+- spec/reacto/trackable/class_level/make_spec.rb
 - 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/diff_spec.rb
 - spec/reacto/trackable/drop_errors_spec.rb
@@ -156,7 +166,14 @@ test_files:
 - spec/reacto/executors_and_trackable_spec.rb
 - spec/reacto/operations/track_on_spec.rb
 - spec/reacto/trackable/buffer_spec.rb
+- spec/reacto/trackable/cache_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
+- spec/reacto/trackable/class_level/later_spec.rb
+- spec/reacto/trackable/class_level/make_spec.rb
 - 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/diff_spec.rb
 - spec/reacto/trackable/drop_errors_spec.rb