huge_enumerable 0.0.2 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: bdd8ece0dcce67e7e8af6652859584c88b568715
-  data.tar.gz: cb41eb56dee65cab7d174e5283dd3d7d06a75e84
+SHA256:
+  metadata.gz: a31b89b4c2cdd80273c579549e27b093fa1723f737dcb5dcf67c8609a930ebc9
+  data.tar.gz: 8de5ac7d85dd81a51349b763768e3d44dba188590c61802b6fb1d8182a5894c2
 SHA512:
-  metadata.gz: 1449cbb6b13a47bc3b1853a8f8cccb0392983e42dc48dc4d596b84e61b71b7e1abb4fb6b6b6454aebe45ffc6a73b0bcb6dded3b5963956a2c50030df226941be
-  data.tar.gz: 64bdc6abf362ca79c8d4538792c293e81122a23ae95126e60e359edafa05f6e593ff910d440c85325f44f238f162e893afd4c715031d3e3df5b2ec2a5368537f
+  metadata.gz: 06d6d73e2c3c2218f0b820a64ee9ee8714cfbdff0350fefcb061b9f965692eab828ec38a1dc159d6b7c38027cb40475525e47491a4adad4dd1770a93919935e6
+  data.tar.gz: 4a1e0cbde30ab90bf71c9da8a1d3a180062205ec37e85c21bddbd594401d62ed68c15f4aecb570c60bd5ec385ff14ce0f1ad570adb4b810eb524228c665b4119

data/lib/huge_enumerable/version.rb

@@ -1,4 +1,3 @@
-class HugeEnumerable
-  # "0.0.1"
-  VERSION = "0.0.2"
-end
+class HugeEnumerable
+  VERSION = "0.1.1"
+end

data/lib/huge_enumerable.rb

@@ -106,11 +106,13 @@ class HugeEnumerable
   # If no block is given, an HugeCombination is returned instead.
   # === Caveat
   # max_array_size is currently inherited by the generated HugeCombination. This may change in the future.
-  def combination(n) # :yields: element
-    random_number_generator = rng != self.method(:rand) ? rng : nil
-    combo = HugeCombination.new(self.dup.reset!, n, max_array_size, random_number_generator)
-    if block_given?
-      combo.each { |x| yield x }
+  def combination(n, &block) # :yields: element
+    # Check to see if we have a specific random number generator to use.
+    # Using hash comparison as dups, clones, and other actions can make == and eql? return false when it is actually the same method
+    random_number_generator = rng.hash != method(:rand).hash ? rng : nil
+    combo = HugeCombination.new(self.clone.reset!, n, max_array_size, random_number_generator)
+    if block
+      combo.each(&block)
       self
     else
       combo
@@ -118,9 +120,15 @@ class HugeEnumerable
   end
 
   # Calls the given block once for each element in the next array of the collection, passing that element as a parameter.
-  def each # :yields: element
+  def each(&block) # :yields: element
     # TODO: Return an Enumerator if no block is given
-    remaining_or(max_array_size).times { |i| yield _fetch(i) }
+    remaining_or(max_array_size).times(&(block << method(:_fetch)))
+    # remaining_or(max_array_size).times { |i| yield _fetch(i) }
+  end
+
+  def initialize_copy(orig)
+    super
+    @rng = @rng.unbind.bind(self) if @rng.respond_to?(:unbind) # Make sure this is bound to self if it is a method
   end
 
   def max_array_size #:nodoc:
@@ -142,11 +150,13 @@ class HugeEnumerable
   # If no block is given, a HugePermutation is returned instead.
   # === Caveat
   # max_array_size is currently inherited by the generated HugePermutation. This may change in the future.
-  def permutation(n) # :yields: element
-    random_number_generator = rng != self.method(:rand) ? rng : nil
-    perm = HugePermutation.new(self.dup.reset!, n, max_array_size, random_number_generator)
-    if block_given?
-      perm.each { |x| yield x }
+  def permutation(n, &block) # :yields: element
+    # Check to see if we have a specific random number generator to use.
+    # Using hash comparison as dups, clones, and other actions can make == and eql? return false when it is actually the same method
+    random_number_generator = rng.hash != method(:rand).hash ? rng : nil
+    perm = HugePermutation.new(self.clone.reset!, n, max_array_size, random_number_generator)
+    if block
+      perm.each(&block)
       self
     else
       perm
@@ -165,12 +175,14 @@ class HugeEnumerable
   # === Caveat
   # max_array_size is currently inherited by the generated HugeProduct. This may change in the future.
   # other_enumerable is duped and reset if it is a HugeEnumerable. This may change in the future.
-  def product(other_enumerable) # :yields: element
-    other_enumerable = other_enumerable.dup.reset! if other_enumerable.is_a?(HugeEnumerable)
-    random_number_generator = rng != self.method(:rand) ? rng : nil
-    prod = HugeProduct.new(self.dup.reset!, other_enumerable, max_array_size, random_number_generator)
-    if block_given?
-      prod.each { |x| yield x }
+  def product(other_enumerable, &block) # :yields: element
+    other_enumerable = other_enumerable.clone.reset! if other_enumerable.is_a?(HugeEnumerable)
+    # Check to see if we have a specific random number generator to use.
+    # Using hash comparison as dups, clones, and other actions can make == and eql? return false when it is actually the same method
+    random_number_generator = rng.hash != method(:rand).hash ? rng : nil
+    prod = HugeProduct.new(self.clone.reset!, other_enumerable, max_array_size, random_number_generator)
+    if block
+      prod.each(&block)
       self
     else
       prod
@@ -221,7 +233,7 @@ class HugeEnumerable
   # ==== Side Effects
   # The new collection is reset to the current collection's original size and elements before shuffling.
   def shuffle(rng=nil)
-    self.dup.shuffle!(rng)
+    self.clone.shuffle!(rng)
   end
 
   # Randomly reorders the elements of the collection.

metadata

@@ -1,99 +1,91 @@
 --- !ruby/object:Gem::Specification
 name: huge_enumerable
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.1
 platform: ruby
 authors:
 - Frank Hall
-autorequire: 
-bindir: bin
+autorequire:
+bindir: exe
 cert_chain: []
-date: 2013-06-25 00:00:00.000000000 Z
+date: 2024-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: prime_miller_rabin
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
+        version: '0.1'
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: 0.1.0
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.13'
+        version: '2.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.13'
+        version: '2.3'
 - !ruby/object:Gem::Dependency
-  name: rdoc
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '13'
 - !ruby/object:Gem::Dependency
-  name: backports
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
+        version: '3'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3'
 - !ruby/object:Gem::Dependency
-  name: prime_miller_rabin
+  name: rdoc
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.2
-  type: :runtime
+        version: '6.4'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.2
+        version: '6.4'
 description: Enumerate, sample, shuffle, combine, permutate, and create products of
   massive data sets using minimal memory
 email:
@@ -102,53 +94,40 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
-- huge_enumerable.gemspec
 - lib/huge_enumerable.rb
 - lib/huge_enumerable/huge_collection.rb
 - lib/huge_enumerable/huge_combination.rb
 - lib/huge_enumerable/huge_permutation.rb
 - lib/huge_enumerable/huge_product.rb
 - lib/huge_enumerable/version.rb
-- spec/lib/huge_enumerable/huge_collection_spec.rb
-- spec/lib/huge_enumerable/huge_combination_spec.rb
-- spec/lib/huge_enumerable/huge_permutation_spec.rb
-- spec/lib/huge_enumerable/huge_product_spec.rb
-- spec/lib/huge_enumerable_spec.rb
-- spec/spec_helper.rb
-homepage: https://github.com/ChapterHouse/huge_enumerable.git
+homepage: https://github.com/ChapterHouse/huge_enumerable
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  homepage_uri: https://github.com/ChapterHouse/huge_enumerable
+  source_code_uri: https://github.com/ChapterHouse/huge_enumerable/tree/v0.1.1
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.0.2
-signing_key: 
+rubygems_version: 3.2.33
+signing_key:
 specification_version: 4
 summary: Enumerate, sample, shuffle, combine, permutate, and create products of massive
   data sets using minimal memory
-test_files:
-- spec/lib/huge_enumerable/huge_collection_spec.rb
-- spec/lib/huge_enumerable/huge_combination_spec.rb
-- spec/lib/huge_enumerable/huge_permutation_spec.rb
-- spec/lib/huge_enumerable/huge_product_spec.rb
-- spec/lib/huge_enumerable_spec.rb
-- spec/spec_helper.rb
+test_files: []

data/.gitignore

@@ -1,21 +0,0 @@
-*.gem
-*.rbc
-.bundle
-.config
-Gemfile.lock
-InstalledFiles
-coverage
-InstalledFiles
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp
-
-# YARD artifacts
-.yardoc
-_yardoc
-doc/
-.idea

data/huge_enumerable.gemspec

@@ -1,28 +0,0 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'huge_enumerable/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = "huge_enumerable"
-  spec.version       = HugeEnumerable::VERSION
-  spec.authors       = ["Frank Hall"]
-  spec.email         = ["ChapterHouse.Dune@gmail.com"]
-  spec.description   = %q{Enumerate, sample, shuffle, combine, permutate, and create products of massive data sets using minimal memory}
-  spec.summary       = %q{Enumerate, sample, shuffle, combine, permutate, and create products of massive data sets using minimal memory}
-  spec.homepage      = "https://github.com/ChapterHouse/huge_enumerable.git"
-  spec.license       = "MIT"
-
-  spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
-
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency 'rspec', '~> 2.13'
-  spec.add_development_dependency 'rdoc'
-  spec.add_runtime_dependency "backports" # Wish this could be conditional. It is only used for ruby 1.8 for as long as I support it.
-  spec.add_runtime_dependency "prime_miller_rabin", ">= 0.0.2"
-
-end

data/spec/lib/huge_enumerable/huge_collection_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-describe HugeCollection do
-
-  let(:enumerable) { ('a'..'z').to_a }
-
-  subject(:collection) do
-    HugeCollection.send(:public, :collection_size)
-    HugeCollection.send(:public, :fetch)
-    HugeCollection.new(enumerable)
-  end
-
-  context "#collection_size" do
-
-    it "is equal to the original enumerable size" do
-      collection.collection_size.should eql(enumerable.size)
-    end
-
-  end
-
-  context "#fetch" do
-
-    it "returns values in the same order as enumerable[]" do
-      enumerable_fetches = []
-      collection_fetches = []
-      enumerable.size.times { |i| enumerable_fetches << enumerable[i] }
-      collection.collection_size.times { |i| collection_fetches << collection.fetch(i) }
-      collection_fetches.should eql(enumerable_fetches)
-    end
-
-  end
-
-end

data/spec/lib/huge_enumerable/huge_combination_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-describe HugeCombination do
-
-  let(:enumerable) { ('a'..'z').to_a }
-  let(:combination_size) { 3 }
-
-  subject(:combination) do
-    HugeCombination.send(:public, :collection_size)
-    HugeCombination.send(:public, :fetch)
-    HugeCombination.new(enumerable, combination_size)
-  end
-
-  def enum_combo(x)
-    @cache ||= {}
-    @cache[x.to_i] ||= enumerable.combination(x).to_a
-  end
-
-  context "#collection_size" do
-
-    it "is equal to array#combination.to_a.size" do
-      combination.collection_size.should eql(enum_combo(combination_size).size)
-    end
-
-  end
-
-  context "#fetch" do
-
-    it "returns values in the same order as array#combination.to_a[]" do
-      enum_combo_fetches = []
-      combination_fetches = []
-      enum_combo(combination_size).size.times { |i| enum_combo_fetches << enum_combo(combination_size)[i] }
-      combination.collection_size.times { |i| combination_fetches << combination.fetch(i) }
-      combination_fetches.should eql(enum_combo_fetches)
-    end
-
-  end
-
-end

data/spec/lib/huge_enumerable/huge_permutation_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-describe HugePermutation do
-
-  let(:enumerable) { ('a'..'z').to_a }
-  let(:permutation_size) { 3 }
-
-  subject(:permutation) do
-    HugePermutation.send(:public, :collection_size)
-    HugePermutation.send(:public, :fetch)
-    HugePermutation.new(enumerable, permutation_size)
-  end
-
-  def enum_perm(x)
-    @cache ||= {}
-    @cache[x.to_i] ||= enumerable.permutation(x).to_a
-  end
-
-  context "#collection_size" do
-
-    it "is equal to array#permutation.to_a.size" do
-      permutation.collection_size.should eql(enum_perm(permutation_size).size)
-    end
-
-  end
-
-  context "#fetch" do
-
-    it "returns values in the same order as array#permutation.to_a[]" do
-      enum_perm_fetches = []
-      permutation_fetches = []
-      enum_perm(permutation_size).size.times { |i| enum_perm_fetches << enum_perm(permutation_size)[i] }
-      permutation.collection_size.times { |i| permutation_fetches << permutation.fetch(i) }
-      permutation_fetches.should eql(enum_perm_fetches)
-    end
-
-  end
-
-end

data/spec/lib/huge_enumerable/huge_product_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-describe HugeProduct do
-
-  let(:enumerable_a) { ('a'..'z').to_a }
-  let(:enumerable_b) { ('A'..'Z').to_a }
-  let(:enum_prod) { enumerable_a.product(enumerable_b) }
-
-  subject(:product) do
-    HugeProduct.send(:public, :collection_size)
-    HugeProduct.send(:public, :fetch)
-    HugeProduct.new(enumerable_a, enumerable_b)
-  end
-
-  context "#collection_size" do
-
-    it "is equal to array#product(other_ary).size" do
-      product.collection_size.should eql(enum_prod.size)
-    end
-
-  end
-
-  context "#fetch" do
-
-    it "returns values in the same order as array#product(other_ary)[]" do
-      enum_prod_fetches = []
-      product_fetches = []
-      enum_prod.size.times { |i| enum_prod_fetches << enum_prod[i] }
-      product.collection_size.times { |i| product_fetches << product.fetch(i) }
-      product_fetches.should eql(enum_prod_fetches)
-    end
-
-  end
-
-end

data/spec/lib/huge_enumerable_spec.rb

@@ -1,642 +0,0 @@
-require 'spec_helper'
-
-describe HugeEnumerable do
-
-  let(:collection) { ('a'..'z').to_a }
-
-  subject(:enumerable) do
-    klass = Class.new(HugeEnumerable)
-    enum_collection = collection.sort
-    klass.send(:define_method, :collection_size) { enum_collection.size }
-    klass.send(:define_method, :fetch) { |x| enum_collection[x] }
-    klass.send(:public, :next_prime)
-    klass.send(:public, :_fetch)
-    klass.send(:public, :element_or_array)
-    klass.send(:public, :full_cycle_increment)
-    klass.new
-  end
-
-  subject(:emptied_enumerable) do
-    enumerable.tap do |enum|
-      enum.max_array_size = enum.size
-      enum.next_array
-    end
-  end
-
-  context ".new" do
-
-    context "with no arguments" do
-
-      it "defaults max_array_size to a Numeric" do
-        enumerable.max_array_size.should be_kind_of(Numeric)
-      end
-
-      it "defaults rng to #rand" do
-        enumerable.rng.should eq(enumerable.method(:rand))
-      end
-
-    end
-
-  end
-
-  context "#[]" do
-
-    context "with a positive index" do
-      it "returns the element from the beginning of the collection at the specified index" do
-        enumerable[3].should eql(collection[3])
-      end
-    end
-
-    context "with a negative index" do
-      it "returns the element from the end of the collection at the specified index" do
-        enumerable[-3].should eql(collection[-3])
-      end
-    end
-
-    context "with an out of bounds index" do
-      it "returns nil" do
-        enumerable[enumerable.size + 1].should be_nil
-      end
-    end
-
-    context "with a range" do
-      it "returns an array of elements corresponding to indexes within the range" do
-        size = collection.size + 1
-        test_range = (-size..size).to_a
-        ranges = test_range.product(test_range).map { |x| (x.first..x.last) }
-        arrays = ranges.map { |range| [enumerable[range], collection[range]] }
-        arrays.each { |x| x.first.should eq(x.last) }
-      end
-    end
-
-    context "with a length" do
-      it "returns an array of elements corresponding to starting with index and containing a maximum of length items" do
-        size = collection.size + 1
-        test_range = (-size..size).to_a
-        index_lengths = test_range.product(test_range).map { |x| [x.first, x.last] }
-        arrays = index_lengths.map do |idx_len|
-          index = idx_len.first
-          length = idx_len.last
-          [enumerable[index, length], collection[index, length]]
-        end
-        arrays.each { |x| x.first.should eq(x.last) }
-      end
-    end
-
-
-    it "relays to #_fetch for index mapping" do
-      enumerable.should_receive(:_fetch).at_least(:once)
-      enumerable[0]
-    end
-
-  end
-
-  context "#each" do
-
-    it "yields #max_array_size items" do
-      items = []
-      total_items = collection.size / 5
-      enumerable.max_array_size = total_items
-      enumerable.each { |x| items << x }
-      items.size.should eql(total_items)
-    end
-
-    it "yields only the remaining items if there are fewer than #max_array_size" do
-      items = []
-      enumerable.max_array_size = collection.size + 1
-      enumerable.each { |x| items << x }
-      items.size.should eql(collection.size)
-    end
-
-    it "relays to #_fetch for index mapping" do
-      enumerable.should_receive(:_fetch).at_least(:once)
-      enumerable.each {}
-    end
-
-  end
-
-  context "#combination" do
-
-    context "with no block" do
-
-      it "returns a new HugeCombination" do
-        enumerable.combination(2).should be_instance_of(HugeCombination)
-      end
-
-    end
-
-    context "with a block" do
-
-      # This should really be calls the block from the combination since there is testing duplication here.
-      # However, knowing where the block is called from would need stack investigation or similar.
-      it "calls the block for each combination element" do
-        combo = enumerable.combination(2)
-        enumerable.max_array_size = combo.size  # Hrm. Perhaps having to do this is a reason to have it call collection_each
-        index = 0
-        enumerable.combination(2) do |x|
-          x.should eql(combo[index])
-          index += 1
-        end
-        index.should eql(combo.size)
-      end
-
-      it "returns self" do
-        enumerable.combination(2) {}.should equal(enumerable)
-      end
-
-    end
-
-    it "uses self a dup of itself as the enumerable" do
-      dupped_enumerable = enumerable.dup
-      enumerable.stub(:dup).and_return(dupped_enumerable)
-      HugeCombination.should_receive(:new).with(dupped_enumerable, 2, enumerable.max_array_size, nil)
-      enumerable.combination(2)
-    end
-
-    it "uses the same max array size" do
-      enumerable.combination(2).max_array_size.should eql(enumerable.max_array_size)
-    end
-
-    it "uses the same random number generator" do
-      enumerable.rng = Proc.new { 1 }
-      enumerable.combination(2).rng.should eq(enumerable.rng)
-    end
-
-    it "calls reset! on the dup" do
-      HugeEnumerable.send(:public, :reset!)
-      dupped_enumerable = enumerable.dup
-      enumerable.stub(:dup).and_return(dupped_enumerable)
-      dupped_enumerable.should_receive(:reset!).and_call_original
-      enumerable.combination(2)
-    end
-
-  end
-
-
-  context "#max_array_size" do
-
-    context "not explicitly set" do
-
-      it "defaults to DEFAULT_MAX_ARRAY_SIZE if smaller than #collection_size" do
-        enumerable.stub(:collection_size).and_return(HugeEnumerable::DEFAULT_MAX_ARRAY_SIZE + 1)
-        enumerable.max_array_size.should eql(HugeEnumerable::DEFAULT_MAX_ARRAY_SIZE)
-      end
-
-      it "defaults to #collection_size if smaller than DEFAULT_MAX_ARRAY_SIZE" do
-        enumerable.stub(:collection_size).and_return(HugeEnumerable::DEFAULT_MAX_ARRAY_SIZE - 1)
-        enumerable.max_array_size.should eql(HugeEnumerable::DEFAULT_MAX_ARRAY_SIZE - 1)
-      end
-
-    end
-
-  end
-
-  context "#next_array" do
-
-    it "advances to the next array in the collection" do
-      size = collection.size / 5
-      enumerable.max_array_size = size
-      enumerable.next_array.should eql(collection[size...size*2])
-    end
-
-    it "changes #size" do
-      size = collection.size / 5
-      enumerable.max_array_size = size
-      enumerable.next_array
-      enumerable.size.should eql(collection.size - size)
-    end
-
-  end
-
-  context "#empty?" do
-
-    it "returns true if the collection has been entirely emptied by #pop, #shift, or #next_array" do
-      enumerable.max_array_size = collection.size
-      enumerable.next_array
-      enumerable.empty?.should be_true
-    end
-
-    it "returns false if the collection has been not entirely emptied by #pop, #shift, or #next_array" do
-      enumerable.max_array_size = collection.size - 1
-      enumerable.next_array
-      enumerable.empty?.should be_false
-    end
-
-  end
-
-  context "#permutation" do
-
-    context "with no block" do
-
-      it "returns a new HugePermutation" do
-        enumerable.permutation(2).should be_instance_of(HugePermutation)
-      end
-
-    end
-
-    context "with a block" do
-
-      # This should really be calls the block from the combination since there is testing duplication here.
-      # However, knowing where the block is called from would need stack investigation or similar.
-      it "calls the block for each permutation element" do
-        perm = enumerable.permutation(2)
-        enumerable.max_array_size = perm.size  # Hrm. Perhaps having to do this is a reason to have it call collection_each
-        index = 0
-        enumerable.permutation(2) do |x|
-          x.should eql(perm[index])
-          index += 1
-        end
-        index.should eql(perm.size)
-      end
-
-      it "returns self" do
-        enumerable.permutation(2) {}.should equal(enumerable)
-      end
-
-    end
-
-    it "uses self a dup of itself as the enumerable" do
-      dupped_enumerable = enumerable.dup
-      enumerable.stub(:dup).and_return(dupped_enumerable)
-      HugePermutation.should_receive(:new).with(dupped_enumerable, 2, enumerable.max_array_size, nil)
-      enumerable.permutation(2)
-    end
-
-    it "uses the same max array size" do
-      enumerable.permutation(2).max_array_size.should eql(enumerable.max_array_size)
-    end
-
-    it "uses the same random number generator" do
-      enumerable.rng = Proc.new { 1 }
-      enumerable.permutation(2).rng.should eq(enumerable.rng)
-    end
-
-    it "calls reset! on the dup" do
-      HugeEnumerable.send(:public, :reset!)
-      dupped_enumerable = enumerable.dup
-      enumerable.stub(:dup).and_return(dupped_enumerable)
-      dupped_enumerable.should_receive(:reset!).and_call_original
-      enumerable.permutation(2)
-    end
-
-  end
-
-
-  context "#pop" do
-
-    context "on a non empty collection" do
-      context "with no parameter" do
-        it "returns the next element from the end of the collection" do
-          enumerable.pop.should eql(collection.pop)
-        end
-      end
-
-      context "with a parameter" do
-        it "returns an array of the next N elements from the end of the collection" do
-          enumerable.pop(3).should eql(collection.pop(3))
-        end
-      end
-
-      it "removes the elements from the end of the collection" do
-        enumerable.pop
-        enumerable.pop(3)
-        enumerable.to_a.should eql(collection[0..-5])
-      end
-
-      it "changes #size" do
-        enumerable.pop
-        enumerable.pop(3)
-        enumerable.size.should eql(collection.size - 4)
-      end
-
-      it "does not harm the original collection" do
-        original = collection.dup
-        enumerable.pop
-        enumerable.pop(3)
-        collection.should eql(original)
-      end
-
-    end
-
-    it "depends on #(private)element_or_array" do
-      enumerable.should_receive(:element_or_array).twice.and_call_original
-      enumerable.pop
-      enumerable.pop(3)
-    end
-
-  end
-
-  context "#product" do
-
-    context "with no block" do
-
-      it "returns a new HugeProduct" do
-        enumerable.product([]).should be_instance_of(HugeProduct)
-      end
-
-    end
-
-    context "with a block" do
-
-      # This should really be calls the block from the combination since there is testing duplication here.
-      # However, knowing where the block is called from would need stack investigation or similar.
-      it "calls the block for each product element" do
-        other_enumerable = [1, 2, 3]
-        prod = enumerable.product(other_enumerable)
-        enumerable.max_array_size = prod.size  # Hrm. Perhaps having to do this is a reason to have it call collection_each
-        index = 0
-        enumerable.product(other_enumerable) do |x|
-          x.should eql(prod[index])
-          index += 1
-        end
-        index.should eql(prod.size)
-      end
-
-      it "returns self" do
-        enumerable.product([]) {}.should equal(enumerable)
-      end
-
-    end
-
-    it "uses self a dup of itself as the enumerable" do
-      dupped_enumerable = enumerable.dup
-      enumerable.stub(:dup).and_return(dupped_enumerable)
-      other_enumerable = []
-      HugeProduct.should_receive(:new).with(dupped_enumerable, other_enumerable, enumerable.max_array_size, nil)
-      enumerable.product(other_enumerable)
-    end
-
-    it "calls dup on the other enumerable if it is a HugeEnumerable" do
-      other_enumerable = HugeCollection.new([])
-      other_enumerable.should_receive(:dup).and_call_original
-      enumerable.product(other_enumerable)
-    end
-
-    it "calls reset on the other enumerable if it is a HugeEnumerable" do
-      HugeEnumerable.send(:public, :reset!)
-      other_enumerable = HugeCollection.new([])
-      dupped_enumerable = other_enumerable.dup
-      other_enumerable.stub(:dup).and_return(dupped_enumerable)
-      dupped_enumerable.should_receive(:reset!).and_call_original
-      enumerable.product(other_enumerable)
-    end
-
-    it "does not call dup on the other enumerable if it is a HugeEnumerable" do
-      other_enumerable = []
-      other_enumerable.should_not_receive(:dup)
-      enumerable.product(other_enumerable)
-    end
-
-    it "uses the same max array size" do
-      enumerable.product([]).max_array_size.should eql(enumerable.max_array_size)
-    end
-
-    it "uses the same random number generator" do
-      enumerable.rng = Proc.new { 1 }
-      enumerable.product([]).rng.should eq(enumerable.rng)
-    end
-
-    it "calls reset! on the dup" do
-      HugeEnumerable.send(:public, :reset!)
-      dupped_enumerable = enumerable.dup
-      enumerable.stub(:dup).and_return(dupped_enumerable)
-      dupped_enumerable.should_receive(:reset!).and_call_original
-      enumerable.product([])
-    end
-
-  end
-
-  context "#sample" do
-
-    context "on an non empty collection" do
-      context "with no arguments" do
-        it "returns a single element from the collection" do
-          collection.include?(enumerable.sample).should be_true
-        end
-      end
-
-      context "with size argument" do
-        it "returns N elements from the collection" do
-          samples = enumerable.sample(3)
-          samples.should have(3).items
-          samples.all? { |item| collection.include?(item) }.should be_true
-        end
-      end
-
-      it "returns elements from the collection in a pseudo random pattern" do
-        enumerable.sample(enumerable.size).should_not eq(collection)
-      end
-
-      it "visits each element exactly once before repeating" do
-        samples = []
-        enumerable.size.times { samples << enumerable.sample }
-        samples.uniq.should have(collection.size).items
-      end
-
-      it "does not reorder the original collection" do
-        original = collection.dup
-        enumerable.sample
-        enumerable.sample(3)
-        collection.should eql(original)
-      end
-
-    end
-
-    it "depends on #(private)element_or_array" do
-      enumerable.should_receive(:element_or_array).twice.and_call_original
-      enumerable.sample
-      enumerable.sample(3)
-    end
-
-  end
-
-  context "#shift" do
-
-    context "on a non empty collection" do
-      context "with no parameter" do
-        it "returns the next element from the beginning of the collection" do
-          enumerable.shift.should eql(collection.shift)
-        end
-      end
-
-      context "with a parameter" do
-        it "returns an array of the next N elements from the beginning of the collection" do
-          enumerable.shift(3).should eql(collection.shift(3))
-        end
-      end
-
-      it "removes the elements from the beginning of the collection" do
-        enumerable.shift
-        enumerable.shift(3)
-        enumerable.to_a.should eql(collection[4..-1])
-      end
-
-      it "changes #size" do
-        enumerable.shift
-        enumerable.shift(3)
-        enumerable.size.should eql(collection.size - 4)
-      end
-
-      it "does not harm the original collection" do
-        original = collection.dup
-        enumerable.shift
-        enumerable.shift(3)
-        collection.should eql(original)
-      end
-
-    end
-
-    it "depends on #(private)element_or_array" do
-      enumerable.should_receive(:element_or_array).twice.and_call_original
-      enumerable.shift
-      enumerable.shift(3)
-    end
-
-  end
-
-  context "#shuffle" do
-
-    it "returns a new HugeEnumerable" do
-      enumerable.shuffle.should_not equal(enumerable)
-    end
-
-  end
-
-  context "#shuffle!" do
-
-    it "randomly alters the order of the sequence" do
-      fake_random = Proc.new { |x| 2 % x }
-      enumerable.max_array_size = enumerable.size
-      original = enumerable.to_a
-      enumerable.shuffle!(fake_random)
-      shuffle1 = enumerable.to_a
-      fake_random = Proc.new { |x| 3 % x }
-      enumerable.shuffle!(fake_random)
-      shuffle2 = enumerable.to_a
-      original.should_not eq(shuffle1)
-      original.should_not eq(shuffle2)
-      shuffle1.should_not eq(shuffle2)
-    end
-
-    it "contains all of the original elements" do
-      enumerable.shuffle!.to_a.sort.should eq(collection)
-    end
-
-    it "does noy alter the original collection" do
-      original = collection.dup
-      enumerable.max_array_size = enumerable.size
-      enumerable.shuffle!
-      enumerable.to_a.should_not eq(original)
-      original.should eq(collection)
-    end
-
-  end
-
-  context "#size" do
-
-    it "returns the current size of the collection" do
-      enumerable.size.should eql(collection.size)
-    end
-
-  end
-
-  context "#(private)next_prime" do
-
-    it "should return the next prime following any integer" do
-      primes = Prime.first(100)
-      x = 0
-      until primes.empty?
-        enumerable.next_prime(x).should eq(primes.first)
-        x += 1
-        primes.shift if x.prime?
-      end
-    end
-
-  end
-
-  context "#(private)_fetch" do
-
-    context "with an index outside the range of (sequence_start..sequence_end)" do
-      it "should never relay to fetch" do
-        enumerable.should_not_receive(:fetch)
-        enumerable._fetch(-1 * enumerable.size - 1)
-        enumerable._fetch(enumerable.size)
-      end
-    end
-
-    context "with an index inside the range of (sequence_start..sequence_end)" do
-      it "should relay to fetch" do
-        enumerable.should_receive(:fetch).twice
-        enumerable._fetch(0)
-        enumerable._fetch(enumerable.size - 1)
-      end
-
-      it "should map the relative index to an absolute index before calling fetch" do
-        enumerable.shift(3)
-        enumerable.stub(:shuffle_index) { |index| index + 2 }
-        enumerable.should_receive(:fetch).with(5)
-        enumerable._fetch(0)
-      end
-
-    end
-
-  end
-
-  context "#(private)element_or_array" do
-
-    let(:block) { Proc.new { 1 } }
-
-    context "on a non empty collection" do
-      context "with no parameter" do
-        it "returns a single element" do
-          enumerable.element_or_array { block.call }.should eql(1)
-        end
-      end
-
-      context "with a nil parameter" do
-        it "returns a single element" do
-          enumerable.element_or_array(nil, &block).should eql(1)
-        end
-      end
-
-      context "with a non nil parameter" do
-        it "returns an array of N elements" do
-          enumerable.element_or_array(3, &block).should eql([1, 1, 1])
-        end
-
-        it "will not return more items than remain in the collection" do
-          size = enumerable.size
-          enumerable.element_or_array(size + 1, &block).should have(size).items
-        end
-      end
-    end
-
-    context "on an empty collection" do
-      context "with no parameter" do
-        it "returns nil" do
-          emptied_enumerable.element_or_array(&:block).should be_nil
-        end
-      end
-
-      context "with a parameter" do
-        it "returns an empty array" do
-          emptied_enumerable.element_or_array(3, &block).should eql([])
-        end
-      end
-    end
-
-    it "raises an exception if the parameter is negative" do
-      expect { enumerable.element_or_array(-1, &block) }.to raise_error(ArgumentError, 'negative array size')
-    end
-
-  end
-
-  context "#(private)full_cycle_increment" do
-
-    it "must never return a value equal to the domain size" do
-      (0...100).to_a.all? { |x| enumerable.full_cycle_increment(x) != x }.should be_true
-    end
-
-  end
-
-end

data/spec/spec_helper.rb

@@ -1 +0,0 @@
-require 'huge_enumerable'