nervion 0.0.1

data/lib/nervion/percent_encoder.rb

@@ -0,0 +1,11 @@
+require 'uri'
+
+module Nervion
+  module PercentEncoder
+    RESERVED_CHARACTERS = /[^a-zA-Z0-9\-\.\_\~]/
+
+    def self.encode(value)
+      URI.escape value.to_s, RESERVED_CHARACTERS
+    end
+  end
+end

data/lib/nervion/reconnection_scheduler.rb

@@ -0,0 +1,96 @@
+require 'eventmachine'
+
+module Nervion
+  class ReconnectionScheduler
+    HTTP_ERROR_LIMIT    = 10
+    NETWORK_ERROR_LIMIT = 65
+
+    def initialize
+      @http_errors = ErrorCounter.new(HTTP_ERROR_LIMIT)
+      @network_errors = ErrorCounter.new(NETWORK_ERROR_LIMIT)
+      @http_wait_calculator = HttpWaitCalculator.new
+      @network_wait_calculator = NetworkWaitCalculator.new
+    end
+
+    def reconnect_after_http_error_in(stream)
+      reconnect_after_error stream, @http_errors, @http_wait_calculator
+    end
+
+    def reconnect_after_network_error_in(stream)
+      reconnect_after_error stream, @network_errors, @network_wait_calculator
+    end
+
+    private
+
+    def reconnect_after_error(stream, errors, wait_calculator)
+      errors.notify_error
+      schedule_reconnect stream, wait_calculator.wait_after(errors.count)
+    end
+
+    def schedule_reconnect(stream, seconds)
+      EM.add_timer(seconds) { stream.retry }
+    end
+  end
+
+  class ErrorCounter
+    attr_reader :count
+
+    def initialize(limit)
+      @count = 0
+      @limit = limit
+    end
+
+    def notify_error
+      @count += 1
+      raise TooManyConnectionErrors if too_many_errors?
+    end
+
+    private
+
+    def too_many_errors?
+      @count >= @limit
+    end
+  end
+
+  class WaitCalculator
+    def initialize(max_wait, &calculator)
+      @max_wait = max_wait
+      @calculator = calculator
+    end
+
+    def wait_after(error_count)
+      cap_wait @max_wait, calculate_wait_after(error_count)
+    end
+
+    private
+
+    def cap_wait(cap_value, current_wait)
+      [current_wait, cap_value].min
+    end
+
+    def calculate_wait_after(error_count)
+      @calculator.call(error_count)
+    end
+  end
+
+  class HttpWaitCalculator < WaitCalculator
+    MIN_WAIT = 10
+    MAX_WAIT = 240
+
+    def initialize
+      super(MAX_WAIT) { |error_count| MIN_WAIT * 2**(error_count - 1) }
+    end
+  end
+
+  class NetworkWaitCalculator < WaitCalculator
+    MIN_WAIT = 0.25
+    MAX_WAIT = 16
+
+    def initialize
+      super(MAX_WAIT) { |error_count| MIN_WAIT * error_count }
+    end
+  end
+
+  class TooManyConnectionErrors < Exception
+  end
+end

data/lib/nervion/request.rb

@@ -0,0 +1,99 @@
+require_relative 'oauth_header'
+
+module Nervion
+  def self.get(uri, params = {}, oauth_params)
+    Get.new uri, params, oauth_params
+  end
+
+  def self.post(uri, params = {}, oauth_params)
+    Post.new uri, params, oauth_params
+  end
+
+  module Request
+    attr_reader :params, :oauth_params
+
+    def initialize(uri, params, oauth_params)
+      @uri = URI.parse(uri)
+      @params = params
+      @oauth_params = oauth_params
+    end
+
+    def uri
+      @uri.to_s
+    end
+
+    def path
+      @uri.request_uri
+    end
+
+    def host
+      @uri.host
+    end
+
+    def port
+      @uri.port
+    end
+
+    private
+
+    def request_line
+      "#{http_method} #{path} HTTP/1.1"
+    end
+
+    def headers
+      [ "Host: #{host}", "Authorization: #{OAuthHeader.for(self)}" ]
+    end
+
+    def percent_encode(params)
+      params.map do |name, value|
+        "#{name.to_s}=#{PercentEncoder.encode(value.to_s)}"
+      end.join '&'
+    end
+  end
+
+  class Get
+    include Request
+
+    def path
+      if params.any?
+        "#{super}?#{percent_encode(params)}"
+      else
+        super
+      end
+    end
+
+    def to_s
+      "#{request_line}\r\n#{headers.join("\r\n")}\r\n\r\n"
+    end
+
+    def http_method
+      'GET'
+    end
+  end
+
+  class Post
+    include Request
+    include PercentEncoder
+
+    def to_s
+      "#{request_line}\r\n#{headers.join("\r\n")}\r\n\r\n#{body}\r\n"
+    end
+
+    def http_method
+      'POST'
+    end
+
+    private
+
+    def headers
+      super << [
+        'Content-Type: application/x-www-form-urlencoded',
+        "Content-Length: #{body.length}"
+      ]
+    end
+
+    def body
+      percent_encode params
+    end
+  end
+end

data/lib/nervion/stream.rb

@@ -0,0 +1,64 @@
+require 'eventmachine'
+require 'nervion/http_parser'
+require 'nervion/reconnection_scheduler'
+
+module Nervion
+  class Stream < EM::Connection
+
+    attr_reader :http_error
+
+    def initialize(*args)
+      @request = args[0]
+      @handler = args[1]
+    end
+
+    def post_init
+      @scheduler = ReconnectionScheduler.new
+    end
+
+    def connection_completed
+      start_tls
+      send_data @request
+    end
+
+    def receive_data(data)
+      @handler << data
+    rescue HttpError => error
+      @http_error = error
+    end
+
+    def retry
+      @http_error = nil
+      reconnect @request.host, @request.port
+    end
+
+    def unbind
+      handle_closed_stream unless @handler.stream_close_requested?
+    end
+
+    def http_error_occurred?
+      not http_error.nil?
+    end
+
+    private
+
+    def handle_closed_stream
+      if http_error_occurred?
+        handle_http_error_and_reopen_stream
+      else
+        handle_network_error_and_reopen_stream
+      end
+    end
+
+    def handle_http_error_and_reopen_stream
+      @handler.handle_http_error http_error
+      @scheduler.reconnect_after_http_error_in self
+    end
+
+    def handle_network_error_and_reopen_stream
+      @handler.handle_network_error
+      @scheduler.reconnect_after_network_error_in self
+    end
+
+  end
+end

data/lib/nervion/stream_handler.rb

@@ -0,0 +1,42 @@
+require 'yajl'
+require 'nervion/http_parser'
+
+module Nervion
+  class StreamHandler
+
+    def initialize(callbacks)
+      @callbacks = callbacks
+      @http_parser = HttpParser.new(setup_json_parser)
+    end
+
+    def <<(data)
+      @http_parser << data
+    end
+
+    def handle_http_error(error)
+      @http_parser.reset!
+      @callbacks[:http_error].call(error.status, error.body)
+    end
+
+    def handle_network_error
+      @http_parser.reset!
+      @callbacks[:network_error].call
+    end
+
+    def stream_close_requested?
+      @close_stream ||= false
+    end
+
+    def close_stream
+      @close_stream = true
+    end
+
+    private
+
+    def setup_json_parser
+      Yajl::Parser.new(symbolize_keys: true).tap do |json_parser|
+        json_parser.on_parse_complete = @callbacks[:status]
+      end
+    end
+  end
+end

data/lib/nervion/version.rb

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

data/nervion.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/nervion/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Javier Acero"]
+  gem.email         = ["j4cegu@gmail.com"]
+  gem.description   = %q{A minimalistic Twitter Stream API Ruby client}
+  gem.summary       = %q{}
+  gem.homepage      = "https://github.com/jacegu/nervion"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(spec|features)/})
+  gem.name          = "nervion"
+  gem.require_paths = ["lib"]
+  gem.version       = Nervion::VERSION
+
+  gem.add_runtime_dependency 'eventmachine', '~> 1.0.0.beta.4'
+  gem.add_runtime_dependency 'http_parser.rb', '~> 0.5.3'
+  gem.add_runtime_dependency 'yajl-ruby', '~> 1.1.0'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'cucumber'
+  gem.add_development_dependency 'simplecov'
+end

data/spec/nervion/callback_table_spec.rb

@@ -0,0 +1,18 @@
+require 'nervion/callback_table'
+
+describe Nervion::CallbackTable do
+  it 'can be setup with a callback' do
+    callback = stub(:callback)
+    subject[:name]= callback
+    subject[:name].should be callback
+  end
+
+  it 'has a callback for network errors by default' do
+    subject[:network_error].should_not be_nil
+  end
+
+  it 'has a callback for http errors by default' do
+    STDERR.should_receive(:puts).with(/500|error/)
+    subject[:http_error].call(500, 'error')
+  end
+end

data/spec/nervion/client_spec.rb

@@ -0,0 +1,51 @@
+require 'eventmachine'
+require 'nervion/client'
+
+describe Nervion::Client do
+  subject              { described_class.new('http://twitter.com', 443) }
+  let(:request)        { stub :request }
+  let(:callbacks)      { stub :callbacks }
+  let(:stream_handler) { stub :stream_handler }
+
+  before(:all) do
+    module EventMachine
+      class << self
+        alias old_run run
+        alias old_connect connect
+      end
+      def self.run; yield; end
+      def self.connect(*args); end
+    end
+  end
+
+  after(:all) do
+    module EM
+      class << self
+        alias run old_run
+        alias connect old_connect
+      end
+    end
+  end
+
+  before do
+    Nervion::StreamHandler.stub(:new).with(callbacks).and_return(stream_handler)
+  end
+
+  it 'starts treaming' do
+    EM.should_receive(:connect).with(
+      'http://twitter.com',
+      443,
+      Nervion::Stream,
+      request,
+      stream_handler
+    )
+    subject.stream(request, callbacks)
+  end
+
+  it 'stops streaming' do
+    stream_handler.should_receive(:close_stream).ordered
+    EM.should_receive(:stop).ordered
+    subject.stream(request, callbacks)
+    subject.stop
+  end
+end

data/spec/nervion/configuration_spec.rb

@@ -0,0 +1,58 @@
+require 'nervion/configuration'
+
+describe Nervion::Configuration do
+
+  it 'allows configuration from the top level' do
+    Nervion::Configuration.should_receive(:access_key=).with 'access_key'
+    Nervion.configure { |config| config.access_key = 'access_key' }
+  end
+
+  context 'when it has not been configured' do
+    it 'has an empty string as consumer_key' do
+      described_class.consumer_key.should eq ''
+    end
+
+    it 'has an empty string as consumer secret' do
+      described_class.consumer_secret.should eq ''
+    end
+
+    it 'has an empty string as access token' do
+      described_class.access_token.should eq ''
+    end
+
+    it 'has an empty string as access token secret' do
+      described_class.access_token_secret.should eq ''
+    end
+  end
+
+  context 'configuration' do
+    it 'can be set with the consumer key' do
+      described_class.consumer_key = 'consumer_key'
+      described_class.consumer_key.should eq 'consumer_key'
+    end
+
+    it 'can be set with the consumer secret' do
+      described_class.consumer_secret = 'consumer_secret'
+      described_class.consumer_secret.should eq 'consumer_secret'
+    end
+
+    it 'can be set with the access token' do
+      described_class.access_token = 'access token'
+      described_class.access_token.should eq 'access token'
+    end
+
+    it 'can be set with the access token secret' do
+      described_class.access_token_secret = 'access token secret'
+      described_class.access_token_secret.should eq 'access token secret'
+    end
+  end
+
+  context 'accessing configuration' do
+    it 'settings can de accessed as if it was hash' do
+      described_class.consumer_secret = 'consumer_secret'
+      described_class[:consumer_secret].should eq 'consumer_secret'
+      described_class.fetch(:consumer_secret).should eq 'consumer_secret'
+    end
+  end
+
+end