flexirest 1.2.0

data/lib/flexirest/connection.rb

@@ -0,0 +1,103 @@
+require 'faraday'
+
+module Flexirest
+
+  class TimeoutException < StandardError ; end
+  class ConnectionFailedException < StandardError ; end
+
+  class Connection
+    attr_accessor :session, :base_url
+
+    def initialize(base_url)
+      @base_url                      = base_url
+      @session                       = new_session
+    end
+
+    def reconnect
+      @session         = new_session
+    end
+
+    def headers
+      @session.headers
+    end
+
+    def make_safe_request(path, &block)
+      block.call
+    rescue Faraday::Error::TimeoutError
+      raise Flexirest::TimeoutException.new("Timed out getting #{full_url(path)}")
+    rescue Faraday::Error::ConnectionFailed
+      begin
+        reconnect
+        block.call
+      rescue Faraday::Error::ConnectionFailed
+        raise Flexirest::ConnectionFailedException.new("Unable to connect to #{full_url(path)}")
+      end
+    end
+
+    def get(path, options={})
+      set_defaults(options)
+      make_safe_request(path) do
+        @session.get(path) do |req|
+          req.headers = req.headers.merge(options[:headers])
+          sign_request(req, options[:api_auth])
+        end
+      end
+    end
+
+    def put(path, data, options={})
+      set_defaults(options)
+      make_safe_request(path) do
+        @session.put(path) do |req|
+          req.headers = req.headers.merge(options[:headers])
+          req.body = data
+          sign_request(req, options[:api_auth])
+        end
+      end
+    end
+
+    def post(path, data, options={})
+      set_defaults(options)
+      make_safe_request(path) do
+        @session.post(path) do |req|
+          req.headers = req.headers.merge(options[:headers])
+          req.body = data
+          sign_request(req, options[:api_auth])
+        end
+      end
+    end
+
+    def delete(path, options={})
+      set_defaults(options)
+      make_safe_request(path) do
+        @session.delete(path) do |req|
+          req.headers = req.headers.merge(options[:headers])
+          sign_request(req, options[:api_auth])
+        end
+      end
+    end
+
+    private
+
+    def new_session
+      Faraday.new({url: @base_url}, &Flexirest::Base.faraday_config)
+    end
+
+    def full_url(path)
+      @session.build_url(path).to_s
+    end
+
+    def set_defaults(options)
+      options[:headers]   ||= {}
+      options[:api_auth]  ||= {}
+      return options
+    end
+
+    def sign_request(request, api_auth)
+      return if api_auth[:api_auth_access_id].nil? || api_auth[:api_auth_secret_key].nil?
+      ApiAuth.sign!(
+        request,
+        api_auth[:api_auth_access_id],
+        api_auth[:api_auth_secret_key])
+    end
+  end
+end

data/lib/flexirest/connection_manager.rb

@@ -0,0 +1,36 @@
+module Flexirest
+  class ConnectionManager
+    def self.reset!
+      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?
+      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)
+      Thread.current[:_connections] ||= {}
+      found = Thread.current[:_connections].keys.detect {|key| url[0,key.length] == key}
+      Thread.current[:_connections][found] if found
+    end
+
+    def self.in_parallel(base_url)
+      begin
+        require 'typhoeus'
+        require 'typhoeus/adapters/faraday'
+      rescue LoadError
+        raise MissingOptionalLibraryError.new("To call '::Flexirest::ConnectionManager.in_parallel' you must include the gem 'Typhoeus' in your Gemfile.")
+      end
+      session = ConnectionManager.get_connection(base_url).session
+      session.in_parallel do
+        yield
+      end
+    end
+
+  end
+
+  class MissingOptionalLibraryError < StandardError ; end
+end

data/lib/flexirest/headers_list.rb

@@ -0,0 +1,47 @@
+module Flexirest
+  class HeadersList
+    STORE_MULTIPLE_VALUES = ["set-cookie"]
+    def initialize
+      @store = {}
+    end
+
+    def []=(key,value)
+      key = find_existing(key)
+      if STORE_MULTIPLE_VALUES.include?(key.downcase)
+        @store[key] ||= []
+        @store[key] << value
+      else
+        @store[key] = value
+      end
+    end
+
+    def [](key)
+      key = find_existing(key)
+      @store[key]
+    end
+
+    def each(split_multiple_headers = false)
+      @store.keys.each do |key|
+        value = @store[key]
+        if value.is_a?(Array) && split_multiple_headers
+          value.each do |inner_value|
+            yield(key, inner_value)
+          end
+        else
+          yield(key, value)
+        end
+      end
+    end
+
+    private
+
+    def find_existing(key)
+      key_downcase = key.downcase
+      @store.keys.each do |found_key|
+        return found_key if found_key.downcase == key_downcase
+      end
+      key
+    end
+
+  end
+end

data/lib/flexirest/instrumentation.rb

@@ -0,0 +1,62 @@
+module Flexirest
+  class Instrumentation < ActiveSupport::LogSubscriber
+    def request_call(event)
+      self.class.time_spent += event.duration
+      self.class.calls_made += 1
+      name = '%s (%.1fms)' % [Flexirest::NAME, event.duration]
+      Flexirest::Logger.debug "  \033[1;4;32m#{name}\033[0m #{event.payload[:name]}"
+    end
+
+    def self.time_spent=(value)
+      @@time_spent = value
+    end
+
+    def self.time_spent
+      @@time_spent ||= 0
+    end
+
+    def self.calls_made=(value)
+      @@calls_made = value
+    end
+
+    def self.calls_made
+      @@calls_made ||= 0
+    end
+
+    def self.reset
+      @@time_spent = 0
+      @@calls_made = 0
+    end
+
+    def logger
+      Flexirest::Logger
+    end
+  end
+
+  module ControllerInstrumentation
+    extend ActiveSupport::Concern
+
+    protected
+
+    def append_info_to_payload(payload)
+      super
+      payload[:flexirest_time_spent] = Flexirest::Instrumentation.time_spent
+      payload[:flexirest_calls_made] = Flexirest::Instrumentation.calls_made
+    end
+
+    module ClassMethods
+      def log_process_action(payload)
+        messages, time_spent, calls_made = super, payload[:flexirest_time_spent], payload[:flexirest_calls_made]
+        messages << ("#{Flexirest::NAME}: %.1fms for %d calls" % [time_spent.to_f, calls_made]) if calls_made
+        Flexirest::Instrumentation.reset
+        messages
+      end
+    end
+  end
+end
+
+Flexirest::Instrumentation.attach_to :flexirest
+
+ActiveSupport.on_load(:action_controller) do
+  include Flexirest::ControllerInstrumentation
+end

data/lib/flexirest/lazy_association_loader.rb

@@ -0,0 +1,97 @@
+require 'active_support/hash_with_indifferent_access'
+
+module Flexirest
+  class LazyAssociationLoader
+    include Enumerable
+
+    def initialize(name, value, request, options = {})
+      @name = name
+      class_to_map = request.method[:options][:lazy][name] rescue nil
+      @request = class_to_map.nil? ? request : Flexirest::Request.new(class_to_map._mapped_method(:find), class_to_map.new, options)
+      @object = nil
+      @options = options
+      if value.is_a? Array
+        @subloaders = value.map {|url| LazyAssociationLoader.new(name, url, request, options)}
+      elsif value.is_a?(Hash) && (value.has_key?("url") || value.has_key?(:url))
+        @url = (value["url"] || value[:url])
+      elsif value.is_a?(Hash) && (value.has_key?("href") || value.has_key?(:href)) # HAL
+        @url = (value["href"] || value[:href])
+        @_hal_attributes = HashWithIndifferentAccess.new(value)
+      elsif value.is_a?(Hash)
+        mapped = {}
+        value.each do |k,v|
+          mapped[k.to_sym] = LazyAssociationLoader.new(name, v, request, options)
+        end
+        @subloaders = mapped
+        # Need to also ensure that the hash/wrapped object is returned when the property is accessed
+      elsif value.is_a? String
+        @url = value
+      else
+        raise InvalidLazyAssociationContentException.new("Invalid content for #{@name}, expected Array, String or Hash containing 'url' key")
+      end
+    end
+
+    def _hal_attributes(key)
+      @_hal_attributes[key]
+    end
+
+    def size
+      if @subloaders
+        @subloaders.size
+      else
+        ensure_lazy_loaded
+        @object.size
+      end
+    end
+
+    def each
+      if @subloaders
+        if @subloaders.is_a? Array
+          @subloaders.each do |loader|
+            yield loader
+          end
+        elsif @subloaders.is_a? Hash
+          @subloaders.each do |key,value|
+            yield key, value
+          end
+        end
+      else
+        ensure_lazy_loaded
+        @object.each do |obj|
+          yield obj
+        end
+      end
+    end
+
+    def keys
+      @subloaders.keys
+    end
+
+    def method_missing(name, *args)
+      if @subloaders.is_a? Hash
+        return @subloaders[name.to_sym]
+      end
+      ensure_lazy_loaded
+      if @object
+        @object.send(name, *args)
+      end
+    end
+
+    private
+
+    def ensure_lazy_loaded
+      if @object.nil?
+        method = MultiJson.load(MultiJson.dump(@request.method),:symbolize_keys => true)
+        method[:method] = :get
+        method[:options][:url] = @url
+        method[:options][:overridden_name] = @options[:overridden_name]
+        request = Flexirest::Request.new(method, @request.object)
+        request.url = request.forced_url = @url
+        @object = request.call
+      end
+    end
+  end
+
+  class InvalidLazyAssociationContentException < Exception ; end
+
+end

data/lib/flexirest/lazy_loader.rb

@@ -0,0 +1,23 @@
+module Flexirest
+  class LazyLoader
+    def initialize(request, params = nil)
+      @request = request
+      @params = params
+      @result = nil
+    end
+
+    def method_missing(name, *args)
+      if @result.nil?
+        @result = @request.call(@params)
+      end
+      @result.send(name, *args)
+    end
+
+    def respond_to?(name)
+      if @result.nil?
+        @result = @request.call(@params)
+      end
+      @result.respond_to?(name)
+    end
+  end
+end

data/lib/flexirest/logger.rb

@@ -0,0 +1,67 @@
+module Flexirest
+  class Logger
+    @logfile = nil
+    @messages = []
+
+    def self.logfile=(value)
+      @logfile = value
+    end
+
+    def self.messages
+      @messages
+    end
+
+    def self.reset!
+      @logfile = nil
+      @messages = []
+    end
+
+    def self.debug(message)
+      if defined?(Rails) && Rails.respond_to?(:logger)
+        Rails.logger.debug(message)
+      elsif @logfile
+        File.open(@logfile, "a") do |f|
+          f << "#{message}\n"
+        end
+      else
+        @messages << message
+      end
+    end
+
+    def self.info(message)
+      if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+        Rails.logger.info(message)
+      elsif @logfile
+        File.open(@logfile, "a") do |f|
+          f << "#{message}\n"
+        end
+      else
+        @messages << message
+      end
+    end
+
+    def self.warn(message)
+      if defined?(Rails) && Rails.respond_to?(:logger)
+        Rails.logger.warn(message)
+      elsif @logfile
+        File.open(@logfile, "a") do |f|
+          f << "#{message}\n"
+        end
+      else
+        @messages << message
+      end
+    end
+
+    def self.error(message)
+      if defined?(Rails) && Rails.respond_to?(:logger)
+        Rails.logger.error(message)
+      elsif @logfile
+        File.open(@logfile, "a") do |f|
+          f << "#{message}\n"
+        end
+      else
+        @messages << message
+      end
+    end
+  end
+end

data/lib/flexirest/mapping.rb

@@ -0,0 +1,69 @@
+module Flexirest
+  module Mapping
+    module ClassMethods
+      def get(name, url, options = {})
+        _map_call(name, url:url, method: :get, options:options)
+      end
+
+      def put(name, url, options = {})
+        _map_call(name, url:url, method: :put, options:options)
+      end
+
+      def post(name, url, options = {})
+        _map_call(name, url:url, method: :post, options:options)
+      end
+
+      def delete(name, url, options = {})
+        _map_call(name, url:url, method: :delete, options:options)
+      end
+
+      def patch(name, url, options = {})
+        _map_call(name, url:url, method: :patch, options:options)
+      end
+
+      def _map_call(name, details)
+        _calls[name] = {name:name}.merge(details)
+        _calls["lazy_#{name}".to_sym] = {name:name}.merge(details)
+        self.class.send(:define_method, name) do |options={}|
+          _call(name, options)
+        end
+        self.class.send(:define_method, "lazy_#{name}".to_sym) do |options={}|
+          _call("lazy_#{name}", options)
+        end
+      end
+
+      def _call(name, options)
+        mapped = _calls[name]
+        lazy_forced = false
+        if mapped.nil? && name.to_s[/^lazy_/]
+          mapped = _calls[name.to_s.gsub(/^lazy_/, '').to_sym]
+          lazy_forced = true
+        end
+        request = Request.new(mapped, self, options)
+        if lazy_load? || lazy_forced
+          Flexirest::LazyLoader.new(request)
+        else
+          request.call
+        end
+      end
+
+      def _calls
+        @_calls
+      end
+
+      def _mapped_method(name)
+        _calls[name]
+      end
+
+      def inherited(subclass)
+        subclass.instance_variable_set(:@_calls, {})
+      end
+
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+  end
+end