analytical 0.3.0

data/example/public/javascripts/rails.js

@@ -0,0 +1,118 @@
+document.observe("dom:loaded", function() {
+  function handleRemote(element) {
+    var method, url, params;
+
+    if (element.tagName.toLowerCase() === 'form') {
+      method = element.readAttribute('method') || 'post';
+      url    = element.readAttribute('action');
+      params = element.serialize(true);
+    } else {
+      method = element.readAttribute('data-method') || 'get';
+      url    = element.readAttribute('href');
+      params = {};
+    }
+
+    var event = element.fire("ajax:before");
+    if (event.stopped) return false;
+
+    new Ajax.Request(url, {
+      method: method,
+      parameters: params,
+      asynchronous: true,
+      evalScripts: true,
+
+      onLoading:     function(request) { element.fire("ajax:loading", {request: request}); },
+      onLoaded:      function(request) { element.fire("ajax:loaded", {request: request}); },
+      onInteractive: function(request) { element.fire("ajax:interactive", {request: request}); },
+      onComplete:    function(request) { element.fire("ajax:complete", {request: request}); },
+      onSuccess:     function(request) { element.fire("ajax:success", {request: request}); },
+      onFailure:     function(request) { element.fire("ajax:failure", {request: request}); }
+    });
+
+    element.fire("ajax:after");
+  }
+
+  function handleMethod(element) {
+    var method, url, token_name, token;
+
+    method     = element.readAttribute('data-method');
+    url        = element.readAttribute('href');
+    csrf_param = $$('meta[name=csrf-param]').first();
+    csrf_token = $$('meta[name=csrf-token]').first();
+
+    var form = new Element('form', { method: "POST", action: url, style: "display: none;" });
+    element.parentNode.appendChild(form);
+
+    if (method != 'post') {
+      var field = new Element('input', { type: 'hidden', name: '_method', value: method });
+      form.appendChild(field);
+    }
+
+    if (csrf_param) {
+      var param = csrf_param.readAttribute('content');
+      var token = csrf_token.readAttribute('content');
+      var field = new Element('input', { type: 'hidden', name: param, value: token });
+      form.appendChild(field);
+    }
+
+    form.submit();
+  }
+
+  $(document.body).observe("click", function(event) {
+    var message = event.findElement().readAttribute('data-confirm');
+    if (message && !confirm(message)) {
+      event.stop();
+      return false;
+    }
+
+    var element = event.findElement("a[data-remote]");
+    if (element) {
+      handleRemote(element);
+      event.stop();
+      return true;
+    }
+
+    var element = event.findElement("a[data-method]");
+    if (element) {
+      handleMethod(element);
+      event.stop();
+      return true;
+    }
+  });
+
+  // TODO: I don't think submit bubbles in IE
+  $(document.body).observe("submit", function(event) {
+    var element = event.findElement(),
+        message = element.readAttribute('data-confirm');
+    if (message && !confirm(message)) {
+      event.stop();
+      return false;
+    }
+
+    var inputs = element.select("input[type=submit][data-disable-with]");
+    inputs.each(function(input) {
+      input.disabled = true;
+      input.writeAttribute('data-original-value', input.value);
+      input.value = input.readAttribute('data-disable-with');
+    });
+
+    var element = event.findElement("form[data-remote]");
+    if (element) {
+      handleRemote(element);
+      event.stop();
+    }
+  });
+
+  $(document.body).observe("ajax:after", function(event) {
+    var element = event.findElement();
+
+    if (element.tagName.toLowerCase() === 'form') {
+      var inputs = element.select("input[type=submit][disabled=true][data-disable-with]");
+      inputs.each(function(input) {
+        input.value = input.readAttribute('data-original-value');
+        input.writeAttribute('data-original-value', null);
+        input.disabled = false;
+      });
+    }
+  });
+});

data/example/public/robots.txt

@@ -0,0 +1,5 @@
+# See http://www.robotstxt.org/wc/norobots.html for documentation on how to use the robots.txt file
+#
+# To ban all spiders from the entire site uncomment the next two lines:
+# User-Agent: *
+# Disallow: /

data/example/script/rails

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+
+ENV_PATH  = File.expand_path('../../config/environment',  __FILE__)
+BOOT_PATH = File.expand_path('../../config/boot',  __FILE__)
+APP_PATH  = File.expand_path('../../config/application',  __FILE__)
+
+require BOOT_PATH
+require 'rails/commands'

data/example/test/functional/page_controller_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+class PageControllerTest < ActionController::TestCase
+  test "should get index" do
+    get :index
+    assert_response :success
+  end
+
+  test "should get test_a" do
+    get :test_a
+    assert_response :success
+  end
+
+  test "should get test_b" do
+    get :test_b
+    assert_response :success
+  end
+
+end

data/example/test/performance/browsing_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+require 'rails/performance_test_help'
+
+# Profiling results for each test method are written to tmp/performance.
+class BrowsingTest < ActionDispatch::PerformanceTest
+  def test_homepage
+    get '/'
+  end
+end

data/example/test/test_helper.rb

@@ -0,0 +1,13 @@
+ENV["RAILS_ENV"] = "test"
+require File.expand_path('../../config/environment', __FILE__)
+require 'rails/test_help'
+
+class ActiveSupport::TestCase
+  # Setup all fixtures in test/fixtures/*.(yml|csv) for all tests in alphabetical order.
+  #
+  # Note: You'll currently still have to declare fixtures explicitly in integration tests
+  # -- they do not yet inherit this setting
+  fixtures :all
+
+  # Add more helper methods to be used by all tests here...
+end

data/example/test/unit/helpers/page_helper_test.rb

@@ -0,0 +1,4 @@
+require 'test_helper'
+
+class PageHelperTest < ActionView::TestCase
+end

data/lib/analytical.rb

@@ -0,0 +1,52 @@
+Dir.glob(File.dirname(__FILE__)+'/analytical/*.rb').each do |f|
+  require f
+end
+
+module Analytical
+
+  # any method placed here will apply to ActionController::Base
+  def analytical(options={})
+    send :include, InstanceMethods
+    send :helper_method, :analytical
+    send :cattr_accessor, :analytical_options
+
+    self.analytical_options = options.reverse_merge({
+      :modules=>[],
+      :development_modules=>[:console],
+      :disable_if=>Proc.new { !Rails.env.production? },
+    })
+
+    config_options = {}
+    File.open("#{RAILS_ROOT}/config/analytical.yml") do |f|
+      config_options = YAML::load(ERB.new(f.read).result).symbolize_keys
+      config_options.each do |k,v|
+        config_options[k] = v.symbolize_keys
+      end
+    end if File.exists?("#{RAILS_ROOT}/config/analytical.yml")
+
+    self.analytical_options = self.analytical_options.merge config_options
+
+    if self.analytical_options[:disable_if].call
+      self.analytical_options[:modules] = self.analytical_options[:development_modules]
+    end
+    self.analytical_options[:modules].each do |m|
+      Analytical::Api.send :include, "Analytical::#{m.to_s.camelize}".constantize
+    end
+  end
+
+  module InstanceMethods
+    # any method placed here will apply to instances
+
+    def analytical
+      options = self.class.analytical_options.merge({
+        :ssl => request.ssl?
+      })
+      @analytical ||= Analytical::Api.new options
+    end
+  end
+
+end
+
+if defined?(ActionController::Base)
+  ActionController::Base.extend Analytical
+end

data/lib/analytical/api.rb

@@ -0,0 +1,90 @@
+module Analytical
+
+  class Api
+    attr_accessor :options, :modules
+
+    def initialize(options={})
+      @options = options
+      @modules = @options[:modules].inject(ActiveSupport::OrderedHash.new) do |h, m|
+        h[m] = "Analytical::#{m.to_s.camelize}::Api".constantize.new(self, @options[m] || {})
+        h
+      end
+    end
+
+    #
+    # Catch commands such as :track, :identify and send them on to all of the modules.
+    # Or... if a module name is passed, return that module so it can be used directly, ie:
+    # analytical.console.go 'make', :some=>:cookies
+    #
+    def method_missing(method, *args, &block)
+      if @modules.keys.include?(method.to_sym)
+        @modules[method.to_sym]
+      else
+        process_command method.to_sym, *args
+      end
+    end
+
+
+    #
+    # Delegation class that passes methods to
+    #
+    class ImmediateDelegateHelper
+      def initialize(_parent)
+        @parent = _parent
+      end
+      def method_missing(method, *args, &block)
+        @parent.modules.values.collect do |m|
+          m.send method, *args
+        end.join("\n")
+      end
+    end
+
+    #
+    # Returns a new delegation object for immediate processing of a command
+    #
+    def now
+      ImmediateDelegateHelper.new(self)
+    end
+
+    #
+    # These methods return the javascript that should be inserted into each section of your layout
+    #
+    def head_javascript
+      [init_javascript(:head), tracking_javascript(:head)].delete_if{|s| s.blank?}.join("\n")
+    end
+    def body_prepend_javascript
+      [init_javascript(:body_prepend), tracking_javascript(:body_prepend)].delete_if{|s| s.blank?}.join("\n")
+    end
+    def body_append_javascript
+      [init_javascript(:body_append), tracking_javascript(:body_append)].delete_if{|s| s.blank?}.join("\n")
+    end
+
+    private
+
+    def process_command(command, *args)
+      @modules.values.each do |m|
+        m.queue command, *args
+      end
+    end
+
+    def tracking_javascript(location)
+      commands = []
+      @modules.each do |name, m|
+        commands += m.process_queued_commands if m.tracking_command_location==location
+      end
+      commands = commands.delete_if{|c| c.blank? || c.empty?}
+      unless commands.empty?
+        commands.unshift "<script type='text/javascript'>"
+        commands << "</script>"
+      end
+      commands.join("\n")
+    end
+
+    def init_javascript(location)
+      @modules.values.collect do |m|
+        m.init_javascript(location)
+      end.compact.join("\n")
+    end
+  end
+
+end

data/lib/analytical/base.rb

@@ -0,0 +1,34 @@
+module Analytical
+  module Base
+    module Api
+      attr_reader :tracking_command_location, :parent, :options
+      attr_accessor :commands
+
+      def initialize(_parent, _options={})
+        @parent = _parent
+        @options = _options
+        @tracking_command_location = :body_prepend
+        @commands = []
+      end
+
+      def track(*args); ''; end
+      def identify(id, *args); ''; end
+      def event(name, *args); ''; end
+      def init_javascript(location); {}; end
+
+      def queue(*args)
+        if args.first==:identify
+          @commands.unshift args
+        else
+          @commands << args
+        end
+      end
+      def process_queued_commands
+        command_strings = @commands.collect {|c| send(*c) }
+        @commands = []
+        command_strings
+      end
+
+    end
+  end
+end

data/lib/analytical/clicky.rb

@@ -0,0 +1,51 @@
+module Analytical
+  module Clicky
+    class Api
+      include Analytical::Base::Api
+
+      def initialize(parent, options={})
+        super
+        @tracking_command_location = :body_append
+      end
+
+      def init_javascript(location)
+        return '' unless location==:body_append
+
+        protocol = options[:ssl] ? 'https' : 'http'
+
+        js = <<-HTML
+        <!-- Analytical Init: Clicky -->
+        <script src="#{protocol}://static.getclicky.com/js" type="text/javascript"></script>
+        <script type="text/javascript">clicky.init('#{@options[:key]}');</script>
+        <noscript><p><img alt="Clicky" width="1" height="1" src="#{protocol}://in.getclicky.com/#{@options[:key]}ns.gif" /></p></noscript>
+        HTML
+
+        identify_commands = []
+        @commands.each do |c|
+          if c[0] == :identify
+            identify_commands << identify(*c[1..-1])
+          end
+        end
+        js = identify_commands.join("\n") + "\n" + js
+        @commands = @commands.delete_if {|c| c[0] == :identify }
+
+        js
+      end
+
+      def track(*args)
+        "clicky.log(\"#{args.first}\");"
+      end
+
+      def identify(id, *args)
+        data = { :id=>id }.merge(args.first)
+        code = <<-HTML
+        <script type='text/javascript'>
+          var clicky_custom_session = #{data.to_json};
+        </script>
+        HTML
+        code
+      end
+
+    end
+  end
+end

data/lib/analytical/console.rb

@@ -0,0 +1,37 @@
+module Analytical
+  module Console
+    class Api
+      include Analytical::Base::Api
+      include ActionView::Helpers::JavaScriptHelper
+
+      def initialize(parent, options={})
+        super
+        @tracking_command_location = :head
+      end
+
+      def init_javascript(location)
+        return '' unless location==:head
+        js = <<-HTML
+        <!-- Analytical Init: Console -->
+        <script type="text/javascript">
+          console.log('Analytical Init: Console');
+        </script>
+        HTML
+        js
+      end
+
+      def track(*args)
+        "console.log(\"Analytical Track: #{escape_javascript args.to_json}\");"
+      end
+
+      def identify(id, *args)
+        "console.log(\"Analytical Identify: #{id} #{escape_javascript args.to_json}\");"
+      end
+
+      def event(name, *args)
+        "console.log(\"Analytical Event: #{name} #{escape_javascript args.to_json}\");"
+      end
+
+    end
+  end
+end