reacto 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 00345a7d238aab953495d04d30b70de59a43b452
+  data.tar.gz: bf82a8089e0b732e456c14a8100d8f8ecf260370
+SHA512:
+  metadata.gz: 552be561f5bec4bc6ab3b75f1f814b5d326dbae95328e83334d17811fcc0a23a6259ae946905fed819700a62d2b61d7119d2f378eddc479bc2518def7308194b
+  data.tar.gz: 972a2db20596802f0957760eadf2b58901bcd20d08211f9332ef633fd1f707833a1ca4f0bc4a07b151c0e3bc1bdf4baea8c5b1e813500c8556a01f7541497766

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,32 @@
+PATH
+  remote: .
+  specs:
+    reacto (0.0.0)
+      concurrent-ruby (~> 1.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    concurrent-ruby (1.0.0)
+    diff-lcs (1.2.5)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+    rspec-core (3.3.2)
+      rspec-support (~> 3.3.0)
+    rspec-expectations (3.3.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  reacto!
+  rspec (~> 3.3.0)

data/README.md

@@ -0,0 +1 @@
+# reacto

data/lib/reacto/behaviours.rb

@@ -0,0 +1,50 @@
+module Reacto
+  module Behaviours
+    module_function
+
+    def with_close_and_error(tracker, &block)
+      begin
+        yield tracker if block_given?
+        tracker.on_close if tracker.subscribed?
+      rescue StandardError => error
+        tracker.on_error(error) if tracker.subscribed?
+      end
+    end
+
+    def single_tracker_value(tracker, value)
+      with_close_and_error(tracker) do |subscriber|
+        subscriber.on_value(value) if subscriber.subscribed?
+      end
+    end
+
+    def single_value(value)
+      lambda do |tracker|
+        with_close_and_error(tracker) do |subscriber|
+          subscriber.on_value(value) if subscriber.subscribed?
+        end
+      end
+    end
+
+    def integers_enumerator
+      Enumerator.new do |yielder|
+        n = 0
+        loop do
+          yielder.yield n
+          n = n + 1
+        end
+      end
+    end
+
+    def array_repeat_enumerator(array)
+      size = array.size
+
+      Enumerator.new do |yielder|
+        n = 0
+        loop do
+          yielder.yield array[n % size]
+          n = n + 1
+        end
+      end
+    end
+  end
+end

data/lib/reacto/constants.rb

@@ -0,0 +1,7 @@
+module Reacto
+  NOTHING = {}
+  NO_ACTION = -> (*args) {}
+  DEFAULT_ON_ERROR = -> (e) { raise e }
+  ID = -> (v) { v }
+  NO_VALUE = {}
+end

data/lib/reacto/executors.rb

@@ -0,0 +1,31 @@
+require 'concurrent/executor/immediate_executor'
+require 'concurrent/executor/cached_thread_pool'
+require 'concurrent/executor/fixed_thread_pool'
+
+module Reacto
+  module Executors
+    class CurrentExecutor
+      def post
+
+      end
+    end
+
+    module_function
+
+    def immediate
+      Concurrent::ImmediateExecutor.new
+    end
+
+    def current
+      Concurrent::ImmediateExecutor.new
+    end
+
+    def io
+      Concurrent::CachedThreadPool.new
+    end
+
+    def tasks
+      Concurrent::FixedThreadPool.new(4) # Number of cores here?
+    end
+  end
+end

data/lib/reacto/operations/buffer.rb

@@ -0,0 +1,80 @@
+require 'concurrent'
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class Buffer
+      def initialize(count: nil, delay: nil)
+        @count = count
+        @delay = delay
+        @buffer = []
+      end
+
+      def call(tracker)
+        close = lambda do
+          finish(tracker)
+          tracker.on_close
+        end
+        error = lambda do |e|
+          finish(tracker)
+          tracker.on_error(e)
+        end
+        value = if !@count.nil? && @delay.nil?
+                  count_buffer_behaviour(tracker)
+                elsif @count.nil? && !@delay.nil?
+                  delay_buffer_behaviour(tracker)
+                elsif @count && @delay
+                  count_and_delay_buffer_behaviour(tracker)
+                else
+                  tracker.method(:on_value)
+                end
+
+        Subscriptions::OperationSubscription.new(
+          tracker,
+          value: value,
+          close: close,
+          error: error
+        )
+      end
+
+      private
+
+      def finish(tracker)
+        @task.shutdown if @task
+
+        tracker.on_value(@buffer) unless @buffer.empty?
+      end
+
+      def count_buffer_behaviour(tracker)
+        lambda do |value|
+          @buffer << value
+
+          if @buffer.size >= @count
+            tracker.on_value(@buffer)
+            @buffer = []
+          end
+        end
+      end
+
+      def delay_task(tracker)
+        @task = Concurrent::TimerTask.new(execution_interval: @delay) do
+          unless @buffer.empty?
+            tracker.on_value(@buffer)
+            @buffer = []
+          end
+        end
+        @task.execute
+      end
+
+      def delay_buffer_behaviour(tracker)
+        delay_task(tracker)
+        -> (value) { @buffer << value }
+      end
+
+      def count_and_delay_buffer_behaviour(tracker)
+        delay_task(tracker)
+        count_buffer_behaviour(tracker)
+      end
+    end
+  end
+end

data/lib/reacto/operations/concat.rb

@@ -0,0 +1,23 @@
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class Concat
+      # TODO Continue on error flag!
+      def initialize(trackable)
+        @trackable = trackable
+      end
+
+      def call(tracker)
+        Subscriptions::OperationSubscription.new(
+          tracker,
+          close: -> () { @trackable.send(:do_track, tracker) },
+          error: -> (e) { 
+            tracker.on_error(e)
+            @trackable.send(:do_track, tracker)
+          }
+        )
+      end
+    end
+  end
+end

data/lib/reacto/operations/diff.rb

@@ -0,0 +1,36 @@
+require 'reacto/constants'
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class Diff
+      DEFAULT_FN = -> (a, b) { [a, b] }
+
+      def initialize(fn = DEFAULT_FN, initial = NO_VALUE)
+        @fn = fn
+        @prev = initial
+      end
+
+      def call(tracker)
+        value = lambda do |v|
+          if @prev == NO_VALUE
+            @prev = v
+            return
+          end
+
+          current = @fn.call(@prev, v)
+          @prev = v
+
+          tracker.on_value(current)
+        end
+
+
+        Subscriptions::OperationSubscription.new(
+          tracker,
+          value: value
+        )
+      end
+    end
+  end
+end
+

data/lib/reacto/operations/drop.rb

@@ -0,0 +1,41 @@
+require 'reacto/constants'
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class Drop
+      def initialize(how_many_to_drop, offset = NO_VALUE)
+        if how_many_to_drop < 0
+          raise ArgumentError.new('Attempt to drop negative size!')
+        end
+
+        @how_many_to_drop = how_many_to_drop
+        @dropped = 0
+        @offset = offset
+      end
+
+      def call(tracker)
+        behaviour = lambda do |value|
+          @dropped += 1
+
+          if @dropped > @how_many_to_drop
+            if @offset != NO_VALUE
+              if @offset <= 0
+                tracker.on_close
+                return
+              else
+                @offset -= 1
+              end
+            end
+            tracker.on_value(value)
+          end
+        end
+
+        Subscriptions::OperationSubscription.new(
+          tracker,
+          value: behaviour
+        )
+      end
+    end
+  end
+end

data/lib/reacto/operations/drop_errors.rb

@@ -0,0 +1,15 @@
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class DropErrors
+      def call(tracker)
+        Subscriptions::OperationSubscription.new(
+          tracker,
+          error: ->(e) {}
+        )
+      end
+    end
+  end
+end
+

data/lib/reacto/operations/flat_map.rb

@@ -0,0 +1,26 @@
+require 'reacto/subscriptions/operation_subscription'
+require 'reacto/subscriptions/flat_map_subscription'
+
+module Reacto
+  module Operations
+    class FlatMap
+      def initialize(transform)
+        @transform = transform
+      end
+
+      def call(tracker)
+        subscription = Subscriptions::FlatMapSubscription.new(tracker)
+        value = lambda do |v|
+          trackable = @transform.call(v)
+
+          trackable.do_track subscription.subscription!
+        end
+
+        Subscriptions::OperationSubscription.new(
+          tracker, value: value
+        )
+      end
+    end
+  end
+end
+

data/lib/reacto/operations/flatten.rb

@@ -0,0 +1,26 @@
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class Flatten
+
+      def call(tracker)
+        behaviour = lambda do |value|
+          if value.kind_of?(Array)
+            value.flatten.each do |sub_value|
+              tracker.on_value(sub_value)
+            end
+          else
+            tracker.on_value(value)
+          end
+        end
+
+        Subscriptions::OperationSubscription.new(
+          tracker,
+          value: behaviour
+        )
+      end
+    end
+  end
+end
+

data/lib/reacto/operations/inject.rb

@@ -0,0 +1,43 @@
+require 'reacto/constants'
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class Inject
+
+      def initialize(injector, initial = NO_VALUE)
+        @injector = injector
+        @current = initial
+        @has_values = false
+      end
+
+      def call(tracker)
+        inject = lambda do |v|
+          if @current == NO_VALUE
+            @current = v
+          else
+            @current = @injector.call(@current, v)
+          end
+
+          @has_values = true
+          tracker.on_value(@current)
+        end
+
+        close = lambda do
+          unless @has_values || @current == NO_VALUE
+            tracker.on_value(@current)
+          end
+
+          tracker.on_close
+        end
+
+        Subscriptions::OperationSubscription.new(
+          tracker,
+          value: inject,
+          close: close
+        )
+      end
+    end
+  end
+end
+

data/lib/reacto/operations/last.rb

@@ -0,0 +1,31 @@
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class Last
+      def initialize
+        @marker = {}
+        @prev = @marker
+      end
+
+      def call(tracker)
+        close = lambda do
+          tracker.on_value(@prev) if @prev != @marker
+          tracker.on_close
+        end
+        error = lambda do |e|
+          tracker.on_value(@prev) if @prev != @marker
+          tracker.on_error(e)
+        end
+
+        Subscriptions::OperationSubscription.new(
+          tracker,
+          value: -> (v) { @prev = v },
+          error: error,
+          close: close
+        )
+      end
+    end
+  end
+end
+

data/lib/reacto/operations/map.rb

@@ -0,0 +1,38 @@
+require 'reacto/constants'
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class Map
+      def initialize(mapping, error: nil, close: nil)
+        @mapping = mapping
+        @error = error
+        @close = close
+      end
+
+      def call(tracker)
+        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
+
+        Subscriptions::OperationSubscription.new(
+          tracker,
+          value: -> (v) { tracker.on_value(@mapping.call(v)) },
+          error: error,
+          close: close
+        )
+      end
+    end
+  end
+end

data/lib/reacto/operations/merge.rb

@@ -0,0 +1,47 @@
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class Merge
+      def initialize(trackable, delay_error: false)
+        @trackable = trackable
+        @close_notifications = 2
+        @lock = Mutex.new
+        @delay_error = delay_error
+      end
+
+      def call(tracker)
+        close = lambda do
+          @lock.synchronize do
+            @close_notifications -= 1
+            if @close_notifications == 0
+              @error.nil? ? tracker.on_close : tracker.on_error(@error)
+            end
+          end
+        end
+        err =
+          if @delay_error
+            lambda do |er|
+              @lock.synchronize do
+                @error = er
+                @close_notifications -= 1
+                tracker.on_error(@error) if @close_notifications == 0
+              end
+            end
+          else
+            tracker.method(:on_error)
+          end
+
+        sub = Subscriptions::OperationSubscription.new(
+          tracker,
+          close: close,
+          error: err
+        )
+
+        @trackable.send(:do_track, sub)
+        sub
+      end
+    end
+  end
+end
+

data/lib/reacto/operations/prepend.rb

@@ -0,0 +1,19 @@
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class Prepend
+      attr_reader :enumerable
+
+      def initialize(enumerable)
+        @enumerable = enumerable
+      end
+
+      def call(tracker)
+        enumerable.each { |value| tracker.on_value(value) }
+        tracker
+      end
+    end
+  end
+end
+

data/lib/reacto/operations/select.rb

@@ -0,0 +1,25 @@
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class Select
+      def initialize(filter)
+        @filter = filter
+      end
+
+      def call(tracker)
+        on_value = lambda do |v|
+          if @filter.call(v)
+            tracker.on_value(v)
+          end
+        end
+
+        Subscriptions::OperationSubscription.new(
+          tracker,
+          value: on_value
+        )
+      end
+    end
+  end
+end
+

data/lib/reacto/operations/take.rb

@@ -0,0 +1,38 @@
+require 'reacto/subscriptions/operation_subscription'
+
+module Reacto
+  module Operations
+    class Take
+      def initialize(how_many_to_take)
+        if how_many_to_take < 0
+          raise ArgumentError.new('Attempt to take negative size!')
+        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
+            tracker.on_value(value)
+            @taken += 1
+          else
+            @closed = true
+            tracker.on_close
+          end
+        end
+
+        Subscriptions::OperationSubscription.new(
+          tracker,
+          value: behaviour
+        )
+      end
+    end
+  end
+end
+
+
+