matilda-stream 0.4.0

data/.gitignore

@@ -0,0 +1 @@
+coverage

data/.ruby-version

@@ -0,0 +1 @@
+1.9.3-p327

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+    - 1.9.3
+    - ruby-head
+    - jruby-head

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gem 'coveralls', :require => false
+
+group :test do
+  gem 'rake'
+end

data/Gemfile.lock

@@ -0,0 +1,27 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    colorize (0.5.8)
+    coveralls (0.6.7)
+      colorize
+      multi_json (~> 1.3)
+      rest-client
+      simplecov (>= 0.7)
+      thor
+    mime-types (1.23)
+    multi_json (1.7.6)
+    rake (10.0.3)
+    rest-client (1.6.7)
+      mime-types (>= 1.16)
+    simplecov (0.7.1)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.7.1)
+    simplecov-html (0.7.1)
+    thor (0.18.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  coveralls
+  rake

data/LICENSE.md

@@ -0,0 +1,7 @@
+The MIT License (MIT) Copyright (c) Callum Stott, http://www.seadowg.com
+
+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,52 @@
+# matilda-stream
+
+[![Build Status](https://travis-ci.org/seadowg/matilda-stream.png?branch=master)](https://travis-ci.org/seadowg/matilda-stream)
+[![Coverage
+Status](https://coveralls.io/repos/seadowg/matilda-stream/badge.png)](https://coveralls.io/r/seadowg/matilda-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`, `filter`, `each`, `take` and `scan` 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 << 'spec'
+  t.test_files = FileList['spec/*_spec.rb']
+  t.verbose = true
+end

data/lib/matilda-stream.rb

@@ -0,0 +1,178 @@
+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 last
+    result = nil
+    self.each do |ele|
+      result = ele
+    end
+
+    result
+  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 drop(n)
+    if n <= 0
+      Stream.new(head) do
+        tail
+      end
+    else
+      tail.drop(n - 1)
+    end
+  end
+
+  def map(&block)
+    Stream.new(yield head) do
+      tail.map(&block)
+    end
+  end
+
+  def scan(zero, &block)
+    Stream.new(zero) do
+      tail.scan(block.call(zero, head), &block)
+    end
+  end
+
+  def fold_left(*args, &block)
+    zero = args[0]
+    symbol = args[1] || args[0]
+
+    scan = if block
+      self.scan(zero, &block)
+    elsif args.length == 2
+      self.scan(zero, &symbol.to_proc)
+    elsif args.length == 1
+      self.drop(1).scan(head, &symbol.to_proc)
+    end
+
+    scan.last
+  end
+
+  alias :inject :fold_left
+  alias :reduce :fold_left
+
+  def filter(&block)
+    if block.call(head)
+      Stream.new(head) do
+        tail.filter(&block)
+      end
+    else
+      tail.filter(&block)
+    end
+  end
+
+  class EmptyStream < Stream
+    def initialize()
+      @head = nil
+    end
+
+    def tail
+      EmptyStream.new
+    end
+
+    def last
+      nil
+    end
+
+    def [](n)
+      nil
+    end
+
+    def each
+      nil
+    end
+
+    def take(n)
+      EmptyStream.new
+    end
+
+    def drop(n)
+      EmptyStream.new
+    end
+
+    def take_while(&block)
+      EmptyStream.new
+    end
+
+    def map(&block)
+      EmptyStream.new
+    end
+
+    def filter(&block)
+      EmptyStream.new
+    end
+
+    def scan(zero, &block)
+      Stream.new(zero) do
+        EmptyStream.new
+      end
+    end
+  end
+end

data/matilda-stream.gemspec

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

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'coveralls'
+Coveralls.wear!
+
+require 'minitest/autorun'

data/spec/stream_spec.rb

@@ -0,0 +1,299 @@
+require 'spec_helper'
+require 'matilda-stream'
+
+describe Stream do
+  before do
+    int_helper = lambda { |i|
+      Stream.new(i) {
+        int_helper.call(i + 1)
+      }
+    }
+
+    @stream = int_helper.call(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 "#last" do
+    it "returns the last element for finite Stream" do
+      @stream.take(5).last.must_equal 5
+    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 "#drop(n)" do
+    it "returns another Stream" do
+      @stream.drop(1).kind_of?(Stream).must_equal true
+    end
+
+    it "returns a Stream that skips the first n elements of the original" do
+      stream = @stream.drop(5)
+      stream[0].must_equal 6
+      stream[1].must_equal 7
+    end
+
+    describe "for a finite Stream" do
+      it "returns a Stream with the correct length" do
+        @stream.take(5).drop(1).length.must_equal 4
+      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 "#scan(zero, func)" do
+    it "returns a new Stream" do
+      @stream.scan(0) { |x, i| i }.kind_of?(Stream).must_equal true
+    end
+
+    it "returns a Stream with a head equivelant to the passed zero" do
+      @stream.scan(-1) { |x, i| i }.head.must_equal -1
+    end
+
+    it "returns a Stream that is the scan of the receiver" do
+      scan = @stream.scan(0) { |x, i| x + i }
+      scan[1].must_equal(1)
+      scan[2].must_equal(3)
+      scan[3].must_equal(6)
+      scan[100].must_equal(5050)
+    end
+
+    it "works correctly with finite streams" do
+      scan = @stream.take(1).scan(0) { |x, i| x + i }
+      scan[1].must_equal 1
+    end
+  end
+
+  describe "#fold_left(zero, func)" do
+    it "returns the left fold for an finite Stream" do
+      sum = @stream.take(5).fold_left(1) { |memo, ele|
+        memo + ele
+      }
+      sum.must_equal 16
+    end
+
+    it "returns the zero value for empty lists" do
+      value = @stream.take(0).fold_left(101) { |i, j| j }
+      value.must_equal 101
+    end
+
+    it "allows the func to be a symbol" do
+      sum = @stream.take(5).fold_left(1, :+)
+      sum.must_equal 16
+    end
+
+    it "is aliased with 'inject'" do
+      @stream.method(:fold_left).must_equal @stream.method(:inject)
+    end
+
+    it "is aliased with 'reduce'" do
+      @stream.method(:fold_left).must_equal @stream.method(:reduce)
+    end
+  end
+
+  describe "#fold_left(symbol)" do
+    it "returns the left fold for a finite Stream but skips the zero value step" do
+      sum = @stream.take(5).fold_left(:+)
+      sum.must_equal 15
+    end
+
+    it "returns nil for an empty Stream" do
+      sum = @stream.take(0).fold_left(:+)
+      sum.must_equal nil
+    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
+
+  describe "EmptyStream" do
+    it "ends the Stream" do
+      stream = lambda { |i|
+        Stream.new(i) do
+          if i < 1
+            Stream::EmptyStream.new
+          else
+            stream.call(i - 1)
+          end
+        end
+      }
+
+      stream.call(10).length.must_equal(11)
+    end
+  end
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: matilda-stream
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+  prerelease: 
+platform: ruby
+authors:
+- Callum Stott
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-07 00:00:00.000000000 Z
+dependencies: []
+description: 
+email:
+- callum@seadowg.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .ruby-version
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- LICENSE.md
+- README.md
+- Rakefile
+- lib/matilda-stream.rb
+- matilda-stream.gemspec
+- spec/spec_helper.rb
+- spec/stream_spec.rb
+homepage: 
+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: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Lazy stream implementation for Ruby
+test_files: []