visitor_sources 0.0.0

data/README.md

@@ -0,0 +1,11 @@
+Visitor Sources
+===============
+
+This code is not finished
+-------------------------
+
+Track where a visitor has come from and kep a record of each visit in the cookie. To get around the "last click wins" nature of Google Analytics
+
+
+# requires the use of Rack::Session::Cookie 
+

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/lib/visitor_sources/search_engine.rb

@@ -0,0 +1,59 @@
+class SearchEngine
+  SEARCH_ENGINES = {
+  "google" => "q",
+  "yahoo" => "p",
+  "msn" => "q",
+  "aol" => "query",
+  "aol" => "encquery",
+  "lycos" => "query",
+  "ask" => "q",
+  "altavista" => "q",
+  "netscape" => "query",
+  "cnn" => "query",
+  "looksmart" => "qt",
+  "about" => "terms",
+  "mamma" => "query",
+  "alltheweb" => "q",
+  "gigablast" => "q",
+  "voila" => "rdata",
+  "virgilio" => "qs",
+  "live" => "q",
+  "baidu" => "wd",
+  "alice" => "qs",
+  "yandex" => "text",
+  "najdi" => "q",
+  "aol" => "q",
+  "club-internet" => "query",
+  "mama" => "query",
+  "seznam" => "q",
+  "search" => "q",
+  "wp" => "szukaj",
+  "onet" => "qt",
+  "netsprint" => "q",
+  "google.interia" => "q",
+  "szukacz" => "q",
+  "yam" => "k",
+  "pchome" => "q",
+  "kvasir" => "searchExpr",
+  "sesam" => "q",
+  "ozu" => "q",
+  "terra" => "query",
+  "nostrum" => "query",
+  "mynet" => "q",
+  "ekolay" => "q",
+  "search.ilse" => "search_for"}
+  
+  attr_accessor :name, :search_parameter
+  
+  def self.find(domain)
+    SEARCH_ENGINES.each do |name, search_parameter|
+      if domain =~ /#{name}/
+        engine =  SearchEngine.new
+        engine.name = name
+        engine.search_parameter = search_parameter
+        return engine
+      end
+    end
+    return nil
+  end
+end

data/lib/visitor_sources/traffic_source.rb

@@ -0,0 +1,109 @@
+# To minimise amount of stored data in the cookie (limited to 4KB) a traffic source gets converted to a string with variables 
+# seperated by a pipe(|), different traffic sources are separated by commas(,)
+#
+# The string looks like the following:
+#    1|1266945604|ppc|just%20tv%20stands|google|December%20Campaign|/content
+# Broken down, this is what the variables mean
+#    1                   => encoder_version    makes it easy to change how this works in the future without loosing old data already in peoples cookies
+#    1266945604          => unix_timestamp     at which the TrafficSource was generated
+#    ppc                 => medium             how the person cameto the site (main ones are cpc, direct, organic or referal)
+#    just%20tv%20stands  => term               The search term that bought the user to the site [not required]
+#    google              => source             Where the person came from. Could be keyword such as `google` or a domain name [not required]
+#    December%20Campaign => campaign           Usually set for ppc traffic in adwords [not required]
+#    /content            => content            when a referal, this is the path from which they came from [not required]
+
+require "uri"
+class TrafficSource
+  attr_accessor :encoder_version, :unix_timestamp, :medium, :term, :source, :campaign, :content, :custom_parameter_mapping, :env
+  
+  COOKIE_LINE_PARAMETERS = ['encoder_version', 'unix_timestamp', 'medium', 'term', 'source', 'campaign', 'content']
+  STANDARD_PARAMETER_MAPPING = {:medium => :utm_medium, :term => :utm_term, :source => :utm_source, :campaign => :utm_campaign, :content => :utm_content}
+  
+  def initialize(attributes={})
+    attributes.each do |key, value|
+      self.send("#{key}=", value)
+    end
+  end
+  
+  def self.updated_rack_environment(old_env, custom_parameter_mapping = {})
+    old_env["rack.session"][:traffic_sources] ||= ''
+    traffic_sources = TrafficSources.new(old_env["rack.session"][:traffic_sources])
+    latest_source = TrafficSource.initialize_with_rack_env(old_env, custom_parameter_mapping)
+    return old_env if latest_source.to_s.nil?
+    if traffic_sources.length > 0
+      return old_env if latest_source.same_as?(traffic_sources.last)
+    end
+    traffic_sources << latest_source
+    old_env["rack.session"][:traffic_sources] = traffic_sources.to_s
+    return old_env
+  end
+  
+  def TrafficSource.initialize_with_rack_env(env, custom_parameter_mapping = {})
+    traffic_source = self.new(:env => env, :custom_parameter_mapping => custom_parameter_mapping, 
+                              :unix_timestamp => Time.now.to_i, :encoder_version => 1)
+    
+    COOKIE_LINE_PARAMETERS.last(5).each do |attribute| 
+      traffic_source.send("#{attribute}=", traffic_source.query_string_value_for(attribute.to_sym))
+    end    
+    
+    #special case for adwords auto tagging
+    traffic_source.medium = 'cpc' if traffic_source.medium.nil? && !traffic_source.env["rack.request.query_hash"]["gclid"].nil?
+    
+    if traffic_source.medium.nil?          
+      if env["HTTP_REFERER"].nil?
+        traffic_source.medium = "direct"      
+      else        
+        traffic_source.medium = "referal" unless env["HTTP_REFERER"] =~ /#{env['HTTP_HOST']}/
+      end
+    end    
+    if traffic_source.source.nil?     
+      begin 
+        uri = URI.parse(env["HTTP_REFERER"])   
+        traffic_source.source = uri.host
+        search_engine = SearchEngine.find(traffic_source.source)
+        if search_engine    
+          traffic_source.source = search_engine.name
+          traffic_source.term = Rack::Utils.parse_query(uri.query)[search_engine.search_parameter] if traffic_source.term.nil?
+          traffic_source.medium = "organic" unless traffic_source.medium == 'cpc'
+        end
+        traffic_source.content = uri.path if traffic_source.content.nil? && !search_engine
+      rescue; end
+    end
+    return traffic_source
+  end
+  
+  def TrafficSource.initialize_from_string(string)
+    string_attributes = string.split("|")
+    traffic_source = TrafficSource.new(:encoder_version => string_attributes[0].to_i, :unix_timestamp => string_attributes[1].to_i)
+    COOKIE_LINE_PARAMETERS.last(5).each_with_index do |attribute, index|
+      traffic_source.send("#{attribute}=", string_attributes[index+2])
+    end
+    return traffic_source
+  end
+  
+  def to_s
+    return nil if medium.nil?
+    # join each element by pipes(|), remove any unnecessary  unused pipes from the end
+    COOKIE_LINE_PARAMETERS.collect{|param| self.send(param)}.join("|").gsub(/\|+$/, '')
+  end
+
+  def query_string_value_for(attribute)    
+    if custom_parameter_mapping[attribute] && !env["rack.request.query_hash"][custom_parameter_mapping[attribute].to_s].nil?
+      return env["rack.request.query_hash"][custom_parameter_mapping[attribute].to_s]      
+    end    
+    if env["rack.request.query_hash"][STANDARD_PARAMETER_MAPPING[attribute].to_s]
+      return env["rack.request.query_hash"][STANDARD_PARAMETER_MAPPING[attribute].to_s]
+    end 
+  end
+  
+  def same_as?(traffic_source)
+    COOKIE_LINE_PARAMETERS.last(5).each do |attribute|
+      return false if self.send(attribute).to_s != traffic_source.send(attribute).to_s
+    end
+    return true
+  end
+  
+  def date
+    Time.at(unix_timestamp)
+  end
+end

data/lib/visitor_sources/traffic_source_middleware.rb

@@ -0,0 +1,16 @@
+class TrafficSourceMiddleware
+  def initialize(app, options={})
+    @app = app
+    @options = options
+  end
+    
+  def call(env)
+    @options[:custom_parameter_mapping] ||= {}        
+    env["rack.request.query_hash"] = Rack::Utils.parse_query(env["QUERY_STRING"]) 
+    env = TrafficSource.updated_rack_environment(env, @options[:custom_parameter_mapping])
+    env[:traffic_sources] = TrafficSources.new(env["rack.session"][:traffic_sources])        
+    @status, @headers, @response = @app.call(env)    
+    [@status, @headers, @response]
+  end
+
+end

data/lib/visitor_sources/traffic_sources.rb

@@ -0,0 +1,13 @@
+class TrafficSources < Array
+  
+  def initialize(string)    
+    traffic_source_strings = string.split(",")
+    traffic_source_strings.each do |string|
+      self << TrafficSource.initialize_from_string(string)
+    end
+  end
+  
+  def to_s
+    each.collect(&:to_s).join(",")
+  end
+end

data/lib/visitor_sources.rb

@@ -0,0 +1,4 @@
+require File.expand_path(File.dirname(__FILE__) + '/visitor_sources/search_engine')
+require File.expand_path(File.dirname(__FILE__) + '/visitor_sources/traffic_source')
+require File.expand_path(File.dirname(__FILE__) + '/visitor_sources/traffic_sources')
+require File.expand_path(File.dirname(__FILE__) + '/visitor_sources/traffic_source_middleware')

data/test/app.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'sinatra'
+require File.expand_path(File.dirname(__FILE__) + '/../lib/visitor_sources')
+
+use Rack::Session::Cookie
+use TrafficSourceMiddleware, :custom_parameter_mapping => {:campaign => :campaign}
+
+
+
+get "/" do 
+  request.env[:traffic_sources].to_s
+end
+

data/test/search_engine_test.rb

@@ -0,0 +1,18 @@
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
+                    
+class SearchEngineTest < Test::Unit::TestCase
+  context "SearchEngineTest" do
+    context "find" do
+      should "return a search engine if one matches" do
+        engine = SearchEngine.find("www.google.com")
+        assert_equal "google", engine.name
+        assert_equal "q", engine.search_parameter
+      end
+      
+      should "return nil if no engine found" do
+        engine = SearchEngine.find("www.fakeengine.com")
+        assert_nil engine
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,47 @@
+require 'rubygems'
+require 'test/unit'
+require 'rack/test'
+require 'shoulda'
+require 'base64'
+require File.expand_path(File.dirname(__FILE__) + '/app')
+
+EXAMPLE_RACK_ENV = {
+"rack.session"=>{:traffic_sources=>""}, 
+"HTTP_HOST"=>"localhost:9393", 
+"HTTP_ACCEPT"=>"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", 
+"SERVER_NAME"=>"localhost", 
+"rack.request.cookie_hash"=>{"rack.session"=>"BAh7BjoUdHJhZmZpY19zb3VyY2VzIghBQkM=\n"}, 
+"rack.url_scheme"=>"http", 
+"REQUEST_PATH"=>"/", 
+"HTTP_USER_AGENT"=>"Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.5; en-US; rv:1.9.2) Gecko/20100115 Firefox/3.6", 
+"HTTP_KEEP_ALIVE"=>"115", 
+"rack.errors"=>{}, 
+"HTTP_ACCEPT_LANGUAGE"=>"en-us,en;q=0.5", 
+"SERVER_PROTOCOL"=>"HTTP/1.1", 
+"rack.version"=>[1, 0], 
+"rack.run_once"=>false, 
+"SERVER_SOFTWARE"=>"Mongrel 1.1.5", 
+"PATH_INFO"=>"/", 
+"REMOTE_ADDR"=>"::1", 
+"rack.request.cookie_string"=>"rack.session=BAh7BjoUdHJhZmZpY19zb3VyY2VzIghBQkM%3D%0A", 
+"HTTP_REFERER"=>"http://localhost:9393/", 
+"SCRIPT_NAME"=>"", 
+"rack.multithread"=>true, 
+"HTTP_VERSION"=>"HTTP/1.1", 
+"HTTP_COOKIE"=>"rack.session=BAh7BjoUdHJhZmZpY19zb3VyY2VzIghBQkM%3D%0A", 
+"rack.request.form_vars"=>"", 
+"rack.multiprocess"=>false, 
+"REQUEST_URI"=>"/", 
+"rack.request.form_input"=>{}, 
+"rack.request.query_hash"=>{}, 
+"HTTP_ACCEPT_CHARSET"=>"ISO-8859-1,utf-8;q=0.7,*;q=0.7", 
+"SERVER_PORT"=>"9393", 
+"rack.session.options"=>{:domain=>nil, :expire_after=>nil, :path=>"/"}, 
+"REQUEST_METHOD"=>"GET", 
+"rack.request.form_hash"=>{}, 
+"rack.request.query_string"=>"", 
+"QUERY_STRING"=>"", 
+"rack.input"=>{},
+"HTTP_ACCEPT_ENCODING"=>"gzip,deflate", 
+"HTTP_CONNECTION"=>"keep-alive", 
+"GATEWAY_INTERFACE"=>"CGI/1.2"}

data/test/traffic_source_middleware_test.rb

@@ -0,0 +1,22 @@
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
+
+
+class TrafficSourceMiddlewareTest < Test::Unit::TestCase
+  include Rack::Test::Methods
+
+  def app
+    Sinatra::Application    
+  end
+
+  def test_should_display_traffic_source_line   
+    start_time = Time.now.to_i
+    get "/", params = {}, rack_env = {}
+    assert last_response.ok?
+    assert_equal "1|#{start_time}|direct", last_response.body
+    sleep 1
+    get "/", params = {:campaign => "mycampaign", :utm_medium => "cpc"}, rack_env = {}
+    assert_equal "1|#{start_time}|direct,1|#{start_time+1}|cpc|||mycampaign", last_response.body
+  end
+
+end
+

data/test/traffic_source_test.rb

@@ -0,0 +1,214 @@
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
+
+# Priority of variables set
+# custom variables configured when using the plugin take the most priority
+# if no custom variable matches, then the standard google variables take priority: 'utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content', 'utm_campaign' 
+# if no match standard google variables then try and work out the required data from referers etc
+                    
+class TrafficSourceTest < Test::Unit::TestCase
+  context "TrafficSourceTest" do
+    setup do
+      @rack_env = EXAMPLE_RACK_ENV.dup
+      @custom_variable_matches = {:campaign => :custom_campaign, :term => :custom_keywords, :medium => :custom_medium}        
+    end
+    context "initialize_with_rack_env" do     
+         
+      context "when there are custom variables in the url present" do
+        should "use the custom variables to set the correct TrafficSource" do
+          @rack_env["rack.request.query_hash"] = {"custom_campaign" => "MyCamp1", "custom_keywords" => "Product One", "gclid" => "AutoAdwordsTaggingClid"}
+          @rack_env["HTTP_REFERER"] = "http://www.google.co.uk/search"
+          traffic_source = TrafficSource.initialize_with_rack_env(@rack_env, @custom_variable_matches)
+          assert_equal "cpc", traffic_source.medium
+          assert_equal "MyCamp1", traffic_source.campaign
+          assert_equal "Product One", traffic_source.term
+          assert_equal Time.now.to_i, traffic_source.unix_timestamp
+          assert_equal "1|#{Time.now.to_i}|cpc|Product One|google|MyCamp1", traffic_source.to_s
+        end
+      
+        should "use presume organic if no gclid and from a search engine" do          
+          @rack_env["rack.request.query_hash"] = {"custom_campaign" => "MyCamp1", "custom_keywords" => "Product One"}
+          @rack_env["HTTP_REFERER"] = "http://www.google.co.uk/search"
+          traffic_source = TrafficSource.initialize_with_rack_env(@rack_env, @custom_variable_matches)
+          assert_equal "organic", traffic_source.medium
+          assert_equal "MyCamp1", traffic_source.campaign
+          assert_equal "Product One", traffic_source.term
+          assert_equal Time.now.to_i, traffic_source.unix_timestamp
+          assert_equal "1|#{Time.now.to_i}|organic|Product One|google|MyCamp1", traffic_source.to_s
+        end
+      
+        should "assign to cpc if a custom variable says thats the case" do
+          @rack_env["rack.request.query_hash"] = {"custom_campaign" => "MyCamp1", "custom_keywords" => "Product One", "custom_medium" => "cpc"}
+          @rack_env["HTTP_REFERER"] = "http://www.google.co.uk/search"
+          traffic_source = TrafficSource.initialize_with_rack_env(@rack_env, @custom_variable_matches)
+          assert_equal "cpc", traffic_source.medium
+          assert_equal "MyCamp1", traffic_source.campaign
+          assert_equal "Product One", traffic_source.term
+          assert_equal Time.now.to_i, traffic_source.unix_timestamp
+          assert_equal "1|#{Time.now.to_i}|cpc|Product One|google|MyCamp1", traffic_source.to_s
+        end
+      end
+     
+      context "when no custom or standard variables matching" do
+        context "when there is no referer" do
+          should "add create a TrafficSource instance with medium of direct" do
+            @rack_env["HTTP_REFERER"] = nil
+            traffic_source = TrafficSource.initialize_with_rack_env(@rack_env, @custom_variable_matches)
+            assert_equal "direct", traffic_source.medium
+            assert_equal Time.now.to_i, traffic_source.unix_timestamp
+            assert_equal "1|#{Time.now.to_i}|direct", traffic_source.to_s
+          end
+        end
+    
+        context "when there is a referer" do
+          context "when the referer is an interal address" do
+            should "have no medium and to_s return nil" do
+              @rack_env["HTTP_REFERER"] = "http://localhost:9393/some/path"
+              traffic_source = TrafficSource.initialize_with_rack_env(@rack_env, @custom_variable_matches)
+              assert_nil traffic_source.medium
+              assert_nil traffic_source.to_s
+            end
+          end
+      
+          context "when the referer is external" do
+            should "have a medium of referer with source and content" do
+              @rack_env["HTTP_REFERER"] = "http://matthewfawcett.co.uk/some/path"
+              traffic_source = TrafficSource.initialize_with_rack_env(@rack_env, @custom_variable_matches)
+              assert_equal "referal", traffic_source.medium
+              assert_equal "matthewfawcett.co.uk", traffic_source.source
+              assert_equal "/some/path", traffic_source.content
+              assert_equal "1|#{Time.now.to_i}|referal||matthewfawcett.co.uk||/some/path", traffic_source.to_s
+            end
+            
+            should "assign to a search engine with correct keywords if referer matches" do
+              @rack_env["HTTP_REFERER"] = "http://google.co.uk/search?q=mysearchterms"
+              traffic_source = TrafficSource.initialize_with_rack_env(@rack_env, @custom_variable_matches)
+              assert_equal "organic", traffic_source.medium
+              assert_equal "google", traffic_source.source
+              assert_equal "mysearchterms", traffic_source.term
+              assert_nil   traffic_source.content
+              assert_equal "1|#{Time.now.to_i}|organic|mysearchterms|google", traffic_source.to_s
+            end
+          end
+        end
+      end    
+      
+      context "using standard google variables" do
+        should "should assign to ppc if the variables say so" do
+          @rack_env["rack.request.query_hash"] = {"utm_campaign" => "MyCamp1", "utm_term" => "Product One", "utm_medium" => "cpc", "utm_source" => "google", "utm_term" => "Product One"}
+          @rack_env["HTTP_REFERER"] = "http://www.google.co.uk/search"
+          traffic_source = TrafficSource.initialize_with_rack_env(@rack_env, @custom_variable_matches)
+          assert_equal "cpc", traffic_source.medium
+          assert_equal "MyCamp1", traffic_source.campaign
+          assert_equal "Product One", traffic_source.term
+          assert_equal Time.now.to_i, traffic_source.unix_timestamp
+          assert_equal "1|#{Time.now.to_i}|cpc|Product One|google|MyCamp1", traffic_source.to_s
+        end
+      end
+    end
+  
+    context "query_string_value_for" do
+      setup do
+        @traffic_source = TrafficSource.new
+        @traffic_source.custom_parameter_mapping = {:campaign => :custom_campaign, :keyword => :custom_keywords, :medium => :custom_medium}        
+      end
+      
+      should "use the custom value if there is a match" do    
+        @traffic_source.env = @rack_env.merge("rack.request.query_hash" => {"custom_campaign" => "mattscustomcampaign", "utm_campaign" => "standardcampaign"})          
+        assert_equal "mattscustomcampaign", @traffic_source.query_string_value_for(:campaign)
+      end
+      
+      should "use the standard value if there is a match and no custom match" do    
+        @traffic_source.env = @rack_env.merge("rack.request.query_hash" => {"utm_campaign" => "standardcampaign"})          
+        assert_equal "standardcampaign", @traffic_source.query_string_value_for(:campaign)
+      end
+      
+      should "use the standard match if we don't even have any custom parameter mapping" do    
+        @traffic_source.custom_parameter_mapping = {}        
+        @traffic_source.env = @rack_env.merge("rack.request.query_hash" => {"custom_campaign" => "mattscustomcampaign", "utm_campaign" => "standardcampaign"})          
+        assert_equal "standardcampaign", @traffic_source.query_string_value_for(:campaign)
+      end
+      
+      should "be nil if no match" do    
+        @traffic_source.env = @rack_env.merge("rack.request.query_hash" => {})          
+        assert_nil @traffic_source.query_string_value_for(:campaign)
+      end
+      
+    end
+    
+    context "updated_rack_environment" do
+
+      should "not update the enviroment if the current TrafficSource#to_s is nil" do
+        @rack_env["HTTP_REFERER"] = "http://localhost:9393/some/path"
+        rack_env = TrafficSource.updated_rack_environment(@rack_env)
+        assert_equal "", rack_env["rack.session"][:traffic_sources]
+      end
+
+      should "not update the enviroment if the last TrafficSource#to_s is the same as the current traffic source" do
+        @rack_env["HTTP_REFERER"] = nil
+        rack_env = TrafficSource.updated_rack_environment(@rack_env)
+        assert_equal "1|#{Time.now.to_i}|direct", rack_env["rack.session"][:traffic_sources]
+
+        rack_env = TrafficSource.updated_rack_environment(@rack_env)
+        assert_equal "1|#{Time.now.to_i}|direct", rack_env["rack.session"][:traffic_sources]
+      end
+
+      should "update the traffic source if the current one is differenty from the last one" do
+        @rack_env["HTTP_REFERER"] = nil
+        rack_env = TrafficSource.updated_rack_environment(@rack_env)
+        assert_equal "1|#{Time.now.to_i}|direct", rack_env["rack.session"][:traffic_sources]
+
+        rack_env["rack.request.query_hash"] = {"utm_campaign" => "MyCamp1", "utm_term" => "Product One", "utm_medium" => "cpc", "utm_source" => "google", "utm_term" => "Product One"}
+        rack_env["HTTP_REFERER"] = "http://www.google.co.uk/search"
+        rack_env = TrafficSource.updated_rack_environment(@rack_env)
+        assert_equal "1|#{Time.now.to_i}|direct,1|#{Time.now.to_i}|cpc|Product One|google|MyCamp1", rack_env["rack.session"][:traffic_sources]      
+      end
+    end
+    
+  end
+  
+  
+  
+  context "same_as?" do
+    setup do
+      @source_1 = TrafficSource.new(:encoder_version => 1, :unix_timestamp => Time.now.to_i, :medium => 'cpc', 
+                                    :term => 'myterm', :source => 'google', :campaign => 'mycamp')
+      @source_2 = @source_1.dup
+    end
+    
+    should "be true if all the main fields are the same" do
+      assert @source_1.same_as?(@source_2)
+      @source_2.encoder_version = 2
+      @source_2.unix_timestamp = 1234
+      assert @source_1.same_as?(@source_2)
+    end
+    
+    should "be false if one of the fields are different" do
+      @source_2.medium = "direct"
+      assert !@source_1.same_as?(@source_2)
+    end
+  end
+  
+  context "initialize_from_string" do
+    should "create a new TrafficSource using the correct parameters from the string" do
+      string = "1|123456|organic|mysearchterms|google"
+      source = TrafficSource.initialize_from_string(string)
+      assert_equal 1,               source.encoder_version
+      assert_equal 123456,          source.unix_timestamp
+      assert_equal "organic",       source.medium
+      assert_equal "mysearchterms", source.term
+      assert_equal "google",        source.source
+      assert_nil    source.campaign
+      assert_nil    source.content
+    end
+  end
+  
+  context "date" do
+    should "return a date object using the timestamp" do
+      @source = TrafficSource.new(:unix_timestamp => 1267804832)
+      assert_equal Time.at(1267804832), @source.date
+    end
+  end
+  
+  
+  
+end                    

data/test/traffic_sources_test.rb

@@ -0,0 +1,18 @@
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
+
+class TrafficSourcesTest < Test::Unit::TestCase
+  context "TrafficSourcesTest" do
+    context "new" do      
+      should "allow the raw string to be used to build the array of TrafficSources" do
+        assert_equal 2, TrafficSources.new("1|#{Time.now.to_i}|direct,1|#{Time.now.to_i}|cpc|Product One|google|MyCamp1").length
+      end
+    end
+    
+    context "to_s" do
+      should "call to_s on each TrafficSource instance and join with commas" do
+        traffic_sources = TrafficSources.new("1|#{Time.now.to_i}|direct,1|#{Time.now.to_i}|cpc|Product One|google|MyCamp1")
+        assert_equal "1|#{Time.now.to_i}|direct,1|#{Time.now.to_i}|cpc|Product One|google|MyCamp1", traffic_sources.to_s
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: visitor_sources
+version: !ruby/object:Gem::Version 
+  version: 0.0.0
+platform: ruby
+authors: 
+- Matt Fawcett
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-05 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Use a cookie to record the sources that each visitor came to your site
+email: mail@matthewfawcett.co.uk
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- README.md
+- VERSION
+- lib/visitor_sources.rb
+- lib/visitor_sources/search_engine.rb
+- lib/visitor_sources/traffic_source.rb
+- lib/visitor_sources/traffic_source_middleware.rb
+- lib/visitor_sources/traffic_sources.rb
+- test/app.rb
+- test/search_engine_test.rb
+- test/test_helper.rb
+- test/traffic_source_middleware_test.rb
+- test/traffic_source_test.rb
+- test/traffic_sources_test.rb
+has_rdoc: true
+homepage: http://github.com/mattfawcett/visitor_sources
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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.3.5
+signing_key: 
+specification_version: 3
+summary: Use a cookie to record the sources that each visitor came to your site
+test_files: 
+- test/app.rb
+- test/search_engine_test.rb
+- test/test_helper.rb
+- test/traffic_source_middleware_test.rb
+- test/traffic_source_test.rb
+- test/traffic_sources_test.rb