blackbeard 0.0.2.0 → 0.0.3.1

data/lib/blackbeard/metric_data/unique.rb

@@ -0,0 +1,58 @@
+require 'blackbeard/metric_data/base'
+
+module Blackbeard
+  module MetricData
+    class Unique < Base
+
+      DEFAULT_SEGMENT = 'uniques'
+      def add(uid, amount = nil, segment = DEFAULT_SEGMENT)
+        add_at(tz.now, uid, amount, segment)
+      end
+
+      def add_at(time, uid, amount = nil, segment = DEFAULT_SEGMENT)
+        key = key_for_hour(time)
+        segment_key = segment_key(key, segment)
+
+        db.set_add_member(hours_set_key, key)
+        db.set_add_member(key, segment_key)
+        db.set_add_member(segment_key, uid)
+        #TODO: if not today, blow away rollup keys
+      end
+
+      def result_for_hour(time)
+        key = key_for_hour(time)
+        segment_keys = db.set_members(key)
+        result = {}
+        segment_keys.each do |segment_key|
+          segment = segment_key.split(/::/).last
+          result[segment] = db.set_count(segment_key)
+        end
+        result
+      end
+
+      def segment_key(key, segment)
+        "#{key}::#{segment}"
+      end
+
+    private
+
+      def merge_results(keys)
+        segments = {}
+        keys.each do |key|
+          segment_keys = db.set_members(key)
+          segment_keys.each do |segment_key|
+            segment = segment_key.split(/::/).last
+            segments[segment] ||= []
+            segments[segment].push(segment_key)
+          end
+        end
+        merged_results = {}
+        segments.each do |segment, segment_keys|
+          merged_results[segment] = db.set_union_count(segment_keys)
+        end
+        merged_results
+      end
+    end
+  end
+end
+

data/lib/blackbeard/metric_date.rb

@@ -0,0 +1,11 @@
+module Blackbeard
+  class MetricDate
+    attr_reader :date, :result
+
+    def initialize(date, result)
+      @date = date
+      @result = result
+    end
+
+  end
+end

data/lib/blackbeard/metric_hour.rb

@@ -0,0 +1,17 @@
+module Blackbeard
+  class MetricHour
+    attr_reader :hour, :result
+
+    def initialize(time, result)
+      @hour = round_to_beginning_of_hour(time)
+      @result = result
+    end
+
+  private
+
+    def round_to_beginning_of_hour(t)
+      t - ((t.min * 60) + t.sec)
+    end
+
+  end
+end

data/lib/blackbeard/pirate.rb

@@ -1,47 +1,58 @@
 require "blackbeard/context"
 require "blackbeard/metric"
-require "blackbeard/metric/unique"
-require "blackbeard/metric/total"
-require "blackbeard/feature"
+require "blackbeard/metric_data/unique"
+require "blackbeard/metric_data/total"
+require "blackbeard/test"
 require "blackbeard/errors"
+require "blackbeard/group"
 
 module Blackbeard
   class Pirate
     def initialize
-      @total_metrics = {}
-      @unique_metrics = {}
-      @features = {}
+      @metrics = {}
+      @tests = {}
     end
 
-    def total_metric(name)
-      @total_metrics[name] ||= Metric::Total.new(name)
+    def metric(type, type_id)
+      @metrics["#{type}::#{type_id}"] ||= Metric.new(type, type_id)
     end
 
-    def unique_metric(name)
-      @unique_metrics[name] ||= Metric::Unique.new(name)
+    def test(id)
+      @tests[id] ||= Test.new(id)
     end
 
-    def feature(name)
-      @features[name] ||= Feature.new(name)
+    def context(*args)
+      Context.new(self, *args)
     end
 
-    def context(options = {})
-      Context.new(self, options)
+    def set_context(*args)
+      @set_context = context(*args)
     end
 
-    def set_context(options = {})
-      @set_context = Context.new(self, options)
+    def clear_context
+      @set_context = nil
     end
 
-    def add_unique(name)
-      raise MissingContextError unless @set_context
-      @set_context.add_unique(name)
+    def add_unique(id)
+      return self unless @set_context
+      @set_context.add_unique(id)
     end
 
-    def add_total(name, amount)
-      raise MissingContextError unless @set_context
-      @set_context.add_total(name, amount)
+    def add_total(id, amount)
+      return self unless @set_context
+      @set_context.add_total(id, amount)
     end
 
+    def ab_test(id, options)
+      return self unless @set_context
+      @set_context.ab_test(id, options)
+    end
+
+    def active?(id)
+      return self unless @set_context
+      @set_context.active?(id)
+    end
+
+
   end
 end

data/lib/blackbeard/redis_store.rb

@@ -14,10 +14,20 @@ module Blackbeard
       redis.keys
     end
 
+
+    # Hash commands
     def hash_key_set_if_not_exists(hash_key, field, value)
       redis.hsetnx(hash_key, field, value)
     end
 
+    def hash_set(hash_key, field, value)
+      redis.hset(hash_key, field, value)
+    end
+
+    def hash_multi_set(hash_key, hash)
+      redis.mapped_hmset(hash_key, hash) unless hash.empty?
+    end
+
     def hash_length(hash_key)
       redis.hlen(hash_key)
     end
@@ -26,24 +36,50 @@ module Blackbeard
       redis.hkeys(hash_key)
     end
 
+    def hash_get(hash_key, field)
+      redis.hget(hash_key, field)
+    end
+
+    def hash_get_all(hash_key)
+      redis.hgetall(hash_key)
+    end
+
+    def hash_increment_by_float(hash_key, field, float)
+      redis.hincrbyfloat(hash_key, field, float)
+    end
+
+    # Set commands
     def set_members(set_key)
       redis.smembers(set_key)
     end
 
+    def set_remove_member(set_key, member)
+      redis.srem(set_key, member)
+    end
+
     def set_add_member(set_key, member)
       redis.sadd(set_key, member)
     end
 
+    def set_add_members(set_key, *members)
+      redis.sadd(set_key, members.flatten)
+    end
+
     def set_count(set_key)
       redis.scard(set_key)
     end
 
+    def set_union_count(*keys)
+      redis.sunionstore('set_union_count', keys.flatten)
+    end
+
+    # String commands
     def del(*keys)
       redis.del(*keys)
     end
 
-    def increment_by_float(key, increment)
-      redis.incrbyfloat(key, increment)
+    def increment_by_float(key, float)
+      redis.incrbyfloat(key, float)
     end
 
     def increment(key)
@@ -54,5 +90,13 @@ module Blackbeard
       redis.get(key)
     end
 
+    def multi_get(*keys)
+      redis.mget(*keys.flatten)
+    end
+
+    def set(key, value)
+      redis.set(key, value)
+    end
+
   end
 end

data/lib/blackbeard/selected_variation.rb

@@ -0,0 +1,13 @@
+module Blackbeard
+  class SelectedVariation
+    def initialize(test, variation)
+      @test = test
+      @variation = variation
+    end
+
+    def ==(s)
+      @test.add_variation(s)
+      @variation == s.to_s
+    end
+  end
+end

data/lib/blackbeard/storable.rb

@@ -1,19 +1,32 @@
+require 'blackbeard/configuration_methods'
+require 'blackbeard/storable_attributes'
+require 'blackbeard/storable_has_many'
+require 'blackbeard/storable_has_set'
+
 module Blackbeard
   class Storable
-    attr_reader :name
+    include ConfigurationMethods
+    include StorableHasMany
+    include StorableHasSet
+    include StorableAttributes
 
-    def initialize(name)
-      @name = name.to_s.downcase
-      db.hash_key_set_if_not_exists(master_key, key, tz.now.to_date)
-    end
+    class << self
+      def set_master_key(master_key)
+        @master_key = master_key.to_s
+      end
 
-    def master_key
-      raise "define master key in the class that inherits from storable"
+      def master_key
+        return @master_key if defined? @master_key
+        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
     end
 
-    def self.new_from_key(key)
-      name = key.split('::').last
-      self.new(name)
+    attr_reader :id
+
+    def initialize(id)
+      @id = id.to_s.downcase
+      db.hash_key_set_if_not_exists(master_key, key, tz.now.to_date)
     end
 
     def self.all_keys
@@ -24,34 +37,33 @@ module Blackbeard
       db.hash_length(master_key)
     end
 
-    def self.all
-      all_keys.map{ |key| new_from_key(key) }
+    def self.new_from_keys(*keys)
+      keys.flatten.map{ |key| new_from_key(key) }
     end
 
-  protected
-
-    def key
-      "#{master_key}::#{ name }"
+    def self.new_from_key(key)
+      if key =~ /^#{master_key}::(.+)$/
+        new($1)
+      else
+        nil
+      end
     end
 
-    def master_key
-      self.class.master_key
+    def self.all
+      all_keys.map{ |key| new_from_key(key) }
     end
 
-    def db
-      self.class.db
+    def ==(o)
+      o.class == self.class && o.id == self.id
     end
 
-    def self.db
-      Blackbeard.db
+    def key
+      "#{master_key}::#{ id }"
     end
 
-    def tz
-      self.class.tz
+    def master_key
+      self.class.master_key
     end
 
-    def self.tz
-      Blackbeard.tz
-    end
   end
 end

data/lib/blackbeard/storable_attributes.rb

@@ -0,0 +1,54 @@
+module Blackbeard
+  module StorableAttributes
+    def self.included(base)
+      base.send :include, InstanceMethods
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def storable_attributes=(x)
+        @storable_attributes = x
+      end
+
+      def storable_attributes
+        return @storable_attributes if defined? @storable_attributes
+        return self.superclass.storable_attributes if self.superclass.respond_to?(:storable_attributes)
+        []
+      end
+
+      def string_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]
+          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
+          end
+        end
+      end
+    end
+
+    module InstanceMethods
+      def update_attributes(tainted_params)
+        attributes = self.class.storable_attributes
+        safe_attributes = tainted_params.keys.select{ |k| attributes.include?(k.to_sym) }
+        safe_attributes.each do |attribute|
+          self.send("#{attribute}=".to_sym, tainted_params[attribute])
+        end
+      end
+
+      def storable_attributes_hash
+        @storable_attributes ||= db.hash_get_all(attributes_hash_key)
+      end
+
+      def attributes_hash_key
+        "#{key}::attributes"
+      end
+
+    end
+
+  end
+end

data/lib/blackbeard/storable_has_many.rb

@@ -0,0 +1,60 @@
+module Blackbeard
+  module StorableHasMany
+    def self.included(base)
+      base.send :include, InstanceMethods
+      base.extend ClassMethods
+    end
+
+    module InstanceMethods
+    end
+
+    module ClassMethods
+
+      def has_many(options = {})
+        options.each_pair do |plural, klass|
+          _has_many(plural, klass)
+        end
+      end
+
+      def _has_many(plural, klass)
+        plural = plural.to_s.downcase
+        singular = klass.name.split('::').last.downcase
+
+        methods = <<-END_OF_RUBY
+
+            def has_#{singular}?(o)
+              #{singular}_ids.include?(o.id)
+            end
+
+            def add_#{singular}(o)
+              db.set_add_member(#{plural}_set_key, o.key) unless has_#{singular}?(o)
+              \@#{plural} = nil
+            end
+
+            def remove_#{singular}(o)
+              db.set_remove_member(#{plural}_set_key, o.key)
+              \@#{plural} = nil
+            end
+
+            def #{plural}
+              \@#{plural} ||= #{klass.name}.new_from_keys(#{singular}_keys)
+            end
+
+            def #{singular}_ids
+              #{plural}.map{ |g| g.id }
+            end
+
+            def #{singular}_keys
+              db.set_members(#{plural}_set_key)
+            end
+
+            def #{plural}_set_key
+              key+"::#{plural}"
+            end
+        END_OF_RUBY
+
+        class_eval(methods)
+      end
+    end
+  end
+end

data/lib/blackbeard/storable_has_set.rb

@@ -0,0 +1,59 @@
+module Blackbeard
+  module StorableHasSet
+    def self.included(base)
+      base.send :include, InstanceMethods
+      base.extend ClassMethods
+    end
+
+    module InstanceMethods
+    end
+
+    module ClassMethods
+
+      def has_set(options = {})
+        options.each_pair do |plural, singular|
+          _has_set(plural, singular)
+        end
+      end
+
+      def _has_set(plural, singular)
+        plural = plural.to_s.downcase
+        singular = singular.to_s.downcase
+
+        methods = <<-END_OF_RUBY
+
+            def has_#{singular}?(o)
+              #{plural}.include?(o)
+            end
+
+            def add_#{singular}(o)
+              db.set_add_member(#{plural}_key, o) unless has_#{singular}?(o)
+              \@#{plural} = nil
+            end
+
+            def add_#{plural}(*args)
+              args.flatten.reject!{|o| has_#{singular}?(o) }
+              db.set_add_members(#{plural}_key, args) unless args.empty?
+              \@#{plural} = nil
+            end
+
+            def remove_#{singular}(o)
+              db.set_remove_member(#{plural}_key, o)
+              \@#{plural} = nil
+            end
+
+            def #{plural}
+              \@#{plural} ||= db.set_members(#{plural}_key)
+            end
+
+            def #{plural}_key
+              key+"::#{plural}"
+            end
+
+        END_OF_RUBY
+
+        class_eval(methods)
+      end
+    end
+  end
+end

data/lib/blackbeard/test.rb

@@ -0,0 +1,21 @@
+require 'blackbeard/storable'
+
+module Blackbeard
+  class Test < Storable
+    set_master_key :tests
+    string_attributes :name, :description
+    has_set :variations => :variation
+
+    def select_variation
+      # add :off unless :off, :control, :default, or :inactive
+      :off
+    end
+
+    def name
+      storable_attributes_hash['name'] || id
+    end
+
+  private
+
+    end
+end

data/lib/blackbeard/version.rb

@@ -1,3 +1,3 @@
 module Blackbeard
-  VERSION = "0.0.2.0"
+  VERSION = "0.0.3.1"
 end

data/lib/blackbeard.rb

@@ -5,14 +5,6 @@ module Blackbeard
   extend self
   attr_accessor :config
 
-  def tz
-    config.tz
-  end
-
-  def db
-    config.db
-  end
-
   def self.pirate
     @config ||= Configuration.new
     yield(config)

data/spec/configuration_spec.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+module Blackbeard
+  describe Configuration do
+    let(:config) { Configuration.new }
+    describe "define_group" do
+      it "should store the block in group_definiations" do
+        config.define_group(:hello) do |user,controller|
+          "world"
+        end
+        config.group_definitions[:hello].call.should == 'world'
+      end
+    end
+  end
+end