flexirest 1.2.0

data/flexirest.gemspec

@@ -0,0 +1,39 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'flexirest/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "flexirest"
+  spec.version       = Flexirest::VERSION
+  spec.platform      = Gem::Platform::RUBY
+  spec.authors       = ["Which Ltd", "Andy Jeffries"]
+  spec.email         = ["swlicensing@which.co.uk", "andy@andyjeffries.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://whichdigital.github.io/"
+  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", "~> 3"
+  spec.add_development_dependency "webmock"
+  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_development_dependency 'coveralls'
+  spec.add_development_dependency "api-auth", ">= 1.3.1"
+  spec.add_development_dependency 'typhoeus'
+
+  spec.add_runtime_dependency "multi_json"
+  spec.add_runtime_dependency "crack"
+  spec.add_runtime_dependency "activesupport"
+  spec.add_runtime_dependency "faraday"
+end

data/lib/flexirest.rb

@@ -0,0 +1,25 @@
+require 'active_support/all'
+require "flexirest/version"
+require "flexirest/mapping"
+require "flexirest/caching"
+require "flexirest/logger"
+require "flexirest/configuration"
+require "flexirest/connection"
+require "flexirest/connection_manager"
+require "flexirest/instrumentation"
+require "flexirest/result_iterator"
+require "flexirest/headers_list"
+require "flexirest/lazy_loader"
+require "flexirest/lazy_association_loader"
+require "flexirest/request"
+require "flexirest/request_delegator"
+require "flexirest/validation"
+require "flexirest/request_filtering"
+require "flexirest/proxy_base"
+require "flexirest/recording"
+require "flexirest/base"
+require "flexirest/monkey_patching"
+
+module Flexirest
+  NAME = "Flexirest"
+end

data/lib/flexirest/base.rb

@@ -0,0 +1,189 @@
+module Flexirest
+  class Base
+    include Mapping
+    include Configuration
+    include RequestFiltering
+    include Validation
+    include Caching
+    include Recording
+
+    attr_accessor :_status
+    attr_accessor :_etag
+    attr_accessor :_headers
+
+    instance_methods.each do |m|
+      next unless %w{display presence load require hash untrust trust freeze method enable_warnings with_warnings suppress capture silence quietly debugger breakpoint}.map(&:to_sym).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 == "Flexirest::Base"
+
+      attrs.each do |attribute_name, attribute_value|
+        attribute_name = attribute_name.to_sym
+        if attribute_value.to_s[/^([\+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6]))))$/]
+          @attributes[attribute_name] = Date.parse(attribute_value)
+        elsif attribute_value.to_s[/^([\+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))([T\s]((([01]\d|2[0-3])((:?)[0-5]\d)?|24\:?00)([\.,]\d+(?!:))?)?(\17[0-5]\d([\.,]\d+)?)?([zZ]|([\+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)?$/]
+          @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 errors
+      @attributes[:errors] || (_errors != {} ? _errors : nil)
+    end
+
+    def self._request(request, method = :get, params = nil)
+      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)
+      Flexirest::LazyLoader.new(prepare_direct_request(request, method), params)
+    end
+
+    def self.prepare_direct_request(request, method, options={})
+      unless request.is_a? Flexirest::Request
+        options[:plain] ||= false
+        mapped = {url:"DIRECT-CALLED-#{request}", method:method, options:{url:request, plain:options[:plain]}}
+
+        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 inspect
+      inspection = if @attributes.any?
+                     @attributes.collect { |key, value|
+                       "#{key}: #{value_for_inspect(value)}"
+                     }.compact.join(", ")
+                   else
+                     "[uninitialized]"
+                   end
+      inspection += "#{"," if @attributes.any?} ETag: #{@_etag}" unless @_etag.nil?
+      inspection += "#{"," if @attributes.any?} Status: #{@_status}" unless @_status.nil?
+      inspection += " (unsaved: #{@dirty_attributes.map(&:to_s).join(", ")})" if @dirty_attributes.any?
+      "#<#{self.class} #{inspection}>"
+    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)
+            Flexirest::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
+
+    def to_hash
+      output = {}
+      @attributes.each do |key, value|
+        if value.is_a? Flexirest::Base
+          output[key.to_s] = value.to_hash
+        elsif value.is_a? Array
+          output[key.to_s] = value.map(&:to_hash)
+        else
+          output[key.to_s] = value
+        end
+      end
+      output
+    end
+
+    def to_json
+      output = to_hash
+      output.to_json
+    end
+
+    private
+
+    def value_for_inspect(value)
+      if value.is_a?(String) && value.length > 50
+        "#{value[0..50]}...".inspect
+      elsif value.is_a?(Date) || value.is_a?(Time)
+        %("#{value.to_s(:db)}")
+      else
+        value.inspect
+      end
+    end
+
+  end
+
+  class NoAttributeException < StandardError ; end
+  class ValidationFailedException < StandardError ; end
+  class MissingOptionalLibraryError < StandardError ; end
+end

data/lib/flexirest/caching.rb

@@ -0,0 +1,92 @@
+module Flexirest
+  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)
+        @@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)
+        @@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 && perform_caching
+          key = "#{request.class_name}:#{request.original_url}"
+          Flexirest::Logger.debug "  \033[1;4;32m#{Flexirest::NAME}\033[0m #{key} - Trying to read 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)
+        headers = response.response_headers
+
+        headers.keys.select{|h| h.is_a? String}.each do |key|
+          headers[key.downcase.to_sym] = headers[key]
+        end
+
+        if cache_store && (headers[:etag] || headers[:expires])
+          key = "#{request.class_name}:#{request.original_url}"
+          Flexirest::Logger.debug "  \033[1;4;32m#{Flexirest::NAME}\033[0m #{key} - Writing to cache"
+          cached_response = CachedResponse.new(status:response.status, result:result)
+          cached_response.etag = headers[:etag] if headers[:etag]
+          cached_response.expires = Time.parse(headers[:expires]) rescue nil if headers[:expires]
+          cache_store.write(key, Marshal.dump(cached_response), {}) if cached_response.etag.present? || cached_response.expires
+        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/flexirest/configuration.rb

@@ -0,0 +1,209 @@
+require 'cgi'
+
+module Flexirest
+  module Configuration
+    module ClassMethods
+      @@base_url = nil
+      @@username = nil
+      @@password = nil
+      @@request_body_type = :form_encoded
+      @lazy_load = false
+      @api_auth_access_id = nil
+      @api_auth_secret_key = nil
+
+      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)
+        Flexirest::Logger.info "\033[1;4;32m#{name}\033[0m Base URL set to be #{value}"
+        value = value.gsub(/\/+$/, '')
+        @@base_url = value
+      end
+
+      def username(value = nil)
+        if value.nil?
+          if @username.nil?
+            @@username
+          else
+            @username
+          end
+        else
+          value = CGI::escape(value) if value.present? && !value.include?("%")
+          @username = value
+        end
+      end
+
+      def username=(value)
+        Flexirest::Logger.info "\033[1;4;32m#{name}\033[0m Username set to be #{value}"
+        value = CGI::escape(value) if value.present? && !value.include?("%")
+        @@username = value
+      end
+
+      def password(value = nil)
+        if value.nil?
+          if @password.nil?
+            @@password
+          else
+            @password
+          end
+        else
+          value = CGI::escape(value) if value.present? && !value.include?("%")
+          @password = value
+        end
+      end
+
+      def password=(value)
+        Flexirest::Logger.info "\033[1;4;32m#{name}\033[0m Password set..."
+        value = CGI::escape(value) if value.present? && !value.include?("%")
+        @@password = value
+      end
+
+      def request_body_type(value = nil)
+        if value.nil?
+          if @request_body_type.nil?
+            @@request_body_type
+          else
+            @request_body_type
+          end
+        else
+          @request_body_type = value
+        end
+      end
+
+      def request_body_type=(value)
+        Flexirest::Logger.info "\033[1;4;32m#{name}\033[0m Request Body Type set to be #{value}"
+        @@request_body_type = value
+      end
+
+      def adapter=(adapter)
+        Flexirest::Logger.info "\033[1;4;32m#{name}\033[0m Adapter set to be #{adapter}"
+        @adapter = adapter
+      end
+
+      def adapter
+        @adapter ||= Faraday.default_adapter
+      end
+
+      def faraday_config(&block)
+        if block
+          @faraday_config = block
+        else
+          @faraday_config ||= default_faraday_config
+        end
+      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 api_auth_credentials(access_id, secret_key)
+        begin
+          require 'api-auth'
+        rescue LoadError
+          raise MissingOptionalLibraryError.new("You must include the gem 'api-auth' in your Gemfile to set api-auth credentials.")
+        end
+
+        @api_auth_access_id = access_id
+        @api_auth_secret_key = secret_key
+      end
+
+      def using_api_auth?
+        !self.api_auth_access_id.nil? && !self.api_auth_secret_key.nil?
+      end
+
+      def api_auth_access_id
+        if !@api_auth_access_id.nil?
+          return @api_auth_access_id
+        elsif self.superclass.respond_to?(:api_auth_access_id)
+          return self.superclass.api_auth_access_id
+        end
+
+        return nil
+      end
+
+      def api_auth_secret_key
+        if !@api_auth_secret_key.nil?
+          return @api_auth_secret_key
+        elsif self.superclass.respond_to?(:api_auth_secret_key)
+          return self.superclass.api_auth_secret_key
+        end
+
+        return nil
+      end
+
+      def verbose!
+        @verbose = true
+      end
+
+      def verbose(value = nil)
+        value ? @verbose = value : @verbose || false
+      end
+
+      def translator(value = nil)
+        Flexirest::Logger.warn("DEPRECATION: The translator functionality of Flexirest 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
+        @request_body_type    = nil
+        @@request_body_type   = :form_encoded
+        @whiny_missing        = nil
+        @lazy_load            = false
+        @faraday_config       = default_faraday_config
+        @adapter              = Faraday.default_adapter
+        @api_auth_access_id   = nil
+        @api_auth_secret_key  = nil
+      end
+
+      private
+
+      def default_faraday_config
+        Proc.new do |faraday|
+          faraday.adapter(adapter)
+
+          if faraday.options.respond_to?(:timeout=)
+            faraday.options.timeout         = 10
+            faraday.options.open_timeout    = 10
+          else
+            faraday.options['timeout']      = 10
+            faraday.options['open_timeout'] = 10
+          end
+
+          faraday.headers['User-Agent'] = "Flexirest/#{Flexirest::VERSION}"
+          faraday.headers['Connection'] = "Keep-Alive"
+          faraday.headers['Accept']     = "application/json"
+        end
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  end
+
+  class InvalidCacheStoreException < StandardError ; end
+end