reacto 0.1.0 → 1.0.0

data/lib/reacto/operations/drop.rb

@@ -10,15 +10,16 @@ module Reacto
         end
 
         @how_many_to_drop = how_many_to_drop
-        @dropped = 0
         @offset = offset
       end
 
       def call(tracker)
-        behaviour = lambda do |value|
-          @dropped += 1
+        dropped = 0
 
-          if @dropped > @how_many_to_drop
+        behaviour = -> (value) do
+          dropped += 1
+
+          if dropped > @how_many_to_drop
             if @offset != NO_VALUE
               if @offset <= 0
                 tracker.on_close
@@ -31,10 +32,7 @@ module Reacto
           end
         end
 
-        Subscriptions::OperationSubscription.new(
-          tracker,
-          value: behaviour
-        )
+        Subscriptions::OperationSubscription.new(tracker, value: behaviour)
       end
     end
   end

data/lib/reacto/operations/drop_while.rb

@@ -0,0 +1,23 @@
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class DropWhile
+      def initialize(predicate)
+        @predicate = predicate
+      end
+
+      def call(tracker)
+        done = false
+
+        behaviour = -> (value) do
+          done = !@predicate.call(value) unless done
+
+          tracker.on_value(value) if done
+        end
+
+        Subscriptions::OperationSubscription.new(tracker, value: behaviour)
+      end
+    end
+  end
+end

data/lib/reacto/operations/each_collect.rb

@@ -0,0 +1,57 @@
+require 'reacto/constants'
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class EachCollect
+      def initialize(
+        n,
+        reset_action: -> (_) { [] }, collect_action: nil,
+        init_action: NO_ACTION, on_error: nil, on_close: nil
+      )
+        @n = n
+        @reset_action = reset_action
+        @collect_action = collect_action
+        @init_action = init_action
+
+        @error = on_error
+        @close = on_close
+      end
+
+      def call(tracker)
+        current = []
+        @init_action.call
+
+        unless @collect_action
+          @collect_action = -> (value, collection) { collection << value }
+        end
+
+        error = @error ? @error : ->(e) do
+          tracker.on_value(current) unless current.empty?
+          tracker.on_error(e)
+        end
+        close = @close ? @close : ->() do
+          tracker.on_value(current) unless current.empty?
+          tracker.on_close
+        end
+
+        error = error == NO_ACTION ? tracker.method(:on_error) : error
+        close = close == NO_ACTION ? tracker.method(:on_close) : close
+
+        behaviour = -> (value) do
+          @collect_action.call(value, current)
+
+          if current.size == @n
+            tracker.on_value(current)
+
+            current = @reset_action.call(current)
+          end
+        end
+
+        Subscriptions::OperationSubscription.new(
+          tracker, value: behaviour, error: error, close: close
+        )
+      end
+    end
+  end
+end

data/lib/reacto/operations/each_with_object.rb

@@ -0,0 +1,31 @@
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class EachWithObject
+      def initialize(action, obj)
+        @action = action
+        @obj = obj
+      end
+
+      def call(tracker)
+        memo = @obj
+
+        close = -> () do
+          tracker.on_value(memo)
+          tracker.on_close
+        end
+
+        error = -> (e) do
+          tracker.on_value(memo)
+          tracker.on_error(e)
+        end
+
+        Subscriptions::OperationSubscription.new(
+          tracker,
+          value: -> (v) { @action.call(v, memo) }, error: error, close: close
+        )
+      end
+    end
+  end
+end

data/lib/reacto/operations/extremums.rb

@@ -0,0 +1,54 @@
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class Extremums
+      AVAILABLE_TYPES = %i(min max minmax)
+
+      def initialize(action: nil, by: nil, type: :max)
+        unless AVAILABLE_TYPES.include?(type)
+          raise ArgumentError.new(
+            "Type not supported, expecting one of #{AVAILABLE_TYPES.join(', ')}"
+          )
+        end
+
+        @action = action
+        @by = by
+        @type = type
+      end
+
+      def call(tracker)
+        buffer = []
+
+        behaviour = -> (v) do
+          buffer << v
+        end
+
+        error = -> (e) do
+          emit_values(tracker, buffer)
+          tracker.on_error(e)
+        end
+
+        close = -> () do
+          emit_values(tracker, buffer)
+          tracker.on_close
+        end
+
+        Subscriptions::OperationSubscription.new(
+          tracker, error: error, value: behaviour, close: close
+        )
+      end
+
+      def emit_values(tracker, buffer)
+        values =
+          if @by
+            buffer.send("#{@type.to_s}_by", &@by)
+          else
+            buffer.send(@type, &@action)
+          end
+
+        Array(values).each { |val| tracker.on_value(val) }
+      end
+    end
+  end
+end

data/lib/reacto/operations/find_index.rb

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

data/lib/reacto/operations/flat_map.rb

@@ -10,13 +10,13 @@ module Reacto
 
       def call(tracker)
         subscription = Subscriptions::FlatMapSubscription.new(tracker)
-        value = lambda do |v|
+        value = ->(v) do
           trackable = @transform.call(v)
 
           trackable.do_track subscription.subscription!
         end
 
-        close = lambda do
+        close = ->() do
           subscription.source_closed = true
           return unless subscription.closed?
 

data/lib/reacto/operations/flatten.rb

@@ -3,9 +3,8 @@ require 'reacto/subscriptions/operation_subscription'
 module Reacto
   module Operations
     class Flatten
-
       def call(tracker)
-        behaviour = lambda do |value|
+        behaviour = -> (value) do
           if value.kind_of?(Array)
             value.flatten.each do |sub_value|
               tracker.on_value(sub_value)
@@ -15,12 +14,8 @@ module Reacto
           end
         end
 
-        Subscriptions::OperationSubscription.new(
-          tracker,
-          value: behaviour
-        )
+        Subscriptions::OperationSubscription.new(tracker, value: behaviour)
       end
     end
   end
 end
-

data/lib/reacto/operations/flatten_labeled.rb

@@ -0,0 +1,44 @@
+require 'ostruct'
+
+require 'reacto/constants'
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class FlattenLabeled
+      def initialize(accumulator = nil, initial = NO_VALUE)
+        @accumulator = accumulator
+        @initial = initial
+      end
+
+      def call(tracker)
+        value = -> (v) do
+          unless v.is_a?(LabeledTrackable)
+            tracker.on_error(ArgumentError.new(
+              'Trackable#flatten_labeled expects all values emitted by the ' \
+              'source Trackable to be LabeledTrackable instances.'
+            ))
+            return
+          end
+
+          labeled_trackable =
+            if @accumulator.nil?
+              v.first
+            else
+              v.inject(@initial, &@accumulator).last
+            end
+
+          accumulated = []
+          labeled_trackable.on(value: ->(val) { accumulated << val })
+          tracker.on_value(
+            OpenStruct.new({ label: v.label, value: accumulated.first })
+          )
+        end
+
+        Subscriptions::OperationSubscription.new(
+          tracker, value: value
+        )
+      end
+    end
+  end
+end

data/lib/reacto/operations/{label.rb → group_by_label.rb}

@@ -2,7 +2,7 @@ require 'reacto/subscriptions/operation_subscription'
 
 module Reacto
   module Operations
-    class Label
+    class GroupByLabel
       def initialize(chose_label, executor = nil)
         @chose_label = chose_label
         @executor = executor

data/lib/reacto/operations/include.rb

@@ -0,0 +1,40 @@
+require 'reacto/constants'
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class Include
+      def initialize(value)
+        @value = value
+      end
+
+      def call(tracker)
+        includes = false
+
+        behaviour = -> (val) do
+          if @value == val
+            includes = true
+
+            tracker.on_value(includes)
+            tracker.on_close
+          end
+        end
+
+        close = -> () do
+          tracker.on_value(includes) unless includes
+          tracker.on_close
+        end
+
+        error = -> (e) do
+          tracker.on_value(includes) unless includes
+          tracker.on_error(e)
+        end
+
+        Subscriptions::OperationSubscription.new(
+          tracker, value: behaviour, error: error, close: close
+        )
+      end
+    end
+  end
+end
+

data/lib/reacto/operations/inject.rb

@@ -4,15 +4,16 @@ require 'reacto/subscriptions/operation_subscription'
 module Reacto
   module Operations
     class Inject
-
       def initialize(injector, initial = NO_VALUE)
         @injector = injector
-        @current = initial
-        @has_values = false
+        @initial = initial
       end
 
       def call(tracker)
-        inject = lambda do |v|
+        @current = @initial
+        @has_values = false
+
+        inject = -> (v) do
           if @current == NO_VALUE
             @current = v
           else
@@ -23,7 +24,7 @@ module Reacto
           tracker.on_value(@current)
         end
 
-        close = lambda do
+        close = -> () do
           unless @has_values || @current == NO_VALUE
             tracker.on_value(@current)
           end
@@ -31,13 +32,18 @@ module Reacto
           tracker.on_close
         end
 
+        error = -> (e) do
+          unless @has_values || @current == NO_VALUE
+            tracker.on_value(@current)
+          end
+
+          tracker.on_error(e)
+        end
+
         Subscriptions::OperationSubscription.new(
-          tracker,
-          value: inject,
-          close: close
+          tracker, value: inject, close: close, error: error
         )
       end
     end
   end
 end
-

data/lib/reacto/operations/map.rb

@@ -11,20 +11,22 @@ module Reacto
       end
 
       def call(tracker)
-        error = if @error
-                  -> (e) { tracker.on_error(@error.call(e)) }
-                else
-                  tracker.method(:on_error)
-                end
+        error =
+          if @error
+            -> (e) { tracker.on_error(@error.call(e)) }
+          else
+            tracker.method(:on_error)
+          end
 
-        close = if @close
-                  -> () do
-                    tracker.on_value(@close.call)
-                    tracker.on_close
-                  end
-                else
-                  tracker.method(:on_close)
-                end
+        close =
+          if @close
+            -> () do
+              tracker.on_value(@close.call)
+              tracker.on_close
+            end
+          else
+            tracker.method(:on_close)
+          end
 
         Subscriptions::OperationSubscription.new(
           tracker,