ag 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d52f18a80b6c4e34a312724af075fb150886ff5d
+  data.tar.gz: 3f27cf30c2fc9fa720f9d9b34102b5beed1715cc
+SHA512:
+  metadata.gz: b3cd6bdc3b40ed3615ebb1061db3179af0b2168dca2a653644d067b8fd206f237f92c7371c8b8ac1dabf4adccb4ec43ca4a5d46b1b1015e38bbb691d16c1703f
+  data.tar.gz: 28c51284f992d75aaef330826abd918b759ddb3fc128f217fab327496c48b9136ef613b4861ec816fed2f64d0f6127cd99511e0c0d41875c112656693552ff32

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+gemspec
+
+gem "sequel", "~> 4.19.0"
+gem "sqlite3", "~> 1.3.10"

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 John Nunemaker
+
+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,64 @@
+# Ag
+
+WORK IN PROGRESS...
+
+Experiments in describing feeds/timelines of events in code based on adapters so things can work at most levels of throughput.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "ag"
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ag
+
+## Usage
+
+```ruby
+require "ag"
+
+adapter = Ag::Adapters::Memory.new
+client = Ag::Client.new(adapter)
+john = Ag::Object.new("User", "1")
+steve = Ag::Object.new("User", "2")
+presentation = Ag::Object.new("Presentation", "1")
+event = Ag::Event.new({
+  producer: steve,
+  object: presentation,
+  verb: "upload_presentation",
+})
+
+# connect john to steve
+pp connect: client.connect(john, steve)
+
+# is john connected to steve
+pp connected?: client.connected?(john, steve)
+
+# consumers of steve
+pp consumers: client.consumers(steve)
+
+# producers john is connected to
+pp producers: client.producers(john)
+
+# produce an event for steve
+pp produce: client.produce(event)
+
+# get the timeline of events for john based on the producers john follows
+pp timeline: client.timeline(john)
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/jnunemaker/ag/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/ag.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "ag/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "ag"
+  spec.version       = Ag::VERSION
+  spec.authors       = ["John Nunemaker"]
+  spec.email         = ["nunemaker@gmail.com"]
+  spec.summary       = %q{Producers, consumers, connections and timelines.}
+  spec.description   = %q{Producers, consumers, connections and timelines.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.5.1"
+end

data/examples/readme.rb

@@ -0,0 +1,31 @@
+require_relative "setup"
+require "ag"
+
+adapter = Ag::Adapters::Memory.new
+client = Ag::Client.new(adapter)
+john = Ag::Object.new("User", "1")
+steve = Ag::Object.new("User", "2")
+presentation = Ag::Object.new("Presentation", "1")
+event = Ag::Event.new({
+  producer: steve,
+  object: presentation,
+  verb: "upload_presentation",
+})
+
+# connect john to steve
+pp connect: client.connect(john, steve)
+
+# is john connected to steve
+pp connected?: client.connected?(john, steve)
+
+# consumers of steve
+pp consumers: client.consumers(steve)
+
+# producers john is connected to
+pp producers: client.producers(john)
+
+# produce an event for steve
+pp produce: client.produce(event)
+
+# get the timeline of events for john based on the producers john follows
+pp timeline: client.timeline(john)

data/examples/setup.rb

@@ -0,0 +1,8 @@
+# Nothing to see here... move along.
+# Sets up load path for examples and requires some stuff
+require "pp"
+require "pathname"
+
+root_path = Pathname(__FILE__).dirname.join("..").expand_path
+lib_path  = root_path.join("lib")
+$:.unshift(lib_path)

data/lib/ag.rb

@@ -0,0 +1,11 @@
+require "ag/version"
+
+module Ag
+end
+
+require "ag/object"
+require "ag/connection"
+require "ag/event"
+require "ag/feed"
+require "ag/client"
+require "ag/adapters/memory"

data/lib/ag/adapters/memory.rb

@@ -0,0 +1,62 @@
+require "securerandom"
+
+module Ag
+  module Adapters
+    class Memory
+      def initialize(source = {})
+        @source = source
+        @source[:connections] ||= []
+        @source[:events] ||= []
+      end
+
+      def connect(consumer, producer)
+        @source[:connections] << Connection.new({
+          id: SecureRandom.uuid,
+          created_at: Time.now.utc,
+          consumer: consumer,
+          producer: producer,
+        })
+      end
+
+      def produce(event)
+        result = Ag::Event.new({
+          id: SecureRandom.uuid,
+          producer: event.producer,
+          object: event.object,
+          verb: event.verb,
+        })
+        @source[:events] << result
+        result
+      end
+
+      def connected?(consumer, producer)
+        !@source[:connections].detect { |connection|
+          connection.consumer == consumer &&
+            connection.producer == producer
+        }.nil?
+      end
+
+      def consumers(producer, options = {})
+        @source[:connections].select { |connection|
+          connection.producer == producer
+        }.reverse[options.fetch(:offset, 0), options.fetch(:limit, 30)]
+      end
+
+      def producers(consumer, options = {})
+        @source[:connections].select { |connection|
+          connection.consumer == consumer
+        }.reverse[options.fetch(:offset, 0), options.fetch(:limit, 30)]
+      end
+
+      def timeline(consumer, options = {})
+        producers = producers(consumer).map(&:producer)
+
+        Array(@source[:events]).select { |event|
+          producers.include?(event.producer)
+        }.sort_by { |event|
+          -event.created_at.to_f
+        }[options.fetch(:offset, 0), options.fetch(:limit, 30)]
+      end
+    end
+  end
+end

data/lib/ag/adapters/sequel_pull.rb

@@ -0,0 +1,174 @@
+require "sequel"
+
+module Ag
+  module Adapters
+    # Adapter that uses the minimum amount of writes while still allowing full
+    # historic assembly of timelines. This comes at the cost of slower reads.
+    class SequelPull
+      def initialize(db)
+        @db = db
+      end
+
+      def connect(consumer, producer)
+        created_at = Time.now.utc
+        id = @db[:connections].insert({
+          consumer_id: consumer.id,
+          consumer_type: consumer.type,
+          producer_id: producer.id,
+          producer_type: producer.type,
+          created_at: created_at,
+        })
+
+        Connection.new({
+          id: id,
+          created_at: created_at,
+          consumer: consumer,
+          producer: producer,
+        })
+      end
+
+      def produce(event)
+        created_at = Time.now.utc
+        id = @db[:events].insert({
+          producer_type: event.producer.type,
+          producer_id: event.producer.id,
+          object_type: event.object.type,
+          object_id: event.object.id,
+          verb: event.verb,
+          created_at: created_at,
+        })
+
+        Ag::Event.new({
+          id: id,
+          created_at: created_at,
+          producer: event.producer,
+          object: event.object,
+          verb: event.verb,
+        })
+      end
+
+      def connected?(consumer, producer)
+        statement = <<-SQL
+          SELECT
+            1
+          FROM
+            connections
+          WHERE
+            consumer_id = :consumer_id AND
+            producer_id = :producer_id
+          LIMIT 1
+        SQL
+
+        binds = {
+          consumer_id: consumer.id,
+          consumer_type: consumer.type,
+          producer_id: producer.id,
+          producer_type: producer.type,
+        }
+
+        !@db[statement, binds].first.nil?
+      end
+
+      def consumers(producer, options = {})
+        statement = <<-SQL
+          SELECT
+            id, created_at, consumer_id, consumer_type, producer_id, producer_type
+          FROM
+            connections
+          WHERE
+            producer_id = :producer_id AND
+            producer_type = :producer_type
+          ORDER BY
+            id DESC
+          LIMIT :limit
+          OFFSET :offset
+        SQL
+
+        binds = {
+          producer_id: producer.id,
+          producer_type: producer.type,
+          limit: options.fetch(:limit, 30),
+          offset: options.fetch(:offset, 0),
+        }
+
+        @db[statement, binds].to_a.map { |row|
+          Connection.new({
+            id: row[:id],
+            created_at: row[:created_at],
+            consumer: Object.new(row[:consumer_type], row[:consumer_id]),
+            producer: Object.new(row[:producer_type], row[:producer_id]),
+          })
+        }
+      end
+
+      def producers(consumer, options = {})
+        statement = <<-SQL
+          SELECT
+            id, created_at, consumer_id, consumer_type, producer_id, producer_type
+          FROM
+            connections
+          WHERE
+            consumer_id = :consumer_id AND
+            consumer_type = :consumer_type
+          ORDER BY
+            id DESC
+          LIMIT :limit
+          OFFSET :offset
+        SQL
+
+        binds = {
+          consumer_id: consumer.id,
+          consumer_type: consumer.type,
+          limit: options.fetch(:limit, 30),
+          offset: options.fetch(:offset, 0),
+        }
+
+        @db[statement, binds].to_a.map { |row|
+          Connection.new({
+            id: row[:id],
+            created_at: row[:created_at],
+            consumer: Object.new(row[:consumer_type], row[:consumer_id]),
+            producer: Object.new(row[:producer_type], row[:producer_id]),
+          })
+        }
+      end
+
+      def timeline(consumer, options = {})
+        statement = <<-SQL
+          SELECT
+            e.*
+          FROM
+            events e
+          INNER JOIN
+            connections c ON
+              e.producer_id = c.producer_id AND
+              e.producer_type = c.producer_type
+          WHERE
+            c.consumer_id = :consumer_id AND
+            c.consumer_type = :consumer_type
+          ORDER BY
+            e.created_at DESC
+          LIMIT :limit
+          OFFSET :offset
+        SQL
+
+        binds = {
+          consumer_id: consumer.id,
+          consumer_type: consumer.type,
+          limit: options.fetch(:limit, 30),
+          offset: options.fetch(:offset, 0),
+        }
+
+        @db[statement, binds].to_a.map { |row|
+          Ag::Event.new({
+            id: row[:id],
+            created_at: row[:created_at],
+            producer: Ag::Object.new(row[:producer_type], row[:producer_id]),
+            object: Ag::Object.new(row[:object_type], row[:object_id]),
+            verb: row[:verb],
+          })
+        }
+      end
+    end
+  end
+end

data/lib/ag/adapters/sequel_pull_compact.rb

@@ -0,0 +1,169 @@
+require "sequel"
+
+module Ag
+  module Adapters
+    # Adapter that uses the minimum amount of writes while still allowing full
+    # historic assembly of timelines. This comes at the cost of slower reads.
+    class SequelPullCompact
+      def self.dehydrate(object)
+        [object.type, object.id].join(":")
+      end
+
+      def self.hydrate(id)
+        Ag::Object.new(*id.split(":"))
+      end
+
+      def initialize(db)
+        @db = db
+      end
+
+      def connect(consumer, producer)
+        created_at = Time.now.utc
+        id = @db[:connections].insert({
+          consumer_id: self.class.dehydrate(consumer),
+          producer_id: self.class.dehydrate(producer),
+          created_at: created_at,
+        })
+
+        Connection.new({
+          id: id,
+          created_at: created_at,
+          consumer: consumer,
+          producer: producer,
+        })
+      end
+
+      def produce(event)
+        created_at = event.created_at || Time.now.utc
+        id = @db[:events].insert({
+          producer_id: self.class.dehydrate(event.producer),
+          object_id: self.class.dehydrate(event.object),
+          verb: event.verb,
+          created_at: created_at,
+        })
+
+        Ag::Event.new({
+          id: id,
+          created_at: created_at,
+          producer: event.producer,
+          object: event.object,
+          verb: event.verb,
+        })
+      end
+
+      def connected?(consumer, producer)
+        statement = <<-SQL
+          SELECT
+            1
+          FROM
+            connections
+          WHERE
+            consumer_id = :consumer_id AND
+            producer_id = :producer_id
+          LIMIT 1
+        SQL
+
+        binds = {
+          consumer_id: self.class.dehydrate(consumer),
+          producer_id: self.class.dehydrate(producer),
+        }
+
+        !@db[statement, binds].first.nil?
+      end
+
+      def consumers(producer, options = {})
+        statement = <<-SQL
+          SELECT
+            id, created_at, consumer_id, producer_id
+          FROM
+            connections
+          WHERE
+            producer_id = :producer_id
+          ORDER BY
+            id DESC
+          LIMIT :limit
+          OFFSET :offset
+        SQL
+
+        binds = {
+          producer_id: self.class.dehydrate(producer),
+          limit: options.fetch(:limit, 30),
+          offset: options.fetch(:offset, 0),
+        }
+
+        @db[statement, binds].to_a.map { |row|
+          Connection.new({
+            id: row[:id],
+            created_at: row[:created_at],
+            consumer: self.class.hydrate(row[:consumer_id]),
+            producer: self.class.hydrate(row[:producer_id]),
+          })
+        }
+      end
+
+      def producers(consumer, options = {})
+        statement = <<-SQL
+          SELECT
+            id, created_at, consumer_id, producer_id
+          FROM
+            connections
+          WHERE
+            consumer_id = :consumer_id
+          ORDER BY
+            id DESC
+          LIMIT :limit
+          OFFSET :offset
+        SQL
+
+        binds = {
+          consumer_id: self.class.dehydrate(consumer),
+          limit: options.fetch(:limit, 30),
+          offset: options.fetch(:offset, 0),
+        }
+
+        @db[statement, binds].to_a.map { |row|
+          Connection.new({
+            id: row[:id],
+            created_at: row[:created_at],
+            consumer: self.class.hydrate(row[:consumer_id]),
+            producer: self.class.hydrate(row[:producer_id]),
+          })
+        }
+      end
+
+      def timeline(consumer, options = {})
+        statement = <<-SQL
+          SELECT
+            e.*
+          FROM
+            events e
+          INNER JOIN
+            connections c ON
+              e.producer_id = c.producer_id
+          WHERE
+            c.consumer_id = :consumer_id
+          ORDER BY
+            e.created_at DESC
+          LIMIT :limit
+          OFFSET :offset
+        SQL
+
+        binds = {
+          consumer_id: self.class.dehydrate(consumer),
+          limit: options.fetch(:limit, 30),
+          offset: options.fetch(:offset, 0),
+        }
+
+        @db[statement, binds].to_a.map { |row|
+          Ag::Event.new({
+            id: row[:id],
+            created_at: row[:created_at],
+            producer: self.class.hydrate(row[:producer_id]),
+            object: self.class.hydrate(row[:object_id]),
+            verb: row[:verb],
+          })
+        }
+      end
+    end
+  end
+end

data/lib/ag/client.rb

@@ -0,0 +1,31 @@
+module Ag
+  class Client
+    def initialize(adapter)
+      @adapter = adapter
+    end
+
+    def connect(consumer, producer)
+      @adapter.connect(consumer, producer)
+    end
+
+    def produce(event)
+      @adapter.produce(event)
+    end
+
+    def connected?(consumer, producer)
+      @adapter.connected?(consumer, producer)
+    end
+
+    def consumers(producer, options = {})
+      @adapter.consumers(producer, options)
+    end
+
+    def producers(consumer, options = {})
+      @adapter.producers(consumer, options)
+    end
+
+    def timeline(consumer, options = {})
+      @adapter.timeline(consumer, options)
+    end
+  end
+end

data/lib/ag/connection.rb

@@ -0,0 +1,17 @@
+require "forwardable"
+
+module Ag
+  class Connection
+    attr_reader :id
+    attr_reader :producer
+    attr_reader :consumer
+    attr_reader :created_at
+
+    def initialize(attributes = {})
+      @id = attributes[:id]
+      @producer = attributes[:producer]
+      @consumer = attributes[:consumer]
+      @created_at = attributes[:created_at]
+    end
+  end
+end

data/lib/ag/event.rb

@@ -0,0 +1,17 @@
+module Ag
+  class Event
+    attr_reader :id
+    attr_reader :producer
+    attr_reader :object
+    attr_reader :verb
+    attr_reader :created_at
+
+    def initialize(attrs = {})
+      @id = attrs[:id]
+      @producer = attrs.fetch(:producer)
+      @object = attrs.fetch(:object)
+      @verb = attrs.fetch(:verb)
+      @created_at = attrs.fetch(:created_at) { Time.now.utc }
+    end
+  end
+end

data/lib/ag/feed.rb

@@ -0,0 +1,4 @@
+module Ag
+  class Feed
+  end
+end

data/lib/ag/object.rb

@@ -0,0 +1,17 @@
+module Ag
+  class Object
+    attr_reader :type
+    attr_reader :id
+
+    def initialize(type, id)
+      @type = type
+      @id = id
+    end
+
+    def ==(other)
+      self.class == other.class &&
+        self.type == other.type &&
+        self.id == other.id
+    end
+  end
+end

data/lib/ag/spec/adapter.rb

@@ -0,0 +1,179 @@
+module Ag
+  module Spec
+    module Adapter
+      def test_connect
+        consumer = Ag::Object.new("User", "1")
+        producer = Ag::Object.new("User", "2")
+
+        adapter.connect(consumer, producer)
+
+        connection = connections.first
+        assert_equal consumer.id, connection.consumer.id
+        assert_equal consumer.type, connection.consumer.type
+        assert_equal producer.id, connection.producer.id
+        assert_equal producer.type, connection.producer.type
+        assert_in_delta Time.now.utc, connection.created_at, 1
+      end
+
+      def test_produce
+        producer = Ag::Object.new("User", "1")
+        object = Ag::Object.new("User", "2")
+        event = Ag::Event.new({
+          producer: producer,
+          object: object,
+          verb: "follow",
+        })
+
+        result = adapter.produce(event)
+
+        event = events.first
+        assert_equal event.id, result.id
+        assert_equal producer.id, event.producer.id
+        assert_equal producer.type, event.producer.type
+        assert_equal object.id, event.object.id
+        assert_equal object.type, event.object.type
+        assert_in_delta Time.now.utc, event.created_at, 1
+      end
+
+      def test_connected
+        consumer = Ag::Object.new("User", "1")
+        producer = Ag::Object.new("User", "2")
+        connect(consumer, producer)
+
+        assert_equal true, adapter.connected?(consumer, producer)
+        assert_equal false, adapter.connected?(producer, consumer)
+      end
+
+      def test_consumers
+        consumer1 = Ag::Object.new("User", "1")
+        consumer2 = Ag::Object.new("User", "2")
+        consumer3 = Ag::Object.new("User", "3")
+        producer = Ag::Object.new("User", "4")
+        connect(consumer1, producer)
+        connect(consumer2, producer)
+
+        consumers = adapter.consumers(producer)
+        assert_equal 2, consumers.size
+        assert_equal "2", consumers[0].consumer.id
+        assert_equal "1", consumers[1].consumer.id
+      end
+
+      def test_consumers_limit
+        producer = Ag::Object.new("User", "99")
+        consumers = (1..10).to_a.map { |n|
+          Ag::Object.new("User", n.to_s).tap { |consumer|
+            connect consumer, producer
+          }
+        }
+        assert_equal 5, adapter.consumers(producer, limit: 5).size
+        assert_equal consumers[5..9].reverse,
+          adapter.consumers(producer, limit: 5).map(&:consumer)
+      end
+
+      def test_consumers_offset
+        producer = Ag::Object.new("User", "99")
+        consumers = (1..10).to_a.map { |n|
+          Ag::Object.new("User", n.to_s).tap { |consumer|
+            connect consumer, producer
+          }
+        }
+        assert_equal consumers[0..4].reverse,
+          adapter.consumers(producer, offset: 5).map(&:consumer)
+      end
+
+      def test_producers
+        consumer1 = Ag::Object.new("User", "1")
+        consumer2 = Ag::Object.new("User", "2")
+        producer1 = Ag::Object.new("User", "3")
+        producer2 = Ag::Object.new("User", "4")
+        producer3 = Ag::Object.new("User", "5")
+        connect(consumer1, producer1)
+        connect(consumer1, producer2)
+        connect(consumer2, producer3)
+
+        producers = adapter.producers(consumer1)
+        assert_equal 2, producers.size
+        assert_equal "4", producers[0].producer.id
+        assert_equal "3", producers[1].producer.id
+      end
+
+      def test_producers_limit
+        consumer = Ag::Object.new("User", "99")
+        producers = (1..10).to_a.map { |n|
+          Ag::Object.new("User", n.to_s).tap { |producer|
+            connect consumer, producer
+          }
+        }
+        assert_equal 5, adapter.producers(consumer, limit: 5).size
+        assert_equal producers[5..9].reverse,
+          adapter.producers(consumer, limit: 5).map(&:producer)
+      end
+
+      def test_producers_offset
+        consumer = Ag::Object.new("User", "99")
+        producers = (1..10).to_a.map { |n|
+          Ag::Object.new("User", n.to_s).tap { |producer|
+            connect consumer, producer
+          }
+        }
+        assert_equal producers[0..4].reverse,
+          adapter.producers(consumer, offset: 5).map(&:producer)
+      end
+
+      def test_timeline
+        john = Ag::Object.new("User", "1")
+        steve = Ag::Object.new("User", "2")
+        presentation = Ag::Object.new("Presentation", "1")
+        connect john, steve
+        produce Ag::Event.new(producer: steve, object: presentation, verb: "publish")
+
+        events = adapter.timeline(john)
+        assert_equal 1, events.size
+      end
+
+      def test_timeline_limit
+        john = Ag::Object.new("User", "1")
+        steve = Ag::Object.new("User", "2")
+        connect john, steve
+
+        presentations = (1..10).to_a.map { |n|
+          Ag::Object.new("Presentation", n.to_s)
+        }
+
+        presentations.each do |presentation|
+          produce Ag::Event.new({
+            producer: steve,
+            object: presentation,
+            verb: "publish",
+          })
+        end
+
+        events = adapter.timeline(john, limit: 5)
+        assert_equal 5, events.size
+        assert_equal presentations[5..9].reverse, events.map(&:object)
+      end
+
+      def test_timeline_offset
+        john = Ag::Object.new("User", "1")
+        steve = Ag::Object.new("User", "2")
+        connect john, steve
+
+        presentations = (1..10).to_a.map { |n|
+          Ag::Object.new("Presentation", n.to_s)
+        }
+
+        presentations.each do |presentation|
+          produce Ag::Event.new({
+            producer: steve,
+            object: presentation,
+            verb: "publish",
+          })
+        end
+
+        events = adapter.timeline(john, offset: 5)
+        assert_equal 5, events.size
+        assert_equal presentations[0..4].reverse, events.map(&:object)
+      end
+    end
+  end
+end

data/lib/ag/version.rb

@@ -0,0 +1,3 @@
+module Ag
+  VERSION = "0.0.1"
+end

data/script/bootstrap

@@ -0,0 +1 @@
+bundle --quiet

data/script/test

@@ -0,0 +1,25 @@
+#!/bin/sh
+#/ Usage: test [individual test file]
+#/
+#/ Bootstrap and run all tests or an individual test.
+#/
+#/ Examples:
+#/
+#/   # run all tests
+#/   test
+#/
+#/   # run individual test
+#/   test test/controller_instrumentation_test.rb
+#/
+
+set -e
+cd $(dirname "$0")/..
+
+[ "$1" = "--help" -o "$1" = "-h" -o "$1" = "help" ] && {
+    grep '^#/' <"$0"| cut -c4-
+    exit 0
+}
+
+ruby -I lib -I test -r rubygems \
+  -e 'require "bundler/setup"' \
+  -e '(ARGV.empty? ? Dir["test/**/*_test.rb"] : ARGV).each { |f| load f }' -- "$@"

data/test/adapters/memory_test.rb

@@ -0,0 +1,41 @@
+require_relative "../helper"
+require "ag/adapters/memory"
+require "ag/spec/adapter"
+require "securerandom"
+
+class AdaptersMemoryTest < Ag::Test
+  def setup
+    @source = {}
+  end
+
+  def adapter
+    @adapter ||= Ag::Adapters::Memory.new(@source)
+  end
+
+  include Ag::Spec::Adapter
+
+  private
+
+  def connections
+    @source[:connections]
+  end
+
+  def events
+    @source[:events]
+  end
+
+  def connect(consumer, producer)
+    @source[:connections] ||= []
+    @source[:connections] << Ag::Connection.new({
+      id: SecureRandom.uuid,
+      created_at: Time.now.utc,
+      consumer: consumer,
+      producer: producer,
+    })
+  end
+
+  def produce(event)
+    @source[:events] ||= []
+    @source[:events] << event
+  end
+end

data/test/adapters/sequel_pull_compact_test.rb

@@ -0,0 +1,72 @@
+require_relative "../helper"
+require "ag/adapters/sequel_pull_compact"
+require "ag/spec/adapter"
+
+class AdaptersSequelPullCompactTest < Ag::Test
+  def setup
+    Sequel.default_timezone = :utc
+    @db = Sequel.sqlite
+
+    @db.create_table :connections do
+      primary_key :id
+      String :consumer_id
+      String :producer_id
+      Time :created_at
+      index [:consumer_id, :producer_id], unique: true
+    end
+
+    @db.create_table :events do
+      primary_key :id
+      String :producer_id
+      String :object_id
+      String :verb
+      Time :created_at
+    end
+  end
+
+  def adapter
+    @adapter ||= Ag::Adapters::SequelPullCompact.new(@db)
+  end
+
+  include Ag::Spec::Adapter
+
+  private
+
+  def connections
+    @db[:connections].map { |row|
+      Ag::Connection.new({
+        id: row[:id],
+        created_at: row[:created_at],
+        consumer: Ag::Adapters::SequelPullCompact.hydrate(row[:consumer_id]),
+        producer: Ag::Adapters::SequelPullCompact.hydrate(row[:producer_id]),
+      })
+    }
+  end
+
+  def events
+    @db[:events].map { |row|
+      Ag::Event.new({
+        id: row[:id],
+        verb: row[:verb],
+        created_at: row[:created_at],
+        producer: Ag::Adapters::SequelPullCompact.hydrate(row[:producer_id]),
+        object: Ag::Adapters::SequelPullCompact.hydrate(row[:object_id]),
+      })
+    }
+  end
+
+  def connect(consumer, producer)
+    @db[:connections].insert({
+      consumer_id: Ag::Adapters::SequelPullCompact.dehydrate(consumer),
+      producer_id: Ag::Adapters::SequelPullCompact.dehydrate(producer),
+    })
+  end
+
+  def produce(event)
+    @db[:events].insert({
+      producer_id: Ag::Adapters::SequelPullCompact.dehydrate(event.producer),
+      object_id: Ag::Adapters::SequelPullCompact.dehydrate(event.object),
+      created_at: Time.now.utc,
+    })
+  end
+end

data/test/adapters/sequel_pull_test.rb

@@ -0,0 +1,80 @@
+require_relative "../helper"
+require "ag/adapters/sequel_pull"
+require "ag/spec/adapter"
+
+class AdaptersSequelPullTest < Ag::Test
+  def setup
+    Sequel.default_timezone = :utc
+    @db = Sequel.sqlite
+
+    @db.create_table :connections do
+      primary_key :id
+      String :consumer_id
+      String :consumer_type
+      String :producer_id
+      String :producer_type
+      Time :created_at
+      index [:consumer_id, :consumer_type, :producer_id, :producer_type], unique: true
+    end
+
+    @db.create_table :events do
+      primary_key :id
+      String :producer_id
+      String :producer_type
+      String :object_id
+      String :object_type
+      String :verb
+      Time :created_at
+    end
+  end
+
+  def adapter
+    @adapter ||= Ag::Adapters::SequelPull.new(@db)
+  end
+
+  include Ag::Spec::Adapter
+
+  private
+
+  def connections
+    @db[:connections].map { |row|
+      Ag::Connection.new({
+        id: row[:id],
+        created_at: row[:created_at],
+        consumer: Ag::Object.new(row[:consumer_type], row[:consumer_id]),
+        producer: Ag::Object.new(row[:producer_type], row[:producer_id]),
+      })
+    }
+  end
+
+  def events
+    @db[:events].map { |row|
+      Ag::Event.new({
+        id: row[:id],
+        verb: row[:verb],
+        created_at: row[:created_at],
+        producer: Ag::Object.new(row[:producer_type], row[:producer_id]),
+        object: Ag::Object.new(row[:object_type], row[:object_id]),
+      })
+    }
+  end
+
+  def connect(consumer, producer)
+    @db[:connections].insert({
+      consumer_id: consumer.id,
+      consumer_type: consumer.type,
+      producer_id: producer.id,
+      producer_type: producer.type,
+    })
+  end
+
+  def produce(event)
+    @db[:events].insert({
+      producer_type: event.producer.type,
+      producer_id: event.producer.id,
+      object_type: event.object.type,
+      object_id: event.object.id,
+      created_at: Time.now.utc,
+    })
+  end
+end

data/test/client_test.rb

@@ -0,0 +1,107 @@
+require "helper"
+
+class ClientTest < Ag::Test
+  def test_initializes_with_adapter
+    adapter = Ag::Adapters::Memory.new
+    client = Ag::Client.new(adapter)
+    assert_instance_of Ag::Client, client
+  end
+
+  def test_forwards_connect_to_adapter
+    args = [consumer, producer]
+    result = true
+    mock_adapter = Minitest::Mock.new
+    mock_adapter.expect(:connect, result, args)
+
+    client = Ag::Client.new(mock_adapter)
+    assert_equal result, client.connect(*args)
+
+    mock_adapter.verify
+  end
+
+  def test_forwards_produce_to_adapter
+    args = [event]
+    result = [producer]
+    mock_adapter = Minitest::Mock.new
+    mock_adapter.expect(:produce, result, args)
+
+    client = Ag::Client.new(mock_adapter)
+    assert_equal result, client.produce(*args)
+
+    mock_adapter.verify
+  end
+
+  def test_forwards_connected_to_adapter
+    args = [consumer, producer]
+    result = true
+    mock_adapter = Minitest::Mock.new
+    mock_adapter.expect(:connected?, result, args)
+
+    client = Ag::Client.new(mock_adapter)
+    assert_equal result, client.connected?(*args)
+
+    mock_adapter.verify
+  end
+
+  def test_forwards_consumers_to_adapter
+    args = [producer, {}]
+    result = [consumer]
+    mock_adapter = Minitest::Mock.new
+    mock_adapter.expect(:consumers, result, args)
+
+    client = Ag::Client.new(mock_adapter)
+    assert_equal result, client.consumers(*args)
+
+    mock_adapter.verify
+  end
+
+  def test_forwards_producers_to_adapter
+    args = [consumer, {}]
+    result = [producer]
+    mock_adapter = Minitest::Mock.new
+    mock_adapter.expect(:producers, result, args)
+
+    client = Ag::Client.new(mock_adapter)
+    assert_equal result, client.producers(*args)
+
+    mock_adapter.verify
+  end
+
+  def test_forwards_timeline_to_adapter
+    args = [consumer, {}]
+    result = [event]
+    mock_adapter = Minitest::Mock.new
+    mock_adapter.expect(:timeline, result, args)
+
+    client = Ag::Client.new(mock_adapter)
+    assert_equal result, client.timeline(*args)
+
+    mock_adapter.verify
+  end
+
+  private
+
+  def event
+    @event ||= Ag::Event.new({
+      producer: producer,
+      object: object,
+      verb: verb,
+    })
+  end
+
+  def verb
+    "follow"
+  end
+
+  def consumer
+    @consumer ||= Ag::Object.new("User", "1")
+  end
+
+  def producer
+    @producer ||= Ag::Object.new("User", "1")
+  end
+
+  def object
+    @object ||= Ag::Object.new("User", "3")
+  end
+end

data/test/helper.rb

@@ -0,0 +1,5 @@
+require "minitest/autorun"
+require "ag"
+
+class Ag::Test < Minitest::Test
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: ag
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- John Nunemaker
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !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: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.5.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.5.1
+description: Producers, consumers, connections and timelines.
+email:
+- nunemaker@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ag.gemspec
+- examples/readme.rb
+- examples/setup.rb
+- lib/ag.rb
+- lib/ag/adapters/memory.rb
+- lib/ag/adapters/sequel_pull.rb
+- lib/ag/adapters/sequel_pull_compact.rb
+- lib/ag/client.rb
+- lib/ag/connection.rb
+- lib/ag/event.rb
+- lib/ag/feed.rb
+- lib/ag/object.rb
+- lib/ag/spec/adapter.rb
+- lib/ag/version.rb
+- script/bootstrap
+- script/test
+- test/adapters/memory_test.rb
+- test/adapters/sequel_pull_compact_test.rb
+- test/adapters/sequel_pull_test.rb
+- test/client_test.rb
+- test/helper.rb
+homepage: ''
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Producers, consumers, connections and timelines.
+test_files:
+- test/adapters/memory_test.rb
+- test/adapters/sequel_pull_compact_test.rb
+- test/adapters/sequel_pull_test.rb
+- test/client_test.rb
+- test/helper.rb