acfs 1.3.3 → 1.3.4

data/lib/acfs/global.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Acfs
+  #
+  # Global Acfs module methods.
+  #
+  module Global
+    #
+    # @api private
+    # @return [Runner]
+    #
+    def runner
+      Thread.current[:acfs_runner] ||= begin
+        adapter = Configuration.current.adapter
+
+        if adapter
+          Runner.new adapter.call
+        else
+          Runner.new Adapter::Typhoeus.new
+        end
+      end
+    end
+
+    # @api public
+    #
+    # Run all queued operations.
+    #
+    # @return [undefined]
+    #
+    def run
+      ::ActiveSupport::Notifications.instrument 'acfs.before_run'
+      ::ActiveSupport::Notifications.instrument 'acfs.run' do
+        runner.start
+      end
+    end
+
+    # @api public
+    #
+    # Configure acfs using given block.
+    #
+    # @return [undefined]
+    # @see Configuration#configure
+    #
+    def configure(&block)
+      Configuration.current.configure(&block)
+    end
+
+    # @api public
+    #
+    # Reset all queues, stubs and internal state.
+    #
+    def reset
+      ::ActiveSupport::Notifications.instrument 'acfs.reset' do
+        runner.clear
+        Acfs::Stub.clear
+      end
+    end
+
+    # @api public
+    #
+    # Add an additional callback hook to not loaded resource.
+    # If given resource already loaded callback will be invoked immediately.
+    #
+    # This method will be replaced by explicit callback
+    # handling when query methods return explicit future objects.
+    #
+    # @example
+    #   user = MyUser.find 1, &callback_one
+    #   Acfs.add_callback(user, &callback_two)
+    #
+    def add_callback(resource, &block)
+      unless resource.respond_to?(:__callbacks__)
+        raise ArgumentError.new 'Given resource is not an Acfs resource ' \
+          "delegator but a: #{resource.class.name}"
+      end
+      return false if block.nil?
+
+      if resource.nil? || resource.loaded?
+        block.call resource
+      else
+        resource.__callbacks__ << block
+      end
+    end
+
+    def on(*resources)
+      # If all resources have already been loaded, we run the callback immediately.
+      if resources.all? {|res| res.nil? || res.loaded? }
+        yield(*resources)
+        return
+      end
+
+      # Otherwise, we add a callback to *each* resource with a guard that ensures
+      # that only the very last resource being loaded executes the callback.
+      resources.each do |resource|
+        add_callback resource do |_|
+          yield(*resources) if resources.all? {|res| res.nil? || res.loaded? }
+        end
+      end
+    end
+  end
+end

data/lib/acfs/location.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Acfs
+  # @api private
+  #
+  # Describes a URL with placeholders.
+  #
+  class Location
+    attr_reader :arguments, :raw, :struct, :args
+
+    REGEXP = /^:([A-z][A-z0-9_]*)$/.freeze
+
+    def initialize(uri, args = {})
+      @raw       = URI.parse uri
+      @args      = args
+      @struct    = raw.path.split('/').reject(&:empty?).map {|s| s =~ REGEXP ? Regexp.last_match[1].to_sym : s }
+      @arguments = struct.select {|s| s.is_a?(Symbol) }
+    end
+
+    def build(args = {})
+      unless args.is_a?(Hash)
+        raise ArgumentError.new "URI path arguments must be a hash, `#{args.inspect}' given."
+      end
+
+      self.class.new raw.to_s, args.merge(self.args)
+    end
+
+    def extract_from(*args)
+      args = {}.tap do |collect|
+        arguments.each {|key| collect[key] = extract_arg key, args }
+      end
+
+      build args
+    end
+
+    def str
+      uri = raw.dup
+      uri.path = '/' + struct.map {|s| lookup_arg(s, args) }.join('/')
+      uri.to_s
+    end
+
+    def raw_uri
+      raw.to_s
+    end
+    alias to_s raw_uri
+
+    private
+
+    def extract_arg(key, hashes)
+      hashes.each_with_index do |hash, index|
+        if hash.key?(key)
+          return (index == 0 ? hash.delete(key) : hash.fetch(key))
+        end
+      end
+
+      nil
+    end
+
+    def lookup_arg(arg, args)
+      arg.is_a?(Symbol) ? lookup_replacement(arg, args) : arg
+    end
+
+    def lookup_replacement(sym, args)
+      value = get_replacement(sym, args).to_s
+      return ::URI.encode_www_form_component(value) unless value.empty?
+
+      raise ArgumentError.new "Cannot replace path argument `#{sym}' with empty string."
+    end
+
+    def get_replacement(sym, args)
+      args.fetch(sym.to_s) do
+        args.fetch(sym) do
+          if args[:raise].nil? || args[:raise]
+            raise ArgumentError.new "URI path argument `#{sym}' missing on `#{self}'. Given: `#{args}.inspect'"
+          else
+            ":#{sym}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/acfs/middleware/base.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Acfs
+  module Middleware
+    # A base middleware that does not modify request or response.
+    # Can be used as super class for custom middleware implementations.
+    #
+    class Base
+      attr_reader :app, :options
+
+      def initialize(app, options = {})
+        @app     = app
+        @options = options
+      end
+
+      def call(request)
+        if respond_to? :response
+          request.on_complete {|res, nxt| response(res, nxt) }
+        end
+        app.call(request)
+      end
+    end
+  end
+end

data/lib/acfs/middleware/json.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'multi_json'
+
+module Acfs
+  module Middleware
+    # A middleware to encore request data using JSON.
+    #
+    class JSON < Serializer
+      def mime
+        ::Mime[:json]
+      end
+
+      def encode(data)
+        ::MultiJson.dump data
+      end
+
+      def decode(body)
+        ::MultiJson.load body
+      end
+    end
+
+    # @deprecated
+    JsonDecoder = JSON
+
+    # @deprecated
+    JsonEncoder = JSON
+  end
+end

data/lib/acfs/middleware/logger.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Acfs
+  module Middleware
+    # Log requests and responses.
+    #
+    class Logger < Base
+      def initialize(app, options = {})
+        super
+        @logger = options[:logger] if options[:logger]
+      end
+
+      def response(res, nxt)
+        logger.info "[ACFS] #{res.request.method.to_s.upcase} #{res.request.url} -> #{res.status}"
+        nxt.call res
+      end
+
+      def logger
+        @logger ||= ::Logger.new STDOUT
+      end
+    end
+  end
+end

data/lib/acfs/middleware/msgpack.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'msgpack'
+require 'action_dispatch'
+
+module Acfs
+  module Middleware
+    class MessagePack < Serializer
+      unless defined?(::Mime::MSGPACK)
+        ::Mime::Type.register 'application/x-msgpack', :msgpack
+      end
+
+      def mime
+        ::Mime[:msgpack]
+      end
+
+      def encode(data)
+        ::MessagePack.pack data
+      end
+
+      def decode(body)
+        ::MessagePack.unpack body
+      end
+    end
+
+    # @deprecated
+    MessagePackEncoder = MessagePack
+
+    # @deprecated
+    MessagePackDecoder = MessagePack
+  end
+end

data/lib/acfs/middleware/print.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Acfs
+  module Middleware
+    # Print resquests and response on terminal
+    #
+    class Print < Base
+      def call(req)
+        puts '-' * 80
+        puts req.inspect
+        puts '-' * 80
+
+        super
+      end
+
+      def response(res)
+        puts '-' * 80
+        puts res.inspect
+        puts '-' * 80
+      end
+    end
+  end
+end

data/lib/acfs/middleware/serializer.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Acfs
+  module Middleware
+    # A base middleware that does not modify request or response.
+    # Can be used as super class for custom middleware implementations.
+    #
+    class Serializer < Base
+      def encode(_data)
+        raise NotImplementedError
+      end
+
+      def decode(_data)
+        raise NotImplementedError
+      end
+
+      def mime
+        raise NotImplementedError
+      end
+
+      def call(request)
+        unless request.headers['Content-Type']
+          request.body = encode request.data
+          request.headers['Content-Type'] = mime
+        end
+
+        accept = request.headers['Accept'].to_s.split(',')
+        accept << "#{mime};q=#{options.fetch(:q, 1)}"
+        request.headers['Accept'] = accept.join(',')
+
+        request.on_complete do |response, nxt|
+          response.data = decode response.body if mime == response.content_type
+
+          nxt.call response
+        end
+
+        app.call(request)
+      end
+    end
+  end
+end

data/lib/acfs/operation.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Acfs
+  # @api private
+  #
+  # Describes a CRUD operation. Handle request creation and response
+  # processing as well as error handling and stubbing.
+  #
+  class Operation
+    attr_reader :action, :params, :resource, :data, :callback, :location, :url
+    delegate :service, to: :resource
+    delegate :call, to: :callback
+
+    def initialize(resource, action, opts = {}, &block)
+      @resource = resource
+      @action   = action.to_sym
+
+      # Operations can be delayed so dup params and data to avoid
+      # later in-place changes by modifying passed hash
+      @params   = (opts[:params] || {}).dup
+      @data     = (opts[:data]   || {}).dup
+
+      if opts[:url]
+        @url = opts[:url]
+      else
+        @location = resource.location(action: @action).extract_from(@params, @data)
+        @url      = location.str
+      end
+
+      @callback = block
+    end
+
+    def single?
+      %i[read update delete].include? action
+    end
+
+    def synchronous?
+      %i[update delete create].include? action
+    end
+
+    def id
+      # TODO
+      @id ||= params.delete(:id) || data[:id]
+    end
+
+    def full_params
+      (id ? params.merge(id: id) : params).merge location_args
+    end
+
+    def location_args
+      location ? location.args : {}
+    end
+
+    def method
+      {read: :get, list: :get, update: :put, create: :post, delete: :delete}[action]
+    end
+
+    def request
+      request = ::Acfs::Request.new url, method: method, params: params,
+                                         data: data, operation: self
+      request.on_complete do |response|
+        ::ActiveSupport::Notifications.instrument 'acfs.operation.complete',
+          operation: self,
+          response: response
+
+        handle_failure response unless response.success?
+        callback.call response.data, response
+      end
+      request
+    end
+
+    def handle_failure(response)
+      case response.code
+        when 404
+          raise ::Acfs::ResourceNotFound.new response: response
+        when 422
+          raise ::Acfs::InvalidResource.new response: response, errors: response.data.try(:[], 'errors')
+        else
+          raise ::Acfs::ErroneousResponse.new response: response
+      end
+    end
+  end
+end