rrx 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rrx.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Daniel Davis
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,40 @@
+# RRX - Ruby Reactive Extensions
+
+Translated (and in future: rubified) from https://github.com/eilara/Rx.pl
+for more about Reactive Programming see http://channel9.msdn.com/Shows/Going+Deep/Expert-to-Expert-Brian-Beckman-and-Erik-Meijer-Inside-the-NET-Reactive-Framework-Rx
+or http://msdn.microsoft.com/en-us/data/gg577609.aspx
+ 
+
+TODO: 
+* translate tests
+* make them pass
+* documentation
+* syntax sugar
+* go over Array and Enumerable to see what additional methods should have a reactive counterpart 
+* prepare some kickass samples
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rrx'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rrx
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new
+
+task :default => :spec
+task :test => :spec

data/examples/all.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'rrx'
+
+ Reactive::Observable.
+     once(3).
+     merge(
+      Reactive::Observable.once(4)
+     ).
+     subscribe(
+      :on_next => lambda {|v| puts "on_next = #{v}"  },
+      :on_complete => lambda { puts "done"  }
+     )
+
+EventMachine.run do
+
+  Reactive::Observable.interval(100).
+      map {|x| x * 2 }.
+      grep(lambda {|x| x % 3 == 0  }).
+      first(10).
+      push( Reactive::Observable.once("Bye!")  ).
+      subscribe(
+        :on_next => lambda {|v|  puts "#{v}" },
+        :on_complete => lambda { puts "done ticking" }
+      )
+
+
+ Reactive::Observable.interval(1000).
+ merge(
+   Reactive::Observable.interval(500)
+ ).
+ subscribe(
+     :on_next => lambda {|v| puts "tick #{v}" },
+     :on_complete => lambda { puts "done ticking"; EventMachine.stop_event_loop }
+ )
+
+end

data/lib/Reactive/observable.rb

@@ -0,0 +1,58 @@
+module Reactive
+module Observable
+  autoload :Composite, 'reactive/observable/composite'
+  autoload :DoubleWrapper, 'reactive/observable/double_wrapper'
+  autoload :FromProc, 'reactive/observable/from_proc'
+  autoload :Generate, 'reactive/observable/generate'
+  autoload :Merge, 'reactive/observable/merge'
+  autoload :Wrapper, 'reactive/observable/wrapper'
+  autoload :Map, 'reactive/observable/map'
+  autoload :Grep, 'reactive/observable/grep'
+  autoload :First, 'reactive/observable/first'
+  autoload :Push, 'reactive/observable/push'
+  autoload :Skip, 'reactive/observable/skip'
+  autoload :Base, 'reactive/observable/base'
+
+
+  # creation
+
+  def self.once(value)
+    FromProc.new do |observer|
+      observer.on_next(value)
+      observer.on_complete
+      Disposable::Wrapper.new
+    end
+  end
+
+  def self.range(from, size)
+    FromProc.new do |observer|
+      from.upto(from + size) {|i| observer.on_next(i) }
+      observer.on_complete
+      Disposable::Wrapper.new
+    end
+  end
+
+  # from time
+  def self.interval(duration)
+    Generate.new(
+        0,
+        lambda {|x| 1 },
+        lambda {|x| 1 + x },
+        lambda {|x| x },
+        lambda {|x| duration }
+    )
+  end
+
+  def self.from_array(array)
+    FromProc.new do |observer|
+      array.each { |v|
+        observer.on_next(v)
+      }
+      observer.on_complete
+      Disposable::Wrapper.new
+    end
+  end
+
+
+end
+end

data/lib/Reactive/observable/base.rb

@@ -0,0 +1,88 @@
+module Reactive::Observable
+
+  class Base
+
+    class_attribute :attributes
+    self.attributes = []
+
+    def self.add_attributes(*v)
+      defaults = v.last.kind_of?(Hash) ? v.pop.to_a : []
+      v.map! {|x| [x,nil] }
+      self.attributes += v + defaults
+    end
+
+    def self.observer_on_next(&method)
+      observer = Class.new(Reactive::ObserverWrapper) do
+        define_method(:on_next, &method)
+      end
+      const_set(:Observer, observer)
+    end
+
+    delegate :schedule_periodic, :schedule_once, :now, to: :scheduler
+
+
+    def initialize(opts = {})
+      self.class.attributes.each { |name, default|
+        instance_variable_set(:"@#{name}", opts[name] || default)
+      }
+    end
+
+    def observer_args(observer, parent)
+      #base = {:observer => observer, :parent => parent}
+      opts = self.class.attributes.each_with_object({}) do |attr, hash|
+        hash[attr[0]] = instance_variable_get(:"@#{attr[0]}")
+      end
+      [observer, parent, opts]
+    end
+
+    def scheduler
+      @scheduler ||= Reactive::Scheduler.new
+    end
+
+    def subscribe(handlers)
+      [:on_next, :on_error, :on_complete].each {|h| handlers[h] ||= ->(*v) { }  }
+      observer = Reactive::Observer.new(handlers)
+      #???
+      self.subscribe_observer(observer)
+    end
+
+    def subscribe_observer(observer)
+      self.run(observer)
+    end
+
+    ##!!!
+    def maybe_scheduler(arg = nil)
+      arg ? {scheduler => arg} : {}
+    end
+
+    #joining
+
+    def merge(observable)
+      #MultiMerge.new(observables)
+      #observable = observables[0]
+      observable ? Merge.new(o1: self, o2: observable) : MergeNotifications(self)
+    end
+
+    def map(&proc)
+      Map.new(target: self, mapper: proc)
+    end
+
+    def grep(predicate)
+      Grep.new(target: self, predicate: predicate)
+    end
+
+    def first(count = 1)
+      First.new(target: self, count: count)
+    end
+
+    def push(observable)
+      Push.new(o1: self, o2: observable)
+    end
+
+    def skip(count)
+      Skip.new(target: self, count: count)
+    end
+
+  end
+
+end

data/lib/Reactive/observable/composite.rb

@@ -0,0 +1,34 @@
+module Reactive::Observable
+
+  class Composite < Base
+
+    def run(observer)
+      disposable_parent = build_disposable_parent
+      observer_class = self.class.const_get('Observer')
+      observer_wrapper =  observer_class.new(*observer_args(observer, disposable_parent))
+
+      disposables = initial_subscriptions.map {|o|  o.subscribe_observer(observer_wrapper) }
+
+      fill_disposable_parent(disposable_parent, disposables)
+      disposable_parent
+    end
+
+    def fill_disposable_parent(parent, disposables)
+      parent.target = disposables unless parent.target
+    end
+
+    def initial_subscriptions
+      []
+    end
+
+    #def observer_args(observer, parent)
+    #  [observer, parent]
+    #end
+
+    private
+    def build_disposable_parent
+      Reactive::Disposable::Wrapper.new
+    end
+  end
+
+end

data/lib/Reactive/observable/double_wrapper.rb

@@ -0,0 +1,17 @@
+module Reactive
+  module Observable
+    class  DoubleWrapper < Composite
+
+    add_attributes :o1, :o2
+
+    #def initialize(o1, o2)
+    #  @o1, @o2, = o1, o2
+    #end
+
+    def initial_subscriptions
+      [@o1, @o2]
+    end
+
+    end
+  end
+end

data/lib/Reactive/observable/empty.rb

@@ -0,0 +1,7 @@
+module Reactive::Observable
+
+  class Empty
+
+  end
+
+end

data/lib/Reactive/observable/first.rb

@@ -0,0 +1,26 @@
+module Reactive::Observable
+
+  class First < Wrapper
+    add_attributes :count
+
+    class Observer < Reactive::ObserverWrapper
+
+      def initialize(*args)
+        @taken = 0
+        super
+      end
+
+      #??? count is nilled (since it's an attribute), but we might not want it to...
+      #can be less change attribute nilling on unwrap to opt in/out or write unwrap method?
+      #or leave as is because everything is sort of perfect?
+      def on_next(value)
+        @target.on_next(value)
+        @taken += 1
+        on_complete if @taken == @count
+      end
+
+    end
+
+  end
+
+end

data/lib/Reactive/observable/from_proc.rb

@@ -0,0 +1,17 @@
+module Reactive
+
+  module Observable
+
+    class FromProc < Observable::Base
+      def initialize(&proc)
+        @on_subscribe = proc
+      end
+
+      def run(observer)
+        @on_subscribe.call(observer)
+      end
+    end
+
+  end
+
+end

data/lib/Reactive/observable/generate.rb

@@ -0,0 +1,41 @@
+module Reactive
+  module Observable
+    class Generate < Base
+      attr_reader :init_value, :continue_perdicate, :step_action, :result_projection, :inter_step_duration
+
+      def initialize(init_value, continue_perdicate, step_action, result_projection, inter_step_duration)
+        @init_value, @continue_perdicate, @step_action, @result_projection, @inter_step_duration = init_value, continue_perdicate, step_action, result_projection, inter_step_duration
+      end
+
+      def run(observer)
+        is_first = true
+        state = @init_value
+        duration = @inter_step_duration
+        action = @step_action
+        projection = @result_projection
+        continue = @continue_perdicate
+
+        init_duration = duration.call(state)
+        self.schedule_periodic(init_duration, lambda do
+          if is_first
+            is_first = false
+          else
+            state = action.call(state)
+          end
+          result = projection.call(state)
+          observer.on_next(result)
+
+          if continue.call(state)
+            duration.call(state)
+          else
+            observer.on_complete()
+            nil
+          end
+
+        end)
+
+      end
+
+    end
+  end
+end

data/lib/Reactive/observable/grep.rb

@@ -0,0 +1,35 @@
+class Reactive::Observable::Grep < Reactive::Observable::Wrapper
+
+  add_attributes :predicate
+
+  #def initialize(value, predicate)
+  #  @predicate = predicate
+  #  super(value)
+  #end
+
+  #def observer_args(observer, parent)
+  #  [observer, parent, @predicate]
+  #end
+
+  class Observer < Reactive::ObserverWrapper
+    attr_reader :predicate
+
+    #def initialize(value, parent, opts={})
+    #  @predicate = opts[:predicate]
+    #  super(value, parent)
+    #end
+
+    def on_next(value)
+      begin
+        should_pass = @predicate.call(value)
+      rescue Exception => e
+        pp e
+        on_error.call(e)
+      else
+        @target.on_next(value) if should_pass
+      end
+    end
+
+  end
+
+end