Ninju-streams 1.0

data/README

@@ -0,0 +1,23 @@
+== Description
+
+Streams is designed to be a lightweight streams processing library written in Ruby. I intend to keep this very small (infact, it's unlikely to change at all), and have added most common methods to make it immediately useable.
+
+== Example 
+
+require 'streams'
+
+class Stream
+  def sieve
+    Stream.new( head ) { tail.select { | n | n % head > 0 }.sieve }
+  end
+end
+
+module Math
+  PRIMES = 2.enumerate.sieve
+end
+
+>> Math::PRIMES.at( 30 )
+=> 127
+
+>> Math::PRIMES.select { | n | n > 100 }.take( 50 )
+=> [101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379]

data/Rakefile

@@ -0,0 +1,32 @@
+require "rubygems"
+require "rake"
+require "echoe"
+
+Echoe.new( "streams", "1.0" ) do | p |
+  p.description = ""
+  p.url = "http://github.com/Ninju/streams"
+  p.author = "Alex Watt"
+  p.email = "alex.watt@me.com"
+  p.ignore_pattern = []
+  p.development_dependencies = []
+end
+
+task :default => "spec:run"
+
+
+namespace :spec do
+  task :run do
+    system( "spec spec/" )
+  end
+
+  task :doc do
+    system( "spec spec/ --format specdoc" )
+  end
+
+  task :coverage do
+    system( "rcov spec/*_spec.rb" )
+    system( "open coverage/index.html" )
+  end
+end
+
+task :spec => "spec:run"

data/lib/streams.rb

@@ -0,0 +1,156 @@
+class Stream
+  attr_reader :head, :delayed_tail
+
+  def initialize( head = nil, &block )
+    @head = head
+    @delayed_tail = block || head && Proc.new { Stream.new }
+  end
+
+  def tail
+    @tail ||= delayed_tail && delayed_tail.call
+  end
+
+  def empty?
+    head.nil?
+  end
+
+  def size
+    return 0 if empty?
+    1 + tail.size
+  end
+
+  def each( &block )
+    return if empty?
+    block.call( head )
+    tail.each( &block )
+  end
+
+  def map( &block )
+    return self if empty?
+    Stream.new( block.call( head ) ) { tail.map( &block ) }
+  end
+  
+  def select( &block )
+    return self if empty?
+    
+    if block.call( head )
+      return Stream.new( head ) { tail.select( &block ) }
+    end
+
+    tail.select( &block )
+  end
+
+  def reject( &block )
+    select do | element |
+      !block.call( element )
+    end
+  end
+
+  def merge( other )
+    return self if other.empty?
+    return other if self.empty?
+    Stream.new( head + other.head ) { tail.merge( other.tail ) }
+  end
+  
+  def append( other )
+    return self if other.empty? 
+    return other if empty?
+    Stream.new( head ) { tail.append( other ) }
+  end
+
+  def take( n )
+    return Stream.new if empty? || n.zero?
+    return Stream.new( head ) if n == 1
+    Stream.new( head ) { tail.take( n - 1 ) }
+  end
+
+  def at( n )
+    raise ArgumentError, "Index out of bounds" if empty? && n >= 0
+    return head if n.zero?
+    tail.at( n - 1 )
+  end
+
+  def drop( n )
+    return self if n.zero?
+    return Stream.new if empty?
+    tail.drop( n - 1 )
+  end
+
+  def uniq
+    return self if empty?
+    Stream.new( head ) { tail.select { | element | element != head }.uniq }
+  end
+
+  def last
+    return nil if empty?
+    return head if tail.empty?
+    tail.last
+  end
+
+  def to_a
+    return [] if empty?
+    [ head ] + tail.to_a
+  end
+
+  def join( separator = "" )
+    return "" if empty?
+    return head.to_s if tail.empty?
+    head.to_s + separator + tail.join( separator )
+  end
+
+  def inspect
+    "[" + join( ", " ) + "]"
+  end
+
+  def include?( element )
+    return false if empty?
+    head == element || tail.include?( element )
+  end
+
+  def ==( other )
+    head == other.head && tail == other.tail
+  end
+
+  def take_while( &block )
+    if block.call( head )
+      Stream.new( head ) { tail.take_while( &block ) }
+    else
+      Stream.new
+    end
+  end
+
+  def all?( &block )
+    return true if empty?
+    block.call( head ) && tail.all?( &block )
+  end
+
+  def any?( &block )
+    return false if empty?
+    block.call( head ) || tail.any?( &block )
+  end
+end
+
+class Array
+  def to_stream
+    return Stream.new if empty?
+    Stream.new( first ) { self[ 1..-1 ].to_stream }
+  end
+end
+
+class Integer
+  def enumerate( step = 1, &block )
+    if block_given?
+      return Stream.new( self ) { block.call( self ).enumerate( &block ) }
+    end
+    Stream.new( self ) { ( self + step ).enumerate( step ) }
+  end
+
+  def enumerate_to( value, step = 1, &block )
+    return Stream.new if ( step >= 0 && self > value ) || ( step < 0 && self < value )
+    if block_given?
+      return Stream.new( self ) { block.call( self ).enumerate_to( value, &block ) }
+    end
+
+    Stream.new( self ) { ( self + step ).enumerate_to( value, step ) }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'spec'
+require 'mocha'
+
+Spec::Runner.configure do |config|
+  config.mock_with :mocha
+end

data/spec/streams_spec.rb

@@ -0,0 +1,430 @@
+require File.join( File.dirname(__FILE__), *%w[spec_helper] )
+require 'streams'
+
+describe Stream do
+  it "should create a new instance" do
+    Proc.new { Stream.new }.should_not raise_error
+  end
+
+  describe "basic" do
+    before do
+      @empty_stream = Stream.new
+      @stream = Stream.new( 43 ) { @empty_stream }
+    end
+
+    it "should return the head" do
+      @stream.head.should == 43 
+    end
+
+    it "should return the tail" do
+      @stream.tail.should == @empty_stream
+    end
+    
+    it "should call the delayed tail" do
+      @stream.delayed_tail.expects( :call ).once.returns( @empty_stream )
+      @stream.tail
+    end
+
+    it "should store the delayed tail in a block" do
+      @stream.delayed_tail.is_a?( Proc ).should be_true
+    end
+
+    it "should not be empty" do
+      @stream.should_not be_empty
+    end
+
+    it "should have the correct size" do
+      @stream.size.should == 1 + @stream.tail.size
+    end
+  end
+
+  describe "stream with head and without tail" do
+    before do
+      @stream = Stream.new( 42 )
+    end
+
+    it "should return the empty stream" do
+      @stream.tail.should be_empty
+    end 
+
+    it "should return a stream" do
+      @stream.tail.is_a?( Stream ).should be_true
+    end
+  end
+
+  describe "the empty stream" do
+    before do
+      @empty_stream = Stream.new
+    end
+
+    it "should be empty" do
+      @empty_stream.should be_empty
+    end
+
+    it "should have zero size" do
+      @empty_stream.size.should == 0
+    end
+
+    it "should return nil if you access the tail" do
+      @empty_stream.tail.should be_nil
+    end
+  end
+  
+  describe "infinite stream" do
+    before do
+      @stream = Stream.new( 1 ) { @stream }
+    end
+
+    it "should return itself" do
+      @stream.stubs( :inspect ).returns( nil ) 
+      @stream.tail.should === @stream
+    end
+  end
+
+  describe "basic stream behaviour: " do
+    before do
+      @stream = Stream.new( 1 ) { Stream.new( 2 ) { Stream.new( 3 ) } }
+    end
+
+    describe "Stream#each" do
+      it "should loop through each element" do
+        array = []
+        @stream.each do | element |
+          array << element
+        end
+
+        @stream.to_a.should == array
+      end
+    end
+
+    describe "Stream#map" do
+      it "should add 1 to each element" do
+        add_one = Proc.new { | n | n + 1 }
+        new_stream = @stream.map( &add_one )
+        
+        new_stream.head.should == add_one.call( @stream.head ) 
+        new_stream.tail.should == @stream.tail.map( &add_one )
+      end
+    end
+
+    describe "Stream#select" do
+      it "should select elements that return true when the predicate is applied to the element" do
+        even = Proc.new { | n | ( n % 2 ).zero? }
+        
+        odd_starting_stream = @stream
+        odd_starting_filtered_stream = odd_starting_stream.select( &even )
+
+        odd_starting_filtered_stream.head.should_not == odd_starting_stream.head
+        odd_starting_filtered_stream.should == odd_starting_stream.tail.select( &even )
+
+        even_starting_stream = Stream.new( 0 ) { odd_starting_stream }
+        even_starting_filtered_stream = even_starting_stream.select( &even )
+
+        even_starting_filtered_stream.head.should == even_starting_stream.head
+        even_starting_filtered_stream.tail.should == even_starting_stream.tail.select( &even )
+      end
+    end
+
+    describe "Stream#take" do
+      it "should return a stream composed of the first N elements" do
+        first_two = @stream.take( 2 )
+        first_two.head.should == @stream.head
+        first_two.tail.should == @stream.tail.take( 1 )
+      end
+
+      it "should return an empty stream if the stream is empty" do
+        Stream.new.take( 100 ).should == Stream.new
+      end
+
+      it "should return the empty stream is N is zero" do
+        @stream.take( 0 ).should == Stream.new
+      end
+    end
+
+    describe "Stream#at" do
+      it "should raise an ArgumentError if the index is out of bounds" do
+        Proc.new { Stream.new.at( 50 ) }.should raise_error( ArgumentError )
+      end
+      
+      it "should raise an ArgumentError if there are no elements in the stream" do
+        Proc.new { Stream.new.at( 0 ) }.should raise_error( ArgumentError )
+      end
+
+      it "should return the element at the Nth position" do
+        @stream.at( 1 ).should == 2
+      end
+    end
+
+    describe "Stream#drop" do
+      it "should remove the first n elements from the array" do
+        @stream.drop( 1 ).should == @stream.tail
+      end
+
+      it "should return the empty stream if the amount of elements to drop is greater than the size of the stream" do
+        Stream.new.drop( 1 ).should == Stream.new
+      end
+    end
+
+    describe "Stream#last" do
+      it "should return the last element" do
+        @stream.last.should == 3
+      end
+
+      it "should return nil if the stream is empty" do
+        Stream.new.last.should be_nil
+      end
+    end
+
+    describe "Stream#uniq" do
+      before do
+        @stream = Stream.new( 1 ) { Stream.new( 2 ) { Stream.new( 2 ) { Stream.new( 1 ) } } }
+      end
+
+      it "should remove duplicate elements" do
+        @stream.uniq.should == Stream.new( 1 ) { Stream.new( 2 ) }
+      end
+    end
+
+    describe "Stream#==(other)" do
+      before do
+        @other_stream = @stream.dup
+      end
+      
+      it "should return false if the elements are different" do
+        Stream.new.should_not == @stream
+      end
+
+      it "should return true if they have the same elements" do
+        @stream.should == @other_stream
+      end
+    end
+
+    describe "Stream#reject" do
+      it "should remove elements which return true when the predicate is applied to the element" do
+        even = Proc.new { | n | ( n % 2 ).zero? }
+        odd_starting_stream = @stream
+        even_starting_stream = Stream.new( 0 ) { odd_starting_stream }
+
+        even_starting_filtered_stream = even_starting_stream.reject( &even )
+        even_starting_filtered_stream.head.should_not == even_starting_stream.head
+        even_starting_filtered_stream.should == even_starting_stream.tail.reject( &even )
+
+        odd_starting_filtered_stream = odd_starting_stream.reject( &even )
+        odd_starting_filtered_stream.head.should == odd_starting_stream.head
+        odd_starting_filtered_stream.tail.should == odd_starting_stream.tail.reject( &even )
+      end
+    end
+
+    describe "Stream#merge" do
+      before do
+        @ones = Stream.new( 1 ) { Stream.new( 1 ) }
+        @twos = Stream.new( 2 ) { Stream.new( 2 ) }
+      end
+      
+      it "should merge the streams by summing each pairing element and constructing a new stream" do
+        threes = @ones.merge( @twos )
+        threes.head.should == @ones.head + @twos.head
+        
+        threes.tail.should == @ones.tail.merge( @twos.tail )
+      end
+
+      it "should return the mergee if the merger is empty" do
+        Stream.new.merge( @ones ).should == @ones
+      end
+
+      it "should return the merger if the mergee is empty" do
+        @ones.merge( Stream.new ).should == @ones
+      end
+    end
+
+    describe "Stream#take_while( &block )" do
+      it "should return a stream of the elements to the point where block.call( element ) is false" do
+        @stream.take_while { | n | n == 1 }.should == Stream.new( 1 )  
+      end
+    end
+
+    describe "Stream#append" do
+      before do
+        @ones = Stream.new( 1 ) { Stream.new( 1 ) }
+        @twos = Stream.new( 2 ) { Stream.new( 2 ) }
+      end
+
+      it "should append the streams" do
+        appended_stream = @ones.append( @twos )
+        appended_stream.head.should == @ones.head
+        appended_stream.tail.should == @ones.tail.append( @twos )
+      end
+
+      it "should return the appendee if the appender is empty" do
+        Stream.new.append( @ones ).should == @ones
+      end
+
+      it "should return the appender if the appendee is empty" do
+        @ones.append( Stream.new ).should == @ones
+      end
+    end
+        
+    describe "Stream#include?" do
+      it "should return false if the object is not an element in the stream" do
+        Stream.new.should_not include( "Hello, world!" )
+      end
+
+      it "should return true if the object is an element in the stream" do
+        @stream.should include( 1 )
+      end
+    end
+
+    describe "Stream#to_a" do
+      it "should return the elements of the stream as an array" do
+        @stream.to_a.should == [ 1, 2, 3 ]
+      end
+
+      it "should return an empty array if the stream is empty" do
+        Stream.new.to_a.should == []
+      end
+    end
+        
+    describe "Stream#join" do
+      it "should be an empty string if the stream is empty" do
+        Stream.new.join.should == ""
+      end
+
+      it "should print the head as a string if there is only one element" do
+        Stream.new( 1 ).join.should == 1.to_s
+      end
+
+      it "should join the elements by the separator" do
+        @stream.join( ", " ).should == "1, 2, 3"
+      end
+    end
+
+    describe "Stream#any?( &block )" do
+      it "should return false if the stream is empty" do
+        Stream.new.any? { | n | true }.should be_false
+      end
+
+      it "should return true if any of the elements return true when passed to the block" do
+        @stream.any? { | n | n == 2 }.should be_true
+      end
+
+      it "should return false if none of the elements return true when passed to the block" do
+        @stream.any? { | n | n < -500 }.should be_false
+      end
+    end
+
+    describe "Stream#all?( &block )" do
+      it "should return true if the stream is empty" do
+        Stream.new.all? { | element | false }.should be_true
+      end
+
+      it "should return true if all the elements return true when the block is applied to the element" do
+        @stream.all? { | n | n > 0 }.should be_true
+      end
+
+      it "should return false if any of the elements return false when the block is applied to the element" do
+        @stream.all? { | n | n != 2 }.should be_false
+      end
+    end
+
+    describe "Stream#inspect" do
+      it "should show [].to_s if the stream is empty" do
+        Stream.new.inspect.should == "[]"
+      end
+
+      it "should show the elements in an array - stream.to_s.inspect" do
+        @stream.inspect.should == "[1, 2, 3]"
+      end
+    end
+
+    it "should cache the tail" do
+      @stream.delayed_tail.expects( :call ).with.once.returns( @stream )
+      2.times { @stream.tail }
+    end
+  end
+end
+
+describe Array, "Stream helpers" do
+  before do
+    @array = [ 1, 2, 3 ]
+  end
+  
+  describe "Array#to_stream" do
+    it "should convert the array to a stream" do
+      @array.to_stream.should be_kind_of( Stream )
+    end
+
+    it "should fill the stream with the correct elements" do
+      stream = @array.to_stream
+      @array.first.should == stream.head
+      @array[ 1..-1 ].to_stream.should == stream.tail
+    end
+
+    it "should return an empty stream if the array is empty" do
+      [].to_stream.should == Stream.new
+    end
+  end
+end
+
+describe Integer, "Stream helpers" do
+  describe "Integer#enumerate( step = 1, &block )" do
+    it "should create an infinite stream of the natural numbers" do
+      natural_numbers = 0.enumerate
+      natural_numbers.head.should == 0
+      natural_numbers.tail.head.should == 1
+      natural_numbers.at( 30 ).should == 30
+    end
+
+    it "should return a stream" do
+      2.enumerate.should be_kind_of( Stream )
+    end
+
+    it "should create an infinite stream with the difference between each element being the step passed" do
+      multiples_of_5 = 0.enumerate( 5 )
+      multiples_of_5.head.should == 0
+      multiples_of_5.at( 5 ).should == 25
+      multiples_of_5.at( 10 ).should == 50
+    end
+    
+    it "should create an infinite stream with the difference between element being the difference between the proc applied to each element" do
+      powers_of_2 = 1.enumerate { | n | n * 2 }
+      powers_of_2.head.should == 1
+      powers_of_2.at( 2 ).should == 4
+      powers_of_2.at( 4 ).should == 16
+    end
+
+    it "should generate the next number based on the block rather than the step" do
+      multiples_of_10 = 0.enumerate( 5 ) { | n | n + 10 }
+      multiples_of_10.at( 0 ).should == 0
+      multiples_of_10.at( 1 ).should == 10
+      multiples_of_10.at( 2 ).should == 20
+    end
+  end
+
+  describe "Integer#enumerate_to( value, step = 1, &block )" do
+    it "should return a stream" do
+      0.enumerate_to( 100 ).should be_kind_of( Stream )
+    end
+
+    it "should not contain an element less than value if the step is negative" do
+      100.enumerate_to( 0, -3 ).any? { | n | n < 0 }.should_not be_true
+    end
+
+    it "should not contain an element greater than value if the step is positive" do
+      0.enumerate_to( 100, 3 ).any? { | n | n > 100 }.should_not be_true
+    end
+
+    it "should generate the next number based on the block rather than the step" do
+      stream = 0.enumerate_to( 100, 3 ) { | n | n + 11 }
+      stream.head.should == 0
+      stream.at( 1 ).should == 11
+      stream.at( 2 ).should == 22
+    end
+
+    it "should generate the next number based on the proc passed" do
+      stream = 0.enumerate_to( 100 ) { | n | n + 11 }
+      stream.head == 0
+      stream.at( 1 ).should == 11
+      stream.at( 2 ).should == 22
+    end
+  end
+end

data/streams.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{streams}
+  s.version = "1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Alex Watt"]
+  s.date = %q{2009-02-12}
+  s.description = %q{}
+  s.email = %q{alex.watt@me.com}
+  s.extra_rdoc_files = ["lib/streams.rb", "README"]
+  s.files = ["lib/streams.rb", "Rakefile", "README", "spec/spec_helper.rb", "spec/streams_spec.rb", "Manifest", "streams.gemspec"]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/Ninju/streams}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Streams", "--main", "README"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{streams}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: Ninju-streams
+version: !ruby/object:Gem::Version 
+  version: "1.0"
+platform: ruby
+authors: 
+- Alex Watt
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-12 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: ""
+email: alex.watt@me.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- lib/streams.rb
+- README
+files: 
+- lib/streams.rb
+- Rakefile
+- README
+- spec/spec_helper.rb
+- spec/streams_spec.rb
+- Manifest
+- streams.gemspec
+has_rdoc: true
+homepage: http://github.com/Ninju/streams
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Streams
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "1.2"
+  version: 
+requirements: []
+
+rubyforge_project: streams
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: ""
+test_files: []
+