active_rest_client 0.9.58

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new('spec')

data/active_rest_client.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_rest_client/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "active_rest_client"
+  spec.version       = ActiveRestClient::VERSION
+  spec.platform      = Gem::Platform::RUBY
+  spec.authors       = ["Andy Jeffries"]
+  spec.email         = ["andy.jeffries@which.co.uk"]
+  spec.description   = %q{Accessing REST services in an ActiveRecord style}
+  spec.summary       = %q{This gem is for accessing REST services in an ActiveRecord style.  ActiveResource already exists for this, but it doesn't work where the resource naming doesn't follow Rails conventions, it doesn't have in-built caching and it's not as flexible in general.}
+  spec.homepage      = "http://www.which.co.uk/"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec_junit_formatter"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "simplecov-rcov"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency 'terminal-notifier-guard'
+
+  spec.add_runtime_dependency "oj", "=2.1.4" # 2.1.7 breaks under linux 
+  spec.add_runtime_dependency "activesupport"
+  spec.add_runtime_dependency "patron", '=0.4.9' # 0.4.18 breaks against Curl v0.7.15
+end

data/lib/active_rest_client.rb

@@ -0,0 +1,23 @@
+require 'active_support'
+require "active_rest_client/version"
+require "active_rest_client/mapping"
+require "active_rest_client/caching"
+require "active_rest_client/logger"
+require "active_rest_client/configuration"
+require "active_rest_client/connection"
+require "active_rest_client/connection_manager"
+require "active_rest_client/instrumentation"
+require "active_rest_client/result_iterator"
+require "active_rest_client/headers_list"
+require "active_rest_client/lazy_loader"
+require "active_rest_client/lazy_association_loader"
+require "active_rest_client/request"
+require "active_rest_client/validation"
+require "active_rest_client/request_filtering"
+require "active_rest_client/proxy_base"
+require "active_rest_client/recording"
+require "active_rest_client/base"
+
+module ActiveRestClient
+  NAME = "ActiveRestClient"
+end

data/lib/active_rest_client/base.rb

@@ -0,0 +1,128 @@
+module ActiveRestClient
+  class Base
+    include Mapping
+    include Configuration
+    include RequestFiltering
+    include Validation
+    include Caching
+    include Recording
+
+    attr_accessor :_status
+
+    instance_methods.each do |m|
+      next unless %i{display errors presence load require hash untrust trust freeze method enable_warnings with_warnings suppress capture silence quietly debugger breakpoint}.include? m
+      undef_method m
+    end
+
+    def initialize(attrs={})
+      @attributes = {}
+      @dirty_attributes = Set.new
+
+      raise Exception.new("Cannot instantiate Base class") if self.class.name == "ActiveRestClient::Base"
+
+      attrs.each do |attribute_name, attribute_value|
+        attribute_name = attribute_name.to_sym
+        if attribute_value.to_s[/\d{4}\-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(Z|[+-]\d{2}:\d{2})/]
+          @attributes[attribute_name] = DateTime.parse(attribute_value)
+        else
+          @attributes[attribute_name] = attribute_value
+        end
+        @dirty_attributes << attribute_name
+      end
+    end
+
+    def _clean!
+      @dirty_attributes = Set.new
+    end
+
+    def _attributes
+      @attributes
+    end
+
+    def _copy_from(result)
+      @attributes =  result._attributes
+      @_status = result._status
+    end
+
+    def dirty?
+      @dirty_attributes.size > 0
+    end
+
+    def self._request(request, method = :get, params = nil)
+      prepare_direct_request(request, method).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)
+      unless request.is_a? ActiveRestClient::Request
+        mapped = {url:"DIRECT-CALLED-URL", method:method, options:{url:request}}
+        request = Request.new(mapped, self)
+      end
+      request
+    end
+
+    def self._request_for(method_name, *args)
+      if mapped = self._mapped_method(method_name)
+        params = (args.first.is_a?(Hash) ? args.first : nil)
+        request = Request.new(mapped, self, params)
+        request
+      else
+        nil
+      end
+    end
+
+    def [](key)
+      @attributes[key.to_sym]
+    end
+
+    def []=(key, value)
+      @attributes[key.to_sym] = value
+      @dirty_attributes << key
+    end
+
+    def each
+      @attributes.each do |key, value|
+        yield key, value
+      end
+    end
+
+    def method_missing(name, *args)
+      if name.to_s[-1,1] == "="
+        name = name.to_s.chop.to_sym
+        @attributes[name] = args.first
+        @dirty_attributes << name
+      else
+        name_sym = name.to_sym
+        name = name.to_s
+
+        if @attributes.has_key? name_sym
+          @attributes[name_sym]
+        else
+          if name[/^lazy_/] && mapped = self.class._mapped_method(name_sym)
+            raise ValidationFailedException.new unless valid?
+            request = Request.new(mapped, self, args.first)
+            ActiveRestClient::LazyLoader.new(request)
+          elsif mapped = self.class._mapped_method(name_sym)
+            raise ValidationFailedException.new unless valid?
+            request = Request.new(mapped, self, args.first)
+            request.call
+          elsif self.class.whiny_missing
+            raise NoAttributeException.new("Missing attribute #{name_sym}")
+          else
+            nil
+          end
+        end
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      @attributes.has_key? method_name.to_sym
+    end
+  end
+
+  class NoAttributeException < StandardError ; end
+  class ValidationFailedException < StandardError ; end
+end

data/lib/active_rest_client/caching.rb

@@ -0,0 +1,84 @@
+module ActiveRestClient
+  module Caching
+    module ClassMethods
+      @@perform_caching = true
+
+      def perform_caching(value = nil)
+        if value.nil?
+          if @perform_caching.nil?
+            @@perform_caching
+          else
+            @perform_caching
+          end
+        else
+          @perform_caching = value
+        end
+      end
+
+      def perform_caching=(value)
+        @@perform_caching = value
+        @perform_caching = value
+      end
+
+      def cache_store=(value)
+        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)
+        @@cache_store = value
+      end
+
+      def cache_store
+        rails_cache_store = if Object.const_defined?(:Rails)
+          ::Rails.cache
+        else
+          nil
+        end
+        (@@cache_store rescue nil) || rails_cache_store
+      end
+
+      def _reset_caching!
+        @@perform_caching = false
+        @perform_caching = false
+        @@cache_store = nil
+      end
+
+      def read_cached_response(request)
+        if cache_store
+          key = "#{request.class_name}:#{request.original_url}"
+          cache_store.read(key)
+        end
+      end
+
+      def write_cached_response(request, response, result)
+        response.headers.keys.select{|h| h.is_a? String}.each do |key|
+          response.headers[key.downcase.to_sym] = response.headers[key]
+        end
+
+        if cache_store && (response.headers[:etag] || response.headers[:expires])
+          key = "#{request.class_name}:#{request.original_url}"
+          ActiveRestClient::Logger.debug "  \033[1;4;32m#{ActiveRestClient::NAME}\033[0m #{key} - Writing to cache"
+          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, {})
+        end
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+  end
+
+  class CachedResponse
+    attr_accessor :status, :result, :etag, :expires
+
+    def initialize(options)
+      @status = options[:status]
+      @result = options[:result]
+      @etag = options[:etag]
+      @expires = options[:expires]
+    end
+  end
+end

data/lib/active_rest_client/configuration.rb

@@ -0,0 +1,69 @@
+module ActiveRestClient
+  module Configuration
+    module ClassMethods
+      @@base_url = nil
+      @lazy_load = false
+
+      def base_url(value = nil)
+        if value.nil?
+          if @base_url.nil?
+            @@base_url
+          else
+            @base_url
+          end
+        else
+          value = value.gsub(/\/$/, '')
+          @base_url = value
+        end
+      end
+
+      def base_url=(value)
+        ActiveRestClient::Logger.info "\033[1;4;32m#{name}\033[0m Base URL set to be #{value}"
+        value = value.gsub(/\/+$/, '')
+        @@base_url = value
+      end
+
+      def lazy_load!
+        @lazy_load = true
+      end
+
+      def lazy_load?
+        @lazy_load || false
+      end
+
+      def whiny_missing(value = nil)
+        value ? @whiny_missing = value : @whiny_missing || false
+      end
+
+      def verbose!
+        @verbose = true
+      end
+
+      def verbose(value = nil)
+        value ? @verbose = value : @verbose || false
+      end
+
+      def translator(value = nil)
+        ActiveRestClient::Logger.warn("DEPRECATION: The translator functionality of ActiveRestClient has been replaced with proxy functionality, see https://github.com/whichdigital/active-rest-client#proxying-apis for more information") unless value.nil?
+        value ? @translator = value : @translator || nil
+      end
+
+      def proxy(value = nil)
+        value ? @proxy = value : @proxy || nil
+      end
+
+      def _reset_configuration!
+        @base_url         = nil
+        @@base_url        = nil
+        @whiny_missing    = nil
+        @lazy_load        = false
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  end
+
+  class InvalidCacheStoreException < StandardError ; end
+end

data/lib/active_rest_client/connection.rb

@@ -0,0 +1,76 @@
+require 'patron'
+
+module ActiveRestClient
+
+  class TimeoutException < StandardError ; end
+  class ConnectionFailedException < StandardError ; end
+
+  class Connection
+    attr_accessor :session, :base_url
+
+    def initialize(base_url)
+      @base_url                      = base_url
+      @session                       = Patron::Session.new
+      @session.timeout               = 10
+      @session.connect_timeout       = 10
+      @session.base_url              = base_url
+      @session.insecure              = true
+      @session.headers['User-Agent'] = "ActiveRestClient/#{ActiveRestClient::VERSION}"
+      @session.headers['Connection'] = "Keep-Alive"
+      @session.headers['Accept']     = "application/json"
+    end
+
+    def reconnect
+      session          = Patron::Session.new
+      session.timeout  = @session.timeout
+      session.base_url = @session.base_url
+      session.insecure              = true
+      @session.headers.each do |k,v|
+        session.headers[k] = v
+      end
+      @session         = session
+    end
+
+    def headers
+      @session.headers
+    end
+
+    def make_safe_request(path, &block)
+      block.call
+    rescue Patron::TimeoutError
+      raise ActiveRestClient::TimeoutException.new("Timed out getting #{@base_url}#{path}")
+    rescue Patron::ConnectionFailed
+      begin
+        reconnect
+        block.call
+      rescue Patron::ConnectionFailed
+        raise ActiveRestClient::ConnectionFailedException.new("Unable to connect to #{@base_url}#{path}")
+      end
+    end
+
+    def get(path, headers={})
+      make_safe_request(path) do
+        @session.get(path, headers)
+      end
+    end
+
+    def put(path, data, headers={})
+      make_safe_request(path) do
+        @session.put(path, data, headers)
+      end
+    end
+
+    def post(path, data, headers={})
+      make_safe_request(path) do
+        @session.post(path, data, headers)
+      end
+    end
+
+    def delete(path, headers={})
+      make_safe_request(path) do
+        @session.delete(path, headers)
+      end
+    end
+
+  end
+end

data/lib/active_rest_client/connection_manager.rb

@@ -0,0 +1,21 @@
+module ActiveRestClient
+  class ConnectionManager
+    def self.reset!
+      @_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]
+    end
+
+    def self.find_connection_for_url(url)
+      @_connections ||= {}
+      found = @_connections.keys.detect {|key| url[0,key.length] == key}
+      @_connections[found] if found
+    end
+
+  end
+end