bucket_maker 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZWUxYWViNjAzYTQ0MmY5NWVmNTc3YTY2ODM3ZTNjZDQwOTNkNzQ1Yg==
+  data.tar.gz: !binary |-
+    YWUzZmMyNzkxYmI2OTc0ZjI2Mjg1MDFiZjE1NGRiMmYyODBhYjFkZg==
+SHA512:
+  metadata.gz: !binary |-
+    ODMxZGE3ZDM3ZDllMmYwOGViYzZiOTIzZTQwMzk0NTQ5N2Y4YTk2YjJiMmRi
+    OWVlMTdiYTBjOGJkMGMyYWE3MjZmM2I1YTFkNDY3ZWQ2ZmIyNzZmZGFkYmY1
+    MjUyZjBhZTBkMzAxYjI0MGQwNmE2M2QzNWRmNjMxNWMxYmI1ODQ=
+  data.tar.gz: !binary |-
+    MGZhOGExYjc5NjgyNjY0YjU2ZGQyMjM0NjllY2EwOGVmN2RkZTNlMGU4NGIy
+    NDhjYmI2ZGUyZGVlNTQzYzcyOTI4ZDEwNjQ2OTM4NjBhZWIzYTgzYjM3MDQx
+    MzRlNDZiMzRhNWJmOGUxOTRhMWJkMTQzYTk2OTQzYmJiOGRlZmQ=

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,8 @@
+cache: bundler
+language:
+  - ruby
+install:
+  - 'bundle install'
+rvm:
+  - 1.9.3
+  - 2.0.0

data/Appraisals

@@ -0,0 +1,11 @@
+if RUBY_VERSION >= '2.0'
+  rails_versions = ['~> 3.2.13', '~> 4.0.0']
+else
+  rails_versions = ['~> 3.1.12', '~> 3.2.13']
+end
+
+rails_versions.each do |rails_version|
+  appraise "rails#{rails_version.slice(/\d+\.\d+/)}" do
+    gem 'rails', rails_version
+  end
+end

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in bucket_maker.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Dinesh Vasudevan
+
+MIT License
+
+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.md

@@ -0,0 +1,115 @@
+# BucketMaker
+
+[![Gem Version](https://badge.fury.io/rb/bucket_maker.png)](http://rubygems.org/gems/bucket_maker)
+[![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)
+
+A Gem to categorize Objects into buckets. Typical use case is an A/B test for Users
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'bucket_maker'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install bucket_maker
+
+Generate the `initializer` by running
+
+    rails g bucket_maker:install
+
+This will create a file `config/bucket_maker.rb` with the configuration options
+
+The `Series/Bucket/Group` is common for all the `Bucketable` objects
+
+We define the buckets in a yml file and add this to the configuration file
+Please look at `spec/dummy/config/buckets.yml`
+
+To create a model (if does not exist) and populate the model with the bucket_maker module inclusion, run
+
+    rails g bucket_maker MODEL
+
+Where `MODEL` could be say `User`
+
+This will add the code to the *top* of the class
+
+    include BucketMaker::Models::Redisable
+
+By default it uses redis to store the keys and groups
+
+To make use of ActiveRecord to hold the key and group, use the generator this way
+
+    rails g bucket_maker user active_record
+
+This will add the code to the *top* of the class
+
+    include BucketMaker::Models::ActiveRecordable
+
+## Usage
+
+Every class which includes `BucketMaker::Models::` should implement 2 methods
+
+    group_for_key(series_key)
+
+and
+
+    set_group_for_key(series_key, group_name)
+
+These methods only define the way to retrieve and store data
+
+Look at `BucketMaker::Models::Bucketable` for more info
+
+### Methods
+
+    in_bucket?(series_name, bucket_name, group_name)
+
+To check if a `Bucketable` object is in the group `group_name` under a bucket `bucket_name`
+under a series `series_name`
+
+    not_in_bucket?(series_name, bucket_name, group_name)
+
+Inverse of `in_bucket?`
+
+    force_to_bucket!(series_name, bucket_name, group_name)
+
+Force the `Bucketable` to take the `group_name` under `bucket_name` under `series_name`
+
+    bucketize!
+
+Randomize the `Bucketable` object for all possible combinations
+
+    bucketize_for_series_and_bucket!(series_name, bucket_name)
+
+Randomize the `Bucketable` object for `bucket_name` under `series_name`
+
+### Routes and Controller
+
+There are 3 routes that the Gem tries to add. This is added *ONLY* if the configuration has the
+`path_prefix` option set to something other than `nil`. By default the routes are loaded
+
+All the results got are with respect to the `Bucketable` object `User`. The gem assumes that this
+request is a part of a A/B Testing procedure and expects `@current_user` to be set accordingly
+
+* GET to `/#{path_prefix}:series_name/:bucket_name/:group_name` is used to see if `@current_user` is
+in the group `group_name` under `bucket_name` under `series_name`
+
+* POST to `/#{path_prefix}:series_name/:bucket_name` is used group the `@current_user` into a group which
+is under `bucket_name` under `series_name`
+
+* POST to `/#{path_prefix}:series_name/:bucket_name/:group_name` is used force group the `@current_user`
+into the group `group_name` under `bucket_name` under `series_name`
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'bundler/gem_tasks'
+
+require 'rake'
+require 'rspec/core/rake_task'
+require 'appraisal'
+
+RSpec::Core::RakeTask.new(:spec)
+
+desc 'Default'
+task :default => [:all]
+
+desc 'Test the engine under all supported Rails versions'
+task all: ['appraisal:install'] do |t|
+  exec 'rake appraisal spec'
+end

data/app/controllers/bucket_maker_controller.rb

@@ -0,0 +1,32 @@
+class BucketMakerController < ApplicationController
+  include BucketMakerConcern
+
+  before_filter :ensure_valid_series_bucket_group, only: [:show, :switch]
+  before_filter :ensure_valid_series_bucket, only: [:randomize]
+
+  def show
+    render text: @current_user.in_bucket?(@series_name, @bucket_name, @group_name)
+  end
+
+  def switch
+    render text: @current_user.force_to_bucket!(@series_name, @bucket_name, @group_name)
+  end
+
+  def randomize
+    render text: @current_user.bucketize_for_series_and_bucket!(@series_name, @bucket_name)
+  end
+
+  private
+  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
+
+  def ensure_valid_series_bucket
+    not_found unless BucketMaker.buckets_configuration.has_bucket_in_series?(@series_name, @bucket_name)
+  end
+
+  def not_found
+    head :not_found
+    false
+  end
+end

data/app/controllers/concerns/bucket_maker_concern.rb

@@ -0,0 +1,23 @@
+module BucketMakerConcern
+  extend ActiveSupport::Concern
+
+  included do
+    layout false
+
+    before_filter :showable?, :extract_params
+
+    private
+    def showable?
+      unless @current_user && BucketMaker.configured?
+        head :unauthorized
+        false
+      end
+    end
+
+    def extract_params
+      @series_name  = params[:series_name] || ''
+      @bucket_name  = params[:bucket_name] || ''
+      @group_name   = params[:group_name] || ''
+    end
+  end
+end

data/bucket_maker.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bucket_maker/version'
+
+Gem::Specification.new do |spec|
+
+  spec.name          = "bucket_maker"
+  spec.version       = BucketMaker::VERSION
+  spec.authors       = ["Dinesh Vasudevan"]
+  spec.email         = ["dinesh.vasudevan@gmail.com"]
+  spec.description   = %q{ Create Simple A/B categories }
+  spec.summary       = %q{ A Gem to categorize Objects into buckets. Typical use case is an A/B test for Users }
+  spec.homepage      = "https://github.com/dinks/bucket_maker"
+  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_runtime_dependency "redis"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "activesupport", ">= 3.1.0" # For x.months
+  spec.add_development_dependency "activerecord", ">= 3.1.0" # For model test
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "appraisal" # Check against different Rails Versions
+  spec.add_development_dependency "capybara", "= 2.0.3"
+  spec.add_development_dependency "pry-debugger"
+  spec.add_development_dependency "rspec-rails"
+  spec.add_development_dependency "factory_girl_rails"
+  spec.add_development_dependency "mock_redis"
+  spec.add_development_dependency "coveralls"
+
+end

data/config/routes.rb

@@ -0,0 +1,14 @@
+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
+end

data/lib/bucket_maker.rb

@@ -0,0 +1,8 @@
+require 'bucket_maker/version'
+require 'bucket_maker/configuration'
+require 'bucket_maker/models/redisable'
+require 'bucket_maker/models/active_recordable'
+
+module BucketMaker
+  require 'bucket_maker/engine' if defined?(Rails)
+end

data/lib/bucket_maker/bucket.rb

@@ -0,0 +1,65 @@
+module BucketMaker
+  class Bucket
+    attr_accessor :name,
+                  :summary,
+                  :created_after,
+                  :distributions
+
+    attr_reader   :distributions_percent
+
+    BUCKET_DESCRIPTION  = 'description'
+    BUCKET_USER_AFTER   = 'created_after'
+    BUCKET_DISTRIBUTION = 'distributions'
+
+    def initialize(name, options={})
+      @name = name.to_sym
+      @summary = options[BUCKET_DESCRIPTION]
+
+      @created_after =  if options[BUCKET_USER_AFTER]
+                                DateTime.parse(options[BUCKET_USER_AFTER])
+                              else
+                                DateTime.parse("1st Jan 1900")
+                              end
+
+      @distributions_percent = nil
+      @denominator = 1
+      @distributions = options[BUCKET_DISTRIBUTION].inject({}) do |result, (dist_name, dist_options)|
+                        result[dist_name.to_sym] = dist_options
+                        result
+                      end if options[BUCKET_DISTRIBUTION]
+
+    end
+
+    def random_group
+      # Is set after first randomization
+      unless @distributions_percent
+        @denominator = @distributions.inject(0) do |result, (_, dist_value)|
+                        result + dist_value
+                      end
+        @distributions_percent =  @distributions.inject({}) do |result, (dist_name, dist_value)|
+                                    result[dist_name.to_sym] = (dist_value * 100.0)/@denominator
+                                    result
+                                  end
+
+        @distributions_percent.inject(0) do |starter, (dist_name, percent_value)|
+          ender = starter + percent_value
+          @distributions_percent[dist_name.to_sym] = (starter .. ender)
+          ender
+        end
+      end
+
+      randomized = rand(@denominator * 100)
+      @distributions_percent.find do |_, percent_range|
+        percent_range.include?(randomized)
+      end.first
+    end
+
+    def is_bucketable?(bucketable)
+      bucketable.created_at >= @created_after
+    end
+
+    def has_group?(group_name)
+      @distributions[group_name.to_sym] != nil
+    end
+  end
+end

data/lib/bucket_maker/configuration.rb

@@ -0,0 +1,66 @@
+require 'forwardable'
+require 'active_support/core_ext'
+require 'bucket_maker/series_maker'
+
+module BucketMaker
+  class Configuration
+    attr_accessor :redis_options,
+                  :path_prefix,
+                  :buckets_config_file,
+                  :lazy_load,
+                  :redis_expiration_time
+
+    attr_reader   :buckets_configuration,
+                  :connection
+
+    def initialize
+      @redis_options = {
+        host:    'localhost',
+        port:    6379,
+        db:      1
+      }
+
+      @redis_expiration_time = 12.months
+
+      @path_prefix = '2bOrNot2B/'
+
+      @buckets_config_file = nil
+      @buckets_configuration = nil
+
+      @lazy_load = true
+    end
+
+    def reconfigure!
+      if @buckets_config_file
+        @buckets_configuration = BucketMaker::SeriesMaker.instance
+        @buckets_configuration.make!(@buckets_config_file)
+      end
+    end
+
+    def configured?
+      @buckets_configuration && @buckets_configuration.configured?
+    end
+
+    def load_routes?
+      @path_prefix != nil
+    end
+
+  end
+
+  class << self
+    extend Forwardable
+
+    attr_accessor :configuration
+
+    def_delegators :@configuration, :configured?, :reconfigure!, :buckets_configuration, :load_routes?
+  end
+
+  def self.configure
+    if block_given?
+      self.configuration ||= Configuration.new
+      yield self.configuration
+      self.configuration.reconfigure!
+    end
+  end
+
+end