acfs 1.3.2 → 1.3.3

data/lib/acfs/location.rb

@@ -1,78 +0,0 @@
-module Acfs
-  # @api private
-  #
-  # Describes a URL with placeholders.
-  #
-  class Location
-    attr_reader :arguments, :raw, :struct, :args
-
-    REGEXP = /^:([A-z][A-z0-9_]*)$/
-
-    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_method :to_s, :raw_uri
-
-    private
-
-    def extract_arg(key, hashes)
-      hashes.each_with_index do |hash, index|
-        return (index == 0 ? hash.delete(key) : hash.fetch(key)) if hash.key?(key)
-      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

@@ -1,20 +0,0 @@
-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)
-        request.on_complete {|res, nxt| response(res, nxt) } if respond_to? :response
-        app.call(request)
-      end
-    end
-  end
-end

data/lib/acfs/middleware/json.rb

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

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

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

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

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

@@ -1,81 +0,0 @@
-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?
-      [:read, :update, :delete].include? action
-    end
-
-    def synchronous?
-      [: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

data/lib/acfs/request.rb

@@ -1,36 +0,0 @@
-require 'acfs/request/callbacks'
-
-module Acfs
-  # Encapsulate all data required to make up a request to the
-  # underlaying http library.
-  #
-  class Request
-    attr_accessor :body, :format
-    attr_reader :url, :headers, :params, :data, :method, :operation
-
-    include Request::Callbacks
-
-    def initialize(url, options = {}, &block)
-      @url = URI.parse(url.to_s).tap do |_url|
-        @data    = options.delete(:data) || nil
-        @format  = options.delete(:format) || :json
-        @headers = options.delete(:headers) || {}
-        @params  = options.delete(:params) || {}
-        @method  = options.delete(:method) || :get
-      end.to_s
-      @operation = options.delete(:operation) || nil
-      on_complete(&block) if block_given?
-    end
-
-    def data?
-      !data.nil?
-    end
-
-    class << self
-      def new(*attrs)
-        return attrs[0] if attrs[0].is_a? self
-        super
-      end
-    end
-  end
-end

data/lib/acfs/request/callbacks.rb

@@ -1,50 +0,0 @@
-module Acfs
-  class Request
-    # Module containing callback handling for Requests.
-    # Current the only callback type is `on_complete`:
-    #
-    #   request = Request.new 'URL'
-    #   request.on_complete { |response| ... }
-    #
-    module Callbacks
-      # Add a new `on_complete` callback for this request.
-      #
-      # @example Set on_complete.
-      #   request.on_complete { |response| print response.body }
-      #
-      # @param [ Block ] block The callback block to execute.
-      #
-      # @yield [ Acfs::Response ]
-      #
-      # @return [ Acfs::Request ] The request itself.
-      #
-      def on_complete(&block)
-        callbacks.insert 0, block if block_given?
-        self
-      end
-
-      # Return array of all callbacks.
-      #
-      # @return [ Array<Block> ] All callbacks.
-      #
-      def callbacks
-        @callbacks ||= []
-      end
-
-      # Trigger all callback for given response.
-      #
-      # @return [ Acfs::Request ] The request itself.
-      #
-      def complete!(response)
-        call_callback response, 0
-        self
-      end
-
-      private
-
-      def call_callback(res, index)
-        callbacks[index].call res, proc {|bres| call_callback bres, index + 1 } if index < callbacks.size
-      end
-    end
-  end
-end

data/lib/acfs/resource.rb

@@ -1,37 +0,0 @@
-require 'active_model'
-
-# @api public
-#
-class Acfs::Resource
-  require 'acfs/resource/initialization'
-  require 'acfs/resource/attributes'
-  require 'acfs/resource/dirty'
-  require 'acfs/resource/loadable'
-  require 'acfs/resource/locatable'
-  require 'acfs/resource/operational'
-  require 'acfs/resource/persistence'
-  require 'acfs/resource/query_methods'
-  require 'acfs/resource/service'
-  require 'acfs/resource/validation'
-
-  if ActiveModel::VERSION::MAJOR >= 4
-    include ActiveModel::Model
-  else
-    extend ActiveModel::Naming
-    extend ActiveModel::Translation
-    include ActiveModel::Conversion
-    include ActiveModel::Validations
-  end
-
-  include Initialization
-
-  include Attributes
-  include Loadable
-  include Persistence
-  include Locatable
-  include Operational
-  include QueryMethods
-  include Service
-  include Dirty
-  include Validation
-end