acfs 1.3.2 → 1.3.3

data/lib/acfs/service.rb

@@ -1,91 +0,0 @@
-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
-
-               path = (resource_class.name || 'class').pluralize.underscore if path.blank?
-
-               resource_class.location_default_path(action, path.strip)
-             end
-
-      raise ArgumentError.new "Location for `#{action}' explicit disabled by set to nil." if path.nil?
-
-      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

@@ -1,56 +0,0 @@
-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

data/lib/acfs/service/middleware/stack.rb

@@ -1,63 +0,0 @@
-module Acfs
-  class Service
-    module Middleware
-      class Stack
-        include Enumerable
-
-        MUTEX = Mutex.new
-        IDENTITY = -> (i) { i }
-
-        attr_reader :middlewares
-
-        def initialize
-          @middlewares = []
-        end
-
-        def call(request)
-          build! unless @app
-
-          @app.call request
-        end
-
-        def build!
-          return if @app
-
-          MUTEX.synchronize do
-            return if @app
-
-            @app = build
-          end
-        end
-
-        def build(app = IDENTITY)
-          middlewares.reverse.inject(app) do |next_middleware, current_middleware|
-            klass, args, block = current_middleware
-            args ||= []
-
-            if klass.is_a?(Class)
-              klass.new(next_middleware, *args, &block)
-            elsif klass.respond_to?(:call)
-              lambda do |env|
-                next_middleware.call(klass.call(env, *args))
-              end
-            else
-              fail "Invalid middleware, doesn't respond to `call`: #{klass.inspect}"
-            end
-          end
-        end
-
-        def insert(index, klass, *args, &block)
-          middlewares.insert(index, [klass, args, block])
-        end
-
-        def each
-          middlewares.each { |x| yield x.first }
-        end
-
-        def clear
-          middlewares.clear
-        end
-      end
-    end
-  end
-end

data/lib/acfs/singleton_resource.rb

@@ -1,83 +0,0 @@
-module Acfs
-  # Acfs SingletonResources
-  #
-  # Usage explanation:
-  #   Single.find      => sends GET    request to http://service:port/single
-  #   my_single.save   => sends POST   request to http://service:port/single
-  #                                    if my_single is a new object
-  #                    or sends PUT    request to http://service:port/single
-  #                                    if my_single has been requested before
-  #   my_single.delete => sends DELETE request to http://service:port/single
-  #
-  # SingletonResources do not support the Resource method :all, since
-  # always only a single instance of the resource is being returned
-  #
-  class SingletonResource < Acfs::Resource
-    # @api public
-    #
-    # Destroy resource by sending a DELETE request.
-    # Will raise an error in case something goes wrong.
-    #
-    # Deleting a resource is a synchronous operation.
-    #
-    # @raise [Acfs::ErroneousResponse]
-    #   If remote service respond with not successful response.
-    # @return [undefined]
-    # @see #delete
-    #
-    def delete!(opts = {})
-      opts[:params] ||= {}
-
-      operation :delete, opts do |data|
-        update_with data
-        freeze
-      end
-    end
-
-    # @api private
-    def need_primary_key?
-      false
-    end
-
-    class << self
-      # @api public
-      #
-      # @overload find(id, opts = {})
-      #   Find a singleton resource, optionally with params.
-      #
-      #   @example
-      #     single = Singleton.find # Will query `http://base.url/singletons/`
-      #
-      #   @param [ Hash ] opts Additional options.
-      #   @option opts [ Hash ] :params Additional parameters added to request.
-      #
-      #   @yield [ resource ] Callback block to be executed after
-      #     resource was fetched successfully.
-      #   @yieldparam resource [ self ] Fetched resources.
-      #
-      #   @return [ self ] Resource object.
-      #
-      def find(*attrs, &block)
-        find_single nil, params: attrs.extract_options!, &block
-      end
-
-      # @api public
-      #
-      # Undefined, raises NoMethodError.
-      # A singleton always only returns one object, therefore the
-      # methods :all and :where are not defined.
-      # :find_by is not defined on singletons, use :find instead
-      #
-      def all
-        raise ::Acfs::UnsupportedOperation.new
-      end
-      alias_method :find_by, :all
-      alias_method :find_by!, :all
-
-      # @api private
-      def location_default_path(_, path)
-        path
-      end
-    end
-  end
-end

data/lib/acfs/stub.rb

@@ -1,172 +0,0 @@
-require 'rack/utils'
-
-module Acfs
-  # Global handler for stubbing resources.
-  #
-  class Stub
-    ACTIONS = [:read, :create, :update, :delete, :list]
-
-    attr_reader :opts
-
-    def initialize(opts)
-      @opts = opts
-
-      @opts[:with].stringify_keys! if @opts[:with].is_a? Hash
-      @opts[:return].stringify_keys! if @opts[:return].is_a? Hash
-      @opts[:return].map! {|h| h.stringify_keys! if h.is_a? Hash } if @opts[:return].is_a? Array
-    end
-
-    def accept?(op)
-      return opts[:with].call op if opts[:with].respond_to? :call
-
-      params = op.full_params.stringify_keys
-      data   = op.data.stringify_keys
-      with   = opts[:with]
-
-      return true if with.nil?
-
-      case opts.fetch(:match, :inclusion)
-        when :legacy
-          return true if with.empty? && params.empty? && data.empty?
-          return true if with.reject {|_, v| v.nil? } == params.reject {|_, v| v.nil? }
-          return true if with.reject {|_, v| v.nil? } == data.reject {|_, v| v.nil? }
-          false
-        when :inclusion
-          with.each_pair.all? do |k, v|
-            (params.key?(k) && params[k] == v) || (data.key?(k) && data[k] == v)
-          end
-      end
-    end
-
-    def calls
-      @calls ||= []
-    end
-
-    def called?(count = nil)
-      count = count.count if count.respond_to? :count # For `5.times` Enumerators
-      count.nil? ? calls.any? : calls.size == count
-    end
-
-    def call(op)
-      calls << op
-
-      err  = opts[:raise]
-      data = opts[:return]
-
-      if err
-        raise_error op, err, opts[:return]
-      elsif data
-        data = data.call(op) if data.respond_to?(:call)
-
-        response = Acfs::Response.new op.request,
-          headers: opts[:headers] || {},
-          status:  opts[:status] || 200,
-          data:    data || {}
-        op.call data, response
-      else
-        raise ArgumentError.new 'Unsupported stub.'
-      end
-    end
-
-    private
-
-    def raise_error(op, name, data)
-      raise name if name.is_a? Class
-      data.stringify_keys! if data.respond_to? :stringify_keys!
-
-      op.handle_failure ::Acfs::Response.new op.request, status: Rack::Utils.status_code(name), data: data
-    end
-
-    class << self
-      # Stub a resource with given handler block. An already created handler
-      # for same resource class will be overridden.
-      #
-      def resource(klass, action, opts = {}, &_block)
-        action = action.to_sym
-        raise ArgumentError.new "Unknown action `#{action}`." unless ACTIONS.include? action
-
-        Stub.new(opts).tap do |stub|
-          stubs[klass]         ||= {}
-          stubs[klass][action] ||= []
-          stubs[klass][action] << stub
-        end
-      end
-
-      def allow_requests=(allow)
-        @allow_requests = allow ? true : false
-      end
-
-      def allow_requests?
-        @allow_requests ||= false
-      end
-
-      def enabled?
-        @enabled ||= false
-      end
-
-      def enable
-        @enabled = true
-      end
-
-      def disable
-        @enabled = false
-      end
-
-      # Clear all stubs.
-      #
-      def clear(klass = nil)
-        klass.nil? ? stubs.clear : stubs[klass].try(:clear)
-      end
-
-      def stubs
-        @stubs ||= {}
-      end
-
-      def stub_for(op)
-        return false unless (classes = stubs[op.resource])
-        return false unless (stubs = classes[op.action])
-
-        accepted_stubs = stubs.select {|stub| stub.accept? op }
-
-        raise AmbiguousStubError.new stubs: accepted_stubs, operation: op if accepted_stubs.size > 1
-
-        accepted_stubs.first
-      end
-
-      def stubbed(op)
-        stub = stub_for op
-        unless stub
-          return false if allow_requests?
-          raise RealRequestsNotAllowedError.new <<-MSG.strip.gsub(/^[ ]{12}/, '')
-            No stub found for `#{op.action}' on `#{op.resource.name}' with params `#{op.full_params.inspect}', data `#{op.data.inspect}' and id `#{op.id}'.
-
-            Available stubs:
-            #{pretty_print}
-          MSG
-        end
-
-        stub.call op
-        true
-      end
-
-      private
-
-      def pretty_print
-        out = ''
-        stubs.each do |klass, actions|
-          out << '  ' << klass.name << ":\n"
-          actions.each do |action, stubs|
-            stubs.each do |stub|
-              out << "    #{action}"
-              out << " with #{stub.opts[:with].inspect}" if stub.opts[:with]
-              out << " and return #{stub.opts[:return].inspect}" if stub.opts[:return]
-              out << " and raise #{stub.opts[:raise].inspect}" if stub.opts[:raise]
-              out << "\n"
-            end
-          end
-        end
-        out
-      end
-    end
-  end
-end