rrx 0.0.1

data/spec/observable/push_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Reactive::Observable do
+  include Lets
+
+  context 'timer(2000).push(timer(5000))' do
+    before do
+      pending
+      o1 = Reactive::Observable.timer(2000)
+      o2 = Reactive::Observable.timer(5000)
+      @s = o1.push(o2)
+      subscribe(@s)
+    end
+
+    it 'does not fire before first timer' do
+      observer[:on_next].should_not_receive(:call)
+      advance_by(1000)
+    end
+
+    it 'fires once after first timer runs' do
+      observer[:on_next].should_receive(:call).with(0)
+      advance_by(2001)
+    end
+
+    it 'fires once after first but before the pushed one' do
+      observer[:on_next].should_receive(:call).with(0)
+      advance_by(4001)
+    end
+
+    it 'fires twice once both timers have run' do
+      observer[:on_next].should_receive(:call).exactly(:twice).with(0)
+      advance_by(7001)
+    end
+
+    it 'doesn\'t fire any more after both timers have run' do
+      observer[:on_next].should_receive(:call).exactly(:twice).with(0)
+      advance_by(20001)
+    end
+
+  end
+
+  context 'interval(100).push(interval(222))' do
+    before do
+      o1 = Reactive::Observable.interval(100)
+      o2 = Reactive::Observable.interval(222)
+      @s = o1.push(o2)
+      @s.subscribe(observer)
+    end
+
+    it 'doesn\'t fire on partial interval' do
+      observer[:on_next].should_not_receive(:call)
+      advance_by(99)
+    end
+
+    it 'fires once when first interval passed' do
+      observer[:on_next].should_receive(:call).with(0)
+      advance_by(101)
+    end
+
+    it 'fires for pushed interval, but not for original interval' do
+      observer[:on_next].should_receive(:call).exactly(:twice).with(anything)
+      advance_by(230)
+    end
+  end
+
+
+  context 'when garbage collected' do
+    before do
+      o1 = Reactive::Observable.interval(100)
+      o2 = Reactive::Observable.interval(222)
+      @s = o1.push(o2)
+      @s.subscribe(observer)
+      remove_instance_variable(:@s)
+      ObjectSpace.garbage_collect
+    end
+    it 'unsubscribes' do
+      scheduler.advance_by(230)
+    end
+  end
+
+
+end

data/spec/observable/skip_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Reactive::Observable do
+  include Lets
+
+  context '#skip(3) on list(4..0)' do
+
+    before do
+      @s = Reactive::Observable.from_array([4,3,2,1,0]).skip(3)
+    end
+
+    #TODO send_call..with should accept arguments for each time. in this case 1, 0
+    it {
+      observer[:on_complete] = ->() {}
+      should send_call.exactly(2).times.with(kind_of(Fixnum)).to(observer, :on_next)
+    }
+    it {
+      observer[:on_next] = ->(v) {}
+      should send_call.with(no_args).to(observer, :on_complete)
+    }
+
+    after do
+      @s.subscribe(observer)
+    end
+
+
+  end
+
+
+end

data/spec/observable/timer_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Reactive::Observable do
+  include Lets
+
+  context '#timer(2000)' do
+    before do
+      @s = Reactive::Observable.timer(2000)
+      @s.subscribe(observer)
+    end
+
+    #TODO shared example?
+    it 'doesn\'t fire on subscribe' do
+      observer[:on_next].should_not_receive(:call)
+    end
+
+    it "doesn't fire before timer" do
+      observer[:on_next].should_not_receive(:call)
+    end
+
+    context 'timer has passed' do
+      advance_by(2001, ignore: :on_complete) {
+        should send_call.with(0).to(observer, :on_next)
+      }
+      advance_by(2001, ignore: :on_next) {
+        should send_call.to(observer, :on_complete)
+      }
+    end
+
+    context "timer x2 has passed" do
+      advance_by(4001, ignore: :on_complete) {
+        should send_call.with(0).to(observer, :on_next)
+      }
+      advance_by(4001, ignore: :on_next) {
+        should send_call.to(observer, :on_complete)
+      }
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,177 @@
+require 'rrx'
+
+
+class VirtualScheduler
+  attr_accessor :now
+
+  def initialize
+    restart
+  end
+
+  def schedule_periodic(at, action, wrapper = Reactive::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)
+    add_action(@now + at, action)
+    Reactive::Disposable::Closure.new { remove_action(action) }
+  end
+
+  def add_action(at, action)
+    @actions << [at, action]
+  end
+
+  def remove_action(action)
+    @actions.reject! {|at_ac|  at_ac[1] == action }
+  end
+
+  def sort_actions
+    @actions.sort_by! {|at_ac| at_ac[0] }
+  end
+
+  def advance_by(ms)
+    max = @now + ms
+    while true
+      sort_actions
+      t, action = @actions[0]
+      break if t.nil?
+      break if t > max
+      @now = t
+      remove_action(action)
+      action.call
+    end
+    @now = max
+  end
+
+  def restart
+    @actions = []
+    @now = 0
+  end
+
+end
+
+class SendMessage
+  def initialize(method)
+    @method = method
+  end
+
+  def with(args)
+    @with = args
+    self
+  end
+
+  def exactly(times)
+     @exactly = times
+     self
+  end
+
+  def times
+    self
+  end
+
+  def to(object, attr)
+    @target = object[attr]
+    @name = attr
+    m = @target.should_receive(@method)
+    m = m.exactly(@exactly).times if @exactly
+    m.with(@with) if @with
+    self
+  end
+
+  def matches?(that)
+    true
+  end
+
+  def description
+    "call #{@name}#{ " with #{@with}" if @with }#{ " #{@exactly} times"  if @exactly}"
+  end
+
+end
+
+def send_call()
+  SendMessage.new(:call)
+end
+
+
+#def error
+#  @error ||= []
+#end
+
+def restart
+  scheduler.restart
+end
+
+def advance_and_check_event_counts(events)
+  events.each {|event| advance_and_check_event_count(*event) }
+end
+
+def advance_and_check_event_count(advance_by = nil, e_nxt = 0, e_complete = 0, e_error = 0, opts= {})
+  [[:next_size, e_nxt], [:complete_size, e_complete], [:error_size, e_error]].each do |base, chg|
+    it do
+      expect {
+        instance_eval(&opts[:proc]) if opts[:proc]
+        scheduler.advance_by(advance_by)
+      }.to change(self, base).by(chg)
+    end
+  end
+  #[nxt.size, error.size, complete.size].should == [e_nxt, e_error, e_complete]
+end
+
+def next_size
+  nxt.size
+end
+def error_size
+  error.size
+end
+def complete_size
+  complete.size
+end
+
+
+
+def subscribe(observable)
+  observable.subscribe(
+      :on_next => ->(v) { nxt << v;  },
+      :on_complete => ->() { complete << 1  },
+      :on_error => ->(e) { error << e  }
+  )
+end
+
+
+def advance_by(ms, options = {}, &block)
+  if block
+    case options[:ignore]
+      when :on_next, :on_error
+        before { observer[options[:ignore]] = ->(v) {} }
+      when :on_complete
+        before { observer[:on_complete] = ->() {} }
+    end
+    after {
+      scheduler.advance_by(ms)
+    }
+    it &block
+  else
+    scheduler.advance_by(ms)
+  end
+end
+
+module Lets
+  def self.included(context)
+    context.let(:scheduler) { VirtualScheduler.new }
+    #context.let(:observer) { {on_next: "Double (next)", on_error:  double('error'), on_complete:  double('complete') } }
+    context.let(:observer) { {on_next: double('next'), on_error:  double('error'), on_complete:  double('complete') } }
+
+    context.before do
+      Reactive::Observable::Base.any_instance.stub(:scheduler).and_return(scheduler)
+    end
+  end
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: rrx
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Daniel Davis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: active_support
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! 'Reactive Extensions provide an enumerable-like interface to process
+  temporal data(events) with the eash usually reserved for structural Enumerables '
+email:
+- shoefish@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/all.rb
+- lib/Reactive/observable.rb
+- lib/Reactive/observable/base.rb
+- lib/Reactive/observable/composite.rb
+- lib/Reactive/observable/double_wrapper.rb
+- lib/Reactive/observable/empty.rb
+- lib/Reactive/observable/first.rb
+- lib/Reactive/observable/from_proc.rb
+- lib/Reactive/observable/generate.rb
+- lib/Reactive/observable/grep.rb
+- lib/Reactive/observable/map.rb
+- lib/Reactive/observable/merge.rb
+- lib/Reactive/observable/push.rb
+- lib/Reactive/observable/skip.rb
+- lib/Reactive/observable/wrapper.rb
+- lib/Reactive/observer.rb
+- lib/Reactive/scheduler.rb
+- lib/Reactive/version.rb
+- lib/rrx.rb
+- rrx.gemspec
+- spec/observable/count_spec.rb
+- spec/observable/first_spec.rb
+- spec/observable/interval_spec.rb
+- spec/observable/push_spec.rb
+- spec/observable/skip_spec.rb
+- spec/observable/timer_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/emirikol/rrx
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Ruby Reactive Extensions
+test_files:
+- spec/observable/count_spec.rb
+- spec/observable/first_spec.rb
+- spec/observable/interval_spec.rb
+- spec/observable/push_spec.rb
+- spec/observable/skip_spec.rb
+- spec/observable/timer_spec.rb
+- spec/spec_helper.rb