zulip 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7104e27dedb5006e5b02e35bf0a8cadf8c74985b
+  data.tar.gz: a33826034e2546c0ef6957b1e41bde933ae5b342
+SHA512:
+  metadata.gz: 4597dad59bb5b8269d3149a91c4629a6cf1f455ea961632b6a351cdcb39a1486e5d6a264609bcce36942b9910aea1b357729e5da9116a0c4e5ddca24929fdd40
+  data.tar.gz: ae289b999a7ebdd71d3504263de80d1255aba4f38aa4c3c141fa80ee28470774793a91e55bbb0bad6c961741cbe321f55725c2140c6302c1d823b20a247d0b5a

data/.gitignore

@@ -0,0 +1 @@
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Ryan Vergeront
+
+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,79 @@
+# Zulip-Rb
+
+A ruby interface to the Zulip API.
+
+### Installation
+
+Add this line to your application's Gemfile:
+
+`gem 'zulip-rb'`
+
+And then execute:
+
+`$ bundle`
+
+Or install it yourself as:
+
+`$ gem install zulip-rb`
+
+### Configuration
+You'll need to register a bot to use the Zulip API.
+You can obtain your Zulip API key, create bots, and manage bots all
+from your Zulip [settings page](https://zulip.com/#settings).
+
+Set your api key and your bot's email address by passing a block to your Zulip::Client instance:
+```ruby
+client = Zulip::Client.new do |config|
+config.bot_email_address = "YOUR_BOTS_EMAIL_ADDRESS"
+config.api_key = "YOUR_API_KEY"
+end
+```
+
+You'll need to subscribe your bot to streams you want to read from. Do so by adding your bot's email to the stream's membership from a zulip client, or use the #subscribe method (see example below).
+
+### Usage
+
+Send messages to a stream:
+```ruby
+client.send_message("Hey", "I'm posting to zulip", "test-stream")
+```
+
+Send private messages to one or more users:
+```ruby
+client.send_private_message("hey I heard you like the internet", "bob@the-internet.net", "alice@the-information-superhighway.org")
+```
+
+Stream messages:
+```ruby
+client.stream_messages do |message|
+# Do some work
+end
+```
+
+Get your bot's current subscriptions:
+```ruby
+client.get_subscriptions
+```
+
+Subscribe your bot to a stream, passing the stream name:
+```ruby
+client.subscribe "food"
+```
+
+List users:
+```ruby
+client.get_users
+```
+
+### Contributing
+
+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
+
+Some areas that could use contributions:
+
+1. Error handling
+2. Add unsubscribing from a stream

data/Rakefile

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

data/example/zulip_message_echo.rb

@@ -0,0 +1,26 @@
+$:.push File.expand_path('../../lib', __FILE__)
+require 'zulip'
+
+### Sends a private message to a new thread is posted to a specified stream
+
+class ZulipEcho
+
+  def run
+    client = Zulip::Client.new do |config|
+      config.bot_email_address = ENV['BOT_EMAIL_ADDRESS'] || "bot@example.com"
+      config.api_key = ENV['BOT_API_KEY'] || "apikey"
+    end
+
+    client.stream_messages do |message|
+      client.send_private_message(private_message_content(message), "example@gmail.com")
+    end
+  end
+
+  private
+
+  def private_message_content(message)
+    "#{message.sender_full_name}, posted to #{message.stream}:\n #{message.subject}: #{message.content}"
+  end
+end
+
+ZulipEcho.new.run

data/lib/zulip/client/event_parser.rb

@@ -0,0 +1,14 @@
+module Zulip
+  class Client
+    module EventParser
+      def self.parse(event)
+        case event['type']
+        when "message"
+          Zulip::Message.new event.fetch('message')
+        when "heartbeat"
+          # NOOP
+        end
+      end
+    end
+  end
+end

data/lib/zulip/client/event_streaming.rb

@@ -0,0 +1,86 @@
+module Zulip
+  class Client
+    module EventStreaming
+
+      def stream_messages(&block)
+        stream_events("message", &block)
+      end
+
+      def stream_private_messages(&block)
+        stream_raw_events("message") do |raw_event|
+          yield parse_event(raw_event) if private_message?(raw_event)
+        end
+      end
+
+      def stream_public_messages(&block)
+        stream_raw_events("message") do |raw_event|
+          yield parse_event(raw_event) if public_message?(raw_event)
+        end
+      end
+
+      def stream_events(event_types, &block)
+        stream_raw_events(event_types) do |raw_event|
+          yield parse_event(raw_event)
+        end
+      end
+
+      private
+
+      def stream_raw_events(event_types, &block)
+        queue = register(event_types)
+        queue_id = queue.queue_id
+        last_event_id = queue.last_event_id
+
+        loop do
+          events = get_events(queue_id, last_event_id)
+          last_event_id = max_event_id_from(events)
+
+          events.each do |event|
+            yield event if event_types.include?(event["type"])
+          end
+        end
+      end
+
+      # Makes a longpulling request on an event queue
+      def get_events(queue_id, last_event_id=nil)
+        connection.params = build_get_event_params(queue_id, last_event_id)
+        event_response.fetch("events")
+      end
+
+      def parse_event(raw_event)
+        Zulip::Client::EventParser.parse(raw_event)
+      end
+
+      def build_get_event_params(registered_queue_or_queue_id, last_event_id)
+        { 'queue_id' => find_queue_id(registered_queue_or_queue_id),
+          'last_event_id' => last_event_id || registered_queue_or_queue_id.last_event_id }
+      end
+
+      def find_queue_id(registered_queue_or_queue_id)
+        if registered_queue_or_queue_id.respond_to?(:queue_id)
+          registered_queue_or_queue_id.queue_id
+        else
+          registered_queue_or_queue_id
+        end
+      end
+
+      def event_response
+        response = connection.get("/v1/events").body
+        JSON.parse(response)
+      end
+
+      def max_event_id_from(events)
+        events.map{ |event| event['id']}.max
+      end
+
+      def private_message?(event)
+        event['message']['type'] == "private"
+      end
+
+      def public_message?(event)
+        event['message']['type'] == "stream"
+      end
+
+    end
+  end
+end

data/lib/zulip/client/messages.rb

@@ -0,0 +1,31 @@
+require 'faraday'
+
+module Zulip
+  class Client
+    module Messages
+
+      def send_message(subject, content, to_stream)
+        post_message("stream", content, to_stream, subject)
+      end
+
+      def send_private_message(content, *recipient_users)
+        post_message("private", content, recipient_users)
+      end
+
+      private
+
+      def post_message(type, content, recipients_or_stream, subject=nil)
+        connection.params = build_post_message_params(type, content,
+                                                      recipients_or_stream, subject)
+        connection.post("v1/messages")
+      end
+
+      def build_post_message_params(type, content, recipients_or_stream, subject=nil)
+        params = subject ? {"subject" => subject } : {}
+        params.merge({ "type" => type, "content" => content,
+                       "to" => json_encode_list(recipients_or_stream) })
+      end
+
+    end
+  end
+end

data/lib/zulip/client/queue_registration.rb

@@ -0,0 +1,25 @@
+module Zulip
+  class Client
+    module QueueRegistration
+      EVENT_TYPES = { message: "message" }
+      # TODO: Add support for other event types
+      # TODO: Add support setting apply markdown to false
+
+      QueueRegistrationResponse = Struct.new(:queue_id, :last_event_id)
+
+      def register(event_types=nil, opts={})
+
+        if event_types
+          connection.params = { "event_types" => json_encode_list(event_types) }
+        end
+
+        QueueRegistrationResponse.new( registration_response['queue_id'],
+                                      registration_response['last_event_id'] )
+      end
+
+      def registration_response
+        @registration_response ||= parse_json(connection.post("v1/register").body)
+      end
+    end
+  end
+end

data/lib/zulip/client/stream_subscriptions.rb

@@ -0,0 +1,40 @@
+module Zulip
+  class Client
+    module StreamSubscriptions
+
+      def get_subscriptions
+        get_subscriptions_response.map do |subscription|
+          Zulip::StreamSubscription.new(subscription)
+        end
+      end
+
+      def subscribe(streams)
+        patch_subscriptions subscribe_params(streams)
+      end
+
+      private
+
+      def get_subscriptions_response
+        parse_response(connection.get(subscription_urn)).fetch("subscriptions") { [] }
+      end
+
+      def subscription_urn
+        'v1/users/me/subscriptions'
+      end
+
+      def subscribe_params(streams)
+        { add: json_encoded_streams(streams) }
+      end
+
+      def json_encoded_streams(streams)
+        streams = Array(streams).map { |subscription_name| { name: subscription_name } }
+        json_encode_list(streams)
+      end
+
+      def patch_subscriptions(req_params)
+        parse_response(connection.patch(subscription_urn, req_params))
+      end
+
+    end
+  end
+end

data/lib/zulip/client/users.rb

@@ -0,0 +1,16 @@
+module Zulip
+  class Client
+    module Users
+      def get_users
+        get_users_response.map { |user_data| Zulip::User.new(user_data) }
+      end
+
+      private
+
+      def get_users_response
+        parse_response(connection.get('v1/users')).fetch("members") { [] }
+      end
+
+    end
+  end
+end

data/lib/zulip/client.rb

@@ -0,0 +1,53 @@
+require 'json'
+require 'faraday'
+
+require 'zulip/client/messages'
+require 'zulip/client/users'
+require 'zulip/client/stream_subscriptions'
+require 'zulip/client/queue_registration'
+require 'zulip/client/event_streaming'
+require 'zulip/client/event_parser'
+
+module Zulip
+  class Client
+    include Zulip::Client::Messages
+    include Zulip::Client::Users
+    include Zulip::Client::StreamSubscriptions
+    include Zulip::Client::QueueRegistration
+    include Zulip::Client::EventStreaming
+    include Zulip::Client::EventParser
+
+    attr_accessor :bot_email_address, :api_key
+    attr_writer :connection
+    ENDPOINT = "https://api.zulip.com"
+
+    def initialize
+      yield self if block_given?
+    end
+
+    def connection
+      @connection ||= initialize_connection
+    end
+
+    private
+
+    def initialize_connection
+      conn = Faraday.new(url: ENDPOINT)
+      conn.basic_auth(bot_email_address, api_key)
+      conn
+    end
+
+    def json_encode_list(items)
+      JSON.generate(Array(items).flatten)
+    end
+
+    def parse_response(http_response)
+      parse_json(http_response.body)
+    end
+
+    def parse_json(json)
+      JSON.parse(json)
+    end
+
+  end
+end

data/lib/zulip/message.rb

@@ -0,0 +1,18 @@
+module Zulip
+  class Message
+    attr_reader :id, :recipient_id, :sender_email, :timestamp, :display_recipient,
+      :sender_id, :sender_full_name, :sender_domain, :content, :gravatar_hash,
+      :avatar_url, :client, :content_type, :subject_links, :sender_short_name,
+      :type, :subject
+
+    alias :stream :display_recipient
+    alias :display_recipients :display_recipient
+
+    def initialize(attrs={})
+      attrs.each do |name, value|
+        instance_variable_set("@#{name}", value)
+      end
+    end
+
+  end
+end

data/lib/zulip/stream_subscription.rb

@@ -0,0 +1,12 @@
+module Zulip
+  class StreamSubscription
+    attr_reader :name, :color, :notifications, :subscribers, :invite_only,
+      :email_address, :in_home_view
+
+    def initialize(attrs={})
+      attrs.each do |name, value|
+        instance_variable_set("@#{name}", value)
+      end
+    end
+  end
+end

data/lib/zulip/user.rb

@@ -0,0 +1,9 @@
+module Zulip
+  class User
+    attr_reader :email, :full_name
+    def initialize(user_data)
+      @email = user_data['email']
+      @full_name = user_data['full_name']
+    end
+  end
+end

data/lib/zulip/version.rb

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

data/lib/zulip.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+
+require 'zulip/version'
+require 'zulip/client'
+require 'zulip/message'
+require 'zulip/user'
+require 'zulip/stream_subscription'

data/spec/fixtures/add-subscription.json

@@ -0,0 +1 @@
+{"subscribed":{"test_zulip_cli-bot@students.hackerschool.com":["clojure"]},"not_subscribed":[],"result":"success","msg":"","already_subscribed":{"test_zulip_cli-bot@students.hackerschool.com":["ruby"]},"removed":[]}

data/spec/fixtures/get-message-event-success.json

@@ -0,0 +1 @@
+{"result":"success","queue_id":"1384457534:662","msg":"","events":[{"flags":[],"message":{"recipient_id":23442,"sender_email":"ryanvergeront@gmail.com","timestamp":1384460690,"display_recipient":"test-stream","sender_id":2874,"sender_full_name":"Ryan Vergeront (F'13)","sender_domain":"students.hackerschool.com","content":"register an event type of 'message' not 'messages'","gravatar_hash":"a8e2e659c929c79669f97603bd73fcc5","avatar_url":"https:\/\/secure.gravatar.com\/avatar\/a8e2e659c929c79669f97603bd73fcc5?d=identicon","client":"desktop app Mac 0.3.10","content_type":"text\/x-markdown","subject_links":[],"sender_short_name":"ryanvergeront","type":"stream","id":12791579,"subject":"sending some internet websites to the internet"},"type":"message","id":0}]}

data/spec/fixtures/get-private-message.json

@@ -0,0 +1 @@
+{"result":"success","queue_id":"1384457534:662","msg":"","events":[{"flags":[],"message":{"recipient_id":25207,"sender_email":"ryanvergeront@gmail.com","timestamp":1384561238,"display_recipient":[{"full_name":"Ryan Vergeront (F'13)","domain":"students.hackerschool.com","email":"ryanvergeront@gmail.com","short_name":"ryanvergeront","id":2874},{"domain":"students.hackerschool.com","short_name":"test_zulip_cli-bot","email":"test_zulip_cli-bot@students.hackerschool.com","full_name":"Ryan's Bot","id":2934}],"sender_id":2874,"sender_full_name":"Ryan Vergeront (F'13)","sender_domain":"students.hackerschool.com","content":"the messages are less funny when I'm PMing myself","gravatar_hash":"a8e2e659c929c79669f97603bd73fcc5","avatar_url":"https://secure.gravatar.com/avatar/a8e2e659c929c79669f97603bd73fcc5?d=identicon","client":"desktop app Mac 0.3.10","content_type":"text/x-markdown","subject_links":[],"sender_short_name":"ryanvergeront","type":"private","id":12855410,"subject":""},"type":"message","id":0}]}

data/spec/fixtures/get-user-subscriptions.json

@@ -0,0 +1 @@
+{"msg":"","result":"success","subscriptions":[{"name":"VIM","color":"#76ce90","notifications":false,"subscribers":["bob@example.com","alice@example.com"],"invite_only":false,"email_address":"VIM+c46cdd8670afe104a66e5f1af277aa05@streams.zulip.com","in_home_view":true},{"name":"social","color":"#94c849","notifications":false,"subscribers":["alice@example.com","jane@example.com"],"invite_only":false,"email_address":"social+06435131f9e681a9835c2733893baad2@streams.zulip.com","in_home_view":true}]}

data/spec/fixtures/get-users.json

@@ -0,0 +1 @@
+{"msg":"","result":"success","members":[{"email":"bob@example.org","full_name":"Bob G"},{"email":"alice@example.org","full_name":"Alice P"}]}

data/spec/fixtures/post-message-to-stream.json

@@ -0,0 +1 @@
+{"msg":"","result":"success","id":12743014}

data/spec/fixtures/queue-registration-success.json

@@ -0,0 +1 @@
+{"msg":"","max_message_id":12779330,"last_event_id":-1,"result":"success","queue_id":"1384438093:1161"}

data/spec/fixtures/sending-private-message-success.json

@@ -0,0 +1 @@
+{"msg":"","result":"success","id":12745890}

data/spec/helper.rb

@@ -0,0 +1,13 @@
+require 'json'
+
+def parsed_json_fixture(file)
+  JSON.parse(fixture(file))
+end
+
+def fixture(file)
+  File.new(fixture_path + '/' + file).read
+end
+
+def fixture_path
+  File.expand_path("../fixtures", __FILE__)
+end

data/spec/lib/zulip/client/event_parser_spec.rb

@@ -0,0 +1,19 @@
+require_relative "../../../../lib/zulip"
+require 'helper'
+
+module Zulip
+  class Client
+    describe EventParser do
+      it "parses message events" do
+        event_hash = parsed_json_fixture("get-message-event-success.json")['events'].first
+        result = Zulip::Client::EventParser.parse(event_hash)
+        expect(result).to be_kind_of Zulip::Message
+      end
+
+      it "parses heartbeat events"
+      it "parses presence events"
+      it "parses subscriptions events"
+      it "parses error events"
+    end
+  end
+end

data/spec/lib/zulip/client/event_streaming_spec.rb

@@ -0,0 +1,85 @@
+require 'helper'
+require_relative "../../../../lib/zulip"
+
+class ExitStreamingGracefullyError < StandardError; end
+
+module Zulip
+  class Client
+    describe EventStreaming do
+      let(:private_message_fixture) { fixture("get-private-message.json") }
+      let(:public_message_fixture) { fixture("get-message-event-success.json") }
+
+      context "streaming messages" do
+
+        let(:client) { Zulip::Client.new }
+        let(:fake_connection) { double("fake connection", :params= => nil) }
+        let(:fake_response) { double("response") }
+        let(:fake_queue) { double("fake queue", queue_id: "id", last_event_id: -1) }
+
+        describe "#stream_private_messages" do
+          it "returns private messages viewable to the bot" do
+
+            # Returns a public-message, then a private message
+            fake_response.stub(:body).and_return(public_message_fixture, private_message_fixture)
+            fake_connection.stub(:get).with('/v1/events').and_return(fake_response)
+            client.stub(:register).and_return(fake_queue)
+
+            client.connection = fake_connection
+
+            messages = []
+            begin
+              client.stream_private_messages do |msg|
+                messages << msg
+                raise ExitStreamingGracefullyError if messages.count == 2
+              end
+            rescue ExitStreamingGracefullyError
+              messages.each { |msg| expect(msg.type).to eq("private") }
+            end
+          end
+        end
+
+        describe "#stream_public_messages" do
+          it "only returns public messages" do
+            fake_response.stub(:body).and_return(private_message_fixture, public_message_fixture)
+            fake_connection.stub(:get).with('/v1/events').and_return(fake_response)
+            client.stub(:register).and_return(fake_queue)
+
+            client.connection = fake_connection
+
+            messages = []
+            begin
+              client.stream_public_messages do |msg|
+                messages << msg
+                raise ExitStreamingGracefullyError if messages.count == 1
+              end
+            rescue ExitStreamingGracefullyError
+              messages.each { |msg| expect(msg.type).to eq("stream") }
+            end
+          end
+        end
+
+        describe "#stream_messages" do
+          it "streams both public and private messages" do
+            fake_response.stub(:body).and_return(public_message_fixture, private_message_fixture)
+            fake_connection.stub(:get).with('/v1/events').and_return(fake_response)
+            client.stub(:register).and_return(fake_queue)
+
+            client.connection = fake_connection
+
+            messages = []
+            begin
+              client.stream_messages do |msg|
+                messages << msg
+                raise ExitStreamingGracefullyError if messages.count == 2
+              end
+            rescue ExitStreamingGracefullyError
+              expect(messages.first.type).to eq "stream"
+              expect(messages.last.type).to eq "private"
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/lib/zulip/client/messages_spec.rb

@@ -0,0 +1,64 @@
+require 'helper'
+require_relative "../../../../lib/zulip"
+
+module Zulip
+  class Client
+    describe Messages do
+      it "posts a message to a stream" do
+        subject = "sending some internet websites to the internet"
+        content = "Hey, I found this on the internet: http://nbapaintings.blogspot.com/"
+        stream = "test-stream"
+
+        client = Zulip::Client.new
+        fake_response = fixture("post-message-to-stream.json")
+        fake_connection = double("fake connection", post: fake_response )
+        client.connection = fake_connection
+
+        fake_connection.should_receive(:params=).with({"type"=>"stream", "content"=>content,
+                                                       "to" => json_encode_list(stream),
+                                                       "subject"=>subject})
+
+        fake_connection.should_receive(:post).with("v1/messages")
+        client.send_message(subject, content, stream)
+      end
+
+      it "sends private messages to a single user" do
+        content = "Hi, I heard you like the internet. Here: http://en.wikipedia.org/wiki/Zebroid"
+        recipient  = "internet_cat@example.com"
+
+        client = Zulip::Client.new
+
+        fake_response = fixture("sending-private-message-success.json")
+        fake_connection = double("fake connection", post: fake_response )
+        client.connection = fake_connection
+
+        fake_connection.should_receive(:params=).with({"type"=>"private", "content"=>content,
+                                                       "to" => json_encode_list(recipient)})
+        fake_connection.should_receive(:post).with("v1/messages")
+        client.send_private_message(content, recipient)
+      end
+
+      it "sends private messages to multiple users" do
+
+        content = 'testing private messages to multiple users'
+        recipients = ["bob@gmail.com", "alice@gmail.com"]
+
+        client = Zulip::Client.new
+
+        fake_response = fixture("sending-private-message-success.json")
+        fake_connection = double("fake connection", post: fake_response )
+        client.connection = fake_connection
+
+        fake_connection.should_receive(:params=).with({"type"=>"private", "content"=>content,
+                                                       "to" => json_encode_list(recipients)})
+        fake_connection.should_receive(:post).with("v1/messages")
+
+        client.send_private_message(content, recipients)
+      end
+
+      def json_encode_list(item)
+        JSON.generate(Array(item).flatten)
+      end
+    end
+  end
+end

data/spec/lib/zulip/client/queue_registration_spec.rb

@@ -0,0 +1,44 @@
+require 'helper'
+require_relative "../../../../lib/zulip"
+
+module Zulip
+  class Client
+    describe QueueRegistration do
+      describe "registering a queue to stream messages" do
+        context "with an event type of messages" do
+          it "posts to the register api" do
+            fake_connection = double("fake connection")
+            fake_response = double("response", body: fixture("queue-registration-success.json"))
+            fake_connection.stub(:post).with("v1/register").and_return(fake_response)
+
+            client = Zulip::Client.new
+            client.connection = fake_connection
+
+            fake_connection.should_receive(:params=).with( { "event_types" => '["message"]' } )
+            fake_connection.should_receive(:post).with("v1/register")
+
+            stream_type = :message
+            client.register(stream_type)
+          end
+
+          it "returns an object with the queue's id and last event id" do
+            fake_response = double("response", body: fixture("queue-registration-success.json"))
+            fake_connection = double("fake connection", :params= => nil )
+            fake_connection.stub(:post).with("v1/register").and_return(fake_response)
+
+            client = Zulip::Client.new
+            client.connection = fake_connection
+
+            the_expected_queue_id = "1384438093:1161"
+            the_expected_last_event_id = -1
+            stream_type = :message
+            response = client.register(stream_type)
+
+            expect(response.queue_id).to eq the_expected_queue_id
+            expect(response.last_event_id).to eq the_expected_last_event_id
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/zulip/client/stream_subscriptions_spec.rb

@@ -0,0 +1,42 @@
+require 'helper'
+require_relative "../../../../lib/zulip"
+
+module Zulip
+  class Client
+    describe StreamSubscriptions do
+      describe "#get_subscriptions" do
+        it "returns the bot's stream subscriptions" do
+          fake_http_response = double("fake http response",
+                                      body: fixture("get-user-subscriptions.json"))
+          fake_connection = double("fake connection", get: fake_http_response)
+
+          client = Zulip::Client.new
+          client.connection = fake_connection
+
+          subscriptions = client.get_subscriptions
+          expect(subscriptions.first).to be_a Zulip::StreamSubscription
+          expect(subscriptions.last).to be_a Zulip::StreamSubscription
+        end
+      end
+
+      describe "#subscribe" do
+        it "sends a PATCH message to subscribe the user to a stream" do
+          fake_http_response = double("fake response",
+                                      body: fixture("add-subscription.json"))
+          fake_connection = double("fake connection", patch: fake_http_response)
+
+          client = Zulip::Client.new
+          client.connection = fake_connection
+
+          expected_params = ["v1/users/me/subscriptions",
+                             {:add=>"[{\"name\":\"clojure\"},{\"name\":\"ruby\"}]"}]
+          fake_connection.should_receive(:patch).with(*expected_params)
+
+          streams = ["clojure", "ruby"]
+          client.subscribe(streams)
+        end
+      end
+
+    end
+  end
+end

data/spec/lib/zulip/client/users_spec.rb

@@ -0,0 +1,24 @@
+require 'helper'
+require_relative "../../../../lib/zulip"
+
+module Zulip
+  class Client
+    describe Users do
+      describe "get_users" do
+        it "returns users in the bot's realm" do
+
+          fake_http_response = double("fake http response", body: fixture("get-users.json"))
+          fake_connection = double("fake connection", get: fake_http_response)
+
+          client = Zulip::Client.new
+          client.connection = fake_connection
+
+          users = client.get_users
+          expect(users.first).to be_kind_of Zulip::User
+          expect(users.last).to be_kind_of Zulip::User
+        end
+      end
+
+    end
+  end
+end

data/spec/lib/zulip/client_spec.rb

@@ -0,0 +1,16 @@
+require_relative "../../../lib/zulip"
+
+describe Zulip::Client do
+  describe "configuration" do
+    it "yields itself upon initialization for configuration" do
+
+      client = Zulip::Client.new do |config|
+        config.bot_email_address = "bot@example.com"
+        config.api_key = "apikey"
+      end
+
+      expect(client.bot_email_address).to eq "bot@example.com"
+      expect(client.api_key).to eq "apikey"
+    end
+  end
+end

data/spec/lib/zulip/message_spec.rb

@@ -0,0 +1,79 @@
+require_relative "../../../lib/zulip"
+
+module Zulip
+  describe Message do
+    let(:message_data) { {
+      "recipient_id"=>23442,
+      "sender_email"=>"ryanvergeront@gmail.com",
+      "timestamp"=>1384460690,
+      "display_recipient"=>"test-stream",
+      "sender_id"=>2874,
+      "sender_full_name"=>"Ryan Vergeront (F'13)",
+      "sender_domain"=>"students.hackerschool.com",
+      "content"=>"register an event type of 'message' not 'messages'",
+      "gravatar_hash"=>"a8e2e659c929c79669f97603bd73fcc5",
+      "avatar_url"=>
+      "https://secure.gravatar.com/avatar/a8e2e659c929c79669f97603bd73fcc5?d=identicon",
+        "client"=>"desktop app Mac 0.3.10",
+        "content_type"=>"text/x-markdown",
+        "subject_links"=>[],
+        "sender_short_name"=>"ryanvergeront",
+        "type"=>"stream",
+        "id"=>12791579,
+        "subject"=>"sending some internet websites to the internet" } }
+
+    it "implements attr_readers for it's attributes" do
+      message = Message.new(message_data)
+      expect(message.sender_email).to eq "ryanvergeront@gmail.com"
+
+      message_data.keys.each do |name|
+        return_value = message.send(name.to_sym)
+        expect(return_value).not_to be_nil
+      end
+      expect(message.stream).to eq "test-stream"
+    end
+
+    let(:pm_data) { {"recipient_id"=>25104,
+                  "sender_email"=>"test_zulip_cli-bot@students.hackerschool.com",
+                  "timestamp"=>1384536182,
+                  "display_recipient"=>
+    [{"domain"=>"students.hackerschool.com",
+      "short_name"=>"ryanvergeront",
+      "email"=>"ryanvergeront@gmail.com",
+      "full_name"=>"Ryan Vergeront (F'13)",
+      "id"=>2874},
+      {"full_name"=>"Ryan's Bot",
+       "domain"=>"students.hackerschool.com",
+       "email"=>"test_zulip_cli-bot@students.hackerschool.com",
+       "short_name"=>"test_zulip_cli-bot",
+       "id"=>2934}],
+       "sender_id"=>2934,
+       "sender_full_name"=>"Ryan's Bot",
+       "sender_domain"=>"students.hackerschool.com",
+       "content"=>
+    "Ryan Vergeront (F'13), posted to test-stream:\n sending some internet websites to the internet: :)",
+      "gravatar_hash"=>"9edc706c9ea089025a4bede65630866b",
+      "avatar_url"=>
+    "https://secure.gravatar.com/avatar/9edc706c9ea089025a4bede65630866b?d=identicon",
+      "client"=>"API",
+      "content_type"=>"text/x-markdown",
+      "subject_links"=>[],
+      "sender_short_name"=>"test_zulip_cli-bot",
+      "type"=>"private",
+      "id"=>12836310,
+      "subject"=>""} }
+
+    it "works for private messages" do
+      pm = Message.new(pm_data)
+      expect(pm.display_recipients).to be_a(Array)
+
+      pm_data.each do |name, value|
+        unless value.class == Array
+          return_value = pm.send(name.to_sym)
+          expect(return_value).not_to be_nil
+        end
+      end
+
+    end
+  end
+end

data/spec/lib/zulip/stream_subscription_spec.rb

@@ -0,0 +1,21 @@
+require_relative "../../../lib/zulip"
+
+module Zulip
+  describe StreamSubscription do
+    let(:data) { { "name"=>"VIM",
+                   "color"=>"#76ce90",
+                   "notifications"=>false,
+                   "subscribers"=>["bob@example.com", "alice@example.com"],
+                   "invite_only"=>false,
+                   "email_address"=>"VIM@streams.zulip.com",
+                   "in_home_view"=>true } }
+
+    it "has attrs" do
+      subscription = StreamSubscription.new(data)
+      data.each do |key, value|
+        expect(subscription.send(key)).to eq value
+      end
+    end
+
+  end
+end

data/spec/lib/zulip/user_spec.rb

@@ -0,0 +1,17 @@
+require_relative "../../../lib/zulip"
+
+module Zulip
+  describe User do
+    it "has an email" do
+      data = {"email"=>"bob@example.org","full_name"=>"Bob G"}
+      user = User.new(data)
+      expect(user.email).to eq "bob@example.org"
+    end
+
+    it "has a full name" do
+      data = {"email"=>"bob@example.org","full_name"=>"Bob G"}
+      user = User.new(data)
+      expect(user.full_name).to eq "Bob G"
+    end
+  end
+end

data/zulip-rb.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'zulip/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "zulip"
+  spec.version       = Zulip::VERSION
+  spec.authors       = ["Ryan Vergeront"]
+  spec.email         = ["ryan.vergeront@gmail.com"]
+  spec.description   = %q{A ruby wrapper for the Zulip API.}
+  spec.summary       = spec.description
+  spec.homepage      = "https://github.com/verg/zulip-rb"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency('faraday', ['>= 0.7', '< 0.9'])
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency('rspec', '~> 2.4')
+  spec.add_development_dependency "pry"
+
+end

metadata

@@ -0,0 +1,177 @@
+--- !ruby/object:Gem::Specification
+name: zulip
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ryan Vergeront
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0.7'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0.7'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A ruby wrapper for the Zulip API.
+email:
+- ryan.vergeront@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- example/zulip_message_echo.rb
+- lib/zulip.rb
+- lib/zulip/client.rb
+- lib/zulip/client/event_parser.rb
+- lib/zulip/client/event_streaming.rb
+- lib/zulip/client/messages.rb
+- lib/zulip/client/queue_registration.rb
+- lib/zulip/client/stream_subscriptions.rb
+- lib/zulip/client/users.rb
+- lib/zulip/message.rb
+- lib/zulip/stream_subscription.rb
+- lib/zulip/user.rb
+- lib/zulip/version.rb
+- spec/fixtures/add-subscription.json
+- spec/fixtures/get-message-event-success.json
+- spec/fixtures/get-private-message.json
+- spec/fixtures/get-user-subscriptions.json
+- spec/fixtures/get-users.json
+- spec/fixtures/post-message-to-stream.json
+- spec/fixtures/queue-registration-success.json
+- spec/fixtures/sending-private-message-success.json
+- spec/helper.rb
+- spec/lib/zulip/client/event_parser_spec.rb
+- spec/lib/zulip/client/event_streaming_spec.rb
+- spec/lib/zulip/client/messages_spec.rb
+- spec/lib/zulip/client/queue_registration_spec.rb
+- spec/lib/zulip/client/stream_subscriptions_spec.rb
+- spec/lib/zulip/client/users_spec.rb
+- spec/lib/zulip/client_spec.rb
+- spec/lib/zulip/message_spec.rb
+- spec/lib/zulip/stream_subscription_spec.rb
+- spec/lib/zulip/user_spec.rb
+- zulip-rb.gemspec
+homepage: https://github.com/verg/zulip-rb
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.5
+signing_key: 
+specification_version: 4
+summary: A ruby wrapper for the Zulip API.
+test_files:
+- spec/fixtures/add-subscription.json
+- spec/fixtures/get-message-event-success.json
+- spec/fixtures/get-private-message.json
+- spec/fixtures/get-user-subscriptions.json
+- spec/fixtures/get-users.json
+- spec/fixtures/post-message-to-stream.json
+- spec/fixtures/queue-registration-success.json
+- spec/fixtures/sending-private-message-success.json
+- spec/helper.rb
+- spec/lib/zulip/client/event_parser_spec.rb
+- spec/lib/zulip/client/event_streaming_spec.rb
+- spec/lib/zulip/client/messages_spec.rb
+- spec/lib/zulip/client/queue_registration_spec.rb
+- spec/lib/zulip/client/stream_subscriptions_spec.rb
+- spec/lib/zulip/client/users_spec.rb
+- spec/lib/zulip/client_spec.rb
+- spec/lib/zulip/message_spec.rb
+- spec/lib/zulip/stream_subscription_spec.rb
+- spec/lib/zulip/user_spec.rb