rack-trade_tracker 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f3f85ee71138c76c5ac68fd3ff519a6829a177d2
+  data.tar.gz: 653d8f2b1e06fb5e36dc6b78f2c7bf34375bcb55
+SHA512:
+  metadata.gz: a08bb9c02b1f192e47f168ee5f8f3f6abd5e1d7e9c5ac25b155a34cc746c974813d1e34c7fe86039a2c6b43524df94239afafd1fcacfccadc018e225b0161a88
+  data.tar.gz: 0e96ef4287638b1e31e7dcea710658e1210870b3599f0152ccdf4f7b2b350b3d45009c9078fcccfbbf26d8c804c428d2fa6fc96ca8d729eb2a7c9f4ffaa8a553

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/Readme.md

@@ -0,0 +1,67 @@
+# Rack::TradeTracker
+
+The `Rack::TradeTracker` gem is for use with the Trade Tracker affiliate network.
+
+The gem provides a [Rack middleware](http://guides.rubyonrails.org/rails_on_rack.html) component to handle Trade Tracker's redirect mechanism.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rack-trade_tracker'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rack-trade_tracker
+
+## Usage
+
+Note that `domain:` and `path:` are required options and you will get an error if you don't provide these:
+- Replace `'your-domain'` with your domain name minus `www`; e.g. `clickmechanic.com`.
+- Replace `'your-path'` with the target path you have agreed with Trade Tracker; e.g. `/repair` (note the leading `/`)
+
+> The gem makes no assumptions about where and how you implement the Trade Tracker JS script.  You will need to do this yourself.
+
+### `config.ru`
+If you are running a basic Rack app, you can configure the middleware in your `config.ru` file:
+```ruby
+use Rack::TradeTracker, domain: 'your-domain', path: '/your_path'
+```
+
+### Rails
+If you are using Rails, you can configure the rack middleware in `config/application.rb`, or one of the `config/environments/<environment>.rb` files, using one of the provided helper methods:
+```Ruby
+config.middleware.use('Rack::TradeTracker', domain: 'your-domain', path: 'your-path')
+
+# or
+config.middleware.insert_before(existing_middleware, 'Rack::TradeTracker', domain: 'your-domain', path: 'your-path')
+
+# or
+config.middleware.insert_after(existing_middleware, 'Rack::TradeTracker', domain: 'your-domain', path: 'your-path')
+```
+
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ClickMechanic/rack-trade_tracker. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Rack::TradeTracker project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/ClickMechanic/rack-trade_tracker/blob/master/CODE_OF_CONDUCT.md).

data/lib/rack/trade_tracker.rb

@@ -0,0 +1,27 @@
+require_relative "trade_tracker/version"
+require_relative "trade_tracker/parameters"
+require_relative "trade_tracker/handler"
+
+module Rack
+
+  class TradeTracker
+    TRACKBACK_URL = 'http://tc.tradetracker.net'.freeze
+    
+    InitializationError = Class.new(RuntimeError)
+    
+    def initialize(app, options = {})
+      @app = app
+      raise InitializationError.new('options must include :domain') unless (@domain = options[:domain])
+      raise InitializationError.new('options must include :path') unless (@path = options[:path])
+    end
+
+    def call(env)
+      Handler.new(domain, path, app).call(env)
+    end
+
+    private
+
+    attr_reader :app, :domain, :path
+  end
+
+end

data/lib/rack/trade_tracker/cookie.rb

@@ -0,0 +1,52 @@
+module Rack
+  class TradeTracker
+
+    class Cookie
+      NAME = 'TT2_%{campaign_id}'.freeze
+      DIGEST_PARAMS = [:campaign_id, :material_id, :affiliate_id, :reference].freeze
+      VALUE_PARAMS = [:material_id, :affiliate_id, :reference].freeze
+      PATH = '/'.freeze
+
+      def initialize(domain, parameters)
+        @domain, @parameters = domain, parameters
+      end
+
+      def name
+        NAME % params_hash
+      end
+
+      def checksum
+        source = "CHK_#{DIGEST_PARAMS.map { |param| params_hash[param]  }.join('::')}"
+        Digest::MD5.hexdigest(source)
+      end
+
+      def timestamp
+        Time.now.to_i
+      end
+
+      def value
+        VALUE_PARAMS.map { |param| params_hash[param] }.tap do |attributes|
+          attributes << checksum << timestamp
+        end.join('::')
+      end
+
+      def as_hash
+        {
+            value: value,
+            domain: ".#{domain}",
+            path: PATH,
+            expires: 1.year.from_now
+        }
+      end
+
+      private
+
+      attr_reader :domain, :parameters
+
+      def params_hash
+        @_params_hash ||= parameters.to_hash
+      end
+    end
+
+  end
+end

data/lib/rack/trade_tracker/handler.rb

@@ -0,0 +1,100 @@
+require 'active_support/core_ext/integer/time'
+
+require_relative 'cookie'
+
+module Rack
+  class TradeTracker
+
+    class Handler
+      PARAMS_MAP = {campaign_id: :c,
+                    material_id: :m,
+                    affiliate_id: :a,
+                    reference: :r,
+                    redirect_url: :u}.freeze
+
+      LOGGER_REGEX = /logger/i
+
+      def initialize(domain, path, app)
+        @domain = domain
+        @path = path
+        @app = app
+      end
+
+      def call(env)
+        @env = env
+        @request = Rack::Request.new(env)
+
+        return @app.call(env) unless matches_path?
+
+        begin
+          redirect
+        rescue Parameters::MissingParametersError
+          redirect_to_root
+        end
+      end
+
+      private
+
+      attr_reader :domain, :path, :app, :env, :request, :cookie
+
+      def matches_path?
+        request.path == path
+      end
+
+      def parameters
+        @_parameters ||= Parameters.new(request.params)
+      end
+
+      def params_hash
+        @_params_hash ||= parameters.to_hash
+      end
+
+      def redirect_to_root
+        response(302, {'Location' => request.base_url} ) do
+          log("Redirecting to root as Trade Tracker parameters missing", :error)
+        end
+      end
+
+      def redirect
+        response(301, {'Location' => redirect_url} ) do |response|
+          set_cookie(response)
+          set_p3p_header(response)
+          log("Redirecting to Trade Tracker with cookie: #{URI.encode(cookie.value)}")
+        end
+      end
+
+      def redirect_url
+        url = URI(TRACKBACK_URL)
+        params = PARAMS_MAP.keys.each_with_object({}) { |param, result| result[PARAMS_MAP[param]] = params_hash[param] }
+        url.query = params.map { |k,v| "#{k}=#{URI.encode(v)}" }.join('&')
+        url.to_s
+      end
+
+      def response(status, header)
+        Rack::Response.new([], status, header).tap do |response|
+          yield response if block_given?
+        end.finish
+      end
+
+      def set_cookie(response)
+        @cookie ||= Cookie.new(domain, parameters)
+        response.set_cookie(cookie.name, cookie.as_hash)
+      end
+
+      def set_p3p_header(response)
+        response.headers['P3P'] = 'CP="ALL PUR DSP CUR ADMi DEVi CONi OUR COR IND"'
+      end
+
+      def log(message, level = :info)
+        return unless logger
+
+        logger.send(level, message) if logger.respond_to?(level)
+      end
+
+      def logger
+        @logger ||= env.find { |key, _| LOGGER_REGEX.match(key) }&.[] 1
+      end
+    end
+
+  end
+end

data/lib/rack/trade_tracker/parameters.rb

@@ -0,0 +1,40 @@
+require 'active_support/core_ext/string'
+
+require_relative 'parameters/paired'
+require_relative 'parameters/delimited'
+
+module Rack
+  class TradeTracker
+    class Parameters
+      CAMPAIGN_ID_PARAM = 'campaignID'.freeze
+      TT_PARAM = 'tt'.freeze
+      MISSING_PARAM_VALUE = ''.freeze
+      PERMITTED_PARAMS = %w(campaignID materialID affiliateID reference).freeze
+
+      MissingParametersError = Class.new(RuntimeError)
+
+
+      def initialize(params)
+        @params = params
+        if params.include?(CAMPAIGN_ID_PARAM)
+          extend Paired
+        elsif params.include?(TT_PARAM)
+          extend Delimited
+        else
+          fail MissingParametersError.new("URL must include either '#{CAMPAIGN_ID_PARAM}' or '#{TT_PARAM}' parameter")
+        end
+      end
+
+      def to_hash
+        PERMITTED_PARAMS.each_with_object({}) do |param, result|
+          key = param.underscore.to_sym
+          result[key] = send(key)
+        end.merge(redirect_url: redirect_url)
+      end
+
+      private
+
+      attr_reader :params
+    end
+  end
+end

data/lib/rack/trade_tracker/parameters/delimited.rb

@@ -0,0 +1,32 @@
+require_relative '../parameters'
+
+module Rack
+  class TradeTracker
+    class Parameters
+
+      module Delimited
+        DELIMITER = '_'.freeze
+        REDIRECT_PARAM = 'r'.freeze
+
+        def self.extended(base)
+          values = base.instance_eval do
+            param = params[TT_PARAM]
+            param.present? ? param.split(DELIMITER) : []
+          end
+
+          PERMITTED_PARAMS.each_with_index do |param, index|
+            define_method param.underscore do
+              values[index] || MISSING_PARAM_VALUE
+            end
+          end
+        end
+
+
+        def redirect_url
+          params[REDIRECT_PARAM] || MISSING_PARAM_VALUE
+        end
+      end
+
+    end
+  end
+end

data/lib/rack/trade_tracker/parameters/paired.rb

@@ -0,0 +1,23 @@
+require_relative '../parameters'
+
+module Rack
+  class TradeTracker
+    class Parameters
+
+      module Paired
+        REDIRECT_PARAM = 'redirectURL'.freeze
+
+        def self.extended(base)
+          params = base.send(:params)
+
+          (PERMITTED_PARAMS.dup << REDIRECT_PARAM).each do |param|
+            define_method param.underscore do
+              params[param] || MISSING_PARAM_VALUE
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/rack/trade_tracker/version.rb

@@ -0,0 +1,5 @@
+module Rack
+  class TradeTracker
+    VERSION = "0.1.3"
+  end
+end

data/spec/rack/trade_tracker/cookie_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+RSpec.describe Rack::TradeTracker::Cookie do
+  let(:params_hash) { {campaign_id: 'ABCDEF', material_id: '123456', affiliate_id: 'ABC123', reference: 'ref'} }
+  let(:parameters) { double :parameters, params_hash.merge(to_hash: params_hash) }
+  let(:domain) { 'test.com' }
+  let(:time_now) { Time.now }
+  let(:digest) { Digest::MD5.hexdigest('CHK_ABCDEF::123456::ABC123::ref') }
+
+  before { allow(Time).to receive(:now).and_return(time_now) }
+
+  subject { Rack::TradeTracker::Cookie.new(domain,parameters) }
+
+  it 'is named after the campaign_id' do
+    expect(subject.name).to eq 'TT2_ABCDEF'
+  end
+
+  it 'generates a checksum' do
+    expect(subject.checksum).to eq digest
+  end
+
+  it 'generates a UNIX timestamp' do
+    expect(subject.timestamp).to eq time_now.to_i
+  end
+
+  describe '#value' do
+    it 'combines material_id, affiliate_id, reference, checkSum and timeStamp' do
+      expected = "123456::ABC123::ref::#{digest}::#{time_now.to_i}"
+      expect(subject.value).to eq expected
+    end
+  end
+
+  describe 'as_hash' do
+    it 'includes the value' do
+      expect(subject.as_hash[:value]).to eq subject.value
+    end
+    it 'includes the domain' do
+      expect(subject.as_hash[:domain]).to eq ".#{domain}"
+    end
+    it 'includes the path' do
+      expect(subject.as_hash[:path]).to eq '/'
+    end
+    it 'includes the expiry' do
+      expect(subject.as_hash[:expires]).to eq time_now + 1.year
+    end
+  end
+end

data/spec/rack/trade_tracker/handler_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+RSpec.describe Rack::TradeTracker::Handler do
+  let(:app) { ->(env) { [200, env, 'app'] } }
+  let(:domain) { 'test.com' }
+  let(:path) { '/path' }
+
+  subject { Rack::TradeTracker::Handler.new(domain, path, app) }
+
+  describe 'call' do
+    let(:env) { env_for(url) }
+
+    context 'with an alternate path' do
+      let(:url)  { 'http://www.example.com/some-other-path' }
+
+      it 'passes the call along' do
+        expect(app).to receive(:call).with(env)
+        subject.call(env)
+      end
+    end
+
+    context 'with a matching path' do
+      let(:url)  { URI.escape("http://www.example.com/path?#{params}") }
+      let(:cookie) { double :cookie, name: 'TT2_ABCDEF', value: '123456::ABC123::ref', as_hash: {value: '123456::ABC123::ref',
+                                                                   expires: 1.year.from_now,
+                                                                   path: '/',
+                                                                   domain: domain} }
+
+      shared_examples 'redirects with cookie' do |redirect_url|
+        attr_reader :status, :headers, :body, :trackback_url, :query
+
+        before do
+          allow(Rack::TradeTracker::Cookie).to receive(:new).and_return(cookie)
+          @status, @headers, @body = subject.call(env)
+          url = URI(headers['Location'])
+          @trackback_url = URI::HTTP.build(host: url.host).to_s
+          @query = url.query.split('&').map { |attr| attr.split('=', -1) }.to_h if url.query
+        end
+
+        it 'redirects to the trackback URL' do
+          expect(status).to eq 301
+          expect(trackback_url).to eq Rack::TradeTracker::TRACKBACK_URL
+        end
+
+        it 'includes the campaign_id parameter' do
+          expect(query['c']).to eq 'ABCDEF'
+        end
+
+        it 'includes the material_id parameter' do
+          expect(query['m']).to eq '123456'
+        end
+
+        it 'includes the affiliate_id parameter' do
+          expect(status).to eq 301
+          expect(query['a']).to eq 'ABC123'
+        end
+
+        it 'includes the redirect_url parameter' do
+          expect(status).to eq 301
+          expect(query['u']).to eq redirect_url
+        end
+
+        it 'creates the Trade Tracker cookie' do
+          cookie_value = "123456%3A%3AABC123%3A%3Aref; domain=test.com; path=/; expires=#{Rack::Utils.rfc2822(cookie.as_hash[:expires].utc)}"
+          expect(headers['set-cookie']).to eq "#{cookie.name}=#{cookie_value}"
+        end
+
+        it 'adds the P3P header' do
+          expect(headers['P3P']).to eq 'CP="ALL PUR DSP CUR ADMi DEVi CONi OUR COR IND"'
+        end
+
+        context 'with a logger defined in the rack env' do
+          let(:logger) { double :logger, info: nil }
+
+          before { env['rack.logger'] = logger }
+
+          it 'logs the redirect' do
+            subject.call(env)
+            expect(logger).to have_received(:info).with("Redirecting to Trade Tracker with cookie: #{URI.encode('123456::ABC123::ref')}")
+          end
+        end
+      end
+
+      context 'with paired parameters' do
+        include_examples 'redirects with cookie', 'www.your-proper-url.com' do
+          let(:params) { 'campaignID=ABCDEF&materialID=123456&affiliateID=ABC123&redirectURL=www.your-proper-url.com' }
+        end
+
+        context 'with missing redirect URL' do
+          include_examples 'redirects with cookie', '' do
+            let(:params) { 'campaignID=ABCDEF&materialID=123456&affiliateID=ABC123' }
+          end
+        end
+      end
+
+      context 'with delimited parameters' do
+        include_examples 'redirects with cookie', 'www.your-proper-url.com' do
+          let(:params) { 'tt=ABCDEF_123456_ABC123_ref&r=www.your-proper-url.com' }
+        end
+
+        context 'with missing redirect URL' do
+          include_examples 'redirects with cookie', '' do
+            let(:params) { 'tt=ABCDEF_123456_ABC123_ref' }
+          end
+        end
+      end
+
+      context 'with missing campaignID and tt parameters' do
+        let(:params) { '' }
+
+        it 'redirects to root with 302' do
+          status, headers, body = subject.call(env)
+          expect(status).to eq 302
+          expect(headers['Location']).to eq 'http://www.example.com'
+        end
+
+        it 'does not forward the request' do
+          expect(app).not_to receive(:call)
+          subject.call(env)
+        end
+
+        context 'with a logger defined in the rack env' do
+          let(:logger) { double :logger, error: nil }
+
+          before { env['rack.logger'] = logger }
+
+          it 'logs the redirect' do
+            subject.call(env)
+            expect(logger).to have_received(:error).with('Redirecting to root as Trade Tracker parameters missing')
+          end
+        end
+      end
+    end
+  end
+end

data/spec/rack/trade_tracker/parameters_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+RSpec.describe Rack::TradeTracker::Parameters do
+  let(:request) { double :request, params: params }
+  subject { Rack::TradeTracker::Parameters.new(request.params) }
+
+  context 'when request includes campaignID parameter' do
+    let(:params) { {'campaignID' => 'a-campaign-id',
+                    'materialID' => 'a-material-id',
+                    'affiliateID' => 'an-affiliate-id',
+                    'redirectURL' => 'www.your-proper-url.com',
+                    }}
+
+    it 'extracts the parameters correctly' do
+      params.each do |key, value|
+        expect(subject.send(key.underscore)).to eq value
+      end
+    end
+
+    it 'converts to a hash' do
+      expected = {campaign_id: subject.campaign_id,
+                  material_id: subject.material_id,
+                  affiliate_id: subject.affiliate_id,
+                  reference: subject.reference,
+                  redirect_url: subject.redirect_url}
+
+      expect(subject.to_hash).to eq expected
+    end
+
+    context 'with a missing parameter' do
+      before { params.delete('materialID') }
+      
+      it 'renders empty string for the missing parameter' do
+        expect(subject.material_id).to eq ''
+      end
+    end
+  end
+  
+  context 'when request includes tt parameter' do
+    (1..4).each do |num_params|
+      context "with #{num_params} values" do
+        let(:provided_params) { Rack::TradeTracker::Parameters::PERMITTED_PARAMS[0..(num_params - 1)] }
+        let(:params) { {'tt' => num_params.times.map(&:to_s).join('_'), 'r' => 'www.your-proper-url.com'} }
+
+        it 'extracts the parameters correctly' do
+          provided_params.each_with_index do |param, index|
+            expect(subject.send(param.underscore)).to eq index.to_s
+          end
+        end
+
+        it 'converts to a hash' do
+          expected = {campaign_id: subject.campaign_id,
+                      material_id: subject.material_id,
+                      affiliate_id: subject.affiliate_id,
+                      reference: subject.reference,
+                      redirect_url: subject.redirect_url}
+
+          expect(subject.to_hash).to eq expected
+        end
+
+        it 'extracts the redirect url' do
+          expect(subject.redirect_url).to eq 'www.your-proper-url.com'
+        end
+      end
+    end
+
+    context 'with missing tt and campaignID parameters' do
+      let(:params) { {} }
+
+      it 'fails with MissingParametersError' do
+        expect{ subject }.to raise_error Rack::TradeTracker::Parameters::MissingParametersError
+      end
+    end
+  end
+end

data/spec/rack/trade_tracker_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+RSpec.describe Rack::TradeTracker do
+  let(:app) { ->(env) { [200, env, 'app'] } }
+  let(:domain) { 'test.com' }
+  let(:path) { '/path' }
+
+  subject { Rack::TradeTracker.new(app, domain: domain, path: path) }
+  
+  it 'has a version number' do
+    expect(Rack::TradeTracker::VERSION).not_to be nil
+  end
+
+  it 'requires a domain' do
+    expect { Rack::TradeTracker.new(app, path: path) }.to raise_error(Rack::TradeTracker::InitializationError)
+  end
+
+  it 'requires a path' do
+    expect { Rack::TradeTracker.new(app, domain: domain) }.to raise_error(Rack::TradeTracker::InitializationError)
+  end
+
+  describe 'call' do
+    let(:env) { env_for(url) }
+    let(:url)  { 'http://www.example.com/path' }
+
+    it 'delegates to the Handler' do
+      handler = double(:handler)
+      allow(Rack::TradeTracker::Handler).to receive(:new).with(domain, path, app).and_return(handler)
+      expect(handler).to receive(:call).with(env)
+      subject.call(env)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+require "bundler/setup"
+require 'rack/mock'
+require "rack/trade_tracker"
+
+module Helpers
+  def env_for(url)
+    Rack::MockRequest.env_for(url)
+  end
+end
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  config.include Helpers
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: rack-trade_tracker
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+platform: ruby
+authors:
+- Ben Forrest
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-08-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: The Rack::TradeTracker gem is for use with the Trade Tracker affiliate
+  network.  The gem provides a Rack middleware component to handle Trade Tracker's
+  redirect mechanism.
+email:
+- ben@clickmechanic.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Rakefile
+- Readme.md
+- lib/rack/trade_tracker.rb
+- lib/rack/trade_tracker/cookie.rb
+- lib/rack/trade_tracker/handler.rb
+- lib/rack/trade_tracker/parameters.rb
+- lib/rack/trade_tracker/parameters/delimited.rb
+- lib/rack/trade_tracker/parameters/paired.rb
+- lib/rack/trade_tracker/version.rb
+- spec/rack/trade_tracker/cookie_spec.rb
+- spec/rack/trade_tracker/handler_spec.rb
+- spec/rack/trade_tracker/parameters_spec.rb
+- spec/rack/trade_tracker_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/ClickMechanic/rack-trade_tracker
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+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.6.12
+signing_key: 
+specification_version: 4
+summary: Provides TradeTracker redirect endpoint as Rack middleware
+test_files: []