lhc 3.5.4 → 3.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8b55a6d77b6a16bb202a4babfc914427d70f092e
-  data.tar.gz: c618090650536a4f7fbff41c8b83a59b91108e3f
+  metadata.gz: 5bd96d437b05df955ff37aed6c1bea4c6c3a68ff
+  data.tar.gz: 6fa74559274820bf6cecca05fc6deb4620483529
 SHA512:
-  metadata.gz: 036f5aa745a97701ef069a902b9ba7d6b6bb142d72ccfd028ebe91358d68ae23d98b6ea2f70d55c87ba7d064185f7c9b24b99b9a19107e8c00c802ff076fc0e7
-  data.tar.gz: 74db7500de0d6a3638c5f96ec918984e4dc9624a2405679fb7936e54178e98d9faa638f41b2fb61ad5bf3fe2c07e7fa1d06c5240a46a1296128209eb03d9525d
+  metadata.gz: a46627d6d00ea9193860f8cab7e8beaace7c514992cccc803baa36ed050112667445c7cd683f9c95e1d19703dc2e0fd47feb969d09e1d770b9c5bcd4be7b9bb0
+  data.tar.gz: 1ea0e5bd2384dc033d38f93a20227160de7c6512b4ff9322c3f2800237ce9db354ea88489ee761938580295ddceab2e70a325852f4c5649670fdfd2fc71b958d

data/README.md

@@ -124,3 +124,7 @@ To monitor and manipulate the http communication done with LHC, you can define i
 ```
 
 → [Read more about interceptors](docs/interceptors.md)
+
+## License
+
+[GNU Affero General Public License Version 3.](https://www.gnu.org/licenses/agpl-3.0.en.html)

data/lhc.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |s|
   s.email       = ['ws-operations@local.ch']
   s.homepage    = 'https://github.com/local-ch/lhc'
   s.summary     = 'LocalHttpServices'
-  s.description = 'Rails gem wrapping typhoeus and providing additional features (like interceptors)'
+  s.description = 'Rails gem for HTTP wrapping typhoeus and providing additional features (like interceptors)'
 
   s.files        = `git ls-files`.split("\n")
   s.test_files   = `git ls-files -- spec/*`.split("\n") +
@@ -30,4 +30,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'geminabox'
   s.add_development_dependency 'pry'
   s.add_development_dependency 'ciderizer'
+  
+  s.license = 'GPL-3'
 end

data/lib/lhc/endpoint.rb

@@ -2,7 +2,7 @@
 # The url can also be an url-template.
 class LHC::Endpoint
 
-  PLACEHOLDER = %r{(?<=^):[^\/\.]+|(?<=\/):[^\/\.]+}
+  PLACEHOLDER = %r{:[^\/\.:;\d\&]+}
   ANYTHING_BUT_SINGLE_SLASH_AND_DOT = '([^\/\.]|\/\/)+'.freeze
 
   attr_accessor :url, :options

data/lib/lhc/version.rb

@@ -1,3 +1,3 @@
 module LHC
-  VERSION = "3.5.4"
+  VERSION = "3.5.5"
 end

data/non_rails_spec/request/request_spec.rb

@@ -2,12 +2,12 @@ require 'spec_helper'
 
 describe LHC::Request do
   before do
-    allow_any_instance_of(described_class).to receive(:use_configured_endpoint!)
-    allow_any_instance_of(described_class).to receive(:generate_url_from_template!)
+    allow_any_instance_of(LHC::Request).to receive(:use_configured_endpoint!)
+    allow_any_instance_of(LHC::Request).to receive(:generate_url_from_template!)
   end
   context 'request without rails' do
     it 'does have deep_merge dependency met' do
-      expect { described_class.new({}, false) }.not_to raise_error
+      expect { LHC::Request.new({}, false) }.not_to raise_error
     end
   end
 end

data/spec/basic_methods/delete_spec.rb

@@ -16,16 +16,16 @@ describe LHC do
     end
 
     it 'does a delete request when providing a complete url' do
-      described_class.delete('http://datastore/v2/feedbacks/12121')
+      LHC.delete('http://datastore/v2/feedbacks/12121')
     end
 
     it 'it makes response data available in a rails way' do
-      response = described_class.delete('http://datastore/v2/feedbacks/12121')
+      response = LHC.delete('http://datastore/v2/feedbacks/12121')
       expect(response.data.recommended).to eq true
     end
 
     it 'provides response headers' do
-      response = described_class.delete('http://datastore/v2/feedbacks/12121')
+      response = LHC.delete('http://datastore/v2/feedbacks/12121')
       expect(response.headers).to be
     end
   end

data/spec/basic_methods/post_spec.rb

@@ -17,23 +17,23 @@ describe LHC do
     end
 
     it 'does a post request when providing a complete url' do
-      described_class.post('http://datastore/v2/feedbacks', body: feedback.to_json)
+      LHC.post('http://datastore/v2/feedbacks', body: feedback.to_json)
     end
 
     it 'does a post request when providing the name of a configured endpoint' do
       url = 'http://:datastore/v2/feedbacks'
       options = { params: { datastore: 'datastore' } }
-      described_class.configure { |c| c.endpoint(:feedbacks, url, options) }
-      described_class.post(:feedbacks, body: feedback.to_json)
+      LHC.configure { |c| c.endpoint(:feedbacks, url, options) }
+      LHC.post(:feedbacks, body: feedback.to_json)
     end
 
     it 'it makes response data available in a rails way' do
-      response = described_class.post('http://datastore/v2/feedbacks', body: feedback.to_json)
+      response = LHC.post('http://datastore/v2/feedbacks', body: feedback.to_json)
       expect(response.data.source_id).to eq 'aaa'
     end
 
     it 'provides response headers' do
-      response = described_class.post('http://datastore/v2/feedbacks', body: feedback.to_json)
+      response = LHC.post('http://datastore/v2/feedbacks', body: feedback.to_json)
       expect(response.headers).to be
     end
   end

data/spec/basic_methods/put_spec.rb

@@ -23,23 +23,23 @@ describe LHC do
     end
 
     it 'does a post request when providing a complete url' do
-      described_class.put('http://datastore/v2/feedbacks', body: change.to_json)
+      LHC.put('http://datastore/v2/feedbacks', body: change.to_json)
     end
 
     it 'does a post request when providing the name of a configured endpoint' do
       url = 'http://:datastore/v2/feedbacks'
       options = { params: { datastore: 'datastore' } }
-      described_class.configure { |c| c.endpoint(:feedbacks, url, options) }
-      described_class.put(:feedbacks, body: change.to_json)
+      LHC.configure { |c| c.endpoint(:feedbacks, url, options) }
+      LHC.put(:feedbacks, body: change.to_json)
     end
 
     it 'it makes response data available in a rails way' do
-      response = described_class.put('http://datastore/v2/feedbacks', body: change.to_json)
+      response = LHC.put('http://datastore/v2/feedbacks', body: change.to_json)
       expect(response.data.recommended).to eq false
     end
 
     it 'provides response headers' do
-      response = described_class.put('http://datastore/v2/feedbacks', body: change.to_json)
+      response = LHC.put('http://datastore/v2/feedbacks', body: change.to_json)
       expect(response.headers).to be
     end
   end

data/spec/basic_methods/request_spec.rb

@@ -10,7 +10,7 @@ describe LHC do
     end
 
     it 'does a request returning a response' do
-      response = described_class.request(url: 'http://datastore/v2/feedbacks', params: { has_reviews: true }, method: :get)
+      response = LHC.request(url: 'http://datastore/v2/feedbacks', params: { has_reviews: true }, method: :get)
       expect(response.data.total).to eq total
     end
   end

data/spec/config/endpoints_spec.rb

@@ -12,50 +12,50 @@ describe LHC do
     end
 
     before(:each) do
-      described_class.configure do |c|
+      LHC.configure do |c|
         c.endpoint(:kpi_tracker, url, options)
       end
     end
 
     it 'configures urls to be able to access them by name later' do
-      expect(described_class.config.endpoints[:kpi_tracker].url).to eq url
-      expect(described_class.config.endpoints[:kpi_tracker].options).to eq options
+      expect(LHC.config.endpoints[:kpi_tracker].url).to eq url
+      expect(LHC.config.endpoints[:kpi_tracker].options).to eq options
     end
 
     it 'compile url' do
       stub_request(:get, 'http://analytics/track/123/w/request?env=PROD')
-      response = described_class.get(:kpi_tracker, params: { entity_id: 123, type: 'request' })
+      response = LHC.get(:kpi_tracker, params: { entity_id: 123, type: 'request' })
       expect(response.request.options[:followlocation]).to eq false
     end
 
     it 'gets overwritten by explicit request options' do
       stub_request(:get, 'http://analytics/track/123/w/request?env=STG')
-      described_class.get(:kpi_tracker, params: { entity_id: 123, type: 'request', env: 'STG' })
+      LHC.get(:kpi_tracker, params: { entity_id: 123, type: 'request', env: 'STG' })
     end
 
     it 'raises in case of claching endpoint names' do
       expect(lambda {
-        described_class.config.endpoint(:kpi_tracker, 'http://kpi-tracker')
+        LHC.config.endpoint(:kpi_tracker, 'http://kpi-tracker')
       }).to raise_error 'Endpoint already exists for that name'
     end
 
     it 'enforces endpoint name to be a symbol' do
-      described_class.configure { |c| c.endpoint('datastore', 'http://datastore') }
-      expect(described_class.config.endpoints[:datastore].url).to eq 'http://datastore'
+      LHC.configure { |c| c.endpoint('datastore', 'http://datastore') }
+      expect(LHC.config.endpoints[:datastore].url).to eq 'http://datastore'
     end
   end
 
   context 'configured enpoints with default params' do
     before(:each) do
-      described_class.config.endpoint(:telemarketers, 'http://datastore/v2/spamnumbers?order_by=-user_frequency&swiss_number=true&offset=0&limit=:limit', params: { limit: 200 })
+      LHC.config.endpoint(:telemarketers, 'http://datastore/v2/spamnumbers?order_by=-user_frequency&swiss_number=true&offset=0&limit=:limit', params: { limit: 200 })
       stub_request(:get, 'http://datastore/v2/spamnumbers?limit=200&offset=0&order_by=-user_frequency&swiss_number=true')
         .to_return(status: 200)
     end
 
     it 'is possible to call them multiple times with default params' do
-      described_class.get(:telemarketers)
-      described_class.get(:telemarketers)
-      described_class.get(:telemarketers)
+      LHC.get(:telemarketers)
+      LHC.get(:telemarketers)
+      LHC.get(:telemarketers)
     end
   end
 end

data/spec/config/placeholders_spec.rb

@@ -3,28 +3,28 @@ require 'rails_helper'
 describe LHC do
   context 'configuration of placeholders' do
     it 'uses values for placeholders defined globally' do
-      described_class.configure { |c| c.placeholder(:datastore, 'http://datastore/v2') }
+      LHC.configure { |c| c.placeholder(:datastore, 'http://datastore/v2') }
       stub_request(:get, "http://datastore/v2/feedbacks")
-      described_class.get(':datastore/feedbacks')
+      LHC.get(':datastore/feedbacks')
     end
 
     it 'uses explicit values first' do
-      described_class.configure { |c| c.placeholder(:campaign_id, '123') }
+      LHC.configure { |c| c.placeholder(:campaign_id, '123') }
       stub_request(:get, 'http://datastore/v2/campaign/456/feedbacks')
       url = 'http://datastore/v2/campaign/:campaign_id/feedbacks'
-      described_class.get(url, params: { campaign_id: '456' })
+      LHC.get(url, params: { campaign_id: '456' })
     end
 
     it 'raises in case of claching placeholder name' do
-      described_class.configure { |c| c.placeholder(:datastore, 'http://datastore') }
+      LHC.configure { |c| c.placeholder(:datastore, 'http://datastore') }
       expect(lambda {
-        described_class.config.placeholder(:datastore, 'http://datastore')
+        LHC.config.placeholder(:datastore, 'http://datastore')
       }).to raise_error 'Placeholder already exists for that name'
     end
 
     it 'enforces placeholder name to be a symbol' do
-      described_class.configure { |c| c.placeholder('datatore', 'http://datastore') }
-      expect(described_class.config.placeholders[:datatore]).to eq 'http://datastore'
+      LHC.configure { |c| c.placeholder('datatore', 'http://datastore') }
+      expect(LHC.config.placeholders[:datatore]).to eq 'http://datastore'
     end
   end
 end

data/spec/endpoint/compile_spec.rb

@@ -3,14 +3,14 @@ require 'rails_helper'
 describe LHC::Endpoint do
   context 'compile' do
     it 'uses parameters for interpolation' do
-      endpoint = described_class.new(':datastore/v2/:campaign_id/feedbacks')
+      endpoint = LHC::Endpoint.new(':datastore/v2/:campaign_id/feedbacks')
       expect(
         endpoint.compile(datastore: 'http://datastore', campaign_id: 'abc')
       ).to eq "http://datastore/v2/abc/feedbacks"
     end
 
     it 'uses provided proc to find values' do
-      endpoint = described_class.new(':datastore/v2')
+      endpoint = LHC::Endpoint.new(':datastore/v2')
       config = { datastore: 'http://datastore' }
       find_value = lambda { |match|
         config[match.gsub(':', '').to_sym]
@@ -21,10 +21,24 @@ describe LHC::Endpoint do
     end
 
     it 'compiles when templates contain dots' do
-      endpoint = described_class.new(':datastore/entries/:id.json')
+      endpoint = LHC::Endpoint.new(':datastore/entries/:id.json')
       expect(
         endpoint.compile(datastore: 'http://datastore', id: 123)
       ).to eq "http://datastore/entries/123.json"
     end
+
+    it 'compiles complex urls containing all sort of characters' do
+      endpoint = LHC::Endpoint.new(':ads/?adrawdata/3.0/1108.1/2844859/0/0/header=yes;cookie=no;adct=204;alias=:region_id:lang:product_type:product;key=cat=:category_id')
+      expect(
+        endpoint.compile(ads: 'http://ads', region_id: 291, lang: 'de', product_type: 'ABC', product: 'xyz', category_id: 312)
+      ).to eq 'http://ads/?adrawdata/3.0/1108.1/2844859/0/0/header=yes;cookie=no;adct=204;alias=291deABCxyz;key=cat=312'
+    end
+
+    it 'compiles complex urls containing &' do
+      endpoint = LHC::Endpoint.new('http://:weather_search_host/forecast?format=json&period=hour&limit=:limit&areas=:zipcodes&when=:when')
+      expect(
+        endpoint.compile(weather_search_host: 'weather', limit: 5, zipcodes: [8005, 8004].join(','), when: 'today')
+      ).to eq 'http://weather/forecast?format=json&period=hour&limit=5&areas=8005,8004&when=today'
+    end
   end
 end

data/spec/endpoint/match_spec.rb

@@ -14,7 +14,7 @@ describe LHC::Endpoint do
           ':datastore/entries/:id.json' => 'http://local.ch/entries/123.json'
         }.each do |template, url|
           expect(
-            described_class.match?(url, template)
+            LHC::Endpoint.match?(url, template)
           ).to be, "#{url} should match #{template}!"
         end
       end
@@ -29,7 +29,7 @@ describe LHC::Endpoint do
           ':datastore/entries/:id' => 'http://local.ch/entries/123.json'
         }.each do |template, url|
           expect(
-            described_class.match?(url, template)
+            LHC::Endpoint.match?(url, template)
           ).not_to be, "#{url} should not match #{template}!"
         end
       end

data/spec/endpoint/placeholders_spec.rb

@@ -3,7 +3,7 @@ require 'rails_helper'
 describe LHC::Endpoint do
   context 'placeholders' do
     it 'returns all placeholders alphabetically sorted' do
-      endpoint = described_class.new(':datastore/v2/:campaign_id/feedbacks')
+      endpoint = LHC::Endpoint.new(':datastore/v2/:campaign_id/feedbacks')
       expect(
         endpoint.placeholders
       ).to eq [':campaign_id', ':datastore']

data/spec/endpoint/remove_interpolated_params_spec.rb

@@ -7,7 +7,7 @@ describe LHC::Endpoint do
       campaign_id: 'abc',
       has_reviews: true
     }
-    endpoint = described_class.new(':datastore/v2/:campaign_id/feedbacks')
+    endpoint = LHC::Endpoint.new(':datastore/v2/:campaign_id/feedbacks')
     removed = endpoint.remove_interpolated_params!(params)
     expect(params).to eq(has_reviews: true)
     expect(removed).to eq(datastore: 'http://datastore', campaign_id: 'abc')

data/spec/endpoint/values_as_params_spec.rb

@@ -17,7 +17,7 @@ describe LHC::Endpoint do
           id: 'ZW9OJyrbt'
         }]
       ].each do |example|
-        params = described_class.values_as_params(example[0], example[1])
+        params = LHC::Endpoint.values_as_params(example[0], example[1])
         expect(params).to eq example[2]
       end
     end

data/spec/error/find_spec.rb

@@ -7,48 +7,48 @@ describe LHC::Error do
 
   context 'find' do
     it 'finds error class by status code' do
-      expect(described_class.find(response('400'))).to eq LHC::BadRequest
-      expect(described_class.find(response('401'))).to eq LHC::Unauthorized
-      expect(described_class.find(response('402'))).to eq LHC::PaymentRequired
-      expect(described_class.find(response('403'))).to eq LHC::Forbidden
-      expect(described_class.find(response('403'))).to eq LHC::Forbidden
-      expect(described_class.find(response('404'))).to eq LHC::NotFound
-      expect(described_class.find(response('405'))).to eq LHC::MethodNotAllowed
-      expect(described_class.find(response('406'))).to eq LHC::NotAcceptable
-      expect(described_class.find(response('407'))).to eq LHC::ProxyAuthenticationRequired
-      expect(described_class.find(response('408'))).to eq LHC::RequestTimeout
-      expect(described_class.find(response('409'))).to eq LHC::Conflict
-      expect(described_class.find(response('410'))).to eq LHC::Gone
-      expect(described_class.find(response('411'))).to eq LHC::LengthRequired
-      expect(described_class.find(response('412'))).to eq LHC::PreconditionFailed
-      expect(described_class.find(response('413'))).to eq LHC::RequestEntityTooLarge
-      expect(described_class.find(response('414'))).to eq LHC::RequestUriToLong
-      expect(described_class.find(response('415'))).to eq LHC::UnsupportedMediaType
-      expect(described_class.find(response('416'))).to eq LHC::RequestedRangeNotSatisfiable
-      expect(described_class.find(response('417'))).to eq LHC::ExpectationFailed
-      expect(described_class.find(response('422'))).to eq LHC::UnprocessableEntity
-      expect(described_class.find(response('423'))).to eq LHC::Locked
-      expect(described_class.find(response('424'))).to eq LHC::FailedDependency
-      expect(described_class.find(response('426'))).to eq LHC::UpgradeRequired
-      expect(described_class.find(response('500'))).to eq LHC::InternalServerError
-      expect(described_class.find(response('501'))).to eq LHC::NotImplemented
-      expect(described_class.find(response('502'))).to eq LHC::BadGateway
-      expect(described_class.find(response('503'))).to eq LHC::ServiceUnavailable
-      expect(described_class.find(response('504'))).to eq LHC::GatewayTimeout
-      expect(described_class.find(response('505'))).to eq LHC::HttpVersionNotSupported
-      expect(described_class.find(response('507'))).to eq LHC::InsufficientStorage
-      expect(described_class.find(response('510'))).to eq LHC::NotExtended
+      expect(LHC::Error.find(response('400'))).to eq LHC::BadRequest
+      expect(LHC::Error.find(response('401'))).to eq LHC::Unauthorized
+      expect(LHC::Error.find(response('402'))).to eq LHC::PaymentRequired
+      expect(LHC::Error.find(response('403'))).to eq LHC::Forbidden
+      expect(LHC::Error.find(response('403'))).to eq LHC::Forbidden
+      expect(LHC::Error.find(response('404'))).to eq LHC::NotFound
+      expect(LHC::Error.find(response('405'))).to eq LHC::MethodNotAllowed
+      expect(LHC::Error.find(response('406'))).to eq LHC::NotAcceptable
+      expect(LHC::Error.find(response('407'))).to eq LHC::ProxyAuthenticationRequired
+      expect(LHC::Error.find(response('408'))).to eq LHC::RequestTimeout
+      expect(LHC::Error.find(response('409'))).to eq LHC::Conflict
+      expect(LHC::Error.find(response('410'))).to eq LHC::Gone
+      expect(LHC::Error.find(response('411'))).to eq LHC::LengthRequired
+      expect(LHC::Error.find(response('412'))).to eq LHC::PreconditionFailed
+      expect(LHC::Error.find(response('413'))).to eq LHC::RequestEntityTooLarge
+      expect(LHC::Error.find(response('414'))).to eq LHC::RequestUriToLong
+      expect(LHC::Error.find(response('415'))).to eq LHC::UnsupportedMediaType
+      expect(LHC::Error.find(response('416'))).to eq LHC::RequestedRangeNotSatisfiable
+      expect(LHC::Error.find(response('417'))).to eq LHC::ExpectationFailed
+      expect(LHC::Error.find(response('422'))).to eq LHC::UnprocessableEntity
+      expect(LHC::Error.find(response('423'))).to eq LHC::Locked
+      expect(LHC::Error.find(response('424'))).to eq LHC::FailedDependency
+      expect(LHC::Error.find(response('426'))).to eq LHC::UpgradeRequired
+      expect(LHC::Error.find(response('500'))).to eq LHC::InternalServerError
+      expect(LHC::Error.find(response('501'))).to eq LHC::NotImplemented
+      expect(LHC::Error.find(response('502'))).to eq LHC::BadGateway
+      expect(LHC::Error.find(response('503'))).to eq LHC::ServiceUnavailable
+      expect(LHC::Error.find(response('504'))).to eq LHC::GatewayTimeout
+      expect(LHC::Error.find(response('505'))).to eq LHC::HttpVersionNotSupported
+      expect(LHC::Error.find(response('507'))).to eq LHC::InsufficientStorage
+      expect(LHC::Error.find(response('510'))).to eq LHC::NotExtended
     end
 
     it 'finds error class also by extended status codes' do
-      expect(described_class.find(response('40001'))).to eq LHC::BadRequest
-      expect(described_class.find(response('50002'))).to eq LHC::InternalServerError
+      expect(LHC::Error.find(response('40001'))).to eq LHC::BadRequest
+      expect(LHC::Error.find(response('50002'))).to eq LHC::InternalServerError
     end
 
     it 'returns UnknownError if no specific error was found' do
-      expect(described_class.find(response('0'))).to eq LHC::UnknownError
-      expect(described_class.find(response(''))).to eq LHC::UnknownError
-      expect(described_class.find(response('600'))).to eq LHC::UnknownError
+      expect(LHC::Error.find(response('0'))).to eq LHC::UnknownError
+      expect(LHC::Error.find(response(''))).to eq LHC::UnknownError
+      expect(LHC::Error.find(response('600'))).to eq LHC::UnknownError
     end
   end
 end

data/spec/interceptors/after_request_spec.rb

@@ -7,13 +7,13 @@ describe LHC do
         def after_request(request)
         end
       end
-      described_class.configure { |c| c.interceptors = [SomeInterceptor] }
+      LHC.configure { |c| c.interceptors = [SomeInterceptor] }
     end
 
     it 'can perform some actions after a request was fired' do
       expect_any_instance_of(SomeInterceptor).to receive(:after_request)
       stub_request(:get, 'http://local.ch')
-      described_class.get('http://local.ch')
+      LHC.get('http://local.ch')
     end
   end
 end

data/spec/interceptors/after_response_spec.rb

@@ -25,7 +25,7 @@ describe LHC do
           Services.timing(path.downcase, response.time)
         end
       end
-      described_class.configure { |c| c.interceptors = [StatsTimingInterceptor] }
+      LHC.configure { |c| c.interceptors = [StatsTimingInterceptor] }
     end
 
     let(:url) { "http://local.ch/v2/feedbacks/-Sc4_pYNpqfsudzhtivfkA" }
@@ -33,7 +33,7 @@ describe LHC do
     it 'can take action after a response was received' do
       allow(Services).to receive(:timing).with('web.dummy.test.get.http.local.ch.200', 0)
       stub_request(:get, url)
-      described_class.get(url)
+      LHC.get(url)
       expect(Services).to have_received(:timing)
     end
   end

data/spec/interceptors/before_request_spec.rb

@@ -8,12 +8,12 @@ describe LHC do
           request.params[:tid] = 123
         end
       end
-      described_class.configure { |c| c.interceptors = [TrackingIdInterceptor] }
+      LHC.configure { |c| c.interceptors = [TrackingIdInterceptor] }
     end
 
     it 'can modify requests before they are send' do
       stub_request(:get, "http://local.ch/?tid=123")
-      described_class.get('http://local.ch')
+      LHC.get('http://local.ch')
     end
   end
 end

data/spec/interceptors/before_response_spec.rb

@@ -7,13 +7,13 @@ describe LHC do
         def before_response(request)
         end
       end
-      described_class.configure { |c| c.interceptors = [SomeInterceptor] }
+      LHC.configure { |c| c.interceptors = [SomeInterceptor] }
     end
 
     it 'can perform some actions before a reponse is received' do
       expect_any_instance_of(SomeInterceptor).to receive(:before_response)
       stub_request(:get, 'http://local.ch')
-      described_class.get('http://local.ch')
+      LHC.get('http://local.ch')
     end
   end
 end

data/spec/interceptors/default_interceptors_spec.rb

@@ -3,11 +3,11 @@ require 'rails_helper'
 describe LHC do
   context 'default interceptors' do
     before(:each) do
-      described_class.configure {}
+      LHC.configure {}
     end
 
     it 'alwayses return a list for default interceptors' do
-      expect(described_class.config.interceptors).to eq []
+      expect(LHC.config.interceptors).to eq []
     end
   end
 end

data/spec/interceptors/define_spec.rb

@@ -10,18 +10,18 @@ describe LHC do
     end
 
     it 'performs interceptor when they are set globally' do
-      described_class.configure { |c| c.interceptors = [SomeInterceptor] }
+      LHC.configure { |c| c.interceptors = [SomeInterceptor] }
       expect_any_instance_of(SomeInterceptor).to receive(:before_request)
       stub_request(:get, 'http://local.ch')
-      described_class.get('http://local.ch')
+      LHC.get('http://local.ch')
     end
 
     it 'overrides interceptors on request level' do
-      described_class.configure { |c| c.interceptors = [SomeInterceptor] }
+      LHC.configure { |c| c.interceptors = [SomeInterceptor] }
       expect_any_instance_of(AnotherInterceptor).to receive(:before_request)
       expect_any_instance_of(SomeInterceptor).not_to receive(:before_request)
       stub_request(:get, 'http://local.ch')
-      described_class.get('http://local.ch', interceptors: [AnotherInterceptor])
+      LHC.get('http://local.ch', interceptors: [AnotherInterceptor])
     end
   end
 end

data/spec/interceptors/response_competition_spec.rb

@@ -25,14 +25,14 @@ describe LHC do
         end
       end
 
-      described_class.configure { |c| c.interceptors = [LocalCacheInterceptor, RemoteCacheInterceptor] }
+      LHC.configure { |c| c.interceptors = [LocalCacheInterceptor, RemoteCacheInterceptor] }
     end
 
     it 'can handle multiple interceptors that compete for returning the response' do
-      response = described_class.get('http://local.ch')
+      response = LHC.get('http://local.ch')
       expect(response.body).to eq 'Im served from remote cache'
       LocalCacheInterceptor.cached = true
-      response = described_class.get('http://local.ch')
+      response = LHC.get('http://local.ch')
       expect(response.body).to eq 'Im served from local cache'
     end
   end

data/spec/interceptors/return_response_spec.rb

@@ -9,11 +9,11 @@ describe LHC do
           LHC::Response.new(Typhoeus::Response.new(response_body: 'Im served from cache'), nil)
         end
       end
-      described_class.configure { |c| c.interceptors = [CacheInterceptor] }
+      LHC.configure { |c| c.interceptors = [CacheInterceptor] }
     end
 
     it 'can return a response rather then doing a real request' do
-      response = described_class.get('http://local.ch')
+      response = LHC.get('http://local.ch')
       expect(response.body).to eq 'Im served from cache'
     end
 
@@ -28,7 +28,7 @@ describe LHC do
 
       it 'raises an exception when two interceptors try to return a response' do
         expect(lambda {
-          described_class.get('http://local.ch', interceptors: [CacheInterceptor, AnotherInterceptor])
+          LHC.get('http://local.ch', interceptors: [CacheInterceptor, AnotherInterceptor])
         }).to raise_error 'Response already set from another interceptor'
       end
     end

data/spec/response/body_spec.rb

@@ -7,7 +7,7 @@ describe LHC::Response do
     let(:raw_response) { OpenStruct.new(body: body) }
 
     it 'provides response body' do
-      response = described_class.new(raw_response, nil)
+      response = LHC::Response.new(raw_response, nil)
       expect(response.body).to eq body
     end
   end

data/spec/response/code_spec.rb

@@ -7,7 +7,7 @@ describe LHC::Response do
     let(:raw_response) { OpenStruct.new(code: code) }
 
     it 'provides response code' do
-      response = described_class.new(raw_response, nil)
+      response = LHC::Response.new(raw_response, nil)
       expect(response.code).to eq code
     end
   end

data/spec/response/effective_url_spec.rb

@@ -7,7 +7,7 @@ describe LHC::Response do
     let(:raw_response) { OpenStruct.new(effective_url: effective_url) }
 
     it 'provides effective_url' do
-      response = described_class.new(raw_response, nil)
+      response = LHC::Response.new(raw_response, nil)
       expect(response.effective_url).to eq effective_url
     end
   end

data/spec/response/headers_spec.rb

@@ -9,7 +9,7 @@ describe LHC::Response do
     let(:raw_response) { OpenStruct.new(headers: headers) }
 
     it 'provides headers' do
-      response = described_class.new(raw_response, nil)
+      response = LHC::Response.new(raw_response, nil)
       expect(response.headers).to eq headers
     end
   end

data/spec/response/options_spec.rb

@@ -9,7 +9,7 @@ describe LHC::Response do
     let(:raw_response) { OpenStruct.new(options: options) }
 
     it 'provides headers' do
-      response = described_class.new(raw_response, nil)
+      response = LHC::Response.new(raw_response, nil)
       expect(response.options).to eq options
     end
   end

data/spec/response/success_spec.rb

@@ -2,8 +2,8 @@ require 'rails_helper'
 
 describe LHC::Response do
   context 'success?' do
-    let(:response_success) { described_class.new(Typhoeus::Response.new(response_code: 200, mock: true), nil) }
-    let(:response_error) { described_class.new(Typhoeus::Response.new(response_code: 404, mock: true), nil) }
+    let(:response_success) { LHC::Response.new(Typhoeus::Response.new(response_code: 200, mock: true), nil) }
+    let(:response_error) { LHC::Response.new(Typhoeus::Response.new(response_code: 404, mock: true), nil) }
 
     it { expect(response_success.success?).to be_truthy }
     it { expect(response_error.success?).to be_falsy }

data/spec/response/time_spec.rb

@@ -7,7 +7,7 @@ describe LHC::Response do
     let(:raw_response) { OpenStruct.new(time: time) }
 
     it 'provides response time in milliseconds' do
-      response = described_class.new(raw_response, nil)
+      response = LHC::Response.new(raw_response, nil)
       expect(response.time).to eq time * 1000
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lhc
 version: !ruby/object:Gem::Version
-  version: 3.5.4
+  version: 3.5.5
 platform: ruby
 authors:
 - local.ch
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-13 00:00:00.000000000 Z
+date: 2016-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: typhoeus
@@ -122,7 +122,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Rails gem wrapping typhoeus and providing additional features (like interceptors)
+description: Rails gem for HTTP wrapping typhoeus and providing additional features
+  (like interceptors)
 email:
 - ws-operations@local.ch
 executables: []
@@ -256,7 +257,8 @@ files:
 - spec/timeouts/no_signal_spec.rb
 - spec/timeouts/timings_spec.rb
 homepage: https://github.com/local-ch/lhc
-licenses: []
+licenses:
+- GPL-3
 metadata: {}
 post_install_message: 
 rdoc_options: []