reacto 0.0.0

data/lib/reacto/subscriptions/zipping_subscription.rb

@@ -0,0 +1,43 @@
+require 'reacto/constants'
+require 'reacto/subscriptions/composite_subscription'
+require 'reacto/subscriptions/buffered_subscription'
+
+module Reacto
+  module Subscriptions
+    class ZippingSubscription < CompositeSubscription
+      def current_value
+        @current_value ||= 0
+      end
+
+      def subscribed?
+        @subscriptions.all? { |s| s.subscribed? }
+      end
+
+      def waiting?
+        @subscriptions.any? { |sub| sub.buffer[current_value] == NO_VALUE }
+      end
+
+      def on_value_subscriptions(_)
+        @subscriber.on_value(
+          @combinator.call(
+            *@subscriptions.map { |sub| sub.buffer[current_value] }
+          )
+        )
+        @current_value += 1
+      end
+
+      def on_close
+        return unless subscribed?
+        @subscriber.on_close
+      end
+
+      def subscription!
+        subscription = BufferedSubscription.new(self)
+        @subscriptions << subscription
+
+        subscription
+      end
+    end
+  end
+end
+

data/lib/reacto/subscriptions.rb

@@ -0,0 +1,27 @@
+require 'reacto/subscriptions/subscription'
+require 'reacto/subscriptions/subscription_wrapper'
+require 'reacto/subscriptions/tracker_subscription'
+require 'reacto/subscriptions/operation_subscription'
+require 'reacto/subscriptions/executor_subscription'
+require 'reacto/subscriptions/simple_subscription'
+require 'reacto/subscriptions/combining_subscription'
+require 'reacto/subscriptions/combining_last_subscription'
+require 'reacto/subscriptions/zipping_subscription'
+require 'reacto/subscriptions/flat_map_subscription'
+
+module Reacto
+  module Subscriptions
+    class << self
+      def on_close(&block)
+        SimpleSubscription.new(close: block)
+      end
+
+      def on_close_and_error(&block)
+        SimpleSubscription.new(
+          close: -> () { block.call },
+          error: -> (_e) { block.call }
+        )
+      end
+    end
+  end
+end

data/lib/reacto/trackable.rb

@@ -0,0 +1,317 @@
+require 'concurrent'
+
+require 'reacto/behaviours'
+require 'reacto/subscriptions'
+require 'reacto/tracker'
+require 'reacto/operations'
+require 'reacto/executors'
+require 'reacto/resources'
+
+module Reacto
+  class Trackable
+    TOPICS = [:open, :value, :error, :close]
+
+    class << self
+      def never
+        self.new
+      end
+
+      def combine(*trackables, &block)
+        combine_create(
+          Subscriptions::CombiningSubscription, *trackables, &block
+        )
+      end
+
+      def combine_last(*trackables, &block)
+        combine_create(
+          Subscriptions::CombiningLastSubscription, *trackables, &block
+        )
+      end
+
+      def zip(*trackables, &block)
+        combine_create(Subscriptions::ZippingSubscription, *trackables, &block)
+      end
+
+      def close(executor = nil)
+        make(nil, executor) do |subscriber|
+          subscriber.on_close
+        end
+      end
+
+      def error(err, executor = nil)
+        make(nil, executor) do |subscriber|
+          subscriber.on_error(err)
+        end
+      end
+
+      def make(behaviour = NO_ACTION, executor = nil, &block)
+        behaviour = block_given? ? block : behaviour
+        self.new(behaviour, executor)
+      end
+
+      def later(secs, value, executor: Reacto::Executors.tasks)
+        if executor.is_a?(Concurrent::ImmediateExecutor)
+          make do |tracker|
+            sleep secs
+            Behaviours.single_tracker_value(tracker, value)
+          end
+        else
+          make do |tracker|
+            Concurrent::ScheduledTask.execute(secs, executor: executor) do
+              Behaviours.single_tracker_value(tracker, value)
+            end
+          end
+        end
+      end
+
+      def interval(
+        interval,
+        enumerator = Behaviours.integers_enumerator,
+        executor: nil
+      )
+        if executor.is_a?(Concurrent::ImmediateExecutor)
+          make do |tracker|
+            Behaviours.with_close_and_error(tracker) do |subscriber|
+              while subscriber.subscribed?
+                sleep interval if subscriber.subscribed?
+                if subscriber.subscribed?
+                  begin
+                    subscriber.on_value(enumerator.next)
+                  rescue StopIteration
+                    break
+                  end
+                else
+                  break
+                end
+              end
+            end
+          end
+        else
+          make do |tracker|
+            queue = Queue.new
+            task = Concurrent::TimerTask.new(execution_interval: interval) do
+              queue.push('ready')
+            end
+            thread = Thread.new do
+              begin
+                loop do
+                  queue.pop
+                  break unless tracker.subscribed?
+
+                  begin
+                    value = enumerator.next
+                    tracker.on_value(value)
+                  rescue StopIteration
+                    tracker.on_close if tracker.subscribed?
+                    break
+                  rescue StandardError => error
+                    tracker.on_error(error) if tracker.subscribed?
+                    break
+                  end
+                end
+              ensure
+                task.shutdown
+              end
+            end
+            task.execute
+
+            tracker.add_resource(Reacto::Resources::ExecutorResource.new(
+              task, threads: [thread]
+            ))
+          end
+        end
+      end
+
+      def repeat(array, int: 0.1, executor: nil)
+        interval(
+          int, Behaviours.array_repeat_enumerator(array), executor: executor
+        )
+      end
+
+      def value(value, executor = nil)
+        make(Behaviours.single_value(value), executor)
+      end
+
+      def enumerable(enumerable, executor = nil)
+        make(nil, executor) do |tracker|
+          begin
+            enumerable.each do |val|
+              break unless tracker.subscribed?
+              tracker.on_value(val)
+            end
+
+            tracker.on_close if tracker.subscribed?
+          rescue => error
+            tracker.on_error(error) if tracker.subscribed?
+          end
+        end
+      end
+
+      def combine_with(function, *trackables)
+      end
+
+      private
+
+      def combine_create(type, *trackables, &block)
+        make do |subscriber|
+          main = type.new(block, subscriber)
+          trackables.each do |trackable|
+            trackable.do_track main.subscription!
+          end
+        end
+      end
+    end
+
+    def initialize(behaviour = NO_ACTION, executor = nil, &block)
+      @behaviour = block_given? ? block : behaviour
+      @executor = executor
+    end
+
+    def on(trackers = {})
+      unless (trackers.keys - TOPICS).empty?
+        raise "This Trackable supports only #{TOPICS}, " \
+          "but #{trackers.keys} were passed."
+      end
+
+      track(Tracker.new(trackers))
+    end
+
+    def off(notification_tracker)
+      # Clean-up logic
+    end
+
+    def track(notification_tracker)
+      subscription =
+        Subscriptions::TrackerSubscription.new(notification_tracker, self)
+
+      do_track(subscription)
+
+      Subscriptions::SubscriptionWrapper.new(subscription)
+    end
+
+    def lift(operation = nil, &block)
+      operation = block_given? ? block : operation
+      Trackable.new(nil, @executor) do |tracker_subscription|
+        begin
+          lift_behaviour(operation.call(tracker_subscription))
+        rescue Exception => e
+          tracker_subscription.on_error(e)
+        end
+      end
+    end
+
+    def flat_map(transform = nil, &block)
+      lift(Operations::FlatMap.new(block_given? ? block : transform))
+    end
+
+    def map(mapping = nil, error: nil, close: nil, &block)
+      lift(Operations::Map.new(
+        block_given? ? block : mapping, error: error, close: close
+      ))
+    end
+
+    def select(filter = nil, &block)
+      lift(Operations::Select.new(block_given? ? block : filter))
+    end
+
+    def inject(initial = NO_VALUE, injector = nil, &block)
+      lift(Operations::Inject.new(block_given? ? block : injector, initial))
+    end
+
+    def diff(initial = NO_VALUE, fn = Operations::Diff::DEFAULT_FN, &block)
+      lift(Operations::Diff.new(block_given? ? block : fn, initial))
+    end
+
+    def drop(how_many_to_drop)
+      lift(Operations::Drop.new(how_many_to_drop))
+    end
+
+    def drop_errors
+      lift(Operations::DropErrors.new)
+    end
+
+    def take(how_many_to_take)
+      lift(Operations::Take.new(how_many_to_take))
+    end
+
+    def uniq
+      lift(Operations::Uniq.new)
+    end
+
+    def flatten
+      lift(Operations::Flatten.new)
+    end
+
+    def first
+      take(1)
+    end
+
+    def [](x)
+      lift(Operations::Drop.new(x, 1))
+    end
+
+    def last
+      lift(Operations::Last.new)
+    end
+
+    def prepend(enumerable)
+      lift(Operations::Prepend.new(enumerable))
+    end
+
+    def concat(trackable)
+      lift(Operations::Concat.new(trackable))
+    end
+
+    def merge(trackable, delay_error: false)
+      lift(Operations::Merge.new(trackable, delay_error: delay_error))
+    end
+
+    def buffer(count: nil, delay: nil)
+      lift(Operations::Buffer.new(count: count, delay: delay))
+    end
+
+    def delay(delay)
+      buffer(delay: delay)
+    end
+
+    def throttle(delay)
+      lift(Operations::Throttle.new(delay))
+    end
+
+    def track_on(executor)
+      lift(Operations::TrackOn.new(executor))
+    end
+
+    def execute_on(executor)
+      Trackable.new(@behaviour, executor)
+    end
+
+    def await(subscription, timeout = nil)
+      latch = Concurrent::CountDownLatch.new(1)
+      subscription.add(Subscriptions.on_close_and_error { latch.count_down })
+      latch.wait(timeout)
+    end
+
+    alias_method :skip, :drop
+    alias_method :skip_errors, :drop_errors
+
+    def do_track(subscription)
+      if @executor
+        @executor.post(subscription, &@behaviour)
+      else
+        @behaviour.call(subscription)
+      end
+    end
+
+    private
+
+    def lift_behaviour(lifted_tracker_subscription)
+      begin
+        lifted_tracker_subscription.on_open
+        @behaviour.call(lifted_tracker_subscription)
+      rescue Exception => e
+        lifted_tracker_subscription.on_error(e)
+      end
+    end
+  end
+end

data/lib/reacto/tracker.rb

@@ -0,0 +1,33 @@
+require 'reacto/constants'
+
+module Reacto
+  class Tracker
+    def initialize(
+      open: NO_ACTION,
+      value: NO_ACTION,
+      error: DEFAULT_ON_ERROR,
+      close: NO_ACTION
+    )
+      @open = open
+      @value = value
+      @error = error
+      @close = close
+    end
+
+    def on_open
+      @open.call
+    end
+
+    def on_value(v)
+      @value.call(v)
+    end
+
+    def on_error(error)
+      @error.call(error)
+    end
+
+    def on_close
+      @close.call
+    end
+  end
+end

data/lib/reacto/version.rb

@@ -0,0 +1,4 @@
+module Reacto
+  VERSION = '0.0.0'
+end
+

data/lib/reacto.rb

@@ -0,0 +1,10 @@
+require 'reacto/version'
+require 'reacto/constants'
+
+require 'reacto/subscriptions'
+require 'reacto/tracker'
+require 'reacto/trackable'
+
+module Reacto
+
+end

data/reacto.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+
+current_dir = File.dirname(File.realpath(__FILE__))
+$LOAD_PATH.unshift(File.join(current_dir, 'lib'))
+
+require 'reacto/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'reacto'
+  spec.version       = Reacto::VERSION
+  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.homepage      = 'https://github.com/meddle0x53/reacto'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rspec', '~> 3.3.0'
+
+  spec.add_dependency 'concurrent-ruby', '~> 1.0.0'
+end
+

data/spec/reacto/create_trackable_spec.rb

@@ -0,0 +1,245 @@
+require 'spec_helper'
+
+context Reacto::Trackable do
+
+  context '.never' do
+    it 'creates a new trackable, which won\'t send any notifications' do
+      attach_test_trackers described_class.never
+
+      expect(test_data).to be_empty
+    end
+  end
+
+  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 ' \
+      '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)
+      trackable3 = described_class.interval(0.5, ('A'..'C').each)
+
+      trackable = described_class.combine_last(
+        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', '3 : b : B', '|'
+      ]
+    end
+  end
+end