snowplow_ruby_duid 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 644cd8ffeb6e17e8da58f514c6fa34926853ca3a
+  data.tar.gz: 7ad6e70b709b0456f5ec0ffc68e3e33937747458
+SHA512:
+  metadata.gz: b2cd6f5d17443d916be7017483cc0ba108c2001e7bdac60fd275ee81253a93b248e77f708274efada54926498a9e85bd9333773f5475b4f8fcc38685ea8a8ff9
+  data.tar.gz: bc8683b0a2b9946fcf335f54cd0971f788dffd248896eff99d2e8696023ec2ff39466dac36d017a3c913c703b98f7736368868ad9fb6829c4816b8246ade30ae

data/.rspec

@@ -0,0 +1,5 @@
+-r rutabaga
+--order rand
+--color
+--require spec_helper
+--format doc

data/Gemfile

@@ -0,0 +1,16 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in snowplow_ruby_duid.gemspec
+gemspec
+
+group :development, :test do
+  gem 'pry-plus'
+end
+
+group :test do
+  gem 'rack'
+  gem 'rack-test'
+  gem 'rspec'
+  gem 'rutabaga'
+  gem 'timecop'
+end

data/Gemfile.lock

@@ -0,0 +1,91 @@
+PATH
+  remote: .
+  specs:
+    snowplow_ruby_duid (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    binding_of_caller (0.7.2)
+      debug_inspector (>= 0.0.1)
+    bond (0.5.1)
+    coderay (1.1.0)
+    columnize (0.9.0)
+    debug_inspector (0.0.2)
+    debugger (1.6.8)
+      columnize (>= 0.3.1)
+      debugger-linecache (~> 1.2.0)
+      debugger-ruby_core_source (~> 1.3.5)
+    debugger-linecache (1.2.0)
+    debugger-ruby_core_source (1.3.7)
+    diff-lcs (1.2.5)
+    gherkin (2.12.2)
+      multi_json (~> 1.3)
+    interception (0.5)
+    jist (1.5.1)
+      json
+    json (1.8.2)
+    method_source (0.8.2)
+    multi_json (1.10.1)
+    pry (0.10.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    pry-debugger (0.2.3)
+      debugger (~> 1.3)
+      pry (>= 0.9.10, < 0.11.0)
+    pry-doc (0.6.0)
+      pry (~> 0.9)
+      yard (~> 0.8)
+    pry-docmore (0.1.1)
+      pry
+      pry-doc
+    pry-plus (1.0.0)
+      bond
+      jist
+      pry-debugger
+      pry-doc
+      pry-docmore
+      pry-rescue
+      pry-stack_explorer
+    pry-rescue (1.4.1)
+      interception (>= 0.5)
+      pry
+    pry-stack_explorer (0.4.9.1)
+      binding_of_caller (>= 0.7)
+      pry (>= 0.9.11)
+    rack (1.6.0)
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.7)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
+    rutabaga (0.1.1)
+      turnip (>= 1.1.0, < 2.0)
+    slop (3.6.0)
+    timecop (0.7.1)
+    turnip (1.2.4)
+      gherkin (>= 2.5)
+      rspec (>= 2.14.0, < 4.0)
+    yard (0.8.7.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  pry-plus
+  rack
+  rack-test
+  rspec
+  rutabaga
+  snowplow_ruby_duid!
+  timecop

data/LICENSE.txt

@@ -0,0 +1,9 @@
+Copyright (c) 2015 Simply Business
+
+MIT License
+
+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.md

@@ -0,0 +1,35 @@
+# Snowplow Ruby Domain UserId
+
+A gem that exposes the Snowplow domain userid in Rack applications. Also allows you to set your own domain userid that will be shared with the Snowplow Javascript tracker. Related Snowplow Google Group discussion [here](https://groups.google.com/forum/#!topic/snowplow-user/GFfhW25UuN8).
+
+## Instructions
+
+Add the gem to your Gemfile
+
+```ruby
+gem 'snowplow_ruby_duid', git: 'git@github.com:simplybusiness/snowplow_ruby_duid'
+```
+
+### Rails
+
+The helper will be included in `ActionController::Base` when the gem is loaded.
+
+### Sinatra
+
+Add the following to `Sinatra::Base`
+
+```ruby
+require 'snowplow_ruby_duid'
+helpers SnowplowRubyDuid::Helper
+```
+
+### Usage
+
+A method called `snowplow_domain_userid` will be exposed in your application's context. Calling this method results in the following behaviour:
+
+- If there is already a Snowplow domain userid in the request's cookie, the value of the id will be returned.
+- Else, a Snowplow domain userid will be generated and persisted in the response's cookie. This domain userid will continue to be used by the Snowplow Javascript tracker on the client side.
+
+## Running the specs and features
+
+Use this command to run the specs and features: `bundle exec rspec`

data/lib/snowplow_ruby_duid.rb

@@ -0,0 +1,10 @@
+require 'digest/sha1'
+require 'snowplow_ruby_duid/cookie'
+require 'snowplow_ruby_duid/domain_userid'
+require 'snowplow_ruby_duid/helper'
+
+module SnowplowRubyDuid
+  KEY_PREFIX = '_sp_id'
+end
+
+ActionController::Base.send :include, SnowplowRubyDuid::Helper if defined?(ActionController)

data/lib/snowplow_ruby_duid/cookie.rb

@@ -0,0 +1,58 @@
+module SnowplowRubyDuid
+  # Responsible for generating a cookie that emulates the Snowplow cookie as closely as possible
+  # Leverages the method used by ActionDispatch::Cookies::CookieJar to determine the top-level domain
+  class Cookie
+
+    # See: https://github.com/snowplow/snowplow-javascript-tracker/blob/d3d10067127eb5c95d0054c8ae60f3bdccba619d/src/js/tracker.js#L142
+    COOKIE_PATH            = '/'
+    # See: https://github.com/snowplow/snowplow-javascript-tracker/blob/d3d10067127eb5c95d0054c8ae60f3bdccba619d/src/js/tracker.js#L156
+    COOKIE_DURATION_MONTHS = 24
+    # See: https://github.com/rails/rails/blob/b1124a2ac88778c0feb0157ac09367cbd204bf01/actionpack/lib/action_dispatch/middleware/cookies.rb#L214
+    DOMAIN_REGEXP          = /[^.]*\.([^.]*|..\...|...\...)$/
+
+    def initialize host, domain_userid, request_created_at
+      @host               = host
+      @domain_userid      = domain_userid
+      @request_created_at = request_created_at
+    end
+
+    # See: https://github.com/snowplow/snowplow-javascript-tracker/blob/d3d10067127eb5c95d0054c8ae60f3bdccba619d/src/js/tracker.js#L358-L360
+    # See: https://github.com/snowplow/snowplow-javascript-tracker/blob/d3d10067127eb5c95d0054c8ae60f3bdccba619d/src/js/tracker.js#L372-L374
+    def key
+      domain = top_level_domain || @host
+      KEY_PREFIX + '.' + (Digest::SHA1.hexdigest (domain + COOKIE_PATH))[0..3]
+    end
+
+    def value
+      cookie_domain = ".#{top_level_domain}" unless top_level_domain.nil?
+      {
+        value:   cookie_value,
+        expires: cookie_expiration,
+        domain:  cookie_domain,
+        path:    COOKIE_PATH,
+      }
+    end
+
+    private
+
+    # See: https://github.com/rails/rails/blob/b1124a2ac88778c0feb0157ac09367cbd204bf01/actionpack/lib/action_dispatch/middleware/cookies.rb#L286-L294
+    def top_level_domain
+      if (@host !~ /^[\d.]+$/) && (@host =~ DOMAIN_REGEXP)
+        $&
+      end
+    end
+
+    # See: https://github.com/snowplow/snowplow-javascript-tracker/blob/d3d10067127eb5c95d0054c8ae60f3bdccba619d/src/js/tracker.js#L476-L487
+    def cookie_value
+      visitCount  = '0'
+      lastVisitTs = ''
+      createTs = nowTs = @request_created_at.to_i.to_s
+      [@domain_userid, createTs, visitCount, nowTs, lastVisitTs].join '.'
+    end
+
+    def cookie_expiration
+      expiration_date = @request_created_at.to_datetime >> COOKIE_DURATION_MONTHS
+      expiration_date.to_time
+    end
+  end
+end

data/lib/snowplow_ruby_duid/domain_userid.rb

@@ -0,0 +1,23 @@
+module SnowplowRubyDuid
+  # Generates a pseudo-unique ID to fingerprint the user
+  # Deviates from this Snowplow Javascript: https://github.com/snowplow/snowplow-javascript-tracker/blob/d3d10067127eb5c95d0054c8ae60f3bdccba619d/src/js/tracker.js#L468-L472
+  #   in order to provide a more unique identifier
+  class DomainUserid
+
+    LENGTH_OF_DUID_IN_BYTES = 8
+
+    def initialize
+      @domain_user_id = domain_user_id
+    end
+
+    def to_s
+      @domain_user_id
+    end
+
+    private
+
+    def domain_user_id
+      SecureRandom.hex LENGTH_OF_DUID_IN_BYTES
+    end
+  end
+end

data/lib/snowplow_ruby_duid/helper.rb

@@ -0,0 +1,39 @@
+module SnowplowRubyDuid
+  # Exposes a snowplow_domain_userid method in the context
+  # that will find or create a domain_userid, which will be
+  # saved in the response's cookie if it does not exist
+  module Helper
+
+    def snowplow_domain_userid
+      @snowplow_domain_userid ||= find_or_create_snowplow_domain_userid
+    end
+
+    def find_or_create_snowplow_domain_userid
+      find_snowplow_domain_userid || create_snowplow_domain_userid
+    end
+    private :find_or_create_snowplow_domain_userid
+
+    def create_snowplow_domain_userid
+      request_created_at = Time.now
+      domain_userid      = DomainUserid.new.to_s
+      snowplow_cookie    = Cookie.new request.host, domain_userid, request_created_at
+
+      response.set_cookie snowplow_cookie.key, snowplow_cookie.value
+      domain_userid
+    end
+    private :create_snowplow_domain_userid
+
+    # See: https://github.com/snowplow/snowplow/wiki/Ruby-Tracker#310-setting-the-domain-user-id-with-set_domain_user_id
+    def find_snowplow_domain_userid
+      snowplow_cookie = find_snowplow_cookie
+      # The cookie value is in this format: domainUserId.createTs.visitCount.nowTs.lastVisitTs
+      snowplow_cookie.last.split('.').first unless snowplow_cookie.nil?
+    end
+    private :find_snowplow_domain_userid
+
+    def find_snowplow_cookie
+      request.cookies.find { |(key, value)| key =~ /^#{KEY_PREFIX}/ } # result will be an array containing: [key, value]
+    end
+    private :find_snowplow_cookie
+  end
+end

data/lib/snowplow_ruby_duid/version.rb

@@ -0,0 +1,3 @@
+module SnowplowRubyDuid
+  VERSION = '0.0.1'
+end

data/snowplow_ruby_duid.gemspec

@@ -0,0 +1,20 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'snowplow_ruby_duid/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'snowplow_ruby_duid'
+  spec.version       = SnowplowRubyDuid::VERSION
+  spec.authors       = ['Simply Business']
+  spec.email         = ['tech@simplybusiness.co.uk']
+  spec.description   = %q{A gem that exposes the Snowplow domain userid in Rack applications. Also allows you to set your own domain userid that will be shared with the Snowplow Javascript tracker.}
+  spec.summary       = %q{A gem that exposes the Snowplow domain userid in Rack applications. Also allows you to set your own domain userid that will be shared with the Snowplow Javascript tracker.}
+  spec.homepage      = 'https://github.com/simplybusiness/snowplow_ruby_duid'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+end

data/spec/lib/snowplow_ruby_duid/cookie.feature

@@ -0,0 +1,53 @@
+Feature: Creating a Snowplow cookie
+
+  Background:
+    Given the host is 'www.simplybusiness.co.uk'
+      And the domain_userid is 'domain_user_id'
+      And the time is '2015-01-22 15:26:31 +0000'
+
+  Scenario: The cookie should apply to the root path (/)
+    When I create a Snowplow cookie
+    Then the cookie has the path '/'
+
+  Scenario Outline: The cookie should apply for all domains under the top-level domain (no domain for localhost or IP addresses, however)
+    Given the host is '<host>'
+     When I create a Snowplow cookie
+     Then the cookie has the domain '<cookie domain>'
+
+    Examples:
+      | host                           | cookie domain         |
+      | localhost                      |                       |
+      | 127.0.0.1                      |                       |
+      | 192.168.2.40                   |                       |
+      | www.simplybusiness.co.uk       | .simplybusiness.co.uk |
+      | www.quote.simplybusiness.co.uk | .simplybusiness.co.uk |
+      | simplybusiness.co.uk           | .simplybusiness.co.uk |
+      | www.simplybusiness.com         | .simplybusiness.com   |
+
+  Scenario Outline: The cookie should be named using the _sp_id prefix, followed by a 4 character hash generated from the top-level domain and root path
+    Given the host is '<host>'
+     When I create a Snowplow cookie
+     Then the cookie has the name '<cookie name>'
+
+    Examples:
+      | host                           | cookie name |
+      | localhost                      | _sp_id.1fff |
+      | 127.0.0.1                      | _sp_id.dc78 |
+      | 192.168.2.40                   | _sp_id.f0ae |
+      | www.simplybusiness.co.uk       | _sp_id.8fb9 |
+      | www.quote.simplybusiness.co.uk | _sp_id.8fb9 |
+      | simplybusiness.co.uk           | _sp_id.8fb9 |
+      | www.simplybusiness.com         | _sp_id.bdbc |
+
+  Scenario: The cookie should expire after 2 years
+    When I create a Snowplow cookie
+    Then the cookie expires at '2017-01-22 15:26:31 +0000'
+
+  Scenario: The cookie's value should be in the following format: domain_userid.createTs.visitCount.nowTs.lastVisitTs
+    When I create a Snowplow cookie
+    Then the cookie value is 'domain_user_id.1421940391.0.1421940391.'
+     And the cookie value for 'domain_userid' is 'domain_user_id'
+     And the cookie value for 'createTs' is '1421940391'
+     And the cookie value for 'visitCount' is '0'
+     And the cookie value for 'nowTs' is '1421940391'
+     And the cookie value for 'lastVisitTs' is ''

data/spec/lib/snowplow_ruby_duid/cookie_spec.rb

@@ -0,0 +1,95 @@
+module SnowplowRubyDuid
+  describe Cookie do
+    before do
+      @host               = 'www.simplybusiness.co.uk'
+      @domain_userid      = 'domain_user_id'
+      @request_created_at = (DateTime.parse '2015-01-22 15:26:31 +0000').to_time
+    end
+
+    subject { described_class.new @host, @domain_userid, @request_created_at }
+
+    describe '#key' do
+
+      it 'generates the key' do
+        expect(subject.key).to eq('_sp_id.8fb9')
+      end
+    end
+
+    describe '#value' do
+
+      it 'generates a cookie' do
+        expect(subject.value).to eq(
+        {
+          domain:  '.simplybusiness.co.uk',
+          expires: (DateTime.parse '2017-01-22 15:26:31 +0000').to_time,
+          path:    '/',
+          value:   'domain_user_id.1421940391.0.1421940391.'
+        })
+      end
+    end
+
+    it 'runs the feature' do
+      feature
+    end
+
+    step 'the host is :host' do |host|
+      @host = host
+    end
+
+    step 'the domain_userid is :domain_userid' do |domain_userid|
+      @domain_userid = domain_userid
+    end
+
+    step 'the time is :time' do |time|
+      @request_created_at = (DateTime.parse time).to_time
+    end
+
+    step 'I create a Snowplow cookie' do; end
+
+    step 'the cookie has the path :path' do |path|
+      expect(subject.value[:path]).to eq(path)
+    end
+
+    step 'the cookie has the domain :domain' do |domain|
+      if domain == ''
+        expect(subject.value[:domain]).to be_nil
+      else
+        expect(subject.value[:domain]).to eq(domain)
+      end
+    end
+
+    step 'the cookie has the name :name' do |name|
+      expect(subject.key).to eq(name)
+    end
+
+    step 'the cookie expires at :time' do |time|
+      expect(subject.value[:expires].to_s).to eq(time)
+    end
+
+    step 'the cookie value is :value' do |value|
+      expect(subject.value[:value]).to eq(value)
+    end
+
+    step 'the cookie value for :field is :value' do |field, value|
+      value_index = case field
+      when 'domain_userid'
+        then 0
+      when 'createTs'
+        then 1
+      when 'visitCount'
+        then 2
+      when 'nowTs'
+        then 3
+      when 'lastVisitTs'
+        then 4
+      else
+        raise "unknown field name: #{field}"
+      end
+
+      value = nil if value == ''
+
+      values = subject.value[:value].split '.'
+      expect(values[value_index]).to eq(value)
+    end
+  end
+end

data/spec/lib/snowplow_ruby_duid/domain_userid_spec.rb

@@ -0,0 +1,11 @@
+module SnowplowRubyDuid
+  describe DomainUserid do
+    subject { described_class.new.to_s }
+
+    describe '#to_s' do
+      it 'generates the domain userid' do
+        expect(subject.length).to eq(16)
+      end
+    end
+  end
+end

data/spec/lib/snowplow_ruby_duid/helper.feature

@@ -0,0 +1,12 @@
+Feature: Helper method for accessing and saving a Snowplow domain userid
+
+  Scenario Outline: The helper will return the Snowplow domain userid from the cookie, if it is available. If it is not available, it will generate a domain userid and set it in the cookie.
+    Given I set a Snowplow domain userid of '<original domain userid in cookie>' in my cookie
+     When I request the Snowplow domain userid
+     Then I receive the Snowplow domain userid '<domain userid>'
+      And I have the Snowplow domain userid '<current domain userid in cookie>' in my cookie
+
+    Examples:
+      | original domain userid in cookie | domain userid    | current domain userid in cookie |
+      | 1111111111111111                 | 1111111111111111 | 1111111111111111                |
+      |                                  | 2222222222222222 | 2222222222222222                |

data/spec/lib/snowplow_ruby_duid/helper_spec.rb

@@ -0,0 +1,81 @@
+require 'rack'
+require 'rack/test'
+require 'timecop'
+
+module SnowplowRubyDuid
+  describe Helper do
+    include Rack::Test::Methods
+
+    describe 'snowplow_domain_userid' do
+      let(:app) { App.new }
+      before do
+        Timecop.freeze(Time.local(1990))
+      end
+      after do
+        Timecop.return
+      end
+      subject { last_response.header['Set-Cookie'] }
+
+      it 'runs the feature' do
+        feature
+      end
+
+      step 'I set a Snowplow domain userid of :domain_userid in my cookie' do |domain_userid|
+        set_cookie("_sp_id.3678=#{domain_userid}.631152000.0.631152000.631152000") unless domain_userid == ''
+      end
+
+      step 'I request the Snowplow domain userid' do
+        allow_any_instance_of(DomainUserid).to receive(:to_s).and_return('2222222222222222')
+        get '/'
+      end
+
+      step 'I receive the Snowplow domain userid :domain_userid' do |domain_userid|
+        expect(app.domain_userid).to eq(domain_userid)
+      end
+
+      step 'I have the Snowplow domain userid :domain_userid in my cookie' do |domain_userid|
+        expect(subject).to include(domain_userid)
+      end
+
+      context 'when there is an existing snowplow cookie' do
+        before do
+          set_cookie('_sp_id.3678=111111111111.631152000.0.631152000.631152000')
+        end
+
+        it 'retrieves the domain userid from the cookie' do
+          get '/'
+          expect(app.domain_userid).to eq('111111111111')
+        end
+
+        it 'does not modify the domain userid' do
+          get '/'
+          expect(subject).to include('111111111111')
+        end
+      end
+
+      context 'when there is not an existing snowplow cookie' do
+
+        it 'generates a domain userid and saves it in the response cookie' do
+          get '/'
+          expect(subject).to include(app.domain_userid)
+        end
+      end
+    end
+  end
+end
+
+class App
+  include SnowplowRubyDuid::Helper
+
+  attr_reader :request, :response, :domain_userid
+
+  def call env
+    @request  = Rack::Request.new env
+    @response = Rack::Response.new
+    request.cookies.each{|k,v| response.set_cookie k, v }
+
+    @domain_userid = snowplow_domain_userid
+
+    [response.status, response.header, response.body]
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,92 @@
+require 'time'
+require 'snowplow_ruby_duid'
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: snowplow_ruby_duid
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Simply Business
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-28 00:00:00.000000000 Z
+dependencies: []
+description: A gem that exposes the Snowplow domain userid in Rack applications. Also
+  allows you to set your own domain userid that will be shared with the Snowplow Javascript
+  tracker.
+email:
+- tech@simplybusiness.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- lib/snowplow_ruby_duid.rb
+- lib/snowplow_ruby_duid/cookie.rb
+- lib/snowplow_ruby_duid/domain_userid.rb
+- lib/snowplow_ruby_duid/helper.rb
+- lib/snowplow_ruby_duid/version.rb
+- snowplow_ruby_duid.gemspec
+- spec/lib/snowplow_ruby_duid/cookie.feature
+- spec/lib/snowplow_ruby_duid/cookie_spec.rb
+- spec/lib/snowplow_ruby_duid/domain_userid_spec.rb
+- spec/lib/snowplow_ruby_duid/helper.feature
+- spec/lib/snowplow_ruby_duid/helper_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/simplybusiness/snowplow_ruby_duid
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: A gem that exposes the Snowplow domain userid in Rack applications. Also
+  allows you to set your own domain userid that will be shared with the Snowplow Javascript
+  tracker.
+test_files:
+- spec/lib/snowplow_ruby_duid/cookie.feature
+- spec/lib/snowplow_ruby_duid/cookie_spec.rb
+- spec/lib/snowplow_ruby_duid/domain_userid_spec.rb
+- spec/lib/snowplow_ruby_duid/helper.feature
+- spec/lib/snowplow_ruby_duid/helper_spec.rb
+- spec/spec_helper.rb
+has_rdoc: