reacto 0.0.0

data/lib/reacto/operations/throttle.rb

@@ -0,0 +1,60 @@
+require 'concurrent'
+require 'reacto/constants'
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class Throttle
+      def initialize(delay)
+        @delay = delay
+        @last = NO_VALUE
+        @ready = false
+        @error = NO_VALUE
+        @close = false
+      end
+
+      def call(tracker)
+        close = -> () { @close = true }
+        error = lambda do |e|
+          delay_task(tracker) unless @ready
+          @error = e
+        end
+        value = lambda do |v|
+          delay_task(tracker) unless @ready
+          @last = v
+        end
+
+        Subscriptions::OperationSubscription.new(
+          tracker,
+          value: value,
+          close: close,
+          error: error
+        )
+      end
+
+      private
+
+      def finish
+        @task.shutdown if @task
+      end
+
+      def delay_task(tracker)
+        @task = Concurrent::TimerTask.new(execution_interval: @delay) do
+          if @error != NO_VALUE
+            tracker.on_error(@error)
+            finish
+          elsif @close
+            tracker.on_close
+            finish
+          elsif @last != NO_VALUE
+            tracker.on_value(@last)
+            @last = NO_VALUE
+          end
+        end
+        @task.execute
+        @ready = true
+      end
+    end
+  end
+end
+

data/lib/reacto/operations/track_on.rb

@@ -0,0 +1,18 @@
+require 'reacto/subscriptions/executor_subscription'
+
+module Reacto
+  module Operations
+    class TrackOn
+      def initialize(executor)
+        @executor = executor
+      end
+
+      def call(tracker)
+        Subscriptions::ExecutorSubscription.new(
+          tracker, @executor
+        )
+      end
+    end
+  end
+end
+

data/lib/reacto/operations/uniq.rb

@@ -0,0 +1,22 @@
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class Uniq
+      def passed
+        @passed ||= {}
+      end
+
+      def call(tracker)
+        value = lambda do |v|
+          unless passed[v]
+            passed[v] = true
+            tracker.on_value(v)
+          end
+        end
+
+        Subscriptions::OperationSubscription.new(tracker, value: value)
+      end
+    end
+  end
+end

data/lib/reacto/operations.rb

@@ -0,0 +1,23 @@
+require 'reacto/operations/map'
+require 'reacto/operations/select'
+require 'reacto/operations/inject'
+require 'reacto/operations/diff'
+require 'reacto/operations/drop'
+require 'reacto/operations/drop_errors'
+require 'reacto/operations/take'
+require 'reacto/operations/last'
+require 'reacto/operations/track_on'
+require 'reacto/operations/prepend'
+require 'reacto/operations/concat'
+require 'reacto/operations/merge'
+require 'reacto/operations/buffer'
+require 'reacto/operations/uniq'
+require 'reacto/operations/flatten'
+require 'reacto/operations/throttle'
+require 'reacto/operations/flat_map'
+
+module Reacto
+  module Operations
+  end
+end
+

data/lib/reacto/resources/executor_resource.rb

@@ -0,0 +1,19 @@
+module Reacto
+  module Resources
+    class ExecutorResource
+      def initialize(executor, threads: [])
+        @executor = executor
+        @threads = threads
+      end
+      def cleanup
+        @executor.shutdown
+        @executor = nil
+
+        @threads.each do |thread|
+          Thread.kill(thread)
+        end
+        @threads = []
+      end
+    end
+  end
+end

data/lib/reacto/resources.rb

@@ -0,0 +1 @@
+require 'reacto/resources/executor_resource'

data/lib/reacto/subscriptions/buffered_subscription.rb

@@ -0,0 +1,52 @@
+module Reacto
+  module Subscriptions
+    class BufferedSubscription < SimpleSubscription
+      include Subscription
+
+      attr_accessor :current_index, :buffer, :last_error
+
+      def initialize(parent)
+        @parent = parent
+        @closed = false
+        @active = false
+
+        @buffer = Hash.new(NO_VALUE)
+        @current_index = 0
+        @last_error = nil
+
+        open = lambda do
+          @active = true
+          @parent.on_open
+        end
+
+        value = lambda do |v|
+          @buffer[@current_index] = v
+          @current_index += 1
+
+          @parent.on_value(v)
+        end
+
+        error = lambda do |e|
+          @last_error = e
+          @parent.on_error(e)
+        end
+
+        close = lambda do
+          @closed = true
+          @parent.on_close
+        end
+
+        super(open: open, value: value, error: error, close: close)
+      end
+
+      def active?
+        @active
+      end
+
+      def closed?
+        @closed
+      end
+    end
+  end
+end
+

data/lib/reacto/subscriptions/combining_last_subscription.rb

@@ -0,0 +1,22 @@
+require 'reacto/constants'
+require 'reacto/subscriptions/composite_subscription'
+
+module Reacto
+  module Subscriptions
+    class CombiningLastSubscription < CompositeSubscription
+      def subscribed?
+        @subscriptions.all? { |s| s.subscribed? }
+      end
+
+      def after_on_value(_)
+        return if @subscriptions.map(&:last_value).any? { |vl| vl == NO_VALUE }
+        @subscriptions.each { |sub| sub.last_value = NO_VALUE }
+      end
+
+      def on_close
+        return unless subscribed?
+        @subscriber.on_close
+      end
+    end
+  end
+end

data/lib/reacto/subscriptions/combining_subscription.rb

@@ -0,0 +1,8 @@
+require 'reacto/subscriptions/composite_subscription'
+
+module Reacto
+  module Subscriptions
+    class CombiningSubscription < CompositeSubscription
+    end
+  end
+end

data/lib/reacto/subscriptions/composite_subscription.rb

@@ -0,0 +1,82 @@
+require 'reacto/constants'
+require 'reacto/subscriptions/subscription'
+require 'reacto/subscriptions/inner_subscription'
+
+module Reacto
+  module Subscriptions
+    class CompositeSubscription
+      include Subscription
+
+      def initialize(combinator, subscriber)
+        @combinator = combinator
+        @subscriptions = []
+        @subscriber = subscriber
+      end
+
+      def subscribed?
+        @subscriptions.any? { |s| s.subscribed? }
+      end
+
+      def unsubscribe
+        @subscriptions.each(&:unsubscribe)
+        @subscriptions = []
+      end
+
+      def add(_)
+      end
+
+      def add_resource(_)
+      end
+
+      def on_open
+        return unless subscribed?
+        return unless @subscriptions.any? { |s| !s.active? }
+        @subscriber.on_open
+      end
+
+      def waiting?
+        @subscriptions.map(&:last_value).any? { |v| v == NO_VALUE }
+      end
+
+      def on_value(val)
+        return unless subscribed?
+        return if waiting?
+
+        on_value_subscriptions(val)
+        after_on_value(val)
+      end
+
+      def on_value_subscriptions(_)
+        @subscriber.on_value(
+          @combinator.call(*@subscriptions.map(&:last_value))
+        )
+      end
+
+      def after_on_value(_)
+        #nothing by default
+      end
+
+      def on_error(e)
+        # Introduce a multi-error and not call on_error right away when there is
+        # an error and an option is set?
+        return unless subscribed?
+        @subscriber.on_error(e)
+      end
+
+      def on_close
+        return unless subscribed?
+        return unless @subscriptions.any? { |s| !s.closed? }
+
+        @subscriber.on_close
+        unsubscribe
+      end
+
+      def subscription!
+        subscription = InnerSubscription.new(self)
+        @subscriptions << subscription
+
+        subscription
+      end
+    end
+  end
+end

data/lib/reacto/subscriptions/executor_subscription.rb

@@ -0,0 +1,63 @@
+require 'reacto/subscriptions/subscription'
+require 'reacto/tracker'
+
+module Reacto
+  module Subscriptions
+    class ExecutorSubscription
+      include Subscription
+
+      def initialize(subscription, executor)
+        @executor = executor
+        @wrapped = subscription
+        @closed = false
+      end
+
+      def subscribed?
+        unsubscribe unless @wrapped.subscribed?
+
+        @executor.running?
+      end
+
+      def unsubscribe
+        @wrapped.unsubscribe
+
+        @executor.post(&@executor.method(:shutdown))
+      end
+
+      def add(subscription)
+        @wrapped.add(subscription)
+      end
+
+      def add_resource(resource)
+        @wrapped.add_resource(resource)
+      end
+
+      def on_open
+        @executor.post(&@wrapped.method(:on_open))
+      end
+
+      def on_value(v)
+        return if !subscribed? || @closed
+
+        @executor.post(v, &@wrapped.method(:on_value))
+      end
+
+      def on_close
+        return if !subscribed? || @closed
+
+        @executor.post(&@wrapped.method(:on_close))
+        @executor.post(&method(:unsubscribe))
+        @closed = true
+      end
+
+      def on_error(error)
+        return if !subscribed? || @closed
+
+        @executor.post(error, &@wrapped.method(:on_error))
+        unsubscribe
+        @closed = true
+      end
+    end
+  end
+end
+

data/lib/reacto/subscriptions/flat_map_subscription.rb

@@ -0,0 +1,20 @@
+require 'reacto/constants'
+require 'reacto/subscriptions/composite_subscription'
+
+module Reacto
+  module Subscriptions
+    class FlatMapSubscription < CompositeSubscription
+      def initialize(subscriber)
+        super(nil, subscriber)
+      end
+
+      def waiting?
+        false
+      end
+
+      def on_value_subscriptions(v)
+        @subscriber.on_value(v)
+      end
+    end
+  end
+end

data/lib/reacto/subscriptions/inner_subscription.rb

@@ -0,0 +1,47 @@
+module Reacto
+  module Subscriptions
+    class InnerSubscription < SimpleSubscription
+      include Subscription
+
+      attr_accessor :last_value, :last_error
+
+      def initialize(parent)
+        @parent = parent
+        @closed = false
+        @active = false
+        @last_value = NO_VALUE
+        @last_error = nil
+
+        open = lambda do
+          @active = true
+          @parent.on_open
+        end
+
+        value = lambda do |v|
+          @last_value = v
+          @parent.on_value(v)
+        end
+
+        error = lambda do |e|
+          @last_error = e
+          @parent.on_error(e)
+        end
+
+        close = lambda do
+          @closed = true
+          @parent.on_close
+        end
+
+        super(open: open, value: value, error: error, close: close)
+      end
+
+      def active?
+        @active
+      end
+
+      def closed?
+        @closed
+      end
+    end
+  end
+end

data/lib/reacto/subscriptions/operation_subscription.rb

@@ -0,0 +1,25 @@
+require 'reacto/subscriptions/subscription'
+require 'reacto/tracker'
+
+module Reacto
+  module Subscriptions
+    class OperationSubscription < Reacto::Tracker
+      extend Forwardable
+      include Subscription
+
+      delegate ['subscribed?', :unsubscribe, :add, :add_resource] => :@wrapped
+
+      def initialize(
+        subscription,
+        open: subscription.method(:on_open),
+        value: subscription.method(:on_value),
+        error: subscription.method(:on_error),
+        close: subscription.method(:on_close)
+      )
+        super(open: open, value: value, error: error, close: close)
+
+        @wrapped = subscription
+      end
+    end
+  end
+end

data/lib/reacto/subscriptions/simple_subscription.rb

@@ -0,0 +1,80 @@
+require 'reacto/constants'
+require 'reacto/subscriptions/subscription'
+
+module Reacto
+  module Subscriptions
+    class SimpleSubscription
+      include Subscription
+
+      def initialize(
+        open: NO_ACTION,
+        value: NO_ACTION,
+        error: DEFAULT_ON_ERROR,
+        close: NO_ACTION
+      )
+        @open = open
+        @value = value
+        @error = error
+        @close = close
+
+        @subscribed = true
+        @subscriptions = []
+        @resources = []
+      end
+
+      def subscribed?
+        @subscribed
+      end
+
+      def unsubscribe
+        @subscriptions.each(&:unsubscribe)
+        @subscribed = false
+        @resources.each(&:cleanup)
+        @resources = []
+      end
+
+      def add(subscription)
+        return unless subscribed?
+
+        @subscriptions << subscription
+      end
+
+      def add_resource(resource)
+        return unless subscribed?
+
+        @resources << resource
+      end
+
+      def on_open
+        return unless subscribed?
+
+        @open.call
+        @subscriptions.each(&:on_open)
+      end
+
+      def on_value(v)
+        return unless subscribed?
+
+        @value.call(v)
+        @subscriptions.each { |s| s.on_value(v) }
+      end
+
+      def on_error(e)
+        return unless subscribed?
+
+        @error.call(error)
+        @subscriptions.each { |s| s.on_error(e) }
+        unsubscribe
+      end
+
+      def on_close
+        return unless subscribed?
+
+        @close.call
+        @subscriptions.each(&:on_close)
+        unsubscribe
+      end
+    end
+  end
+end
+

data/lib/reacto/subscriptions/subscription.rb

@@ -0,0 +1,21 @@
+module Reacto
+  module Subscriptions
+    module Subscription
+      def subscribed?
+        raise NotImplementedError.new('Abstract method!')
+      end
+
+      def unsubscribe
+        raise NotImplementedError.new('Abstract method!')
+      end
+
+      def add(subscription)
+        raise NotImplementedError.new('Abstract method!')
+      end
+
+      def add_resource(resource)
+        raise NotImplementedError.new('Abstract method!')
+      end
+    end
+  end
+end

data/lib/reacto/subscriptions/subscription_wrapper.rb

@@ -0,0 +1,16 @@
+require 'reacto/subscriptions/subscription'
+
+module Reacto
+  module Subscriptions
+    class SubscriptionWrapper
+      extend Forwardable
+      include Subscription
+
+      delegate ['subscribed?', :unsubscribe, :add, :add_resource] => :@wrapped
+
+      def initialize(wrapped)
+        @wrapped = wrapped
+      end
+    end
+  end
+end

data/lib/reacto/subscriptions/tracker_subscription.rb

@@ -0,0 +1,76 @@
+require 'reacto/subscriptions/subscription'
+
+module Reacto
+  module Subscriptions
+    class TrackerSubscription
+      include Subscription
+
+      def initialize(notification_tracker, trackable)
+        @notification_tracker = notification_tracker
+        @trackable = trackable
+
+        @subscribed = true
+        @subscriptions = []
+        @resources = []
+      end
+
+      def subscribed?
+        @subscribed
+      end
+
+      def unsubscribe
+        @subscriptions.each(&:unsubscribe)
+
+        @trackable.off(@notification_tracker)
+
+        @trackable = nil
+        @notification_tracker = nil
+        @subscribed = false
+        @resources.each(&:cleanup)
+        @resources = []
+      end
+
+      def add_resource(resource)
+        return unless subscribed?
+
+        @resources << resource
+      end
+
+      def add(subscription)
+        return unless subscribed?
+
+        @subscriptions << subscription
+      end
+
+      def on_open
+        return unless subscribed?
+
+        @notification_tracker.on_open
+        @subscriptions.each(&:on_open)
+      end
+
+      def on_value(v)
+        return unless subscribed?
+
+        @notification_tracker.on_value(v)
+        @subscriptions.each { |s| s.on_value(v) }
+      end
+
+      def on_error(e)
+        return unless subscribed?
+
+        @notification_tracker.on_error(e)
+        @subscriptions.each { |s| s.on_error(e) }
+        unsubscribe
+      end
+
+      def on_close
+        return unless subscribed?
+
+        @notification_tracker.on_close
+        @subscriptions.each(&:on_close)
+        unsubscribe
+      end
+    end
+  end
+end