riffle 0.0.1 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f0a462eefd0ef7b1494eec7847a0518a34dd3876
-  data.tar.gz: 47e2520de2f35d39da9eabf321e333c2281ad5e4
+  metadata.gz: 0f072f9e01cd3dae017947eca483b6edb3ddbebd
+  data.tar.gz: 6cc6682bc9332e96f873745676f98b8489f0071f
 SHA512:
-  metadata.gz: 84210dd35055df948f24c8c34c8754458da764227f0cee4c58b0ade7a8b91679dd009f4209596bff8dc1f78695f514381102502b583101d3129a933868cea7ec
-  data.tar.gz: ad6d5c63e120fb904e81489895d4cb0ed9d6b32729166c4aeb2f12e56d06a43443f5ad5ab7ac05c1a180cef76d7e77ad4c50b9b1f7cf9cbdb2420930f300dd74
+  metadata.gz: b29b6efd71e529a0183447b10fbfc261f7aab102264491b5dd4738ed555c9cfbef3f9e6f7732c6791e4815ca463ad7bb807abb4403c5279700184595424fb6d4
+  data.tar.gz: 104592ccc714b3571bc754d86954d109efbd46af9275b02b7382c26e9eb9394c112dc9aa2e7075ff2190e5ab414ccadb7dc9910f33a1833d475130bc0af490a1

data/lib/riffle.rb

@@ -1,2 +1,3 @@
 require "riffle/version"
+require "riffle/array"
 require "riffle/core_ext/array/riffle"

data/lib/riffle/array.rb

@@ -0,0 +1,58 @@
+
+module Riffle
+  module Array
+    def riffle(*args)
+      result = []
+
+      # handle empty or insufficient args
+      if self == ::Array && args.length < 2
+        return args.empty? ? [] : args.first
+      elsif self.is_a?(::Array) && args.empty?
+        return self
+      end
+
+      opts = get_opts_from_args(args)
+
+      opts[:range] ||= (1..3)
+
+      unless args.select { |a| !a.is_a? ::Array }.empty?
+        raise ArgumentError, "All arguments must be of type `Array`"
+      end
+
+      # insert self at front of args list if self is an Array instance
+      args.unshift self if self.is_a?(::Array)
+
+      # Random.new(nil) explodes for some reason...
+      if opts[:seed].nil?
+        prng = Random.new
+      else
+        prng = Random.new(opts[:seed])
+      end
+
+      until args.flatten.empty?
+        args.each_with_index do |arg, i|
+          group_size = prng.rand(opts[:range])
+          if arg.length < group_size
+            result.concat arg
+            args[i] = []
+          else
+            result.concat arg.take(group_size)
+            args[i] = arg.drop group_size
+          end
+        end
+      end
+
+      result
+    end
+
+    private
+
+    def get_opts_from_args(args)
+      opts_passed?(args) ? args.pop : {}
+    end
+
+    def opts_passed?(args)
+      args.length > 1 && args.last.is_a?(Hash)
+    end
+  end
+end

data/lib/riffle/core_ext/array/riffle.rb

@@ -1,35 +1,5 @@
 
 class Array
-  def riffle(*args)
-    result = []
-
-    return self if args.empty?
-
-    opts = args.pop if args.length > 1 && args.last.is_a?(Hash)
-
-    min_group_size = (opts && opts[:min_group_size]) || 1
-    max_group_size = (opts && opts[:max_group_size]) || 3
-
-    # insert self at front of args list
-    args.unshift self
-
-    unless args.select { |a| !a.is_a? Array }.empty?
-      raise ArgumentError, "All arguments must be of type `Array`"
-    end
-
-    until args.flatten.empty?
-      args.each_with_index do |arg, i|
-        group_size = rand(min_group_size..max_group_size)
-        if arg.length < group_size
-          result.concat arg
-          args[i] = []
-        else
-          result.concat arg.take(group_size)
-          args[i] = arg.drop group_size
-        end
-      end
-    end
-
-    result
-  end
+  include Riffle::Array
+  extend Riffle::Array
 end

data/lib/riffle/version.rb

@@ -1,3 +1,3 @@
 module Riffle
-  VERSION = "0.0.1"
+  VERSION = "1.0.1"
 end

data/spec/array_spec.rb

@@ -1,81 +1,29 @@
 require "spec_helper"
 
 describe Array do
-  it "Array#riffle should be defined" do
-    [].respond_to?(:riffle).should be_true
-  end
-
-  it "returns self if no args are passed" do
-    a = [1, 2, 3]
-    a.riffle.should == a
-  end
-
-  it "requires all arguments to be of type `Array`, except when the last arg is an opts Hash" do
-    expect { [].riffle 1 }.to raise_error(ArgumentError)
-    expect { [].riffle [1], :foo }.to raise_error(ArgumentError)
-    expect { [].riffle({}, [1]) }.to raise_error(ArgumentError)
-
-    # allow an opts Hash to be passed as the last arg
-    expect { [].riffle [1], { min_group_size: 1 } }.to_not raise_error
-  end
-
-  it "does not raise exceptions when empty args are passed" do
-    expect { [].riffle [], [] }.to_not raise_error
-    [].riffle([], []).should be_empty
-  end
-
-  it "supports more than two arguments" do
-    numbers = [1, 2, 3, 4, 5, 6]
-    letters = %w(a b c d e f)
-    symbols = [:foo, :bar, :baz, :qux]
-    result = numbers.riffle letters, symbols
-
-    result.length.should == numbers.length +
-                            letters.length +
-                            symbols.length
-
-    # filtering out integers from the result should be exactly equal to the
-    # original `numbers` array. particularly the order should be the same
-    result.select { |r| r.is_a? Integer }.should.eql? numbers
-
-    # filtering out strings from the result should be exactly equal to the
-    # original `letters` array. particularly the order should be the same
-    result.select { |r| r.is_a? String }.should.eql? letters
-
-    # filtering out strings from the result should be exactly equal to the
-    # original `letters` array. particularly the order should be the same
-    result.select { |r| r.is_a? Symbol }.should.eql? symbols
-  end
-
-  it "merges all argument arrays while maintaining the order of the original arrays in relation to themselves" do
-    numbers = [1, 2, 3, 4, 5, 6]
-    letters = %w(a b c d e f)
-    result = numbers.riffle letters
-
-    result.length.should == numbers.length + letters.length
-
-    # filtering out integers from the result should be exactly equal to the
-    # original `numbers` array. particularly the order should be the same
-    result.select { |r| r.is_a? Integer }.should.eql? numbers
-
-    # filtering out strings from the result should be exactly equal to the
-    # original `letters` array. particularly the order should be the same
-    result.select { |r| r.is_a? String }.should.eql? letters
-  end
-
-  it "maintains the first element in the array on which `riffle` was called" do
-    a = [1, 2, 3]
-    b = %w(a b c)
-    a.riffle(b).first.should == a.first
-  end
-
-  it "supports defining a min and max group size through an opts Hash passed as the last arg" do
-    a = [1, 2, 3, 4, 5, 6, 7, 8]
-    b = %w(a b c d e f g h)
-    r = a.riffle(b, { min_group_size: 2, max_group_size: 2 })
-    r.slice(0..1).each { |x| x.is_a?(Integer).should be_true }
-    r.slice(2..3).each { |x| x.is_a?(String).should be_true }
-    r.slice(6..7).each { |x| x.is_a?(String).should be_true }
-    r.slice(8..9).each { |x| x.is_a?(Integer).should be_true }
+  context "#riffle" do
+    it "defines Array#riffle" do
+      [].respond_to?(:riffle).should be_true
+    end
+
+    it "returns self if no args are passed" do
+      a = [1, 2, 3]
+      a.riffle.should == a
+    end
+  end
+
+  context ".riffle" do
+    it "defines Array.riffle" do
+      Array.respond_to?(:riffle).should be_true
+    end
+
+    it "returns [] if no args are passed" do
+      Array.riffle.should == []
+    end
+
+    it "returns the arg if only one arg is passed" do
+      a = [1,2,3]
+      Array.riffle(a).should == a
+    end
   end
 end

data/spec/riffle_spec.rb

@@ -0,0 +1,81 @@
+require "spec_helper"
+
+describe Riffle do
+  it "requires all arguments to be of type `Array`, except when the last arg is an opts Hash" do
+    expect { [].riffle 1 }.to raise_error(ArgumentError)
+    expect { [].riffle [1], :foo }.to raise_error(ArgumentError)
+    expect { [].riffle({}, [1]) }.to raise_error(ArgumentError)
+
+    # allow an opts Hash to be passed as the last arg
+    expect { [].riffle [1], { min_group_size: 1 } }.to_not raise_error
+  end
+
+  it "does not raise exceptions when empty args are passed" do
+    expect { [].riffle [], [] }.to_not raise_error
+    [].riffle([], []).should be_empty
+  end
+
+  it "supports more than two arguments" do
+    numbers = [1, 2, 3, 4, 5, 6]
+    letters = %w(a b c d e f)
+    symbols = [:foo, :bar, :baz, :qux]
+    result = numbers.riffle letters, symbols
+
+    result.length.should == numbers.length +
+                            letters.length +
+                            symbols.length
+
+    # filtering out integers from the result should be exactly equal to the
+    # original `numbers` array. particularly the order should be the same
+    result.select { |r| r.is_a? Integer }.should.eql? numbers
+
+    # filtering out strings from the result should be exactly equal to the
+    # original `letters` array. particularly the order should be the same
+    result.select { |r| r.is_a? String }.should.eql? letters
+
+    # filtering out strings from the result should be exactly equal to the
+    # original `letters` array. particularly the order should be the same
+    result.select { |r| r.is_a? Symbol }.should.eql? symbols
+  end
+
+  it "merges all argument arrays while maintaining the order of the original arrays in relation to themselves" do
+    numbers = [1, 2, 3, 4, 5, 6]
+    letters = %w(a b c d e f)
+    result = numbers.riffle letters
+
+    result.length.should == numbers.length + letters.length
+
+    # filtering out integers from the result should be exactly equal to the
+    # original `numbers` array. particularly the order should be the same
+    result.select { |r| r.is_a? Integer }.should.eql? numbers
+
+    # filtering out strings from the result should be exactly equal to the
+    # original `letters` array. particularly the order should be the same
+    result.select { |r| r.is_a? String }.should.eql? letters
+  end
+
+  it "maintains the first element in the array on which `riffle` was called" do
+    a = [1, 2, 3]
+    b = %w(a b c)
+    a.riffle(b).first.should == a.first
+  end
+
+  it "supports defining a min and max group size through an opts Hash passed as the last arg" do
+    a = [1, 2, 3, 4, 5, 6, 7, 8]
+    b = %w(a b c d e f g h)
+    r = a.riffle(b, { range: (2..2) })
+    r.slice(0..1).each { |x| x.is_a?(Integer).should be_true }
+    r.slice(2..3).each { |x| x.is_a?(String).should be_true }
+    r.slice(6..7).each { |x| x.is_a?(String).should be_true }
+    r.slice(8..9).each { |x| x.is_a?(Integer).should be_true }
+  end
+
+  it "supports passing a custom seed" do
+    a = [1, 2, 3, 4, 5, 6, 7, 8]
+    b = %w(a b c d e f g h)
+    r1 = Array.riffle(a, b, seed: 123)
+    r2 = Array.riffle(a, b, seed: 123)
+    expect(r1).to eql(r2)
+  end
+end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: riffle
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.1
 platform: ruby
 authors:
 - Jordan Stephens
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-27 00:00:00.000000000 Z
+date: 2013-12-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,10 +66,12 @@ files:
 - README.md
 - Rakefile
 - lib/riffle.rb
+- lib/riffle/array.rb
 - lib/riffle/core_ext/array/riffle.rb
 - lib/riffle/version.rb
 - riffle.gemspec
 - spec/array_spec.rb
+- spec/riffle_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/jordanstephens/riffle
 licenses:
@@ -91,7 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.0
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: riffle multiple Arrays by selecting a random number of items from each and
@@ -99,5 +101,5 @@ summary: riffle multiple Arrays by selecting a random number of items from each
   have been merged.
 test_files:
 - spec/array_spec.rb
+- spec/riffle_spec.rb
 - spec/spec_helper.rb
-has_rdoc: