rubaidh-google_analytics 1.0.20081111

data/README.rdoc

@@ -0,0 +1,122 @@
+= GoogleAnalytics
+
+This plugin enables Google Analytics support in your application. By default
+it will output the analytics code for every single page automatically, if it
+is configured correctly. This is done by adding:
+
+    Rubaidh::GoogleAnalytics.tracker_id = 'UA-12345-67'
+
+to your <tt>config/environment.rb</tt>, inserting your own tracker id. This
+can be discovered by looking at the value assigned to +_uacct+ in the
+Javascript code.
+
+If you want to disable the code insertion for particular pages, add the
+following to controllers that don't want it:
+
+    skip_after_filter :add_google_analytics_code
+
+If you are running rails 2.1 or above add install this by adding:
+
+    config.gem 'rubaidh-google_analytics', :lib => 'rubaidh/google_analytics', :source => 'http://gems.github.com'
+
+and run:
+
+    rake gems:install
+
+Simple. :-)
+
+
+== Note
+
+This version of the plugin uses the new Google Analytics code (ga.js) by
+default. To use the legacy tracking code add the following line to your
+<tt>config/environment.rb</tt>:
+
+    Rubaidh::GoogleAnalytics.legacy_mode = true
+
+== Tracking outbound Links
+
+Google Analytics only tracks intra-site links by default. To create an
+outbound link that is tracked use the link_to_tracked helper:
+
+    link_to_tracked(name, track_path = "/", options = {}, html_options = {})
+
+You can use the track_path parameter to group your outbound links into logical
+folders inside of Google Analytics.
+
+The other forms of link_to are also supported:
+
+    link_to_tracked_if(condition, name, track_path = "/", options = {}, html_options = {}, &block)
+    link_to_tracked_unless(condition, name, track_path = "/", options = {}, html_options = {}, &block)
+    link_to_tracked_unless_current(name, track_path = "/", options = {}, html_options = {}, &block)
+
+To track outbound links, you should set
+
+    Rubaidh::GoogleAnalytics.defer_load = false
+
+This will move the tracking javascript to the top of your page.
+(see http://www.google.com/support/googleanalytics/bin/answer.py?answer=55527&topic=11006)
+
+Tracked links respect the legacy_mode flag.
+
+Note: Link-tracking works by inserting onclick() code in the HTML. Because of
+this, it will overwrite any onclick that you insert in the html_options hash.
+
+== Using local copies of the Analytics Javascript files
+
+Under certain circumstances you might find it valuable to serve a copy of the
+Analytics JavaScript directly from your server to your visitors, and not
+directly from Google. If your visitors are geograhically very far from Google,
+or if they have low quality international bandwidth, the loading time for the
+Analytics JS might kill the user experience and force you to remove the
+valuable tracking code from your site.
+
+This plugin now supports local copies of the legacy and new Analytics
+JavaScript files, updated via a rake task and served courtesy of the Rails
+AssetTagHelper methods. So even if you use asset hosts, the JS will be served
+from the correct source and under the correct protocol (HTTP/HTTPS).
+
+To enable cached copies and the following to your initialization code:
+
+    Rubaidh::GoogleAnalytics.local_javascript = true
+
+Use the following rake task to update the local copy of the JavaScript file:
+
+    rake google_analytics:updates
+
+To keep the file updated you can add the following to your Capistrano
+configuration:
+
+    after "deploy:symlink", "deploy:google_analytics"
+
+    namespace :deploy do
+      desc "Update local Google Analytics files"
+      task :google_analytics, :role => :web do
+        run "cd #{current_path} && rake google_analytics:update RAILS_ENV=#{ENV['RAILS_ENV']}"
+      end
+    end
+
+The above Capistrano recipe will almost certainly need some adjustments based
+on how you run your deployments, but you should get the idea.
+
+== Overriding application-default values
+
+If you're using one Rails application to serve pages across multiple domains,
+you may wish to override the domain and tracker ID values on a
+controller-by-controller or view-by-view basis. You can do this by setting the
+override_domain_name and override_tracker_id properties. These properties are
+automatically reset after each use, so the values you set for domain_name and
+tracker_id (usually in an initializer) will apply to all other requests.
+
+    before_filter :local_analytics
+
+    def local_analytics
+      Rubaidh::GoogleAnalytics.override_domain_name  = 'foo.com'
+      Rubaidh::GoogleAnalytics.override_tracker_id  = 'UA-123456-7'
+    end
+
+See the documentation for the GoogleAnalytics class for other configuration
+options.
+
+Note: You will need to have the mocha gem installed to run the tests for this
+plugin.

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the google_analytics plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the google_analytics plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'GoogleAnalytics'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/rubaidh/google_analytics.rb

@@ -0,0 +1,233 @@
+module Rubaidh # :nodoc:
+  # This module gets mixed in to ActionController::Base
+  module GoogleAnalyticsMixin
+    # The javascript code to enable Google Analytics on the current page.
+    # Normally you won't need to call this directly; the +add_google_analytics_code+
+    # after filter will insert it for you.
+    def google_analytics_code
+      GoogleAnalytics.google_analytics_code(request.ssl?) if GoogleAnalytics.enabled?(request.format)
+    end
+    
+    # An after_filter to automatically add the analytics code.
+    # If you intend to use the link_to_tracked view helpers, you need to set Rubaidh::GoogleAnalytics.defer_load = false
+    # to load the code at the top of the page
+    # (see http://www.google.com/support/googleanalytics/bin/answer.py?answer=55527&topic=11006)
+    def add_google_analytics_code
+      if GoogleAnalytics.defer_load
+        response.body.sub! '</body>', "#{google_analytics_code}</body>" if response.body.respond_to?(:sub!)
+      else
+        response.body.sub! '<body>', "<body>#{google_analytics_code}" if response.body.respond_to?(:sub!)
+      end
+    end
+  end
+
+  class GoogleAnalyticsConfigurationError < StandardError; end
+
+  # The core functionality to connect a Rails application
+  # to a Google Analytics installation.
+  class GoogleAnalytics
+  
+    @@tracker_id = nil
+    ##
+    # :singleton-method:
+    # Specify the Google Analytics ID for this web site. This can be found
+    # as the value of +_getTracker+ if you are using the new (ga.js) tracking
+    # code, or the value of +_uacct+ if you are using the old (urchin.js)
+    # tracking code.
+    cattr_accessor :tracker_id  
+
+    @@domain_name = nil
+    ##
+    # :singleton-method:
+    # Specify a different domain name from the default. You'll want to use
+    # this if you have several subdomains that you want to combine into
+    # one report. See the Google Analytics documentation for more
+    # information.
+    cattr_accessor :domain_name
+
+    @@legacy_mode = false
+    ##
+    # :singleton-method:
+    # Specify whether the legacy Google Analytics code should be used. By
+    # default, the new Google Analytics code is used.
+    cattr_accessor :legacy_mode
+    
+    @@analytics_url = 'http://www.google-analytics.com/urchin.js'
+    ##
+    # :singleton-method:
+    # The URL that analytics information is sent to. This defaults to the
+    # standard Google Analytics URL, and you're unlikely to need to change it.
+    # This has no effect unless you're in legacy mode.
+    cattr_accessor :analytics_url
+
+    @@analytics_ssl_url = 'https://ssl.google-analytics.com/urchin.js'
+    ##
+    # :singleton-method:
+    # The URL that analytics information is sent to when using SSL. This defaults to the
+    # standard Google Analytics URL, and you're unlikely to need to change it.
+    # This has no effect unless you're in legacy mode.
+    cattr_accessor :analytics_ssl_url
+
+    @@environments = ['production']
+    ##
+    # :singleton-method:
+    # The environments in which to enable the Google Analytics code. Defaults
+    # to 'production' only. Supply an array of environment names to change this.
+    cattr_accessor :environments
+    
+    @@formats = [:html, :all]
+    ##
+    # :singleton-method:
+    # The request formats where tracking code should be added. Defaults to +[:html, :all]+. The entry for
+    # +:all+ is necessary to make Google recognize that tracking is installed on a
+    # site; it is not the same as responding to all requests. Supply an array
+    # of formats to change this.
+    cattr_accessor :formats
+
+    @@defer_load = true
+    ##
+    # :singleton-method:
+    # Set this to true (the default) if you want to load the Analytics javascript at 
+    # the bottom of page. Set this to false if you want to load the Analytics 
+    # javascript at the top of the page. The page will render faster if you set this to
+    # true, but that will break the linking functions in Rubaidh::GoogleAnalyticsViewHelper.
+    cattr_accessor :defer_load
+    
+    @@local_javascript = false
+    ##
+    # :singleton-method:
+    # Set this to true to use a local copy of the ga.js (or urchin.js) file.
+    # This gives you the added benefit of serving the JS directly from your
+    # server, which in case of a big geographical difference between your server
+    # and Google's can speed things up for your visitors. Use the 
+    # 'google_analytics:update' rake task to update the local JS copies.
+    cattr_accessor :local_javascript
+    
+    ##
+    # :singleton-method:
+    # Set this to override the initialized domain name for a single render. Useful
+    # when you're serving to multiple hosts from a single codebase. Typically you'd 
+    # set up a before filter in the appropriate controller:
+    #    before_filter :override_domain_name
+    #    def override_domain_name
+    #      Rubaidh::GoogleAnalytics.override_domain_name  = 'foo.com'
+    #   end
+    cattr_accessor :override_domain_name
+    
+    ##
+    # :singleton-method:
+    # Set this to override the initialized tracker ID for a single render. Useful
+    # when you're serving to multiple hosts from a single codebase. Typically you'd 
+    # set up a before filter in the appropriate controller:
+    #    before_filter :override_tracker_id
+    #    def override_tracker_id
+    #      Rubaidh::GoogleAnalytics.override_tracker_id  = 'UA-123456-7'
+    #   end
+    cattr_accessor :override_tracker_id
+    
+    ##
+    # :singleton-method:
+    # Set this to override the automatically generated path to the page in the
+    # Google Analytics reports for a single render. Typically you'd set this up on an 
+    # action-by-action basis:
+    #    def show
+    #      Rubaidh::GoogleAnalytics.override_trackpageview = "path_to_report"
+    #      ...
+    cattr_accessor :override_trackpageview
+    
+    # Return true if the Google Analytics system is enabled and configured
+    # correctly for the specified format
+    def self.enabled?(format)
+      raise Rubaidh::GoogleAnalyticsConfigurationError if tracker_id.blank? || analytics_url.blank?
+      environments.include?(RAILS_ENV) && formats.include?(format.to_sym)
+    end
+    
+    # Construct the javascript code to be inserted on the calling page. The +ssl+
+    # parameter can be used to force the SSL version of the code in legacy mode only.
+    def self.google_analytics_code(ssl = false)
+      return legacy_google_analytics_code(ssl) if legacy_mode
+
+      extra_code = domain_name.blank? ? nil : "pageTracker._setDomainName(\"#{domain_name}\");"
+      if !override_domain_name.blank?
+        extra_code = "pageTracker._setDomainName(\"#{override_domain_name}\");"
+        self.override_domain_name = nil
+      end
+      
+      code = if local_javascript
+        <<-HTML
+        <script src="#{LocalAssetTagHelper.new.javascript_path( 'ga.js' )}" type="text/javascript">
+        </script>
+        HTML
+      else
+        <<-HTML
+      <script type="text/javascript">
+      var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www.");
+      document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E"));
+      </script>
+        HTML
+      end
+      
+      code << <<-HTML
+      <script type="text/javascript">
+      <!--//--><![CDATA[//><!--
+      var pageTracker = _gat._getTracker('#{request_tracker_id}');
+      #{extra_code}
+      pageTracker._initData();
+      pageTracker._trackPageview(#{request_tracked_path});
+      //--><!]]>
+      </script>
+      HTML
+    end
+
+    # Construct the legacy version of the Google Analytics code. The +ssl+
+    # parameter specifies whether or not to return the SSL version of the code.
+    def self.legacy_google_analytics_code(ssl = false)
+      extra_code = domain_name.blank? ? nil : "_udn = \"#{domain_name}\";"
+      if !override_domain_name.blank?
+        extra_code = "_udn = \"#{override_domain_name}\";"
+        self.override_domain_name = nil
+      end
+
+      url = legacy_analytics_js_url(ssl)
+
+      code = <<-HTML
+      <script src="#{url}" type="text/javascript">
+      </script>
+      <script type="text/javascript">
+      _uacct = "#{request_tracker_id}";
+      #{extra_code}
+      urchinTracker(#{request_tracked_path});
+      </script>
+      HTML
+    end
+    
+    # Generate the correct URL for the legacy Analytics JS file
+    def self.legacy_analytics_js_url(ssl = false)
+      if local_javascript
+        LocalAssetTagHelper.new.javascript_path( 'urchin.js' )
+      else
+        ssl ? analytics_ssl_url : analytics_url
+      end
+    end
+
+    # Determine the tracker ID for this request
+    def self.request_tracker_id
+      use_tracker_id = override_tracker_id.blank? ? tracker_id : override_tracker_id
+      self.override_tracker_id = nil
+      use_tracker_id
+    end
+    
+    # Determine the path to report for this request
+    def self.request_tracked_path
+      use_tracked_path = override_trackpageview.blank? ? '' : "'#{override_trackpageview}'"
+      self.override_trackpageview = nil
+      use_tracked_path
+    end
+    
+  end
+
+  class LocalAssetTagHelper # :nodoc:
+    # For helping with local javascripts
+    include ActionView::Helpers::AssetTagHelper
+  end
+end

data/lib/rubaidh/view_helpers.rb

@@ -0,0 +1,67 @@
+module Rubaidh
+  # Collection of methods similar to the ones in ActionView::Helpers::UrlHelper,
+  # with the addition of outbound link tracking. See the Google Analytics help
+  # at http://www.google.com/support/googleanalytics/bin/answer.py?answer=55527
+  # for more information on outbound link tracking.
+  module GoogleAnalyticsViewHelper
+    # Creates a link tag of the given +name+ using a URL created by the set of +options+,
+    # with outbound link tracking under +track_path+ in Google Analytics. The +html_options+
+    # will accept a hash of attributes for the link tag.
+    def link_to_tracked(name, track_path = "/", options = {}, html_options = {})
+      raise AnalyticsError.new("You must set Rubaidh::GoogleAnalytics.defer_load = false to use outbound link tracking") if GoogleAnalytics.defer_load == true
+      html_options.merge!({:onclick => tracking_call(track_path)})
+      link_to name, options, html_options
+    end
+    
+    # Creates a link tag of the given +name+ using a URL created by the set of +options+
+    # if +condition+ is true, with outbound link tracking under +track_path+ in Google Analytics. 
+    # The +html_options+ will accept a hash of attributes for the link tag.
+    def link_to_tracked_if(condition, name, track_path = "/", options = {}, html_options = {}, &block)
+      raise AnalyticsError.new("You must set Rubaidh::GoogleAnalytics.defer_load = false to use outbound link tracking") if GoogleAnalytics.defer_load == true
+      html_options.merge!({:onclick => tracking_call(track_path)})
+      link_to_unless !condition, name, options, html_options, &block
+    end
+    
+    # Creates a link tag of the given +name+ using a URL created by the set of +options+
+    # unless +condition+ is true, with outbound link tracking under +track_path+ in Google Analytics. 
+    # The +html_options+ will accept a hash of attributes for the link tag.
+    def link_to_tracked_unless(condition, name, track_path = "/", options = {}, html_options = {}, &block)
+      raise AnalyticsError.new("You must set Rubaidh::GoogleAnalytics.defer_load = false to use outbound link tracking") if GoogleAnalytics.defer_load == true
+      html_options.merge!({:onclick => tracking_call(track_path)})
+      link_to_unless condition, name, options, html_options, &block
+    end
+    
+    # Creates a link tag of the given +name+ using a URL created by the set of +options+
+    # unless the current request URI is the same as the link's, with outbound link tracking 
+    # under +track_path+ in Google Analytics. If the request URI is the same as the link 
+    # URI, only the name is returned, or the block is yielded, if one exists.
+    # The +html_options+ will accept a hash of attributes for the link tag.
+    def link_to_tracked_unless_current(name, track_path = "/", options = {}, html_options = {}, &block)
+      raise AnalyticsError.new("You must set Rubaidh::GoogleAnalytics.defer_load = false to use outbound link tracking") if GoogleAnalytics.defer_load == true
+      html_options.merge!({:onclick =>tracking_call(track_path)})
+      link_to_unless current_page?(options), name, options, html_options, &block
+    end
+    
+private
+
+    def tracking_call(track_path)
+      if GoogleAnalytics.legacy_mode
+        "javascript:urchinTracker('#{track_path}');"
+      else
+        "javascript:pageTracker._trackPageview('#{track_path}');"
+      end
+    end
+    
+  end
+  
+  # Error raised by tracking methods if Rubaidh::GoogleAnalytics.defer_load is not configured
+  # properly to enable tracking.
+  class AnalyticsError < StandardError
+    attr_reader :message
+    
+    def initialize(message)
+      @message = message
+    end
+  end
+end
+

data/rails/init.rb

@@ -0,0 +1,5 @@
+require 'rubaidh/google_analytics'
+require 'rubaidh/view_helpers'
+ActionController::Base.send :include, Rubaidh::GoogleAnalyticsMixin
+ActionController::Base.send :after_filter, :add_google_analytics_code
+ActionView::Base.send :include, Rubaidh::GoogleAnalyticsViewHelper

data/test/google_analytics_test.rb

@@ -0,0 +1,119 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+require 'test/unit'
+require 'rubygems'
+require 'mocha'
+RAILS_ENV = 'test'
+
+class GoogleAnalyticsTest < Test::Unit::TestCase
+  def setup
+    @ga = Rubaidh::GoogleAnalytics.new
+    @ga.tracker_id = "the tracker id"
+  end
+  
+  def test_createable
+    assert_not_nil(@ga)
+  end
+  
+  def test_domain_name_defaults_to_nil
+    assert_nil(@ga.domain_name)
+  end
+  
+  def test_legacy_mode_defaults_to_false
+    assert_equal(false, @ga.legacy_mode)
+  end
+  
+  def test_default_analytics_url
+    assert_equal("http://www.google-analytics.com/urchin.js", @ga.analytics_url)
+  end
+  
+  def test_default_analytics_ssl_url
+    assert_equal('https://ssl.google-analytics.com/urchin.js', @ga.analytics_ssl_url)
+  end
+  
+  def test_default_environments
+    assert_equal(false, @ga.environments.include?('test'))
+    assert_equal(false, @ga.environments.include?('development'))
+    assert_equal(true, @ga.environments.include?('production'))
+  end
+  
+  def test_default_formats
+    assert_equal(false, @ga.formats.include?(:xml))
+    assert_equal(true, @ga.formats.include?(:html))
+  end
+
+  def test_defer_load_defaults_to_true
+    assert_equal(true, @ga.defer_load)
+  end
+  
+  def test_local_javascript_defaults_to_false
+    assert_equal(false, @ga.local_javascript)
+  end
+  
+  # test self.enabled
+  def test_enabled_requires_tracker_id
+    Rubaidh::GoogleAnalytics.stubs(:tracker_id).returns(nil)
+    assert_raise(Rubaidh::GoogleAnalyticsConfigurationError) { Rubaidh::GoogleAnalytics.enabled?(:html) }
+  end
+  
+  def test_enabled_requires_analytics_url
+    Rubaidh::GoogleAnalytics.stubs(:analytics_url).returns(nil)
+    assert_raise(Rubaidh::GoogleAnalyticsConfigurationError) { Rubaidh::GoogleAnalytics.enabled?(:html) }
+  end
+  
+  def test_enabled_returns_false_if_current_environment_not_enabled
+    Rubaidh::GoogleAnalytics.stubs(:environments).returns(['production'])
+    assert_equal(false, Rubaidh::GoogleAnalytics.enabled?(:html))
+  end
+  
+  def test_enabled_with_default_format
+    Rubaidh::GoogleAnalytics.stubs(:environments).returns(['test'])
+    assert_equal(true, Rubaidh::GoogleAnalytics.enabled?(:html))
+  end
+  
+  def test_enabled_with_not_included_format
+    Rubaidh::GoogleAnalytics.stubs(:environments).returns(['test'])
+    assert_equal(false, Rubaidh::GoogleAnalytics.enabled?(:xml))
+  end
+  
+  def test_enabled_with_added_format
+    Rubaidh::GoogleAnalytics.stubs(:environments).returns(['test'])
+    Rubaidh::GoogleAnalytics.stubs(:formats).returns([:xml])
+    assert_equal(true, Rubaidh::GoogleAnalytics.enabled?(:xml))
+  end
+
+  # test request_tracker_id
+  def test_request_tracker_id_without_override
+    Rubaidh::GoogleAnalytics.stubs(:tracker_id).returns("1234")
+    assert_equal("1234", Rubaidh::GoogleAnalytics.request_tracker_id)
+  end
+  
+  def test_request_tracker_id_with_override
+    Rubaidh::GoogleAnalytics.stubs(:tracker_id).returns("1234")
+    Rubaidh::GoogleAnalytics.override_tracker_id = "4567"
+    assert_equal("4567", Rubaidh::GoogleAnalytics.request_tracker_id)
+  end
+  
+  def test_request_tracker_id_resets_override
+    Rubaidh::GoogleAnalytics.override_tracker_id = "4567"
+    Rubaidh::GoogleAnalytics.stubs(:tracker_id).returns("1234")
+    foo = Rubaidh::GoogleAnalytics.request_tracker_id
+    assert_nil(Rubaidh::GoogleAnalytics.override_tracker_id)
+  end
+  
+  # test request_tracked_path
+  def test_request_tracked_path_without_override
+    assert_equal('', Rubaidh::GoogleAnalytics.request_tracked_path)
+  end
+  
+  def test_request_tracked_path_with_override
+    Rubaidh::GoogleAnalytics.override_trackpageview = "/my/path"
+    assert_equal("'/my/path'", Rubaidh::GoogleAnalytics.request_tracked_path)
+  end
+  
+  def test_request_tracked_path_resets_override
+    Rubaidh::GoogleAnalytics.override_trackpageview = "/my/path"
+    foo = Rubaidh::GoogleAnalytics.request_tracked_path
+    assert_nil(Rubaidh::GoogleAnalytics.override_trackpageview)
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+ENV['RAILS_ENV'] = 'test'
+
+require 'rubygems'
+require 'test/unit'
+require 'action_controller'
+require 'active_record'
+
+require File.expand_path(File.dirname(__FILE__) + '/../lib/rubaidh/google_analytics.rb')
+require File.expand_path(File.dirname(__FILE__) + '/../lib/rubaidh/view_helpers.rb')
+

data/test/view_helpers_test.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+include Rubaidh::GoogleAnalyticsViewHelper
+include ActionView::Helpers::UrlHelper
+include ActionView::Helpers::TagHelper
+
+class ViewHelpersTest < Test::Unit::TestCase
+  
+  def setup
+    Rubaidh::GoogleAnalytics.defer_load = false
+  end
+  
+  def test_link_to_tracked_should_return_a_tracked_link
+    assert_equal "<a href=\"http://www.example.com\" onclick=\"javascript:pageTracker._trackPageview('/sites/linked');\">Link</a>", link_to_tracked('Link', '/sites/linked', "http://www.example.com" )
+  end
+  
+  def test_link_to_tracked_with_legacy_should_return_a_tracked_link
+    Rubaidh::GoogleAnalytics.legacy_mode = true
+    assert_equal "<a href=\"http://www.example.com\" onclick=\"javascript:urchinTracker('/sites/linked');\">Link</a>", link_to_tracked('Link', '/sites/linked', "http://www.example.com" )
+  end
+  
+  def test_link_to_tracked_should_error_if_defer_load
+    Rubaidh::GoogleAnalytics.defer_load = true
+    assert_raise(Rubaidh::AnalyticsError) { link_to_tracked('Link', '/sites/linked', "http://www.example.com" ) }
+  end
+  
+  def test_link_to_tracked_if_with_true_should_return_a_tracked_link
+    assert_equal "<a href=\"http://www.example.com\" onclick=\"javascript:pageTracker._trackPageview('/sites/linked');\">Link</a>", link_to_tracked_if(true, 'Link', '/sites/linked', "http://www.example.com" )
+  end
+  
+  def test_link_to_tracked_if_with_false_should_return_unlinked_text
+    assert_equal "Link", link_to_tracked_if(false, 'Link', '/sites/linked', "http://www.example.com" )
+  end
+  
+  def test_link_to_tracked_if_should_error_if_defer_load
+    Rubaidh::GoogleAnalytics.defer_load = true
+    assert_raise(Rubaidh::AnalyticsError) { link_to_tracked_if(false, 'Link', '/sites/linked', "http://www.example.com" ) }
+  end
+  
+  def test_link_to_tracked_unless_with_false_should_return_a_tracked_link
+    assert_equal "<a href=\"http://www.example.com\" onclick=\"javascript:pageTracker._trackPageview('/sites/linked');\">Link</a>", link_to_tracked_unless(false, 'Link', '/sites/linked', "http://www.example.com" )
+  end
+  
+  def test_link_to_tracked_unless_with_true_should_return_unlinked_text
+    assert_equal "Link", link_to_tracked_unless(true, 'Link', '/sites/linked', "http://www.example.com" )
+  end
+  
+  def test_link_to_tracked_unless_should_error_if_defer_load
+    Rubaidh::GoogleAnalytics.defer_load = true
+    assert_raise(Rubaidh::AnalyticsError) { link_to_tracked_unless(false, 'Link', '/sites/linked', "http://www.example.com" ) }
+  end
+
+  def test_link_to_tracked_unless_current
+    #postponed
+  end
+  
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: rubaidh-google_analytics
+version: !ruby/object:Gem::Version 
+  version: 1.0.20081111
+platform: ruby
+authors: 
+- Graeme Mathieson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-11-11 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: actionpack
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: "By default this gem will output google analytics code forevery page automatically, if it's configured correctly.This is done by adding: Rubaidh::GoogleAnalytics.tracker_id = 'UA-12345-67'"
+email: mathie@rubaidh.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.rdoc
+- Rakefile
+- rails/init.rb
+- test/google_analytics_test.rb
+- test/test_helper.rb
+- test/view_helpers_test.rb
+- lib/rubaidh/google_analytics.rb
+- lib/rubaidh/view_helpers.rb
+- task/google_analytics.rake
+has_rdoc: true
+homepage: http://github.com/rubaidh/google_analytics/tree/master
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: "[Rails] This is a quick 'n' dirty module to easily enableGoogle Analytics support in your application."
+test_files: []
+