mountain-goat 1.0.1 → 1.0.2

data/lib/mountain-goat/models/mg/gi_meta.rb

@@ -0,0 +1,10 @@
+class Mg::GiMeta < ActiveRecord::Base
+  set_table_name :mg_gi_metas
+  
+  belongs_to :mg_goal_meta_type, :class_name => "Mg::GoalMetaType"
+  belongs_to :mg_record, :class_name => "Mg::Record"
+  
+  validates_presence_of :mg_goal_meta_type_id
+  validates_presence_of :mg_record_id
+  
+end

data/lib/mountain-goat/models/mg/goal.rb

@@ -0,0 +1,183 @@
+# Mg::Goal represents a target for user interaction (E.g. Sign-up)
+#
+# Attributes
+# goal_type:: A symbol uniquely identifying this goal type (for code interactions)
+# name:: A name for this goal
+# deleted_at:: Is this goal deleted? (MG Console)
+# is_hidden:: Is this goal hidden? (MG Console)
+class Mg::Goal < ActiveRecord::Base
+  set_table_name :mg_goals
+  
+  # ActiveRecord Associations
+  has_many :mg_records, :class_name => "Mg::Record", :foreign_key => "mg_goal_id"
+  has_many :mg_goal_meta_types, :class_name => "Mg::GoalMetaType", :foreign_key => "mg_goal_id"
+  has_many :gi_metas, :through => :mg_goal_meta_types, :class_name => "Mg::GiMeta", :foreign_key => "mg_goal_id"
+  has_many :gs_metas, :through => :mg_goal_meta_types, :class_name => "Mg::GsMeta", :foreign_key => "mg_goal_id"
+  has_many :report_items, :as => :reportable, :class_name => "Mg::ReportItem"
+  
+  # Secondary Associations
+  accepts_nested_attributes_for :mg_goal_meta_types, :reject_if => lambda { |a| a[:name].blank? || a[:var].blank? || a[:meta_type].blank? }, :allow_destroy => true
+  
+  # Validations
+  validates_presence_of :name
+  validates_format_of :goal_type, :with => /[a-z0-9_]{3,50}/i, :message => "must be between 3 and 30 characters, alphanumeric with underscores"
+  validates_uniqueness_of :goal_type  
+  
+  # Member Functions
+  
+  # Helper function to retrieve a goal by symbol
+  def self.by_type(s)
+    Mg::Goal.find( :first, :conditions => { :mg_goal_type => s.to_s } )
+  end
+  
+  # Get all records for given meta (e.g. for "Referer": { "Youtube" => Record1, } ...)
+  def records_for_meta(var)
+    gmt = self.mg_goal_meta_types.find_by_var( var.to_s )
+    return {} if gmt.nil?
+    gmt.meta.map { |m| { m.data => m.record } }
+  end
+  
+  # Get all records for a given meta value (e.g. for "Referer", "Facebook": [ Record1, Record2, Record3 ] ) 
+  def records_for_meta_val(var, data)
+    gmt = self.mg_goal_meta_types.find_by_var( var.to_s )
+    return [] if gmt.nil?
+    gmt.meta.find(:all, :conditions => { :data => data } ).map { |m| m.record }
+  end
+  
+  # Get all records pivoted by given meta (e.g. "Youtube" => [ Date, Date, Date ], "Facebook" => [ Date, Date, Date ])
+  def records_pivot(pivot)
+    res = {}
+    gmt_pivot = self.mg_goal_meta_types.find_by_var( pivot.to_s )
+    return {} if gmt_pivot.nil?
+    gmt_pivot.meta.map { |c| { :created_at => c.created_at, :pivot => c.data } }.each do |c|
+      if !res.include?(c[:pivot])
+        res[c[:pivot]] = []
+      end
+      
+      res[c[:pivot]].push c[:created_at]
+    end
+    
+    res.each { |k,v| v.sort! }
+    res
+  end
+  
+  def records_for_meta_val_pivot(var, data, pivot)
+    res = {}
+    gmt = self.mg_goal_meta_types.find_by_var( var.to_s )
+    gmt_pivot = self.mg_goal_meta_types.find_by_var( pivot.to_s )
+    return {} if gmt.nil? || gmt_pivot.nil?
+    gmt.meta.find(:all, :select => "`#{gmt.meta.table_name}`.created_at, gm.data AS pivot", :conditions => { :data => data }, :joins => "LEFT JOIN `#{gmt_pivot.meta.table_name}` gm ON gm.mg_goal_meta_type_id = #{gmt_pivot.id} AND gm.mg_record_id = `#{gmt.meta.table_name}`.mg_record_id").each do |c|
+      if !res.include?(c.pivot)
+        res[c.pivot] = []
+      end
+      
+      res[c.pivot].push c.created_at
+    end
+    
+    res.each { |k,v| v.sort! }
+    res
+  end
+  
+  # Pivot by given meta data by value (TODO: Document better)
+  def records_for_meta_val_pivot_item(var, data, pivot, item)
+    res = {}
+    gmt = self.mg_goal_meta_types.find_by_var( var.to_s )
+    gmt_pivot = self.mg_goal_meta_types.find_by_var( pivot.to_s )
+    gmt_item = self.mg_goal_meta_types.find_by_var( item.to_s )
+    return {} if gmt.nil? || gmt_pivot.nil? || gmt_item.nil?
+    gmt.meta.find(:all, :select => "`#{gmt.meta.table_name}`.created_at, gm.data AS pivot, gi.data as item", :conditions => { :data => data }, :joins => "LEFT JOIN `#{gmt_pivot.meta.table_name}` gm ON gm.mg_goal_meta_type_id = #{gmt_pivot.id} AND gm.mg_record_id = `#{gmt.meta.table_name}`.mg_record_id LEFT JOIN `#{gmt_item.meta.table_name}` gi ON gi.mg_goal_meta_type_id = #{gmt_item.id} AND gi.mg_record_id = `#{gmt.meta.table_name}`.mg_record_id").each do |c|
+      if !res.include?(c.pivot)
+        res[c.pivot] = []
+      end
+      
+      if gmt_item.meta_type == 'gi_meta'
+        c.item.to_i.times { res[c.pivot].push c.created_at }
+      else
+        res[c.pivot].push c.created_at if c.item == 'yes' #what else?
+      end
+    end
+    
+    res.each { |k,v| v.sort! }
+    res.delete_if { |k,v| v.count == 0 }
+    res
+  end
+  
+  # Get recent records based on start date
+  def recent_records(time_frame)
+    self.mg_records.find( :all, :conditions => [ "CREATED_AT > ?", time_frame.ago ] )  
+  end
+  
+  # Tally we have given a reward
+  def tally_reward_given( reward )
+    self.transaction do
+      self.update_attribute(:rewards_total, 0) if self.rewards_total.nil? #we should merge this with the next line, but whatever
+      Mg::Goal.update_counters(self.id, :rewards_given => 1)
+      Mg::Goal.update_counters(self.id, :rewards_total => reward)
+    end
+    
+    return self.reload
+  end
+  
+  #For Reportable
+  
+  # Title in report charts
+  def reportable_title(pivot)
+    if pivot.nil?
+      return self.name
+    elsif pivot.instance_of?(Mg::GoalMetaType)
+      return "#{self.name} by #{pivot.name}"
+    end
+  end
+  
+  # 
+  def reportable_chart_items(pivot)
+    #let's look for pageviews by day by source
+    #rallies_for_meta_val( :clique_id, @clique.id )
+    #logger.debug "sources: #{sources.inspect}"
+    #We now have a map of { source => [ date1, date2, ... ], ... }
+    
+    #Now, we just need to insert missing data (and group)
+    #Let's transpose that into { source => [ :x => day0, y => count ] }
+    if pivot.nil?
+      return Analytics.pivot_by_date( { :"Records" => self.mg_records.map { |r| r.created_at } }, self.created_at )
+    elsif pivot.instance_of?(Mg::GoalMetaType)
+      sources = self.records_pivot( pivot.var )
+      logger.warn "sources: #{sources}"
+      return Analytics.pivot_by_date(sources, self.created_at)
+    end
+  end
+  
+  # 
+  def reportable_gerbil_chart(pivot)
+    #chart = GerbilCharts::Charts::LineChart.new( :width => 350, :height => 200, :style => 'brushmetal.css', :circle_data_points => true )
+    
+    if pivot.nil?
+      data = Analytics.pivot_by_date( { :"Records" => self.mg_records.map { |r| r.created_at } }, self.created_at )
+    elsif pivot.instance_of?(Mg::GoalMetaType)
+      sources = self.records_pivot( pivot.var )
+      data = Analytics.pivot_by_date(sources, self.created_at)
+    end
+    #logger.warn "data: #{data.inspect}"
+    #logger.warn "ts: #{data.map { |line| line[1].map { |d| d[:x] }.to_a }[0].inspect}"
+    #logger.warn "val: #{data.map { |line| [ line[0] ] + line[1].map { |d| d[:y] }.to_a }[0].inspect}"
+    #chart.modelgroup = GerbilCharts::Models::SimpleTimeSeriesModelGroup.new(
+    #    :title => "Rallies",
+    #    :timeseries  =>  data.map { |line| line[1].map { |d| d[:x].to_time }.to_a }[0],
+    #    :models => data.map { |line| [ line[0].to_s ] + line[1].map { |d| d[:y] }.to_a }
+    #)
+    #fields = { }
+    #fields_simple = []
+    #fields.merge!({ d[:x].to_time.to_i => d[:x].to_s } ); fields_simple.push(d[:x])
+    graph = SVG::Graph::TimeSeries.new( :height => 350, :width => 700, :show_data_labels => false, :x_label_format => "%m/%d/%y", :graph_title => self.reportable_title(pivot), :show_graph_title => true, :show_data_values => false, :show_data_points => false, :area_fill => true )
+    data.each do |line|
+      res = []
+      line[1].each { |d| res.push(d[:x].strftime('%m/%d/%y')).push(d[:y]) }
+      graph.add_data :data => res, :title => line[0].to_s
+    end
+    
+    #logger.warn "Fields: #{fields.inspect}"
+    #logger.warn "Fields Simple: #{fields_simple.inspect}"
+        
+    graph
+  end
+end

data/lib/mountain-goat/models/mg/goal_meta_type.rb

@@ -0,0 +1,20 @@
+class Mg::GoalMetaType < ActiveRecord::Base
+  set_table_name :mg_goal_meta_types
+  
+  belongs_to :mg_goal, :class_name => "Mg::Goal"
+  has_many :gi_metas, :dependent => :destroy, :class_name => "Mg::GiMeta", :foreign_key => "mg_goal_meta_type_id" 
+  has_many :gs_metas, :dependent => :destroy, :class_name => "Mg::GsMeta", :foreign_key => "mg_goal_meta_type_id"
+  
+  validates_presence_of :name
+  validates_presence_of :var
+  validates_presence_of :meta_type
+  
+  def meta
+    case self.meta_type
+    when 'gi_meta', 'ci_meta'
+      return self.gi_metas
+    when 'gs_meta', 'cs_meta'
+      return self.gs_metas
+    end
+  end
+end

data/lib/mountain-goat/models/mg/gs_meta.rb

@@ -0,0 +1,10 @@
+class Mg::GsMeta < ActiveRecord::Base
+  set_table_name :mg_gs_metas
+  
+  belongs_to :mg_goal_meta_type, :class_name => "Mg::GoalMetaType"
+  belongs_to :mg_record, :class_name => "Mg::Record"
+  
+  validates_presence_of :mg_goal_meta_type_id
+  validates_presence_of :mg_record_id
+  
+end

data/lib/mountain-goat/models/mg/record.rb

@@ -0,0 +1,59 @@
+class Mg::Record < ActiveRecord::Base
+  set_table_name :mg_records
+  
+  belongs_to :mg_goal, :class_name => "Mg::Goal"
+  has_many :mg_goal_meta_types, :through => :mg_goal, :class_name => "Mg::GoalMetaType"
+  #has_many :mg_gi_metas, :through => :mg_goal_meta_types
+  #has_many :mg_gs_metas, :through => :mg_goal_meta_types
+
+  #Set meta data for applicable options-- don't store nil data (waste of space)
+  def set_meta_data(options)
+    options.each do |option|
+      gmt = self.mg_goal_meta_types.find_by_var(option[0].to_s)
+
+      #Create cmt if it doesn't current exist (unless nil)
+      if gmt.nil? && !option[1].nil? && ( option[1].is_a?(Integer) || option[1].is_a?(String) )
+        #infer type
+        meta_type = "gi_meta" if option[1].is_a?(Integer)
+        meta_type = "gs_meta" if option[1].is_a?(String)
+        gmt = mg_goal.mg_goal_meta_types.create!(:name => option[0].to_s, :var => option[0].to_s, :meta_type => meta_type)
+      end
+      
+      if !gmt.nil? #only if we can do it
+        gmt.meta.create!(:mg_record_id => self.id, :data => option[1]) if !option[1].nil?
+      end
+    end
+  end
+  
+  def meta_for( var )
+    gmt = self.mg_goal_meta_types.find_by_var( var.to_s )
+    return nil if gmt.nil?
+    m = gmt.meta.find_by_mg_record_id( self.id )
+    return nil if m.nil?
+    return m.data
+  end
+  
+  def all_metas
+    res = {}
+    self.mg_goal_meta_types.each do |gmt|
+      r = res.count
+      begin
+        if gmt.var =~ /(\w+)[_]id/i
+          if Kernel.const_get($1.classify)
+            item = Kernel.const_get($1.classify).find( self.meta_for( gmt.var ) )
+            if item.respond_to?(:name)
+              res.merge!({ $1 => item.name })
+            elsif item.respond_to?(:title)
+              res.merge!({ $1 => item.title })
+            end
+          end
+        end
+      rescue
+    end
+    
+      res.merge!({ gmt.var => self.meta_for( gmt.var ) }) if res.count == r
+    end
+    
+    res
+  end
+end

data/lib/mountain-goat/models/mg/test.rb

@@ -0,0 +1,31 @@
+# Mg::Test represents something you are 'a/b testing'
+# 
+# Attributes
+# test_type:: Symbol uniquely identifying this test (for code interaction)
+# title:: Title of the test (E.g. Banner text)
+# tally_each_serve:: Should we count each view by a user as a hit, or just first-serve to that user?
+# is_switch:: Are we implementing a code-switch as opposed to a text substitution
+# deleted_at:: Is this test deleted? (MG Console)
+# is_hidden:: Is this test hidden? (MG Console)
+class Mg::Test < ActiveRecord::Base
+  set_table_name :mg_tests
+  
+  # ActiveRecord Associations
+  has_many :mg_choices, :class_name => "Mg::Choice", :foreign_key => "mg_test_id"
+  
+  # Validations
+  validates_format_of :test_type, :with => /[a-z0-9_]{3,50}/i, :message => "must be between 3 and 30 characters, alphanumeric with underscores"
+  validates_uniqueness_of :test_type
+  
+  # Member Functions
+  
+  # Get total reward of all choices for this test
+  def total_reward
+    self.mg_choices.map { |choice| choice.reward || 0 }.sum
+  end
+  
+  # Get total served of all choices for this test
+  def total_served
+    self.mg_choices.map { |choice| choice.served || 0 }.sum
+  end
+end

data/lib/mountain-goat/public/g-funnel.js

@@ -0,0 +1,168 @@
+/*
+ * g.Raphael 0.4.1 - Charting library, based on Raphaël
+ *
+ * Copyright (c) 2009 Dmitry Baranovskiy (http://g.raphaeljs.com)
+ *               2011 Geoffrey Hayes (http://github.com/hayesgm)
+ * Licensed under the MIT (http://www.opensource.org/licenses/mit-license.php) license.
+ */
+Raphael.fn.g.funnelchart = function (cx, cy, cw, ch, values, opts) {
+    opts = opts || {};
+    var paper = this,
+        sectors = [],
+        covers = this.set(),
+        chart = this.set(),
+        series = this.set(),
+		insetLabels = this.set(),
+        order = [],
+        len = values.length,
+        angle = 0,
+        total = 0,
+        others = 0,
+        cut = 9,
+        defcut = true,
+		max = 0.0,
+		sh = ch / ( len + 0.0 );
+    chart.covers = covers;
+	
+	function trap(x0, y0, w0, w1, h) {
+		path = ['M', x0, y0, 'H', x0 + w0, 'L', ( w0 - w1 ) / 2.0 + x0 + w1, y0 + h, 'H', ( w0 - w1 ) / 2.0 + x0, 'Z'];
+		return path;
+	};
+    
+	var labeltext;
+	for (var i = 0; i < len; i++) {
+      total += values[i];
+	  max = max > values[i] ? max : values[i] + 0.0;
+	  
+	  if (opts.legend && opts.legend.length > i)
+	  	labeltext = opts.legend[i];
+		
+      values[i] = {value: values[i], order: i, valueOf: function () { return this.value; }, labeltext: labeltext};
+    }
+    
+	//values.sort(function (a, b) {
+    //  return b.value - a.value;
+    //});
+	
+    for (i = 0; i < len; i++) {
+		
+		var sx0 = ( cx + (cw / 2.0 ) - cw * ( values[i] / ( 2.0 * max ) ) );
+		var sy0 = cy + sh * i;
+		var w0 = values[i] * cw / max;
+		var w1 = ( i < len - 1 ) ? values[i + 1] * cw / max : 0;
+		
+    	if (opts.init) {
+    		var ipath = trap(sx0, sy0, w0, w1, sh).join(",");
+    	}
+      	//console.log([sx0, sy0, w0, w1, sh]);
+		var path = trap(sx0, sy0, w0, w1, sh);
+		var p = this.path(path).attr({fill: opts.colors && opts.colors[i] || this.g.colors[i] || "#666", stroke: opts.stroke || "#fff", "stroke-width": (opts.strokewidth == null ? 1 : opts.strokewidth), "stroke-linejoin": "round"});
+		if (values[i].labeltext)
+			p.insetLabel = this.text(sx0 + w0 / 2.0, sy0 + sh / 3.0, values[i].labeltext + ( i > 0 ? ( " " + ( values[i] - values[i - 1] / values[i - 1] ) + "%" ) : "")).attr({font: "20px Helvetica", stroke: "#fff", fill: "#eee", "fill-opacity": 0.95, "stroke-opacity": 0 });
+			
+    	p.value = values[i];
+    	sectors.push(p);
+    	series.push(p);
+    	opts.init && p.animate({path: path.join(",")}, (+opts.init - 1) || 1000, ">");
+    }
+	
+    for (i = 0; i < len; i++) {
+        p = paper.path(sectors[i].attr("path")).attr(this.g.shim);
+        opts.href && opts.href[i] && p.attr({href: opts.href[i]});
+        p.attr = function () {};
+        covers.push(p);
+        series.push(p);
+    }
+
+    chart.hover = function (fin, fout) {
+        fout = fout || function () {};
+        var that = this;
+        for (var i = 0; i < len; i++) {
+            (function (sector, cover, j) {
+                var o = {
+                    sector: sector,
+                    cover: cover,
+                    cx: cx,
+                    cy: cy,
+                    cw: cw,
+					ch: ch,
+                    value: values[j],
+                    total: total,
+                    label: that.labels && that.labels[j]
+                };
+                cover.mouseover(function () {
+                    fin.call(o);
+                }).mouseout(function () {
+                    fout.call(o);
+                });
+            })(series[i], covers[i], i);
+        }
+        return this;
+    };
+    // x: where label could be put
+    // y: where label could be put
+    // value: value to show
+    // total: total number to count %
+    chart.each = function (f) {
+        var that = this;
+        for (var i = 0; i < len; i++) {
+            (function (sector, cover, j) {
+                var o = {
+                    sector: sector,
+                    cover: cover,
+                    cx: cx,
+                    cy: cy,
+                    x: sector.middle.x,
+                    y: sector.middle.y,
+                    mangle: sector.mangle,
+                    r: r,
+                    value: values[j],
+                    total: total,
+                    label: that.labels && that.labels[j]
+                };
+                f.call(o);
+            })(series[i], covers[i], i);
+        }
+        return this;
+    };
+    chart.inject = function (element) {
+        element.insertBefore(covers[0]);
+    };
+    var legend = function (labels, otherslabel, mark, dir) {
+        var x = cx + cw * 1.7,
+            y = cy,
+            h = y + 10;
+        labels = labels || [];
+        dir = (dir && dir.toLowerCase && dir.toLowerCase()) || "east";
+        mark = paper.g.markers[mark && mark.toLowerCase()] || "disc";
+        chart.labels = paper.set();
+        for (var i = 0; i < len; i++) {
+            var clr = series[i].attr("fill"),
+                j = values[i].order,
+                txt;
+            values[i].others && (labels[j] = otherslabel || "Others");
+            labels[j] = paper.g.labelise(labels[j], values[i], total);
+            chart.labels.push(paper.set());
+            chart.labels[i].push(paper.g[mark](x + 5, h, 5).attr({fill: clr, stroke: "none"}));
+            chart.labels[i].push(txt = paper.text(x + 20, h, labels[j] || values[j]).attr(paper.g.txtattr).attr({fill: opts.legendcolor || "#000", "text-anchor": "start"}));
+            covers[i].label = chart.labels[i];
+            h += txt.getBBox().height * 1.2;
+        }
+        var bb = chart.labels.getBBox(),
+            tr = {
+                east: [0, -bb.height / 2],
+                west: [-bb.width - cw - 20, -bb.height / 2],
+                north: [-cw - bb.width / 2, -cw - bb.height - 10],
+                south: [- ( cw / 2 ) - bb.width / 2, ( cw / 2 ) + 10]
+            }[dir];
+        chart.labels.translate.apply(chart.labels, tr);
+        chart.push(chart.labels);
+    };
+    if (opts.legend) {
+        legend(opts.legend, opts.legendothers, opts.legendmark, opts.legendpos);
+    }
+    chart.push(series, covers);
+    chart.series = series;
+    chart.covers = covers;
+    return chart;
+};