ruby-stream 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 671bd48c3710f55b50a919a2e5649f04e431e576
+  data.tar.gz: f8af1124273e7f59bd118c1b83b7f8a0951cb761
+SHA512:
+  metadata.gz: d1f62a98ae959111f0733f0ca186412bf04a2c397bec51445e4e74f3e16ed9e941147bde62577ac52a5c1270f0ce5b9443203f5ea123e2a0266a68382a945143
+  data.tar.gz: d3e05556757511d3ce946a714a79b7fe207b0d0a1e5366ecc1a11b9ac32890aaee7d2803deba99704967592f0b0ca6e2b8a43a90a162438cf13f4ec6db736f4f

data/Gemfile

@@ -0,0 +1,5 @@
+source :rubygems
+
+group :test do
+  gem 'rake'
+end

data/Gemfile.lock

@@ -0,0 +1,10 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    rake (10.0.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake

data/README.md

@@ -0,0 +1,50 @@
+#ruby-stream
+
+[![Build Status](https://travis-ci.org/oetzi/ruby-stream.png?branch=master)](https://travis-ci.org/oetzi/ruby-stream)
+
+Lazy stream implementation for Ruby because Enumerators are kinda silly.
+
+## Description
+
+Streams are infinite, lazily evaluated, awesome lists. Here's an example
+of a Stream that represents the set of positive integers:
+
+    def int_stream(i)
+      Stream.new(i) do
+        int_stream(i + 1)
+      end
+    end
+
+    integers = int_stream(1)
+
+You can access streams like any other data structure:
+
+    integers[0] # => 1
+    integers[12] # => 13
+    integers[999999] # => 999998
+
+Each value will be lazily calculated by materializing the Streams values
+until the requested value. Streams are stateless so a Stream will
+recalculate for every access.
+
+You can also create finite Streams from infinite ones:
+
+    integers.take(5)
+
+Finite streams have some extra functionality due to their ability to
+end:
+
+    integers.take(5).each do |i|
+       puts i
+    end
+
+    integers.length # => 5
+
+Infinite Streams also support interation and length calculations but you
+will need to be prepared to wait, forever. No seriously, I mean for all
+time. Its infinite.
+
+Streams become most powerful when used with high order functions. At the
+moment ruby-stream supports `map` and `filter` operations that operate
+as they would on normal collections (these operations will only actually be
+applied to Stream elements on access or iteration however).

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rake/testtask'
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.libs.push "lib"
+  t.test_files = FileList['spec/*_spec.rb']
+  t.verbose = true
+end

data/lib/ruby-stream.rb

@@ -0,0 +1,123 @@
+class Stream
+  def self.continually(&block)
+    Stream.new(yield) do
+      Stream.continually(&block)
+    end
+  end
+
+  attr_reader :head
+
+  def initialize(head, &block)
+    @head = head
+    @tail_block = block
+  end
+
+  def tail
+    @tail_block.call
+  end
+
+  def [](n)
+    if n == 0
+      self.head
+    elsif n < 0
+      nil
+    else
+      last_stream = self
+      n.times {
+        return nil if last_stream.kind_of?(EmptyStream)
+        last_stream = last_stream.tail
+      }
+
+      last_stream.head
+    end
+  end
+
+  def length
+    counter = 0
+    self.each { |ele| counter += 1 }
+    counter
+  end
+
+  def each(&block)
+    last_stream = self
+
+    until last_stream.kind_of?(EmptyStream)
+      block.call(last_stream.head)
+      last_stream = last_stream.tail
+    end
+
+    nil
+  end
+
+  def take(n)
+    if n <= 0
+      EmptyStream.new
+    else
+      Stream.new(head) do
+        tail.take(n - 1)
+      end
+    end
+  end
+
+  def take_while(&block)
+    if block.call(head)
+      Stream.new(head) do
+        tail.take_while(&block)
+      end
+    else
+      EmptyStream.new
+    end
+  end
+
+  def map(&block)
+    Stream.new(yield head) do
+      tail.map(&block)
+    end
+  end
+
+  def filter(&block)
+    if block.call(head)
+      Stream.new(head) do
+        tail.filter(&block)
+      end
+    else
+      tail.filter(&block)
+    end
+  end
+
+  private
+
+  class EmptyStream < Stream
+    def initialize()
+      @head = nil
+    end
+
+    def tail
+      EmptyStream.new
+    end
+
+    def [](n)
+      nil
+    end
+
+    def each
+      nil
+    end
+
+    def take(n)
+      EmptyStream.new
+    end
+
+    def take_while(&block)
+      EmptyStream.new
+    end
+
+    def map(&block)
+      EmptyStream.new
+    end
+
+    def filter(&block)
+      EmptyStream.new
+    end
+  end
+end

data/ruby-stream.gemspec

@@ -0,0 +1,14 @@
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+Gem::Specification.new do |s|
+  s.name = "ruby-stream"
+  s.version = "0.1.0"
+  s.platform = Gem::Platform::RUBY
+  s.authors = ["Callum Stott"]
+  s.email = ["callum.stott@me.com"]
+  s.summary = "Lazy stream implementation for Ruby"
+
+  s.require_paths = ['lib']
+  s.files = `git ls-files`.split("\n")
+end

data/spec/ruby-stream_spec.rb

@@ -0,0 +1,197 @@
+require 'minitest/autorun'
+require 'ruby-stream'
+
+def int_helper(i)
+  Stream.new(i) do
+    int_helper(i + 1)
+  end
+end
+
+describe Stream do
+  before do
+    @stream = int_helper(1)
+  end
+
+  describe "#head" do
+    it "returns the first element of the Stream" do
+      @stream.head.must_equal 1
+    end
+  end
+
+  describe "#tail" do
+    it "returns another Stream" do
+      @stream.tail.kind_of?(Stream).must_equal true
+    end
+
+    it "returns a Stream with the next element as its head" do
+      @stream.tail.head.must_equal 2
+      @stream.tail.tail.head.must_equal 3
+    end
+  end
+
+  describe "#[](n)" do
+    it "calculates the nth element of the stream" do
+      @stream[999].must_equal 1000
+    end
+
+    it "returns nil for negative n" do
+      @stream[-1].must_equal nil
+    end
+
+    describe "for a finite Stream" do
+      it "returns nil for n greater than the limit of the Stream" do
+        @stream.take(10)[10].must_equal nil
+      end
+    end
+  end
+
+  describe "#take(n)" do
+    it "returns another Stream" do
+      @stream.take(10).kind_of?(Stream).must_equal true
+    end
+
+    it "returns a Stream with the correct #length" do
+      @stream.take(10).length.must_equal 10
+    end
+
+    it "returns a Stream with the correct values" do
+      stream = @stream.take(10)
+      stream[0].must_equal 1
+      stream[5].must_equal 6
+      stream[7].must_equal 8
+      stream[9].must_equal 10
+    end
+
+    it "returns a Stream that can be iterated through finitely" do
+      @stream.take(10).each do |element|
+        true.must_equal true
+      end
+    end
+
+    describe "when operating on the result Stream" do
+      it "returns a finite Stream for #map" do
+        stream = @stream.take(10).map { |i| i.to_s }
+        stream.length.must_equal 10
+      end
+
+      it "returns a finite Stream for #filter" do
+        stream = @stream.take(10).filter { |i| true }
+        stream.length.must_equal 10
+      end
+    end
+
+    describe "for a finite Stream" do
+      it "returns a Stream with length limit if n > limit" do
+        original = @stream.take(10)
+        original.take(100).length.must_equal 10
+      end
+    end
+  end
+
+  describe "#each(func)" do
+    describe "for a finite Stream" do
+      it "should return nil" do
+        @stream.take(5).each do
+          1
+        end.must_equal nil
+      end
+
+      it "should execute the passed block for every element of the stream" do
+        i = 0
+        @stream.take(5).each do
+          i += 1
+        end
+
+        i.must_equal 5
+      end
+    end
+  end
+
+  describe "#length" do
+    it "returns the lenght for a finite array" do
+      @stream.take(5).length.must_equal 5
+    end
+  end
+
+  describe "#map(func)" do
+    it "returns a new Stream" do
+      @stream.map(&:to_s).kind_of?(Stream).must_equal true
+    end
+
+    it "returns a new Stream with mapped values" do
+      mapped = @stream.map { |i| i + 1 }
+      mapped[0].must_equal(2)
+      mapped[3].must_equal(5)
+      mapped[1000].must_equal(1002)
+    end
+  end
+
+  describe "#filter(func)" do
+    it "returns a new Stream" do
+      @stream.filter { |i| i % 2 == 0 }.kind_of?(Stream).must_equal true
+    end
+
+    it "returns a new Stream with only elements matching the predicate" do
+      filtered = @stream.filter { |i| i % 2 == 0 }
+      filtered[0].must_equal 2
+      filtered[1].must_equal 4
+      filtered[3].must_equal 8
+    end
+  end
+
+  describe "#take_while(func)" do
+    it "returns a new Stream" do
+      @stream.take_while { |i| i < 10 }.kind_of?(Stream).must_equal true
+    end
+
+    describe "when the return Stream is finite" do
+      it "returns a Stream with the correct length" do
+        @stream.take_while { |i| i < 10 }.length.must_equal 9
+      end
+
+      it "returns a Stream that iterates through finitely" do
+        stream = @stream.take_while { |i| i < 10 }
+        counter = 0
+        stream.each { |i| counter += 1 }
+        counter.must_equal 9
+      end
+
+      it "returns a finite Stream for #map" do
+        stream = @stream.take_while { |i|
+          i < 10
+        }.map { |i| i.to_s }
+
+        stream.length.must_equal 9
+      end
+
+      it "returns a finite Stream for #filter" do
+        stream = @stream.take_while { |i|
+          i < 10
+        }.filter { |i| true }
+
+        stream.length.must_equal 9
+      end
+    end
+  end
+
+  describe ".continually(func)" do
+    it "returns a new Stream" do
+      Stream.continually {
+        true
+      }.kind_of?(Stream).must_equal true
+    end
+
+    it "returns a Stream with the calculated block as each element" do
+      stream_block = Proc.new do
+        counter = 0
+        Stream.continually {
+          counter += 1
+        }
+      end
+
+      stream_block.call.head.must_equal 1
+      stream_block.call.tail.head.must_equal 2
+      stream_block.call.tail.tail.head.must_equal 3
+    end
+  end
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: ruby-stream
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Callum Stott
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-04 00:00:00.000000000 Z
+dependencies: []
+description: 
+email:
+- callum.stott@me.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- lib/ruby-stream.rb
+- ruby-stream.gemspec
+- spec/ruby-stream_spec.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: Lazy stream implementation for Ruby
+test_files: []