frappuccino 0.0.1 → 0.2.0

data/lib/frappuccino/stream/drop.rb

@@ -0,0 +1,18 @@
+module Frappuccino
+  class Drop < Stream
+    def initialize(source, n)
+      source.add_observer(self)
+
+      @dropped = 0
+      @n = n
+    end
+
+    def update(event)
+      @dropped += 1
+
+      if @dropped > @n
+        occur(event)
+      end
+    end
+  end
+end

data/lib/frappuccino/stream/map.rb

@@ -0,0 +1,12 @@
+module Frappuccino
+  class Map < Stream
+    def initialize(source, &blk)
+      @block = blk
+      source.add_observer(self)
+    end
+
+    def update(event)
+      occur(@block.call(event))
+    end
+  end
+end

data/lib/frappuccino/stream/scan.rb

@@ -0,0 +1,15 @@
+module Frappuccino
+  class Scan < Stream
+    def initialize(source, zero, &blk)
+      @last = zero
+      @block = blk
+
+      source.add_observer(self)
+    end
+
+    def update(value)
+      @last = @block.call(@last, value)
+      occur(@last)
+    end
+  end
+end

data/lib/frappuccino/stream/select.rb

@@ -0,0 +1,14 @@
+module Frappuccino
+  class Select < Stream
+    def initialize(source, &blk)
+      @block = blk
+      source.add_observer(self)
+    end
+
+    def update(event)
+      if @block.call(event)
+        occur(event)
+      end
+    end
+  end
+end

data/lib/frappuccino/stream/take.rb

@@ -0,0 +1,16 @@
+module Frappuccino
+  class Take < Stream
+    def initialize(source, n)
+      @n = n
+      @length = 0
+      source.add_observer(self)
+    end
+
+    def update(value)
+      if @length < @n
+        occur(value)
+        @length += 1
+      end
+    end
+  end
+end

data/lib/frappuccino/stream/zip.rb

@@ -0,0 +1,26 @@
+module Frappuccino
+  class Zip < Stream
+    def initialize(left, right)
+      @left_buffer = []
+      @right_buffer = []
+      left.add_observer(self, :left_update)
+      right.add_observer(self, :right_update)
+    end
+
+    def left_update(event)
+      if @right_buffer.length > 0
+        occur([event, @right_buffer.shift])
+      else
+        @left_buffer << event
+      end
+    end
+
+    def right_update(event)
+      if @left_buffer.length > 0
+        occur([@left_buffer.shift, event])
+      else
+        @right_buffer << event
+      end
+    end
+  end
+end

data/lib/frappuccino/version.rb

@@ -0,0 +1,3 @@
+module Frappuccino
+  VERSION = "0.2.0"
+end

data/test/drop_test.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+
+describe "drop" do
+  it "ignores the first n events" do
+    button = CounterButton.new
+    stream = Frappuccino::Stream.new(button)
+    dropped_stream = to_array(stream.drop(3))
+
+    5.times { button.push }
+    assert_equal 2, dropped_stream.length
+    assert_equal [3, 4], dropped_stream
+  end
+end

data/test/map_test.rb

@@ -0,0 +1,80 @@
+require 'test_helper'
+
+describe "map" do
+  it "can take callbacks" do
+    button = Button.new
+
+    stream = Frappuccino::Stream.new(button)
+
+    filtered_stream = stream
+                        .map{|event| 1 }
+
+    count = 0
+
+    filtered_stream.on_value do |event|
+      count += event
+    end
+
+    button.push
+    button.push
+    button.push
+
+    assert_equal 3, count
+  end
+
+  it "maps events to values" do
+    plus_button = PlusOneButton.new
+    minus_button = MinusOneButton.new
+
+    stream_one = Frappuccino::Stream.new(plus_button)
+    stream_two = Frappuccino::Stream.new(minus_button)
+
+    merged_stream = Frappuccino::Stream.merge(stream_one, stream_two)
+    mapped_stream = to_array(merged_stream.map(:+ => 1, :- => -1, :default => 0))
+
+    assert_equal [], mapped_stream
+
+    plus_button.push
+    assert_equal [1], mapped_stream
+
+    minus_button.push
+    assert_equal [1, -1], mapped_stream
+  end
+
+  it "respects the default value of the hash" do
+    plus_button = PlusOneButton.new
+    minus_button = MinusOneButton.new
+
+    stream_one = Frappuccino::Stream.new(plus_button)
+    stream_two = Frappuccino::Stream.new(minus_button)
+
+    merged_stream = Frappuccino::Stream.merge(stream_one, stream_two)
+    mapped_stream = to_array(merged_stream.map(:default => 1))
+
+    assert_equal [], mapped_stream
+
+    plus_button.push
+    minus_button.push
+    assert_equal [1, 1], mapped_stream
+  end
+end
+
+describe "collect" do
+  it "is a synonym for #map" do
+    stream = Frappuccino::Stream.new(nil)
+
+    map = stream.collect{|event| 1 }
+
+    assert_kind_of Frappuccino::Map, map
+  end
+end
+
+describe "#map_stream" do
+  it "is a synonym for #map" do
+    stream = Frappuccino::Stream.new(nil)
+
+    map = stream.map_stream(:default => 1)
+
+    assert_kind_of Frappuccino::Map, map
+  end
+end

data/test/merge_test.rb

@@ -0,0 +1,53 @@
+require 'test_helper'
+
+describe "merging steams" do
+  it "produces one stream with both sets of events" do
+    button_one = Button.new
+    button_two = Button.new
+
+    stream_one = Frappuccino::Stream.new(button_one)
+    stream_two = Frappuccino::Stream.new(button_two)
+    merged_stream = to_array(Frappuccino::Stream.merge(stream_one, stream_two))
+
+    button_one.push
+    button_two.push
+
+    assert_equal 2, merged_stream.length
+  end
+
+  it "+1/-1" do
+    plus_button = PlusOneButton.new
+    minus_button = MinusOneButton.new
+
+    stream_one = Frappuccino::Stream.new(plus_button)
+    stream_two = Frappuccino::Stream.new(minus_button)
+
+    merged_stream = Frappuccino::Stream.merge(stream_one, stream_two)
+    counter = merged_stream
+              .map do |event|
+                case event
+                when :+
+                  1
+                when :-
+                  -1
+                else
+                  0
+                end
+              end
+              .inject(0) {|sum, n| sum + n }
+
+    assert_equal 0, counter.now
+
+    plus_button.push
+    assert_equal 1, counter.now
+
+    minus_button.push
+    assert_equal 0, counter.now
+
+    2.times { minus_button.push }
+    assert_equal(-2, counter.now)
+
+    4.times { plus_button.push }
+    assert_equal 2, counter.now
+  end
+end

data/test/mvp_test.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+
+require 'frappuccino'
+
+describe "MVP interaction" do
+  it "can subscribe to an event stream" do
+    button = Button.new
+    stream = Frappuccino::Stream.new(button)
+
+    counter = stream
+              .map {|event| event == :pushed ? 1 : 0 }
+              .inject(0) {|sum, n| sum + n }
+
+    assert_equal 0, counter.now
+
+    3.times { button.push }
+    assert_equal 3, counter.now
+
+    button.push
+    assert_equal 4, counter.now
+  end
+end

data/test/not_implemented_test.rb

@@ -0,0 +1,18 @@
+require 'test_helper'
+
+describe "not implemented methods" do
+  [:all?,
+   :any?,
+   :chunk,
+   :cycle,
+   :find,
+   :detect,
+  ].each do |m|
+    it "#{m} is not implemented because it's nonsensical" do
+      assert_raises(NotImplementedError) do
+        stream = Frappuccino::Stream.new(nil)
+        stream.send(m)
+      end
+    end
+  end
+end

data/test/on_value_test.rb

@@ -0,0 +1,75 @@
+require 'test_helper'
+
+describe "#on_value" do
+  it "calls the block on a value" do
+    button = Button.new
+    stream = Frappuccino::Stream.new(button)
+
+    event = false
+
+    stream.on_value do |value|
+      event = value
+    end
+
+    button.push
+
+    assert_equal :pushed, event, "#on_value did not call back."
+  end
+
+  it "allows for multiple callbacks per Stream" do
+    button = Button.new
+    stream = Frappuccino::Stream.new(button)
+
+    callback1 = false
+    callback2 = false
+
+    stream.on_value do |value|
+      callback1 = value
+    end
+
+    stream.on_value do |value|
+      callback2 = value
+    end
+
+    button.push
+
+    assert_equal :pushed, callback1, "#on_value did not call first callback"
+    assert_equal :pushed, callback2, "#on_value did not call second callback"
+  end
+
+  it "works with mapped Streams" do
+    button = Button.new
+    stream = Frappuccino::Stream.new(button)
+
+    callback = false
+
+    stream.map { |val| :true }.on_value do |val|
+      callback = val
+    end
+
+    button.push
+
+    assert_equal :true, callback, "#on_value did not call back."
+  end
+
+  it "works with filtered Streams" do
+    button = Button.new
+    stream = Frappuccino::Stream.new(button)
+
+    callback = false
+    should = true
+
+    stream.select { |val| should }.on_value do |val|
+      callback = val
+    end
+
+    button.push
+    assert_equal :pushed, callback, "#on_value did not call back."
+
+    should = false
+    callback = :didnot
+    button.push
+
+    assert_equal :didnot, callback, "#on_value did call back."
+  end
+end

data/test/property_test.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+
+describe "Property" do
+  describe "#now" do
+    it "returns the current 'last' value of the Stream" do
+      button = Button.new
+      stream = Frappuccino::Stream.new(button)
+      stepper = Frappuccino::Property.new(:not_pushed, stream)
+
+      button.push
+      assert_equal :pushed, stepper.now
+    end
+
+    describe "when the input Stream is empty" do
+      it "returns the zero value" do
+        stream = Frappuccino::Stream.new(Object.new)
+        stepper = Frappuccino::Property.new("zero", stream)
+        assert_equal "zero", stepper.now
+      end
+    end
+  end
+end

data/test/scan_test.rb

@@ -0,0 +1,14 @@
+require 'test_helper'
+
+describe "scan" do
+  it "returns a stream where every element is the result of the passed block applied to the last result and the current element" do
+    button =  Button.new
+    stream = Frappuccino::Stream.new(button)
+    count_stream = to_array(stream.scan(0) { |last, current|
+      last + 1
+    })
+
+    5.times { button.push }
+    assert_equal [1,2,3,4,5], count_stream
+  end
+end

data/test/select_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+describe "#select" do
+  it "properly filters events from the stream" do
+    points = Points.new
+    button = Button.new
+
+    stream = Frappuccino::Stream.new(points, button)
+
+    filtered_stream = to_array(stream.select{|event| event == :POINTS! })
+
+    9.times { points.POINTS! }
+    9.times { button.push }
+
+    assert_equal 9, filtered_stream.length
+    assert_equal true, filtered_stream.all? { |event| event == :POINTS! }
+  end
+
+  it "has #on_value" do
+    points = Points.new
+    button = Button.new
+
+    stream = Frappuccino::Stream.new(points, button)
+
+    filtered_stream = stream
+                        .select{|event| event == :POINTS! }
+
+    count = 0
+
+    filtered_stream.on_value do |event|
+      count += 1
+    end
+
+    points.POINTS!
+    points.POINTS!
+    button.push
+
+    assert_equal 2, count
+  end
+end