stream 0.5 → 0.5.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3374a923bc2d44c39ea1c1957d5982b26f55a22ac958cfa119be87a978e17676
+  data.tar.gz: 88b9b768b08a6edf3a689f76f50627784825b15ac1ed07d6b3172bb34ce69fa3
+SHA512:
+  metadata.gz: fd0f115fefc0969ccde444c8200d9f279b8d9736af6c91884d89e5fa9dd4a46dccb6b570da4467b7dfaa35e038644b09dbf25348289a66cf0ea919c4c21c732b
+  data.tar.gz: 56d49b892e3355026bb05bd98535471ebfe9e8564f9f1885e43938deda8b7f3e33551fcd15f1b492821944de5707ef296dff3f134812b1f8e904ce0ef8b4f037

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,37 @@
+PATH
+  remote: .
+  specs:
+    stream (0.5.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    codeclimate-test-reporter (1.0.9)
+      simplecov (<= 0.13)
+    docile (1.1.5)
+    json (2.1.0)
+    power_assert (1.1.3)
+    rake (12.3.2)
+    rdoc (6.1.1)
+    simplecov (0.13.0)
+      docile (~> 1.1.0)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+    test-unit (3.2.9)
+      power_assert
+    yard (0.9.16)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  codeclimate-test-reporter
+  rake
+  rdoc
+  stream!
+  test-unit
+  yard
+
+BUNDLED WITH
+   2.0.1

data/{README → README.rdoc}

@@ -1,3 +1,5 @@
+{<img src="https://secure.travis-ci.org/monora/stream.png?branch=master" alt="Build Status" />}[https://travis-ci.org/monora/stream]
+
 = Extended External Iterators (forward and backward)
 
 == Description
@@ -24,7 +26,7 @@ exactly defined
  s.current_edge == [s.current, s.peek]
 
 If s a stream on [x1,...,xn]. Consider the edges [xi,xi+1] i=1,...,n and
-[x0,x1] and [xn,xn+1] (x0 and xn are helper elements to define the boundary
+[x0,x1] and [xn,xn+1] (x0 and xn+1 are helper elements to define the boundary
 conditions). Then if s is non empty, the following conditions must be true:
 
  s.at_beginning? <=> s.current_edge == [x0,x1]
@@ -87,7 +89,7 @@ There are several concrete classes implementing the stream interface:
 
 The latest version of stream.rb can be found at
 
-* http://rubyforge.org/frs/?group_id=110
+* http://github.com/monora/stream
 
 == Installation
 
@@ -112,7 +114,6 @@ root privileges to install.
 
 * Streams in Smalltalk: http://wiki.cs.uiuc.edu/PatternStories/FunWithStreams
 * Simon Strandgaards iterator.rb[http://aeditor.rubyforge.org/iterator/files/iterator_rb.html]
-* IterationStyles: http://www.rubygarden.org/ruby?IterationStyles
 
 == Examples
 
@@ -166,9 +167,6 @@ root privileges to install.
 
 == Other Stuff
 
-$Revision: 1.1.1.1 $
-$Date: 2004/05/13 23:30:03 $
-
-Author:: Horst Duchene <hd.at.clr@hduchene.de>
-License:: Copyright (c) 2001, 2004 Horst Duchene
+Author:: Horst Duchene
+License:: Copyright (c) 2001, 2013, 2016 Horst Duchene
 Released under the same license as Ruby

data/Rakefile

@@ -1,22 +1,15 @@
-# Rakefile for         -*- ruby -*-
+# Rakefile for stream   -*- ruby -*-
 
-begin
-  require 'rubygems'
-rescue Exception
-  nil
-end
-require 'rake/clean'
-require 'rake/testtask'
-require 'rake/gempackagetask'
-require 'rake/rdoctask'
+require 'rubygems'
+require 'bundler/setup'
+require 'rubygems/package_task'
 
-# Determine the current version of the software
+require 'rake/testtask'
+require 'rake/clean'
+require 'yard'
 
-if `ruby -Ilib -rstream -e'puts STREAM_VERSION'` =~ /\S+$/
-  PKG_VERSION = $&
-else
-  PKG_VERSION = "0.0.0"
-end
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
+require 'stream' # require module to STREAM_VERSION
 
 SRC_RB = FileList['lib/*.rb']
 
@@ -27,11 +20,11 @@ task :default => :test
 
 # Define a test task.
 
-Rake::TestTask.new { |t|
-  #t.libs << "tests"
-  #t.pattern = 'tests/Test*.rb'
+Rake::TestTask.new do |t|
+  t.libs << "tests"
+  t.pattern = 'tests/Test*.rb'
   t.verbose = true
-}
+end
 
 task :test
 
@@ -39,123 +32,19 @@ task :test
 desc "Run all test targets"
 task :testall => [:test ]
 
-# Install stream using the standard install.rb script.
+# Git tagging
 
-desc "Install the application"
-task :install do
-  ruby "install.rb"
+desc "Commit all changes as a new version commit. Tag the commit with v<version> tag"
+task :tag do
+  puts "Committing and tagging version #{STREAM_VERSION}"
+  `git commit -am 'Version #{STREAM_VERSION}'`
+  `git tag 'v#{STREAM_VERSION}'`
 end
 
-# Create a task to build the RDOC documentation tree.
-
-rd = Rake::RDocTask.new("rdoc") { |rdoc|
-  rdoc.rdoc_dir = 'html'
-#  rdoc.template = 'kilmer'
-#  rdoc.template = 'css2'
-  rdoc.title    = "Stream - Extended External Iterators"
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include('README')
-  rdoc.rdoc_files.include('lib/*.rb', 'doc/**/*.rdoc')
-}
-
-# ====================================================================
-# Create a task that will package the stream software into distributable
-# tar, zip and gem files.
-
-PKG_FILES = FileList[
-  'install.rb',
-  '[A-Z]*',
-  'lib/**/*.rb', 
-  'test/**/*.rb',
-  'examples/**/*'
-]
-
-if ! defined?(Gem)
-  puts "Package Target requires RubyGEMs"
-else
-  spec = Gem::Specification.new do |s|
-    
-    #### Basic information.
-
-    s.name = 'stream'
-    s.version = PKG_VERSION
-    s.summary = "Stream - Extended External Iterators"
-    s.description = <<-EOF
-      Module Stream defines an interface for external iterators.
-    EOF
-
-    #### Dependencies and requirements.
-
-    #s.add_dependency('log4r', '> 1.0.4')
-    #s.requirements << ""
-
-    #### Which files are to be included in this gem?  Everything!  (Except CVS directories.)
-
-    s.files = PKG_FILES.to_a
+# Documentation
 
-    #### C code extensions.
+YARD::Rake::YardocTask.new
 
-    #s.extensions << "ext/rmagic/extconf.rb"
+# Tasks for building and installing Stream gem.
 
-    #### Load-time details: library and application (you will need one or both).
-
-    s.require_path = 'lib'                         # Use these for libraries.
-    s.autorequire = 'stream'
-
-    #### Documentation and testing.
-
-    s.has_rdoc = true
-    #s.test_suite_file = "test/rmagic-tests.rb"
-
-    #### Author and project details.
-    s.author = "Horst Duchene"
-    s.email = "hd.at.clr@hduchene.de"
-    s.homepage = "http://rgl.rubyforge.org"
-    s.rubyforge_project = "rgl"
-  end
-
-  Rake::GemPackageTask.new(spec) do |pkg|
-    pkg.need_zip = true
-    pkg.need_tar = true
-  end
-end
-
-# Misc tasks =========================================================
-
-def count_lines(filename)
-  lines = 0
-  codelines = 0
-  open(filename) { |f|
-    f.each do |line|
-      lines += 1
-      next if line =~ /^\s*$/
-      next if line =~ /^\s*#/
-      codelines += 1
-    end
-  }
-  [lines, codelines]
-end
-
-def show_line(msg, lines, loc)
-  printf "%6s %6s   %s\n", lines.to_s, loc.to_s, msg
-end
-
-desc "Count lines in the main files"
-task :lines do
-  total_lines = 0
-  total_code = 0
-  show_line("File Name", "LINES", "LOC")
-  SRC_RB.each do |fn|
-    lines, codelines = count_lines(fn)
-    show_line(fn, lines, codelines)
-    total_lines += lines
-    total_code  += codelines
-  end
-  show_line("TOTAL", total_lines, total_code)
-end
-
-ARCHIVEDIR = '/mnt/flash'
-
-task :archive => [:package] do
-  cp FileList["pkg/*.tgz", "pkg/*.zip", "pkg/*.gem"], ARCHIVEDIR
-end
+Bundler::GemHelper.install_tasks

data/lib/stream.rb

@@ -1,4 +1,4 @@
-STREAM_VERSION = "0.5"
+STREAM_VERSION = "0.5.2"
 
 ##
 # Module Stream defines an interface for an external Iterator which
@@ -62,25 +62,25 @@ 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.
+
+  # 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
 
   # Returns the element returned by the last call of #backward. If at_end? is
@@ -110,9 +110,9 @@ module Stream
       yield basic_forward
     end
   end
-  
-  # create_stream is used for each Enumerable to create a stream for it. A Stream as
-  # an Enumerable returns itself.
+
+  # 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
 
   # A Stream::WrappedStream should return the wrapped stream unwrapped. If the
@@ -122,80 +122,83 @@ module Stream
   # 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?
+  # 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
   end
 
-  # A CollectionStream can be used as an external iterator for each interger-indexed
-  # collection. The state of the iterator is stored in instance variable @pos.
+  # A CollectionStream can be used as an external iterator for each
+  # interger-indexed collection. The state of the iterator is stored in instance
+  # variable @pos.
   #
-  # A CollectionStream for an array is created by the method Array#create_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
+	  def at_beginning?; @pos < 0; end
 
-	# positioning
+	  # positioning
 
-	#
-	def set_to_begin; @pos = -1; end
-	def set_to_end; @pos = @seq.size - 1; 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
-	def basic_backward; r = @seq[@pos]; @pos -= 1; r; end
+	  def basic_forward; @pos += 1; @seq[@pos]; end
+	  def basic_backward; r = @seq[@pos]; @pos -= 1; r; end
 
-	protected
+	  protected
 
-	# 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
+	  # 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
 
   end							# 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 be
-  # made private but if somebody needs it here it is. Is there a better name for it?
+  # zero up to a given upper bound. Mainly used by Stream::FilteredStream. Could
+  # be made private but if somebody needs it here it is. Is there a better name
+  # for it?
   #
-  # The upper bound is stored in the instance variable @stop which can be incremented
-  # dynamically by the method increment_stop.
+  # 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
+	  # 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
+	  def at_beginning?; @pos < 0; end
+	  def at_end?; @pos == @stop; end
 
-	def set_to_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_backward;  @pos -= 1; @pos + 1; end
+	  def basic_forward; @pos += 1; end
+	  def basic_backward;  @pos -= 1; @pos + 1; end
   end
 
   # Class WrappedStream is the abstract superclass for stream classes that wrap
@@ -208,25 +211,25 @@ 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 _otherStream_.
-	def initialize (otherStream)
-	  @wrapped_stream = otherStream
-	end
+	  # Create a new WrappedStream wrapping the Stream _otherStream_.
+	  def initialize(otherStream)
+	    @wrapped_stream = otherStream
+	  end
 
-	def at_beginning?; @wrapped_stream.at_beginning?; 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_begin; @wrapped_stream.set_to_begin; end
+	  def set_to_end; @wrapped_stream.set_to_end; 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
+	  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
   end
 
   ##
@@ -238,212 +241,215 @@ module Stream
   #  (1..6).create_stream.filtered { |x| x % 2 == 0 }.to_a ==> [2, 4, 6]
   class FilteredStream < WrappedStream
 
-	# 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
+	  # 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
 
   ##
-  # Each reversable stream (a stream that implements #backward and at_beginning?) can
-  # be wrapped by a ReversedStream.
+  # Each reversable stream (a stream that implements #backward and
+  # at_beginning?) can be wrapped by a ReversedStream.
   #
   # A ReversedStream is created by the method #reverse:
   #
   #  (1..6).create_stream.reverse.to_a ==> [6, 5, 4, 3, 2, 1]
   class ReversedStream < WrappedStream
 
-	# 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_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
-
-	# 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  
+	  # 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_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
+
+	  # 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
 
   ##
-  # The analog to Enumerable#collect for a stream is a MappedStream wrapping another
-  # stream. A MappedStream is created by the method #collect, thus modifying
-  # the behavior mixed in by Enumerable:
+  # The analog to Enumerable#collect for a stream is a MappedStream wrapping
+  # another stream. A MappedStream is created by the method #collect, thus
+  # modifying the behavior mixed in by Enumerable:
   #
   #  (1..5).create_stream.collect {|x| x**2}.type ==> Stream::MappedStream
   #  (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 _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 previous element in the wrapped stream and return
-	# the result.
-	def basic_backward; @mapping.call(super); 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 previous element in the wrapped stream
+	  # and return the result.
+	  def basic_backward; @mapping.call(super); end
   end
 
   ##
-  # Given a stream of streams. Than a ConcatenatedStream is obtained by concatenating
-  # these in the given order. A ConcatenatedStream is created by the methods
-  # Stream#concatenate or Stream#concatenate_collected send to a stream of streams or
-  # by the method + which concatenats two streams:
+  # Given a stream of streams. Than a ConcatenatedStream is obtained by
+  # concatenating these in the given order. A ConcatenatedStream is created by
+  # the methods Stream#concatenate or Stream#concatenate_collected send to a
+  # stream of streams or by the method + which concatenats two streams:
   #
   #  ((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?
- 	  @currentStream.at_end? and
-		begin
-		  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
-		  reachedBoundary		# sets @dirOfLastMove and @currentStream
-		end
-  	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?
+ 	    if @currentStream.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
+    end
 
-	# Same as at_end? the other way round.
-  	def at_beginning?
-	  # same algorithm as at_end? the other way round. Could we do it
-	  # with metaprogramming?
- 	  @currentStream.at_beginning? and
-		begin
-		  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
+	  # Same as at_end? the other way round.
+    def at_beginning?
+	    # same algorithm as at_end? the other way round.
+ 	    if @currentStream.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
-		  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.
+
+	  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
 
-  # 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 are defined with
-  # blocks: 
+  # 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
+  # are defined with blocks:
   #
   #  s = Stream::ImplicitStream.new { |s|
   #		x = 0
-  #		s.at_end_proc = proc {x == 5}
-  #		s.forward_proc = proc {x += 1 }
+  #		s.at_end_proc = proc { x == 5 }
+  #		s.forward_proc = proc { x += 1 }
   #	 }
   #
   #  s.to_a ==> [1, 2, 3, 4, 5]
@@ -457,51 +463,52 @@ 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, :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}
+	  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
-	  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
 
   # Stream creation functions
@@ -509,59 +516,64 @@ module Stream
   ##
   # 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
-  
-  # 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
 
-  # Create a Stream::ConcatenatedStream on self, which must be a stream of streams.
+  # 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
+
+  # Create a Stream::ConcatenatedStream on self, which must be a stream of
+  # streams.
   def concatenate; ConcatenatedStream.new self; end
 
-  # Create a Stream::ConcatenatedStream, concatenated from streams build with the
-  # block for each element of self:
-  # 
+  # Create a Stream::ConcatenatedStream, concatenated from streams build with
+  # the block for each element of self:
+  #
   #  s = [1, 2, 3].create_stream.concatenate_collected { |i|
   #    [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); self.collect(&mapping).concatenate; end
 
-  # Create a Stream::ConcatenatedStream by concatenatating the receiver and _otherStream_
+  # Create a Stream::ConcatenatedStream by concatenatating the receiver and
+  # _otherStream_
   #
-  #  (%w(a b c).create_stream + [4,5].create_stream).to_a ==> ["a", "b", "c", 4, 5]
-  def + (otherStream)
-	[self, otherStream].create_stream.concatenate
+  #  (%w(a b c).create_stream + [4,5].create_stream).to_a
+  #  ==> ["a", "b", "c", 4, 5]
+  def +(otherStream)
+	  [self, otherStream].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
+  # 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
 
   # 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 { | element | i += 1; i > 1 }
-	filter.modify { |s|
-	  s.set_to_begin_proc = proc {filter.set_to_begin; i = 0}
-	}
+	  i = 0
+	  filter = self.filtered { i += 1; i > 1 }
+	  filter.modify { |s|
+	    s.set_to_begin_proc = proc {filter.set_to_begin; i = 0}
+	  }
   end
 
   # Returns a Stream which eliminates the first element of the receiver.
   #
   #  (1..3).create_stream.remove_last.to_a ==> [1,2]
   #
-  # <em>Take a look at the source. The implementation is inefficient but elegant.</em>
+  # <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
+	  self.reverse.remove_first.reverse	# I like this one
   end
 end
 

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
+require 'rubygems'
+require 'test/unit'

metadata

@@ -1,64 +1,116 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: stream
-version: !ruby/object:Gem::Version 
-  version: "0.5"
+version: !ruby/object:Gem::Version
+  version: 0.5.2
 platform: ruby
-authors: 
+authors:
 - Horst Duchene
 autorequire: stream
 bindir: bin
 cert_chain: []
-
-date: 2009-11-24 00:00:00 -07:00
-default_executable: 
-dependencies: []
-
-description: "      Module Stream defines an interface for external iterators.\n"
-email: hd.at.clr@hduchene.de
+date: 2019-01-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Module Stream defines an interface for external iterators.
+email: monora@gmail.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: []
-
-files: 
-- install.rb
+extra_rdoc_files:
+- README.rdoc
+files:
+- Gemfile
+- Gemfile.lock
+- README.rdoc
 - Rakefile
-- README
+- examples/examples.rb
+- examples/streamtester.rb
 - lib/generator2stream.rb
 - lib/stream.rb
 - test/bm.rb
+- test/test_helper.rb
 - test/testgenerator.rb
 - test/teststream.rb
-- examples/examples.rb
-- examples/streamtester.rb
-has_rdoc: true
-homepage: http://rgl.rubyforge.org
+homepage: https://github.com/monora/stream
 licenses: []
-
+metadata: {}
 post_install_message: 
-rdoc_options: []
-
-require_paths: 
+rdoc_options:
+- "--title"
+- stream - Extended External Iterators
+- "--main"
+- README.rdoc
+- "--line-numbers"
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
+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: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: rgl
-rubygems_version: 1.3.5
+rubyforge_project: 
+rubygems_version: 2.7.7
 signing_key: 
-specification_version: 3
-summary: Stream - Extended External Iterators
+specification_version: 4
+summary: stream - Extended External Iterators
 test_files: []
-

data/install.rb

@@ -1,24 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'rbconfig'
-require 'ftools'
-require 'find'
-
-SRC_BASE = 'lib'
-INSTDIR = File.join Config::CONFIG['sitedir']
-
-def install
-  begin
-    pwd = Dir.pwd
-    Dir.chdir(SRC_BASE)
-	Dir['*.rb'].each do |file|
-      dst = File.join( INSTDIR, file )
-      File.install(file, dst, 0644, true)
-    end
-    Dir.chdir(pwd)
-  rescue
-    puts $!
-  end
-end
-
-install