rrx 0.0.1

data/lib/Reactive/observable/map.rb

@@ -0,0 +1,20 @@
+module Reactive::Observable
+  class Map < Wrapper
+
+    add_attributes :mapper
+
+    #TODO need to handle array returned from @map.call ?
+    observer_on_next do |value|
+      begin
+        new_value = @mapper.call(value)
+      rescue Exception => e
+        on_error(e)
+      else
+        #new_values.each {|v| @target.on_next(v)  }
+        @target.on_next(new_value)
+      end
+    end
+
+  end
+
+end

data/lib/Reactive/observable/merge.rb

@@ -0,0 +1,26 @@
+module Reactive
+  module Observable
+  class Merge < DoubleWrapper
+
+    class Observer < ObserverWrapper
+      attr_accessor :num_completed
+
+      def initialize(*args)
+        @num_completed = 0
+        super
+      end
+
+      def on_complete
+        if num_completed == 0
+          self.num_completed = 1
+        else
+          self.target.on_complete
+          unwrap
+        end
+      end
+
+    end
+
+  end
+  end
+end

data/lib/Reactive/observable/push.rb

@@ -0,0 +1,47 @@
+module Reactive::Observable
+
+  class Push < Composite
+    add_attributes :o1, :o2
+
+    #def initialize(o1, o2)
+    #  @o1, @o2 = o1, o2
+    #end
+
+    def initial_subscriptions
+      [@o1]
+    end
+
+    def observer_args(observer, parent)
+        [observer, parent, @o2]
+    end
+
+    class Observer < Reactive::ObserverWrapper
+      attr_reader :next_observable
+
+      def initialize(observer, parent, ob)
+        @next_observable = ob
+        super(observer, parent)
+      end
+
+      def on_complete
+        if @next_observable
+          next_observable = @next_observable
+          @next_observable = nil
+          disposable = next_observable.subscribe_observer(self)
+          wrap_with_parent(disposable) if @target
+        else
+          @target.on_complete
+          unwrap
+        end
+      end
+
+      def unwrap
+        @next_observable = nil
+        super
+      end
+
+    end
+
+  end
+
+end

data/lib/Reactive/observable/skip.rb

@@ -0,0 +1,25 @@
+module Reactive::Observable
+
+  class Skip < Wrapper
+    add_attributes :count
+
+    class Observer < Reactive::ObserverWrapper
+
+      def initialize(*args)
+        @skipped = 0
+        super
+      end
+
+      def on_next(value)
+        if @skipped == @count
+          @target.on_next(value)
+        else
+          @skipped += 1
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/Reactive/observable/wrapper.rb

@@ -0,0 +1,10 @@
+module Reactive::Observable
+
+  class Wrapper < Composite
+    add_attributes :target
+
+    def initial_subscriptions
+      [@target]
+    end
+  end
+end

data/lib/Reactive/observer.rb

@@ -0,0 +1,36 @@
+module Reactive
+  class Observer
+
+      def initialize(handlers)
+        @handlers = handlers
+      end
+
+      def on_next(value)
+        @handlers[:on_next].call(value)
+      end
+
+      def on_complete
+        @handlers[:on_complete].call()
+      end
+
+      def on_error(error)
+        @handlers[:on_error].call(error)
+        unwrap
+      end
+
+      def unwrap
+        @handlers = nil
+      end
+
+
+  end
+
+  class EmptyObserver
+
+    def on_next(value); end
+    def on_complete; end
+    def on_error(error); end
+
+  end
+
+end

data/lib/Reactive/scheduler.rb

@@ -0,0 +1,23 @@
+module Reactive
+  class Scheduler
+
+    def schedule_periodic(at, action, wrapper = Disposable::Wrapper.new)
+      return unless wrapper
+      callback = lambda do
+        new_at = action.()
+        if new_at #defined ~
+          schedule_periodic(new_at, action, wrapper)
+        else
+          wrapper.unwrap
+        end
+      end
+      wrapper.target = schedule_once(at, callback)
+
+    end
+
+    def schedule_once(at, action)
+      EventMachine.add_timer(at / 1000.0, action)
+    end
+
+  end
+end

data/lib/Reactive/version.rb

@@ -0,0 +1,3 @@
+module Rrx
+  VERSION = "0.0.1"
+end

data/lib/rrx.rb

@@ -0,0 +1,125 @@
+require "reactive/version"
+require 'weakref'
+require 'pp'
+require 'active_support'
+require 'eventmachine'
+
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/module/introspection'
+require 'active_support/core_ext/class/attribute'
+
+module Reactive
+
+  autoload :Observer, 'reactive/observer'
+  autoload :Scheduler, 'reactive/scheduler'
+  autoload :Observable, 'reactive/observable'
+
+  class AmbivalentRef < WeakRef
+
+    def self.create(value)
+      case value
+        when NilClass, TrueClass, FalseClass, Fixnum, Symbol
+          value
+        else
+          new(value)
+      end
+    end
+
+    def __getobj__
+      super rescue nil
+    end
+  end
+
+  module Disposable
+    class Wrapper
+      attr_reader :target
+
+      def initialize(target = nil, parent = nil)
+        @parent = AmbivalentRef.create(parent)
+        self.target = target
+      end
+
+      def target=(v)
+        @target = AmbivalentRef.create(v)
+      end
+
+      def unwrap
+        self.target = nil #return previous target?
+      end
+
+    end
+
+    class Closure
+      def initialize(&cleanup)
+        ObjectSpace.define_finalizer(self, cleanup)
+      end
+    end
+  end
+
+
+  class ObserverWrapper
+    attr_reader :target, :parent
+
+    def initialize(target, parent, opts = {})
+      attributes.each do |name, default|
+        instance_variable_set(:"@#{name}", opts[name])
+      end
+      @target =  target
+      @parent =  AmbivalentRef.new(parent)
+    end
+
+    def attributes
+      self.class.parent.attributes
+    end
+
+    def on_next(value)
+      @target.on_next(value)
+    end
+
+    def on_complete
+      @target.on_complete
+      unwrap
+    end
+
+    def wrap_with_parent(child)
+      @parent.target = child
+    end
+
+    def unwrap
+      attributes.each {|name, default|  instance_variable_set(:"@#{name}", nil)  }
+      @target = EmptyObserver.new
+      unwrap_parent if active?
+    end
+
+    def active?
+      @parent
+    end
+
+    def unwrap_parent(*args)
+      @parent.unwrap(*args)
+    end
+  end
+
+  #class ReplaySubject
+  #
+  #
+  #  def subject
+  #    @subject ||= Subject.new
+  #  end
+  #
+  #  def run(observer)
+  #    wrapper = subject.run(observer)
+  #    @queue.each {|q| q.accept(observer) }
+  #    return wrapper
+  #  end
+  #
+  #  def on_next(value)
+  #    @queue << value
+  #    value.accept(subject)
+  #  end
+  #
+  #end
+
+
+end
+

data/rrx.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'reactive/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "rrx"
+  gem.version       = Rrx::VERSION
+  gem.authors       = ["Daniel Davis"]
+  gem.email         = ["shoefish@gmail.com"]
+  gem.description   = %q{Reactive Extensions provide an enumerable-like interface to process temporal data(events) with the eash usually reserved for structural Enumerables }
+  gem.summary       = %q{Ruby Reactive Extensions}
+  gem.homepage      = "https://github.com/emirikol/rrx"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec'
+
+  gem.add_runtime_dependency 'eventmachine'
+  gem.add_runtime_dependency 'active_support'
+end

data/spec/observable/count_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Reactive::Observable::Count do
+
+  include Lets
+
+  context '#count from interval(1000)' do
+    before do
+      @s = Reactive::Observable.interval(1000).count
+      @s.subscribe(observer)
+    end
+
+    it 'fires with 1 after one interval' do
+      observer[:on_next].should_receive(:call).with(1)
+      advance_by(1001)
+    end
+
+    it 'fires with 2 after two intervals' do
+      observer[:on_next].should_receive(:call).with(2)
+      advance_by 2001
+    end
+
+    it 'fires with 7 after 7 intervals' do
+      observer[:on_next].should_receive(:call).with(7)
+      advance_by 7001
+    end
+
+  end
+
+end

data/spec/observable/first_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Reactive::Observable::First do
+  include Lets
+
+  context '#first(3) from interval' do
+    before do
+      @s = Reactive::Observable::First.new(target: Reactive::Observable.interval(1000), count: 3)
+      @s.subscribe(observer)
+    end
+
+    context 'after one interval' do
+      advance_by(1001) {
+        should send_call.with(0).to(observer, :on_next)
+      }
+    end
+
+    context 'after 3 intervals' do
+      advance_by(3001, ignore: :on_complete) {
+        should send_call.exactly(3).times.with(kind_of(Fixnum)).to(observer, :on_next)
+      }
+      advance_by(3001, ignore: :on_next) {
+        should send_call.with(no_args).to(observer, :on_complete)
+      }
+    end
+
+
+    context 'after 4 intervals' do
+      advance_by(4001, ignore: :on_complete) {
+        should send_call.exactly(3).times.with(kind_of(Fixnum)).to(observer, :on_next)
+      }
+    end
+
+  end
+
+  context  do
+    it 'take 1 from 1', :focus => true do
+      @s = Reactive::Observable::First.new(target:  Reactive::Observable.once(1), count: 1 )
+      observer[:on_next].should_receive(:call).with(1)
+      observer[:on_complete].should_receive(:call).with(no_args())
+      @s.subscribe(observer)
+    end
+
+  end
+
+
+end

data/spec/observable/interval_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Reactive::Observable do
+  include Lets
+
+  context '#interval(400)' do
+
+    before do
+      @s = Reactive::Observable.interval(400)
+      @s.subscribe(observer)
+    end
+
+    it "does not fire on subscribe" do
+      observer[:on_next].should_not_receive(:call)
+    end
+
+    it "does not fire before interval has passed" do
+      scheduler.advance_by(200)
+    end
+
+    it "fires once interval was reached" do
+      observer[:on_next].should_receive(:call).with(0)
+      scheduler.advance_by(400)
+    end
+
+    it "fires for each interval passed" do
+      [0,1,2,3].each do |i|
+        observer[:on_next].should_receive(:call).times.with(i).ordered
+      end
+      scheduler.advance_by(1600)
+    end
+
+    context "when it has been destroyed" do
+      #didn't manage to garbage collect without using before block.
+      before do
+        remove_instance_variable(:@s)
+        ObjectSpace.garbage_collect
+      end
+      it 'does not fire' do
+        scheduler.advance_by(400)
+      end
+    end
+
+  end
+
+
+end