acfs 1.3.3 → 1.3.4

data/acfs.gemspec

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'acfs/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'acfs'
+  spec.version       = Acfs::VERSION
+  spec.authors       = ['Jan Graichen']
+  spec.email         = %w[jgraichen@altimos.de]
+  spec.homepage      = 'https://github.com/jgraichen/acfs'
+  spec.license       = 'MIT'
+  spec.description   = 'API Client For Services'
+  spec.summary       = <<~SUMMARY.strip
+    An abstract API base client for service oriented application.
+  SUMMARY
+
+  spec.files = Dir['**/*'].grep(%r{
+    ^((bin|lib|test|spec|features)/|
+    .*\.gemspec|.*LICENSE.*|.*README.*|.*CHANGELOG.*)
+  }xi)
+
+  spec.executables   = spec.files.grep(%r{^bin/}) {|f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = %w[lib]
+
+  spec.add_runtime_dependency 'actionpack', '>= 4.2'
+  spec.add_runtime_dependency 'activemodel', '>= 4.2'
+  spec.add_runtime_dependency 'activesupport', '>= 4.2'
+  spec.add_runtime_dependency 'multi_json'
+
+  # Bundle update w/o version resolves to 0.3.3 ...
+  spec.add_runtime_dependency 'typhoeus', '~> 1.0'
+
+  spec.add_runtime_dependency 'rack'
+
+  spec.add_development_dependency 'bundler'
+
+  if ENV['TRAVIS_BUILD_NUMBER'] && !ENV['TRAVIS_TAG']
+    # Append travis build number for auto-releases
+    # rubocop:disable Gemspec/DuplicatedAssignment
+    spec.version = "#{spec.version}.1.b#{ENV['TRAVIS_BUILD_NUMBER']}"
+    # rubocop:enable Gemspec/DuplicatedAssignment
+  end
+end

data/lib/acfs.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/core_ext/hash'
+require 'active_support/core_ext/class'
+require 'active_support/core_ext/string'
+require 'active_support/core_ext/module'
+require 'active_support/notifications'
+
+module Acfs
+  extend ActiveSupport::Autoload
+  require 'acfs/version'
+  require 'acfs/errors'
+  require 'acfs/global'
+  require 'acfs/util'
+
+  require 'acfs/collection'
+  require 'acfs/configuration'
+  require 'acfs/location'
+  require 'acfs/operation'
+  require 'acfs/request'
+  require 'acfs/resource'
+  require 'acfs/response'
+  require 'acfs/runner'
+  require 'acfs/service'
+  require 'acfs/singleton_resource'
+
+  extend Global
+
+  autoload :Stub
+
+  module Middleware
+    extend ActiveSupport::Autoload
+    require 'acfs/middleware/base'
+    require 'acfs/middleware/serializer'
+
+    autoload :Print
+    autoload :Logger
+    autoload :JSON
+    autoload :JsonDecoder, 'acfs/middleware/json'
+    autoload :JsonEncoder, 'acfs/middleware/json'
+    autoload :MessagePack, 'acfs/middleware/msgpack'
+    autoload :MessagePackDecoder, 'acfs/middleware/msgpack'
+    autoload :MessagePackEncoder, 'acfs/middleware/msgpack'
+  end
+
+  module Adapter
+    require 'acfs/adapter/base'
+    require 'acfs/adapter/typhoeus'
+  end
+end

data/lib/acfs/adapter/base.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Acfs::Adapter
+  # Base adapter handling operation queuing
+  # and processing.
+  #
+  class Base
+    # Start processing queued requests.
+    #
+    def start; end
+
+    # Abort running and queued requests.
+    #
+    def abort; end
+
+    # Run request right now skipping queue.
+    #
+    def run(_); end
+
+    # Enqueue request to be run later.
+    #
+    def queue(_); end
+  end
+end

data/lib/acfs/adapter/typhoeus.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'typhoeus'
+
+module Acfs
+  module Adapter
+    # Adapter for Typhoeus.
+    #
+    class Typhoeus < Base
+      def initialize(**kwargs)
+        @options = kwargs
+      end
+
+      def start
+        hydra.run
+      rescue StandardError
+        @hydra = nil
+        raise
+      end
+
+      delegate :abort, to: :hydra
+
+      def run(request)
+        convert_request(request).run
+      end
+
+      def queue(request)
+        hydra.queue convert_request request
+      end
+
+      protected
+
+      def hydra
+        @hydra ||= ::Typhoeus::Hydra.new(**@options)
+      end
+
+      def convert_request(req)
+        request = ::Typhoeus::Request.new req.url,
+          method: req.method,
+          params: req.params,
+          headers: req.headers.merge(
+            'Expect' => '',
+            'Transfer-Encoding' => ''
+          ),
+          body: req.body
+
+        request.on_complete do |response|
+          if response.timed_out?
+            raise ::Acfs::TimeoutError.new(req)
+          elsif response.code.zero?
+            # Failed to get HTTP response
+            raise ::Acfs::RequestError.new(req, response.return_message)
+          else
+            req.complete! convert_response(req, response)
+          end
+        end
+
+        request
+      end
+
+      def convert_response(request, response)
+        Acfs::Response.new request,
+          status: response.code,
+          headers: response.headers,
+          body: response.body
+      end
+    end
+  end
+end

data/lib/acfs/collection.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+require 'acfs/resource/loadable'
+require 'acfs/collections/paginatable'
+
+module Acfs
+  class Collection < ::Delegator
+    include Resource::Loadable
+    include Acfs::Util::Callbacks
+    include Collections::Paginatable
+
+    def initialize(resource_class)
+      super([])
+
+      @resource_class = resource_class
+    end
+
+    def __getobj__
+      @models
+    end
+
+    def __setobj__(obj)
+      @models = obj
+    end
+  end
+end

data/lib/acfs/collections/paginatable.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Acfs::Collections
+  module Paginatable
+    extend ActiveSupport::Concern
+
+    included do
+      def self.operation(_action, opts = {}, &_block)
+        opts[:url]
+      end
+
+      attr_reader :total_pages, :current_page, :total_count
+    end
+
+    def process_response(response)
+      setup_params response.request.params if response.request
+      setup_headers response.headers
+    end
+
+    def next_page(&block)
+      page 'next', &block
+    end
+
+    def prev_page(&block)
+      page 'prev', &block
+    end
+
+    def first_page(&block)
+      page 'first', &block
+    end
+
+    def last_page(&block)
+      page 'last', &block
+    end
+
+    def page(rel, &block)
+      return unless relations[rel]
+
+      @resource_class.all nil, url: relations[rel], &block
+    end
+
+    private
+
+    def relations
+      @relations ||= {}
+    end
+
+    def setup_headers(headers)
+      if headers['X-Total-Pages']
+        @total_pages = Integer(headers['X-Total-Pages'])
+      end
+
+      if headers['X-Total-Count']
+        @total_count = Integer(headers['X-Total-Count'])
+      end
+
+      setup_links headers['Link'] if headers['Link']
+    end
+
+    def setup_links(links)
+      links.split(/,\s+/).each do |link|
+        if link =~ /^\s*<([^>]+)>.*\s+rel="([\w_-]+)".*$/
+          relations[Regexp.last_match[2]] = Regexp.last_match[1]
+        end
+      end
+    end
+
+    def setup_params(params)
+      @current_page = begin
+        Integer params.fetch(:page, 1)
+      rescue ArgumentError
+        params[:page]
+      end
+    end
+  end
+end

data/lib/acfs/configuration.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'yaml'
+
+module Acfs
+  # Acfs configuration is used to locate services and get their base URLs.
+  #
+  class Configuration
+    attr_reader :locations
+    attr_accessor :adapter
+
+    # @api private
+    def initialize
+      @locations = {}
+    end
+
+    # @api public
+    #
+    # Configure using given block. If block accepts zero arguments
+    # bock will be evaluated in context of the configuration instance
+    # otherwise the configuration instance will be given as first arguments.
+    #
+    # @yield [configuration] Give configuration as arguments or evaluate block
+    #   in context of configuration object.
+    # @yieldparam configuration [Configuration] Configuration object.
+    # @return [undefined]
+    #
+    def configure(&block)
+      if block.arity.positive?
+        block.call self
+      else
+        instance_eval(&block)
+      end
+    end
+
+    # @api public
+    #
+    # @overload locate(service, uri)
+    #   Configures URL where a service can be reached.
+    #
+    #   @param [Symbol] service
+    #     Service identity key for service that is reachable under given URL.
+    #
+    #   @param [String] uri
+    #     URL where service is reachable. Will be passed to {URI.parse}.
+    #
+    #   @return [undefined]
+    #
+    # @overload locate(service)
+    #   Return configured base URL for given service identity key.
+    #
+    #   @param [Symbol] service Service identity key to lookup.
+    #   @return [URI, NilClass] Configured base URL or nil.
+    #
+    def locate(service, uri = nil)
+      service = service.to_s.underscore.to_sym
+      if uri.nil?
+        locations[service]
+      else
+        locations[service] = URI.parse uri
+      end
+    end
+
+    # @api public
+    #
+    # Load configuration from given YAML file.
+    #
+    # @param [String] filename Path to YAML configuration file.
+    # @return [undefined]
+    #
+    def load(filename)
+      config = YAML.safe_load(File.read(filename), [], [], true)
+      env    = ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development'
+
+      config = config[env] if config.key? env
+      config.each do |key, value|
+        case key
+          when 'services' then load_services value
+        end
+      end
+    end
+
+    # @api private
+    #
+    # Load services from configuration YAML.
+    #
+    def load_services(services)
+      services.each do |service, data|
+        if (val = data).is_a?(String) || (val = data['locate'])
+          locate service.to_sym, val
+        end
+      end
+    end
+
+    class << self
+      # @api private
+      #
+      # Return current configuration object.
+      #
+      # @return [Configuration]
+      #
+      def current
+        @current ||= new
+      end
+
+      # @api private
+      #
+      # Swap configuration object with given new one. Must be
+      # a {Configuration} object.
+      #
+      # @param [Configuration] configuration
+      # @return [undefined]
+      #
+      def set(configuration)
+        @current = configuration if configuration.is_a? Configuration
+      end
+    end
+  end
+end

data/lib/acfs/errors.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Acfs
+  # Acfs base error.
+  #
+  class Error < StandardError
+    def initialize(opts = {}, message = nil)
+      opts.merge! message: message if message
+      super opts[:message]
+    end
+  end
+
+  class UnsupportedOperation < StandardError; end
+
+  class RequestError < Error
+    attr_reader :request
+
+    def initialize(request, message)
+      @request = request
+
+      message = "#{message}: #{request.method.upcase} #{request.url}"
+
+      super message: message
+    end
+  end
+
+  class TimeoutError < RequestError
+    def initialize(request)
+      super(request, "Timeout reached")
+    end
+  end
+
+  # Response error containing the responsible response object.
+  #
+  class ErroneousResponse < Error
+    attr_reader :response
+
+    def initialize(opts = {})
+      @response = opts[:response]
+
+      if response
+        message = (opts[:message] ? opts[:message] + ':' : 'Received') +
+                  " #{response.code} for #{response.request.method.upcase}" \
+                  " #{response.request.url} #{response.request.format}"
+      else
+        message = opts[:message] || 'Received erroneous response'
+      end
+
+      super opts, message
+    end
+  end
+
+  class AmbiguousStubError < Error
+    attr_reader :stubs, :operation
+
+    def initialize(opts = {})
+      require 'pp'
+
+      @stubs     = opts.delete :stubs
+      @operation = opts.delete :operation
+
+      message = "Ambiguous stubs for #{operation.action} " \
+                "on #{operation.resource}.\n" +
+                stubs.map {|s| "  #{s.opts.pretty_inspect}" }.join
+
+      super opts, message
+    end
+  end
+
+  # Resource not found error raised on a 404 response
+  #
+  class ResourceNotFound < ErroneousResponse
+  end
+
+  class InvalidResource < ErroneousResponse
+    attr_reader :errors, :resource
+
+    def initialize(opts = {})
+      @errors   = opts.delete :errors
+      @resource = opts.delete :resource
+
+      if @errors.is_a?(Hash)
+        opts[:message] ||= @errors.each_pair.map do |k, v|
+          @errors.is_a?(Array) ? "#{k}: #{v.join(', ')}" : "#{k}: #{v}"
+        end.join ', '
+      elsif @errors.is_a?(Array)
+        opts[:message] ||= @errors.join ', '
+      end
+
+      super
+    end
+  end
+
+  # A ResourceNotLoaded error will be thrown when calling some
+  # modifing methods on not loaded resources as it is usally
+  # unwanted to call e.g. `update_attributes` on a not loaded
+  # resource.
+  # Correct solution is to first run `Acfs.run` to fetch the
+  # resource and then update the resource.
+  #
+  class ResourceNotLoaded < Error
+    attr_reader :resource
+
+    def initialize(opts = {})
+      @resource = opts.delete :resource
+      super
+    end
+  end
+
+  # Gets raised if ressource type is no valid subclass of
+  # parent resource. Check if the type is set to the correct
+  # Acfs::Resource Name
+  class ResourceTypeError < Error
+    attr_reader :base_class
+    attr_reader :type_name
+
+    def initialize(opts = {})
+      @base_class    = opts.delete :base_class
+      @type_name     = opts.delete :type_name
+      opts[:message] = "Received resource type `#{type_name}` " \
+                       "is no subclass of #{base_class}"
+      super
+    end
+  end
+
+  class RealRequestsNotAllowedError < StandardError; end
+end