huge_enumerable 0.0.1 → 0.0.2

data/lib/huge_enumerable/huge_product.rb

@@ -1,77 +1,77 @@
-require 'huge_enumerable'
-# HugePermutation is a HugeEnumerable style product. Comparable to Array#product.
-# This class can be used to generate products of large arrays or anything else that responds to [].
-# It is not necessary for the enumerables to be completely mapped into memory.
-# They only have to be able to return the element mapped to the index given to [].
-# ==== Examples
-#
-# Using HugeProduct directly:
-#
-#    product = HugeProduct.new(('a'..'z').to_a, ('A'..'Z').to_a)
-#    product[0..4]   # => [["a", "A"], ["a", "B"], ["a", "C"], ["a", "D"], ["a", "E"]]
-#    product[23..27] # => [["a", "X"], ["a", "Y"], ["a", "Z"], ["b", "A"], ["b", "B"]]
-#
-#
-# Subclassing HugeProduct
-#
-#    class BabyGirlNames < HugeProduct
-#
-#      def initialize
-#        first_names = %w{Emma Olivia Sophia Isabella Ava Mia Emily Charlotte Ella Amelia Abigail Madison Lily Chloe}
-#        middle_names = %w{Zoe Sophie Evelyn Aubrey Elizabeth Layla Anna Natalie Brooklyn Aria Audrey Ellie Lucy}
-#        super(first_names, middle_names)
-#      end
-#
-#      private
-#
-#      def fetch(index)
-#        super(index).join(' ')
-#      end
-#
-#    end
-#
-#    name = BabyGirlNames.new
-#    name[0]          # => "Emma Zoe"
-#    name[-1]         # => "Chloe Lucy"
-#    size = name.size # => 182
-#    name[size / 2]   # => "Charlotte Zoe"
-class HugeProduct < HugeEnumerable
-
-  # Create a new HugeProduct
-  #
-  # ==== Attributes
-  #
-  # * +enumerable_a+ - Any enumerable that responds to []
-  # * +enumerable_b+ - Any enumerable that responds to [] (This can be the same object as enumerable_a)
-  #
-  # ==== Options
-  #
-  # * +:max_array_size+ - The default size of arrays when #to_a is called.
-  # * +:rng+ - The random number generator to use.
-  def initialize(enumerable_a, enumerable_b, max_array_size = nil, rng = nil)
-    @enum_a = enumerable_a
-    @enum_b = enumerable_b
-    super(max_array_size, rng)
-  end
-
-  private
-
-  attr_accessor :enum_a, :enum_b
-
-  def collection_size
-    enum_a_size * enum_b_size
-  end
-
-  def fetch(x)
-    [enum_a[x / enum_b_size], enum_b[x % enum_b_size]]
-  end
-
-  def enum_a_size
-    @enum_a_size ||= enum_a.size
-  end
-
-  def enum_b_size
-    @enum_b_size ||= enum_b.size
-  end
-
-end
+require 'huge_enumerable'
+# HugePermutation is a HugeEnumerable style product. Comparable to Array#product.
+# This class can be used to generate products of large arrays or anything else that responds to [].
+# It is not necessary for the enumerables to be completely mapped into memory.
+# They only have to be able to return the element mapped to the index given to [].
+# ==== Examples
+#
+# Using HugeProduct directly:
+#
+#    product = HugeProduct.new(('a'..'z').to_a, ('A'..'Z').to_a)
+#    product[0..4]   # => [["a", "A"], ["a", "B"], ["a", "C"], ["a", "D"], ["a", "E"]]
+#    product[23..27] # => [["a", "X"], ["a", "Y"], ["a", "Z"], ["b", "A"], ["b", "B"]]
+#
+#
+# Subclassing HugeProduct
+#
+#    class BabyGirlNames < HugeProduct
+#
+#      def initialize
+#        first_names = %w{Emma Olivia Sophia Isabella Ava Mia Emily Charlotte Ella Amelia Abigail Madison Lily Chloe}
+#        middle_names = %w{Zoe Sophie Evelyn Aubrey Elizabeth Layla Anna Natalie Brooklyn Aria Audrey Ellie Lucy}
+#        super(first_names, middle_names)
+#      end
+#
+#      private
+#
+#      def fetch(index)
+#        super(index).join(' ')
+#      end
+#
+#    end
+#
+#    name = BabyGirlNames.new
+#    name[0]          # => "Emma Zoe"
+#    name[-1]         # => "Chloe Lucy"
+#    size = name.size # => 182
+#    name[size / 2]   # => "Charlotte Zoe"
+class HugeProduct < HugeEnumerable
+
+  # Create a new HugeProduct
+  #
+  # ==== Attributes
+  #
+  # * +enumerable_a+ - Any enumerable that responds to []
+  # * +enumerable_b+ - Any enumerable that responds to [] (This can be the same object as enumerable_a)
+  #
+  # ==== Options
+  #
+  # * +:max_array_size+ - The default size of arrays when #to_a is called.
+  # * +:rng+ - The random number generator to use.
+  def initialize(enumerable_a, enumerable_b, max_array_size = nil, rng = nil)
+    @enum_a = enumerable_a
+    @enum_b = enumerable_b
+    super(max_array_size, rng)
+  end
+
+  private
+
+  attr_accessor :enum_a, :enum_b
+
+  def collection_size
+    enum_a_size * enum_b_size
+  end
+
+  def fetch(x)
+    [enum_a[x / enum_b_size], enum_b[x % enum_b_size]]
+  end
+
+  def enum_a_size
+    @enum_a_size ||= enum_a.size
+  end
+
+  def enum_b_size
+    @enum_b_size ||= enum_b.size
+  end
+
+end

data/lib/huge_enumerable/version.rb

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

data/spec/lib/huge_enumerable/huge_collection_spec.rb

@@ -1,33 +1,33 @@
-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
-
+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,38 +1,39 @@
-require 'spec_helper'
-
-describe HugeCombination do
-
-  let(:enumerable) { ('a'..'z').to_a }
-
-  subject(:combination) do
-    HugeCombination.send(:public, :collection_size)
-    HugeCombination.send(:public, :fetch)
-    HugeCombination.new(enumerable, 2)
-  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(2).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(2).size.times { |i| enum_combo_fetches << enum_combo(2)[i] }
-      combination.collection_size.times { |i| combination_fetches << combination.fetch(i) }
-      combination_fetches.should eql(enum_combo_fetches)
-    end
-
-  end
-
+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,38 +1,39 @@
-require 'spec_helper'
-
-describe HugePermutation do
-
-  let(:enumerable) { ('a'..'z').to_a }
-
-  subject(:permutation) do
-    HugePermutation.send(:public, :collection_size)
-    HugePermutation.send(:public, :fetch)
-    HugePermutation.new(enumerable, 2)
-  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(2).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(2).size.times { |i| enum_perm_fetches << enum_perm(2)[i] }
-      permutation.collection_size.times { |i| permutation_fetches << permutation.fetch(i) }
-      permutation_fetches.should eql(enum_perm_fetches)
-    end
-
-  end
-
+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 +1,35 @@
-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
-
+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