stream 0.5.2 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3374a923bc2d44c39ea1c1957d5982b26f55a22ac958cfa119be87a978e17676
-  data.tar.gz: 88b9b768b08a6edf3a689f76f50627784825b15ac1ed07d6b3172bb34ce69fa3
+  metadata.gz: cbfc5988a8fe8b8e4735b9f576da07e6e1aa18a87b4b8a6df0c917b5a9789a13
+  data.tar.gz: 06d3fe1334d5adbce1123621410c22efab33159396e967eb96d18d926c8c9080
 SHA512:
-  metadata.gz: fd0f115fefc0969ccde444c8200d9f279b8d9736af6c91884d89e5fa9dd4a46dccb6b570da4467b7dfaa35e038644b09dbf25348289a66cf0ea919c4c21c732b
-  data.tar.gz: 56d49b892e3355026bb05bd98535471ebfe9e8564f9f1885e43938deda8b7f3e33551fcd15f1b492821944de5707ef296dff3f134812b1f8e904ce0ef8b4f037
+  metadata.gz: 161659d0943d54ca3c0ab0eadddf9933f800d57108b0f3f1368929fdc01bebb3dbb0cf12bc1cff8b82cffb005b7a1e04d2646a1ea628b692dd6890afa576310c
+  data.tar.gz: 55f2c790ea82ef64f90bdef541303ec4a2fc6be1292a19a96648f5bfc1159cd17e807d1264d1d98c55a6b5298129037c5576cd7b94f22931686cdd57e1e08f4f

data/Gemfile

@@ -1,5 +1,3 @@
 source 'https://rubygems.org'
 
 gemspec
-
-gem "codeclimate-test-reporter", group: :test, require: nil

data/Gemfile.lock

@@ -1,7 +1,8 @@
 PATH
   remote: .
   specs:
-    stream (0.5.2)
+    stream (0.5.3)
+      generator
 
 GEM
   remote: https://rubygems.org/
@@ -9,6 +10,7 @@ GEM
     codeclimate-test-reporter (1.0.9)
       simplecov (<= 0.13)
     docile (1.1.5)
+    generator (0.0.1)
     json (2.1.0)
     power_assert (1.1.3)
     rake (12.3.2)
@@ -24,6 +26,7 @@ GEM
 
 PLATFORMS
   ruby
+  x86_64-linux
 
 DEPENDENCIES
   codeclimate-test-reporter
@@ -34,4 +37,4 @@ DEPENDENCIES
   yard
 
 BUNDLED WITH
-   2.0.1
+   2.2.1

data/LICENSE

@@ -0,0 +1,56 @@
+Ruby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.jp>.
+You can redistribute it and/or modify it under either the terms of the
+2-clause BSDL (see the file BSDL), or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to Usenet or an equivalent medium, or by allowing
+	  the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) give non-standard binaries non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or binary form,
+     provided that you do at least ONE of the following:
+
+       a) distribute the binaries and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard binaries non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under these terms.
+
+     For the list of those files and their copying conditions, see the
+     file LEGAL.
+
+  5. The scripts and library files supplied as input to or produced as
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them,
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.

data/README.rdoc

@@ -168,5 +168,5 @@ root privileges to install.
 == Other Stuff
 
 Author:: Horst Duchene
-License:: Copyright (c) 2001, 2013, 2016 Horst Duchene
+License:: Copyright (c) 2001, 2013, 2016, 2020 Horst Duchene
 Released under the same license as Ruby

data/Rakefile

@@ -21,8 +21,8 @@ task :default => :test
 # Define a test task.
 
 Rake::TestTask.new do |t|
-  t.libs << "tests"
-  t.pattern = 'tests/Test*.rb'
+  t.libs << 'test'
+  t.pattern = 'test/test*.rb'
   t.verbose = true
 end
 

data/lib/stream.rb

@@ -1,4 +1,4 @@
-STREAM_VERSION = "0.5.2"
+STREAM_VERSION = '0.5.3'.freeze
 
 ##
 # Module Stream defines an interface for an external Iterator which
@@ -14,15 +14,20 @@ module Stream
   class EndOfStreamException < StandardError; end
 
   # Returns false if the next #forward will return an element.
-  def at_end?; raise NotImplementedError; end
+  def at_end?
+    raise NotImplementedError
+  end
 
   # Returns false if the next #backward will return an element.
-  def at_beginning?; raise NotImplementedError; end
+  def at_beginning?
+    raise NotImplementedError
+  end
 
   # Move forward one position. Returns the _target_ of current_edge.
   # Raises Stream::EndOfStreamException if at_end? is true.
   def forward
     raise EndOfStreamException if at_end?
+
     basic_forward
   end
 
@@ -30,28 +35,41 @@ module Stream
   # Stream::EndOfStreamException if at_beginning? is true.
   def backward
     raise EndOfStreamException if at_beginning?
+
     basic_backward
   end
 
   # Position the stream before its first element, i.e. the next #forward
   # will return the first element.
   def set_to_begin
-    until at_beginning?; basic_backward; end
+    basic_backward until at_beginning?
   end
 
   # Position the stream behind its last element, i.e. the next #backward
   # will return the last element.
   def set_to_end
-    until at_end?; basic_forward; end
+    basic_forward until at_end?
   end
 
   protected
 
-  def basic_forward; raise NotImplementedError; end
-  def basic_backward; raise NotImplementedError; end
+  def basic_forward
+    raise NotImplementedError
+  end
+
+  def basic_backward
+    raise NotImplementedError
+  end
 
-  def basic_current; backward; forward; end
-  def basic_peek; forward; backward; end
+  def basic_current
+    backward
+    forward
+  end
+
+  def basic_peek
+    forward
+    backward
+  end
 
   public
 
@@ -62,77 +80,106 @@ module Stream
   # current position. #detect, which is inherited from Enumerable uses
   # #each, which implicitly calls #set_to_begin.
   def move_forward_until
-	  until at_end?
-	    element = basic_forward
-	    return element if yield(element)
-	  end
-	  nil
+    until at_end?
+      element = basic_forward
+      return element if yield(element)
+    end
+    nil
   end
 
   # Move backward until the boolean block is not false and returns the element
   # found. Returns nil if no object matches.
   def move_backward_until
-	  until at_beginning?
-	    element = basic_backward
-	    return element if yield(element)
-	  end
-	  nil
+    until at_beginning?
+      element = basic_backward
+      return element if yield(element)
+    end
+    nil
   end
 
   # Returns the element returned by the last call of #forward. If at_beginning?
   # is true self is returned.
-  def current; at_beginning? ? self : basic_current; end
+  def current
+    at_beginning? ? self : basic_current
+  end
 
   # Returns the element returned by the last call of #backward. If at_end? is
   # true self is returned.
-  def peek; at_end? ? self : basic_peek; end
+  def peek
+    at_end? ? self : basic_peek
+  end
 
   # Returns the array [#current,#peek].
-  def current_edge; [current,peek]; end
+  def current_edge
+    [current, peek]
+  end
 
   # Returns the first element of the stream. This is accomplished by calling
   # set_to_begin and #forward, which means a state change.
-  def first; set_to_begin; forward; end
+  def first
+    set_to_begin
+    forward
+  end
 
   # Returns the last element of the stream. This is accomplished by calling
   # set_to_begin and #backward, which means a state change.
-  def last; set_to_end; backward; end
+  def last
+    set_to_end
+    backward
+  end
 
   # Returns true if the stream is empty which is equivalent to at_end? and
   # at_beginning? both being true.
-  def empty?; at_end? and at_beginning?; end
+  def empty?
+    at_end? and at_beginning?
+  end
 
   # Implements the standard iterator used by module Enumerable, by calling
   # set_to_begin and basic_forward until at_end? is true.
   def each
     set_to_begin
-    until at_end?
-      yield basic_forward
-    end
+    yield basic_forward until at_end?
   end
 
   # create_stream is used for each Enumerable to create a stream for it. A
   # Stream as an Enumerable returns itself.
-  def create_stream; self end
+  def create_stream
+    self
+  end
 
   # A Stream::WrappedStream should return the wrapped stream unwrapped. If the
   # stream is not a wrapper around another stream it simply returns itself.
-  def unwrapped; self; end
+  def unwrapped
+    self
+  end
 
   # The abstract super class of all concrete Classes implementing the Stream
   # interface. Only used for including module Stream.
   class BasicStream
-	  include Stream
+    include Stream
   end
 
   # A Singleton class for an empty stream. EmptyStream.instance is the sole
   # instance which answers true for both at_end? and at_beginning?
   class EmptyStream < BasicStream
-	  require 'singleton'
-	  include Singleton
+    require 'singleton'
+    include Singleton
+
+    def at_end?
+      true
+    end
+
+    def at_beginning?
+      true
+    end
 
-	  def at_end?; true; end
-	  def at_beginning?; true; end
+    def basic_forward
+      raise EndOfStreamException
+    end
+
+    def basic_backward
+      raise EndOfStreamException
+    end
   end
 
   # A CollectionStream can be used as an external iterator for each
@@ -142,34 +189,56 @@ module Stream
   # A CollectionStream for an array is created by the method
   # Array#create_stream.
   class CollectionStream < BasicStream
-	  attr_reader :pos
+    attr_reader :pos
 
-	  # Creates a new CollectionStream for the indexable sequence _seq_.
-	  def initialize(seq)
-	    @seq = seq
-	    set_to_begin
-	  end
+    # Creates a new CollectionStream for the indexable sequence _seq_.
+    def initialize(seq)
+      @seq = seq
+      set_to_begin
+    end
 
-	  def at_end?; @pos + 1 >= @seq.size; end
-	  def at_beginning?; @pos < 0; end
+    def at_end?
+      @pos + 1 >= @seq.size
+    end
 
-	  # positioning
+    def at_beginning?
+      @pos < 0
+    end
 
-	  #
-	  def set_to_begin; @pos = -1; end
-	  def set_to_end; @pos = @seq.size - 1; end
+    # positioning
 
-	  def basic_forward; @pos += 1; @seq[@pos]; end
-	  def basic_backward; r = @seq[@pos]; @pos -= 1; r; end
+    def set_to_begin
+      @pos = -1
+    end
+
+    def set_to_end
+      @pos = @seq.size - 1
+    end
+
+    def basic_forward
+      @pos += 1
+      @seq[@pos]
+    end
 
-	  protected
+    def basic_backward
+      r = @seq[@pos]
+      @pos -= 1; r
+    end
+
+    protected
+
+    # basic_current and basic_peek can be implemented more efficiently than in
+    # superclass
+    def basic_current
+      @seq[@pos]
+    end
 
-	  # basic_current and basic_peek can be implemented more efficiently than in
-	  # superclass
-	  def basic_current; @seq[@pos]; end
-	  def basic_peek; @seq[@pos+1]; end
+    def basic_peek
+      @seq[@pos + 1]
+    end
+  end
 
-  end							# CollectionStream
+  # CollectionStream
 
   # A simple Iterator for iterating over a sequence of integers starting from
   # zero up to a given upper bound. Mainly used by Stream::FilteredStream. Could
@@ -179,26 +248,44 @@ module Stream
   # The upper bound is stored in the instance variable @stop which can be
   # incremented dynamically by the method increment_stop.
   class IntervalStream < BasicStream
-	  attr_reader :pos
+    attr_reader :pos
+
+    # Create a new IntervalStream with upper bound _stop_. stop - 1 is the last
+    # element. By default _stop_ is zero which means that the stream is empty.
+    def initialize(stop = 0)
+      @stop = stop - 1
+      set_to_begin
+    end
+
+    def at_beginning?
+      @pos < 0
+    end
+
+    def at_end?
+      @pos == @stop
+    end
 
-	  # Create a new IntervalStream with upper bound _stop_. stop - 1 is the last
-	  # element. By default _stop_ is zero which means that the stream is empty.
-	  def initialize(stop=0)
-	    @stop = stop - 1
-	    set_to_begin
-	  end
+    def set_to_end
+      @pos = @stop
+    end
 
-	  def at_beginning?; @pos < 0; end
-	  def at_end?; @pos == @stop; end
+    def set_to_begin
+      @pos = -1
+    end
 
-	  def set_to_end; @pos = @stop; end
-	  def set_to_begin; @pos = -1; end
+    # Increment the upper bound by incr.
+    def increment_stop(incr = 1)
+      @stop += incr
+    end
 
-	  # Increment the upper bound by incr.
-	  def increment_stop(incr=1); @stop += incr; end
+    def basic_forward
+      @pos += 1
+    end
 
-	  def basic_forward; @pos += 1; end
-	  def basic_backward;  @pos -= 1; @pos + 1; end
+    def basic_backward
+      @pos -= 1
+      @pos + 1
+    end
   end
 
   # Class WrappedStream is the abstract superclass for stream classes that wrap
@@ -211,25 +298,41 @@ module Stream
   #  arrayStream.to_a => [1,2,3]
   #  Stream::WrappedStream.new(arrayStream).to_a => [1,2,3]
   class WrappedStream < BasicStream
-	  attr_reader :wrapped_stream
+    attr_reader :wrapped_stream
+
+    # Create a new WrappedStream wrapping the Stream _other_stream_.
+    def initialize(other_stream)
+      @wrapped_stream = other_stream
+    end
+
+    def at_beginning?
+      @wrapped_stream.at_beginning?
+    end
 
-	  # Create a new WrappedStream wrapping the Stream _otherStream_.
-	  def initialize(otherStream)
-	    @wrapped_stream = otherStream
-	  end
+    def at_end?
+      @wrapped_stream.at_end?
+    end
 
-	  def at_beginning?; @wrapped_stream.at_beginning?; end
-	  def at_end?; @wrapped_stream.at_end?; end
+    def set_to_end
+      @wrapped_stream.set_to_end
+    end
 
-	  def set_to_end; @wrapped_stream.set_to_end; end
-	  def set_to_begin; @wrapped_stream.set_to_begin; end
+    def set_to_begin
+      @wrapped_stream.set_to_begin
+    end
 
-	  # Returns the wrapped stream unwrapped.
-	  def unwrapped; @wrapped_stream.unwrapped; end
+    # Returns the wrapped stream unwrapped.
+    def unwrapped
+      @wrapped_stream.unwrapped
+    end
 
-	  public # but should be protected. Would like to have a friend concept here.
-	  def basic_forward; @wrapped_stream.basic_forward; end
-	  def basic_backward;  @wrapped_stream.basic_backward; end
+    def basic_forward
+      @wrapped_stream.basic_forward
+    end
+
+    def basic_backward
+      @wrapped_stream.basic_backward
+    end
   end
 
   ##
@@ -240,64 +343,69 @@ module Stream
   #
   #  (1..6).create_stream.filtered { |x| x % 2 == 0 }.to_a ==> [2, 4, 6]
   class FilteredStream < WrappedStream
+    # Create a new FilteredStream wrapping _other_stream_ and selecting all its
+    # elements which satisfy the condition defined by the block_filter_.
+    def initialize(other_stream, &filter)
+      super other_stream
+      @filter = filter
+      @position_holder = IntervalStream.new
+      set_to_begin
+    end
 
-	  # Create a new FilteredStream wrapping _otherStream_ and selecting all its
-	  # elements which satisfy the condition defined by the block_filter_.
-	  def initialize(otherStream, &filter)
-	    super otherStream
-	    @filter = filter
-	    @positionHolder = IntervalStream.new
-	    set_to_begin
-	  end
-
-	  def at_beginning?; @positionHolder.at_beginning?; end
-
-	  # at_end? has to look ahead if there is an element satisfing the filter
-	  def at_end?
-	    @positionHolder.at_end? and
-		    begin
-		      if @peek.nil?
-			      @peek = wrapped_stream.move_forward_until( &@filter ) or return true
-			      @positionHolder.increment_stop
-		      end
-		      false
-		    end
-	  end
-
-	  def basic_forward
-	    result =
-		    if @peek.nil?
-		      wrapped_stream.move_forward_until(&@filter)
-		    else
-		      # Do not move!!
-		      @peek
-		    end
-	    @peek = nil
-	    @positionHolder.forward
-	    result
-	  end
-
-	  def basic_backward
-	    wrapped_stream.backward unless @peek.nil?
-	    @peek = nil
-	    @positionHolder.backward
-	    wrapped_stream.move_backward_until(&@filter) or self
-	  end
-
-	  def set_to_end
-	    # Not super which is a WrappedStream, but same behavior as in Stream
-	    until at_end?; basic_forward; end
-	  end
-
-	  def set_to_begin
-	    super
-	    @peek = nil
-	    @positionHolder.set_to_begin
-	  end
-
-	  # Returns the current position of the stream.
-	  def pos; @positionHolder.pos; end
-  end							# FilteredStream
+    def at_beginning?
+      @position_holder.at_beginning?
+    end
+
+    # at_end? has to look ahead if there is an element satisfing the filter
+    def at_end?
+      @position_holder.at_end? and
+          begin
+            if @peek.nil?
+              @peek = wrapped_stream.move_forward_until(&@filter) or return true
+              @position_holder.increment_stop
+            end
+            false
+          end
+    end
+
+    def basic_forward
+      result =
+          if @peek.nil?
+            wrapped_stream.move_forward_until(&@filter)
+          else
+            # Do not move!!
+            @peek
+          end
+      @peek = nil
+      @position_holder.forward
+      result
+    end
+
+    def basic_backward
+      wrapped_stream.backward unless @peek.nil?
+      @peek = nil
+      @position_holder.backward
+      wrapped_stream.move_backward_until(&@filter) or self
+    end
+
+    def set_to_end
+      # Not super which is a WrappedStream, but same behavior as in Stream
+      basic_forward until at_end?
+    end
+
+    def set_to_begin
+      super
+      @peek = nil
+      @position_holder.set_to_begin
+    end
+
+    # Returns the current position of the stream.
+    def pos
+      @position_holder.pos
+    end
+  end
+
+  # FilteredStream
 
   ##
   # Each reversable stream (a stream that implements #backward and
@@ -307,29 +415,43 @@ module Stream
   #
   #  (1..6).create_stream.reverse.to_a ==> [6, 5, 4, 3, 2, 1]
   class ReversedStream < WrappedStream
+    # Create a reversing wrapper for the reversable stream _other_stream_. If
+    # _other_stream_ does not support backward moving a NotImplementedError is
+    # signaled on the first backward move.
+    def initialize(other_stream)
+      super other_stream
+      set_to_begin
+    end
 
-	  # Create a reversing wrapper for the reversable stream _otherStream_. If
-	  # _otherStream_ does not support backward moving a NotImplementedError is
-	  # signaled on the first backward move.
-	  def initialize(otherStream)
-	    super otherStream
-	    set_to_begin
-	  end
+    # Returns true if the wrapped stream is at_end?.
+    def at_beginning?
+      wrapped_stream.at_end?
+    end
 
-	  # Returns true if the wrapped stream is at_end?.
-	  def at_beginning?; wrapped_stream.at_end?; end
-	  # Returns true if the wrapped stream is at_beginning?.
-	  def at_end?; wrapped_stream.at_beginning?; end
+    # Returns true if the wrapped stream is at_beginning?.
+    def at_end?
+      wrapped_stream.at_beginning?
+    end
 
-	  # Moves the wrapped stream one step backward.
-	  def basic_forward; wrapped_stream.basic_backward; end
-	  # Moves the wrapped stream one step forward.
-	  def basic_backward; wrapped_stream.basic_forward; end
+    # Moves the wrapped stream one step backward.
+    def basic_forward
+      wrapped_stream.basic_backward
+    end
 
-	  # Sets the wrapped stream to the beginning.
-	  def set_to_end; wrapped_stream.set_to_begin; end
-	  # Sets the wrapped stream to the end.
-	  def set_to_begin; wrapped_stream.set_to_end; end
+    # Moves the wrapped stream one step forward.
+    def basic_backward
+      wrapped_stream.basic_forward
+    end
+
+    # Sets the wrapped stream to the beginning.
+    def set_to_end
+      wrapped_stream.set_to_begin
+    end
+
+    # Sets the wrapped stream to the end.
+    def set_to_begin
+      wrapped_stream.set_to_end
+    end
   end
 
   ##
@@ -341,21 +463,25 @@ module Stream
   #  (1..5).collect {|x| x**2} ==> [1, 4, 9, 16, 25]
   #  (1..5).create_stream.collect {|x| x**2}.to_a ==> [1, 4, 9, 16, 25]
   class MappedStream < WrappedStream
+    ##
+    # Creates a new MappedStream wrapping _other_stream_ which calls the block
+    # _mapping_ on each move.
+    def initialize(other_stream, &mapping)
+      super other_stream
+      @mapping = mapping
+    end
 
-	  ##
-	  # Creates a new MappedStream wrapping _otherStream_ which calls the block
-	  # _mapping_ on each move.
-	  def initialize(otherStream, &mapping)
-	    super otherStream
-	    @mapping = mapping
-	  end
+    # Apply the stored closure for the next element in the wrapped stream and
+    # return the result.
+    def basic_forward
+      @mapping.call(super)
+    end
 
-	  # Apply the stored closure for the next element in the wrapped stream and
-	  # return the result.
-	  def basic_forward; @mapping.call(super); end
-	  # Apply the stored closure for the previous element in the wrapped stream
-	  # and return the result.
-	  def basic_backward; @mapping.call(super); end
+    # Apply the stored closure for the previous element in the wrapped stream
+    # and return the result.
+    def basic_backward
+      @mapping.call(super)
+    end
   end
 
   ##
@@ -366,81 +492,98 @@ module Stream
   #
   #  ((1..3).create_stream + [4,5].create_stream).to_a ==> [1, 2, 3, 4, 5]
   class ConcatenatedStream < WrappedStream
-	  alias :streamOfStreams :wrapped_stream
-	  private :streamOfStreams
-
-	  # Creates a new ConcatenatedStream wrapping the stream of streams
-	  # _streamOfStreams_.
-	  def initialize(streamOfStreams)
-	    super
-	    set_to_begin
-	  end
-
-	  # If the current stream is at end, than at_end? has to look ahead to find a
-	  # non empty in the stream of streams, which than gets the current stream.
-	  def at_end?
- 	    if @currentStream.at_end?
+    alias streamOfStreams wrapped_stream
+    private :streamOfStreams
+
+    # Creates a new ConcatenatedStream wrapping the stream of streams
+    # _streamOfStreams_.
+    def initialize(streamOfStreams)
+      super
+      set_to_begin
+    end
+
+    # If the current stream is at end, than at_end? has to look ahead to find a
+    # non empty in the stream of streams, which than gets the current stream.
+    def at_end?
+      unless @current_stream.at_end?
         return false
-      else      
-		    until streamOfStreams.at_end?
-			    dir, @dirOfLastMove = @dirOfLastMove, :forward
-			    s = streamOfStreams.basic_forward
-			    # if last move was backwards, then @currentStream is
-			    # equivalent to s. Move to next stream.
-			    next if dir == :backward
-			    s.set_to_begin
-			    if s.at_end?          # empty stream?
-			      next                # skip it
-			    else
-			      @currentStream = s
-			      return false        # found non empty stream
-			    end
-		    end                     # until
-		    reachedBoundary         # sets @dirOfLastMove and @currentStream
       end
+
+      until streamOfStreams.at_end?
+        dir = @dir_of_last_move
+        @dir_of_last_move = :forward
+        s = streamOfStreams.basic_forward
+        # if last move was backwards, then @current_stream is
+        # equivalent to s. Move to next stream.
+        next if dir == :backward
+
+        s.set_to_begin
+        if s.at_end? # empty stream?
+          next # skip it
+        else
+          @current_stream = s
+          return false # found non empty stream
+        end
+      end # until
+      reached_boundary # sets @dir_of_last_move and @current_stream
     end
 
-	  # Same as at_end? the other way round.
+    # Same as at_end? the other way round.
+    # @return [Boolean]
     def at_beginning?
-	    # same algorithm as at_end? the other way round.
- 	    if @currentStream.at_beginning?
+      # same algorithm as at_end? the other way round.
+      unless @current_stream.at_beginning?
         return false
-      else
-		    until streamOfStreams.at_beginning?
-			    dir, @dirOfLastMove = @dirOfLastMove, :backward
-			    s = streamOfStreams.basic_backward
-			    next if dir == :forward
-			    s.set_to_end
-			    if s.at_beginning?
-			      next
-			    else
-			      @currentStream = s
-			      return false
-			    end
-		    end
-		    reachedBoundary
-		  end
-  	end
-
-	  def set_to_begin; super; reachedBoundary end
-	  def set_to_end; super; reachedBoundary end
-
-	  # Returns the next element of @currentStream. at_end? ensured that there is
-	  # one.
-	  def basic_forward; @currentStream.basic_forward end
-	  # Returns the previous element of @currentStream. at_beginning? ensured that
-	  # there is one.
-	  def basic_backward; @currentStream.basic_backward end
-
-	  private
-
-	  def reachedBoundary
-	    @currentStream = EmptyStream.instance
-	    @dirOfLastMove = :none	# not :forward or :backward
-	    true
-	  end
-	  # Uff, this was the hardest stream to implement.
-  end							# ConcatenatedStream
+      end
+
+      until streamOfStreams.at_beginning?
+        dir = @dir_of_last_move
+        @dir_of_last_move = :backward
+        s = streamOfStreams.basic_backward
+        next if dir == :forward
+
+        s.set_to_end
+        if s.at_beginning?
+          next
+        else
+          @current_stream = s
+          return false
+        end
+      end
+      reached_boundary
+    end
+
+    def set_to_begin
+      super; reached_boundary
+    end
+
+    def set_to_end
+      super; reached_boundary
+    end
+
+    # Returns the next element of @current_stream. at_end? ensured that there is
+    # one.
+    def basic_forward
+      @current_stream.basic_forward
+    end
+
+    # Returns the previous element of @current_stream. at_beginning? ensured that
+    # there is one.
+    def basic_backward
+      @current_stream.basic_backward
+    end
+
+    private
+
+    def reached_boundary
+      @current_stream = EmptyStream.instance
+      @dir_of_last_move = :none # not :forward or :backward
+      true
+    end
+    # Uff, this was the hardest stream to implement.
+  end
+
+  # ConcatenatedStream
 
   # An ImplicitStream is an easy way to create a stream on the fly without
   # defining a subclass of BasicStream. The basic methods required for a stream
@@ -463,72 +606,96 @@ module Stream
   # remove the first or last element of an existing stream (see remove_first
   # and remove_last).
   class ImplicitStream < BasicStream
-	  attr_writer :at_beginning_proc, :at_end_proc, :forward_proc,
+    attr_writer :at_beginning_proc, :at_end_proc, :forward_proc,
                 :backward_proc, :set_to_begin_proc, :set_to_end_proc
-	  attr_reader :wrapped_stream
-
-	  # Create a new ImplicitStream which might wrap an existing stream
-	  # _otherStream_. If _otherStream_ is supplied the blocks for the basic
-	  # stream methods are initialized with closures that delegate all operations
-	  # to the wrapped stream.
-	  #
-	  # If a block is given to new, than it is called with the new ImplicitStream
-	  # stream as parameter letting the client overwriting the default blocks.
-	  def initialize(otherStream=nil)
-	    if otherStream
-		    @wrapped_stream = otherStream
-		    @at_beginning_proc = proc {otherStream.at_beginning?}
-		    @at_end_proc = proc {otherStream.at_end?}
-		    @forward_proc = proc {otherStream.basic_forward}
-		    @backward_proc = proc {otherStream.basic_backward}
-		    @set_to_end_proc = proc {otherStream.set_to_end}
-		    @set_to_begin_proc = proc {otherStream.set_to_begin}
-	    end
-	    yield self if block_given? # let client overwrite defaults
-
-	    @at_beginning_proc = proc {true} unless @at_beginning_proc
-	    @at_end_proc = proc {true} unless @at_end_proc
-	  end
-
-	  # Returns the value of @at_beginning_proc.
-	  def at_beginning?; @at_beginning_proc.call; end
-	  # Returns the value of @at_end_proc.
-	  def at_end?; @at_end_proc.call; end
-
-	  # Returns the value of @forward_proc.
-	  def basic_forward; @forward_proc.call; end
-	  # Returns the value of @backward_proc_proc.
-	  def basic_backward; @backward_proc.call; end
-
-	  # Calls set_to_end_proc or super if set_to_end_proc is undefined.
-	  def set_to_end
-	    @set_to_end_proc ? @set_to_end_proc.call : super
-	  end
-
-	  # Calls set_to_begin_proc or super if set_to_begin_proc is undefined.
-	  def set_to_begin
-	    @set_to_begin_proc ? @set_to_begin_proc.call : super
-	  end
-  end							# ImplicitStream
+    attr_reader :wrapped_stream
+
+    # Create a new ImplicitStream which might wrap an existing stream
+    # _other_stream_. If _other_stream_ is supplied the blocks for the basic
+    # stream methods are initialized with closures that delegate all operations
+    # to the wrapped stream.
+    #
+    # If a block is given to new, than it is called with the new ImplicitStream
+    # stream as parameter letting the client overwriting the default blocks.
+    def initialize(other_stream = nil)
+      # Initialize with defaults
+      @at_beginning_proc = proc { true }
+      @at_end_proc = proc { true }
+
+      @set_to_begin_proc = proc {}
+      @set_to_end_proc = proc {}
+
+      if other_stream
+        @wrapped_stream = other_stream
+        @at_beginning_proc = proc { other_stream.at_beginning? }
+        @at_end_proc = proc { other_stream.at_end? }
+        @forward_proc = proc { other_stream.basic_forward }
+        @backward_proc = proc { other_stream.basic_backward }
+        @set_to_end_proc = proc { other_stream.set_to_end }
+        @set_to_begin_proc = proc { other_stream.set_to_begin }
+      end
+      yield self if block_given? # let client overwrite defaults
+    end
+
+    # Returns the value of @at_beginning_proc.
+    def at_beginning?
+      @at_beginning_proc.call
+    end
+
+    # Returns the value of @at_end_proc.
+    def at_end?
+      @at_end_proc.call
+    end
+
+    # Returns the value of @forward_proc.
+    def basic_forward
+      @forward_proc.call
+    end
+
+    # Returns the value of @backward_proc_proc.
+    def basic_backward
+      @backward_proc.call
+    end
+
+    # Calls set_to_end_proc or super if set_to_end_proc is undefined.
+    def set_to_end
+      @set_to_end_proc ? @set_to_end_proc.call : super
+    end
+
+    # Calls set_to_begin_proc or super if set_to_begin_proc is undefined.
+    def set_to_begin
+      @set_to_begin_proc ? @set_to_begin_proc.call : super
+    end
+  end
+
+  # ImplicitStream
 
   # Stream creation functions
 
   ##
   # Return a Stream::FilteredStream which iterates over all my elements
   # satisfying the condition specified  by the block.
-  def filtered(&block); FilteredStream.new(self,&block); end
+  def filtered(&block)
+    FilteredStream.new(self, &block)
+  end
 
   # Create a Stream::ReversedStream wrapper on self.
-  def reverse; ReversedStream.new self; end
+  def reverse
+    ReversedStream.new self
+  end
 
   # Create a Stream::MappedStream wrapper on self. Instead of returning the
   # stream element on each move, the value of calling _mapping_ is returned
   # instead. See Stream::MappedStream for examples.
-  def collect(&mapping); MappedStream.new(self, &mapping); end
+  def collect(&mapping)
+    MappedStream.new(self, &mapping)
+  end
 
   # Create a Stream::ConcatenatedStream on self, which must be a stream of
   # streams.
-  def concatenate; ConcatenatedStream.new self; end
+  def concatenate
+    ConcatenatedStream.new self
+  end
 
   # Create a Stream::ConcatenatedStream, concatenated from streams build with
   # the block for each element of self:
@@ -537,33 +704,37 @@ module Stream
   #    [i,-i].create_stream
   #  }.
   #  s.to_a ==> [1, -1, 2, -2, 3, -3]
-  def concatenate_collected(&mapping); self.collect(&mapping).concatenate; end
+  def concatenate_collected(&mapping)
+    collect(&mapping).concatenate
+  end
 
   # Create a Stream::ConcatenatedStream by concatenatating the receiver and
-  # _otherStream_
+  # _other_stream_
   #
   #  (%w(a b c).create_stream + [4,5].create_stream).to_a
   #  ==> ["a", "b", "c", 4, 5]
-  def +(otherStream)
-	  [self, otherStream].create_stream.concatenate
+  def +(other)
+    [self, other].create_stream.concatenate
   end
 
   # Create a Stream::ImplicitStream which wraps the receiver stream by modifying
   # one or more basic methods of the receiver. As an example the method
   # remove_first uses #modify to create an ImplicitStream which filters the
   # first element away.
-  def modify(&block); ImplicitStream.new(self, &block); end
+  def modify(&block)
+    ImplicitStream.new(self, &block)
+  end
 
   # Returns a Stream::ImplicitStream wrapping a Stream::FilteredStream, which
   # eliminates the first element of the receiver.
   #
   #  (1..3).create_stream.remove_first.to_a ==> [2,3]
   def remove_first
-	  i = 0
-	  filter = self.filtered { i += 1; i > 1 }
-	  filter.modify { |s|
-	    s.set_to_begin_proc = proc {filter.set_to_begin; i = 0}
-	  }
+    i = 0
+    filter = filtered { i += 1; i > 1 }
+    filter.modify do |s|
+      s.set_to_begin_proc = proc { filter.set_to_begin; i = 0 }
+    end
   end
 
   # Returns a Stream which eliminates the first element of the receiver.
@@ -573,7 +744,7 @@ module Stream
   # <em>Take a look at the source. The implementation is inefficient but
   # elegant.</em>
   def remove_last
-	  self.reverse.remove_first.reverse	# I like this one
+    reverse.remove_first.reverse # I like this one
   end
 end