rubactive 0.0.1

data/.gitignore

@@ -0,0 +1,8 @@
+*.gem
+.bundle
+.yardoc
+coverage
+doc
+Gemfile.lock
+rdoc
+pkg/*

data/.rvmrc

@@ -0,0 +1,2 @@
+rvm_install_on_use_flag=1
+rvm --create use ruby-1.9.2

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Brian Marick
+
+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.rdoc

@@ -0,0 +1,283 @@
+= Rubactive
+
+I had a hard time figuring out what "functional reactive
+programming" and "reactive programming" meant from
+documentation on the web. Implementing it helped. This is
+the implementation. You can tell me if I'm still confused.
+
+Note: a big part of my confusion was because, I believe, the
+terminology used obscures more than it reveals, so I tried
+to pick better names. Again, you'll be the judge of whether
+I succeeded.
+
+The implementation I chose is most closely modeled after
+Flapjax (http://www.flapjax-lang.org/). Their tutorial is
+pretty good, though it uses the conventional names and is
+occasionally obfuscated by having flapjax code mixed up with
+HTML. Still: good job, guys!
+
+Note: my implementation is extremely naive (for example, it
+doesn't even try to deal with "glitching"), and it's missing
+some of the nice utility functions Flapjax has.
+
+= Rubactive
+
+To use Rubactive, you'll need Ruby 1.9. (I use 1.9.2.) Do
+this in irb:
+
+    require 'rubactive'
+    include Rubactive
+
+The idea of reactive programming is that you have values
+that change as a reaction to changes in other values. There
+are two ways to look at such values:
+
+[time-varying values]
+    There's a single value that changes over time. It might
+    be 5 at one moment and 6 at another. That might happen
+    because you explicitly changed it, but it might also
+    change because *some* *other* time-varying value changed
+    and this one reacted to that.
+
+    In Rubactive, such values are of class Rubactive::TimeVaryingValue.
+
+[streams of values]
+    Instead of one value that changes, it can be convenient
+    to think of a stream of distinct values, arriving one at
+    a time. A stream might change because some code added a
+    value to it, or because it reacted to a new value
+    appearing on another stream.
+
+    In Rubactive, such streams are of class
+    Rubactive::DiscreteValueStream.
+
+I used terminology like "a way to look at" and "convenient
+to think of" because there's no huge difference between the
+two classes. They are both thin wrappers (that mainly
+provide different terminology) over a base ReactiveNode
+class (which I haven't bothered to document).
+
+== TimeVaryingValues
+
+The simple way to create a time-varying value is to give it
+a starting value:
+
+    origin = TimeVaryingValue.starting_with(0)
+
+The current value of +origin+ can be found like this:
+
+    origin.current #=> 0
+
+(Note: it's sort of lame that we refer to +origin+ as a
+value but have to use +current+ to get the... value... of
+the... value. Some reactive frameworks work to hide the fact
+that +origin+ isn't really a value, but rather an
+object-containing-a-value. I don't do that.)
+
+We can also create another time-varying value that will
+always be the same as +origin+:
+
+    exactly = TimeVaryingValue.follows(origin)
+    exactly.current #=> 0
+
+Here's a way to see that +exactly+ really does follow
++origin+:
+
+    origin.change_to("dawn!")
+    exactly.current #=> "dawn!"
+
+That's not wildly exciting, so let's have one time-varying
+value be a function of another:
+
+    upper = TimeVaryingValue.follows(origin) { | o | o.upcase }
+    upper.current #=> "DAWN!"
+    origin.change_to("dawn, paul, and sophie")
+    upper.current #=> "DAWN, PAUL, AND SOPHIE" 
+
+(As noted before, it'd be better if time-varying values
+looked like integers, or strings, or whatever, instead of
+objects containing integers, or strings, or whatever. As a
+gesture toward that, I made it so +method_missing+
+constructed new time-varying-values:
+
+    coolness = origin.upcase
+    coolness.current  # => "DAWN, PAUL, AND SOPHIE" 
+    origin.change_to("your name here")
+    coolness.current  # => "YOUR NAME HERE" 
+
+That really doesn't add anything to your understanding, but
+what's the point of programming in Ruby if you can't show
+off?)
+
+There's no reason why time-varying values can't be dependent
+on more than one "origin":
+
+   annoyance = TimeVaryingValue.starting_with(" [that's what she said]")
+   michael = coolness + annoyance
+   # above shorthand equivalent to:
+   #   michael = TimeVaryingValue.follows(coolness, annoyance) do | c, a |
+   #        c + a
+   #   end
+   michael.current #=> "YOUR NAME HERE [that's what she said]"
+   
+   annoyance.change_to(" in bed!")
+   michael.current #=> "YOUR NAME HERE in bed!" 
+
+== DiscreteValueStream
+
+Now let's consider a stream of values, where a new value
+might appear at any instant. (You can probably see how this
+might be useful for modeling user input.) Here's how to
+create a stream that doesn't depend on anything:
+
+    values = DiscreteValueStream.manual
+
+You can put something onto a stream and look at it:
+
+    values.add_value(5)
+    values.most_recent_value   #=> 5
+
+As you might expect, you can have one stream follow another:
+
+    boring_values = DiscreteValueStream.manual
+    excited_values = DiscreteValueStream.follows(boring_values) do | b | 
+        b.upcase + "!"
+    end
+
+   boring_values.add_value("party")
+   excited_values.most_recent_value #=> "PARTY!" 
+
+== The outside world
+
+The "reactive world" is one in which values are tied
+together with relationships created by +follows+. But that
+reactive world is embedded within other code that's not
+reactive. For example, it might be that a change to a
+reactive value should make a user interface control update.
+
+This can be done by handing a callback to the reactive
+value. Here's how a new addition to a value stream can
+affect the non-reactive world:
+
+    excited_values.on_addition do | most_recent |
+       puts "This new value has been added: #{most_recent}"
+    end
+
+    boring_values.add_value("vegetate")
+    # This new value has been added: VEGETATE!
+
+The same can be done with time-varying-values, but the
+method name is different (for clarity):
+
+    tvv = TimeVaryingValue.starting_with(8)
+    tvv.on_change do | current |
+      puts "New value: #{current.inspect}"
+    end
+
+    tvv.change_to("Veterinarians >> human medicine people")
+    New value: "Veterinarians >> human medicine people"
+    
+== An end-to-end-example
+
+Consider a model-view-controller architecture that lets a
+user control a particular hardware setting. The user
+interface displays the current setting, and provides
+controls that lets the user change it by some delta. In a
+typical MVC implementation, the controller takes an active
+role in shuttling events and values between layers of the
+system. But that responsibility could be implemented
+declaratively with reactive values.
+
+Let's begin!
+
+The current hardware setting is a time-varying value:
+
+    hardware_setting = TimeVaryingValue.starting_with(50)
+
+The user's actions can be considered to be a stream of delta
+values:
+
+    deltas = DiscreteValueStream.manual
+
+That stream of deltas should be combined with the hardware
+setting to produce a stream of desired settings:
+
+    user_changes = DiscreteValueStream.follows(deltas) do |delta|
+        delta + hardware_setting.current
+    end
+
+(Alternately, we could be more terse:
+
+    user_changes = deltas + hardware_setting.current
+
+... but that would be showing off.)
+
+Note: I'm not having the +user_changes+ follow the hardware
+settings because independent changes to the hardware don't
+count as *user* changes.
+
+When a user asks for a change, the hardware should be told
+to change. That steps out of the reactive framework, so it
+requires a callback. I'm going to pretend that the callback
+does various things, one of which is to change the
++hardware_setting+ value:
+
+    user_changes.on_addition do |value|
+      # The code talks to the real hardware and also sets the authoritative value:
+      hardware_setting.change_to(value)
+    end
+
+At this point, we've propagated the user's desires
+"downward" (toward the hardware), but we also have to
+propagate the truth about the hardware upward (toward the
+user interface). We could have the user interface directly
+reflect the low-level +hardware_setting+ value, but lets
+decouple things a bit by having the displayed value +follow+
+the +hardware_setting+:
+
+    value_displayed = TimeVaryingValue.follows(hardware_setting)
+
+(There'd presumably be some sort of +on_change+ callback to
+communicate changes to the time-varying value to the
+user-interface control.)
+
+So, now that we've done this wiring, how does it work?
+
+The hardware setting starts at 50, because we told it that's
+the default:
+
+    hardware_setting.current #=> 50
+
+Because the displayed value follows the hardware setting, it
+too is 50:
+
+    value_displayed.current #=> 50
+
+Suppose the user clicks a button, enters a text value, or drags
+a slider---whatever. That provokes code that adds a value to
+the +deltas+ stream. Let's simulate that:
+
+    deltas.add_value(5)
+
+Did that count as a new +user_change+? Yes:
+
+    user_changes.most_recent_value  #=> 55
+
+Did that (via the callback) change the value of the
+hardware setting? Yes:
+
+    hardware_setting.current #=> 55
+
+Was that value reflected up to the user interface? Yes:
+
+    value_displayed.current #=> 55
+
+All this was done declaratively (with a sort of DSL), rather
+than with writing controller methods. That's the promise of
+reactive programming.
+
+== Copyright
+
+Copyright (c) 2012 Brian Marick. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,13 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*test*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+task :rdoc
+     `rdoc README.rdoc lib`

data/lib/rubactive.rb

@@ -0,0 +1,2 @@
+require "rubactive/version"
+require "rubactive/rubactive"

data/lib/rubactive/rubactive.rb

@@ -0,0 +1,254 @@
+require 'forwardable'
+
+# Rubactive provides two kinds of values-that-react-to-changes-in-other-values.
+#
+# Sometimes you want to think of the changing value as being something
+# that "magically" changes over time (typically in reaction to changes
+# in other values). That perspective is implemented by TimeVaryingValue.
+#
+# Sometimes you want to think of a stream of unchanging values that
+# "magically" arrive (often in reaction to values appearing in other
+# streams). That perspective is implemented by DiscreteValueStream. 
+#
+
+
+module Rubactive
+  class ReactiveNode # :nodoc: 
+    # This should probably be a delegate instead of superclass
+    # because the subclasses don't want all of the methods
+    # (but the tests do)
+    private_class_method :new
+
+    def self.follows(*earlier_nodes, &updater)
+      new(*earlier_nodes, &updater)
+    end
+
+    attr_reader :value
+
+    DEFAULT_VALUE = :no_value_at_all
+
+    def initialize(*earlier_nodes, &recalculator)
+      @value = DEFAULT_VALUE
+      @recalculator = recalculator || ->val {val}
+      @later_nodes = []
+      @earlier_nodes = earlier_nodes
+      @change_callback = ->ignored{}
+      tell_earlier_nodes_about_me(earlier_nodes)
+    end
+
+    def tell_earlier_nodes_about_me(earlier_nodes)
+      earlier_nodes.each do |e|
+        e.this_node_is_later_than_you(self) if e.is_a?(ReactiveNode)
+      end
+    end
+
+    def this_node_is_later_than_you(this_node)
+      @later_nodes << this_node
+    end
+
+    def recalculate
+      propagate(@recalculator.call(*just_values(@earlier_nodes)))
+    end
+
+    def value=(new_value)
+      propagate(new_value)
+    end
+
+    # When the value of this variable changes, call the block argument.
+    def on_change(&block)
+      @change_callback = block
+    end
+
+    def propagate(value)
+      @value = value
+      @change_callback.(value)
+      @later_nodes.each do |node|
+        node.recalculate
+      end
+    end
+
+    def method_missing(message, *args)
+      recalculator = lambda do |*just_values|
+        receiver = just_values.shift
+        receiver.send(message, *just_values)
+      end
+      self.class.follows(self, *args, &recalculator)
+    end
+
+    def just_values(args)
+      args.collect do |arg|
+        if arg.is_a?(ReactiveNode)
+          arg.value
+        else
+          arg
+        end
+      end
+    end
+
+    # test_support
+
+    def self.blank
+      follows() {}
+    end
+
+  end
+
+  # A TimeVaryingValue represents a value that might "mysteriously"
+  # change each time you look at it.
+  #
+  # The current value can change in three ways:
+  # 
+  # * Explicitly, via change_to. That's no different than setting an attribute of any
+  #   sort of object.
+  #
+  # * It might have been created to "follow" other time-varying values. In that case,
+  #   it will react to any of their changes by recalculating itself (in a way
+  #   defined when it was created.)
+  #
+  # * It might have been created to follow a DiscreteValueStream. In that case, any
+  #   value added to the stream becomes the time-varying value's current value.
+  #   
+  # There is a different constructor for each of the above cases. In addition, variables
+  # can be implicity created by sending unrecognized messages to other time-varying values. 
+  # 
+  #    origin = TimeVaryingValue.starting_with(5)
+  #    follower = origin + 1
+  #    follower.current #=> 6
+  #    
+  #    origin.change_to(700)
+  #    follower.current #=> 701
+  class TimeVaryingValue < ReactiveNode
+    # Create a value that changes as the values it depends upon change.
+    # 
+    # When any followed variables change, the block is called with their current
+    # values. The result becomes the current value for this TimeVaryingValue.
+    #
+    # Example: 
+    #   verb = TimeVaryingValue.starting_with("vote")
+    #   adverb = TimeVaryingValue.starting_with("early")
+    #   tracker = TimeVaryingValue.follows(verb, adverb) { | v, a | "#{v} #{a}!" }
+    #   tracker.current #=> "vote early!"
+    #   
+    #   adverb.change_to("often") 
+    #   tracker.current #=> "vote often!"
+    #
+    # If no block is given, this value should be following only one other. 
+    # It adopts that other value whenever it changes.
+    #--
+    # Defined here so that I can write special-purpose documentation.
+    def self.follows(*values, &block)
+      super
+    end
+
+    # Create a new TimeVaryingValue.
+    #
+    # Since the returned instance follows nothing, only change_to can
+    # be used to change its value.
+    def self.starting_with(initial_value)
+      follows { initial_value }
+    end
+
+    # Create a time-varying value that follows the latest value in a stream.
+    #
+    # The first argument must be a DiscreteValueStream. Whenever that stream
+    # has a new value added, the time-varying value changes to match. 
+    #
+    # The time-varying value always starts with the given initial_value, even
+    # if stream has previously had some values added to it. 
+    #--
+    # Flapjax startsWith
+    def self.tracks_stream(value_stream, initial_value)
+      retval = follows(value_stream)
+      retval.change_to(initial_value)
+      retval
+    end
+
+    # Retrieve the current value.
+    #
+    # Earlier values are inaccessible.
+    def current; value; end
+
+    # Change the current value.
+    def change_to(new_value); self.value=new_value; end
+
+    def initialize(*earlier_nodes, &recalculator) # :nodoc:
+      super
+      recalculate
+    end
+
+  end
+
+  # A DiscreteValueStream represents a stream of values. When a value is added to the stream,
+  # other DiscreteValueStreams may react if they follow this stream.
+  #
+  # Streams are explicitly created with DiscreteValueStream.manual or
+  # DiscreteValueStream.follows.  In the first case, values are added
+  # only with add_value. In the second, values can also be added in
+  # reaction to the streams being followed.
+  #
+  # Streams can also be implicity created by sending other streams unrecognized messages.
+  # 
+  #    origin = DiscreteValueStream.manual
+  #    follower = origin + 1
+  #
+  # The previous definition of the follower stream is equivalent to this:
+  #
+  #    follower = DiscreteValueStream.follows(origin) { | o | o + 1 }
+  class DiscreteValueStream < ReactiveNode
+    # Create a stream that reacts to one or more other streams.
+    # 
+    # The addition of values to any of the streams will cause the block
+    # to be called with their most recent values. The result is added to
+    # this stream (as with add_value).
+    #
+    # Example: 
+    #   origin = DiscreteValueStream.manual
+    #   follower = DiscreteValueStream.follows(origin) { | o | o+1 }
+    #   origin.add_value(5)
+    #   follower.most_recent_value #=> 6
+    #
+    # If no block is given, this stream should be following only one other stream.
+    # The value just added to that stream is also added to this one.
+    #--
+    # Defined here so that I can write special-purpose documentation.
+    def self.follows(*streams, &block)
+      super
+    end
+
+    # Create an empty value stream
+    # 
+    # Use add_value to insert values into the stream.
+    def self.manual
+      follows {
+        raise "Incorrect use of recalculation in a manual event stream"
+      }
+    end
+
+    # Run a callback when a new value is added.
+    #
+    # This is an interface to the non-reactive world. When a new value is
+    # added (whether with add_value or in reaction to a followed stream),
+    # the callback is called and given that value. The callback will typically
+    # do something with the value, like add it to a GUI.
+    def on_addition(&callback); on_change(&callback); end
+
+
+    # Retrieve last value added to the stream
+    #
+    # Earlier values are inaccessible.
+    #
+    # It is an error to ask for the value of an #empty? stream.
+    def most_recent_value; @value; end
+
+    # Place a new value on the stream
+    def add_value(new_value)    # this?
+      self.value = new_value
+    end
+
+    # True iff no value has ever been added to the stream.
+    def empty?
+      most_recent_value == DEFAULT_VALUE
+    end
+  end
+end
+

data/lib/rubactive/version.rb

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

data/rubactive.gemspec

@@ -0,0 +1,29 @@
+
+$:.push File.expand_path("../lib", __FILE__)
+require "rubactive/version"
+
+Gem::Specification.new do |s|
+  s.name = "rubactive"
+  s.homepage = "http://github.com/marick/rubactive"
+  s.license = "MIT"
+  s.summary = %Q{A basic and perhaps misinformed library for  learning about reactive programming}
+  s.description = %Q{A basic and perhaps misinformed library for learning about reactive programming}
+  s.email = "marick@exampler.com"
+  s.authors = ["Brian Marick"]
+  s.required_ruby_version = '>= 1.9.2'
+  s.version = Rubactive::VERSION
+
+  s.rubyforge_project = "rubactive"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "shoulda", ">= 0"
+  s.add_development_dependency "assert2"
+  s.add_development_dependency "rr"
+  s.add_development_dependency "bundler", "~> 1.0.0"
+  s.add_development_dependency "jeweler", "~> 1.6.4"
+  s.add_development_dependency "test-unit"
+end

data/test/rubactive-end-to-end-ish-tests.rb

@@ -0,0 +1,53 @@
+require 'rubactive'
+require_relative 'testutil'
+
+class RubactiveUseCaseTests < Test::Unit::TestCase
+  include Rubactive
+
+  MIN=0
+  MAX=100
+  DEFAULT=50
+
+  def setup
+    # What our program knows about the current setting.
+    @hardware_setting = TimeVaryingValue.starting_with(DEFAULT)
+
+    # User-initiated deltas to the hardware setting
+    @deltas = DiscreteValueStream.manual
+
+    # Convert a stream of deltas to a stream of actual values
+    @user_changes = DiscreteValueStream.follows(@deltas) do |delta|
+      delta + @hardware_setting.current
+    end
+
+    # Callback to code that manipulates hardware.
+    @user_changes.on_addition do |value|
+      # The code talks to the real hardware and also sets the authoritative value:
+      @hardware_setting.change_to(value)
+    end
+
+    #Pretend this is the value of a slider or something
+    @value_displayed = TimeVaryingValue.follows(@hardware_setting)
+  end
+
+  should "propagate user changes" do
+    @deltas.add_value(5)
+
+    assert_equal(55, @hardware_setting.current)
+    assert_equal(55, @value_displayed.current)
+  end
+
+  should "propagate and obey hardware changes" do
+    @hardware_setting.change_to(80)
+
+    assert_equal(80, @hardware_setting.current)
+    assert_equal(80, @value_displayed.current)
+
+    @deltas.add_value(5)
+
+    assert_equal(85, @hardware_setting.current)
+    assert_equal(85, @value_displayed.current)
+  end
+end
+
+

data/test/rubactive-tests.rb

@@ -0,0 +1,244 @@
+require 'rubactive'
+require_relative 'testutil'
+
+class Fixnum
+  # A useful N-argument method for testing
+  def max3(other1, other2)
+    [self, other1, other2].max
+  end
+end
+
+
+class RubactiveTests < Test::Unit::TestCase
+  include Rubactive
+
+  context "time-varying values" do
+    should "hold values" do
+      v = TimeVaryingValue.starting_with(3)
+      assert_equal(3, v.current)
+      v.change_to(4)
+      assert_equal(4, v.current)
+    end
+
+    context "following" do
+
+      should "allow other time-varying values" do
+        origin = TimeVaryingValue.starting_with(3)
+        destination = TimeVaryingValue.follows(origin) { |o| o + 1}
+        assert_equal(4, destination.current)
+        origin.change_to(4)
+        assert_equal(5, destination.current)
+      end
+
+      should "allow chains" do
+        origin = TimeVaryingValue.starting_with(3)
+        middle = TimeVaryingValue.follows(origin) { |o| o + 1}
+        destination = TimeVaryingValue.follows(middle) { |o| o + 1}
+
+        assert_equal(4, middle.current)
+        assert_equal(5, destination.current)
+
+        origin.change_to(40)
+        assert_equal(41, middle.current)
+        assert_equal(42, destination.current)
+      end
+
+      should "allow discrete value streams" do
+        changes = DiscreteValueStream.manual
+        tracker = TimeVaryingValue.tracks_stream(changes, 88)
+        assert_equal(88, tracker.current)
+        changes.add_value(5)
+        assert_equal(5, tracker.current)
+      end
+    end
+
+    context "implicit creation" do
+
+      should "generates value calculation from method-missing" do
+        origin = TimeVaryingValue.starting_with(8)
+        destination = origin + 1
+        assert_equal(9, destination.current)
+        assert_equal(TimeVaryingValue, destination.class)
+
+        origin.change_to(33)
+        assert_equal(34, destination.current)
+      end
+
+      should "work with multi-argument methods" do
+        assert_equal(3, 1.max3(2, 3))
+
+        origin = TimeVaryingValue.starting_with(2)
+        other = origin * -1
+        final = origin.max3(8, other)
+        assert_equal(8, final.current)
+
+        origin.change_to(100)
+        assert_equal(100, final.current)
+
+        origin.change_to(-222)
+        assert_equal(222, final.current)
+      end
+    end
+  end
+
+  context "discrete value streams" do
+    should "remember their most recent value" do
+      s = DiscreteValueStream.manual
+      s.add_value(33)
+      assert_equal(33, s.most_recent_value)
+    end
+
+    should "start out with a null-like value" do
+      s = DiscreteValueStream.manual
+      assert_equal(:no_value_at_all, s.most_recent_value)
+      assert_true(true, s.empty?)
+    end
+
+    should "be able to create new event streams from old" do
+      stream = DiscreteValueStream.manual
+      transformed = DiscreteValueStream.follows(stream) { |s|
+        s + 1
+      }
+      stream.add_value(33)
+      assert_equal(34, transformed.most_recent_value)
+    end
+
+    should "be able to create streams implicitly" do
+      stream = DiscreteValueStream.manual
+      transformed = stream + 1
+      assert_equal(DiscreteValueStream, transformed.class)
+
+      stream.add_value(33)
+      assert_equal(34, transformed.most_recent_value)
+    end
+  end
+
+  ### Behavior common to both types of value-holders
+  ### Not a public API
+
+  context "Reactive Nodes" do
+    should "take a block that calculates their value" do
+      n = ReactiveNode.blank
+      n.value=5
+      assert_equal(5, n.value)
+    end
+
+    should "be able to depend on other nodes" do
+      before = ReactiveNode.blank
+      before.value = 5
+
+      after = ReactiveNode.follows(before) do |b|
+        1 + b
+      end
+      after.recalculate
+      assert_equal(6, after.value)
+
+      before.value = 88
+      assert_equal(89, after.value)
+    end
+
+    should "be able to depend on a combination of nodes" do
+      a_node = ReactiveNode.blank
+      a_node.value = 1
+
+      b_node = ReactiveNode.blank
+      b_node.value = 10
+
+      captured = 100
+
+      combiner = ReactiveNode.follows(a_node, b_node) do |a,b|
+        a+b+captured
+      end
+
+      combiner.recalculate
+      assert_equal(111, combiner.value)
+
+      a_node.value = 20000
+      assert_equal(20110, combiner.value)
+
+      # unsurprisingly, changing the plain variable triggers no propagation
+      captured = -a_node.value
+      assert_equal(20110, combiner.value)
+
+      b_node.value = 88
+      assert_equal(88, combiner.value)
+    end
+
+    should "follow a variable if no block given" do
+      before = ReactiveNode.blank
+      after = ReactiveNode.follows(before)
+      before.value = 88
+      assert_equal(88, after.value)
+
+    end
+
+    should "be able to generate nodes implicitly" do
+      origin = ReactiveNode.blank
+      origin.value = 8
+      destination = origin + 1
+      destination.recalculate
+      assert_equal(9, destination.value)
+
+      origin.value=33
+      assert_equal(34, destination.value)
+
+      final_destination = destination + origin
+      final_destination.recalculate
+      assert_equal(67, final_destination.value)
+
+      origin.value=1
+      assert_equal(2, destination.value)
+      assert_equal(3, final_destination.value)
+    end
+
+    should "capture many types of value-containing-things" do
+      origin = ReactiveNode.blank
+      other = ReactiveNode.blank
+      other.value = 10
+
+      captured = 100
+      destination = origin + captured + other + 1
+
+      origin.value=1000
+      assert_equal(1111, destination.value)
+
+      captured = 999999  # This does not trigger update - no surprise
+      assert_equal(1111, destination.value)
+
+      # But it also has no effect on any future updates.
+      origin.value=2000
+      assert_equal(2111, destination.value)
+    end
+
+    context "callbacks to update the outside world" do
+
+      should "happen on recalculation" do
+        origin = ReactiveNode.blank
+        destination = ReactiveNode.follows(origin) {|o| o.to_s.upcase.to_sym}
+
+        triggered = false
+        destination.on_change do | value |
+          triggered = value
+        end
+
+        origin.value = :new_value
+
+        assert_equal(:NEW_VALUE, triggered)
+      end
+
+      should "happen on value-setting" do
+        n = ReactiveNode.blank
+
+        triggered = false
+        n.on_change do | value |
+          triggered = value
+        end
+
+        n.value = :new_value
+        assert_equal(:new_value, triggered)
+      end
+    end
+  end
+
+
+end

data/test/testutil.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+require 'rr'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require_relative 'testutil/mock-talk'
+

data/test/testutil/mock-talk.rb

@@ -0,0 +1,76 @@
+class Test::Unit::TestCase
+  include RR::Adapters::TestUnit
+end
+
+# These methods are used to change the flow of control so that the
+# test can state what is to happen before stating what the mock should
+# receive.
+class Test::Unit::TestCase
+  def during(&block)
+    # Use of global needed for current way of handling
+    # listeners:
+    #  listeners_to(@sut).run_methods {...}
+    $what_runs_after_mock_setup = block
+    self
+  end
+
+  def behold!
+    yield
+    @result = $what_runs_after_mock_setup.call
+  end
+
+  def listeners_to(object)
+    klass = object.class.const_get("Listener")
+    any_old_listener = klass.new
+    object.add_listener(any_old_listener)
+
+    # mock(any_old_listener).increase_setting
+    mockable = mock(any_old_listener)
+
+    def mockable.are_sent(&block)
+      instance_eval(&block)
+      $what_runs_after_mock_setup.call
+    end
+    mockable
+  end
+
+  def mocked(n = 1)
+    if (n == 1)
+      one_mock
+    else
+      (0...n).collect do
+        one_mock
+      end
+    end
+  end
+
+  def one_mock
+    core_object = Object.new
+    mock_wrapper = mock(core_object)
+    core_object.define_singleton_method(:is_sent) { mock_wrapper }
+    core_object
+  end
+
+
+  def collaborators(*names)
+    ensure_strings(names).each do | name |
+      result = one_mock()
+      self.instance_variable_set(instance_name(name), result)
+    end
+  end
+  alias_method :collaborator, :collaborators
+
+
+  private
+
+  def ensure_strings(maybe_symbols)
+    maybe_symbols.collect(&:to_s)
+  end
+
+  def instance_name(raw_name)
+    "@" + raw_name.to_s
+  end
+
+
+
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: rubactive
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Brian Marick
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-01 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: &2169222580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2169222580
+- !ruby/object:Gem::Dependency
+  name: assert2
+  requirement: &2169222140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2169222140
+- !ruby/object:Gem::Dependency
+  name: rr
+  requirement: &2169221560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2169221560
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &2169220900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *2169220900
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &2169220240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+  type: :development
+  prerelease: false
+  version_requirements: *2169220240
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: &2169219700 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2169219700
+description: A basic and perhaps misinformed library for learning about reactive programming
+email: marick@exampler.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- lib/rubactive.rb
+- lib/rubactive/rubactive.rb
+- lib/rubactive/version.rb
+- rubactive.gemspec
+- test/rubactive-end-to-end-ish-tests.rb
+- test/rubactive-tests.rb
+- test/testutil.rb
+- test/testutil/mock-talk.rb
+homepage: http://github.com/marick/rubactive
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: rubactive
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A basic and perhaps misinformed library for  learning about reactive programming
+test_files:
+- test/rubactive-end-to-end-ish-tests.rb
+- test/rubactive-tests.rb
+- test/testutil.rb
+- test/testutil/mock-talk.rb
+has_rdoc: