blackbeard 0.0.3.1 → 0.0.4.0

data/lib/blackbeard/configuration.rb

@@ -22,9 +22,10 @@ module Blackbeard
       @tz ||= TZInfo::Timezone.get(@timezone)
     end
 
-    def define_group(id, &block)
+    def define_group(id, segments = nil, &block)
+      group = Group.find_or_create(id)
+      group.add_segments(segments || id)
       @group_definitions[id.to_sym] = block
-      Group.new(id)
     end
   end
 end

data/lib/blackbeard/context.rb

@@ -37,21 +37,25 @@ module Blackbeard
       end
     end
 
-    def active?(id)
-      ab_test(id) == :active
+    def feature_active?(id)
+      @pirate.feature(id.to_s).reload.active_for?(self)
     end
 
     def unique_identifier
-      @user.nil? ? "b#{blackbeard_visitor_id}" : "a#{@user.id}"
+      @user.nil? ? "b#{visitor_id}" : "a#{@user.id}"
     end
 
-private
+    def user_id
+      @user.id
+    end
 
-    def blackbeard_visitor_id
-      controller.request.cookies[:bbd] ||= generate_blackbeard_visitor_id
+    def visitor_id
+      controller.request.cookies[:bbd] ||= generate_visitor_id
     end
 
-    def generate_blackbeard_visitor_id
+private
+
+    def generate_visitor_id
       id = db.increment("visitor_id")
       controller.request.cookies[:bbd] = { :value => id, :expires => Time.now + 31536000 }
       id

data/lib/blackbeard/dashboard.rb

@@ -8,6 +8,7 @@ require 'routes/home'
 require 'routes/groups'
 require 'routes/metrics'
 require 'routes/tests'
+require 'routes/features'
 
 module Blackbeard
   class Dashboard < Sinatra::Base
@@ -19,6 +20,7 @@ module Blackbeard
     use DashboardRoutes::Metrics
     use DashboardRoutes::Tests
     use DashboardRoutes::Groups
+    use DashboardRoutes::Features
   end
 end
 

data/lib/blackbeard/errors.rb

@@ -1,4 +1,8 @@
 module Blackbeard
   class GroupNotInMetric < StandardError; end
   class StorableMasterKeyUndefined < StandardError; end
+  class StorableNotFound < StandardError; end
+  class StorableDuplicateKey < StandardError; end
+  class StorableNotSaved < StandardError; end
+  class UserIdNotDivisable < StandardError; end
 end

data/lib/blackbeard/feature.rb

@@ -0,0 +1,45 @@
+require 'blackbeard/storable'
+require 'blackbeard/feature_rollout'
+module Blackbeard
+  class Feature < Storable
+    include FeatureRollout
+
+    set_master_key :features
+    string_attributes :name, :description, :status
+    integer_attributes :visitors_rate, :users_rate
+    json_attributes :group_segments
+
+    def segments_for(group_id)
+      (group_segments && group_segments[group_id.to_s]) || []
+    end
+
+    def set_segments_for(group_id, *segments)
+      segments = Array(segments).flatten.compact.map{|a| a.to_s}
+      grp_segments = self.group_segments || {}
+      grp_segments[group_id.to_s] = segments
+      self.group_segments = grp_segments
+    end
+
+    def active_for?(context)
+      case status
+      when 'active'
+        true
+      when 'rollout'
+        rollout?(context)
+      else
+        false
+      end
+    end
+
+    def status
+      storable_attributes_hash['status'] || "inactive"
+    end
+
+    def name
+      storable_attributes_hash['name'] || id
+    end
+
+  private
+
+  end
+end

data/lib/blackbeard/feature_rollout.rb

@@ -0,0 +1,47 @@
+module Blackbeard
+  module FeatureRollout
+    def rollout?(context)
+      active_user?(context) || active_visitor?(context) || active_segment?(context)
+    end
+
+    def active_segment?(context)
+      return false unless group_segments
+      #TODO: speed this up. memoize group on the feature. store segment in user session
+      group_segments.each_pair do |group_id, segments|
+        next if segments.nil? || segments.empty?
+        group = Group.find(group_id) or next
+        user_segment = group.segment_for(context) or next
+        return true if segments.include?(user_segment)
+      end
+      false
+    end
+
+    def active_user?(context)
+      return false if (users_rate.zero? || !context.user)
+      return true if users_rate == 100
+
+      user_id = id_to_int(context.user_id)
+      (user_id % 100).between?(1,users_rate)
+    end
+
+    def active_visitor?(context)
+      return false if visitors_rate.zero?
+      return true if visitors_rate == 100
+      (context.visitor_id % 100).between?(1,visitors_rate)
+    end
+
+    def id_to_int(id)
+      if id.kind_of?(Integer)
+        id
+      elsif id.kind_of?(String)
+        bytes = id.bytes
+        if bytes.count > 8
+          bytes = bytes[-8..-1]
+        end
+        bytes.inject { |sum, n| sum * n }
+      else
+        raise UserIdNotDivisable
+      end
+    end
+  end
+end

data/lib/blackbeard/metric.rb

@@ -9,13 +9,30 @@ module Blackbeard
     string_attributes :name, :description
     has_many :groups => Group
 
-    def initialize(type, type_id)
-      @type = type
-      @type_id = type_id
-      @metric_data = {}
+    def self.create(type, type_id, options = {})
+      super("#{type}::#{type_id}", options)
+    end
+
+    def self.find(type, type_id)
+      super("#{type}::#{type_id}")
+    end
+
+    def self.find_or_create(type, type_id)
       super("#{type}::#{type_id}")
     end
 
+    def initialize(*args)
+      if args.size == 1 && args[0] =~ /::/
+        @type, @type_id = args[0].split(/::/)
+      elsif args.size == 2
+        @type = args[0]
+        @type_id = args[1]
+      else
+        raise ArgumentError
+      end
+      super("#{@type}::#{@type_id}")
+    end
+
     def self.new_from_key(key)
       if key =~ /^#{master_key}::(.+)::(.+)$/
         new($1,$2)
@@ -42,6 +59,7 @@ module Blackbeard
     end
 
     def metric_data(group = nil)
+      @metric_data ||= {}
       @metric_data[group] ||= begin
         raise GroupNotInMetric unless group.nil? || has_group?(group)
         MetricData.const_get(type.capitalize).new(self, group)

data/lib/blackbeard/pirate.rb

@@ -5,20 +5,26 @@ require "blackbeard/metric_data/total"
 require "blackbeard/test"
 require "blackbeard/errors"
 require "blackbeard/group"
+require "blackbeard/feature"
 
 module Blackbeard
   class Pirate
     def initialize
       @metrics = {}
       @tests = {}
+      @features = {}
     end
 
     def metric(type, type_id)
-      @metrics["#{type}::#{type_id}"] ||= Metric.new(type, type_id)
+      @metrics["#{type}::#{type_id}"] ||= Metric.find_or_create(type, type_id)
     end
 
     def test(id)
-      @tests[id] ||= Test.new(id)
+      @tests[id] ||= Test.find_or_create(id)
+    end
+
+    def feature(id)
+      @features[id] ||= Feature.find_or_create(id)
     end
 
     def context(*args)
@@ -48,9 +54,9 @@ module Blackbeard
       @set_context.ab_test(id, options)
     end
 
-    def active?(id)
-      return self unless @set_context
-      @set_context.active?(id)
+    def feature_active?(id)
+      return false unless @set_context
+      @set_context.feature_active?(id)
     end
 
 

data/lib/blackbeard/redis_store.rb

@@ -48,6 +48,10 @@ module Blackbeard
       redis.hincrbyfloat(hash_key, field, float)
     end
 
+    def hash_field_exists(hash_key, field)
+      redis.hexists(hash_key, field)
+    end
+
     # Set commands
     def set_members(set_key)
       redis.smembers(set_key)

data/lib/blackbeard/storable.rb

@@ -6,9 +6,6 @@ require 'blackbeard/storable_has_set'
 module Blackbeard
   class Storable
     include ConfigurationMethods
-    include StorableHasMany
-    include StorableHasSet
-    include StorableAttributes
 
     class << self
       def set_master_key(master_key)
@@ -20,13 +17,59 @@ module Blackbeard
         return self.superclass.master_key if self.superclass.respond_to?(:master_key)
         raise StorableMasterKeyUndefined, "define master key in the class that inherits from storable"
       end
+
+      def on_save(method)
+        on_save_methods.push(method)
+      end
+
+      def on_save_methods
+        @on_save_methods ||= self.superclass.on_save_methods.dup if self.superclass.respond_to?(:on_save_methods)
+        @on_save_methods ||= []
+      end
+
+      def on_reload(method)
+        on_reload_methods.push(method)
+      end
+
+      def on_reload_methods
+        @on_reload_methods ||= self.superclass.on_reload_methods.dup if self.superclass.respond_to?(:on_reload_methods)
+        @on_reload_methods ||= []
+      end
     end
 
+    include StorableHasMany
+    include StorableHasSet
+    include StorableAttributes
+
     attr_reader :id
+    attr_accessor :new_record
 
     def initialize(id)
       @id = id.to_s.downcase
-      db.hash_key_set_if_not_exists(master_key, key, tz.now.to_date)
+      @new_record = true
+    end
+
+    def self.find(id)
+      key = key_for(id)
+      return nil unless db.hash_field_exists(master_key, key)
+      storable = new(id)
+      storable.new_record = false
+      storable
+    end
+
+    def self.create(id, attributes = {})
+      key = key_for(id)
+      raise StorableDuplicateKey if db.hash_field_exists(master_key, key)
+      storable = new(id)
+      storable.save
+      storable.update_attributes(attributes) unless attributes.empty?
+      storable
+    end
+
+    def self.find_or_create(id)
+      storable = new(id)
+      storable.save
+      storable
     end
 
     def self.all_keys
@@ -43,7 +86,9 @@ module Blackbeard
 
     def self.new_from_key(key)
       if key =~ /^#{master_key}::(.+)$/
-        new($1)
+        storable = new($1)
+        storable.new_record = false
+        storable
       else
         nil
       end
@@ -53,12 +98,33 @@ module Blackbeard
       all_keys.map{ |key| new_from_key(key) }
     end
 
+    def save
+      if new_record?
+        db.hash_key_set_if_not_exists(master_key, key, tz.now.to_date)
+        @new_record = false
+      end
+      self.class.on_save_methods.each{ |m| self.send(m) }
+    end
+
+    def reload
+      self.class.on_reload_methods.each{ |m| self.send(m) }
+      self
+    end
+
+    def new_record?
+      @new_record
+    end
+
     def ==(o)
       o.class == self.class && o.id == self.id
     end
 
+    def self.key_for(id)
+      "#{master_key}::#{ id.to_s.downcase }"
+    end
+
     def key
-      "#{master_key}::#{ id }"
+      self.class.key_for(id)
     end
 
     def master_key

data/lib/blackbeard/storable_attributes.rb

@@ -1,8 +1,12 @@
+require 'json'
+
 module Blackbeard
   module StorableAttributes
     def self.included(base)
-      base.send :include, InstanceMethods
       base.extend ClassMethods
+      base.send :include, InstanceMethods
+      base.send :on_save, :save_storable_attributes
+      base.send :on_reload, :reload_storable_attributes
     end
 
     module ClassMethods
@@ -16,6 +20,35 @@ module Blackbeard
         []
       end
 
+      def integer_attributes(*attributes)
+        self.storable_attributes += attributes
+        attributes.each do |method_name|
+          method_name = method_name.to_sym
+          send :define_method, method_name do
+            storable_attributes_hash[method_name.to_s].to_i
+          end
+          send :define_method, "#{method_name}=".to_sym do |value|
+            storable_attributes_hash[method_name.to_s] = value.to_i.to_s
+            @storable_attributes_dirty = true
+          end
+        end
+      end
+
+      def json_attributes(*attributes)
+        self.storable_attributes += attributes
+        attributes.each do |method_name|
+          method_name = method_name.to_sym
+          send :define_method, method_name do
+            return nil if storable_attributes_hash[method_name.to_s].nil?
+            JSON.parse(storable_attributes_hash[method_name.to_s])
+          end
+          send :define_method, "#{method_name}=".to_sym do |value|
+            storable_attributes_hash[method_name.to_s] =  JSON.generate(value)
+            @storable_attributes_dirty = true
+          end
+        end
+      end
+
       def string_attributes(*attributes)
         self.storable_attributes += attributes
         attributes.each do |method_name|
@@ -24,8 +57,8 @@ module Blackbeard
             storable_attributes_hash[method_name.to_s]
           end
           send :define_method, "#{method_name}=".to_sym do |value|
-            db.hash_set(attributes_hash_key, method_name, value)
-            storable_attributes_hash[method_name.to_s] = value
+            storable_attributes_hash[method_name.to_s] = value.to_s
+            @storable_attributes_dirty = true
           end
         end
       end
@@ -38,6 +71,20 @@ module Blackbeard
         safe_attributes.each do |attribute|
           self.send("#{attribute}=".to_sym, tainted_params[attribute])
         end
+        save_storable_attributes
+      end
+
+      def save_storable_attributes
+        raise StorableNotSaved if new_record?
+        if @storable_attributes_dirty
+          db.hash_multi_set(attributes_hash_key, storable_attributes_hash)
+          @storable_attributes_dirty = false
+        end
+      end
+
+      def reload_storable_attributes
+        @storable_attributes = nil
+        @storable_attributes_dirty = false
       end
 
       def storable_attributes_hash