acfs 1.3.3 → 1.3.4

data/lib/acfs/resource/service.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+class Acfs::Resource
+  # Included by Acfs::Model. Allows to configure the service
+  # a resource belongs to.
+  #
+  module Service
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # @api public
+      #
+      # @overload service()
+      #   Return service instance.
+      #
+      #   @return [Service] Service class instance.
+      #
+      # @overload service(klass, options = {})
+      #   Link to service this model belongs to. Connection
+      #   settings like base URL are fetched from service.
+      #   Return assigned service if no arguments are given.
+      #
+      #   @example
+      #     class AccountService < Acfs::Client
+      #       self.base_url = 'http://acc.serv.org'
+      #     end
+      #
+      #     class MyUser < Acfs::Resource
+      #       service AccountService
+      #     end
+      #     MyUser.find 5 # Will fetch `http://acc.serv.org/users/5`
+      #
+      #   @param klass [Class] Service class derived from {Acfs::Service}.
+      #   @param options [Object] Option delegated to
+      #     service class initializer.
+      #
+      def service(klass = nil, options = {})
+        return (@service = klass.new options) if klass
+
+        @service || superclass.service
+      end
+    end
+  end
+end

data/lib/acfs/resource/validation.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+class Acfs::Resource
+  module Validation
+    def valid?(*args)
+      super
+      remote_errors.each {|f, e| errors.add f, e }
+      errors.empty?
+    end
+
+    def remote_errors
+      @remote_errors ||= ActiveModel::Errors.new self
+    end
+
+    def remote_errors=(errors)
+      if errors.respond_to?(:each_pair)
+        errors.each_pair do |field, errs|
+          Array(errs).each do |err|
+            self.errors.add field.to_sym, err
+            remote_errors.add field.to_sym, err
+          end
+        end
+      else
+        Array(errors).each do |err|
+          self.errors.add :base, err
+          remote_errors.add :base, err
+        end
+      end
+    end
+
+    def save!(*_)
+      unless valid?(new? ? :create : :save)
+        raise ::Acfs::InvalidResource.new resource: self, errors: errors.to_a
+      end
+
+      super
+    end
+  end
+end

data/lib/acfs/response.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'acfs/response/formats'
+require 'acfs/response/status'
+require 'active_support/core_ext/module/delegation'
+
+module Acfs
+  # This represents a response. In addition to an standard HTTP
+  # it has a field `data` for storing the encoded body.
+  #
+  class Response
+    attr_accessor :data
+    attr_reader :headers, :body, :request, :status
+
+    include Response::Formats
+    include Response::Status
+
+    # delegate :status, :status_message, :success?, :modified?, :timed_out?,
+    #         :response_body, :response_headers, :response_code, :headers,
+    #         to: :response
+
+    def initialize(request, data = {})
+      @request  = request
+      @status   = data[:status]  || 0
+      @headers  = data[:headers] || {}
+      @body     = data[:body]    || ''
+      @data     = data[:data]    || nil
+    end
+  end
+end

data/lib/acfs/response/formats.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'action_dispatch'
+
+module Acfs
+  class Response
+    # Quick accessors for format handling.
+    module Formats
+      def content_type
+        @content_type ||= read_content_type
+      end
+
+      def json?
+        content_type == Mime[:json]
+      end
+
+      private
+
+      def read_content_type
+        return 'text/plain' unless headers && headers['Content-Type']
+
+        content_type = headers['Content-Type'].split(/;\s*\w+="?\w+"?/).first
+        Mime::Type.parse(content_type).first
+      end
+    end
+  end
+end

data/lib/acfs/response/status.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Acfs
+  class Response
+    # Method to fetch information about response status.
+    #
+    module Status
+      # Return response status code. Will return zero if
+      # request was not executed or failed on client side.
+      #
+      def status_code
+        return @status.to_i if defined? :@status
+        # return response.response_code unless response.nil?
+        # 0
+      end
+      alias code status_code
+
+      # Return true if response was successful indicated by
+      # response status code.
+      #
+      def success?
+        code >= 200 && code < 300
+      end
+
+      # Return true unless response status code indicates that
+      # resource was not modified according to send precondition headers.
+      #
+      def modified?
+        code != 304
+      end
+    end
+  end
+end

data/lib/acfs/rspec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'acfs'
+
+RSpec.configure do |config|
+  config.before(:each) do
+    Acfs::Stub.enable
+  end
+
+  config.after(:each) do
+    Acfs.reset
+  end
+end

data/lib/acfs/runner.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'acfs/service/middleware'
+
+module Acfs
+  # @api private
+  #
+  class Runner
+    include Service::Middleware
+    attr_reader :adapter
+
+    def initialize(adapter)
+      @adapter = adapter
+      @running = false
+    end
+
+    # Process an operation. Synchronous operations will be run
+    # and parallel operations will be queued.
+    #
+    def process(op)
+      ::ActiveSupport::Notifications.instrument 'acfs.operation.before_process', operation: op
+      op.synchronous? ? run(op) : enqueue(op)
+    end
+
+    # Run operation right now skipping queue.
+    #
+    def run(op)
+      ::ActiveSupport::Notifications.instrument 'acfs.runner.sync_run', operation: op do
+        op_request(op) {|req| adapter.run req }
+      end
+    end
+
+    # List of current queued operations.
+    #
+    def queue
+      @queue ||= []
+    end
+
+    # Enqueue operation to be run later.
+    #
+    def enqueue(op)
+      ::ActiveSupport::Notifications.instrument 'acfs.runner.enqueue', operation: op do
+        if running?
+          op_request(op) {|req| adapter.queue req }
+        else
+          queue << op
+        end
+      end
+    end
+
+    # Return true if queued operations are currently processed.
+    #
+    def running?
+      @running
+    end
+
+    # Start processing queued operations.
+    #
+    def start
+      return if running?
+
+      enqueue_operations
+      start_all
+    rescue StandardError
+      queue.clear
+      raise
+    end
+
+    def clear
+      queue.clear
+      adapter.abort
+      @running = false
+    end
+
+    private
+
+    def start_all
+      @running = true
+      adapter.start
+    ensure
+      @running = false
+    end
+
+    def enqueue_operations
+      while (op = queue.shift)
+        op_request(op) {|req| adapter.queue req }
+      end
+    end
+
+    def op_request(op)
+      return if Acfs::Stub.enabled? && Acfs::Stub.stubbed(op)
+
+      req = op.service.prepare op.request
+      return unless req.is_a? Acfs::Request
+
+      req = prepare req
+      return unless req.is_a? Acfs::Request
+
+      yield req
+    end
+  end
+end

data/lib/acfs/service.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'acfs/service/middleware'
+
+module Acfs
+  # User {Acfs::Service} to define your services. That includes
+  # an identity used to identify the service in configuration files
+  # and middlewares the service uses.
+  #
+  # Configure your service URLs in a YAML file loaded in an
+  # initializer using the identity as a key:
+  #
+  #   production:
+  #     services:
+  #       user_service_key: "http://users.service.org/base/path"
+  #
+  # @example
+  #   class UserService < Acfs::Service
+  #     identity :user_service_key
+  #
+  #     use Acfs::Middleware::MessagePackDecoder
+  #   end
+  #
+  class Service
+    attr_accessor :options
+
+    include Service::Middleware
+
+    # @api private
+    #
+    def initialize(options = {})
+      @options = options
+    end
+
+    # @api private
+    # @return [Location]
+    #
+    def location(resource_class, opts = {})
+      opts.reverse_merge! options
+
+      action = opts[:action] || :list
+
+      path = if opts[:path].is_a?(Hash) && opts[:path].key?(action)
+               opts[:path].fetch(action)
+             else
+               path = if opts[:path].is_a?(Hash)
+                        opts[:path][:all].to_s
+                      else
+                        opts[:path].to_s
+                      end
+
+               if path.blank?
+                 path = (resource_class.name || 'class').pluralize.underscore
+               end
+
+               resource_class.location_default_path(action, path.strip)
+             end
+
+      if path.nil?
+        raise ArgumentError.new "Location for `#{action}' explicit disabled by set to nil."
+      end
+
+      Location.new [self.class.base_url.to_s, path.to_s].join('/')
+    end
+
+    class << self
+      # @api public
+      #
+      # @overload identity()
+      #   Return configured identity key or derive key from class name.
+      #
+      #   @return [Symbol] Service identity key.
+      #
+      # @overload identity(identity)
+      #   Set identity key.
+      #
+      #   @param [#to_s] identity New identity key.
+      #   @return [Symbol] New set identity key.
+      #
+      def identity(identity = nil)
+        @identity = identity.to_s.to_sym unless identity.nil?
+        @identity ||= name.to_sym
+      end
+
+      # @api private
+      # @return [String]
+      #
+      def base_url
+        unless (base = Acfs::Configuration.current.locate identity)
+          raise ArgumentError.new "#{identity} not configured. Add `locate '#{identity.to_s.underscore}', 'http://service.url/'` to your configuration."
+        end
+
+        base.to_s
+      end
+    end
+  end
+end

data/lib/acfs/service/middleware.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'acfs/service/middleware/stack'
+
+module Acfs
+  class Service
+    # Module providing all function to register middlewares
+    # on services and process queued request through the
+    # middleware stack.
+    #
+    module Middleware
+      extend ActiveSupport::Concern
+
+      # @api private
+      # @return [Request]
+      #
+      def prepare(request)
+        self.class.middleware.call request
+      end
+
+      module ClassMethods
+        # @!method use(klass, *args, &block)
+        #   @api public
+        #
+        #   Register a new middleware to be used for this service.
+        #
+        #   @example
+        #     class MyService < Acfs::Service
+        #       self.base_url = 'http://my.srv'
+        #       use Acfs::Middleware::JSON
+        #     end
+        #
+        #   @param [Class] klass Middleware class to append
+        #   @param [Array<Object>] args Arguments passed to klass initialize
+        #   @param [Proc] block Block passed to klass initialize
+        #   @return [undefined]
+        #
+        def use(klass, *args, &block)
+          # Backward compatible behavior
+          middleware.insert(0, klass, *args, &block)
+        end
+
+        # @api private
+        #
+        # Return top most middleware.
+        #
+        # @return [#call]
+        #
+        def middleware
+          @middleware ||= Stack.new
+        end
+
+        # @deprecated
+        delegate :clear, to: :middleware
+      end
+    end
+  end
+end