kyusik-google_analytics 1.1.5

data/CREDITS

@@ -0,0 +1,14 @@
+This plugin was initially release by Graeme Mathieson, of Rubaidh Ltd.
+However, since it appeared on github, it has benefited from the contributions
+of many, including:
+
+* Mike Gunderloy (ffmike)
+* Mark Catley (markcatley)
+* Kenneth Kalmer (kennethkalmer)
+* Daniel Morrison (danielmorrison)
+
+Thank you to all these folks for their contributions, and thank you also to
+Github for facilitating their contribution without having to wait for me to
+accept patches!
+
+If I've missed anybody out, please fork, patch and send me a pull request. :-)

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006-2008 Rubaidh Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,140 @@
+= 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. :-)
+
+
+== Google Analytics Tracking Code versions
+
+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
+
+To use new asynchronous tracking code add the following line to your
+<tt>config/environment.rb</tt>:
+
+    Rubaidh::GoogleAnalytics.asynchronous_mode = true
+
+== Tracking custom variables
+
+You can track custom variables by setting the variable using:
+
+    Rubaidh::GoogleAnalytics.set_custom_var(name, value, slot, scope)
+
+You can set more than one custom variable at a time by making repeated calls to
++set_custom_var+ with different variable names.
+
+== 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.
+
+Copyright (c) 2006-2008 Rubaidh Ltd, released under the MIT license.

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rcov/rcovtask'
+require 'rubyforge'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+task :clean => [:clobber_rdoc, :clobber_package]
+
+desc 'Test the google_analytics plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+Rcov::RcovTask.new do |t|
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.verbose = true
+  t.rcov_opts = ["-x", "^/"]
+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
+
+gem_spec = eval(File.read('google_analytics.gemspec'))
+
+Rake::GemPackageTask.new(gem_spec) do |p|
+  p.need_tar = false
+  p.need_zip = false
+end
+
+desc 'Package and upload the release to rubyforge.'
+task :release => [:clean, :package] do |t|
+  rubyforge = RubyForge.new.configure
+  rubyforge.login
+  rubyforge.add_release gem_spec.rubyforge_project, gem_spec.name, gem_spec.version.to_s, "pkg/#{gem_spec.name}-#{gem_spec.version}.gem"
+end
+
+begin
+  gem 'ci_reporter'
+  require 'ci/reporter/rake/test_unit'
+  task :bamboo => "ci:setup:testunit"
+rescue LoadError
+end
+
+task :bamboo => [ :package, :test ]

data/lib/rubaidh.rb

@@ -0,0 +1,2 @@
+module Rubaidh #:nodoc:
+end

data/lib/rubaidh/google_analytics.rb

@@ -0,0 +1,328 @@
+require 'active_support'
+require 'action_pack'
+require 'action_view'
+
+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.asynchronous_mode
+        response.body.sub! /<[bB][oO][dD][yY]>/, "<body>#{google_analytics_code}" if response.body.respond_to?(:sub!)
+      elsif GoogleAnalytics.defer_load
+        response.body.sub! /<\/[bB][oO][dD][yY]>/, "#{google_analytics_code}</body>" if response.body.respond_to?(:sub!)
+      else
+        response.body.sub! /(<[bB][oO][dD][yY][^>]*>)/, "\\1#{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
+    
+    @@custom_vars = { }
+    ##
+    # :singleton-method
+    # Specify a custom variable to include in the analytics javascript
+    # name: variable name
+    # value: variable value
+    # slot: variable slot (1,2,3,4, or 5)
+    # scope: variable scope (page => 3, sesion => 2, visitor => 1)
+    def self.set_custom_var(name, value, slot = 1, scope = 3)
+      @@custom_vars[name] = { :value => value, :slot => slot, :scope => scope }
+    end
+    
+    ##
+    # :singleton-method
+    # Clear all custom variables currently set
+    def self.clear_all_custom_vars()
+      @@custom_vars = { }
+    end
+    
+    ##
+    # :singleton-method
+    # Clear the custom variable specified
+    def self.clear_custom_var(name)
+      @@custom_vars[name].delete
+    end
+    
+    @@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
+
+    @@asynchronous_mode = false
+    ##
+    # :singleton-method:
+    # Specify whether the new Asynchronous Google Analytics code should be used.
+    # By default, the synchronous Google Analytics code is used.
+    # For more information:
+    # http://code.google.com/apis/analytics/docs/tracking/asyncTracking.html
+    cattr_accessor :asynchronous_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)
+      if asynchronous_mode
+        code = asynchronous_google_analytics_code
+      elsif legacy_mode
+        code = legacy_google_analytics_code(ssl)
+      else
+        code = synchronous_google_analytics_code
+      end
+      
+      return code
+    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
+
+    # Construct the synchronous version of the Google Analytics code.
+    def self.synchronous_google_analytics_code
+      if !override_domain_name.blank?
+        domain_code = "pageTracker._setDomainName(\"#{override_domain_name}\");"
+        self.override_domain_name = nil
+      elsif !domain_name.blank?
+        domain_code = "pageTracker._setDomainName(\"#{domain_name}\");"
+      else
+        domain_code = nil
+      end
+      
+      custom_vars = []
+      @@custom_vars.each do |name, var|
+        custom_vars << "pageTracker._setCustomVar(#{var[:slot]}, \"#{name}\", \"#{var[:value]}\", #{var[:scope]});"
+      end
+      
+      if local_javascript
+        code = <<-HTML
+        <script src="#{LocalAssetTagHelper.new.javascript_path( 'ga.js' )}" type="text/javascript">
+        </script>
+        HTML
+      else
+        code = <<-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[//><!--
+          try {
+            var pageTracker = _gat._getTracker('#{request_tracker_id}');
+            #{domain_code}
+            pageTracker._initData();
+            #{custom_vars.empty? ? nil : custom_vars.join("\n")}
+            pageTracker._trackPageview(#{request_tracked_path});
+          } catch(err) {}
+        //--><!]]>
+      </script>
+      HTML
+    end
+
+    # Construct the new asynchronous version of the Google Analytics code.
+    def self.asynchronous_google_analytics_code
+      if !override_domain_name.blank?
+        domain_code = "_gaq.push(['_setDomainName', '#{override_domain_name}']);"
+        self.override_domain_name = nil
+      elsif !domain_name.blank?
+        domain_code = "_gaq.push(['_setDomainName', '#{domain_name}']);"
+      else
+        domain_code = nil
+      end
+        
+      custom_vars = []
+      @@custom_vars.each do |name, var|
+        custom_vars << "_gaq.push(['_setCustomVar', '#{name}', '#{var[:value]}', #{var[:scope]}]);"
+      end
+
+      code = <<-HTML
+      <script type="text/javascript">
+        var _gaq = _gaq || [];
+        _gaq.push(['_setAccount', '#{request_tracker_id}']);
+        #{domain_code}
+        #{custom_vars.empty? ? nil : custom_vars.join("\n")}
+        _gaq.push(['_trackPageview(#{request_tracked_path})']);
+        (function() {
+          var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+          ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+          (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(ga);
+        })();
+      </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/tasks/google_analytics.rake

@@ -0,0 +1,62 @@
+namespace :google_analytics do
+  
+  desc "Update the local copy of the Analytics JS"
+  task :update => :environment do
+    file = Rubaidh::GoogleAnalytics.legacy_mode ? 'urchin.js' : 'ga.js'
+    File.open( File.join( RAILS_ROOT, 'public', 'javascripts', file ), 'w+' ) do |f|
+      res = Net::HTTP.get_response( 'www.google-analytics.com', '/' + file )
+      f.write( res.plain_body )
+    end
+  end
+end
+
+# Intended to extend the Net::HTTP response object
+# and adds support for decoding gzip and deflate encoded pages
+#
+# Author: Jason Stirk <http://griffin.oobleyboo.com>
+# Home: http://griffin.oobleyboo.com/projects/http_encoding_helper
+# Created: 5 September 2007
+# Last Updated: 23 November 2007
+#
+# Usage:
+#
+# require 'net/http'
+# require 'http_encoding_helper'
+# headers={'Accept-Encoding' => 'gzip, deflate' }
+# http = Net::HTTP.new('griffin.oobleyboo.com', 80)
+# http.start do |h|
+#   request = Net::HTTP::Get.new('/', headers)
+#   response = http.request(request)
+#   content=response.plain_body     # Method from our library
+#   puts "Transferred: #{response.body.length} bytes"
+#   puts "Compression: #{response['content-encoding']}"
+#   puts "Extracted: #{response.plain_body.length} bytes"  
+# end
+#	
+
+require 'net/http'
+require 'zlib'
+require 'stringio'
+
+class Net::HTTPResponse
+  # Return the uncompressed content
+  def plain_body
+    encoding=self['content-encoding']
+    content=nil
+    if encoding then
+      case encoding
+        when 'gzip'
+          i=Zlib::GzipReader.new(StringIO.new(self.body))
+          content=i.read
+        when 'deflate'
+          i=Zlib::Inflate.new
+          content=i.inflate(self.body)
+        else
+          raise "Unknown encoding - #{encoding}"
+      end
+    else
+      content=self.body
+    end
+    return content
+  end
+end

data/test/google_analytics_test.rb

@@ -0,0 +1,182 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+require 'test/unit'
+require 'rubygems'
+require 'mocha'
+RAILS_ENV = 'test'
+
+class TestMixin
+  class MockRequest
+    attr_accessor :format
+  end
+  class MockResponse
+    attr_accessor :body
+  end
+
+  include Rubaidh::GoogleAnalyticsMixin
+  attr_accessor :request, :response
+
+  def initialize
+    self.request = MockRequest.new
+    self.response = MockResponse.new
+  end
+
+  # override the mixin's method
+  def google_analytics_code
+    "Google Code"
+  end
+end
+
+
+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
+
+  # Test the before_filter method does what we expect by subsituting the body tags and inserting
+  # some google code for us automagically.
+  def test_add_google_analytics_code
+    # setup our test mixin
+    mixin = TestMixin.new
+
+    # bog standard body tag
+    Rubaidh::GoogleAnalytics.defer_load = false
+    mixin.response.body = "<body><p>some text</p></body>"
+    mixin.add_google_analytics_code
+    assert_equal mixin.response.body, '<body>Google Code<p>some text</p></body>'
+
+    Rubaidh::GoogleAnalytics.defer_load = true
+    mixin.response.body = "<body><p>some text</p></body>"
+    mixin.add_google_analytics_code
+    assert_equal mixin.response.body, '<body><p>some text</p>Google Code</body>'
+
+    # body tag upper cased (ignoring this is semantically incorrect)
+    Rubaidh::GoogleAnalytics.defer_load = false
+    mixin.response.body = "<BODY><p>some text</p></BODY>"
+    mixin.add_google_analytics_code
+    assert_equal mixin.response.body, '<BODY>Google Code<p>some text</p></BODY>'
+
+    Rubaidh::GoogleAnalytics.defer_load = true
+    mixin.response.body = "<BODY><p>some text</p></BODY>"
+    mixin.add_google_analytics_code
+    assert_equal mixin.response.body, '<BODY><p>some text</p>Google Code</body>'
+
+    # body tag has additional attributes
+    Rubaidh::GoogleAnalytics.defer_load = false
+    mixin.response.body = '<body style="background-color:red"><p>some text</p></body>'
+    mixin.add_google_analytics_code
+    assert_equal mixin.response.body, '<body style="background-color:red">Google Code<p>some text</p></body>'
+
+    Rubaidh::GoogleAnalytics.defer_load = true
+    mixin.response.body = '<body style="background-color:red"><p>some text</p></body>'
+    mixin.add_google_analytics_code
+    assert_equal mixin.response.body, '<body style="background-color:red"><p>some text</p>Google Code</body>'
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,8 @@
+ENV['RAILS_ENV'] = 'test'
+
+require 'rubygems'
+require 'test/unit'
+
+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,88 @@
+--- !ruby/object:Gem::Specification 
+name: kyusik-google_analytics
+version: !ruby/object:Gem::Version 
+  version: 1.1.5
+platform: ruby
+authors: 
+- Graeme Mathieson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-28 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: actionpack
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  type: :runtime
+  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: 
+- CREDITS
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- rails/init.rb
+- test/google_analytics_test.rb
+- test/test_helper.rb
+- test/view_helpers_test.rb
+- lib/rubaidh.rb
+- lib/rubaidh/google_analytics.rb
+- lib/rubaidh/view_helpers.rb
+- tasks/google_analytics.rake
+has_rdoc: true
+homepage: http://rubaidh.com/portfolio/open-source/google-analytics/
+licenses: []
+
+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: rubaidh
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: "[Rails] Easily enable Google Analytics support in your Rails application."
+test_files: []
+