fiverr-vanity 1.7.2

data/doc/site.js

@@ -0,0 +1,27 @@
+$(function() {
+  var issuesTable = $("table#issues");
+  if (issuesTable.size() > 0) {
+    $.getJSON("http://github.com/api/v2/json/issues/list/assaf/vanity/open?callback=?", function(response) {
+      $.each(response.issues, function(i, issue) {
+        issuesTable.append(
+          $("<tr>").append(
+            $("<td>").append(
+              $("<a>").text(issue.title).attr("href", "http://github.com/assaf/vanity/issues#issue/" + issue.number)
+            ).append(
+              $("<span class='votes'>").text(issue.votes == 0 ? "no votes" : issue.votes == 1 ? "1 vote" : issue.votes + " votes")
+            )
+          )
+        );
+      });
+    });
+  }
+
+  var statsTable = $("#sidebar ul#stats");
+  if (statsTable.size() > 0) {
+    $.getJSON("http://github.com/api/v2/json/repos/show/assaf/vanity?callback=?", function(response) {
+      statsTable.
+        prepend( $("<li>").append("Forks: " + response.repository.forks) ).
+        prepend( $("<li>").append("Watchers: " + response.repository.watchers) )
+    })
+  }
+});

data/generators/templates/vanity_migration.rb

@@ -0,0 +1,53 @@
+class VanityMigration < ActiveRecord::Migration
+  def self.up
+    create_table :vanity_metrics do |t|
+      t.string :metric_id
+      t.datetime :updated_at
+    end
+    add_index :vanity_metrics, [:metric_id]
+
+    create_table :vanity_metric_values do |t|
+      t.integer :vanity_metric_id
+      t.integer :index
+      t.integer :value
+      t.string :date
+    end
+    add_index :vanity_metric_values, [:vanity_metric_id]
+
+    create_table :vanity_experiments do |t|
+      t.string :experiment_id
+      t.integer :outcome
+      t.datetime :created_at
+      t.datetime :completed_at
+    end
+    add_index :vanity_experiments, [:experiment_id]
+
+    create_table :vanity_conversions do |t|
+      t.integer :vanity_experiment_id
+      t.integer :alternative
+      t.integer :conversions
+    end
+    add_index :vanity_conversions, [:vanity_experiment_id, :alternative], :name => "by_experiment_id_and_alternative"
+
+    create_table :vanity_participants do |t|
+      t.string :experiment_id
+      t.string :identity
+      t.integer :shown
+      t.integer :seen
+      t.integer :converted
+    end
+    add_index :vanity_participants, [:experiment_id]
+    add_index :vanity_participants, [:experiment_id, :identity], :name => "by_experiment_id_and_identity"
+    add_index :vanity_participants, [:experiment_id, :shown], :name => "by_experiment_id_and_shown"
+    add_index :vanity_participants, [:experiment_id, :seen], :name => "by_experiment_id_and_seen"
+    add_index :vanity_participants, [:experiment_id, :converted], :name => "by_experiment_id_and_converted"
+  end
+
+  def self.down
+    drop_table :vanity_metrics
+    drop_table :vanity_metric_values
+    drop_table :vanity_experiments
+    drop_table :vanity_conversions
+    drop_table :vanity_participants
+  end
+end

data/generators/vanity_generator.rb

@@ -0,0 +1,8 @@
+class VanityGenerator < Rails::Generator::Base
+  def manifest
+    record do |m|
+      m.migration_template 'vanity_migration.rb', 'db/migrate',
+        :migration_file_name => "vanity_migration"
+    end
+  end
+end

data/lib/generators/templates/vanity_migration.rb

@@ -0,0 +1,53 @@
+class VanityMigration < ActiveRecord::Migration
+  def self.up
+    create_table :vanity_metrics do |t|
+      t.string :metric_id
+      t.datetime :updated_at
+    end
+    add_index :vanity_metrics, [:metric_id]
+
+    create_table :vanity_metric_values do |t|
+      t.integer :vanity_metric_id
+      t.integer :index
+      t.integer :value
+      t.string :date
+    end
+    add_index :vanity_metric_values, [:vanity_metric_id]
+
+    create_table :vanity_experiments do |t|
+      t.string :experiment_id
+      t.integer :outcome
+      t.datetime :created_at
+      t.datetime :completed_at
+    end
+    add_index :vanity_experiments, [:experiment_id]
+
+    create_table :vanity_conversions do |t|
+      t.integer :vanity_experiment_id
+      t.integer :alternative
+      t.integer :conversions
+    end
+    add_index :vanity_conversions, [:vanity_experiment_id, :alternative], :name => "by_experiment_id_and_alternative"
+
+    create_table :vanity_participants do |t|
+      t.string :experiment_id
+      t.string :identity
+      t.integer :shown
+      t.integer :seen
+      t.integer :converted
+    end
+    add_index :vanity_participants, [:experiment_id]
+    add_index :vanity_participants, [:experiment_id, :identity], :name => "by_experiment_id_and_identity"
+    add_index :vanity_participants, [:experiment_id, :shown], :name => "by_experiment_id_and_shown"
+    add_index :vanity_participants, [:experiment_id, :seen], :name => "by_experiment_id_and_seen"
+    add_index :vanity_participants, [:experiment_id, :converted], :name => "by_experiment_id_and_converted"
+  end
+
+  def self.down
+    drop_table :vanity_metrics
+    drop_table :vanity_metric_values
+    drop_table :vanity_experiments
+    drop_table :vanity_conversions
+    drop_table :vanity_participants
+  end
+end

data/lib/generators/vanity_generator.rb

@@ -0,0 +1,15 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+class VanityGenerator < Rails::Generators::Base
+  include Rails::Generators::Migration
+  source_root File.expand_path('../templates', __FILE__)
+
+  def self.next_migration_number(path)
+    Time.now.utc.strftime("%Y%m%d%H%M%S")
+  end
+
+  def create_model_file
+    migration_template "vanity_migration.rb", "db/migrate/vanity_migration.rb"
+  end
+end

data/lib/vanity.rb

@@ -0,0 +1,36 @@
+require "date"
+require "time"
+require "logger"
+require "cgi"
+require "erb"
+require "yaml"
+
+# All the cool stuff happens in other places.
+# @see Vanity::Helper
+# @see Vanity::Rails
+# @see Vanity::Playground
+# @see Vanity::Metric
+# @see Vanity::Experiment
+module Vanity
+end
+
+require "vanity/version"
+require "vanity/backport" if RUBY_VERSION < "1.9"
+# Metrics.
+require "vanity/metric/base"
+require "vanity/metric/active_record"
+require "vanity/metric/google_analytics"
+require "vanity/metric/remote"
+# Experiments.
+require "vanity/experiment/base"
+require "vanity/experiment/ab_test"
+# Database adapters
+require "vanity/adapters/abstract_adapter"
+require "vanity/adapters/redis_adapter"
+require "vanity/adapters/mongodb_adapter"
+require "vanity/adapters/mock_adapter"
+# Playground.
+require "vanity/playground"
+require "vanity/helpers"
+# Integration with various frameworks.
+require "vanity/frameworks"

data/lib/vanity/adapters/abstract_adapter.rb

@@ -0,0 +1,140 @@
+module Vanity
+  module Adapters
+
+    class << self
+      # Creates new connection to underlying datastore and returns suitable
+      # adapter (adapter object extends AbstractAdapter and wraps the
+      # connection). Vanity.playgroup.establish_connection uses this.
+      #
+      # @since 1.4.0
+      def establish_connection(spec)
+        begin
+          require "vanity/adapters/#{spec[:adapter]}_adapter"
+        rescue LoadError
+          raise "Could not find #{spec[:adapter]} in your load path"
+        end
+        adapter_method = "#{spec[:adapter]}_connection"
+        send adapter_method, spec
+      end
+    end
+
+    # Base class for all adapters. Adapters wrap underlying connection to a
+    # datastore and implement an API that Vanity can use to store/access
+    # metrics, experiments, etc.
+    class AbstractAdapter
+      # Returns true if connected.
+      def active?
+        false
+      end
+
+      # Close connection, release any resources.
+      def disconnect!
+      end
+
+      # Close and reopen connection.
+      def reconnect!
+      end
+
+      # Empty the database. This is used during tests.
+      def flushdb
+      end
+      
+
+      # -- Metrics --
+     
+      # Return when metric was last updated.
+      def get_metric_last_update_at(metric)
+        fail "Not implemented"
+      end
+  
+      # Track metric data.
+      def metric_track(metric, timestamp, identity, values)
+        fail "Not implemented"
+      end
+
+      # Returns all the metric values between from and to time instances
+      # (inclusive). Returns pairs of date and total count for that date.
+      def metric_values(metric, from, to)
+        fail "Not implemented"
+      end
+
+      # Deletes all information about this metric.
+      def destroy_metric(metric)
+        fail "Not implemented"
+      end
+
+
+      # -- Experiments --
+
+      # Store when experiment was created (do not write over existing value). 
+      def set_experiment_created_at(experiment, time)
+        fail "Not implemented"
+      end
+
+      # Return when experiment was created.
+      def get_experiment_created_at(experiment)
+        fail "Not implemented"
+      end
+     
+      # Returns true if experiment completed. 
+      def is_experiment_completed?(experiment)
+        fail "Not implemented"
+      end
+
+      # Returns counts for given A/B experiment and alternative (by index).
+      # Returns hash with values for the keys :participants, :converted and
+      # :conversions.
+      def ab_counts(experiment, alternative)
+        fail "Not implemented"
+      end 
+
+      # Pick particular alternative (by index) to show to this particular
+      # participant (by identity).
+      def ab_show(experiment, identity, alternative)
+        fail "Not implemented"
+      end
+
+      # Indicates which alternative to show to this participant. See #ab_show.
+      def ab_showing(experiment, identity)
+        fail "Not implemented"
+      end
+
+      # Cancels previously set association between identity and alternative. See
+      # #ab_show.
+      def ab_not_showing(experiment, identity)
+        fail "Not implemented"
+      end
+
+      # Records a participant in this experiment for the given alternative.
+      def ab_add_participant(experiment, alternative, identity)
+        fail "Not implemented"
+      end
+
+      # Records a conversion in this experiment for the given alternative.
+      # Associates a value with the conversion (default to 1). If implicit is
+      # true, add particpant if not already recorded for this experiment. If
+      # implicit is false (default), only add conversion is participant
+      # previously recorded as participating in this experiment.
+      def ab_add_conversion(experiment, alternative, identity, count = 1, implicit = false)
+        fail "Not implemented"
+      end
+
+      # Returns the outcome of this expriment (if set), the index of a
+      # particular alternative.
+      def ab_get_outcome(experiment)
+        fail "Not implemented"
+      end
+
+      # Sets the outcome of this experiment to a particular alternative.
+      def ab_set_outcome(experiment, alternative = 0)
+        fail "Not implemented"
+      end
+
+      # Deletes all information about this experiment.
+      def destroy_experiment(experiment)
+        fail "Not implemented"
+      end
+
+    end
+  end
+end

data/lib/vanity/adapters/active_record_adapter.rb

@@ -0,0 +1,247 @@
+module Vanity
+  module Adapters
+    class << self
+      # Creates new ActiveRecord connection and returns ActiveRecordAdapter.
+      def active_record_connection(spec)
+        require "active_record"
+        ActiveRecordAdapter.new(spec)
+      end
+    end
+
+    # ActiveRecord adapter
+    class ActiveRecordAdapter < AbstractAdapter
+      # Base model, stores connection and defines schema
+      class VanityRecord < ActiveRecord::Base
+      end
+
+      # Schema model
+      class VanitySchema < VanityRecord
+        set_table_name :vanity_schema
+      end
+
+      # Metric model
+      class VanityMetric < VanityRecord
+        set_table_name :vanity_metrics
+        has_many :vanity_metric_values
+
+        def self.retrieve(metric)
+          find_or_create_by_metric_id(metric.to_s)
+        end
+      end
+
+      # Metric value
+      class VanityMetricValue < VanityRecord
+        set_table_name :vanity_metric_values
+        belongs_to :vanity_metric
+      end
+
+      # Experiment model
+      class VanityExperiment < VanityRecord
+        set_table_name :vanity_experiments
+        has_many :vanity_conversions, :dependent => :destroy
+
+        # Finds or creates the experiment
+        def self.retrieve(experiment)
+          find_or_create_by_experiment_id(experiment.to_s)
+        end
+
+        def increment_conversion(alternative, count = 1)
+          record = vanity_conversions.find_or_create_by_alternative(alternative)
+          record.increment!(:conversions, count)
+        end
+      end
+
+      # Conversion model
+      class VanityConversion < VanityRecord
+        set_table_name :vanity_conversions
+        belongs_to :vanity_experiment
+      end
+
+      # Participant model
+      class VanityParticipant < VanityRecord
+        set_table_name :vanity_participants
+
+        # Finds the participant by experiment and identity. If
+        # create is true then it will create the participant
+        # if not found. If a hash is passed then this will be
+        # passed to create if creating, or will be used to
+        # update the found participant.
+        def self.retrieve(experiment, identity, create = true, update_with = nil)
+          if record = VanityParticipant.first(:conditions=>{ :experiment_id=>experiment.to_s, :identity=>identity.to_s })
+            record.update_attributes(update_with) if update_with
+          elsif create
+            record = VanityParticipant.create({ :experiment_id=>experiment.to_s, :identity=>identity }.merge(update_with || {}))
+          end
+          record
+        end
+      end
+
+      def initialize(options)
+        @options = options.inject({}) { |h,kv| h[kv.first.to_s] = kv.last ; h }
+        if @options["active_record_adapter"] && (@options["active_record_adapter"] != "default")
+          @options["adapter"] = @options["active_record_adapter"]
+          VanityRecord.establish_connection(@options)
+        end
+      end
+
+      def active?
+        VanityRecord.connected?
+      end
+
+      def disconnect!
+        VanityRecord.connection.disconnect! if active?
+      end
+
+      def reconnect!
+        VanityRecord.connection.reconnect!
+      end
+
+      def flushdb
+        [VanityExperiment, VanityMetric, VanityParticipant, VanityMetricValue, VanityConversion].each do |klass|
+          klass.delete_all
+        end
+      end
+
+      def get_metric_last_update_at(metric)
+        record = VanityMetric.find_by_metric_id(metric.to_s)
+        record && record.updated_at
+      end
+
+      def metric_track(metric, timestamp, identity, values)
+        record = VanityMetric.retrieve(metric)
+
+        values.each_with_index do |value, index|
+          record.vanity_metric_values.create(:date => timestamp.to_date.to_s, :index => index, :value => value)
+        end
+
+        record.updated_at = Time.now
+        record.save
+      end
+
+      def metric_values(metric, from, to)
+        connection = VanityMetric.connection
+        record = VanityMetric.retrieve(metric)
+        dates = (from.to_date..to.to_date).map(&:to_s)
+        conditions = [connection.quote_column_name('date') + ' IN (?)', dates]
+        order = "#{connection.quote_column_name('date')}"
+        select = "sum(#{connection.quote_column_name('value')}) AS value, #{connection.quote_column_name('date')}"
+        group_by = "#{connection.quote_column_name('date')}"
+
+        values = record.vanity_metric_values.all(
+                :select => select,
+                :conditions => conditions,
+                :order => order,
+                :group => group_by
+        )
+
+        dates.map do |date|
+          value = values.detect{|v| v.date == date }
+          [(value && value.value) || 0]
+        end
+      end
+
+      def destroy_metric(metric)
+        record = VanityMetric.find_by_metric_id(metric.to_s)
+        record && record.destroy
+      end
+
+      # Store when experiment was created (do not write over existing value).
+      def set_experiment_created_at(experiment, time)
+        record = VanityExperiment.find_by_experiment_id(experiment.to_s) ||
+                VanityExperiment.new(:experiment_id => experiment.to_s)
+        record.created_at ||= time
+        record.save
+      end
+
+      # Return when experiment was created.
+      def get_experiment_created_at(experiment)
+        record = VanityExperiment.retrieve(experiment)
+        record && record.created_at
+      end
+
+      def set_experiment_completed_at(experiment, time)
+        VanityExperiment.retrieve(experiment).update_attribute(:completed_at, time)
+      end
+
+      def get_experiment_completed_at(experiment)
+        VanityExperiment.retrieve(experiment).completed_at
+      end
+
+      # Returns true if experiment completed.
+      def is_experiment_completed?(experiment)
+        !!VanityExperiment.retrieve(experiment).completed_at
+      end
+
+      # Returns counts for given A/B experiment and alternative (by index).
+      # Returns hash with values for the keys :participants, :converted and
+      # :conversions.
+      def ab_counts(experiment, alternative)
+        record = VanityExperiment.retrieve(experiment)
+        participants = VanityParticipant.count(:conditions => {:experiment_id => experiment.to_s, :seen => alternative})
+        converted = VanityParticipant.count(:conditions => {:experiment_id => experiment.to_s, :converted => alternative})
+        conversions = record.vanity_conversions.sum(:conversions, :conditions => {:alternative => alternative})
+
+        {
+                :participants => participants,
+                :converted => converted,
+                :conversions => conversions
+        }
+      end
+
+      # Pick particular alternative (by index) to show to this particular
+      # participant (by identity).
+      def ab_show(experiment, identity, alternative)
+        VanityParticipant.retrieve(experiment, identity, true, :shown => alternative)
+      end
+
+      # Indicates which alternative to show to this participant. See #ab_show.
+      def ab_showing(experiment, identity)
+        participant = VanityParticipant.retrieve(experiment, identity, false)
+        participant && participant.shown
+      end
+
+      # Cancels previously set association between identity and alternative. See
+      # #ab_show.
+      def ab_not_showing(experiment, identity)
+        VanityParticipant.retrieve(experiment, identity, true, :shown => nil)
+      end
+
+      # Records a participant in this experiment for the given alternative.
+      def ab_add_participant(experiment, alternative, identity)
+        VanityParticipant.retrieve(experiment, identity, true, :seen => alternative)
+      end
+
+      # Records a conversion in this experiment for the given alternative.
+      # Associates a value with the conversion (default to 1). If implicit is
+      # true, add particpant if not already recorded for this experiment. If
+      # implicit is false (default), only add conversion is participant
+      # previously recorded as participating in this experiment.
+      def ab_add_conversion(experiment, alternative, identity, count = 1, implicit = false)
+        VanityParticipant.retrieve(experiment, identity, implicit, :converted => alternative)
+        VanityExperiment.retrieve(experiment).increment_conversion(alternative, count)
+      end
+
+      # Returns the outcome of this experiment (if set), the index of a
+      # particular alternative.
+      def ab_get_outcome(experiment)
+        VanityExperiment.retrieve(experiment).outcome
+      end
+
+      # Sets the outcome of this experiment to a particular alternative.
+      def ab_set_outcome(experiment, alternative = 0)
+        VanityExperiment.retrieve(experiment).update_attribute(:outcome, alternative)
+      end
+
+      # Deletes all information about this experiment.
+      def destroy_experiment(experiment)
+        VanityParticipant.delete_all(:experiment_id => experiment.to_s)
+        record = VanityExperiment.find_by_experiment_id(experiment.to_s)
+        record && record.destroy
+      end
+
+      def to_s
+        @options.to_s
+      end
+    end
+  end
+end