reacto 0.1.0 → 1.0.0

data/lib/reacto/operations/act.rb

@@ -0,0 +1,69 @@
+require 'ostruct'
+
+require 'reacto/constants'
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class Act
+      ALL = %i(value error close)
+
+
+      def initialize(action = NO_ACTION, on = ALL)
+        @action = action
+        @on = on
+
+        @on = ALL if @on == :all
+      end
+
+      def call(tracker)
+        value =
+          if @on.include?(:value)
+            value_action(tracker)
+          else
+            tracker.method(:on_value)
+          end
+
+        error =
+          if @on.include?(:error)
+            error_action(tracker)
+          else
+            tracker.method(:on_error)
+          end
+
+        close =
+          if @on.include?(:close)
+            close_action(tracker)
+          else
+            tracker.method(:on_close)
+          end
+
+        Subscriptions::OperationSubscription.new(
+          tracker, value: value, error: error, close: close
+        )
+      end
+
+      def value_action(tracker)
+        lambda do |value|
+          @action.call(OpenStruct.new(value: value, type: :value))
+          tracker.on_value(value)
+        end
+      end
+
+      def error_action(tracker)
+        lambda do |error|
+          @action.call(OpenStruct.new(error: error, type: :error))
+          tracker.on_error(error)
+        end
+      end
+
+      def close_action(tracker)
+        lambda do
+          @action.call(OpenStruct.new(type: :close))
+          tracker.on_close
+        end
+      end
+    end
+  end
+end
+

data/lib/reacto/operations/append.rb

@@ -0,0 +1,45 @@
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class Append
+      attr_reader :to_append
+
+      def initialize(to_append, condition: nil)
+        @to_append = to_append
+        @condition = condition
+      end
+
+      def call(tracker)
+        empty = true
+
+        on_value =
+          if @condition == :source_empty
+            -> (v) do
+              empty = false if empty
+              tracker.on_value(v)
+            end
+          else
+            tracker.method(:on_value)
+          end
+
+        on_close = -> () do
+          if (@condition == :source_empty && empty) || @condition.nil?
+            if to_append.respond_to? :each
+              to_append.each { |v| tracker.on_value(v) }
+            else
+              tracker.on_value(to_append)
+            end
+          end
+
+          tracker.on_close
+        end
+
+        Subscriptions::OperationSubscription.new(
+          tracker, close: on_close, value: on_value
+        )
+      end
+    end
+  end
+end
+

data/lib/reacto/operations/blocking_enumerable.rb

@@ -0,0 +1,40 @@
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class BlockingEnumerable
+      def initialize(method_name, block)
+        @method_name = method_name
+        @block = block
+      end
+
+      def call(tracker)
+        data = []
+
+        value = -> (val) { data << val }
+        close = -> do
+          emit(tracker, data)
+          tracker.on_close
+        end
+        error = ->(e) do
+          emit(tracker, data)
+          tracker.on_error(e)
+        end
+
+        Subscriptions::OperationSubscription.new(
+          tracker, value: value, error: error, close: close
+        )
+      end
+
+      def emit(tracker, data)
+        result = data.send(@method_name, &@block)
+
+        if result.is_a?(Enumerable)
+          result.each { |value| tracker.on_value(value) }
+        else
+          tracker.on_value(result)
+        end
+      end
+    end
+  end
+end

data/lib/reacto/operations/buffer.rb

@@ -30,10 +30,7 @@ module Reacto
                 end
 
         Subscriptions::OperationSubscription.new(
-          tracker,
-          value: value,
-          close: close,
-          error: error
+          tracker, value: value, close: close, error: error
         )
       end
 

data/lib/reacto/operations/chunk.rb

@@ -0,0 +1,81 @@
+require 'reacto/constants'
+require 'reacto/behaviours'
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class Chunk
+      def initialize(func, executor: nil)
+        @func = func
+        @executor = executor
+      end
+
+      def call(tracker)
+        @current_key = NO_VALUE
+        @current_data = []
+
+        value = ->(v) do
+          key = @func.call(v)
+
+          if key == nil || key == :_separator
+            flush_current!(tracker)
+            return
+          end
+
+          if key == :_alone
+            flush_current!(tracker)
+            tracker.on_value(LabeledTrackable.new(
+              key, @executor, &Behaviours.single_value(v)
+            ))
+
+            return
+          end
+
+          if key.to_s.start_with?('_')
+            flush_current!(tracker)
+            tracker.on_error(RuntimeError.new(
+              'symbols beginning with an underscore are reserved'
+            ))
+            return
+          end
+
+          if @current_key == NO_VALUE || @current_key == key
+            @current_key = key
+            @current_data << v
+            return
+          end
+
+          flush_current!(tracker)
+
+          @current_key = key
+          @current_data = [v]
+        end
+
+        error = ->(e) do
+          flush_current!(tracker)
+          tracker.on_error(e)
+        end
+
+        close = ->() do
+          flush_current!(tracker)
+          tracker.on_close
+        end
+
+        Subscriptions::OperationSubscription.new(
+          tracker, value: value, close: close, error: error
+        )
+      end
+
+      def flush_current!(tracker)
+        if @current_key != NO_VALUE
+          tracker.on_value(LabeledTrackable.new(
+            @current_key, @executor, &Behaviours.enumerable(@current_data)
+          ))
+        end
+
+        @current_key = NO_VALUE
+        @current_data = []
+      end
+    end
+  end
+end

data/lib/reacto/operations/chunk_while.rb

@@ -0,0 +1,56 @@
+require 'reacto/constants'
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class ChunkWhile
+      def initialize(func, executor: nil)
+        @func = func
+        @executor = executor
+      end
+
+      def call(tracker)
+        current_data = []
+        prev_value = NO_VALUE
+
+        value = ->(v) do
+          if prev_value == NO_VALUE
+            prev_value = v
+            current_data << v
+
+            return
+          end
+
+          should_continue = @func.call(prev_value, v)
+          prev_value = v
+
+          unless should_continue
+            flush_current(tracker, current_data)
+            current_data = []
+          end
+          current_data << v
+        end
+
+        error = ->(e) do
+          flush_current(tracker, current_data)
+          tracker.on_error(e)
+        end
+
+        close = ->() do
+          flush_current(tracker, current_data)
+          tracker.on_close
+        end
+
+        Subscriptions::OperationSubscription.new(
+          tracker, value: value, close: close, error: error
+        )
+      end
+
+      def flush_current(tracker, current_data)
+        tracker.on_value(
+          Trackable.enumerable(current_data, executor: @executor)
+        )
+      end
+    end
+  end
+end

data/lib/reacto/operations/cycle.rb

@@ -0,0 +1,27 @@
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class Cycle
+      def initialize(behaviour, n = nil)
+        @behaviour = behaviour
+        @n = n
+      end
+
+      def call(tracker)
+
+        close = -> do
+          if @n.nil? || @n > 1
+            next_n = @n.nil? ? @n : @n - 1
+            @behaviour.call(self.class.new(@behaviour, next_n).call(tracker))
+          else
+            tracker.on_close
+          end
+        end
+
+        Subscriptions::OperationSubscription.new(tracker, close: close)
+      end
+    end
+  end
+end
+

data/lib/reacto/operations/delay_each.rb

@@ -0,0 +1,75 @@
+require 'ostruct'
+require 'concurrent'
+
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class DelayEach
+      class TaskObserver
+        def initialize(tracker)
+          @tracker = tracker
+        end
+        def update(time, result, e)
+          if e
+            @tracker.on_error(e) unless e.is_a?(Concurrent::TimeoutError)
+          end
+        end
+      end
+
+      def initialize(delay)
+        @delay = delay
+        @queue = []
+      end
+
+      def call(tracker)
+        close = lambda do
+          @queue << OpenStruct.new(type: :close)
+          delay_task(tracker)
+        end
+
+        error = lambda do |e|
+          @queue << OpenStruct.new(error: e, type: :error)
+          delay_task(tracker)
+        end
+
+        value = lambda do |v|
+          @queue << OpenStruct.new(value: v, type: :value)
+          delay_task(tracker)
+        end
+
+        Subscriptions::OperationSubscription.new(
+          tracker,
+          value: value,
+          close: close,
+          error: error
+        )
+      end
+
+      private
+
+      def delay_task(tracker)
+        return if @task
+
+        @task = Concurrent::TimerTask.new(execution_interval: @delay) do
+          notification = @queue.shift
+
+          return unless notification
+
+          if notification.type == :value
+            tracker.on_value(notification.value)
+          elsif notification.type == :error
+            tracker.on_error(notification.error)
+            @task.shutdown
+          else
+            tracker.on_close
+            @task.shutdown
+          end
+        end
+        @task.add_observer(TaskObserver.new(tracker))
+
+        @task.execute
+      end
+    end
+  end
+end

data/lib/reacto/operations/depend_on.rb

@@ -1,3 +1,5 @@
+require 'ostruct'
+
 require 'reacto/constants'
 require 'reacto/subscriptions/operation_subscription'
 
@@ -10,7 +12,7 @@ module Reacto
           if accumulator.nil?
             trackable.first
           else
-            trackable.inject(NO_VALUE, accumulator)
+            trackable.inject(NO_VALUE, &accumulator)
           end
 
         @lock = Mutex.new
@@ -92,10 +94,7 @@ module Reacto
         end
 
         Subscriptions::OperationSubscription.new(
-          tracker,
-          value: value,
-          error: error,
-          close: close
+          tracker, value: value, error: error, close: close
         )
       end
     end

data/lib/reacto/operations/diff.rb

@@ -8,27 +8,25 @@ module Reacto
 
       def initialize(fn = DEFAULT_FN, initial = NO_VALUE)
         @fn = fn
-        @prev = initial
+        @initial = initial
       end
 
       def call(tracker)
-        value = lambda do |v|
-          if @prev == NO_VALUE
-            @prev = v
+        prev = @initial
+        value = -> (v) do
+          if prev == NO_VALUE
+            prev = v
             return
           end
 
-          current = @fn.call(@prev, v)
-          @prev = v
+          current = @fn.call(prev, v)
+          prev = v
 
           tracker.on_value(current)
         end
 
 
-        Subscriptions::OperationSubscription.new(
-          tracker,
-          value: value
-        )
+        Subscriptions::OperationSubscription.new(tracker, value: value)
       end
     end
   end