buckets 0.0.1

data/Gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+group :development do
+  gem "minitest", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.4"
+end

data/Gemfile.lock

@@ -0,0 +1,18 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    git (1.2.5)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    minitest (2.0.2)
+    rake (0.9.2.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.6.4)
+  minitest

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Tyson Tate
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,60 @@
+Splashy
+=======
+
+Simple distribution-based sampling of arbitrary objects from pools. Splashy.
+Pools. Get it!?
+
+Disclaimer: I have a BFA in Art, so I'm convinced there's a far better algorithm
+than the awful one I came up with. Pull request button is thataway.
+
+```ruby
+# Initialize with a desired final distribution.
+buckets = Splashy::Buckets.new( :easy => 0.3, :hard => 0.7 )
+
+# You can also specify a limit on elements in the final selection, no matter
+# how many objects you collect.
+buckets = Splashy::Buckets.new( {:easy => 0.3, :hard => 0.7}, 5 )
+
+# Fill one-by-one:
+buckets.add( :easy, obj1 )
+buckets.add( :hard, obj2 )
+
+# Fill using blocks:
+i = 0
+buckets.fill do |total_count|
+  bucket = [:easy, :hard][total_count % 1]
+  total_count < 100 ? [bucket, object] : nil
+end
+buckets.fill( :easy ) do |total_count|
+  total_count < 105 ? object : nil
+end
+
+# Get a distribution of objects:
+buckets = Splashy::Buckets.new( :a => 0.01, :b => 0.19, :c => 0.80 )
+10.times { |i| buckets.add( :a, "1#{i}") }
+2.times { |i| buckets.add( :b, "2#{i}") }
+40.times { |i| buckets.add( :c, "3#{i}") }
+buckets.select
+# Returns:
+#   {
+#     :a => ["10"],
+#     :b => ["20", "21"],
+#     :c => ["30", "31", "32", "33", "34", "35", "36", "37"]
+#   }
+```
+
+Contributing
+============
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+Copyright
+=========
+
+Copyright (c) 2011 Tyson Tate. See LICENSE.txt for further details.

data/Rakefile

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  gem.name = "buckets"
+  gem.homepage = "http://github.com/tysontate/buckets"
+  gem.license = "MIT"
+  gem.summary = "Simple distribution-based sampling of arbitrary objects."
+  gem.description = "Simple distribution-based sampling of arbitrary objects via the use of, well, buckets."
+  gem.email = "tyson@tysontate.com"
+  gem.authors = ["Tyson Tate"]
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/buckets.gemspec

@@ -0,0 +1,57 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{buckets}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Tyson Tate"]
+  s.date = %q{2011-12-08}
+  s.description = %q{Simple distribution-based sampling of arbitrary objects via the use of, well, buckets.}
+  s.email = %q{tyson@tysontate.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.markdown"
+  ]
+  s.files = [
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.markdown",
+    "Rakefile",
+    "VERSION",
+    "buckets.gemspec",
+    "lib/splashy.rb",
+    "lib/splashy/bucket.rb",
+    "lib/splashy/buckets.rb",
+    "test/helper.rb",
+    "test/test_splashy_buckets.rb"
+  ]
+  s.homepage = %q{http://github.com/tysontate/buckets}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.4.2}
+  s.summary = %q{Simple distribution-based sampling of arbitrary objects.}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<minitest>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
+    else
+      s.add_dependency(%q<minitest>, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+    end
+  else
+    s.add_dependency(%q<minitest>, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+  end
+end
+

data/lib/splashy.rb

@@ -0,0 +1,7 @@
+module Splashy
+  # That's unpossible!
+  class DistributionUnsatisfiedError < StandardError; end
+end
+
+require "splashy/buckets"
+require "splashy/bucket"

data/lib/splashy/bucket.rb

@@ -0,0 +1,29 @@
+module Splashy
+  private
+  
+  # Private: Collector of elements.
+  class Bucket
+    attr_reader :name
+    
+    def initialize( name )
+      @name = name
+      @elements = []
+    end
+    
+    def <<( element )
+      @elements << element
+    end
+    
+    def elements( count )
+      @elements[0, count]
+    end
+    
+    def empty?
+      self.count == 0
+    end
+    
+    def count
+      @elements.count
+    end
+  end
+end

data/lib/splashy/buckets.rb

@@ -0,0 +1,156 @@
+module Splashy
+  class Buckets
+    # wanted_distribution - A Hash of desired distributions:
+    #                       { :a => 0.2, :b => 0.5, :c => 0.3 }
+    # wanted_count        - (optional) Maximum total elements to be selected.
+    #                       otherwise, the maximum size set is selected.
+    def initialize( wanted_distribution, wanted_count=nil )
+      unless wanted_distribution.values.inject(0){ |m,v| m + v } == 1.0
+        raise ArgumentError.new( "Distribution must sum to 1.0" )
+      end
+      @wanted_distribution = wanted_distribution
+      @wanted_count = wanted_count
+      @buckets = Hash.new do |hash, name|
+        hash[name] = Bucket.new( name )
+      end
+      @total_count = 0
+    end
+    
+    # Public: Put elements into buckets.
+    # 
+    # bucket_name - If supplied, all yielded elements will be added to that
+    #               bucket.
+    # &block      - A block that returns (if `bucket_name` is not supplied)
+    #               an Array: [bucket_name, element]. If `bucket_name` is
+    #               supplied, only the element needs to be returned.
+    # 
+    # Examples
+    # 
+    #   fill { return [bucket_name, element] }
+    #   fill( :bucket_name ) { return element }
+    def fill( bucket_name = nil, &block )
+      if bucket_name
+        while element = yield( @total_count )
+          self.add( bucket_name, element )
+        end
+      else
+        while pair = yield( @total_count )
+          self.add( *pair )
+        end
+      end
+    end
+    
+    # Public: Add a single element to a bucket.
+    def add( bucket_name, element )
+      @buckets[bucket_name] << element
+      @total_count += 1
+    end
+    
+    # Returns true if the conditions are satisfied enough to select.
+    def satisfied?
+      begin
+        self.assert_satisfied!
+        true
+      rescue DistributionUnsatisfiedError => e
+        false
+      end
+    end
+    
+    # Public: Return a distribution of elements based on the desired
+    # distribution. If a satisfactory distribution is not possible, a
+    # DistributionUnsatisfiedError is raised.
+    # 
+    # Returns a Hash of elements based on the desired distribution, keyed by
+    # the bucket names.
+    def select
+      self.assert_satisfied!
+      
+      total_count = estimated_final_count
+      
+      selected = @wanted_distribution.keys.inject({}) do |memo, bucket_name|
+        bucket = @buckets[bucket_name]
+        count = total_count * @wanted_distribution[bucket_name]
+        count = [1, count.round].max
+        memo[bucket_name] = bucket.elements( count )
+        memo
+      end
+      
+      # Sometimes we need to fudge by a few to meet the `@wanted_count`
+      selected = self.trim( selected ) if @wanted_count
+      
+      selected
+    end
+    
+    protected
+    
+    # Trim a given Hash of Arrays keyed by bucket names until it meets
+    # @wanted_count.
+    def trim( selected )
+      raise ArgumentError.new( "Can't trip to a nil @wanted_count" ) unless @wanted_count
+      
+      while self.class.elements_count( selected ) > @wanted_count
+        # Calculate current variances from desired distribution. Ignore
+        # buckets with only one element, too.
+        variances = selected.keys.inject([]) do |memo, bucket_name|
+          size = selected[bucket_name].size
+          if size > 1
+            current_percent = size / @wanted_count.to_f
+            variance = @wanted_distribution[bucket_name] / current_percent
+            memo << [bucket_name, variance]
+          end
+          memo
+        end
+        break if variances.empty? # All have one element. Can't trim.
+        trim_bucket_name = variances.sort{ |a, b| a[1] }[0][0] # Smallest variance
+        selected[trim_bucket_name].pop
+      end
+      
+      selected
+    end
+    
+    # Returns count of all elements in the Hash's Array values.
+    def self.elements_count( hash )
+      hash.values.inject(0){ |memo, array| memo + array.count }
+    end
+    
+    # Returns projected final number of elements that will be returned to
+    # satisfy the requirements. If this is less than `@wanted_count`, when
+    # supplied, we can't meet the requirements.
+    def estimated_final_count
+      limiter_bucket = self.limiter_bucket
+      final_count = ( limiter_bucket.count / @wanted_distribution[limiter_bucket.name] ).floor
+      final_count = [@wanted_count, final_count].min if @wanted_count
+      final_count
+    end
+    
+    def assert_satisfied!
+      if @total_count < @wanted_distribution.size
+        raise DistributionUnsatisfiedError.new(
+          "Not enough elements (#{@total_count})."
+        )
+      end
+      
+      if @wanted_count
+        if @total_count < @wanted_count
+          raise DistributionUnsatisfiedError.new(
+            "Not enough elements (#{@total_count}) to satisfy your desired count (#{@wanted_count})."
+          )
+        end
+        
+        if self.estimated_final_count < @wanted_count
+          raise DistributionUnsatisfiedError.new(
+            "Distribution prevents the satisfaction of your desired count (#{@wanted_count})."
+          )
+        end
+      end
+    end
+    
+    # Return the bucket that is the limiter in the distribution.
+    def limiter_bucket
+      # Smallest value of "count / desired percent" is the limiter.
+      @buckets.values.map do |bucket|
+        [bucket, bucket.count / @wanted_distribution[bucket.name]]
+      end.sort { |a, b| a[1] <=> b[1] }[0][0]
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'minitest/autorun'
+# require 'minitest/unit'
+require 'minitest/benchmark'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'splashy'
+
+MiniTest::Unit.autorun

data/test/test_splashy_buckets.rb

@@ -0,0 +1,243 @@
+require 'helper'
+
+module BucketsSpecHelpers
+  def fill_with_counts( a, b, c )
+    a.times { |i| @buckets.add( :a, "1#{i}" ) }
+    b.times { |i| @buckets.add( :b, "2#{i}" ) }
+    c.times { |i| @buckets.add( :c, "3#{i}" ) }
+  end
+end
+
+describe Splashy::Buckets do
+  include BucketsSpecHelpers
+  
+  describe "failure" do
+    it "fails with bad distribution" do
+      assert_raises( ArgumentError ) do
+        Splashy::Buckets.new( :a => 0.33, :b => 0.33, :c => 0.33 )
+      end
+    end
+    
+    it "fails with empty pool" do
+      @buckets = Splashy::Buckets.new( :a => 0.33, :b => 0.33, :c => 0.34 )
+      assert !@buckets.satisfied?
+      assert_raises( Splashy::DistributionUnsatisfiedError ) do
+        @buckets.select
+      end
+    end
+    
+    it "fails with one empty pool" do
+      @buckets = Splashy::Buckets.new( :a => 0.33, :b => 0.33, :c => 0.34 )
+      fill_with_counts( 0, 1, 1 )
+      assert !@buckets.satisfied?
+      assert_raises( Splashy::DistributionUnsatisfiedError ) do
+        @buckets.select
+      end
+    end
+    
+    it "fails with not enough for the desired count" do
+      @buckets = Splashy::Buckets.new({ :a => 0.33, :b => 0.33, :c => 0.34 }, 4 )
+      fill_with_counts( 1, 1, 1 )
+      assert !@buckets.satisfied?
+      assert_raises( Splashy::DistributionUnsatisfiedError ) do
+        @buckets.select
+      end
+    end
+    
+    it "fails with an empty bucket" do
+      @buckets = Splashy::Buckets.new({ :a => 0.33, :b => 0.33, :c => 0.34 } )
+      fill_with_counts( 1, 1, 0 )
+      assert !@buckets.satisfied?
+      assert_raises( Splashy::DistributionUnsatisfiedError ) do
+        @buckets.select
+      end
+    end
+    
+    it "fails with distribution being such that desired count can't be met" do
+      @buckets = Splashy::Buckets.new({ :a => 0.80, :b => 0.1, :c => 0.10 }, 10 )
+      fill_with_counts( 2, 20, 20 )
+      assert !@buckets.satisfied?
+      assert_raises( Splashy::DistributionUnsatisfiedError ) do
+        @buckets.select
+      end
+    end
+  end
+  
+  describe "success" do
+    it "fills a single bucket, which is dumb" do
+      @buckets = Splashy::Buckets.new( :a => 1 )
+      @buckets.add( :a, "1" )
+      assert @buckets.satisfied?
+      assert_equal( {:a=>["1"]}, @buckets.select )
+    end
+    
+    it "selects from a small pool" do
+      @buckets = Splashy::Buckets.new( :a => 0.33, :b => 0.33, :c => 0.34 )
+      fill_with_counts( 1, 1, 1 )
+      assert @buckets.satisfied?
+      assert_equal( {:a=>["10"], :b=>["20"], :c=>["30"]}, @buckets.select )
+    end
+    
+    it "selects from a small pool with more than enough in one bucket" do
+      @buckets = Splashy::Buckets.new( :a => 0.33, :b => 0.33, :c => 0.34 )
+      fill_with_counts( 1, 1, 2 )
+      assert @buckets.satisfied?
+      assert_equal( {:a=>["10"], :b=>["20"], :c=>["30"]}, @buckets.select )
+    end
+    
+    it "selects from a small pool with a limiter bucket" do
+      @buckets = Splashy::Buckets.new( :a => 0.33, :b => 0.33, :c => 0.34 )
+      fill_with_counts( 1, 3, 3 )
+      assert @buckets.satisfied?
+      assert_equal( {:a=>["10"], :b=>["20"], :c=>["30"]}, @buckets.select )
+    end
+    
+    it "selects from a larger pool" do
+      @buckets = Splashy::Buckets.new( :a => 0.33, :b => 0.33, :c => 0.34 )
+      fill_with_counts( 3, 3, 3 )
+      assert @buckets.satisfied?
+      assert_equal(
+        {:a=>["10", "11", "12"], :b=>["20", "21", "22"], :c=>["30", "31", "32"]},
+        @buckets.select
+      )
+    end
+    
+    it "selects from a pool with a unequal distribution" do
+      @buckets = Splashy::Buckets.new( :a => 0.10, :b => 0.10, :c => 0.80 )
+      fill_with_counts( 3, 3, 3 )
+      assert @buckets.satisfied?
+      assert_equal(
+        {:a=>["10"], :b=>["20"], :c=>["30", "31"]},
+        @buckets.select
+      )
+    end
+    
+    it "selects from a pool with an \"opposite\" distribution" do
+      @buckets = Splashy::Buckets.new( :a => 0.10, :b => 0.10, :c => 0.80 )
+      fill_with_counts( 5, 5, 2 )
+      assert @buckets.satisfied?
+      assert_equal(
+        {:a=>["10"], :b=>["20"], :c=>["30", "31"]},
+        @buckets.select
+      )
+    end
+    
+    it "selects from a pool with a skewed distribution" do
+      @buckets = Splashy::Buckets.new( :a => 0.10, :b => 0.10, :c => 0.80 )
+      fill_with_counts( 10, 10, 1 )
+      assert @buckets.satisfied?
+      assert_equal(
+        {:a=>["10"], :b=>["20"], :c=>["30"]},
+        @buckets.select
+      )
+    end
+    
+    it "selects from a pool with another skewed distribution" do
+      @buckets = Splashy::Buckets.new( :a => 0.01, :b => 0.19, :c => 0.80 )
+      fill_with_counts( 10, 10, 1 )
+      assert @buckets.satisfied?
+      assert_equal(
+        {:a=>["10"], :b=>["20"], :c=>["30"]},
+        @buckets.select
+      )
+    end
+    
+    it "selects from a pool with yet another skewed distribution" do
+      @buckets = Splashy::Buckets.new( :a => 0.01, :b => 0.19, :c => 0.80 )
+      fill_with_counts( 10, 2, 40 )
+      assert @buckets.satisfied?
+      assert_equal(
+        {:a=>["10"], :b=>["20", "21"], :c=>["30", "31", "32", "33", "34", "35", "36", "37"]},
+        @buckets.select
+      )
+    end
+  end
+  
+  describe "filling buckets" do
+    it "accepts blocks" do
+      @buckets = Splashy::Buckets.new( :a => 0.01, :b => 0.19, :c => 0.80 )
+      a = [[:a, "1"]]
+      b = [[:b, "2"]]
+      c = [[:c, "3"]]
+      @buckets.fill { a.pop }
+      @buckets.fill { b.pop }
+      @buckets.fill { c.pop }
+      assert @buckets.satisfied?
+      assert_equal(
+        {:a=>["1"], :b=>["2"], :c=>["3"]},
+        @buckets.select
+      )
+    end
+    
+    it "accepts blocks with specified buckets" do
+      @buckets = Splashy::Buckets.new( :a => 0.01, :b => 0.19, :c => 0.80 )
+      a = ["1"]
+      b = ["2"]
+      c = ["3"]
+      @buckets.fill( :a ) { a.pop }
+      @buckets.fill( :b ) { b.pop }
+      @buckets.fill( :c ) { c.pop }
+      assert @buckets.satisfied?
+      assert_equal(
+        {:a=>["1"], :b=>["2"], :c=>["3"]},
+        @buckets.select
+      )
+    end
+  end
+  
+  describe "success with an enforced count" do
+    it "selects from a pool with an even distribution" do
+      @buckets = Splashy::Buckets.new( {:a => 0.33, :b => 0.33, :c => 0.34}, 6 )
+      fill_with_counts( 10, 2, 40 )
+      assert @buckets.satisfied?
+      assert_equal(
+        {:a=>["10", "11"], :b=>["20", "21"], :c=>["30", "31"]},
+        @buckets.select
+      )
+    end
+    
+    it "selects from a pool with an uneven distribution" do
+      @buckets = Splashy::Buckets.new( {:a => 0.33, :b => 0.33, :c => 0.34}, 5 )
+      fill_with_counts( 10, 2, 40 )
+      assert @buckets.satisfied?
+      assert_equal(
+        {:a=>["10", "11"], :b=>["20"], :c=>["30", "31"]},
+        @buckets.select
+      )
+    end
+    
+    it "selects from a pool with a skewed distribution" do
+      @buckets = Splashy::Buckets.new( {:a => 0.01, :b => 0.19, :c => 0.80}, 8 )
+      fill_with_counts( 10, 2, 40 )
+      assert @buckets.satisfied?
+      assert_equal(
+        {:a=>["10"], :b=>["20"], :c=>["30", "31", "32", "33", "34", "35"]},
+        @buckets.select
+      )
+    end
+    
+    it "selects from a pool with a wacky distribution" do
+      @buckets = Splashy::Buckets.new( {:a => 0.01, :b => 0.01, :c => 0.98}, 3 )
+      fill_with_counts( 3, 3, 3 )
+      assert @buckets.satisfied?
+      assert_equal(
+        {:a=>["10"], :b=>["20"], :c=>["30"]},
+        @buckets.select
+      )
+    end
+  end
+  
+  describe "performance" do
+    it "grows linearly with more elements" do
+      puts
+      assert_performance_linear 0.999 do |n|
+        @buckets = Splashy::Buckets.new( :a => 0.20, :b => 0.30, :c => 0.50 )
+        n.times do |i|
+          bucket = [:a, :a, :b, :c][i % 3]
+          @buckets.add( bucket, i.to_s )
+        end
+        @buckets.select rescue nil
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification 
+name: buckets
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Tyson Tate
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-12-08 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  requirement: *id001
+  name: minitest
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  requirement: *id002
+  name: bundler
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 6
+        - 4
+        version: 1.6.4
+  type: :development
+  requirement: *id003
+  name: jeweler
+description: Simple distribution-based sampling of arbitrary objects via the use of, well, buckets.
+email: tyson@tysontate.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.markdown
+files: 
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.markdown
+- Rakefile
+- VERSION
+- buckets.gemspec
+- lib/splashy.rb
+- lib/splashy/bucket.rb
+- lib/splashy/buckets.rb
+- test/helper.rb
+- test/test_splashy_buckets.rb
+has_rdoc: true
+homepage: http://github.com/tysontate/buckets
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: Simple distribution-based sampling of arbitrary objects.
+test_files: []
+