protolink 0.1.1 → 0.2.0

data/.gitignore

@@ -0,0 +1 @@
+coverage

data/.rvmrc

@@ -0,0 +1 @@
+rvm use ruby-1.8.7@protolink

data/Gemfile

@@ -0,0 +1,8 @@
+source :gemcutter
+
+gem "httparty"
+
+group :test do
+  gem "rake"
+  gem "rcov"
+end

data/Gemfile.lock

@@ -0,0 +1,16 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    crack (0.1.8)
+    httparty (0.7.8)
+      crack (= 0.1.8)
+    rake (0.9.2)
+    rcov (0.9.9)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  httparty
+  rake
+  rcov

data/README.markdown

@@ -9,13 +9,8 @@ Sorry, there are no tests at all yet...
 
 ## Dependencies
 
-    activesupport
-    faraday -v 0.5.1
-    multipart-post
-    mime-types
-    twitter-stream (for streaming listening in future)
-    eventmachine
-
+    httparty
+    crack
 
 ## Usage
 
@@ -25,7 +20,7 @@ Sorry, there are no tests at all yet...
     require 'rubygems'
     require 'protolink'
 
-    protonet = Protolink::Protonet.new('SUBDOMAIN.DOMAIN.DE', 'USERLOGIN', 'PASSWORD', :ssl => false)
+    protonet = Protolink::Protonet.new('HTTP://SUBDOMAIN.DOMAIN.DE', 'USERLOGIN', 'PASSWORD')
     channel  = protonet.channels.first
     channel.speak 'Hello world!'
 
@@ -48,6 +43,15 @@ Sorry, there are no tests at all yet...
     channel.speak 'Hello world!'
 
 
+    # find channel by id
+    require 'rubygems'
+    require 'protolink'
+
+    protonet = Protolink::Protonet.new('SUBDOMAIN.DOMAIN.DE', 'USERLOGIN', 'PASSWORD', :ssl => false)
+    channel  = protonet.find_channel(117)
+    channel.speak 'Hello world!'
+
+
     # find or create a channel
     require 'rubygems'
     require 'protolink'
@@ -66,6 +70,12 @@ Sorry, there are no tests at all yet...
     protonet = Protolink::Protonet.new('SUBDOMAIN.DOMAIN.DE', 'USERLOGIN', 'PASSWORD', :ssl => false)
     user     = protonet.find_user_by_login("bjoern.dorra")
 
+    # find user by id
+    require 'rubygems'
+    require 'protolink'
+
+    protonet = Protolink::Protonet.new('SUBDOMAIN.DOMAIN.DE', 'USERLOGIN', 'PASSWORD', :ssl => false)
+    user     = protonet.find_user(117)
 
     # create a user
     require 'rubygems'

data/example/create_and_subscribe.rb

@@ -1,15 +1,15 @@
 require 'rubygems'
 require 'protolink'
 
-protonet   = Protolink::Protonet.new('localhost:3000', 'bjoern.dorra', 'geheim')
+protonet   = Protolink::Protonet.open('http://localhost:3000', 'bjoern.dorra', 'geheim')
 
-user       = protonet.find_or_create_user_by_login("johndoe", "password", "John Doe", "john@doe.com")
+user       = protonet.find_or_create_user_by_login("johndoe", :password => "password", :name => "John Doe", :email => "john@doe.com")
 auth_token = user.auth_token
 puts       "user_id     : #{user.id}"
 puts       "user_login  : #{user.login}"
 puts       "auth_token  : #{auth_token}"
 
-channel    = protonet.find_or_create_channel_by_name("test", "This is a test channel!")
+channel    = protonet.find_or_create_channel_by_name("test", :description => "This is a test channel!")
 puts       "channel_id  : #{channel.id}"
 puts       "channel_name: #{channel.name}"
 puts       "channel_desc: #{channel.description}"

data/lib/protolink.rb

@@ -1,13 +1,7 @@
-require 'active_support'
-require 'active_support/json'
-require 'mime/types'
-
-require 'protolink/connection'
 require 'protolink/protonet'
 require 'protolink/channel'
 require 'protolink/user'
 require 'protolink/listen'
-require 'protolink/middleware'
 
 module Protolink
   class Error < StandardError; end

data/lib/protolink/channel.rb

@@ -16,6 +16,16 @@ module Protolink
       send_message(message)
     end
 
+    def delete!
+      connection.delete("/api/v1/channels/#{self.id}")
+    end
+    
+    def listener
+      users = connection.get("/api/v1/channels/#{self.id}/users")
+      users && users.map do |user|
+        User.new(connection, user)
+      end
+    end
 
     protected
 
@@ -34,7 +44,7 @@ module Protolink
       end
 
       def send_message(message)
-        connection.post("/api/v1/meeps/create", {:channel_id => self.id, :message => message})
+        connection.post("/api/v1/meeps/create", :body => {:channel_id => self.id, :message => message})
       end
 
       def connection

data/lib/protolink/protonet.rb

@@ -1,3 +1,5 @@
+require 'httparty'
+
 module Protolink
 
   #   protonet = Protolink::Protonet.new 'domain', :user => 'john.doe', :password => 'secret', :token => 'xyz'
@@ -5,87 +7,119 @@ module Protolink
   #   channel = protonet.find_channel_by_name 'home'
   #   channel.speak 'Hello world!'
   class Protonet
-    attr_reader :connection
-
-    # Create a new connection to the account with the given +domain+.
+    include HTTParty
+    
+    # Create a new connection to the account with the given +uri+.
     #
     # == Options:
-    # * +:ssl+: use SSL for the connection, which is required if you have a Protonet SSL account.
-    #           Defaults to false
-    # * +:proxy+: a proxy URI. (e.g. :proxy => 'http://user:pass@example.com:8000')
+    # * +:username+: your api users username
+    # * +:password+: your api users password
+    # * +:proxy+: a hash with your proxy options (e.g. {:uri => 'http://user:pass@example.com', :port => 8800})
     #
-    def initialize(domainname, username, password, options = {})
-      @connection = Connection.new(domainname, username, password, options)
+    def self.open(uri, username, password, proxy = nil)
+      # this allows you to use the httparty class helpers (base_uri...) with multiple connections
+      clazz = self.dup
+      clazz.base_uri(uri)
+      clazz.basic_auth(username, password)
+      if proxy
+        clazz.http_proxy(proxy[:uri], proxy[:port])
+      end
+      clazz.new
     end
-
-
+    
     # CHANNELS
 
     # Get an array of all the available channels
     def channels
-      s = connection.get('/api/v1/channels.json')
-      s = Hash["channels", s]
-      s['channels'].map do |channel|
-        Channel.new(connection, channel)
+      get('/api/v1/channels.json').map do |channel|
+        Channel.new(self, channel)
       end
     end
 
-    # Find a Channel by name
-    def find_channel_by_name(name)
-      channels.detect { |channel| channel.name == name }
-    end
-
     # Creates and returns a new Channel with the given +name+ and optionally a +description+
-    def create_channel(name, description = nil)
-      connection.post('/api/v1/channels/create.json', {  :name => name, :description => description } )
+    def create_channel(options={})
+      name        = options[:name] || raise(ArgumentError, "Please provide a name for the channel")
+      description = options[:description]
+      skip_autosubscribe = options[:skip_autosubscribe]
+      post('/api/v1/channels', :body => { :name => name, :description => description, :skip_autosubscribe => skip_autosubscribe } )
       find_channel_by_name(name)
     end
 
-    def find_or_create_channel_by_name(name, description = nil)
-      find_channel_by_name(name) || create_channel(name, description)
+    def find_or_create_channel_by_name(name, options = {})
+      find_channel_by_name(name) || create_channel({:name => name}.merge(options))
     end
 
+    # Find a Channel by id
+    def find_channel(id)
+      response = get("/api/v1/channels/#{id}")
+      Channel.new(self, response) if response
+    end
+
+    # Find a Channel by name
+    def find_channel_by_name(name)
+      response = get("/api/v1/channels/#{name}")
+      Channel.new(self, response) if response
+    end
 
     # USERS
     
     # Get an array of all the available users
     def users
-      s = connection.get('/api/v1/users.json')
-      s = Hash["users", s]
-      s['users'].map do |user|
-        User.new(connection, user)
+      get('/api/v1/users.json').map do |user|
+        User.new(self, user)
       end
     end
 
     # Creates and returns a new user with the given attributes
-    def create_user(login, password = nil, name = nil, email = nil, avatar_url = nil, channels = nil)
+    def create_user(options)
+      login       = options[:login] || raise(ArgumentError, "Please provide a login for this user")
+      password    = options[:password]
+      name        = options[:name]
+      email       = options[:email] || raise(ArgumentError, "Please provide an email for this user")
+      avatar_url  = options[:avatar_url]
+      profile_url = options[:profile_url]
+      channels    = options[:channels]
       if channels
         # not implemented yet
         no_channels = "true"
       else
         no_channels = "true"
       end
-      connection.post('/api/v1/users/create.json', {:login => login, :name => name, :password => password, :email => email, :avatar_url => avatar_url, :no_channels => no_channels, :channels_to_subscribe => nil } )
+      post('/api/v1/users', :body => {:login => login, :name => name, :password => password, :email => email, :avatar_url => avatar_url, :no_channels => no_channels, :channels_to_subscribe => nil } )
       find_user_by_login(login)
     end
 
-    # Find a user by name
-    def find_user_by_login(login)
-      users.detect { |user| user.login == login }
+    def find_or_create_user_by_login(login, options = {})
+      find_user_by_login(login) || create_user({:login => login}.merge(options))
     end
 
-    def find_or_create_user_by_login(login, password = nil, name = nil, email = nil, avatar_url = nil, channels = nil)
-      find_user_by_login(login) || create_user(login, password, name, email, avatar_url = nil, channels = nil)
+    # Find a user by id
+    def find_user(id)
+      response = get("/api/v1/users/#{id}")
+      User.new(self, response) if response
+    end
+    
+    def find_user_by_login(login)
+      response = get("/api/v1/users/#{login}")
+      User.new(self, response) if response
     end
-
 
     # LISTENS
     def create_listen(user_id, channel_id)
-      connection.post('/api/v1/listens/create.json', {:user_id => user_id, :channel_id => channel_id } )
+      post('/api/v1/listens', :body => {:user_id => user_id, :channel_id => channel_id } )
     end
 
     def destroy_listen(user_id, channel_id)
-      connection.post('/api/v1/listens/destroy.json', {:user_id => user_id, :channel_id => channel_id } )
+      delete('/api/v1/listens', :body => {:user_id => user_id, :channel_id => channel_id } )
+    end
+    
+    [:get, :post, :update, :delete].each do |method|
+      class_eval <<-EOS
+        def #{method}(uri, options = {})
+          response = self.class.#{method}(uri, options)
+          response.code.to_s.match(/2../) ? response : nil
+        end
+      EOS
     end
 
   end

data/lib/protolink/user.rb

@@ -14,15 +14,15 @@ module Protolink
 
     # get token for autologin
     def auth_token
-      receive_auth_token
+      connection.get("/api/v1/users/#{self.id}/auth_token.json")["token"]
+    end
+    
+    def delete!
+      connection.delete("/api/v1/users/#{self.id}")
     end
 
     protected
 
-      def receive_auth_token
-        connection.get("/api/v1/users/auth_token.json?user_id=#{self.id}")['token']
-      end
-
       def load
         reload! unless @loaded
       end

data/lib/protolink/version.rb

@@ -1,3 +1,3 @@
 module Protolink
-  VERSION = '0.1.1' unless defined?(::Protolink::VERSION)
+  VERSION = '0.2.0' unless defined?(::Protolink::VERSION)
 end

data/protolink.gemspec

@@ -25,33 +25,15 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<activesupport>, [">= 0"])
-      s.add_runtime_dependency(%q<faraday>, ["~> 0.5.1"])
-      s.add_runtime_dependency(%q<multipart-post>, [">= 0"])
-      s.add_runtime_dependency(%q<mime-types>, [">= 0"])
-      s.add_runtime_dependency(%q<twitter-stream>, [">= 0"])
-      s.add_runtime_dependency(%q<eventmachine>, [">= 0"])
-      s.add_development_dependency(%q<rspec>, [">= 0"])
-      s.add_development_dependency(%q<fakeweb>, [">= 0"])
+      s.add_runtime_dependency(%q<crack>, [">= 0"])
+      s.add_runtime_dependency(%q<httparty>, ["~> 0.5.1"])
     else
-      s.add_dependency(%q<activesupport>, [">= 0"])
-      s.add_dependency(%q<faraday>, ["~> 0.5.1"])
-      s.add_dependency(%q<multipart-post>, [">= 0"])
-      s.add_dependency(%q<mime-types>, [">= 0"])
-      s.add_dependency(%q<twitter-stream>, [">= 0"])
-      s.add_dependency(%q<eventmachine>, [">= 0"])
-      s.add_dependency(%q<rspec>, [">= 0"])
-      s.add_dependency(%q<fakeweb>, [">= 0"])
+      s.add_dependency(%q<crack>, [">= 0"])
+      s.add_dependency(%q<httparty>, ["~> 0.5.1"])
     end
   else
-    s.add_dependency(%q<activesupport>, [">= 0"])
-    s.add_dependency(%q<faraday>, ["~> 0.5.1"])
-    s.add_dependency(%q<multipart-post>, [">= 0"])
-    s.add_dependency(%q<mime-types>, [">= 0"])
-    s.add_dependency(%q<twitter-stream>, [">= 0"])
-    s.add_dependency(%q<eventmachine>, [">= 0"])
-    s.add_dependency(%q<rspec>, [">= 0"])
-    s.add_dependency(%q<fakeweb>, [">= 0"])
+    s.add_dependency(%q<crack>, [">= 0"])
+    s.add_dependency(%q<httparty>, ["~> 0.5.1"])
   end
 end
 

data/test/all_tests.rb

@@ -0,0 +1,82 @@
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
+
+require 'rubygems'
+require 'protolink'
+require "test/unit"
+
+# require 'ruby-debug'
+# Debugger.start
+# change this if you need to connect to another server
+PTN_SERVER = "http://localhost:3000"
+PTN_USER   = "dude"
+PTN_PASS   = "geheim"
+# protonet   = Protolink::Protonet.new('localhost:3000', 'bjoern.dorra', 'geheim')
+# 
+# user       = protonet.find_or_create_user_by_login("johndoe", "password", "John Doe", "john@doe.com")
+# auth_token = user.auth_token
+# puts       "user_id     : #{user.id}"
+# puts       "user_login  : #{user.login}"
+# puts       "auth_token  : #{auth_token}"
+# 
+# channel    = protonet.find_or_create_channel_by_name("test", "This is a test channel!")
+# puts       "channel_id  : #{channel.id}"
+# puts       "channel_name: #{channel.name}"
+# puts       "channel_desc: #{channel.description}"
+# 
+# protonet.create_listen(user.id, channel.id)
+# 
+# puts       "\nhttp://localhost:3000/?auth_token=#{auth_token}"
+
+class TestAll < Test::Unit::TestCase
+  
+  def teardown
+    protonet = Protolink::Protonet.open(PTN_SERVER, PTN_USER, PTN_PASS)
+    user = protonet.find_user_by_login("test")
+    user.delete!
+    user = protonet.find_user_by_login("test_2")
+    user.delete!
+    channel = protonet.find_channel_by_name("test_foobar")
+    channel.delete!
+    channel = protonet.find_channel_by_name("test_foobar_2")
+    channel.delete!
+  end
+  
+  def test_all
+    protonet = Protolink::Protonet.open(PTN_SERVER, PTN_USER, PTN_PASS)
+    assert protonet, "Couldn't create connection instance"
+    
+    user_1 = protonet.create_user(:login => 'test', :email => 'test@test.com')
+    assert user_1.is_a?(Protolink::User), "Couldn't create user"
+    assert_equal 'test', user_1.login
+    assert_equal 'test@test.com', user_1.email
+    assert user_1.auth_token.match(/\w+/)
+    
+    user_2 = protonet.find_or_create_user_by_login('test', :email => 'test@test.com')
+    assert_equal user_1.id, user_2.id
+    
+    user_3 = protonet.find_or_create_user_by_login('test_2', :email => 'test_2@test.com')
+    assert user_3.is_a?(Protolink::User), "Couldn't create user"
+    assert_equal 'test_2', user_3.login
+    assert_equal 'test_2@test.com', user_3.email
+    
+    channel_1 = protonet.create_channel(:name => "test_foobar", :skip_autosubscribe => true)
+    assert channel_1.is_a?(Protolink::Channel), "Couldn't create channel"
+    assert_equal 'test_foobar', channel_1.name
+    
+    channel_2 = protonet.find_or_create_channel_by_name("test_foobar")
+    assert_equal channel_1.id, channel_2.id
+    
+    channel_3 = protonet.find_or_create_channel_by_name("test_foobar_2")
+    assert channel_3.is_a?(Protolink::Channel), "Couldn't create channel"
+    assert_equal 'test_foobar_2', channel_3.name
+    
+    protonet.create_listen(user_1.id, channel_1.id)
+    protonet.create_listen(user_3.id, channel_1.id)
+    
+    assert_equal [user_1.id, user_3.id].sort, channel_1.listener.map {|u| u.id}.sort
+    
+    protonet.destroy_listen(user_1.id, channel_1.id)
+    
+    assert_equal [user_3.id], channel_1.listener.map {|u| u.id}.sort
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: protolink
 version: !ruby/object:Gem::Version 
-  hash: 25
-  prerelease: false
+  hash: 23
+  prerelease: 
   segments: 
   - 0
-  - 1
-  - 1
-  version: 0.1.1
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - "Bj\xC3\xB6rn B. Dorra"
@@ -16,11 +16,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-15 00:00:00 +02:00
+date: 2011-07-25 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: activesupport
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
@@ -32,9 +31,9 @@ dependencies:
         - 0
         version: "0"
   type: :runtime
+  name: crack
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: faraday
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
@@ -48,91 +47,8 @@ dependencies:
         - 1
         version: 0.5.1
   type: :runtime
+  name: httparty
   version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: multipart-post
-  prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :runtime
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: mime-types
-  prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :runtime
-  version_requirements: *id004
-- !ruby/object:Gem::Dependency 
-  name: twitter-stream
-  prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :runtime
-  version_requirements: *id005
-- !ruby/object:Gem::Dependency 
-  name: eventmachine
-  prerelease: false
-  requirement: &id006 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :runtime
-  version_requirements: *id006
-- !ruby/object:Gem::Dependency 
-  name: rspec
-  prerelease: false
-  requirement: &id007 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  version_requirements: *id007
-- !ruby/object:Gem::Dependency 
-  name: fakeweb
-  prerelease: false
-  requirement: &id008 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  version_requirements: *id008
 description: A Ruby API for interfacing with Protonet, the next-gen internet infrastructure. Truly social and people-powered.
 email: dorra@d-1.comg
 executables: []
@@ -142,18 +58,21 @@ extensions: []
 extra_rdoc_files: 
 - README.markdown
 files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- Gemfile.lock
 - README.markdown
 - Rakefile
 - example/create_and_subscribe.rb
 - lib/protolink.rb
 - lib/protolink/channel.rb
-- lib/protolink/connection.rb
 - lib/protolink/listen.rb
-- lib/protolink/middleware.rb
 - lib/protolink/protonet.rb
 - lib/protolink/user.rb
 - lib/protolink/version.rb
 - protolink.gemspec
+- test/all_tests.rb
 has_rdoc: true
 homepage: http://github.com/protonet/protolink
 licenses: []
@@ -184,7 +103,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: protolink
-rubygems_version: 1.3.7
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: Ruby wrapper for the ProtoNet API

data/lib/protolink/connection.rb

@@ -1,83 +0,0 @@
-require 'uri'
-require 'faraday'
-
-module Protolink
-  class Connection
-
-    attr_reader :domain, :username, :password, :uri, :options
-
-    def self.connection
-      @connection ||= Faraday::Connection.new do |conn|
-        conn.use      Faraday::Request::ActiveSupportJson
-        conn.adapter  :net_http
-        conn.use      Protolink::FaradayResponse::RaiseOnAuthenticationFailure
-        conn.use      Faraday::Response::ActiveSupportJson
-        conn.use      Protolink::FaradayResponse::WithIndifferentAccess
-
-        conn.headers['Content-Type'] = 'application/json'
-      end
-    end
-
-    def self.raw_connection
-      @raw_connection ||= Faraday::Connection.new do |conn|
-        conn.adapter  Faraday.default_adapter
-        conn.use      Protolink::FaradayResponse::RaiseOnAuthenticationFailure
-        conn.use      Faraday::Response::ActiveSupportJson
-        conn.use      Protolink::FaradayResponse::WithIndifferentAccess
-      end
-    end
-
-    def initialize(domainname, username, password, options = {})
-      @domainname   = domainname
-      @username = username
-      @password = password
-      @options  = { :ssl => false, :proxy => ENV['HTTP_PROXY'] }.merge(options)
-      @uri = URI.parse("#{@options[:ssl] ? 'https' : 'http' }://#{domainname}")
-
-      connection.basic_auth username, password
-      raw_connection.basic_auth username, password
-    end
-
-    def connection
-      @connection ||= begin
-        conn = self.class.connection.dup
-        conn.url_prefix = @uri.to_s
-        conn.proxy options[:proxy]
-        conn
-      end
-    end
-
-    def raw_connection
-      @raw_connection ||= begin
-        conn = self.class.raw_connection.dup
-        conn.url_prefix = @uri.to_s
-        conn.proxy options[:proxy]
-        conn
-      end
-    end
-
-    def get(url, *args)
-      response = connection.get(url, *args)
-      response.body
-    end
-
-    def post(url, body = nil, *args)
-      response = connection.post(url, body, *args)
-      response.body
-    end
-
-    def raw_post(url, body = nil, *args)
-      response = raw_connection.post(url, body, *args)
-    end
-
-    def put(url, body = nil, *args)
-      response = connection.put(url, body, *args)
-      response.body
-    end
-
-    # Is the connection using ssl?
-    def ssl?
-      uri.scheme == 'https'
-    end
-  end
-end

data/lib/protolink/middleware.rb

@@ -1,30 +0,0 @@
-module Protolink
-  module FaradayResponse
-    class WithIndifferentAccess < ::Faraday::Response::Middleware
-      begin
-        require 'active_support/core_ext/hash/indifferent_access'
-      rescue LoadError, NameError => error
-        self.load_error = error
-      end
-
-      def self.register_on_complete(env)
-        env[:response].on_complete do |response|
-          json = response[:body]
-          if json.is_a?(Hash)
-            response[:body] = ::HashWithIndifferentAccess.new(json)
-          elsif json.is_a?(Array) and json.first.is_a?(Hash)
-            response[:body] = json.map{|item| ::HashWithIndifferentAccess.new(item) }
-          end
-        end
-      end
-    end
-
-    class RaiseOnAuthenticationFailure < ::Faraday::Response::Middleware
-      def self.register_on_complete(env)
-        env[:response].on_complete do |response|
-          raise AuthenticationFailed if response[:status] == 401
-        end
-      end
-    end
-  end
-end