reacto 0.1.0 → 1.0.0

data/lib/reacto/operations/merge.rb

@@ -1,31 +1,35 @@
+require 'concurrent'
 require 'reacto/subscriptions/operation_subscription'
 
 module Reacto
   module Operations
     class Merge
-      def initialize(trackable, delay_error: false)
-        @trackable = trackable
-        @close_notifications = 2
+      def initialize(trackables, delay_error: false)
+        @trackables = trackables
+
+        @close_notifications =
+          Concurrent::AtomicFixnum.new(@trackables.size + 1)
         @lock = Mutex.new
         @delay_error = delay_error
       end
 
       def call(tracker)
-        close = lambda do
+        error = nil
+
+        close = -> () do
           @lock.synchronize do
-            @close_notifications -= 1
-            if @close_notifications == 0
-              @error.nil? ? tracker.on_close : tracker.on_error(@error)
+            if @close_notifications.decrement == 0
+              error.nil? ? tracker.on_close : tracker.on_error(error)
             end
           end
         end
+
         err =
           if @delay_error
-            lambda do |er|
+            -> (er) do
               @lock.synchronize do
-                @error = er
-                @close_notifications -= 1
-                tracker.on_error(@error) if @close_notifications == 0
+                error = er
+                tracker.on_error(error) if @close_notifications.decrement == 0
               end
             end
           else
@@ -33,15 +37,12 @@ module Reacto
           end
 
         sub = Subscriptions::OperationSubscription.new(
-          tracker,
-          close: close,
-          error: err
+          tracker, close: close, error: err
         )
 
-        @trackable.send(:do_track, sub)
+        @trackables.each { |trackable| trackable.send(:do_track, sub) }
         sub
       end
     end
   end
 end
-

data/lib/reacto/operations/operation_on_labeled.rb

@@ -0,0 +1,29 @@
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class OperationOnLabeled
+      def initialize(label, action, op: :map, **args)
+        @op = op
+        @action = action
+        @label = label
+        @args = args
+      end
+
+      def call(tracker)
+        value = -> (v) do
+          to_emit =
+            if v.is_a?(LabeledTrackable) && v.label == @label
+              v.send(@op, **@args, &@action)
+            else
+              v
+            end
+
+          tracker.on_value(to_emit)
+        end
+
+        Subscriptions::OperationSubscription.new(tracker, value: value)
+      end
+    end
+  end
+end

data/lib/reacto/operations/partition.rb

@@ -0,0 +1,52 @@
+require 'reacto/behaviours'
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class Partition
+      def initialize(predicate, executor: nil)
+        @predicate = predicate
+        @executor = executor
+      end
+
+      def call(tracker)
+        true_array = []
+        false_array = []
+
+        behavior = -> (val) do
+          if @predicate.call(val)
+            true_array << val
+          else
+            false_array << val
+          end
+        end
+
+        error = -> (e) do
+          emit_trackables(tracker, true_array, false_array)
+          tracker.on_error(e)
+        end
+
+        close = -> () do
+          emit_trackables(tracker, true_array, false_array)
+          tracker.on_close
+        end
+
+        Subscriptions::OperationSubscription.new(
+          tracker, value: behavior, error: error, close: close
+        )
+      end
+
+      def emit_trackables(tracker, true_array, false_array)
+        true_trackable = LabeledTrackable.new(
+          true, @executor, &Behaviours.enumerable(true_array)
+        )
+        false_trackable = LabeledTrackable.new(
+          false, @executor, &Behaviours.enumerable(false_array)
+        )
+
+        tracker.on_value(true_trackable)
+        tracker.on_value(false_trackable)
+      end
+    end
+  end
+end

data/lib/reacto/operations/prepend.rb

@@ -1,5 +1,3 @@
-require 'reacto/subscriptions/operation_subscription'
-
 module Reacto
   module Operations
     class Prepend
@@ -16,4 +14,3 @@ module Reacto
     end
   end
 end
-

data/lib/reacto/operations/rescue_and_replace_error.rb

@@ -0,0 +1,21 @@
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class RescueAndReplaceError
+      def initialize(action)
+        @action = action
+      end
+
+      def call(tracker)
+        error = -> (e) do
+          trackable = @action.call(e)
+
+          trackable.send(:do_track, tracker)
+        end
+
+        Subscriptions::OperationSubscription.new(tracker, error: error)
+      end
+    end
+  end
+end

data/lib/reacto/operations/retry.rb

@@ -0,0 +1,26 @@
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class Retry
+      def initialize(behaviour, retries = 1)
+        @behaviour = behaviour
+        @retries = retries
+      end
+
+      def call(tracker)
+        error = ->(e) do
+          @retries = @retries - 1
+
+          if @retries < 0
+            tracker.on_error(e)
+          else
+            @behaviour.call(self.call(tracker))
+          end
+        end
+
+        Subscriptions::OperationSubscription.new(tracker, error: error)
+      end
+    end
+  end
+end

data/lib/reacto/operations/retry_when.rb

@@ -0,0 +1,30 @@
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class RetryWhen
+      def initialize(behaviour, predicate)
+        @behaviour = behaviour
+        @predicate = predicate
+        @retries = {}
+      end
+
+      def call(tracker)
+        @retries[tracker] ||= 0
+
+        error = -> (e) do
+          should_retry = @predicate.call(e, @retries[tracker])
+
+          if should_retry
+            @retries[tracker] += 1
+            @behaviour.call(self.call(tracker))
+          else
+            tracker.on_error(e)
+          end
+        end
+
+        Subscriptions::OperationSubscription.new(tracker, error: error)
+      end
+    end
+  end
+end

data/lib/reacto/operations/select.rb

@@ -8,18 +8,14 @@ module Reacto
       end
 
       def call(tracker)
-        on_value = lambda do |v|
+        behaviour = -> (v) do
           if @filter.call(v)
             tracker.on_value(v)
           end
         end
 
-        Subscriptions::OperationSubscription.new(
-          tracker,
-          value: on_value
-        )
+        Subscriptions::OperationSubscription.new(tracker, value: behaviour)
       end
     end
   end
 end
-

data/lib/reacto/operations/slice.rb

@@ -0,0 +1,50 @@
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class Slice
+      TYPES = %i(before after)
+
+      def initialize(predicate, type: :after)
+        unless TYPES.include?(type)
+          raise ArgumentError.new(
+            "Type #{type} not supported. " \
+            "Supported types are #{TYPES.join(', ')}"
+          )
+        end
+
+        @type = type
+        @predicate = predicate
+      end
+
+      def call(tracker)
+        buffer = []
+
+        behaviour = -> (val) do
+          buffer << val if @type == :after
+
+          if @predicate.call(val)
+            tracker.on_value(Trackable.enumerable(buffer))
+            buffer = []
+          end
+
+          buffer << val if @type == :before
+        end
+
+        error = -> (e) do
+          tracker.on_value(Trackable.enumerable(buffer)) unless buffer.empty?
+          tracker.on_error(e)
+        end
+
+        close = -> () do
+          tracker.on_value(Trackable.enumerable(buffer)) unless buffer.empty?
+          tracker.on_close
+        end
+
+        Subscriptions::OperationSubscription.new(
+          tracker, value: behaviour, error: error, close: close
+        )
+      end
+    end
+  end
+end

data/lib/reacto/operations/slice_when.rb

@@ -0,0 +1,41 @@
+require 'reacto/constants'
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class SliceWhen
+      def initialize(predicate)
+        @predicate = predicate
+      end
+
+      def call(tracker)
+        previous = NO_VALUE
+        buffer = []
+
+        behaviour = -> (val) do
+          if previous != NO_VALUE && @predicate.call(previous, val)
+            tracker.on_value(Trackable.enumerable(buffer))
+            buffer = []
+          end
+
+          buffer << val
+          previous = val
+        end
+
+        error = -> (e) do
+          tracker.on_value(Trackable.enumerable(buffer)) unless buffer.empty?
+          tracker.on_error(e)
+        end
+
+        close = -> () do
+          tracker.on_value(Trackable.enumerable(buffer)) unless buffer.empty?
+          tracker.on_close
+        end
+
+        Subscriptions::OperationSubscription.new(
+          tracker, value: behaviour, error: error, close: close
+        )
+      end
+    end
+  end
+end

data/lib/reacto/operations/split_labeled.rb

@@ -0,0 +1,32 @@
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class SplitLabeled
+      def initialize(label, chose_label, executor = nil)
+        @label = label
+        @chose_label = chose_label
+        @executor = executor
+      end
+
+      def call(tracker)
+        value = -> (v) do
+          if v.is_a?(LabeledTrackable) && v.label == @label
+            action = -> (labeled_trackable) do
+              tracker.on_value(labeled_trackable)
+            end
+
+            v.group_by_label(executor: @executor, &@chose_label)
+              .on(value: action)
+          else
+            tracker.on_value(v)
+          end
+        end
+
+        Subscriptions::OperationSubscription.new(
+          tracker, value: value
+        )
+      end
+    end
+  end
+end

data/lib/reacto/operations/take.rb

@@ -9,30 +9,25 @@ module Reacto
         end
 
         @how_many_to_take = how_many_to_take
-        @taken = 0
-        @closed = false
       end
 
       def call(tracker)
-        behaviour = lambda do |value|
-          return if @closed
-          if @taken < @how_many_to_take
+        taken = 0
+        closed = false
+
+        behaviour = -> (value) do
+          return if closed
+          if taken < @how_many_to_take
             tracker.on_value(value)
-            @taken += 1
+            taken += 1
           else
-            @closed = true
+            closed = true
             tracker.on_close
           end
         end
 
-        Subscriptions::OperationSubscription.new(
-          tracker,
-          value: behaviour
-        )
+        Subscriptions::OperationSubscription.new(tracker, value: behaviour)
       end
     end
   end
 end
-
-
-

data/lib/reacto/operations/take_while.rb

@@ -0,0 +1,28 @@
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class TakeWhile
+      def initialize(predicate)
+        @predicate = predicate
+      end
+
+      def call(tracker)
+        closed = false
+
+        behaviour = -> (value) do
+          return if closed
+
+          if @predicate.call(value)
+            tracker.on_value(value)
+          else
+            closed = true
+            tracker.on_close
+          end
+        end
+
+        Subscriptions::OperationSubscription.new(tracker, value: behaviour)
+      end
+    end
+  end
+end