keikokuc 0.0.3 → 0.1

data/LICENSE

@@ -1,22 +1,19 @@
-Copyright (c) 2012 Harold Giménez
+Copyright (C) 2012 Harold Giménez
 
-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:
 
-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 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.
+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

@@ -1,6 +1,8 @@
 # Keikokuc
 
-TODO: Write a gem description
+Wrapper to the keikoku API
+
+[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/hgmnz/keikokuc)
 
 ## Installation
 
@@ -16,14 +18,13 @@ Or install it yourself as:
 
     $ gem install keikokuc
 
-## Usage
+## Docs
+
+For usage examples please see the docs:
 
-TODO: Write usage instructions here
+[http://rdoc.info/github/hgmnz/keikokuc/master/frames](http://rdoc.info/github/hgmnz/keikokuc/master/frames)
 
-## Contributing
+## License
 
-1. Fork it
-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 new Pull Request
+keikokuc is copyright (c) Harold Giménez and is released under the terms of the
+MIT License found in the LICENSE file.

data/keikokuc.gemspec

@@ -5,9 +5,9 @@ require 'factory_girl'
 Gem::Specification.new do |gem|
   gem.authors       = ["Harold Giménez"]
   gem.email         = ["harold.gimenez@gmail.com"]
-  gem.description   = %q{Keikoku API client}
-  gem.summary       = %q{Keikoku API client}
-  gem.homepage      = ""
+  gem.description   = %q{Keikoku client}
+  gem.summary       = %q{Keikoku is an experimental notification system on Heroku. This gem interfaces with the keikoku API to be used bynotification producers and consumers}
+  gem.homepage      = "https://github.com/hgmnz/keikokuc"
 
   gem.files         = `git ls-files`.split($\)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }

data/lib/handles_timeout.rb

@@ -8,9 +8,13 @@ module HandlesTimeout
   module ClassMethods
     def handle_timeout(method_name)
       alias_method "#{method_name}_without_timeout", method_name
-      define_method method_name do |args|
+      define_method method_name do |*args|
         begin
-          Timeout::timeout(5) { send("#{method_name}_without_timeout", args) }
+          if args.empty?
+            Timeout::timeout(5) { send("#{method_name}_without_timeout") }
+          else
+            Timeout::timeout(5) { send("#{method_name}_without_timeout", *args) }
+          end
         rescue Timeout::Error
           [nil, RequestTimeout]
         end

data/lib/keikokuc.rb

@@ -2,6 +2,7 @@ require 'handles_timeout'
 require 'keikokuc/version'
 require 'keikokuc/client'
 require 'keikokuc/notification'
+require 'keikokuc/notification_list'
 
 module Keikokuc
 end

data/lib/keikokuc/client.rb

@@ -11,10 +11,12 @@ class Keikokuc::Client
   InvalidNotification = Class.new
   Unauthorized = Class.new
 
-  attr_accessor :producer_api_key
+  attr_accessor :producer_api_key, :user, :password
 
   def initialize(opts = {})
     @producer_api_key = opts[:producer_api_key]
+    @user             = opts[:user]
+    @password         = opts[:password]
   end
 
   # Internal: posts a new notification to keikoku
@@ -44,15 +46,69 @@ class Keikokuc::Client
       [parse_json(response), nil]
     rescue RestClient::UnprocessableEntity => e
       [parse_json(e.response), InvalidNotification]
-    rescue RestClient::Unauthorized => e
+    rescue RestClient::Unauthorized
       [{}, Unauthorized]
     end
   end
   handle_timeout :post_notification
 
+  # Internal: gets all active notifications for a user
+  #
+  # Examples
+  #
+  #   client = Keikokuc::Client.new(user: 'user@example.com', password: 'pass')
+  #   response, error = client.get_notifications
+  #
+  # Returns
+  #
+  # two objects:
+  #   The response as a hash
+  #   The error if any (nil if no error)
+  #
+  # Possible errors include:
+  #
+  # * `Client::Timeout` if the request takes longer than 5 seconds
+  # * `Client::Unauthorized` if HTTP Basic auth fails
+  def get_notifications
+    begin
+      response = notifications_api.get
+      [parse_json(response), nil]
+    rescue RestClient::Unauthorized
+      [{}, Unauthorized]
+    end
+  end
+  handle_timeout :get_notifications
+
+  # Public: Marks a notification as read
+  #
+  # remote_id - the keikoku id for the notification to mark as read
+  #
+  # two objects:
+  #   The response as a hash
+  #   The error if any (nil if no error)
+  #
+  # Possible errors include:
+  #
+  # * `Client::Timeout` if the request takes longer than 5 seconds
+  # * `Client::Unauthorized` if HTTP Basic auth fails
+  def read_notification(remote_id)
+    begin
+      response = notifications_api["/#{remote_id}/read"].post ''
+      parsed_response = parse_json(response)
+      parsed_response[:read_at] = DateTime.parse(parsed_response[:read_at])
+      [parsed_response, nil]
+    rescue RestClient::Unauthorized
+      [{}, Unauthorized]
+    end
+  end
+  handle_timeout :read_notification
+
+
 private
   def notifications_api # :nodoc:
-    @notifications_api ||= RestClient::Resource.new(api_url)
+    @notifications_api ||= RestClient::Resource.new(api_url,
+                                                    user: user,
+                                                    password: password)
   end
 
   def api_url # :nodoc:
@@ -67,7 +123,16 @@ private
     symbolize_keys(Yajl::Parser.parse(data)) if data
   end
 
-  def symbolize_keys(hash) # :nodoc:
+  def symbolize_keys(object) # :nodoc:
+    case object
+    when Hash
+      symbolize_hash_keys(object)
+    when Array
+      object.map { |item| symbolize_hash_keys(item) }
+    end
+  end
+
+  def symbolize_hash_keys(hash)
     hash.inject({}) do |result, (k, v)|
       result[k.to_sym] = v
       result

data/lib/keikokuc/notification.rb

@@ -8,7 +8,7 @@
 #                                             severity: 'info',
 #                                             target: 'sunny-skies-42'
 #                                             producer_api_key: 'abcd')
-#   if notificaiton.publish
+#   if notification.publish
 #     # persist notification
 #   else
 #     # handle error
@@ -17,11 +17,11 @@
 class Keikokuc::Notification
   ATTRS = %w[message url severity
              target_name account_email
-             producer_api_key remote_id errors].freeze
+             producer_api_key remote_id errors read_at].freeze
 
   attr_accessor *ATTRS
 
-  # Public: class constructor
+  # Public: Initialize a notification
   #
   # opts - a hash of attributes to be set on constructed object
   #
@@ -36,6 +36,8 @@ class Keikokuc::Notification
         send("#{attribute}=", opts[attribute.to_sym])
       end
     end
+    @read   = false
+    @client = opts[:client]
   end
 
   # Public: publishes this notification to keikoku
@@ -55,6 +57,27 @@ class Keikokuc::Notification
     error.nil?
   end
 
+  # Public: marks this notification as read on keikoku
+  #
+  # Marks the notification as read, after which it will
+  # no longer be displayed to any consumer for this user
+  #
+  # Returns a boolean set to true if marking as read succeeded
+  def read
+    response, error = client.read_notification(remote_id)
+    if error.nil?
+      self.read_at = response[:read_at]
+    end
+    error.nil?
+  end
+
+  # Public: whether this notification is marked as read by this user
+  #
+  # Returns true if the user has marked this notification as read
+  def read?
+    !!@read_at
+  end
+
   # Internal: coerces this notification to a hash
   #
   # Returns this notification's attributes as a hash
@@ -65,7 +88,6 @@ class Keikokuc::Notification
     end
   end
 
-private
   def client # :nodoc:
     @client ||= Keikokuc::Client.new(producer_api_key: producer_api_key)
   end

data/lib/keikokuc/notification_list.rb

@@ -0,0 +1,74 @@
+# Public: collection of keikoku notifications
+#
+# This class encapsulates Keikoku::Notification objects
+# as a collection.
+#
+# It includes the Enumerable module, so `map`, `detect`,
+# and friends can be used.
+#
+# Examples
+#
+#   notifications = Keikokuc::NotificationList.new(user:    'user@example.com',
+#                                                  api_key: 'abcd')
+#   if notifications.fetch
+#     notifications.each do |notification|
+#       puts notification.inspect
+#     end
+#   else
+#     # handle error
+#   end
+class Keikokuc::NotificationList
+  include Enumerable
+
+  attr_accessor :user, :password
+
+  # Public: Initializes a NotificationList
+  #
+  # opts - options hash containing attribute values for the object
+  #        being constructed accepting the following three keys:
+  #  user - the heroku account's email (required)
+  #  password - the heroku account's password (required)
+  #  client - the client, used for DI in tests
+  def initialize(opts)
+    @user          = opts.fetch(:user)
+    @password      = opts.fetch(:password)
+    @client        = opts[:client]
+    @notifications = []
+  end
+
+  # Public: fetches notifications for the provided user
+  #
+  # Sets notifications to a set of `Notification` objects
+  # accessible via methods in Enumerable
+  #
+  # Returns a boolean set to true if fetching succeeded
+  def fetch
+    result, error = client.get_notifications
+    if error.nil?
+      @notifications = result.map do |attributes|
+        Keikokuc::Notification.new(attributes)
+      end
+    end
+
+    error.nil?
+  end
+
+  # Public: the number of notifications
+  #
+  # Returns an Integer set to the number of notifications
+  def size
+    @notifications.size
+  end
+
+  # Public: yields each Notification
+  #
+  # Yields every notification in this collection
+  def each
+    @notifications.each
+  end
+
+private
+  def client # :nodoc:
+    @client ||= Client.new(user: user, password: password)
+  end
+end

data/lib/keikokuc/version.rb

@@ -1,3 +1,3 @@
 module Keikokuc
-  VERSION = "0.0.3"
+  VERSION = "0.1"
 end

data/spec/factories.rb

@@ -6,5 +6,14 @@ FactoryGirl.define do
     target_name   'cloudy-skies-243'
     severity      'info'
     account_email 'harold@heroku.com'
+
+    initialize_with { new(attributes) }
+  end
+
+  factory :notification_list, class: Keikokuc::NotificationList do
+    user     'user@example.com'
+    password 'pass'
+
+    initialize_with { new(attributes) }
   end
 end

data/spec/keikoku/client_spec.rb

@@ -1,10 +1,13 @@
 require 'spec_helper'
 require 'sham_rack'
 module Keikokuc
-  describe Client, '#post_notification' do
+  shared_context 'client specs' do
     let(:fake_keikoku) { FakeKeikoku.new }
-
     after { ShamRack.unmount_all }
+  end
+
+  describe Client, '#post_notification' do
+    include_context 'client specs'
 
     it 'publishes a new notification' do
       ShamRack.mount(fake_keikoku, "keikoku.herokuapp.com", 443)
@@ -12,8 +15,8 @@ module Keikokuc
       client = Client.new(producer_api_key: 'abc')
       result, error = client.post_notification(message:  'hello',
                                                severity: 'info')
-      result[:id].should_not be_nil
-      error.should be_nil
+      expect(result[:id]).not_to be_nil
+      expect(error).to be_nil
     end
 
     it 'handles invalid notifications' do
@@ -22,8 +25,8 @@ module Keikokuc
       end
 
       response, error = Client.new.post_notification({})
-      error.should == Client::InvalidNotification
-      response[:errors].should == 'srorre'
+      expect(error).to be Client::InvalidNotification
+      expect(response[:errors]).to eq('srorre')
     end
 
     it 'handles authentication failures' do
@@ -32,15 +35,88 @@ module Keikokuc
       client = Client.new(producer_api_key: 'bad one')
       result, error = client.post_notification(message:  'hello',
                                                severity: 'info')
-      result[:id].should be_nil
-      error.should == Client::Unauthorized
+      expect(result[:id]).to be_nil
+      expect(error).to eq Client::Unauthorized
     end
 
     it 'handles timeouts' do
       RestClient::Resource.any_instance.stub(:post).and_raise Timeout::Error
       response, error = Client.new.post_notification({})
-      response.should be_nil
-      error.should == Client::RequestTimeout
+      expect(response).to be_nil
+      expect(error).to eq(Client::RequestTimeout)
+    end
+  end
+
+  describe Client, '#get_notifications' do
+    include_context 'client specs'
+
+    it 'gets all notifications for a user' do
+      ShamRack.mount(fake_keikoku, "keikoku.herokuapp.com", 443)
+      fake_keikoku.register_publisher(api_key: 'abc')
+      fake_keikoku.register_user(email: 'harold@heroku.com', password: 'pass')
+      build(:notification, account_email: 'harold@heroku.com', message: 'find me!', producer_api_key: 'abc').publish
+      build(:notification, account_email: 'another@heroku.com', producer_api_key: 'abc').publish
+
+      client = Client.new(user: 'harold@heroku.com', password: 'pass')
+
+      notifications, error = client.get_notifications
+
+      expect(error).to be_nil
+      expect(notifications).to have(1).item
+
+      expect(notifications.first[:message]).to eq('find me!')
+    end
+
+    it 'handles timeouts' do
+      RestClient::Resource.any_instance.stub(:get).and_raise Timeout::Error
+      response, error = Client.new.get_notifications
+      expect(response).to be_nil
+      expect(error).to eq(Client::RequestTimeout)
+    end
+
+    it 'handles authentication failures' do
+      ShamRack.mount(fake_keikoku, "keikoku.herokuapp.com", 443)
+      fake_keikoku.register_user(email: 'harold@heroku.com', password: 'pass')
+      client = Client.new(user: 'harold@heroku.com', password: 'bad-pass')
+
+      response, error = client.get_notifications
+
+      expect(response).to be_empty
+      expect(error).to eq(Client::Unauthorized)
+    end
+  end
+
+  describe Client, '#read_notification' do
+    include_context 'client specs'
+    it 'marks the notification as read' do
+      ShamRack.mount(fake_keikoku, "keikoku.herokuapp.com", 443)
+      fake_keikoku.register_publisher(api_key: 'abc')
+      fake_keikoku.register_user(email: 'harold@heroku.com', password: 'pass')
+      client = Client.new(user: 'harold@heroku.com', password: 'pass')
+      notification = build(:notification, account_email: 'harold@heroku.com', producer_api_key: 'abc')
+      notification.publish or raise "Notification publish error"
+
+      response, error = client.read_notification(notification.remote_id)
+      expect(error).to be_nil
+
+      expect(response[:read_by]).to eq('harold@heroku.com')
+      expect(response[:read_at]).to be_within(1).of(DateTime.now)
+    end
+
+    it 'handles authentication errors' do
+      ShamRack.mount(fake_keikoku, "keikoku.herokuapp.com", 443)
+      fake_keikoku.register_user(email: 'harold@heroku.com', password: 'pass')
+      client = Client.new(user: 'harold@heroku.com', password: 'bad-pass')
+      response, error = client.read_notification(1)
+      expect(response).to be_empty
+      expect(error).to eq(Client::Unauthorized)
+    end
+
+    it 'handles timeouts' do
+      RestClient::Resource.any_instance.stub(:post).and_raise Timeout::Error
+      response, error = Client.new.read_notification(1)
+      expect(response).to be_nil
+      expect(error).to eq(Client::RequestTimeout)
     end
   end
 end

data/spec/keikoku/notification_list_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+module Keikokuc
+  describe NotificationList, '#fetch' do
+    it 'finds all notifications for the current user' do
+      fake_client = double
+      fake_client.should_receive(:get_notifications).
+        and_return([user_notifications, nil])
+      list = build(:notification_list, client: fake_client)
+
+      result = list.fetch
+      expect(result).to be_true
+
+      expect(list.size).to eq(2)
+      list.each do |notification|
+        expect(user_notifications.map do |h|
+          h[:message]
+        end).to include(notification.message)
+        expect(notification).to be_kind_of(Notification)
+      end
+    end
+
+    def user_notifications
+      [
+        {
+          resource: 'flying-monkey-123',
+          message:  'Database HEROKU_POSTGRESQL_BROWN is over row limits',
+          url:      'https://devcenter.heroku.com/how-to-fix-problem',
+          severity: 'info'
+        },
+        {
+          resource: 'rising-cloud-42',
+          message:  'High OOM rates',
+          url:      'https://devcenter.heroku.com/oom',
+          severity: 'fatal'
+        }
+      ]
+    end
+  end
+end

data/spec/keikoku/notification_spec.rb

@@ -4,44 +4,100 @@ module Keikokuc
   describe Notification, '#publish' do
     it 'publishes to keikoku and stores an id' do
       fake_client = double
-      Client.stub(new: fake_client)
       fake_client.
         should_receive(:post_notification).with do |args|
-          args[:message].should == 'hello'
-          args[:account_email].should == 'harold@heroku.com'
+          expect(args[:message]).to eq('hello')
+          expect(args[:account_email]).to eq('harold@heroku.com')
         end.and_return([{ id: 1 }, nil])
 
       notification = build(:notification, message: 'hello',
-                                          account_email: 'harold@heroku.com')
+                                          account_email: 'harold@heroku.com',
+                                          client: fake_client)
 
       result = notification.publish
-      result.should be_true
+      expect(result).to be_true
 
-      notification.remote_id.should == 1
+      expect(notification.remote_id).to eq(1)
     end
 
     it 'returns false when publishing fails and stores errors' do
       fake_client = double
-      Client.stub(new: fake_client)
       fake_client.
         should_receive(:post_notification).with do |args|
-          args[:message].should be_nil
+          expect(args[:message]).to be_nil
         end.
-        and_return([{ errors: { attributes: { message: ['is not present'] }}}, Keikokuc::Client::InvalidNotification])
+        and_return([{ errors: { attributes: { message: ['is not present'] }}},
+                   Keikokuc::Client::InvalidNotification])
 
-      notification = build(:notification, message: nil)
+      notification = build(:notification, message: nil, client: fake_client)
 
       result = notification.publish
-      result.should be_false
+      expect(result).to be_false
 
-      notification.remote_id.should be_nil
-      notification.errors[:attributes][:message].should == ['is not present']
+      expect(notification.remote_id).to be_nil
+      expect(notification.errors[:attributes][:message]).to eq(['is not present'])
     end
 
     it 'stores attributes as instance vars' do
       notification = Notification.new(message: 'foo')
-      notification.message.should == 'foo'
+      expect(notification.message).to eq('foo')
     end
+  end
+
+  describe Notification, '#read' do
+    it 'marks as read to keikoku' do
+      fake_client = double
+
+      fake_client.should_receive(:read_notification).
+        with('1234').
+        and_return([{read_at: Time.now}, nil])
+
+      notification = Notification.new(remote_id: '1234', client: fake_client)
+
+      result = notification.read
+      expect(result).to be_true
+
+      expect(notification.read_at).to be_within(1).of(Time.now)
+      expect(notification).to be_read
+    end
+
+    it 'handles errors' do
+      fake_client = double
+      fake_client.stub(:read_notification).
+        with('1234').
+        and_return([{}, :some_error])
+
+      notification = Notification.new(remote_id: '1234', client: fake_client)
+
+      result = notification.read
+      expect(result).to be_false
 
+      expect(notification.read_at).to be_nil
+      expect(notification).not_to be_read
+    end
+  end
+
+  describe Notification, '#read?' do
+    it 'is true if the read_at is known' do
+      notification = build(:notification, read_at: nil)
+      expect(notification.read?).to be_false
+
+      notification.read_at = Time.now
+
+      expect(notification.read?).to be_true
+    end
+  end
+
+  describe Notification, '#client' do
+    it 'defaults to a properly constructer Keikokuc::Client' do
+      notification = build(:notification, producer_api_key: 'fake-api-key')
+      expect(notification.client).to be_kind_of(Keikokuc::Client)
+      expect(notification.client.producer_api_key).to eq('fake-api-key')
+    end
+
+    it 'can be injected' do
+      notification = Notification.new(client: :foo)
+      expect(notification.client).to eq(:foo)
+    end
   end
 end

data/spec/spec_helper.rb

@@ -5,8 +5,8 @@
 #
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 require 'keikokuc'
-require './spec/factories'
-require './spec/support/fake_keikoku'
+require 'factories'
+require 'support/fake_keikoku'
 RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
@@ -19,4 +19,8 @@ RSpec.configure do |config|
   config.order = 'random'
 
   config.include FactoryGirl::Syntax::Methods
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
 end

data/spec/support/fake_keikoku.rb

@@ -2,16 +2,31 @@ class FakeKeikoku
   def initialize
     @publishers = []
     @notifications = []
+    @users = []
   end
 
   def register_publisher(opts)
     @publishers << opts
   end
 
+  def register_user(opts)
+    @users << opts
+  end
+
   def publisher_by_api_key(api_key)
     @publishers.detect { |p| p[:api_key] == api_key }
   end
 
+  def find_user(user, pass)
+    @users.detect { |u| u[:email] == user && u[:password] == pass }
+  end
+
+  def notifications_for_user(email)
+    @notifications.select do |notification|
+      notification.to_hash['account_email'] == email
+    end
+  end
+
   def call(env)
     with_rack_env(env) do
       if request_path == '/api/v1/notifications' && request_verb == 'POST'
@@ -22,6 +37,23 @@ class FakeKeikoku
         else
           [401, { }, ["Not authorized"]]
         end
+      elsif request_path == '/api/v1/notifications' && request_verb == 'GET'
+        if current_user = authenticate_consumer
+          notifications = notifications_for_user(current_user).map(&:to_hash)
+          [200, { }, [Yajl::Encoder.encode(notifications)]]
+        else
+          [401, { }, ["Not authorized"]]
+        end
+      elsif request_path =~ %r{/api/v1/notifications/([^/]+)/read} && request_verb == 'POST'
+        if current_user = authenticate_consumer
+          notification = notifications_for_user(current_user).detect do |notification|
+            notification.to_hash[:id].to_s == $1.to_s
+          end
+          notification.mark_read_by!(current_user)
+          [200, {}, [Yajl::Encoder.encode({read_by: current_user, read_at: Time.now})]]
+        else
+          [401, { }, ["Not authorized"]]
+        end
       end
     end
   end
@@ -57,6 +89,16 @@ private
     rack_env["HTTP_X_KEIKOKU_AUTH"]
   end
 
+  def authenticate_consumer
+    auth = Rack::Auth::Basic::Request.new(rack_env)
+    if auth.provided? && auth.basic? && creds = auth.credentials
+      # creds looks like [user, password]
+      if find_user(*creds)
+        creds.first
+      end
+    end
+  end
+
   def next_id
     @@sequence ||= 0
     @@sequence += 1
@@ -71,5 +113,13 @@ private
         end
       end
     end
+
+    def to_hash
+      @opts
+    end
+
+    def mark_read_by!(user)
+      (@read_by ||= []) << user
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: keikokuc
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: '0.1'
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-08 00:00:00.000000000 Z
+date: 2012-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
-  requirement: &70352245332780 !ruby/object:Gem::Requirement
+  requirement: &70298442791900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70352245332780
+  version_requirements: *70298442791900
 - !ruby/object:Gem::Dependency
   name: yajl-ruby
-  requirement: &70352245332360 !ruby/object:Gem::Requirement
+  requirement: &70298442791480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70352245332360
+  version_requirements: *70298442791480
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70352245331940 !ruby/object:Gem::Requirement
+  requirement: &70298442791040 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70352245331940
+  version_requirements: *70298442791040
 - !ruby/object:Gem::Dependency
   name: factory_girl
-  requirement: &70352245331520 !ruby/object:Gem::Requirement
+  requirement: &70298442790620 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70352245331520
+  version_requirements: *70298442790620
 - !ruby/object:Gem::Dependency
   name: sham_rack
-  requirement: &70352245331100 !ruby/object:Gem::Requirement
+  requirement: &70298442790180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,8 +65,8 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70352245331100
-description: Keikoku API client
+  version_requirements: *70298442790180
+description: Keikoku client
 email:
 - harold.gimenez@gmail.com
 executables: []
@@ -84,13 +84,15 @@ files:
 - lib/keikokuc.rb
 - lib/keikokuc/client.rb
 - lib/keikokuc/notification.rb
+- lib/keikokuc/notification_list.rb
 - lib/keikokuc/version.rb
 - spec/factories.rb
 - spec/keikoku/client_spec.rb
+- spec/keikoku/notification_list_spec.rb
 - spec/keikoku/notification_spec.rb
 - spec/spec_helper.rb
 - spec/support/fake_keikoku.rb
-homepage: ''
+homepage: https://github.com/hgmnz/keikokuc
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -113,10 +115,12 @@ rubyforge_project:
 rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
-summary: Keikoku API client
+summary: Keikoku is an experimental notification system on Heroku. This gem interfaces
+  with the keikoku API to be used bynotification producers and consumers
 test_files:
 - spec/factories.rb
 - spec/keikoku/client_spec.rb
+- spec/keikoku/notification_list_spec.rb
 - spec/keikoku/notification_spec.rb
 - spec/spec_helper.rb
 - spec/support/fake_keikoku.rb