pachube-stream 0.0.3

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,15 @@
+source "http://rubygems.org"
+
+gem "pachube-stream", :path => File.expand_path("..", __FILE__)
+gem "yard"
+
+# These are development dependencies 
+group :test do
+  gem "rake"
+  gem "rspec", "2.5.0"
+  gem "autotest"
+end
+
+gemspec
+
+

data/README.rdoc

@@ -0,0 +1,109 @@
+== PachubeStream
+
+PachubeStream gives you an API for the Pachube TCP Stream using EventMachine
+
+http://api.pachube.com/v2/beta/#tcp-socket-and-websocket-connections
+
+== Quickstart
+  
+  require "pachube-stream"
+  connection = PachubeStream::Connection.connect(:api_key => ENV["PACHUBE_API_KEY"])
+  
+  Look at the examples directory for exactly that!
+  
+== Connection Methods
+
+The methods on the connection are what Pachube look for when making a request; this in-turn will 
+generate the correct method value in the 'http json'
+
+=== Example
+  connection = PachubeStream::Connection.connect(:api_key => ENV["PACHUBE_API_KEY"])
+  request = connection.subscribe("/feeds/504")
+  
+  Results In the following JSON request
+
+  {
+    "method" : "subscribe",
+    "resource" : "/feeds/504",
+    "headers" :
+      {
+        "X-PachubeApiKey" : "API_KEY"
+      },
+    "token" : "subscribe"
+  }
+  
+
+=== Subscribe
+  
+  connection = PachubeStream::Connection.connect(:api_key => ENV["PACHUBE_API_KEY"])
+  request = connection.subscribe("/feeds/504")
+  request.on_datastream do |response|
+    puts response
+  end
+
+=== Unsubscribe
+
+  connection = PachubeStream::Connection.connect(:api_key => ENV["PACHUBE_API_KEY"])
+  request = connection.unsubscribe("/feeds/504")
+  request.on_compelete do |response|
+    puts response
+  end
+
+=== Get
+
+  connection = PachubeStream::Connection.connect(:api_key => ENV["PACHUBE_API_KEY"])
+  request = connection.get("/feeds/504")
+  request.on_get do |response|
+    puts response
+  end
+
+=== Put
+
+  connection = PachubeStream::Connection.connect(:api_key => ENV["PACHUBE_API_KEY"])
+  request = connection.put("/feeds/504")
+  request.on_complete do |response|
+    puts response
+  end
+  
+=== Delete
+
+  connection = PachubeStream::Connection.connect(:api_key => ENV["PACHUBE_API_KEY"])
+  request = connection.delete("/feeds/504")
+  request.on_complete do |response|
+    puts response
+  end
+
+=== Post
+
+  connection = PachubeStream::Connection.connect(:api_key => ENV["PACHUBE_API_KEY"])
+  request = connection.post("/feeds/504")
+  request.on_complete do |response|
+    puts response
+  end
+
+
+The way we make a request is to send json in the format of a HTTP request; you only have
+to give extra options when you want to provide your own headers, params and body etc;
+
+Therefore when using the connection Methods
+
+When can create this 'http json request' with PachubeStream::HttpRequest passing in a hash
+  
+  connection = PachubeStream::Connection.connect(:api_key => ENV["PACHUBE_API_KEY"])
+  request = connection.put("/feeds/504", PachubeStream::HttpRequest.new(:body => {}, :params => {}, :headers => {}))
+  
+  request.on_complete do |response|
+    puts response
+  end
+
+== Defaults:
+
+When creating a connection you can specify the host and port these have defaults
+
+    host                       # => beta.pachube.com
+    port                       # => 8081
+    
+
+== Respect
+
+Respect goes out to the twitter-stream Gem as one took some concepts form that; nice!

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/autotest/discover.rb

@@ -0,0 +1 @@
+Autotest.add_discovery { ["rspec2"] }

data/examples/subscribe.rb

@@ -0,0 +1,32 @@
+$: << 'lib' << '../lib'
+require 'rubygems'
+require 'eventmachine'
+require '../lib/pachube-stream'
+
+EM.run do
+  connection = PachubeStream::Connection.connect(:api_key => ENV["PACHUBE_API_KEY"])
+  
+  connection.on_reconnect do |timeout, reconnect_retries|
+    puts timeout
+    puts reconnect_retries
+  end
+  
+  connection.on_max_reconnects do |timeout, reconnect_retries|
+    puts timeout
+    puts reconnect_retries
+  end
+  
+  feed = connection.subscribe("/feeds/6643") # random Feed  
+  
+  feed.on_datastream do |response|
+    puts response
+  end
+  
+  feed.on_complete do |response|
+    puts response
+  end
+  
+  feed.on_error do |response|
+    puts response
+  end
+end

data/lib/pachube-stream/client.rb

@@ -0,0 +1,80 @@
+module PachubeStream
+  class Client
+        
+    # @param [EventMachine::Connection] conn
+    # @param [String] api_key
+    # @param [Hash] options defaults {}
+    def initialize(conn, api_key, options = {})
+      @conn = conn
+      @api_key = api_key
+      @options = options
+      @requests = {}
+    end
+    
+    # @param [String] response
+    #
+    # @return [Hash]
+    # @todo refactor ugly as Sin
+    def process_data(response)
+      parsed_response = parse_response(response)
+      status_ok = parsed_response["status"] && parsed_response["status"] != 200
+      if request = @requests[parsed_response["token"]]
+        if status_ok
+          call_block_for_request(request, parsed_response)
+        else
+          call_error_for_request_block(request, parsed_response)
+        end
+      else
+        if status_ok
+          @conn.on_response_block.call(parsed_response) if @conn.on_response_block 
+        else
+          receive_error(parsed_response)
+        end
+      end
+    end
+    
+    # @param [String] response
+    #
+    # @return [Hash]
+    def parse_response(response)
+      begin
+        Yajl::Parser.parse(response)
+      rescue Exception => e
+        receive_error("#{e.class}: " + [e.message, e.backtrace].flatten.join("\n\t"))
+        @conn.close_connection
+        return
+      end
+    end
+    
+    def receive_error(error)
+      @conn.on_error_block.call(error) if @conn.on_error_block
+    end
+    
+    # we send the request and also keep the request with the token
+    # as its key so we can attach callback to requests
+    def send_request(method, resource, html_request = {}, token = nil, &block)
+      @request = Request.new(@api_key, method, resource, html_request, token)
+      @requests[@request.token] = @request
+      @conn.send_data(@request.to_json)
+      @request
+    end
+            
+    # finds the correct callback based on the token which
+    # has the method call in its sig
+    def call_block_for_request(request, parsed_response)
+      case request.token.gsub(/:.*/, "")
+      when "subscribe" && !parsed_response["body"].nil?
+        request.on_datastream_block.call(parsed_response) if request.on_datastream_block
+      when "get" && !parsed_response["body"].nil?
+        request.on_get_block.call(parsed_response) if request.on_get_block
+      else
+        request.on_complete_block.call(parsed_response) if request.on_complete_block
+      end
+    end
+    
+    def call_error_for_request_block(request, parsed_response)
+      request.on_error_block.call(parsed_response) if request.on_error_block
+    end
+  
+  end
+end

data/lib/pachube-stream/connection.rb

@@ -0,0 +1,117 @@
+module PachubeStream
+  class Connection < EventMachine::Connection
+    include RequestMethods
+    
+    NF_RECONNECT_START = 0.25
+    NF_RECONNECT_ADD   = 0.25
+    NF_RECONNECT_MAX   = 16
+    RECONNECT_MAX   = 320
+    RETRIES_MAX     = 10
+    
+    attr_accessor :options, :on_init_callback, :api_key, :on_response_block, :on_error_block
+    attr_accessor :reconnect_callback, :max_reconnects_callback, :nf_last_reconnect, :reconnect_retries
+    
+    # @todo tidy as crap
+    def self.connect(options = {})
+      api_key = options[:api_key]
+      raise ArgumentError.new("You need to supply an API Key") unless api_key
+      host = options[:host] || "beta.pachube.com"
+      port = options[:port] || 8081
+      EventMachine.connect host, port, self, options
+      rescue EventMachine::ConnectionError => e
+        conn = EventMachine::FailedConnection.new(req)
+        conn.error = e.message
+        conn.fail
+        conn
+    end
+    
+    def initialize(options)
+      @options = options
+      @api_key = options[:api_key]
+      @timeout = options[:timeout] || 0
+      @reconnect_retries = 0
+      @immediate_reconnect = false
+    end
+    
+    def client
+      @client ||= PachubeStream::Client.new(self, @api_key, @options)
+    end
+      
+    def post_init
+      set_comm_inactivity_timeout @timeout if @timeout > 0
+      @on_inited_callback.call if @on_inited_callback
+    end
+        
+    def on_reconnect(&block)
+      @reconnect_callback = block
+    end
+
+    def on_max_reconnects(&block)
+      @max_reconnects_callback = block
+    end
+    
+    def on_response_block(&block)
+      @on_response_block = block
+    end
+    
+    def on_error_block(&block)
+      @on_error_block = block
+    end
+
+    def stop
+      @gracefully_closed = true
+      close_connection
+    end
+
+    def immediate_reconnect
+      @immediate_reconnect = true
+      @gracefully_closed = false
+      close_connection
+    end
+
+    def unbind
+      schedule_reconnect unless @gracefully_closed
+    end
+
+    def receive_data(response)
+      client.process_data(response)
+    end
+
+    protected
+    def schedule_reconnect
+      timeout = reconnect_timeout
+      @reconnect_retries += 1
+      if (timeout <= RECONNECT_MAX) && (@reconnect_retries <= RETRIES_MAX)
+        reconnect_after(timeout)
+      else
+        @max_reconnects_callback.call(timeout, @reconnect_retries) if @max_reconnects_callback
+      end
+    end
+
+    def reconnect_after(timeout)
+      @reconnect_callback.call(timeout, @reconnect_retries) if @reconnect_callback
+
+      if timeout == 0
+        reconnect @options[:host], @options[:port]
+      else
+        EventMachine.add_timer(timeout) do
+          reconnect @options[:host], @options[:port]
+        end
+      end
+    end
+
+    def reconnect_timeout
+      if @immediate_reconnect
+        @immediate_reconnect = false
+        return 0
+      end
+      if @nf_last_reconnect
+        @nf_last_reconnect += NF_RECONNECT_ADD
+      else
+        @nf_last_reconnect = NF_RECONNECT_START
+      end
+      [@nf_last_reconnect, NF_RECONNECT_MAX].min
+    end
+    
+  end
+end

data/lib/pachube-stream/html_request.rb

@@ -0,0 +1,15 @@
+module PachubeStream
+  class HtmlRequest < Hashie::Dash
+  
+    property :resource
+    property :method
+    property :headers, :default => {}
+    property :token
+    property :body
+    property :params
+  
+    def api_key=(api_key)
+      headers["X-PachubeApiKey"] = api_key
+    end
+  end
+end

data/lib/pachube-stream/methods.rb

@@ -0,0 +1,29 @@
+module PachubeStream
+  module RequestMethods
+    
+    def get(resource, html_request = {}, token = nil, &block)
+      client.send_request(:get, resource,  html_request = {}, token, &block)
+    end
+    
+    def post(resource, html_request = {}, token  = nil, &block)
+      client.send_request(:post, resource,  html_request = {}, token, &block)
+    end
+    
+    def put(resource, html_request = {}, token = nil, &block)
+      client.send_request(:put, resource, html_request = {}, token, &block)
+    end
+    
+    def delete(resource,html_request = {}, token= nil, &block)
+      client.send_request(:delete, resource, html_request = {}, token, &block)
+    end
+    
+    def subscribe(resource, html_request = {}, token  = nil, &block)
+      client.send_request(:subscribe, resource, html_request = {}, token, &block)
+    end
+    
+    def unsubsribe(resource, html_request = {}, token = nil, &block)
+      client.send_request(:unsubsribe, resource, html_request = {}, token, &block)
+    end
+
+  end
+end

data/lib/pachube-stream/request.rb

@@ -0,0 +1,51 @@
+module PachubeStream
+  class Request
+    
+    attr_accessor :on_complete_block, :on_datastream_block, :request, :token, :method, :on_error_block, :on_get_block
+    
+    # @param[String] method
+    # @param[String] html this means headers and body and resource and params
+    # @param[String] token if you wanted to send a specific token
+    def initialize(api_key, method, resource, html_request, token = nil)
+      @api_key = api_key
+      @method = method
+      @resource = resource
+      @html_request = html_request
+      @token = token || generate_token(method)
+      generate_html_request(api_key, method, resource, html_request, @token)
+    end
+    
+    def on_complete(&block)
+      @on_complete_block = block
+    end
+    
+    def on_datastream(&block)
+      @on_datastream_block = block
+    end
+    
+    def on_error(&block)
+      @on_error_block = block
+    end
+    
+    def on_get(&block)
+      @on_get_block = block
+    end
+    
+    def to_json
+      @request.to_json
+    end
+        
+    protected 
+    def generate_token(method)
+      "#{method}:#{UUID.generate}"
+    end
+    
+    def generate_html_request(api_key, method, resource, html_request, token)
+      @request = HtmlRequest.new(html_request)
+      @request.api_key = api_key
+      @request[:method] = method
+      @request[:resource] = resource
+      @request[:token] = token
+    end
+  end
+end

data/lib/pachube-stream/version.rb

@@ -0,0 +1,3 @@
+module PachubeStream
+  VERSION = "0.0.3"
+end

data/lib/pachube-stream.rb

@@ -0,0 +1,15 @@
+module PachubeStream
+end
+
+require 'eventmachine'
+require 'addressable/uri'
+require "hashie"
+require 'yajl'
+require 'json'
+require 'uuid'
+require 'pachube-stream/methods'
+require 'pachube-stream/connection'
+require 'pachube-stream/client'
+require 'pachube-stream/request'
+require 'pachube-stream/html_request'
+

data/pachube-stream.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "pachube-stream/version"
+
+Gem::Specification.new do |s|
+  s.name        = "pachube-stream"
+  s.version     = PachubeStream::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Hookercookerman"]
+  s.email       = ["hookercookerman@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Pachube TCP streaming API}
+  s.description = %q{Simple Ruby client library for pachube TCP streaming API. Uses EventMachine for connection handling.JSON format only.}
+
+  s.rubyforge_project = "pachube-stream"
+  
+  s.add_dependency "eventmachine", ">= 1.0.0.beta.3"
+  s.add_dependency "addressable", ">= 2.2.3"
+  s.add_dependency "hashie", ">= 0.5.1"
+  s.add_dependency 'yajl-ruby', '~> 0.8.2'
+  s.add_dependency 'uuid', '~> 2.3.2'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/fixtures/pachube/not_authorized.json

@@ -0,0 +1,6 @@
+{
+  "body":"Forbidden: You are not authorized",
+  "resource":"/feeds/664334434",
+  "token":"subscribe:df279110-4d78-012e-e33e-002332cf7bbe",
+  "status":403
+}

data/spec/fixtures/pachube/subscribe.json

@@ -0,0 +1,5 @@
+{
+    "resource":"/feeds/6643",
+    "token":"subscribe:a06d6f30-4d78-012e-e33d-002332cf7bbe",
+    "status":200
+}

data/spec/fixtures/pachube/subscribe_data_stream.json

@@ -0,0 +1,64 @@
+{
+    "body":
+    {
+        "location":
+        {
+            "lon":-0.0215005874633789,
+            "domain":"physical",
+            "disposition":"fixed",
+            "exposure":"indoor",
+            "lat":51.4722148395794
+        },
+        "title":"CurrentCost meter",
+        "datastreams":
+        [
+            {
+                "current_value":"32.2",
+                "max_value":"32.3",
+                "min_value":"9.3",
+                "id":"0",
+                "tags":
+                [
+                    "celsius",
+                    "degrees",
+                    "temperature"
+                ],
+                "unit":
+                {
+                    "label":"Celsius",
+                    "symbol":"C",
+                    "type":"basicSI"
+                },
+                "at":"2011-04-20T12:35:42.653484Z"
+            },
+            {
+                "current_value":"309.0",
+                "max_value":"12675.0",
+                "min_value":"24.0",
+                "id":"1",
+                "tags":
+                [
+                    "electricity",
+                    "power",
+                    "watts"
+                ],
+                "unit":
+                {
+                    "label":"Watts",
+                    "symbol":"W",
+                    "type":"derivedSI"
+                },
+                "at":"2011-04-20T12:35:42.653484Z"
+            }
+        ],
+        "creator":"http://www.pachube.com/users/sc84647",
+        "private":"false",
+        "id":6643,
+        "version":"1.0.0",
+        "updated":"2011-04-20T12:35:42.653484Z",
+        "status":"live",
+        "feed":"http://api.pachube.com/v2/feeds/6643.json"
+    },
+    "resource":"/feeds/6643",
+    "token":"subscribe:a06d6f30-4d78-012e-e33d-002332cf7bbe"
+}

data/spec/fixtures/pachube/subscribe_request.json

@@ -0,0 +1,9 @@
+{
+    "headers":
+    {
+        "X-PachubeApiKey":"testing"
+    },
+    "method":"subscribe",
+    "resource":"/feeds/100",
+    "token":"token"
+}

data/spec/pachube_spec.rb

@@ -0,0 +1,106 @@
+# encoding: utf-8
+require File.expand_path("../spec_helper", __FILE__)
+
+describe "Pachube" do
+  context "on connection" do
+    it "should return stream" do
+      EM.should_receive(:connect).and_return('TESTING CONNECT')
+      stream = PachubeStream::Connection.connect(:api_key => "Testing")
+      stream.should == 'TESTING CONNECT'
+    end
+    
+    it "should define default properties" do
+      EM.should_receive(:connect).with do |host, port, handler, opts|
+        host.should == 'beta.pachube.com'
+        port.should == 8081
+      end
+      stream = PachubeStream::Connection.connect(:api_key => "Testing")
+    end
+  end
+  
+  context "Connection #subscribe" do
+    attr_reader :stream
+    before(:each) do
+      $data_to_send = read_fixture('pachube/subscribe.json')
+      $recieved_data = ''
+      $close_connection = false
+    end
+    
+    it "should send the 'http_request json request' with the method subscribe'" do
+      connect_stream do |connection|
+        connection.subscribe("/feeds/100", {}, "token")
+      end
+      Yajl::Parser.parse($recieved_data).should == Yajl::Parser.parse(read_fixture('pachube/subscribe_request.json'))
+    end
+    
+    it "should capture response to the on_compelete as that is not a datastream response" do
+      connect_stream do |connection|
+        subscription = connection.subscribe("/feeds/100", {}, "subscribe:a06d6f30-4d78-012e-e33d-002332cf7bbe")
+        subscription.on_complete do |response|
+          $data_to_send = read_fixture('pachube/subscribe_data_stream.json')
+          response.should eq(Yajl::Parser.parse(read_fixture('pachube/subscribe.json')))
+        end
+      end
+    end
+    
+    it "should send capture response on_datastream for datastream" do
+      $data_to_send = read_fixture('pachube/subscribe_data_stream.json')
+      connect_stream do |connection|
+        subscription = connection.subscribe("/feeds/100", {}, "subscribe:a06d6f30-4d78-012e-e33d-002332cf7bbe")
+        subscription.on_datastream do |response|
+          response.should eq(Yajl::Parser.parse(read_fixture('pachube/subscribe_data_stream.json')))
+        end
+      end
+    end
+    
+    it "should capture to the on_error for the request when status code other then 200" do
+      $data_to_send = read_fixture('pachube/not_authorized.json')
+      connect_stream do |connection|
+        subscription = connection.subscribe("/feeds/100", {}, "subscribe:a06d6f30-4d78-012e-e33d-002332cf7bbe")
+        subscription.on_error do |response|
+          response.should eq(Yajl::Parser.parse(read_fixture('pachube/not_authorized.json')))
+        end
+      end
+    end
+  end
+  
+  context "network failure" do
+    before(:each) do
+      $close_connection = true
+      $data_to_send = ''
+    end
+    
+    it "should reconnect with 0.25 at base"  do
+      connect_stream do |connection|
+        connection.should_receive(:reconnect_after).with(0.25)
+      end
+    end
+    
+    it "should reconnect with linear timeout" do
+      connect_stream do |connection|
+        connection.nf_last_reconnect = 1
+        connection.should_receive(:reconnect_after).with(1.25)
+      end
+    end
+  
+    it "should stop reconnecting after 100 times" do
+      connect_stream do |connection|
+        connection.reconnect_retries = 100
+        connection.should_not_receive(:reconnect_after)
+      end
+    end
+  
+    it "should notify after reconnect limit is reached" do
+      timeout, retries = nil, nil
+      connect_stream do |connection|
+        connection.on_max_reconnects do |t, r|
+          timeout, retries = t, r
+        end
+        connection.reconnect_retries = 100
+      end
+      timeout.should == 0.25
+      retries.should == 101
+    end    
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,51 @@
+require 'rubygems'
+require "bundler"
+Bundler.setup
+
+require "pachube-stream"
+Bundler.require(:test)
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+
+def fixture_path(path)
+  File.join(File.dirname(__FILE__), 'fixtures', path)
+end
+
+def read_fixture(path)
+  File.read(fixture_path(path))
+end
+
+Host = "127.0.0.1"
+Port = 9550
+
+# == What would be awsome to capture the response tcpdump or something and the replay
+class PachubeServer < EM::Connection
+  attr_accessor :data
+  def receive_data data
+    $recieved_data = data
+    send_data $data_to_send
+    EventMachine.next_tick {
+      close_connection if $close_connection
+    }
+  end
+end
+
+def connect_stream(opts={}, &blk)
+  EM.run {
+    opts.merge!(:host => Host, :port => Port)
+    stop_in = opts.delete(:stop_in) || 0.5
+    unless opts[:start_server] == false
+      EM.start_server Host, Port, PachubeServer
+    end
+    @stream = PachubeStream::Connection.connect(:api_key => "testing", :host => Host, :port => Port)
+    blk.call(@stream) if blk
+    EM.add_timer(stop_in){ EM.stop }
+  }
+end
+
+Rspec.configure do |config|   
+  config.mock_with :rspec
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+end

metadata

@@ -0,0 +1,165 @@
+--- !ruby/object:Gem::Specification 
+name: pachube-stream
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
+platform: ruby
+authors: 
+- Hookercookerman
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-20 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 0
+        - beta
+        - 3
+        version: 1.0.0.beta.3
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: addressable
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 2
+        - 3
+        version: 2.2.3
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: hashie
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 5
+        - 1
+        version: 0.5.1
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: yajl-ruby
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 8
+        - 2
+        version: 0.8.2
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: uuid
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 3
+        - 2
+        version: 2.3.2
+  type: :runtime
+  version_requirements: *id005
+description: Simple Ruby client library for pachube TCP streaming API. Uses EventMachine for connection handling.JSON format only.
+email: 
+- hookercookerman@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- autotest/discover.rb
+- examples/subscribe.rb
+- lib/pachube-stream.rb
+- lib/pachube-stream/client.rb
+- lib/pachube-stream/connection.rb
+- lib/pachube-stream/html_request.rb
+- lib/pachube-stream/methods.rb
+- lib/pachube-stream/request.rb
+- lib/pachube-stream/version.rb
+- pachube-stream.gemspec
+- spec/fixtures/pachube/not_authorized.json
+- spec/fixtures/pachube/subscribe.json
+- spec/fixtures/pachube/subscribe_data_stream.json
+- spec/fixtures/pachube/subscribe_request.json
+- spec/pachube_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: pachube-stream
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Pachube TCP streaming API
+test_files: 
+- spec/fixtures/pachube/not_authorized.json
+- spec/fixtures/pachube/subscribe.json
+- spec/fixtures/pachube/subscribe_data_stream.json
+- spec/fixtures/pachube/subscribe_request.json
+- spec/pachube_spec.rb
+- spec/spec_helper.rb