affiliate_window_etl 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3c47d9293527c807d7c97c7c549ae5b29604a6a9
+  data.tar.gz: 07b406b3253d7b040b2c925167ac9ef5fd0c387e
+SHA512:
+  metadata.gz: 65c1afd3e2086c82ca1f383e468e5f6522fb8d3372304f441beeee7e66beed14647040301f10681bdb90c3214343098c222bfbe2036504b70adb6f6dfb663be2
+  data.tar.gz: 83334372aef519037ca82a0920bbbb1253ec0642e583b6ec150759bf8afca3a93b442032aa178a196e9d5d73454ce985e462ded16fa78d1c9b6c4f336b87c694

data/README.md

@@ -0,0 +1,109 @@
+##Affiliate Window ETL
+
+[![Build Status](https://travis-ci.org/reevoo/affiliate_window_etl.svg?branch=master)](https://travis-ci.org/reevoo/affiliate_window_etl)
+
+This gem provides an extract-transform-load process for retrieving records from
+the [Affiliate Window](http://www.affiliatewindow.com/) API and loading them
+into a Postgres database. It works incrementally, updating existing records
+rather than creating duplicates. It handles its own scheduling and determines
+which records need to be retrieved from the API based on the current state of
+the database.
+
+##How to run it
+
+You can either clone this repository and run the ETL with rake or add it as a
+dependency of another application.
+
+**To run from this repository:**
+
+1. Create the database: `createdb affiliate_window`
+2. Migrate the database: `rake db:migrate`
+3. Run the ETL: `rake run`
+
+**To run as a dependency:**
+
+```ruby
+require "affiliate_window/etl"
+etl = AffiliateWindow::ETL.new
+
+etl.migrate
+etl.run
+```
+
+By default, it will inherit config from your environment variables. If you don't
+want it do this, you can pass in a hash:
+
+```ruby
+AffiliateWindow::ETL.new(
+  "START_DATE" => "2016-01-01",
+  "END_DATE" => "2016-01-07",
+  # ...
+)
+```
+
+If you would like, you can add the gem's rake tasks to your app:
+
+```ruby
+# Rakefile
+namespace :etl do
+  spec = Gem::Specification.find_by_name "affiliate_window_etl"
+  load "#{spec.gem_dir}/lib/affiliate_window/etl/tasks.rake"
+end
+```
+
+If you are incorporating the ETL into an app that has its own migrations, it is
+recommended you copy the migrations into the container app:
+
+```ruby
+etl.migration_filenames.each do |filename|
+  # copy to db/migrate/
+end
+```
+
+##How to configure it
+
+The library tries to be [twelve-factor](https://12factor.net/) compliant and is
+configured via environment variables. When not specified, the configuration
+defaults to something suitable for development purposes. If the library is used
+as a dependency of something else, this configuration can be passed into the
+`AffiliateWindow::ETL` initializer.
+
+`ACCOUNT_ID`
+
+The id of the Affiliate Window account for which to retrieve records.
+
+`AFFILIATE_API_PASSWORD`
+
+The API token of for the Publisher Service. Can be retrieved from
+[this page](https://www.affiliatewindow.com/affiliates/accountdetails.php).
+
+`DATABASE_URL`
+
+The connection to the database may be configured with `DATABASE_URL`.
+
+e.g. `postgres://user:password@database_host:1234/my-database?pool=5&encoding=unicode`
+
+`LAST_N_DAYS`
+
+The number of days to retrieve. When the ETL runs, it will fetch this many days
+of data, prior to today. It can take a while for transactions to appear in the
+API. It is recommended this be set to 60 in production. Defaults to 7.
+
+`DEBUG_STREAM`
+
+The stream to write debug output. Defaults to `stdout`.
+
+Valid options are: `stdout`, `stderr` and `none`.
+
+## How to contribute
+
+Bug reports and pull requests are welcome on
+[GitHub](https://github.com/reevoo/affiliate_window_etl). 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).

data/lib/affiliate_window/etl.rb

@@ -0,0 +1,11 @@
+require "active_record"
+require "affiliate_window"
+
+require "affiliate_window/etl/base"
+require "affiliate_window/etl/scheduler"
+require "affiliate_window/etl/database"
+require "affiliate_window/etl/extracter"
+require "affiliate_window/etl/transformer"
+require "affiliate_window/etl/normaliser"
+require "affiliate_window/etl/loader"
+require "affiliate_window/etl/config"

data/lib/affiliate_window/etl/base.rb

@@ -0,0 +1,78 @@
+class AffiliateWindow
+  class ETL
+    attr_accessor :config
+
+    def initialize(env: ENV)
+      self.config = Config.new(env: env)
+    end
+
+    def run
+      database.connect!
+
+      scheduler.jobs.each do |job|
+        extracter.extract(job.type, job.args).each do |record|
+          transformer.transform(record).each do |transformed_record|
+            loader.load(transformed_record)
+          end
+        end
+      end
+    end
+
+    def migrate
+      database.connect!
+      ActiveRecord::Migrator.migrate(migrations_path)
+    end
+
+    def migration_filenames
+      path = File.expand_path("../../../db/migrate/*", File.dirname(__FILE__))
+      Dir[path].each
+    end
+
+    private
+
+    def scheduler
+      Scheduler.new(
+        database: database,
+        last_n_days: config.last_n_days,
+      )
+    end
+
+    def extracter
+      Extracter.new(
+        client: client,
+        output: config.output_stream,
+      )
+    end
+
+    def transformer
+      Transformer.new(normaliser: normaliser)
+    end
+
+    def loader
+      Loader.new(database: database)
+    end
+
+    def database
+      Database.new(config.database_url)
+    end
+
+    def client
+      AffiliateWindow.login(
+        account_id: config.account_id,
+        affiliate_api_password: config.affiliate_api_password,
+      )
+    end
+
+    def schema
+      Schema.new
+    end
+
+    def normaliser
+      Normaliser.new
+    end
+
+    def migrator
+      Migrator.new
+    end
+  end
+end

data/lib/affiliate_window/etl/config.rb

@@ -0,0 +1,37 @@
+class AffiliateWindow
+  class ETL
+    class Config
+      attr_accessor :env
+
+      def initialize(env:)
+        self.env = env
+      end
+
+      def database_url
+        env.fetch(
+          "DATABASE_URL",
+          "postgres://#{`whoami`.strip}@localhost:5432/affiliate_window?pool=5&encoding=unicode",
+        )
+      end
+
+      def account_id
+        env.fetch("ACCOUNT_ID", 1234)
+      end
+
+      def affiliate_api_password
+        env.fetch("AFFILIATE_API_PASSWORD", "password")
+      end
+
+      def last_n_days
+        env.fetch("LAST_N_DAYS", "7").to_i
+      end
+
+      def output_stream
+        name = env.fetch("DEBUG_STREAM", "stdout")
+        name = name.downcase.to_sym
+
+        { stdout: $stdout, stderr: $stderr, none: nil }.fetch(name)
+      end
+    end
+  end
+end

data/lib/affiliate_window/etl/database.rb

@@ -0,0 +1,89 @@
+class AffiliateWindow
+  class ETL
+    class Database
+      attr_accessor :database_url
+
+      def initialize(database_url)
+        self.database_url = database_url
+      end
+
+      def connect!
+        ActiveRecord::Base.establish_connection(database_url)
+      end
+
+      def model(record_type)
+        MODELS.fetch(record_type)
+      end
+
+      class ClickStat < ActiveRecord::Base
+        def self.identity
+          [:date, :merchant_name]
+        end
+      end
+
+      class CommissionGroup < ActiveRecord::Base
+        def self.identity
+          [:merchant_id, :commission_group_code]
+        end
+      end
+
+      class CommissionRange < ActiveRecord::Base
+        self.inheritance_column = :_disabled
+
+        def self.identity
+          [:merchant_id]
+        end
+      end
+
+      class ImpressionStat < ActiveRecord::Base
+        def self.identity
+          [:date, :merchant_name]
+        end
+      end
+
+      class Merchant < ActiveRecord::Base
+        def self.identity
+          [:id]
+        end
+      end
+
+      class MerchantSector < ActiveRecord::Base
+        def self.identity
+          [:merchant_id, :sector_id]
+        end
+      end
+
+      class Transaction < ActiveRecord::Base
+        self.inheritance_column = :_disabled
+
+        def self.identity
+          [:id]
+        end
+      end
+
+      class TransactionPart < ActiveRecord::Base
+        def self.identity
+          [:transaction_id, :commission_group_name]
+        end
+      end
+
+      class TransactionProduct < ActiveRecord::Base
+        def self.identity
+          [:id]
+        end
+      end
+
+      MODELS = {
+        click_stat: ClickStat,
+        commission_group: CommissionGroup,
+        commission_range: CommissionRange,
+        impression_stat: ImpressionStat,
+        merchant: Merchant,
+        merchant_sector: MerchantSector,
+        transaction: Transaction,
+        transaction_part: TransactionPart,
+        transaction_product: TransactionProduct,
+      }
+    end
+  end
+end

data/lib/affiliate_window/etl/extracter.rb

@@ -0,0 +1,183 @@
+class AffiliateWindow
+  class ETL
+    class Extracter # rubocop:disable Metrics/ClassLength
+      CHUNK_SIZE = 100
+
+      attr_accessor :client, :output
+
+      def initialize(client:, output: nil)
+        self.client = client
+        self.output = output
+      end
+
+      def extract(type, params = {})
+        Enumerator.new do |yielder|
+          public_send("extract_#{type}", yielder, params)
+        end
+      end
+
+      def extract_merchants(yielder, _params) # rubocop:disable Metrics/AbcSize
+        response = client.get_merchant_list
+        merchants = response.fetch(:merchant)
+        merchant_ids = merchants.map { |m| m.fetch(:i_id) }
+
+        count = 0
+        merchant_ids.each_slice(CHUNK_SIZE) do |ids|
+          response = client.get_merchant(merchant_ids: ids)
+          merchants = response.fetch(:merchant)
+
+          merchants.each do |record|
+            yielder.yield(record.merge(record_type: :merchant))
+          end
+
+          count += [CHUNK_SIZE, ids.count].min
+          write "Extracted #{count} / #{merchant_ids.count} merchants"
+        end
+
+        extract_commission_groups(yielder, merchant_ids: merchant_ids)
+      end
+
+      def extract_commission_groups(yielder, merchant_ids:)
+        merchant_ids.each.with_index do |id, index|
+          maybe_response = catch_invalid_relationship_error do
+            client.get_commission_group_list(merchant_id: id)
+          end
+
+          next unless maybe_response
+          response = maybe_response
+
+          commission_groups = [response.fetch(:commission_group)].flatten
+
+          commission_groups.each do |record|
+            yielder.yield(record.merge(
+              record_type: :commission_group,
+              merchant_id: id,
+            ))
+          end
+
+          write "Extracted commission groups for #{index + 1} / #{merchant_ids.count} merchants"
+        end
+      end
+
+      def extract_daily_transactions(yielder, date:)
+        response = client.get_transaction_list(
+          start_date: "#{date}T00:00:00",
+          end_date: "#{date}T23:59:59",
+          date_type: "transaction",
+        )
+        results = response.fetch(:results)
+        pagination = response.fetch(:pagination)
+
+        check_all_records_received!(pagination)
+
+        transactions = results.fetch(:transaction)
+        transactions.each do |record|
+          yielder.yield(record.merge(record_type: :transaction))
+        end
+
+        write "Extracted #{transactions.count} transactions for #{date}"
+
+        transaction_ids = transactions.map { |t| t.fetch(:i_id) }
+        extract_transaction_products(yielder, transaction_ids: transaction_ids)
+      end
+
+      def extract_transactions(yielder, transaction_ids:)
+        count = 0
+        transaction_ids.each_slice(CHUNK_SIZE) do |ids|
+          response = client.get_transaction(transaction_ids: ids)
+
+          transactions = response.fetch(:transaction)
+          transactions.each do |record|
+            yielder.yield(record.merge(record_type: :transaction))
+          end
+
+          count += [CHUNK_SIZE, ids.count].min
+          write "Extracted #{count} / #{transaction_ids.count} transactions"
+        end
+
+        extract_transaction_products(yielder, transaction_ids: transaction_ids)
+      end
+
+      def extract_transaction_products(yielder, transaction_ids:)
+        count = 0
+        transaction_ids.each_slice(CHUNK_SIZE) do |ids|
+          response = client.get_transaction_product(transaction_ids: ids)
+          transaction_products = [response.fetch(:transaction_product)].flatten
+
+          transaction_products.each do |record|
+            yielder.yield(record.merge(record_type: :transaction_product))
+          end
+
+          count += [CHUNK_SIZE, ids.count].min
+          write "Extracted #{transaction_products.count} products for #{count} / #{transaction_ids.count} transactions"
+        end
+      end
+
+      def extract_daily_clicks(yielder, date:)
+        response = client.get_click_stats(
+          start_date: "#{date}T00:00:00",
+          end_date: "#{date}T23:59:59",
+          date_type: "transaction",
+        )
+        results = response.fetch(:results)
+        pagination = response.fetch(:pagination)
+
+        check_all_records_received!(pagination)
+
+        click_stats = results.fetch(:click_stats)
+        click_stats.each do |record|
+          yielder.yield(record.merge(
+            record_type: :click_stat,
+            date: date,
+          ))
+        end
+
+        write "Extracted #{click_stats.count} click stats for #{date}"
+      end
+
+      def extract_daily_impressions(yielder, date:)
+        response = client.get_impression_stats(
+          start_date: "#{date}T00:00:00",
+          end_date: "#{date}T23:59:59",
+          date_type: "transaction",
+        )
+        results = response.fetch(:results)
+        pagination = response.fetch(:pagination)
+
+        check_all_records_received!(pagination)
+
+        impression_stats = results.fetch(:impression_stats)
+        impression_stats.each do |record|
+          yielder.yield(record.merge(
+            record_type: :impression_stat,
+            date: date,
+          ))
+        end
+
+        write "Extracted #{impression_stats.count} impression stats for #{date}"
+      end
+
+      def check_all_records_received!(pagination)
+        retrieved = pagination.fetch(:i_rows_returned)
+        total = pagination.fetch(:i_rows_available)
+
+        fail "Did not receive all records: #{retrieved} retrieved out of #{total}" unless total == retrieved
+      end
+
+      # If the current account is not affiliated with the merchant, the API does
+      # not let you retrieve commission groups for that merchant.
+      def catch_invalid_relationship_error(&block)
+        block.call
+      rescue AffiliateWindow::Error => e
+        raise unless e.message.match(/Invalid merchant \/ affiliate relationship/)
+        nil
+      end
+
+      def write(message)
+        return unless output
+        message_with_quota = "[quota:#{client.remaining_quota}] #{message}"
+        output.puts(message_with_quota)
+      end
+    end
+  end
+end

data/lib/affiliate_window/etl/loader.rb

@@ -0,0 +1,25 @@
+class AffiliateWindow
+  class ETL
+    class Loader
+      attr_accessor :database
+
+      def initialize(database:)
+        self.database = database
+      end
+
+      def load(attributes)
+        record_type = attributes.delete(:record_type)
+        attributes.delete_if { |_, v| v.nil? }
+
+        model = database.model(record_type)
+        identity = attributes.slice(*model.identity)
+
+        if (record = model.find_by(identity))
+          record.update!(attributes)
+        else
+          model.create!(attributes)
+        end
+      end
+    end
+  end
+end

data/lib/affiliate_window/etl/normaliser.rb

@@ -0,0 +1,22 @@
+class AffiliateWindow
+  class ETL
+    class Normaliser
+      def normalise!(record, field_name:, nested_name:, foreign_name:, id_name: :i_id, record_type: nil) # rubocop:disable Metrics/ParameterLists, Metrics/LineLength
+        record_type ||= nested_name
+
+        value = record.delete(field_name)
+        return [] unless value
+
+        elements = [value.fetch(nested_name)].flatten
+        foreign_id = record.fetch(id_name)
+
+        elements.map do |attributes|
+          attributes.merge(
+            record_type: record_type,
+            foreign_name => foreign_id,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/affiliate_window/etl/scheduler.rb

@@ -0,0 +1,67 @@
+class AffiliateWindow
+  class ETL
+    class Scheduler
+      attr_accessor :database, :last_n_days
+
+      def initialize(database:, last_n_days:)
+        self.database = database
+        self.last_n_days = last_n_days
+      end
+
+      def jobs
+        jobs = []
+
+        schedule_last_n_days(:daily_transactions, jobs)
+        schedule_last_n_days(:daily_clicks, jobs)
+        schedule_last_n_days(:daily_impressions, jobs)
+        schedule_old_pending_transactions(jobs)
+        schedule_merchants(jobs)
+
+        jobs
+      end
+
+      private
+
+      def schedule_last_n_days(type, jobs)
+        today = Date.today
+
+        (n_days_ago..today).each do |date|
+          job = Job.new(type, date: date.to_s)
+          jobs.push(job)
+        end
+      end
+
+      def schedule_old_pending_transactions(jobs)
+        model = database.model(:transaction)
+        pending = model.where(status: "pending")
+        old_pending = pending.where("transaction_date < ?", n_days_ago)
+
+        transaction_ids = old_pending.pluck(:id)
+
+        job = Job.new(:transactions, transaction_ids: transaction_ids)
+        jobs.push(job)
+      end
+
+      def schedule_merchants(jobs)
+        jobs.push(Job.new(:merchants))
+      end
+
+      def n_days_ago
+        Date.today - last_n_days + 1
+      end
+
+      class Job
+        attr_accessor :type, :args
+
+        def initialize(type, args = {})
+          self.type = type
+          self.args = args
+        end
+
+        def ==(other)
+          type == other.type && args == other.args
+        end
+      end
+    end
+  end
+end

data/lib/affiliate_window/etl/tasks.rake

@@ -0,0 +1,12 @@
+require "affiliate_window/etl"
+
+desc "Runs the extract-transform-load process"
+task :run do
+  AffiliateWindow::ETL.new.run
+end
+
+namespace :db do
+  task :migrate do
+    AffiliateWindow::ETL.new.migrate
+  end
+end

data/lib/affiliate_window/etl/transformer.rb

@@ -0,0 +1,135 @@
+class AffiliateWindow
+  class ETL
+    class Transformer # rubocop:disable Metrics/ClassLength
+      attr_accessor :normaliser
+
+      def initialize(normaliser:)
+        self.normaliser = normaliser
+      end
+
+      def transform(record)
+        record = record.dup
+        record_type = record.fetch(:record_type)
+
+        transformed_records = []
+
+        case record_type
+        when :merchant
+          normalise_commision_ranges!(record, transformed_records)
+          normalise_sectors!(record, transformed_records)
+        when :transaction
+          normalise_transaction_parts!(record, transformed_records)
+        when :transaction_product
+          normalise_transaction_products!(record, transformed_records)
+
+          # transaction_product has no other top-level attributes
+          return transformed_records
+        end
+
+        attributes = infer_field_names(record)
+        transformed_records.push(attributes)
+      end
+
+      private
+
+      def normalise_commision_ranges!(record, transformed_records)
+        commision_ranges = normaliser.normalise!(
+          record,
+          field_name: :a_commission_ranges,
+          nested_name: :commission_range,
+          foreign_name: :merchant_id,
+        )
+
+        commision_ranges.each do |commision_range|
+          attributes = infer_field_names(commision_range)
+          transformed_records.push(attributes)
+        end
+      end
+
+      def normalise_sectors!(record, transformed_records)
+        sectors = normaliser.normalise!(
+          record,
+          field_name: :a_sectors,
+          nested_name: :merchant_sector,
+          foreign_name: :merchant_id,
+        )
+
+        sectors.each do |sector|
+          attributes = infer_field_names(sector)
+          transformed_records.push(attributes)
+        end
+      end
+
+      def normalise_transaction_parts!(record, transformed_records)
+        transaction_parts = normaliser.normalise!(
+          record,
+          field_name: :a_transaction_parts,
+          nested_name: :transaction_part,
+          foreign_name: :transaction_id,
+        )
+
+        transaction_parts.each do |transaction_part|
+          attributes = infer_field_names(transaction_part)
+          transformed_records.push(attributes)
+        end
+      end
+
+      def normalise_transaction_products!(record, transformed_records)
+        transaction_products = normaliser.normalise!(
+          record,
+          field_name: :a_products,
+          nested_name: :product,
+          foreign_name: :transaction_id,
+          id_name: :i_transaction_id,
+          record_type: :transaction_product,
+        )
+
+        transaction_products.each do |transaction_product|
+          attributes = infer_field_names(transaction_product)
+          transformed_records.push(attributes)
+        end
+      end
+
+      def infer_field_names(record, prefix = nil)
+        record.keys.each.with_object({}) do |field_name, hash|
+          value = record.fetch(field_name)
+          new_name = new_field_name(field_name)
+
+          case value
+          when Hash
+            sub_record = record.fetch(field_name)
+            sub_prefix = "#{prefix}#{new_name}_"
+            sub_attributes = infer_field_names(sub_record, sub_prefix)
+
+            hash.merge!(sub_attributes)
+          when Array
+            fail arrays_unsupported_error(field_name, value)
+          else
+            new_name = "#{prefix}#{new_name}".to_sym
+            attributes = record.fetch(field_name, nil)
+
+            hash.merge!(new_name => attributes)
+          end
+        end
+      end
+
+      def new_field_name(field_name)
+        if field_name.to_s[1] == "_"
+          field_name.to_s[2..-1]
+        else
+          field_name
+        end
+      end
+
+      def arrays_unsupported_error(field_name, _array)
+        message = "Unable to transform '#{field_name}' because its value is an array.\n"
+        message += "To cope with this, normalise elements of the array into a separate table.\n"
+        message += "Then, add a foreign key from the normalised record to this one."
+
+        TypeError.new(message)
+      end
+
+      class TypeError < StandardError; end
+    end
+  end
+end

data/lib/affiliate_window/etl/version.rb

@@ -0,0 +1,5 @@
+class AffiliateWindow
+  class ETL
+    VERSION = "0.0.1"
+  end
+end

data/lib/affiliate_window_etl.rb

@@ -0,0 +1 @@
+require "affiliate_window/etl"

metadata

@@ -0,0 +1,211 @@
+--- !ruby/object:Gem::Specification
+name: affiliate_window_etl
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Reevoo Developers
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: affiliate_window
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.3'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: bundler-audit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: reevoocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.8
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.8
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+- !ruby/object:Gem::Dependency
+  name: simplecov-console
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+description: An ETL for retrieving records from the Affiliate Window APIand loading
+  them into a Postgres database.
+email: developers@reevoo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/affiliate_window/etl.rb
+- lib/affiliate_window/etl/base.rb
+- lib/affiliate_window/etl/config.rb
+- lib/affiliate_window/etl/database.rb
+- lib/affiliate_window/etl/extracter.rb
+- lib/affiliate_window/etl/loader.rb
+- lib/affiliate_window/etl/normaliser.rb
+- lib/affiliate_window/etl/scheduler.rb
+- lib/affiliate_window/etl/tasks.rake
+- lib/affiliate_window/etl/transformer.rb
+- lib/affiliate_window/etl/version.rb
+- lib/affiliate_window_etl.rb
+homepage: https://github.com/reevoo/affiliate_window_etl
+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.6.7
+signing_key: 
+specification_version: 4
+summary: Affiliate Window ETL
+test_files: []