stream 0.5.2 → 0.5.3

data/test/test_helper.rb

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

data/test/teststream.rb

@@ -2,85 +2,89 @@ require 'test/unit'
 require 'stream'
 
 module StreamExamples
-  def new_collection_stream; (1..5).create_stream; end
+  def new_collection_stream
+    (1..5).create_stream;
+  end
 
   # a stream which is aquivalent to new_collection_stream
   def new_implicit_stream
-    s = Stream::ImplicitStream.new { |s|
-	  x = 0
-      s.at_beginning_proc = proc {x < 1}
-      s.at_end_proc = proc {x == 5}
-      s.forward_proc = proc {x += 1 }
-      s.backward_proc = proc {y = x; x -= 1; y }
+    Stream::ImplicitStream.new { |s|
+      x = 0
+      s.at_beginning_proc = proc { x < 1 }
+      s.at_end_proc = proc { x == 5 }
+      s.forward_proc = proc { x += 1 }
+      s.backward_proc = proc { y = x; x -= 1; y }
+      s.set_to_begin_proc = proc { x = 0 }
+      s.set_to_end_proc = proc { x = 5 }
     }
   end
 
   def filtered_streams
-	[
-	  new_collection_stream.filtered { |x| true },
-	  new_collection_stream.filtered { |x| false },
-	  new_collection_stream.filtered { |x| x > 3 },
-	  new_collection_stream.filtered { |x| x % 2 == 0 },
-	  new_collection_stream.filtered { |x| x % 2 == 0 }.filtered { |x| x > 3 }
-	]
+    [
+        new_collection_stream.filtered { |x| true },
+        new_collection_stream.filtered { |x| false },
+        new_collection_stream.filtered { |x| x > 3 },
+        new_collection_stream.filtered { |x| x % 2 == 0 },
+        new_collection_stream.filtered { |x| x % 2 == 0 }.filtered { |x| x > 3 }
+    ]
   end
 
   def new_concatenated_stream
-	[1, 2, 3].create_stream.concatenate_collected { |i|
-	  [i,-i].create_stream
-	}
+    [1, 2, 3].create_stream.concatenate_collected { |i|
+      [i, -i].create_stream
+    }
   end
 
   def all_examples
-	[
-	  new_collection_stream,
-	  new_implicit_stream,
-	  new_collection_stream.remove_first,
-	  new_collection_stream.remove_last,
-	  new_collection_stream.remove_first.remove_last,
-	  Stream::WrappedStream.new(new_collection_stream),
-	  Stream::IntervalStream.new(6),
-	  Stream::IntervalStream.new(1),
-	  new_collection_stream.collect { |x| x * 2 },
-
-	  # Some concatenated streams
-	  Stream::EmptyStream.instance.concatenate,
-	  new_concatenated_stream,
-	  # concatenated inside concatenated
-	  new_concatenated_stream + new_concatenated_stream,
-	  new_collection_stream + Stream::EmptyStream.instance,
-	  Stream::EmptyStream.instance + new_collection_stream
-	].concat(filtered_streams)
+    [
+        new_collection_stream,
+        new_implicit_stream,
+        new_collection_stream.remove_first,
+        new_collection_stream.remove_last,
+        new_collection_stream.remove_first.remove_last,
+        Stream::WrappedStream.new(new_collection_stream),
+        Stream::IntervalStream.new(6),
+        Stream::IntervalStream.new(1),
+        new_collection_stream.collect { |x| x * 2 },
+
+        # Some concatenated streams
+        Stream::EmptyStream.instance.concatenate,
+        new_concatenated_stream,
+        # concatenated inside concatenated
+        new_concatenated_stream + new_concatenated_stream,
+        new_collection_stream + Stream::EmptyStream.instance,
+        Stream::EmptyStream.instance + new_collection_stream
+    ].concat(filtered_streams)
   end
 
   private
 
   def standard_tests_for(s)
-    arrayStream = s.to_a.create_stream	# A collection stream that should be OK
-    assert_equal(s.to_a, arrayStream.to_a)
+    array_stream = s.to_a.create_stream # A collection stream that should be OK
+    assert_equal(s.to_a, array_stream.to_a)
     # Tests at end of stream
-    assert_equal(s.at_end?, arrayStream.at_end?)
-    assert_raises(Stream::EndOfStreamException) {s.forward}
-    assert_equal(s.at_beginning?, arrayStream.at_beginning?)
-    assert_equal(s.peek,s)
-    unless arrayStream.at_beginning?
-      assert_equal(arrayStream.current,s.current)
-      assert_equal(arrayStream.backward, s.backward)
+    assert_equal(s.at_end?, array_stream.at_end?)
+    assert_raises(Stream::EndOfStreamException) { s.forward }
+    assert_equal(s.at_beginning?, array_stream.at_beginning?)
+    assert_equal(s.peek, s)
+    unless array_stream.at_beginning?
+      assert_equal(array_stream.current, s.current)
+      assert_equal(array_stream.backward, s.backward)
     end
-    assert_equal(arrayStream.at_end?, s.at_end?)
-    
+    assert_equal(array_stream.at_end?, s.at_end?)
+
     # Tests at begin of stream
-    s.set_to_begin; arrayStream.set_to_begin
-    assert_raises(Stream::EndOfStreamException) {s.backward}
-    assert_equal(s.at_beginning?,arrayStream.at_beginning?)
-    assert_equal(s.at_end?,arrayStream.at_end?)
-    assert_equal(s.current,s)
-    unless arrayStream.at_end?
-      assert_equal(s.peek,arrayStream.peek)
-      assert_equal(s.forward,arrayStream.forward)
-      assert_equal(s.current,arrayStream.current)
-      unless arrayStream.at_end?
-        assert_equal(s.peek,arrayStream.peek)
+    s.set_to_begin; array_stream.set_to_begin
+    assert_raises(Stream::EndOfStreamException) { s.backward }
+    assert_equal(s.at_beginning?, array_stream.at_beginning?)
+    assert_equal(s.at_end?, array_stream.at_end?)
+    assert_equal(s.current, s)
+    unless array_stream.at_end?
+      assert_equal(s.peek, array_stream.peek)
+      assert_equal(s.forward, array_stream.forward)
+      assert_equal(s.current, array_stream.current)
+      unless array_stream.at_end?
+        assert_equal(s.peek, array_stream.peek)
       end
     end
   end
@@ -92,15 +96,15 @@ class TestStream < Test::Unit::TestCase
 
   def test_enumerable
     s = new_collection_stream
-    assert_equal([2, 4, 6, 8, 10], s.collect {|x| x*2}.entries)
-    assert_equal([2,4],s.select {|x| x[0]== 0})# even numbers
+    assert_equal([2, 4, 6, 8, 10], s.collect { |x| x * 2 }.entries)
+    assert_equal([2, 4], s.select { |x| x[0] == 0 }) # even numbers
   end
 
   def test_collection_stream
     s = new_collection_stream
     assert_equal([1, 2, 3, 4, 5], s.entries)
     assert(s.at_end?)
-	assert_raises(Stream::EndOfStreamException) {s.forward}
+    assert_raises(Stream::EndOfStreamException) { s.forward }
     assert_equal(5, s.backward)
     assert_equal(5, s.forward)
     assert_equal(5, s.current)
@@ -108,70 +112,76 @@ class TestStream < Test::Unit::TestCase
 
     s.set_to_begin
     assert(s.at_beginning?)
-	assert_raises(Stream::EndOfStreamException) {s.backward}
+    assert_raises(Stream::EndOfStreamException) { s.backward }
     assert_equal(s, s.current)
     assert_equal(1, s.peek)
     assert_equal(1, s.forward)
     assert_equal(1, s.current)
     assert_equal(2, s.peek)
 
-	# move_forward_until
-	assert_equal(4, s.move_forward_until { |x| x > 3 })
-	assert_equal(nil, s.move_forward_until { |x| x < 3 })
-	assert(s.at_end?)
+    # move_forward_until
+    assert_equal(4, s.move_forward_until { |x| x > 3 })
+    assert_equal(nil, s.move_forward_until { |x| x < 3 })
+    assert(s.at_end?)
 
-	s.set_to_begin
-	assert_equal(nil, s.move_forward_until { |x| x > 6 })
+    s.set_to_begin
+    assert_equal(nil, s.move_forward_until { |x| x > 6 })
   end
 
   def test_standard_for_examples
-	all_examples.each do |exampleStream|
-	  standard_tests_for(exampleStream)
-	end
+    all_examples.each do |example_stream|
+      standard_tests_for(example_stream)
+    end
   end
 
   def test_for_examples_reversed
-	all_examples.each do |exampleStream|
-	  assert_equal(exampleStream.entries.reverse, exampleStream.reverse.entries)
-	  assert_equal(exampleStream.entries, exampleStream.reverse.reverse.entries)
-	  standard_tests_for(exampleStream.reverse)
-	  standard_tests_for(exampleStream.reverse.reverse)
-	end
+    all_examples.each do |example_stream|
+      assert_equal(example_stream.entries.reverse, example_stream.reverse.entries)
+      assert_equal(example_stream.entries, example_stream.reverse.reverse.entries)
+      standard_tests_for(example_stream.reverse)
+      standard_tests_for(example_stream.reverse.reverse)
+    end
   end
 
   def test_filtered_stream
-    [(1..6).create_stream.filtered {|x| x % 2 == 0 }].each do |s| 
-	  standard_tests_for(s)
-	end
+    [(1..6).create_stream.filtered { |x| x % 2 == 0 }].each do |s|
+      standard_tests_for(s)
+    end
   end
 
   def test_interval_stream
-	s = Stream::IntervalStream.new 6
-	standard_tests_for(s)
-	assert_equal([0, 1, 2, 3, 4, 5], s.entries)
-	s.increment_stop
-	assert(!s.at_end?)
-	assert_equal([0, 1, 2, 3, 4, 5, 6], s.entries)
-	standard_tests_for(s)
+    s = Stream::IntervalStream.new 6
+    standard_tests_for(s)
+    assert_equal([0, 1, 2, 3, 4, 5], s.entries)
+    s.increment_stop
+    assert(!s.at_end?)
+    assert_equal([0, 1, 2, 3, 4, 5, 6], s.entries)
+    standard_tests_for(s)
   end
 
   def test_enumerable_protocol
-	s = [1, 2, 3, 4, 5].create_stream
-	assert(s.include?(2))
-	assert_equal(3,s.detect {|x| x > 2})
-	assert_equal(nil,s.detect {|x| x < 0})
-	assert_equal([1,2],s.find_all {|x| x < 3})
+    s = [1, 2, 3, 4, 5].create_stream
+    assert(s.include?(2))
+    assert_equal(3, s.detect { |x| x > 2 })
+    assert_equal(nil, s.detect { |x| x < 0 })
+    assert_equal([1, 2], s.find_all { |x| x < 3 })
   end
 
   def test_modified_stream
-	a = [1,2,3]
-	assert_equal([2,3],a.create_stream.remove_first.to_a)
-	assert_equal([1,2],a.create_stream.remove_last.to_a)
-	assert_raises(Stream::EndOfStreamException) {
-	  [1].create_stream.remove_last.forward
-	}
-	assert_raises(Stream::EndOfStreamException) {
-	  [1].create_stream.remove_first.forward
-	}
+    a = [1, 2, 3]
+    assert_equal([2, 3], a.create_stream.remove_first.to_a)
+    assert_equal([1, 2], a.create_stream.remove_last.to_a)
+    assert_raises(Stream::EndOfStreamException) {
+      [1].create_stream.remove_last.forward
+    }
+    assert_raises(Stream::EndOfStreamException) {
+      [1].create_stream.remove_first.forward
+    }
+  end
+
+  def test_concatenated_empty_stream
+    s = Stream::EmptyStream.instance + Stream::EmptyStream.instance
+    assert s.at_end?
+    assert s.at_beginning?
   end
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: stream
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.5.3
 platform: ruby
 authors:
 - Horst Duchene
 autorequire: stream
 bindir: bin
 cert_chain: []
-date: 2019-01-09 00:00:00.000000000 Z
+date: 2020-12-19 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: generator
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -75,20 +89,19 @@ extra_rdoc_files:
 files:
 - Gemfile
 - Gemfile.lock
+- LICENSE
 - README.rdoc
 - Rakefile
 - 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
 homepage: https://github.com/monora/stream
-licenses: []
+licenses:
+- ruby
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options:
 - "--title"
 - stream - Extended External Iterators
@@ -108,9 +121,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.7
-signing_key: 
+rubygems_version: 3.0.6
+signing_key:
 specification_version: 4
 summary: stream - Extended External Iterators
 test_files: []

data/lib/generator2stream.rb

@@ -1,22 +0,0 @@
-# Let a Generator look like a Stream.
-require 'stream'
-require 'generator'
-
-# The generator is made a Stream by aliasing
-# the methods at_end?, basic_forward, basic_peek, set_to_begin to the approriate
-# methods #end?, #next, #peek and #rewind of the Generator class.
-#
-# Be careful if you already use a version of Akinori MUSHAs generator.rb. Check out
-# the version numbers of the one you use and the one comming with the stream package.
-class Generator
-  include Stream
-
-  alias_method :at_end?, :end?
-  alias_method :basic_forward, :next
-  alias_method :basic_peek, :peek
-  alias_method :set_to_begin, :rewind
-
-  # Returns the generator itself.
-  def create_stream; self; end
-end
-  

data/test/bm.rb

@@ -1,49 +0,0 @@
-require "benchmark"
-require "stream"
-require "generator"
-
-include Benchmark
-
-a =(1..5000).to_a
-s = a.create_stream
-n = 10
-g = Generator.new a
-
-bm(15) do |test|
-  test.report("A.each:") do
-	n.times {a.each {|x| x}}
-  end
-  test.report("S.each:") do
-	n.times {s.each {|x| x}}
-  end
-  test.report("G.each:") do
-	n.times {g.each {|x| x}}
-  end
-
-  test.report("A.collect.first:") do
-	n.times {a.collect {|x| x}.collect {|x| x}.first}
-  end
-  test.report("S.collect.first:") do
-	n.times {s.collect {|x| x}.collect {|x| x}.first}
-  end
-  test.report("G.collect.first:") do
-	n.times {g.collect {|x| x}.collect {|x| x}.first}
-  end
-
-  test.report("A.reverse:") do
-	n.times {a.reverse.reverse.reverse.each {|x| x}}
-  end
-  test.report("S.reverse:") do
-	n.times {s.reverse.reverse.reverse.each {|x| x}}
-  end
-
-  test.report("A.collect:") do
-	n.times {a.collect {|x| x}.collect {|x| x}.each {|x| x}}
-  end
-  test.report("S.collect:") do
-	n.times {s.collect {|x| x}.collect {|x| x}.each {|x| x}}
-  end
-  test.report("G.collect:") do
-	n.times {g.collect {|x| x}.collect {|x| x}.each {|x| x}}
-  end
-end

data/test/testgenerator.rb

@@ -1,24 +0,0 @@
-require 'test/unit'
-require 'generator2stream'
-
-class TestGenerator < Test::Unit::TestCase
-  include Stream
-
-  def test_generator
-	# Use WrappedStream to ensure that the stream protocol is used and
-	# not the Enumerable protocol.
-	g = Generator.new { |g|
-	  for i in 1..3
-		g.yield i
-	  end
-	  g.yield 0
-	}
-	assert_equal([1, 2, 3, 0], WrappedStream.new(g).to_a)
-	
-	# Generators are not reversable
-	assert_raises(NotImplementedError) {g.reverse.first}
-
-	a = (1..10).to_a
-	assert_equal(a, WrappedStream.new(Generator.new(a)).to_a)
-  end
-end