active_rest_client 0.9.60 → 0.9.65

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b97b97ad9f83eabd1677c743fa9ffb0dc18b6519
-  data.tar.gz: 51b923f2dc18d42a5b471416b13d1a45f48ee314
+  metadata.gz: 25402e9d8bfc6b6a100bc3879d52ab05bf6b405d
+  data.tar.gz: 1008478bfd788080beace5892d18ebfce789e0f8
 SHA512:
-  metadata.gz: 0781899548d2deeafcc5c654ad110384d52df1dbaa2028e30ab30f687fc191c5dc1d3330894f6a7bbd5cb7880b8b960cf9f124070468f7b820aaec5f048e8f09
-  data.tar.gz: a56d18bd1789d4daac331de8b08fde1ede3007eb94365db2f0df24fc27da46552bf95cb86d75e8518d5f52eda04485e1a3e15450a070f37993fabe8f2e357ea2
+  metadata.gz: d89b51eef05da436ab06c8e7f26b710ec3ef23f7c98877338b67a91832d73bde76d9b35a1385900155b61c063c5b27166c726b2515f6c66c010e1e0193b18cf3
+  data.tar.gz: bfd28ddd34cd232649ec40cb7924e72ef30b6981076aed71f1df88d7c1a416fa611147a4a068244b6e31db504917a41821ae1cb7c71b17e7c3c88f127cf18ba0

data/README.md

@@ -40,7 +40,7 @@ class Person < ActiveRestClient::Base
 end
 ```
 
-Note I've specified the base_url in the class above.  This is usful where you want to be explicit or use different APIs for some classes and be explicit. If you have one server that's generally used, you can set it once with a simple line in the application.rb/production.rb:
+Note I've specified the base_url in the class above.  This is useful where you want to be explicit or use different APIs for some classes and be explicit. If you have one server that's generally used, you can set it once with a simple line in the application.rb/production.rb:
 
 ```ruby
 ActiveRestClient::Base.base_url = "https://www.example.com/api/v1"
@@ -394,6 +394,22 @@ This initially creates an ActiveRestClient::Request object as if you'd called `P
 
 Doing this will try to find a literally mapped method called "lazy_find" and if it fails, it will try to use "find" but instantiate the object lazily.
 
+### Plain Requests
+
+If you are already using ActiveRestClient but then want to simply call a normal URL and receive the resulting content as a string (i.e. not going through JSON parsing or instantiating in to an ActiveRestClient::Base descendent) you can use code like this:
+
+```ruby
+class Person < ActiveRestClient::Base
+end
+
+people = Person._plain_request('http://api.example.com/v1/people') # Defaults to get with no parameters
+# people is a normal ActiveRestClient object, implementing iteration, HAL loading, etc.
+
+Person._plain_request('http://api.example.com/v1/people', :post, {id:1234,name:"John"}) # Post with parameters
+```
+
+The parameters are the same as for _request, but it does no parsing on the response
+
 ### Proxying APIs
 
 Sometimes you may be working with an old API that returns JSON in a less than ideal format or the URL or parameters required have changed.  In this case you can define a descendent of `ActiveRestClient::ProxyBase`, pass it to your model as the proxy and have it rework URLs/parameters on the way out and the response on the way back in (already converted to a Ruby hash/array). By default any non-proxied URLs are just passed through to the underlying connection layer. For example:

data/Rakefile

@@ -1,3 +1,11 @@
 require "bundler/gem_tasks"
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new('spec')
+
+task :console do
+  require 'irb'
+  require 'irb/completion'
+  require 'active_rest_client'
+  ARGV.clear
+  IRB.start
+end

data/lib/active_rest_client.rb

@@ -1,4 +1,4 @@
-require 'active_support'
+require 'active_support/all'
 require "active_rest_client/version"
 require "active_rest_client/mapping"
 require "active_rest_client/caching"

data/lib/active_rest_client/base.rb

@@ -52,13 +52,19 @@ module ActiveRestClient
       prepare_direct_request(request, method).call(params)
     end
 
+    def self._plain_request(request, method = :get, params = nil)
+      prepare_direct_request(request, method, plain:true).call(params)
+    end
+
     def self._lazy_request(request, method = :get, params = nil)
       ActiveRestClient::LazyLoader.new(prepare_direct_request(request, method), params)
     end
 
-    def self.prepare_direct_request(request, method)
+    def self.prepare_direct_request(request, method, options={})
       unless request.is_a? ActiveRestClient::Request
-        mapped = {url:"DIRECT-CALLED-URL", method:method, options:{url:request}}
+        options[:plain] ||= false
+        mapped = {url:"DIRECT-CALLED-#{request}", method:method, options:{url:request, plain:options[:plain]}}
+
         request = Request.new(mapped, self)
       end
       request

data/lib/active_rest_client/caching.rb

@@ -21,6 +21,7 @@ module ActiveRestClient
       end
 
       def cache_store=(value)
+        @@cache_store = nil if value.nil? and return
         raise InvalidCacheStoreException.new("Cache store does not implement #read") unless value.respond_to?(:read)
         raise InvalidCacheStoreException.new("Cache store does not implement #write") unless value.respond_to?(:write)
         raise InvalidCacheStoreException.new("Cache store does not implement #fetch") unless value.respond_to?(:fetch)
@@ -43,13 +44,19 @@ module ActiveRestClient
       end
 
       def read_cached_response(request)
-        if cache_store
+        if cache_store && perform_caching
           key = "#{request.class_name}:#{request.original_url}"
-          cache_store.read(key)
+          ActiveRestClient::Logger.debug "  \033[1;4;32m#{ActiveRestClient::NAME}\033[0m #{key} - Reading from cache"
+          value = cache_store.read(key)
+          value = Marshal.load(value) rescue value
         end
       end
 
       def write_cached_response(request, response, result)
+        return if result.is_a? Symbol
+        return unless perform_caching
+        return unless !result.respond_to?(:_status) || [200, 304].include?(result._status)
+
         response.headers.keys.select{|h| h.is_a? String}.each do |key|
           response.headers[key.downcase.to_sym] = response.headers[key]
         end
@@ -60,7 +67,7 @@ module ActiveRestClient
           cached_response = CachedResponse.new(status:response.status, result:result)
           cached_response.etag = response.headers[:etag] if response.headers[:etag]
           cached_response.expires = Time.parse(response.headers[:expires]) if response.headers[:expires]
-          cache_store.write(key, cached_response, {})
+          cache_store.write(key, Marshal.dump(cached_response), {})
         end
       end
     end

data/lib/active_rest_client/connection_manager.rb

@@ -1,20 +1,20 @@
 module ActiveRestClient
   class ConnectionManager
     def self.reset!
-      @_connections = {}
+      Thread.current[:_connections]={}
     end
 
     def self.get_connection(base_url)
       raise Exception.new("Nil base URL passed to ConnectionManager.get_connection") if base_url.nil?
-      @_connections ||= {}
-      @_connections[base_url] ||= Connection.new(base_url)
-      @_connections[base_url]
+      Thread.current[:_connections] ||= {}
+      Thread.current[:_connections][base_url] ||= Connection.new(base_url)
+      Thread.current[:_connections][base_url]
     end
 
     def self.find_connection_for_url(url)
-      @_connections ||= {}
-      found = @_connections.keys.detect {|key| url[0,key.length] == key}
-      @_connections[found] if found
+      Thread.current[:_connections] ||= {}
+      found = Thread.current[:_connections].keys.detect {|key| url[0,key.length] == key}
+      Thread.current[:_connections][found] if found
     end
 
   end

data/lib/active_rest_client/lazy_association_loader.rb

@@ -80,10 +80,11 @@ module ActiveRestClient
 
     def ensure_lazy_loaded
       if @object.nil?
-        @request.method[:method] = :get
-        @request.method[:options][:url] = @url
-        @request.method[:options][:overriden_name] = @options[:overriden_name]
-        request = ActiveRestClient::Request.new(@request.method, @request.object)
+        method=@request.method.dup
+        method[:method] = :get
+        method[:options][:url] = @url
+        method[:options][:overriden_name] = @options[:overriden_name]
+        request = ActiveRestClient::Request.new(method, @request.object)
         request.url = request.forced_url = @url
         @object = request.call
       end

data/lib/active_rest_client/proxy_base.rb

@@ -1,3 +1,5 @@
+require "uri"
+
 module ActiveRestClient
   class ProxyBase
     cattr_accessor :mappings, :request, :original_handler

data/lib/active_rest_client/request.rb

@@ -28,6 +28,14 @@ module ActiveRestClient
       end
     end
 
+    def original_object_class
+      if object_is_class?
+        @object
+      else
+        @object.class
+      end
+    end
+
     def base_url
       if object_is_class?
         @object.base_url
@@ -87,12 +95,12 @@ module ActiveRestClient
         append_get_parameters
         prepare_request_body
         self.original_url = self.url
-        cached = ActiveRestClient::Base.read_cached_response(self)
+        cached = original_object_class.read_cached_response(self)
         if cached
           if cached.expires && cached.expires > Time.now
             ActiveRestClient::Logger.debug "  \033[1;4;32m#{ActiveRestClient::NAME}\033[0m #{@instrumentation_name} - Absolutely cached copy found"
             return handle_cached_response(cached)
-          elsif cached.etag.present?
+          elsif cached.etag.to_s != "" #present? isn't working for some reason
             ActiveRestClient::Logger.debug "  \033[1;4;32m#{ActiveRestClient::NAME}\033[0m #{@instrumentation_name} - Etag cached copy found with etag #{cached.etag}"
             etag = cached.etag
           end
@@ -111,7 +119,7 @@ module ActiveRestClient
         if result == :not_modified && cached
           result = cached.result
         end
-        ActiveRestClient::Base.write_cached_response(self, response, result)
+        original_object_class.write_cached_response(self, response, result)
         result
       end
     end
@@ -246,6 +254,11 @@ module ActiveRestClient
       else
         ActiveRestClient::Logger.debug "  \033[1;4;32m#{ActiveRestClient::NAME}\033[0m #{@instrumentation_name} - Response received #{response.body.size} bytes"
       end
+
+      if @method[:options][:plain]
+        return @response = response.body
+      end
+
       @response = response
 
       if response.body.is_a?(Array) || response.body.is_a?(Hash)

data/lib/active_rest_client/version.rb

@@ -1,3 +1,3 @@
 module ActiveRestClient
-  VERSION = "0.9.60"
+  VERSION = "0.9.65"
 end

data/spec/lib/base_spec.rb

@@ -214,6 +214,35 @@ describe ActiveRestClient::Base do
       expect(example.first_name).to eq("Billy")
     end
 
+    it "should be able to pass the plain response from the directly called URL bypassing JSON loading" do
+      response = OpenStruct.new(_status:200, body:"This is another non-JSON string")
+      ActiveRestClient::Connection.any_instance.should_receive(:post).with(any_args).and_return(OpenStruct.new(status:200, headers:{}, body:response))
+      expect(EmptyExample._plain_request("http://api.example.com/", :post, {id:1234})).to eq(response)
+    end
+
+    it "should cache plain requests separately" do
+      perform_caching = EmptyExample.perform_caching
+      cache_store = EmptyExample.cache_store
+      begin
+        response = OpenStruct.new(_status:200, body:"This is a non-JSON string")
+        other_response = OpenStruct.new(_status:200, body:"This is another non-JSON string")
+        allow_any_instance_of(ActiveRestClient::Connection).to receive(:get) do |url, others|
+          if url == "/?test=1"
+            OpenStruct.new(status:200, headers:{}, body:response)
+          else
+            OpenStruct.new(status:200, headers:{}, body:other_response)
+          end
+        end
+        EmptyExample.perform_caching = true
+        EmptyExample.cache_store = TestCacheStore.new
+        expect(EmptyExample._plain_request("http://api.example.com/?test=1")).to eq(response)
+        expect(EmptyExample._plain_request("http://api.example.com/?test=2")).to eq(other_response)
+      ensure
+        EmptyExample.perform_caching = perform_caching
+        EmptyExample.cache_store = cache_store
+      end
+    end
+
     it "should be able to lazy load a direct URL request" do
       ActiveRestClient::Request.any_instance.should_receive(:do_request).with(any_args).and_return(OpenStruct.new(status:200, headers:{}, body:"{\"first_name\":\"Billy\"}"))
       example = EmptyExample._lazy_request("http://api.example.com/")

data/spec/lib/caching_spec.rb

@@ -78,6 +78,10 @@ describe ActiveRestClient::Caching do
       expect{ ActiveRestClient::Base.cache_store = CachingExampleCacheStore3.new }.to raise_error
       expect{ ActiveRestClient::Base.cache_store = CachingExampleCacheStore4.new }.to raise_error
     end
+
+    it "should allow you to remove the custom cache store" do
+      expect{ ActiveRestClient::Base.cache_store = nil }.to_not raise_error
+    end
   end
 
   context "Reading/writing to the cache" do
@@ -106,7 +110,7 @@ describe ActiveRestClient::Caching do
         status:200,
         result:@cached_object,
         etag:@etag)
-      CachingExampleCacheStore5.any_instance.should_receive(:read).once.with("Person:/").and_return(cached_response)
+      CachingExampleCacheStore5.any_instance.should_receive(:read).once.with("Person:/").and_return(Marshal.dump(cached_response))
       ActiveRestClient::Connection.any_instance.should_receive(:get).with("/", hash_including("If-None-Match" => @etag)).and_return(OpenStruct.new(status:304, headers:{}))
       ret = Person.all
       expect(ret.first_name).to eq("Johnny")
@@ -117,7 +121,7 @@ describe ActiveRestClient::Caching do
         status:200,
         result:@cached_object,
         expires:Time.now + 30)
-      CachingExampleCacheStore5.any_instance.should_receive(:read).once.with("Person:/").and_return(cached_response)
+      CachingExampleCacheStore5.any_instance.should_receive(:read).once.with("Person:/").and_return(Marshal.dump(cached_response))
       ActiveRestClient::Connection.any_instance.should_not_receive(:get)
       ret = Person.all
       expect(ret.first_name).to eq("Johnny")
@@ -128,7 +132,7 @@ describe ActiveRestClient::Caching do
         status:200,
         result:@cached_object,
         expires:Time.now + 30)
-      CachingExampleCacheStore5.any_instance.should_receive(:read).once.with("Person:/").and_return(cached_response)
+      CachingExampleCacheStore5.any_instance.should_receive(:read).once.with("Person:/").and_return(Marshal.dump(cached_response))
       ActiveRestClient::Connection.any_instance.should_not_receive(:get)
       p = Person.new(first_name:"Billy")
       ret = p.all({})
@@ -146,7 +150,7 @@ describe ActiveRestClient::Caching do
         result:object,
         etag:@etag,
         expires:Time.now + 30)
-      CachingExampleCacheStore5.any_instance.should_receive(:read).once.with("Person:/").and_return(cached_response)
+      CachingExampleCacheStore5.any_instance.should_receive(:read).once.with("Person:/").and_return(Marshal.dump(cached_response))
       ActiveRestClient::Connection.any_instance.should_not_receive(:get)
       ret = Person.all
       expect(ret.first.first_name).to eq("Johnny")
@@ -162,15 +166,17 @@ describe ActiveRestClient::Caching do
 
     it "should write the response to the cache if there's an etag" do
       CachingExampleCacheStore5.any_instance.should_receive(:read).once.with("Person:/").and_return(nil)
-      CachingExampleCacheStore5.any_instance.should_receive(:write).once.with("Person:/", an_instance_of(ActiveRestClient::CachedResponse), {})
+      CachingExampleCacheStore5.any_instance.should_receive(:write).once.with("Person:/", an_instance_of(String), {})
       ActiveRestClient::Connection.any_instance.should_receive(:get).with("/", an_instance_of(Hash)).and_return(OpenStruct.new(status:200, body:"{\"result\":true}", headers:{etag:"1234567890"}))
+      Person.perform_caching true
       ret = Person.all
     end
 
     it "should write the response to the cache if there's a hard expiry" do
       CachingExampleCacheStore5.any_instance.should_receive(:read).once.with("Person:/").and_return(nil)
-      CachingExampleCacheStore5.any_instance.should_receive(:write).once.with("Person:/", an_instance_of(ActiveRestClient::CachedResponse), an_instance_of(Hash))
+      CachingExampleCacheStore5.any_instance.should_receive(:write).once.with("Person:/", an_instance_of(String), an_instance_of(Hash))
       ActiveRestClient::Connection.any_instance.should_receive(:get).with("/", an_instance_of(Hash)).and_return(OpenStruct.new(status:200, body:"{\"result\":true}", headers:{expires:(Time.now + 30).rfc822}))
+      Person.perform_caching = true
       ret = Person.all
     end
 

data/spec/lib/connection_manager_spec.rb

@@ -24,7 +24,7 @@ describe ActiveRestClient::ConnectionManager do
     other_base_url = "http://other.example.com"
     expect(ActiveRestClient::ConnectionManager.get_connection(base_url).base_url).to eq(base_url)
     expect(ActiveRestClient::ConnectionManager.get_connection(other_base_url).base_url).to eq(other_base_url)
-    expect(ActiveRestClient::ConnectionManager.instance_variable_get(:@_connections).size).to eq(2)
+    expect(Thread.current[:_connections].size).to eq(2)
   end
 
   it "should find a connection if you pass in URLs containing an existing connection's base_url" do

data/spec/lib/connection_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe ActiveRestClient::Connection do
-  before(:each) do
+  before do
     @connection = ActiveRestClient::Connection.new("http://www.example.com")
   end
 
@@ -30,7 +30,7 @@ describe ActiveRestClient::Connection do
 
   it "should pass a PUT request through to Patron" do
     @connection.session = double(Patron::Session)
-    @connection.session.stub(:put).with("/foo", "body", {}).and_return(OpenStruct.new(body:"{result:true}"))
+    allow(@connection.session).to receive(:put).with("/foo", "body", {}).and_return(OpenStruct.new(body:"{result:true}"))
     result = @connection.put("/foo", "body")
     expect(result.body).to eq("{result:true}")
   end

data/spec/lib/proxy_spec.rb

@@ -126,15 +126,24 @@ describe ActiveRestClient::Base do
   end
 
   it "caches responses in the standard way" do
+
+     cached_response = ActiveRestClient::CachedResponse.new(
+        status:200,
+        result:@cached_object,
+        etag:@etag)
+
     cache_store = double("CacheStore")
     cache_store.stub(:read).with(any_args).and_return(nil)
-    ActiveRestClient::Base.stub(:cache_store).and_return(cache_store)
+    ProxyClientExample.perform_caching true
+    ProxyClientExample.stub(:cache_store).and_return(cache_store)
     expiry = 10.minutes.from_now.rfc2822
     ActiveRestClient::Connection.any_instance.should_receive(:put).with("/update", "MY-BODY-CONTENT", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{"Expires" => expiry, "ETag" => "123456"}))
-    ActiveRestClient::Base.cache_store.should_receive(:write) do |key, object, options|
+    ProxyClientExample.cache_store.should_receive(:write) do |key, object, options|
       expect(key).to eq("ProxyClientExample:/update")
-      expect(object.etag).to eq("123456")
-      expect(object.expires).to eq(expiry)
+      expect(object).to be_an_instance_of(String)
+      unmarshalled = Marshal.load(object)
+      expect(unmarshalled.etag).to eq("123456")
+      expect(unmarshalled.expires).to eq(expiry)
     end
     ProxyClientExample.update(id:1)
   end

data/spec/lib/request_spec.rb

@@ -188,7 +188,7 @@ describe ActiveRestClient::Request do
       with("/create", "first_name=John&should_disappear=true", an_instance_of(Hash)).
       and_return(OpenStruct.new(body:"{\"first_name\":\"John\", \"id\":1234}", headers:{}, status:200))
     ActiveRestClient::Logger.should_receive(:info).with {|*args| args.first[%r{Requesting http://www.example.com/create}]}
-    ActiveRestClient::Logger.should_receive(:debug).with {|*args| args.first[/Response received \d+ bytes/]}
+    ActiveRestClient::Logger.should_receive(:debug).at_least(1).times.with {|*args| args.first[/Response received \d+ bytes/] || args.first["Reading from cache"]}
 
     object = ExampleClient.new(first_name:"John", should_disappear:true)
     object.create
@@ -202,7 +202,7 @@ describe ActiveRestClient::Request do
       with("/create", "first_name=John&should_disappear=true", an_instance_of(Hash)).
       and_return(OpenStruct.new(body:"{\"first_name\":\"John\", \"id\":1234}", headers:{}, status:200))
     ActiveRestClient::Logger.should_receive(:info).with {|*args| args.first[%r{Requesting http://www.example.com/create}]}
-    ActiveRestClient::Logger.should_receive(:debug).with {|*args| args.first[/Response received \d+ bytes/]}
+    ActiveRestClient::Logger.should_receive(:debug).at_least(1).times.with {|*args| args.first[/Response received \d+ bytes/] || args.first["Reading from cache"]}
 
     object = ExampleClient.new(first_name:"John", should_disappear:true)
     object.create
@@ -335,6 +335,7 @@ describe ActiveRestClient::Request do
     end
     fake_object = RequestFakeObject.new
     request = ActiveRestClient::Request.new(method, fake_object, {})
+    allow(fake_object).to receive(:read_cached_response).and_return(nil)
     expect{request.call}.to raise_error(ActiveRestClient::InvalidRequestException)
   end
 

data/spec/spec_helper.rb

@@ -20,3 +20,25 @@ RSpec.configure do |config|
   #     --seed 1234
   config.order = 'random'
 end
+
+class TestCacheStore
+  def initialize
+    @items = {}
+  end
+
+  def read(key)
+    @items[key]
+  end
+
+  def write(key, value, options={})
+    @items[key] = value
+  end
+
+  def fetch(key, &block)
+    read(key) || begin
+      value = block.call
+      write(value)
+      value
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_rest_client
 version: !ruby/object:Gem::Version
-  version: 0.9.60
+  version: 0.9.65
 platform: ruby
 authors:
 - Which Ltd
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-31 00:00:00.000000000 Z
+date: 2014-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler