bucket_maker 0.0.1 → 0.0.2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZWUxYWViNjAzYTQ0MmY5NWVmNTc3YTY2ODM3ZTNjZDQwOTNkNzQ1Yg==
+    NzI3ZDVhYjZhNGQwMDc0YTljOTk1MzBmODE1MDYzNmUwOGRkNWQ1Zg==
   data.tar.gz: !binary |-
-    YWUzZmMyNzkxYmI2OTc0ZjI2Mjg1MDFiZjE1NGRiMmYyODBhYjFkZg==
+    Yjk3N2ExMWNkZjI5MDkzZDIwZGExMDVlZmM0MDE2YTMxOWM0NmJhNQ==
 SHA512:
   metadata.gz: !binary |-
-    ODMxZGE3ZDM3ZDllMmYwOGViYzZiOTIzZTQwMzk0NTQ5N2Y4YTk2YjJiMmRi
-    OWVlMTdiYTBjOGJkMGMyYWE3MjZmM2I1YTFkNDY3ZWQ2ZmIyNzZmZGFkYmY1
-    MjUyZjBhZTBkMzAxYjI0MGQwNmE2M2QzNWRmNjMxNWMxYmI1ODQ=
+    MTUwMWQ3ODA5OTYyODNkZDYzOWY0ZmYxMGJlNDQzYjg3N2EzYjcyMmUxOGFk
+    OTZhNTU3ZTg2MmY2MWMwNTY1OTQ1MDcyOWFkMmUxNDU1NWQ4MzNiNGE3MzZi
+    NzllOGQ4ODYyMmQ2OTI0OGNlNjFiMTIxMjQzZTczN2U4ZWJmNTE=
   data.tar.gz: !binary |-
-    MGZhOGExYjc5NjgyNjY0YjU2ZGQyMjM0NjllY2EwOGVmN2RkZTNlMGU4NGIy
-    NDhjYmI2ZGUyZGVlNTQzYzcyOTI4ZDEwNjQ2OTM4NjBhZWIzYTgzYjM3MDQx
-    MzRlNDZiMzRhNWJmOGUxOTRhMWJkMTQzYTk2OTQzYmJiOGRlZmQ=
+    NTM0Y2QzODkwOTRkNDhlN2FmMGI1ODY0NGMwYjJjZWIzYjY2NjkxOGFmNmRm
+    ZDg3NGE2Nzk0ZGM3Y2FkYjA5MTUwMzU1OGYxYjRmOTQ5Zjg1OTE1MTliNDZj
+    MjVhZWZkMDVhNjYxYmJmNDYwMTMxMmQyMzM1MmRhMWYyMzk0NGE=

data/.gitignore

@@ -16,3 +16,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+*.log

data/README.md

@@ -4,6 +4,7 @@
 [![Code Climate](https://codeclimate.com/github/dinks/bucket_maker.png)](https://codeclimate.com/github/dinks/bucket_maker)
 [![Build Status](https://travis-ci.org/dinks/bucket_maker.png?branch=master)](https://travis-ci.org/dinks/bucket_maker)
 [![Coverage Status](https://coveralls.io/repos/dinks/bucket_maker/badge.png)](https://coveralls.io/r/dinks/bucket_maker)
+[![Dependency Status](https://gemnasium.com/dinks/bucket_maker.png)](https://gemnasium.com/dinks/bucket_maker)
 
 A Gem to categorize Objects into buckets. Typical use case is an A/B test for Users
 

data/app/controllers/bucket_maker_controller.rb

@@ -4,27 +4,40 @@ class BucketMakerController < ApplicationController
   before_filter :ensure_valid_series_bucket_group, only: [:show, :switch]
   before_filter :ensure_valid_series_bucket, only: [:randomize]
 
+  # Show if the group for the current_user is the same as stored
+  #
   def show
     render text: @current_user.in_bucket?(@series_name, @bucket_name, @group_name)
   end
 
+  # Switch the current user to group_name
+  #
   def switch
     render text: @current_user.force_to_bucket!(@series_name, @bucket_name, @group_name)
   end
 
+  # Randomize the current_user for series_name and bucket_name
+  #
   def randomize
     render text: @current_user.bucketize_for_series_and_bucket!(@series_name, @bucket_name)
   end
 
   private
+
+  # Ensure we have valid attributes
+  #
   def ensure_valid_series_bucket_group
     not_found unless BucketMaker.buckets_configuration.has_group_in_bucket_in_series?(@series_name, @bucket_name, @group_name)
   end
 
+  # Ensure we have valid attributes
+  #
   def ensure_valid_series_bucket
     not_found unless BucketMaker.buckets_configuration.has_bucket_in_series?(@series_name, @bucket_name)
   end
 
+  # Head not found for invalid requests
+  #
   def not_found
     head :not_found
     false

data/config/routes.rb

@@ -2,12 +2,15 @@ Rails.application.routes.draw do
   if BucketMaker.configured? && BucketMaker.load_routes?
 
     # Show if the user is in group
+    #
     get   "/#{BucketMaker.configuration.path_prefix}:series_name/:bucket_name/:group_name", to: 'bucket_maker#show', as: :show_bucket, format: :json
 
     # Randomize group
+    #
     post   "/#{BucketMaker.configuration.path_prefix}:series_name/:bucket_name", to: 'bucket_maker#randomize', as: :randomize_bucket, format: :json
 
     # Force Switch group
+    #
     post   "/#{BucketMaker.configuration.path_prefix}:series_name/:bucket_name/:group_name", to: 'bucket_maker#switch', as: :switch_bucket, format: :json
 
   end

data/lib/bucket_maker/bucket.rb

@@ -1,4 +1,6 @@
 module BucketMaker
+  # Class which holds all the Bucket information
+  #
   class Bucket
     attr_accessor :name,
                   :summary,
@@ -11,6 +13,11 @@ module BucketMaker
     BUCKET_USER_AFTER   = 'created_after'
     BUCKET_DISTRIBUTION = 'distributions'
 
+    # Initializer
+    #
+    # @param name [string] Name of the Bucket
+    # @param options [Hash] Options for the Bucket like BUCKET_DESCRIPTION, BUCKET_USER_AFTER, BUCKET_DISTRIBUTION
+    #
     def initialize(name, options={})
       @name = name.to_sym
       @summary = options[BUCKET_DESCRIPTION]
@@ -27,20 +34,28 @@ module BucketMaker
                         result[dist_name.to_sym] = dist_options
                         result
                       end if options[BUCKET_DISTRIBUTION]
-
     end
 
+    # Randomize and get the group for this bucket
+    #
+    # @return [String] Group Name after randomization
+    #
     def random_group
       # Is set after first randomization
       unless @distributions_percent
+        # Get the total value of the distributions
+        #
         @denominator = @distributions.inject(0) do |result, (_, dist_value)|
                         result + dist_value
                       end
+        # Populate the variable with Distribution Percentages
+        #
         @distributions_percent =  @distributions.inject({}) do |result, (dist_name, dist_value)|
                                     result[dist_name.to_sym] = (dist_value * 100.0)/@denominator
                                     result
                                   end
-
+        # Change the Distribution Percentages with Ranges for easy checks
+        #
         @distributions_percent.inject(0) do |starter, (dist_name, percent_value)|
           ender = starter + percent_value
           @distributions_percent[dist_name.to_sym] = (starter .. ender)
@@ -48,18 +63,32 @@ module BucketMaker
         end
       end
 
+      # Randomize within the 0..max_range
+      #
       randomized = rand(@denominator * 100)
+      # Find where the randomized number falls in the calculated range
+      #
       @distributions_percent.find do |_, percent_range|
         percent_range.include?(randomized)
       end.first
     end
 
+    # Check if the Bucketable conforms to the pre-conditions
+    #
+    # @param bucketable [Object] an object which responds to :created_at
+    # @return [Boolean] is it bucketable?
+    #
     def is_bucketable?(bucketable)
-      bucketable.created_at >= @created_after
+      bucketable.created_at >= @created_after rescue false
     end
 
+    # Check if there is a group in this bucket
+    #
+    # @param group_name [String] Name of the group
+    # @return [Boolean] does the group exist?
+    #
     def has_group?(group_name)
-      @distributions[group_name.to_sym] != nil
+      @distributions[group_name.to_sym] != nil if group_name
     end
   end
 end

data/lib/bucket_maker/configuration.rb

@@ -3,6 +3,8 @@ require 'active_support/core_ext'
 require 'bucket_maker/series_maker'
 
 module BucketMaker
+  # Configuration Holder for the BucketMaker
+  #
   class Configuration
     attr_accessor :redis_options,
                   :path_prefix,
@@ -13,23 +15,35 @@ module BucketMaker
     attr_reader   :buckets_configuration,
                   :connection
 
+    # Initializer
+    # Sets up the default variable values
+    #
     def initialize
+      # For Redis
       @redis_options = {
         host:    'localhost',
         port:    6379,
         db:      1
       }
-
       @redis_expiration_time = 12.months
 
+      # For paths
+      # If nil, the routes wont be loaded
       @path_prefix = '2bOrNot2B/'
 
+      # Configuration for the buckets
+      #
       @buckets_config_file = nil
       @buckets_configuration = nil
 
+      # Lazy Load is used to group only if in_bucket? is called
+      # if false, then the group is done at creation time of the objec as well
+      #
       @lazy_load = true
     end
 
+    # Reconfigure the Configuration
+    #
     def reconfigure!
       if @buckets_config_file
         @buckets_configuration = BucketMaker::SeriesMaker.instance
@@ -37,10 +51,17 @@ module BucketMaker
       end
     end
 
+    # Check if the configuration is done
+    #
+    # @return [Boolean]
     def configured?
       @buckets_configuration && @buckets_configuration.configured?
     end
 
+    # Check if its ok to load routes
+    #
+    # @return [Boolean]
+    #
     def load_routes?
       @path_prefix != nil
     end
@@ -48,6 +69,8 @@ module BucketMaker
   end
 
   class << self
+    # Forward some of the calls to the configuration object
+    #
     extend Forwardable
 
     attr_accessor :configuration
@@ -55,6 +78,8 @@ module BucketMaker
     def_delegators :@configuration, :configured?, :reconfigure!, :buckets_configuration, :load_routes?
   end
 
+  # Configure after yielding to the block
+  #
   def self.configure
     if block_given?
       self.configuration ||= Configuration.new

data/lib/bucket_maker/engine.rb

@@ -1,4 +1,6 @@
 module BucketMaker
+  # Engine for the BucketMaker
+  #
   class Engine < Rails::Engine
     initializer 'Require concerns path' do |app|
       concerns_path = 'app/controllers/concerns'
@@ -7,6 +9,8 @@ module BucketMaker
         app.paths.add(concerns_path)
       end
 
+      # Always add the concern
+      #
       require 'concerns/bucket_maker_concern'
     end
   end

data/lib/bucket_maker/models/bucketable.rb

@@ -2,7 +2,18 @@ require 'bucket_maker/series_maker'
 
 module BucketMaker
   module Models
+    # Module which holds the base methods for Bucketable objects
+    #
     module Bucketable
+
+      # Used to test if this object has been grouped under a certain group
+      #
+      # @param series_name [String] Name of the Series
+      # @param bucket_name [String] Name of the Bucket
+      # @param group_name [String] Name of the Group
+      # @param force [Boolean] To force the object into the group_name
+      # @return [Boolean] if the given group_name is the same after randomization of groups
+      #
       def in_bucket?(series_name, bucket_name, group_name, force=false)
         # Get the singleton Series Maker
         series_maker = BucketMaker::SeriesMaker.instance
@@ -39,15 +50,32 @@ module BucketMaker
         end
       end
 
+      # Used to test if this object has not been grouped under a certain group
+      #
+      # @param series_name [String] Name of the Series
+      # @param bucket_name [String] Name of the Bucket
+      # @param group_name [String] Name of the Group
+      # @return [Boolean] if the given group_name is the not the same after randomization of groups
+      #
       def not_in_bucket?(series_name, bucket_name, group_name)
         !in_bucket?(series_name, bucket_name, group_name)
       end
 
+      # Force object into the group_name under bucket under series
+      #
+      # @param series_name [String] Name of the Series
+      # @param bucket_name [String] Name of the Bucket
+      # @param group_name [String] Name of the Group
+      # @return [Boolean] Always true because forcing is ok by us
+      #
       def force_to_bucket!(series_name, bucket_name, group_name)
         # Forcefully place inside the bucket
         in_bucket?(series_name, bucket_name, group_name, true)
       end
 
+      # Iteratively group object into buckets
+      #
+      # @return [Boolean] true if all the operations are successfull
       def bucketize!
         # Take each series and bucket
         BucketMaker::SeriesMaker.instance.for_each_series_with_bucketable do |series_maker, series_name, bucket_name|
@@ -61,6 +89,11 @@ module BucketMaker
         end
       end
 
+      # Group object for series_name and bucket_name
+      #
+      # @param series_name [String] Name of the Series
+      # @param bucket_name [String] Name of the Bucket
+      # @return [Boolean] true if the operation is successfull
       def bucketize_for_series_and_bucket!(series_name, bucket_name)
         # Get the singleton Series Maker
         series_maker = BucketMaker::SeriesMaker.instance
@@ -77,10 +110,20 @@ module BucketMaker
         end
       end
 
+      # Get the value from persistent store for a key
+      #
+      # @param series_key [String] Series Key
+      # @return [String] should return the group_name
+      #
       def group_for_key(series_key)
         raise NotImplementedError, "Implement group_for_key"
       end
 
+      # Set the value to a persistent store for a series and group
+      #
+      # @param series_key [String] Series Key
+      # @param group_name [String] Name of the Group
+      #
       def set_group_for_key(series_key, group_name)
         raise NotImplementedError, "Implement set_group_for_key"
       end

data/lib/bucket_maker/series.rb

@@ -1,4 +1,6 @@
 module BucketMaker
+  # Class which holds all the Series based information
+  #
   class Series
     attr_reader :name,
                 :description,
@@ -9,6 +11,11 @@ module BucketMaker
     SERIES_USER_AFTER   = 'created_after'
     SERIES_BUCKETS      = 'buckets'
 
+    # Initializer
+    #
+    # @param name [String] Name of the Series
+    # @param options [Hash] Options for the Series like SERIES_DESCRIPTION, SERIES_USER_AFTER, SERIES_BUCKETS
+    #
     def initialize(name, options={})
       @name = name.to_sym
       @description = options[SERIES_DESCRIPTION] || ''
@@ -23,26 +30,49 @@ module BucketMaker
                   end if options[SERIES_BUCKETS]
     end
 
+    # Iterator going through each bucket
+    #
     def each_bucket
       @buckets.each do |bucket_name, bucket|
         yield bucket_name, bucket
       end if block_given?
     end
 
+    # Get the Bucket object when given the bucket_name
+    #
+    # @param bucket_name [String] Name of the Bucket
+    # @return [BucketMaker::Bucket] Bucket object
+    #
     def bucket_with_name(bucket_name)
-      @buckets[bucket_name.to_sym]
+      @buckets[bucket_name.to_sym] if bucket_name
     end
 
+    # Check if the Bucketable object conforms to the conditions
+    #
+    # @param bucketable [Object] an object which responds to :created_at
+    # @return [Boolean] is it bucketable?
+    #
     def is_bucketable?(bucketable)
-      bucketable.created_at >= @created_after
+      bucketable.created_at >= @created_after rescue false
     end
 
+    # Check if the Series has the bucket
+    #
+    # @param bucket_name [String] Name of the Bucket
+    # @return [Boolean] does the bucket exist?
+    #
     def has_bucket?(bucket_name)
-      @buckets[bucket_name.to_sym] != nil
+      @buckets[bucket_name.to_sym] != nil rescue false
     end
 
+    # Check if the bucket has the group
+    #
+    # @param bucket_name [String] Name of the Bucket
+    # @param group_name [String] Name of the Group
+    # @return [Boolean] does the group exist inside the bucket?
+    #
     def has_group_in_bucket?(bucket_name, group_name)
-      has_bucket?(bucket_name) && @buckets[bucket_name.to_sym].has_group?(group_name)
+      has_bucket?(bucket_name) && @buckets[bucket_name.to_sym].has_group?(group_name) rescue false
     end
   end
 end

data/lib/bucket_maker/series_maker.rb

@@ -4,6 +4,8 @@ require 'bucket_maker/series'
 require 'bucket_maker/bucket'
 
 module BucketMaker
+  # Singleton which holds all information regarding the series, buckets and groups
+  #
   class SeriesMaker
     include Singleton
 
@@ -13,6 +15,10 @@ module BucketMaker
 
     BUCKET_ROOT = 'series'
 
+    # Set the class variables with configuration details
+    #
+    # @param config [String] Path of the config file WRT the rails app
+    #
     def make!(config)
       @series = []
 
@@ -28,10 +34,17 @@ module BucketMaker
       end
     end
 
+    # Check if the SeriesMaker is configured
+    #
+    # @return [Boolean] Signifies if the Object is configured
+    #
     def configured?
       @configuration != nil
     end
 
+    # Iterator for each series to be run on a Bucketable instance
+    # Expects a block parameter to be passed
+    #
     def for_each_series_with_bucketable
       @series.collect do |series_name, series|
         series.each_bucket do |bucket_name, bucket|
@@ -40,37 +53,81 @@ module BucketMaker
       end.inject(true) {|result, value| result && value } if block_given?
     end
 
+    # Get the Series object when given the series_name
+    #
+    # @param series_name [String] Series Name to search
+    # @return [BucketMaker::Series]
+    #
     def series_with_name(series_name)
-      @series[series_name.to_sym]
+      @series[series_name.to_sym] if series_name
     end
 
+    # Check if the series exist
+    #
+    # @param series_name [String] Series Name to search
+    # @return [Boolean] is it there?
+    #
     def has_series?(series_name)
-      @series[series_name.to_sym] != nil
+      @series[series_name.to_sym] != nil rescue false
     end
 
+    # Check if the bucket exist in the series
+    #
+    # @param series_name [String] Series Name to search
+    # @param bucket_name [String] Bucket Name to search
+    # @return [Boolean] is it there?
+    #
     def has_bucket_in_series?(series_name, bucket_name)
-      has_series?(series_name) && series_with_name(series_name).has_bucket?(bucket_name)
+      has_series?(series_name) && series_with_name(series_name).has_bucket?(bucket_name) rescue false
     end
 
+    # Check if the group exists in the bucket in the series
+    #
+    # @param series_name [String] Series Name to search
+    # @param bucket_name [String] Bucket Name to search
+    # @param group_name [String] Group Name to search
+    # @return [Boolean] is it there?
+    #
     def has_group_in_bucket_in_series?(series_name, bucket_name, group_name)
       has_bucket_in_series?(series_name, bucket_name) &&
-      series_with_name(series_name).bucket_with_name(bucket_name).has_group?(group_name)
+      series_with_name(series_name).bucket_with_name(bucket_name).has_group?(group_name) rescue false
     end
 
+    # Get the key for the combination
+    #
+    # @param bucketable [Object] any object which responds to :id
+    # @param series_name [String] Series Name
+    # @param bucket_name [String] Bucket Name
+    # @return [String] The key for future use
+    #
     def key_for_series(bucketable, series_name, bucket_name)
-      "bucket_maker:#{bucketable.class.to_s.underscore}_#{bucketable.id}:#{series_name.to_s}:#{bucket_name.to_s}" if bucketable && bucketable.id
+      "bucket_maker:#{bucketable.class.to_s.underscore}_#{bucketable.id}:#{series_name.to_s}:#{bucket_name.to_s}" if bucketable && bucketable.id rescue nil
     end
 
+    # Get a random group for the bucket in a series
+    #
+    # @param series_name [String] Series Name
+    # @param bucket_name [String] Bucket Name
+    # @return [String] Random Group Name according to the distribution
+    #
     def bucketize(series_name, bucket_name)
-      series_with_name(series_name).bucket_with_name(bucket_name).random_group
+      series_with_name(series_name).bucket_with_name(bucket_name).random_group rescue nil
     end
 
+    # Check if a Bucketable Object conform to the pre-conditions
+    #
+    # @param bucketable [Object] any object which has methods :has_attribute?, :created_at and :id
+    # @param series_name [String] Series Name
+    # @param bucket_name [String] Bucket Name
+    # @param group_name [String] Group Name
+    # @return [Boolean] is it bucketable?
+    #
     def bucketable?(bucketable, series_name, bucket_name, group_name)
       if  bucketable.has_attribute?(:created_at) &&
           has_group_in_bucket_in_series?(series_name, bucket_name, group_name)
 
         series_with_name(series_name).bucket_with_name(bucket_name).is_bucketable?(bucketable) ||
-        series_with_name(series_name).is_bucketable?(bucketable)
+        series_with_name(series_name).is_bucketable?(bucketable) rescue false
 
       else
         false

data/lib/bucket_maker/version.rb

@@ -1,3 +1,5 @@
 module BucketMaker
-  VERSION = "0.0.1"
+  # Get the version number
+  #
+  VERSION = "0.0.2"
 end

data/lib/generators/active_record/bucket_maker_generator.rb

@@ -2,6 +2,8 @@ require 'rails/generators/active_record'
 
 module ActiveRecord
   module Generators
+    # Generator to create Active Record specific classes
+    #
     class BucketMakerGenerator < ActiveRecord::Generators::Base
 
       ACTIVE_RECORDABLE = 'bucket'
@@ -9,6 +11,10 @@ module ActiveRecord
       source_root File.expand_path("../../templates", __FILE__)
       argument :store_in, type: :string, default: 'redis'
 
+      # Generate the model
+      #
+      # If store_in is active_record then the ACTIVE_RECORDABLE is also created which holds association
+      #
       def generate_model
         invoke "active_record:model", [name], :migration => false unless model_exists? && behavior == :invoke
         if store_in == 'active_record'
@@ -16,6 +22,10 @@ module ActiveRecord
         end
       end
 
+      # Inject the content to the models
+      #
+      # If store_in is actice_record then the ACTIVE_RECORDABLE is also inserted with association
+      #
       def inject_bucket_maker_content
         contents = <<-CONTENT.strip_heredoc
           # Module Inclusion for BucketMaker
@@ -40,6 +50,8 @@ module ActiveRecord
         inject_for_active_recordable if store_in == 'active_record' && active_recordable_exists?
       end
 
+      # Content for association if store_in is active_record
+      #
       def inject_for_active_recordable
         ar_contents = <<-CONTENT.strip_heredoc
             # Association with the bucket
@@ -51,6 +63,10 @@ module ActiveRecord
           inject_into_class(active_recordable_path, ACTIVE_RECORDABLE.camelize, ar_contents)
       end
 
+      # Migration copier
+      #
+      # If store_in is actice_record then the migration runs
+      #
       def copy_bucket_maker_migration
         if behavior == :invoke && store_in == 'active_record' && active_recordable_exists?
           migration_template "active_recordable_migration.rb", "db/migrate/create_#{ACTIVE_RECORDABLE.pluralize}"
@@ -59,22 +75,32 @@ module ActiveRecord
 
       private
 
+      # Check if the MODEL exists
+      #
       def model_exists?
         File.exists?(File.join(destination_root, model_path))
       end
 
+      # Check if the association exists
+      #
       def active_recordable_exists?
         File.exists?(File.join(destination_root, active_recordable_path))
       end
 
+      # Get the association path
+      #
       def active_recordable_path
         @ar_path ||= File.join("app", "models", "#{ACTIVE_RECORDABLE}.rb")
       end
 
+      # Get the MODEL path
+      #
       def model_path
         @model_path ||= File.join("app", "models", "#{file_path}.rb")
       end
 
+      # Get the module name to the included for store_in values
+      #
       def module_name_for_include
         case store_in
         when 'redis'

data/lib/generators/bucket_maker/bucket_maker_generator.rb

@@ -2,6 +2,8 @@ require 'rails/generators/named_base'
 
 module BucketMaker
   module Generators
+    # Base Generator to set the namespace
+    #
     class BucketMakerGenerator < Rails::Generators::NamedBase
 
       namespace 'bucket_maker'

data/lib/generators/bucket_maker/install_generator.rb

@@ -2,11 +2,15 @@ require 'rails/generators/base'
 
 module BucketMaker
   module Generators
+    # Installs the initializer
+    #
     class InstallGenerator < Rails::Generators::Base
       source_root File.expand_path("../../templates", __FILE__)
 
       desc "Creates a BucketMaker initializer"
 
+      # Copies the initializer bucket_maker from the templates and pastes
+      #
       def copy_initializer
         template "bucket_maker.rb", "config/initializers/bucket_maker.rb"
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bucket_maker
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Dinesh Vasudevan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-25 00:00:00.000000000 Z
+date: 2013-12-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -337,3 +337,4 @@ test_files:
 - spec/unit/bucketable_spec.rb
 - spec/unit/series_maker_spec.rb
 - spec/unit/series_spec.rb
+has_rdoc: