oscillo 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 oscillo.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Evan Tatarka
+
+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,133 @@
+# Oscillo
+
+Based off of functional reactive programming, oscillo gives you a signal that
+represents a value changing over time. You can manipulate signals and combine
+them together in various ways.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'oscillo'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install oscillo
+
+## Usage
+
+### Creating and using signals
+
+Creating a signal is as simple as
+
+    s = Oscillo::Signal.new
+
+You modify the value of the signal with `s << :value` and you get the current
+value of the signal with `s.value`, or `s.val` if you want to save a couple of
+letters.
+
+If you want to give a signal a starting value, you just pass it to the
+constructor.
+
+    s = Oscillo::Signal.new(0)
+
+### Following other signals
+
+If you pass another signal as an argument to `new`, the signal's value will
+follow the other one.
+
+    a = Oscillo::Signal.new
+    b = Oscillo::Signal.new(a)
+
+    a << :value
+    b.val #=> :value
+
+You can pass a block to `new` to modify how the new signal follows the old.
+
+    a = Oscillo::Signal.new(0)
+    b = Oscillo::Signal.new(a) { |v| v * 2 }
+
+    a << 3
+    b.val #=> 6
+
+You can also follow multiple signals at once. The new signal will change if any
+of the signal that you follow changes.
+
+    a = Oscillo::Signal.new(0)
+    b = Oscillo::Signal.new(0)
+    c = Oscillo::Signal.new(a, b) { |v1, v2| v1 + v2 }
+
+    a << 2
+    c.val #=> 2
+    b << 3
+    c.val #=> 5
+
+### Useful methods in the block
+
+The last argument given to the block passed to new is the signal itself. This is
+so you utilize other methods to query the signal and modify it's changed value.
+
+{Oscillo::Signal#abort} aborts the new value change, keeping the old one.
+
+    a = Oscillo::Signal.new
+    b = Oscillo::Signal.new(a) { |v, s| s.abort if v == :bad; v }
+
+    a << :good
+    b.val #=> :good
+    a << :bad
+    b.val #=> :bad
+
+{Oscillo::Signal#source} gives the original signal that caused the cascade of
+changes. This is useful if you are following multiple signals and want to know
+which one actually changed.
+
+    a = Oscillo::Signal.new
+    b = Oscillo::Signal.new
+    c = Oscillo::Signal.new(a, b) do |v1, v2, s|
+      "The last change was to #{s.source.val}"
+    end
+
+    a << 1
+    c.val #=> "The last change was to 1"
+    b << 2
+    c.val #=> "The last change was to 2"
+
+### Combining signals
+
+You can combine signals together in different ways. For example,
+{Oscillo::Combine.either} updates the new signal to the value of whichever was
+the last signal to change.
+
+    a = Oscillo::Signal.new
+    b = Oscillo::Signal.new
+    c = Oscillo::Combine.either(a, b)
+    a << "a changed"
+    c.val #=> "a changed"
+    b << "b changed"
+    c.val #=> "b changed"
+
+See {Oscillo::Combine} for all combination methods.
+
+### Enumerable
+
+A signal can thought of a sequence of values over time. Therefore, {Oscillo::Signal}
+implements a large number of Enumerable's methods. For example,
+
+    a = Oscillo::Signal.new(0)
+    b = a.map { |v| v ** 2 }
+    a << 3
+    b.val #=> 9
+
+See {Oscillo::Enumerable} for all the methods implemented.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,14 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rake/testtask'
+require 'yard'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+YARD::Rake::YardocTask.new(:doc) do |t|
+end
+
+desc "Run tests"
+task default: :test

data/lib/oscillo/bool_signal.rb

@@ -0,0 +1,76 @@
+module Oscillo
+  # A signal that operates on boolean values.
+  class BoolSignal < Signal
+    # (see Signal#initialize)
+    # Defaults to false instead of nil.
+    def initialize(*, &block)
+      @value = false; super
+    end
+
+    # Negates the signal. i.e if the original signal was true, the new signal is
+    # false and vice versa.
+    #
+    # @return [Signal]
+    def not
+      self.class.new(self) { |v| !v }
+    end
+    alias_method '!', :not
+
+    # The new signal is true if all of the given signals are true, otherwise it
+    # is false.
+    #
+    # @param signals [[Signal]]
+    # @return [Signal]
+    def and(*signals)
+      self.class.new(self, *signals) { |*vs, s| vs.all? }
+    end
+    alias_method :&, :and
+
+    # The new signal is true if all of the given signals are false, otherwise it
+    # is true.
+    #
+    # @param signals [[Signal]]
+    # @return [Signal]
+    def nand(*signals)
+      self.and(*signals).not
+    end
+
+    # The new signal is true if any of the given signals are true, otherwise it
+    # is false.
+    #
+    # @param signals [[Signal]]
+    # @return [Signal]
+    def or(*signals)
+      self.class.new(self, *signals) { |*vs, s| vs.any? }
+    end
+    alias_method :|, :or
+
+    # The new signal is true if any of the given signals are false, otherwise it
+    # is false.
+    #
+    # @param signals [[Signal]]
+    # @return [Signal]
+    def nor(*signals)
+      self.or(*signals).not
+    end
+
+    # The new signal is true if only one of the given signals are true,
+    # otherwise it is false.
+    #
+    # @param signal [Signal]
+    # @return [Signal]
+    def xor(signal)
+      self.class.new(self, signal) { |a, b| a ^ b }
+    end
+    alias_method :^, :xor
+
+    # The new signal is true if only one of the given signals are false,
+    # otherwise it is false.
+    #
+    # @param signal [Signal]
+    # @return [Signal]
+    def xnor(signal)
+      self.xor(signal).not
+    end
+  end
+end

data/lib/oscillo/combine.rb

@@ -0,0 +1,44 @@
+module Oscillo
+  # Constructs new signals by combining multiple signals together in different
+  # ways.
+  module Combine
+    # When any of the signals change, update the new signal with the value of
+    # the last changed signal.
+    #
+    # @param signals [[Signal]] the signals to update on
+    # @return [Signal]
+    def self.either(*signals)
+      Signal.new(*signals) do |*vs, s|
+        s.source.val
+      end
+    end
+
+    # Updates the signal when any of the given signals change and the block
+    # evaluates to true. The value is the value of the last changed signal.
+    # @see when_not
+    #
+    # @param signals [[Signal]] the signals to update on
+    # @yield [value] the new value of the last changed signal
+    # @return [Signal]
+    def self.when(*signals, &block)
+      Signal.new(*signals) do |*vs, s|
+        s.abort unless block.(s.source.val)
+        s.source.val
+      end
+    end
+
+    # Updates the signal when any of the given signals change and the block
+    # evaluates to false. The value is the value of the last changed signal.
+    # @see when
+    #
+    # @param signals [[Signal]] the signals to update on
+    # @yield [value] the new value of the last changed signal
+    # @return [Signal]
+    def self.when_not(*signals, &block)
+      Signal.new(*signals) do |*vs, s|
+        s.abort if block.(s.source.val)
+        s.source.val
+      end
+    end
+  end
+end

data/lib/oscillo/enumerable.rb

@@ -0,0 +1,183 @@
+module Oscillo
+  # Adds enumerable-like methods to Signal.
+  module Enumerable
+    NO_ARG = Object.new
+    private_constant :NO_ARG
+
+    # Returns a signal that is the result of running the values of the original
+    # signal through the block.
+    #
+    # @yield [*signals] gives the new values of the signals to the block
+    # @return [Signal]
+    def collect(&block)
+      self.class.new(self) { |*v, s| block.(*v) }
+    end
+    alias_method :map, :collect
+
+    # Returns a signal that changes only when the original signal changes and
+    # the block is not false.
+    # @see #reject
+    #
+    # @yield [value] gives the new value of the signal to the block
+    # @return [Signal]
+    def find_all(&block)
+      self.class.new(self) do |v, s|
+        s.abort unless block.(v); v
+      end
+    end
+    alias_method :select, :find_all
+
+    # Returns a signal that changes only when the original signal changes and
+    # the block is false.
+    # @see #find_all
+    #
+    # @yield [value] give the new value of the signal to the block
+    # @return [Signal]
+    def reject(&block)
+      self.class.new(self) do |v, s|
+        s.abort if block.(v); v
+      end
+    end
+
+    # Passes each value of the signal to the given block. The value of the
+    # resulting signal is true if the block never returns false or nil. If the
+    # block is not given, uses an implicit block of {|value| value} (that is
+    # {#all?} will return true only if none of the signal values were false or
+    # nil.)
+    # @note Only takes in to consideration values from the time the signal was
+    #   created.
+    # @see #any?
+    #
+    # @yield [new_value] give the new value of the signal to the block
+    # @return [Signal<Boolean>]
+    def all?(&block)
+      self.class.new(true, self) do |v, s|
+        v = block.(v) if block_given?
+        s.val & v
+      end
+    end
+
+    # Passes each value of the signal to the given block. The value of the
+    # resulting signal is true if the block ever returns a value other than
+    # false or nil. If the block is not given, uses an implicit block of
+    # {|value| value} (that is {#any?} will return true if at least one of the
+    # signal values were not false or nil.)
+    # @note Only takes in to consideration values from the time the signal was
+    #   created.
+    # @see #all?
+    #
+    # @yield [new_value] give the new value of the signal to the block
+    # @return [Signal<Boolean>]
+    def any?(&block)
+      self.class.new(false, self) do |v, s|
+        s.val | block.(v)
+      end
+    end
+
+    # Take the value from this signal and merges it with the values of the given
+    # signals to form an array.
+    #
+    # @param signals [[Signal]] the other signals to merge in the array
+    # @return [Signal]
+    def zip(*signals)
+      self.class.new(self, *signals) {|*v, s| v }
+    end
+
+    # Equivalent to {Signal#on_change}
+    #
+    # @yield (see Signal#on_change)
+    # @return [Signal]
+    def each(&block)
+      self.on_change(&block)
+    end
+
+    # Returns the number values that the signal has had. If an argument is
+    # given, counts the number of values in the signal, for which equals to
+    # item. If a block is given, counts the number of values yielding a true
+    # value.
+    # @note Only takes in to consideration values from the time the signal was
+    #   created.
+    #
+    # @overload count
+    #   @return number of values that the signal had
+    # @overload count(obj)
+    #   @param obj values to count
+    #   @return number of values equal to obj that the signal had
+    # @overload count
+    #   @yield [value] gives the new value to the block
+    #   @return number of values for which the block evaluates to true
+    def count(obj=NO_ARG, &block)
+      return count_with_arg(obj) unless obj.equal?(NO_ARG)
+      return count_with_block(&block) if block_given?
+
+      self.class.new(0, self) do |v, s|
+        s.val + 1
+      end
+    end
+
+    # Combines all values of the signal by applying a binary operation,
+    # specified by a block or a symbol that names a method or operator. If you
+    # specify a block, then for each value in this signal the block is passed an
+    # accumulator value (memo) the new value. If you specify a symbol instead,
+    # then each new value will be passed to the named method of memo. In either
+    # case, the result becomes the new value for memo.
+    #
+    # @overload inject
+    #   @yield [memo, value] gives the memo and the new value of the signal to the
+    #     block
+    # @overload inject(symbol)
+    #   @param symbol that represents method to call on memo
+    # @overload inject(initial)
+    #   @param initial the start value of the memo
+    #   @yield [memo, value] gives the memo and the new value of the signal to the
+    #     block
+    # @overload inject(initial, symbol)
+    #   @param initial the start value of the memo
+    #   @param symbol that represents method to call on memo
+    # @return [Signal]
+    def inject(*args, &block)
+      if block_given?
+        inject_with_block(*args, &block)
+      else
+        inject_with_sym(*args)
+      end
+    end
+    alias_method :reduce, :inject
+
+    private
+
+    def count_with_arg(obj)
+      self.class.new(0, self) do |v, s|
+        obj == v ? s.val + 1 : s.val
+      end
+    end
+
+    def count_with_block(&block)
+      self.class.new(0, self) do |v, s|
+        block.(v) ? s.val + 1 : s.val
+      end
+    end
+
+    def inject_with_sym(initial=NO_ARG, sym)
+      first_run = true
+      self.class.new(initial, self) do |v, s|
+        if first_run and initial.equal?(NO_ARG)
+          first_run = false; v
+        else
+          s.val.send(sym, v)
+        end
+      end
+    end
+
+    def inject_with_block(initial=NO_ARG, &block)
+      first_run = true
+      self.class.new(initial, self) do |v, s|
+        if first_run and initial.equal?(NO_ARG)
+          first_run = false; v
+        else
+          block.(s.val, v)
+        end
+      end
+    end
+  end
+end

data/lib/oscillo/num_signal.rb

@@ -0,0 +1,96 @@
+module Oscillo
+  # A signal that works on numeric values.
+  class NumSignal < Signal
+    # (see Signal#initialize)
+    # Defaults to 0 instead of nil.
+    def initialize(*, &block)
+      @value = 0; super
+    end
+
+    # The new signal gives the running total of all values of the original
+    # signal.
+    #
+    # @return [Signal]
+    def sum
+      self.inject(:+)
+    end
+
+    # The new signal gives the difference between the previous value and the
+    # current value of the signal.
+    #
+    # @return [Signal]
+    def delta
+      prev = self.val
+      self.class.new(self) do |v, s|
+        v - prev.tap { prev = v }
+      end
+    end
+
+    # The new signal gives the running product of all values of the original
+    # signal.
+    #
+    # @return [Signal]
+    def product
+      self.inject(:*)
+    end
+
+    # The new signal is the sum of the original signal and the given signal.
+    #
+    # @param signal [Signal] the signal to sum
+    # @return [Signal]
+    def plus(signal)
+      self.class.new(self, signal) { |a, b| a + b}
+    end
+    alias_method :+, :plus
+
+    # The new signal is the difference of the original signal and the given
+    # signal.
+    #
+    # @param signal [Signal] the signal to subtract
+    # @return [Signal]
+    def minus(signal)
+      self.class.new(self, signal) { |a, b| a - b }
+    end
+    alias_method :-, :minus
+
+    # The new signal is the product of the original signal and the given
+    # signal.
+    #
+    # @param signal [Signal] the signal to multiply
+    # @return [Signal]
+    def times(signal)
+      self.class.new(self, signal) { |a, b| a * b }
+    end
+    alias_method :*, :times
+
+    # The new signal is the division of the original signal and the given
+    # signal.
+    #
+    # @param signal [Signal] the signal to divide
+    # @return [Signal]
+    def div(signal)
+      self.class.new(self, signal) { |a, b| a / b }
+    end
+    alias_method :/, :div
+
+    # The new signal is the modulus of the original signal and the given
+    # signal.
+    #
+    # @param signal [Signal] the signal to mod
+    # @return [Signal]
+    def mod(signal)
+      self.class.new(self, signal) { |a, b| a % b }
+    end
+    alias_method :%, :mod
+
+    # The new signal is the original signal raised to the power of the given
+    # signal.
+    #
+    # @param signal [Signal] the signal to raise to the power of
+    # @return [Signal]
+    def pow(signal)
+      self.class.new(self, signal) { |a, b| a ** b }
+    end
+    alias_method :**, :pow
+  end
+end

data/lib/oscillo/signal.rb

@@ -0,0 +1,187 @@
+require 'oscillo/enumerable'
+
+module Oscillo
+  # A signal that changes over time. This change can either be explicit through
+  # the use of {#change} or {#<<}, or it can be implicit when any of the signals
+  # that this signal follows changes.
+  #
+  # @author Evan Tatarka <evan@tatarka.me>
+  class Signal
+    include Enumerable
+
+    # Creates a new Signal with an optional initial value, signals to follow,
+    # and block. The block converts the values from any signals that this one
+    # follows to the value of this signal. If no block is given, the value will
+    # be an array of all the values of the signals that it follows (or if it is
+    # just following one signal, the value of that signal).
+    #
+    # @overload initialize(*signals)
+    #   Follows some number of other signals, changing when they change.
+    #   @param signals [Signal] the signals to follow
+    #   @yield [*signals, self] gives the new values of the signals to the block
+    #
+    # @overload initialize(start_value, *signals)
+    #   Starts with an initial value and follows other signals when they change.
+    #   @param start_value the initial value of this signal
+    #   @param signals [Signal] the signals to follow
+    #   @yield [*signals, self] gives the new values of the signals to the block
+    def initialize(*values, &block)
+      @on_change = []
+      @follows = []
+      @followed_by = []
+
+      @block = block || ->(*x, s) { x.size <= 1 ? x.first : x }
+
+      return if values.empty?
+
+      # first may be initial value instead of signal
+      first, *rest = *values
+      if first.is_a?(self.class)
+        follow(*values)
+      else
+        @value = first
+        follow(*rest)
+      end
+    end
+ 
+    # Follows additional signals, changing when those signals change. This is
+    # necessary to define mutually recursive signals.
+    # @note Immediately updates value.
+    #
+    # @param signals [Signal] the signals to follow
+    # @return [self]
+    def follow(*signals)
+      @follows += signals.each { |signal| signal.followed_by(self) }
+      update(self)
+
+      self
+    end
+
+    # Stops following the given signals.
+    # @note Immediately updates value.
+    #
+    # @param signals [Signal] the signals to stop following
+    # @return [self]
+    def dont_follow(*signals)
+      @follows -= signals.each { |signal| signal.not_followed_by(self) } 
+      update(self)
+
+      self
+    end
+
+    # Updates the value if this signal to represent the values of the signals
+    # that it follows. This is called automatically when dependent signals
+    # change so you don't need to call this manually in most cases.
+    #
+    # @param source [Signal] The signal that initialized the update. If not
+    #   passed, then this signal will be the source of the update.
+    def update(source=nil)
+      return if @follows.empty? # nothing to update
+
+      @source = source
+      @aborted = false
+      new_value = @block.(*@follows.map(&:value), self)
+      self.change(new_value) unless @aborted
+    end
+
+    # Returns the current value of the signal
+    # 
+    # @return the current value
+    def value
+      @value
+    end
+    alias_method :val, :value
+
+    # Change the current value of the signal. This will update all signals that
+    # follow this on as well as call all {#on_change} callbacks registered.
+    #
+    # @param new_value the new value of the signal
+    # @return [self]
+    def change(new_value)
+      @value = new_value
+      @on_change.each { |c| c.(new_value) }
+
+      unless self === source
+        @followed_by.each { |f| f.update(source || self) }
+      end
+      @source = nil
+
+      self
+    end
+    alias_method :<<, :change
+
+    # Register a callback that will be called any time the signal value is
+    # changed.
+    #
+    # @yield [value] gives the new value to the block
+    # @return [self]
+    def on_change(&block)
+      @on_change << block
+
+      self
+    end
+
+    # Aborts the change so that the value stays the same, no callbacks
+    # registered by {#on_change} are called, and no dependent signals are
+    # changed. 
+    # @note This should only be called in the block passed to {#initialize}.
+    def abort
+      @aborted = true
+    end
+
+    # The original source of the current run of signal changes. This can be
+    # useful to know which signal caused the change if you are following
+    # multiple signals.
+    # @note This is only defined within the block passed to {#initialize}.
+    #
+    # @return [Signal] the signal that caused the change
+    def source
+      @source
+    end
+
+    # The value of the signal as a string, for convenience.
+    #
+    # @return [String] the signal value
+    def to_s
+      value.to_s
+    end
+
+    # The value of the signal as an integer, for convenience.
+    #
+    # @return [Fixnum] the signal value
+    def to_i
+      value.to_i
+    end
+
+    # The new signal ignores change events when the new value is the same as the
+    # old value.
+    #
+    # @return [Signal]
+    def drop_repeats
+      self.class.new(self) do |v, s|
+        s.abort if s.val == v; v
+      end
+    end
+
+    # Updates the new signal to the value of this signal any time the value of
+    # sample changes.
+    #
+    # @param sample [Signal] the signal to update on
+    # @return [Signal]
+    def sample_on(sample)
+      Signal.new(self.val, sample) do |v, s|
+        self.val
+      end
+    end
+
+    protected
+
+    def followed_by(follower)
+      @followed_by << follower
+    end
+
+    def not_followed_by(follower)
+      @followed_by.delete(follower)
+    end
+  end
+end

data/lib/oscillo/version.rb

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

data/lib/oscillo.rb

@@ -0,0 +1,8 @@
+require "oscillo/version"
+
+module Oscillo
+  require 'oscillo/signal'
+  require 'oscillo/combine'
+  require 'oscillo/bool_signal'
+  require 'oscillo/num_signal'
+end

data/oscillo.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/oscillo/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Evan Tatarka"]
+  gem.email         = ["evan@tatarka.me"]
+  gem.description   = %q{Modify and respond to signals, inspired by functional reactive programming}
+  gem.summary       = %q{Modify and respond to signals, inspired by functional reactive programming}
+  gem.homepage      = "http://www.github.com/evant/oscillo"
+
+  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.name          = "oscillo"
+  gem.require_paths = ["lib"]
+  gem.version       = Oscillo::VERSION
+
+  gem.add_development_dependency 'yard', '~> 0.8.3'
+  gem.add_development_dependency 'redcarpet', '~> 2.2.2'
+end

data/test/test_bool_signal.rb

@@ -0,0 +1,44 @@
+require 'test/unit'
+require 'oscillo'
+
+class TestBoolSignal < Test::Unit::TestCase
+  include Oscillo
+
+  def self.test_bool(method, expected)
+    a = BoolSignal.new
+    b = BoolSignal.new
+    c = a.send(method, b)
+
+    define_method("test_#{method}") do
+      i = 0
+      [true, false].each do |a_val|
+        [true, false].each do |b_val|
+          a << a_val; b << b_val
+          assert_equal expected[i], c.val
+          i += 1
+        end
+      end
+    end
+  end
+
+  def test_default_value
+    assert_equal false, BoolSignal.new.val
+  end
+  
+  def test_not
+    a = BoolSignal.new
+    b = a.not
+
+    a << true
+    assert_equal false, b.val
+    a << false
+    assert_equal true, b.val
+  end
+
+  test_bool :and,  [true,  false, false, false]
+  test_bool :nand, [false, true,  true,  true ]
+  test_bool :or,   [true,  true,  true,  false]
+  test_bool :nor,  [false, false, false, true ]
+  test_bool :xor,  [false, true,  true,  false]
+  test_bool :xnor, [true,  false, false, true ]
+end

data/test/test_combine.rb

@@ -0,0 +1,47 @@
+require 'test/unit'
+require 'oscillo'
+
+class TestCombine < Test::Unit::TestCase
+  include Oscillo
+
+  def test_either
+    a = Signal.new
+    b = Signal.new
+    c = Combine::either(a, b)
+
+    a << :a
+    assert_equal :a, c.val
+    b << :b
+    assert_equal :b, c.val
+  end
+
+  def test_when
+    a = Signal.new
+    b = Signal.new
+    c = Combine::when(a, b) { |x| x != :bad }
+
+    a << :a
+    assert_equal :a, c.val
+    a << :bad
+    assert_equal :a, c.val
+    b << :b
+    assert_equal :b, c.val
+    b << :bad
+    assert_equal :b, c.val
+  end
+
+  def test_when_not
+    a = Signal.new
+    b = Signal.new
+    c = Combine::when_not(a, b) { |x| x == :bad }
+
+    a << :a
+    assert_equal :a, c.val
+    a << :bad
+    assert_equal :a, c.val
+    b << :b
+    assert_equal :b, c.val
+    b << :bad
+    assert_equal :b, c.val
+  end
+end

data/test/test_enumerable.rb

@@ -0,0 +1,137 @@
+require 'test/unit'
+require 'oscillo'
+
+class TestEnumerable < Test::Unit::TestCase
+  include Oscillo
+
+  def test_collect
+    a = Signal.new(0)
+    b = a.map { |x| x * 2 }
+
+    a << 2
+    assert_equal 2 * 2, b.val
+  end
+
+  def test_find_all
+    a = Signal.new
+    b = a.find_all { |x| x == :good }
+
+    a << :good
+    assert_equal :good, b.val
+    a << :bad
+    assert_equal :good, b.val
+  end
+
+  def test_select
+    test_find_all
+  end
+
+  def test_reject
+    a = Signal.new
+    b = a.reject { |x| x == :bad }
+
+    a << :good
+    assert_equal :good, b.val
+    b << :bad
+    assert_equal :bad, b.val
+  end
+
+  def test_all?
+    a = Signal.new(:good)
+    b = a.all? { |x| x == :good }
+
+    assert b.val
+    a << :bad
+    assert !b.val
+    a << :good
+    assert !b.val
+  end
+
+  def test_any?
+    a = Signal.new
+    b = a.any? { |x| x == :good }
+
+    a << :bad
+    assert !b.val
+    a << :good
+    assert b.val
+    a << :bad
+    assert b.val 
+  end
+
+  def test_zip
+    a = Signal.new
+    b = Signal.new
+    c = a.zip(b)
+
+    a << :a
+    b << :b
+    assert_equal [:a, :b], c.val
+  end
+
+  def test_inject_with_block
+    a = Signal.new("a")
+    b = a.inject { |str, value| str + value }
+
+    assert_equal "a", b.val
+    a << "b"
+    assert_equal "ab", b.val
+  end
+
+  def test_inject_with_symbol
+    a = Signal.new(0)
+    b = a.inject(:+)
+
+    a << 1
+    assert_equal 1, b.val
+    a << 2
+    assert_equal 3, b.val
+  end
+
+  def test_inject_with_initial_and_block
+    a = Signal.new(:a)
+    b = a.inject([]) { |array, value| array << value }
+
+    assert_equal [:a], b.val
+    a << :b
+    assert_equal [:a, :b], b.val
+  end
+
+  def test_inject_with_initial_and_symbol
+    a = Signal.new(1)
+    b = a.inject(0, :+)
+
+    assert_equal 1, b.val
+    a << 2
+    assert_equal 3, b.val
+  end
+
+  def test_count
+    a = Signal.new(:a)
+    b = a.count
+
+    assert_equal 1, b.val
+    a << :b
+    assert_equal 2, b.val
+  end
+
+  def test_count_with_arg
+    a = Signal.new
+    b = a.count(:good)
+
+    a << :good
+    assert_equal 1, b.val
+    a << :bad
+    assert_equal 1, b.val
+  end
+
+  def test_count_with_block
+    a = Signal.new
+    b = a.count { |x| x == :good }
+
+    a << :good
+    assert_equal 1, b.val
+    a << :bad
+    assert_equal 1, b.val
+  end
+end

data/test/test_num_signal.rb

@@ -0,0 +1,96 @@
+require 'test/unit'
+require 'oscillo'
+
+class TestNumSignal < Test::Unit::TestCase
+  include Oscillo
+
+  def test_default_value
+    assert_equal 0, NumSignal.new.val
+  end
+
+  def test_sum
+    a = NumSignal.new(0)
+    b = a.sum
+
+    a << 1
+    assert_equal 1, b.val
+    a << 2
+    assert_equal 3, b.val
+  end
+
+  def test_delta
+    a = NumSignal.new(0)
+    b = a.delta
+
+    a << 5
+    assert_equal 5, b.val
+    a << 2
+    assert_equal(-3, b.val)
+    a << 4
+    assert_equal 2, b.val
+  end
+
+  def test_product
+    a = NumSignal.new(1)
+    b = a.product
+
+    a << 2
+    assert_equal 2, b.val
+    a << 3
+    assert_equal 6, b.val
+  end
+
+  def test_plus
+    a = NumSignal.new
+    b = NumSignal.new
+    c = a + b
+
+    a << 1; b << 2
+    assert_equal 3, c.val
+  end
+
+  def test_minus
+    a = NumSignal.new
+    b = NumSignal.new
+    c = a - b
+
+    a << 5; b << 2
+    assert_equal 3, c.val
+  end
+
+  def test_mult
+    a = NumSignal.new
+    b = NumSignal.new
+    c = a * b
+
+    a << 2; b << 3
+    assert_equal 6, c.val
+  end
+
+  def test_div
+    a = NumSignal.new
+    b = NumSignal.new(1) # Prevent division by 0
+    c = a / b
+
+    a << 6; b << 3
+    assert_equal 2, c.val
+  end
+
+  def test_mod
+    a = NumSignal.new
+    b = NumSignal.new(1) # Prevent division by 0
+    c = a % b
+
+    a << 12; b << 5
+    assert_equal 2, c.val
+  end
+
+  def test_pow
+    a = NumSignal.new
+    b = NumSignal.new
+    c = a ** b
+
+    a << 2; b << 3
+    assert_equal 8, c.val
+  end
+end

data/test/test_signal.rb

@@ -0,0 +1,145 @@
+require 'test/unit'
+require 'oscillo'
+
+class TestSignal < Test::Unit::TestCase
+  include Oscillo
+
+  def test_initial_value
+    assert_equal :test, Signal.new(:test).val
+  end
+
+  def test_change_value
+    a = Signal.new
+    a << :test
+
+    assert_equal :test, a.val
+  end
+
+  def test_follows
+    a = Signal.new
+    b = Signal.new(a)
+
+    a << :test
+    assert_equal :test, b.val
+  end
+
+  def test_follows_initial_value
+    a = Signal.new(:a)
+    b = Signal.new(a)
+    
+    assert_equal :a, b.val
+  end
+
+  def test_follows_with_block
+    a = Signal.new(0)
+    b = Signal.new(a) { |x| x * 2 }
+
+    a << 2
+    assert_equal 2 * 2, b.val
+  end
+
+  def test_follows_initial_value_with_block
+    a = Signal.new(2)
+    b = Signal.new(a) { |x| x * 2 }
+
+    assert_equal 2 * 2, b.val
+  end
+
+  def test_follows_multiple
+    a = Signal.new
+    b = Signal.new
+    c = Signal.new(a, b)
+
+    a << :test1
+    b << :test2
+    assert_equal [:test1, :test2], c.val
+  end
+
+  def test_follows_multiple_with_block
+    a = Signal.new(0)
+    b = Signal.new(0)
+    c = Signal.new(a, b) { |x, y| x + y }
+
+    a << 2
+    b << 3
+    assert_equal 2 + 3, c.val
+  end
+
+  def test_abort_follows
+    a = Signal.new
+    b = Signal.new(a) { |x| b.abort if x == :bad; x }
+
+    a << :good
+    assert_equal :good, b.val
+    a << :bad
+    assert_equal :good, b.val
+  end
+
+  def test_chained_follows
+    a = Signal.new
+    b = Signal.new(a)
+    c = Signal.new(b)
+
+    a << :test
+    assert_equal :test, b.val
+    assert_equal :test, c.val
+  end
+
+  def test_recursive_follows
+    a = Signal.new
+    b = Signal.new(a)
+
+    # should not cause a SystemStackError
+    a.follow(b)
+
+    a << :test_a
+    assert_equal :test_a, b.val
+    b << :test_b
+    assert_equal :test_b, a.val
+  end
+
+  def test_dont_follow
+    a = Signal.new
+    b = Signal.new(a)
+    b.dont_follow(a)
+
+    a << :test
+    assert :test != b.val
+  end
+                            
+  def test_on_change
+    a = Signal.new(:a)
+    changes = 0
+    a.on_change { changes += 1 }
+
+    assert_equal 0, changes
+    a << :a1
+    assert_equal 1, changes
+  end
+
+  def test_sample_on
+    a = Signal.new(:start)
+    b = Signal.new
+    c = a.sample_on(b)
+
+    a << :new
+    assert_equal :start, c.val
+    b << :changed
+    assert_equal :new, c.val
+  end
+
+  def test_drop_repeats
+    a = Signal.new
+    b = a.drop_repeats
+
+    changes = 0
+    b.on_change { changes += 1 }
+
+    a << :a
+    assert_equal 1, changes
+    a << :a
+    assert_equal 1, changes
+    a << :b
+    assert_equal 2, changes
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: oscillo
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Evan Tatarka
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &13298160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.3
+  type: :development
+  prerelease: false
+  version_requirements: *13298160
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: &13297620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.2.2
+  type: :development
+  prerelease: false
+  version_requirements: *13297620
+description: Modify and respond to signals, inspired by functional reactive programming
+email:
+- evan@tatarka.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/oscillo.rb
+- lib/oscillo/bool_signal.rb
+- lib/oscillo/combine.rb
+- lib/oscillo/enumerable.rb
+- lib/oscillo/num_signal.rb
+- lib/oscillo/signal.rb
+- lib/oscillo/version.rb
+- oscillo.gemspec
+- test/test_bool_signal.rb
+- test/test_combine.rb
+- test/test_enumerable.rb
+- test/test_num_signal.rb
+- test/test_signal.rb
+homepage: http://www.github.com/evant/oscillo
+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.11
+signing_key: 
+specification_version: 3
+summary: Modify and respond to signals, inspired by functional reactive programming
+test_files:
+- test/test_bool_signal.rb
+- test/test_combine.rb
+- test/test_enumerable.rb
+- test/test_num_signal.rb
+- test/test_signal.rb
+has_rdoc: