garage_client 2.1.1

data/lib/garage_client/configuration.rb

@@ -0,0 +1,51 @@
+module GarageClient
+  class Configuration
+    DEFAULTS = {
+      adapter: :net_http,
+      cacher: nil,
+      headers: {
+        'Accept' => 'application/json',
+        'User-Agent' => "garage_client #{GarageClient::VERSION}",
+      },
+      path_prefix: '/v1',
+      verbose: false,
+    }
+
+    def self.keys
+      DEFAULTS.keys + [:endpoint]
+    end
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def options
+      @options ||= {}
+    end
+
+    def reset
+      @options = nil
+    end
+
+    DEFAULTS.keys.each do |key|
+      define_method(key) do
+        options.fetch(key, DEFAULTS[key])
+      end
+
+      define_method("#{key}=") do |value|
+        options[key] = value
+      end
+    end
+
+    def endpoint
+      options[:endpoint] or raise 'Configuration error: missing endpoint'
+    end
+
+    def endpoint=(value)
+      options[:endpoint] = value
+    end
+
+    alias :default_headers :headers
+    alias :default_headers= :headers=
+  end
+end

data/lib/garage_client/error.rb

@@ -0,0 +1,37 @@
+module GarageClient
+  class Error < StandardError
+    attr_accessor :response
+
+    def initialize(response = nil)
+      @response = response
+    end
+
+    def to_s
+      case
+      when String === response
+        response
+      when response.respond_to?(:[]) && response[:method].respond_to?(:upcase) && response[:url].is_a?(URI::HTTP)
+        "#{response[:method].upcase} #{response[:url]} #{response[:status]}: #{response[:body]}"
+      else
+        super
+      end
+    end
+  end
+
+  # HTTP level
+  class Unauthorized < Error; end
+  class Forbidden < Error; end
+  class NotFound < Error; end
+  class NotAcceptable < Error; end
+  class Conflict < Error; end
+  class UnsupportedMediaType < Error; end
+  class UnprocessableEntity < Error; end
+
+  # Remote Server
+  class InternalServerError < Error; end
+  class ServiceUnavailable < Error; end
+
+  # GarageClient Client
+  class UnsupportedResource < Error; end
+  class InvalidResponseType < Error; end
+end

data/lib/garage_client/request.rb

@@ -0,0 +1,38 @@
+module GarageClient
+  module Request
+    MIME_DICT = 'application/vnd.cookpad.dictionary+json'
+
+    def get(path, params = nil, options = {})
+      request(:get, path, params, nil, options)
+    end
+
+    def post(path, body = nil, options = {})
+      request(:post, path, {}, body, options)
+    end
+
+    def put(path, body = nil, options = {})
+      request(:put, path, {}, body, options)
+    end
+
+    def delete(path, options = {})
+      request(:delete, path, options)
+    end
+
+    private
+    def request(method, path, params = {}, body = nil, options = {})
+      response = conn.send(method) do |request|
+        request.url(path, params)
+        request.body = body if body
+        request.headers.update(options[:headers]) if options[:headers]
+      end
+      options[:raw] ? response : GarageClient::Response.new(self, response)
+    end
+
+    def request_with_prefix(method, path, *args)
+      path = "#{path_prefix}#{path}" unless path.start_with?(path_prefix)
+      request_without_prefix(method, path, *args)
+    end
+    alias request_without_prefix request
+    alias request request_with_prefix
+  end
+end

data/lib/garage_client/request/json_encoded.rb

@@ -0,0 +1,59 @@
+module GarageClient
+  module Request
+    class JsonEncoded < Faraday::Middleware
+      def call(env)
+        request = Request.new(env)
+
+        if request.json_compatible?
+          env[:request_headers]["Content-Type"] ||= "application/json"
+          env[:body] = env[:body].to_json
+        end
+
+        @app.call(env)
+      end
+
+      class Request
+        attr_reader :env
+
+        def initialize(env)
+          @env = env
+        end
+
+        def json_compatible?
+          has_json_compatible_body? && has_json_compatible_content_type?
+        end
+
+        private
+
+        def has_json_compatible_content_type?
+          headers["Content-Type"].nil? || headers["Content-Type"] == "application/json"
+        end
+
+        def has_json_compatible_body?
+          case body
+          when nil
+            false
+          when Array, Hash
+            true
+          end
+        end
+
+        def body
+          env[:body]
+        end
+
+        def headers
+          env[:request_headers]
+        end
+
+        def has_json_content_type?
+          headers["Content-Type"] == "application/json"
+        end
+
+        def has_content_type?
+          !headers["Content-Type"].nil?
+        end
+      end
+    end
+  end
+end

data/lib/garage_client/resource.rb

@@ -0,0 +1,63 @@
+require "hashie"
+
+module GarageClient
+  class Resource
+    attr_accessor :data, :client
+
+    def self.resource?(hash)
+      hash.kind_of?(Hash) && hash.has_key?('_links')
+    end
+
+    def initialize(client, data)
+      @client = client
+      @data = Hashie::Mash.new(data)
+    end
+
+    def properties
+      @properties ||= data.keys.map(&:to_sym)
+    end
+
+    def links
+      @links ||= data._links ? data._links.keys.map(&:to_sym) : []
+    end
+
+    def self_path
+      @self_path ||= data._links.self.href
+    end
+
+    def update(body = nil, options = {})
+      client.put(self_path, body, options)
+    end
+
+    def destroy(options = {})
+      client.delete(self_path, options)
+    end
+
+    def method_missing(name, *args, &block)
+      if properties.include?(name)
+        value = data[name]
+        if self.class.resource?(value)
+          GarageClient::Resource.new(client, value)
+        else
+          value
+        end
+      elsif links.include?(name)
+        path = data._links[name].href
+        client.get(path, *args)
+      elsif nested_resource_creation_method?(name)
+        path = data._links[name.to_s.sub(/create_/, '')].href
+        client.post(path, *args)
+      else
+        super
+      end
+    end
+
+    def respond_to?(name)
+      super || !!(properties.include?(name) || links.include?(name) || nested_resource_creation_method?(name))
+    end
+
+    def nested_resource_creation_method?(name)
+      !!(name =~ /\Acreate_(.+)\z/ && links.include?($1.to_sym))
+    end
+  end
+end

data/lib/garage_client/response.rb

@@ -0,0 +1,123 @@
+require "link_header"
+
+module GarageClient
+  class Response
+    MIME_DICT = %r{application/vnd\.cookpad\.dictionary\+(json|x-msgpack)}
+    ACCEPT_BODY_TYPES = [Array, Hash, NilClass]
+
+    attr_accessor :client, :response
+
+    def initialize(client, response)
+      @client = client
+      @response = response
+
+      # Faraday's Net::Http adapter returns '' if response is nil.
+      # Changes from faraday v0.9.0. faraday/f41ffaabb72d3700338296c79a2084880e6a9843
+      #
+      # GarageClient::Response#body should be always a String when Faraday
+      # became v1.0.0. Because 0.9.0 seems to be not stable.
+      response.env[:body] = nil if response.env[:body] == ''
+
+      unless ACCEPT_BODY_TYPES.any? {|type| type === response.body }
+        raise GarageClient::InvalidResponseType, "Invalid response type (#{response.body.class}): #{response.body}"
+      end
+    end
+
+    def link
+      @link ||= response.headers['Link']
+    end
+
+    def total_count
+      unless @total_count
+        @total_count = response.headers['X-List-TotalCount']
+        @total_count = @total_count.to_i if @total_count
+      end
+      @total_count
+    end
+
+    def body
+      @body ||= case response.body
+                when Array
+                  response.body.map {|res| GarageClient::Resource.new(client, res) }
+                when Hash
+                  if dictionary_response?
+                    Hash[response.body.map {|id, res| [id, GarageClient::Resource.new(client, res)] }]
+                  else
+                    GarageClient::Resource.new(client, response.body)
+                  end
+                when NilClass
+                  nil
+                end
+    end
+
+    def next_page_path
+      next_page_link.try(:href)
+    end
+
+    def prev_page_path
+      prev_page_link.try(:href)
+    end
+
+    def first_page_path
+      first_page_link.try(:href)
+    end
+
+    def last_page_path
+      last_page_link.try(:href)
+    end
+
+    def has_next_page?
+      !!next_page_link
+    end
+
+    def has_prev_page?
+      !!prev_page_link
+    end
+
+    def has_first_page?
+      !!first_page_link
+    end
+
+    def has_last_page?
+      !!last_page_link
+    end
+
+    def next_page_link
+      parsed_link_header.try(:find_link, %w[rel next])
+    end
+
+    def prev_page_link
+      parsed_link_header.try(:find_link, %w[rel prev])
+    end
+
+    def first_page_link
+      parsed_link_header.try(:find_link, %w[rel first])
+    end
+
+    def last_page_link
+      parsed_link_header.try(:find_link, %w[rel last])
+    end
+
+    def respond_to?(name, *args)
+      super || body.respond_to?(name, *args)
+    end
+
+    private
+
+    def method_missing(name, *args, &block)
+      if body.respond_to?(name)
+        body.send(name, *args, &block)
+      else
+        super
+      end
+    end
+
+    def dictionary_response?
+      response.headers['Content-Type'] =~ MIME_DICT
+    end
+
+    def parsed_link_header
+      @parsed_link_header ||= LinkHeader.parse(link) if link
+    end
+  end
+end

data/lib/garage_client/response/cacheable.rb

@@ -0,0 +1,27 @@
+require "faraday_middleware"
+
+module GarageClient
+  class Response
+    class Cacheable < Faraday::Response::Middleware
+      register_middleware cache: self
+
+      def initialize(app, args)
+        super(app)
+        @cacher_class = args[:cacher]
+        validate!
+      end
+
+      def call(env)
+        @cacher_class.new(env).call { @app.call(env) }
+      end
+
+      private
+
+      def validate!
+        unless @cacher_class
+          raise ArgumentError, "You must pass cacher_class to #{self.class}.new"
+        end
+      end
+    end
+  end
+end

data/lib/garage_client/response/raise_http_exception.rb

@@ -0,0 +1,34 @@
+require 'garage_client/error'
+require 'faraday_middleware'
+
+module GarageClient
+  class Response
+    class RaiseHttpException < Faraday::Response::Middleware
+      def call(env)
+        @app.call(env).on_complete do |response|
+          resp = response
+          case response[:status].to_i
+          when 401
+            raise GarageClient::Unauthorized.new(resp)
+          when 403
+            raise GarageClient::Forbidden.new(resp)
+          when 404
+            raise GarageClient::NotFound.new(resp)
+          when 406
+            raise GarageClient::NotAcceptable.new(resp)
+          when 409
+            raise GarageClient::Conflict.new(resp)
+          when 415
+            raise GarageClient::UnsupportedMediaType.new(resp)
+          when 422
+            raise GarageClient::UnprocessableEntity.new(resp)
+          when 500
+            raise GarageClient::InternalServerError.new(resp)
+          when 503
+            raise GarageClient::ServiceUnavailable.new(resp)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/garage_client/version.rb

@@ -0,0 +1,3 @@
+module GarageClient
+  VERSION = '2.1.1'
+end