the_garage 2.0.0

data/lib/garage/docs/engine.rb

@@ -0,0 +1,35 @@
+require "rails"
+require "haml"
+require "sass-rails"
+require "coffee-rails"
+require "redcarpet"
+
+require "garage/docs/anchor_building"
+require "garage/docs/console_link_building"
+require "garage/docs/renderer"
+require "garage/docs/toc_renderer"
+require "garage/docs/application"
+require "garage/docs/document"
+require "garage/docs/example"
+
+module Garage
+  module Docs
+    class Engine < ::Rails::Engine
+      isolate_namespace Garage::Docs
+
+      initializer "garage.docs.engine.routes" do
+        Engine.routes.append do
+          root :to => 'resources#index', as: nil
+          resources :resources do
+            collection do
+              get 'console'
+              post 'authenticate'
+              get 'callback'
+              post 'callback'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/garage/docs/example.rb

@@ -0,0 +1,26 @@
+module Garage
+  module Docs
+    class Example
+      def self.build_all(controller, examples)
+        examples.compact.map do |resource|
+          new(resource, controller)
+        end
+      end
+
+      def initialize(resource, controller)
+        @resource, @controller = resource, controller
+      end
+
+      def url
+        if @resource.is_a?(String)
+          @resource
+        elsif @resource.respond_to?(:to_proc)
+          @resource.to_proc.call(@controller.main_app)
+        else
+          @resource.represent!
+          @resource.link_path_for(:self)
+        end
+      end
+    end
+  end
+end

data/lib/garage/docs/renderer.rb

@@ -0,0 +1,17 @@
+module Garage
+  module Docs
+    class Renderer < ::Redcarpet::Render::HTML
+      include ConsoleLinkBuilding
+      include AnchorBuilding
+
+      def header(text, header_level)
+        if header_level == 2
+          id = to_anchor(text)
+          %!<a href="##{id}"><h#{header_level} id="#{id}">#{text} #{build_console_link(text)}</h#{header_level}></a>!
+        else
+          %!<h#{header_level}>#{text}</h#{header_level}>!
+        end
+      end
+    end
+  end
+end

data/lib/garage/docs/toc_renderer.rb

@@ -0,0 +1,14 @@
+module Garage
+  module Docs
+    class TocRenderer < ::Redcarpet::Render::HTML_TOC
+      include ConsoleLinkBuilding
+      include AnchorBuilding
+
+      def header(text, header_level)
+        return if header_level > 2
+
+        %'<li><a href="##{to_anchor(text)}">#{text}</a> #{build_console_link(text)}</li>'
+      end
+    end
+  end
+end

data/lib/garage/docs.rb

@@ -0,0 +1,9 @@
+require 'garage/docs/engine'
+
+module Garage
+  module Docs
+    def self.application
+      @application ||= Garage::Docs::Application.new(Rails.application)
+    end
+  end
+end

data/lib/garage/exceptions.rb

@@ -0,0 +1,49 @@
+module Garage
+  class HTTPError < ::StandardError
+    attr_accessor :status
+    def status_code
+      Rack::Utils.status_code(status)
+    end
+  end
+
+  class BadRequest < HTTPError
+    def initialize(error)
+      @status = :bad_request
+      super(error)
+    end
+  end
+
+  class Unauthorized < HTTPError
+    attr_reader :user, :action, :resource_class, :scopes
+
+    def initialize(user, action, resource_class, status = :forbidden, scopes = [])
+      @user, @action, @resource_class, @status, @scopes = user, action, resource_class, status, scopes
+
+      if scopes.empty?
+        super "Authorized user is not allowed to take the requested operation #{action} on #{resource_class}"
+      else
+        super "Insufficient scope to process the requested operation. Missing scope(s): #{scopes.join(", ")}"
+      end
+    end
+  end
+
+  class PermissionError < Unauthorized; end
+  class MissingScopeError < Unauthorized; end
+
+  class AuthBackendTimeout < HTTPError
+    def initialize(open_timeout, read_timeout)
+      @status = :internal_server_error
+      super("Auth backend timed out: open_timeout=#{open_timeout}, read_timeout=#{read_timeout}")
+    end
+  end
+
+  class AuthBackendError < HTTPError
+    attr_reader :response
+
+    def initialize(response)
+      @status = :internal_server_error
+      @response = response
+      super("Auth backend responded error: status=#{response.status_code}")
+    end
+  end
+end

data/lib/garage/hypermedia_filter.rb

@@ -0,0 +1,44 @@
+module Garage
+  class HypermediaFilter
+    MIME_DICT = %r[application/vnd\.cookpad\.dictionary\+(json|x-msgpack)]
+
+    def self.before(controller)
+      helper = new(controller)
+      controller.representation = helper.dictionary_representation if helper.has_dictionary_mime_type?
+      controller.request.format = helper.dictionary_request_format if helper.has_dictionary_mime_type?
+      controller.field_selector = helper.field_selector
+    rescue Garage::NestedFieldQuery::InvalidQuery
+      raise Garage::BadRequest, "Invalid query in ?fields="
+    end
+
+    attr_reader :controller
+
+    def initialize(controller)
+      @controller = controller
+    end
+
+    def field_selector
+      Garage::NestedFieldQuery::Selector.build(fields_param)
+    end
+
+    def fields_param
+      controller.params[:fields]
+    end
+
+    def dictionary_representation
+      :dictionary
+    end
+
+    def dictionary_request_format
+      dictionary_match_data[1].sub(/^x-/, "").to_sym
+    end
+
+    def has_dictionary_mime_type?
+      dictionary_match_data
+    end
+
+    def dictionary_match_data
+      @dictionary_match_data ||= controller.request.format.to_s.match(MIME_DICT)
+    end
+  end
+end

data/lib/garage/hypermedia_responder.rb

@@ -0,0 +1,120 @@
+require 'oj'
+
+module Garage
+  module HypermediaResponder
+    def display(resource, given_options={})
+      given_options[:content_type] = representation.content_type if representation.dictionary?
+      super(render(transform(resource)), given_options)
+    end
+
+    def render(data)
+      DataRenderer.render(data, dictionary: representation.dictionary?)
+    end
+
+    def transform(resources)
+      if resources.respond_to?(:map) && resources.respond_to?(:to_a)
+        resources.map {|resource| encode_to_hash(resource, partial: true) }
+      else
+        encode_to_hash(resources)
+      end
+    end
+
+    # Cache resource encoding result if the resource can be identified.
+    # Garage try to get resource identifier by acccess the resource
+    # `#resource_identifier` or `#id`.
+    def encode_to_hash(resource, *args)
+      if id = get_resource_identifier(resource)
+        cache_key = "#{resource.class.name}:#{id}"
+        cache[cache_key] ||= _encode_to_hash(resource, *args)
+      else
+        _encode_to_hash(resource, *args)
+      end
+    end
+
+    private
+
+    def _encode_to_hash(resource, options = {})
+      resource.represent!
+      resource.params = controller.params.slice(*resource.class.params)
+      resource.partial = options[:partial]
+      resource.selector = options[:selector] || controller.field_selector
+      resource.render_hash(:responder => self)
+    end
+
+    def cache
+      @cache ||= {}
+    end
+
+    def get_resource_identifier(resource)
+      case
+      when resource.respond_to?(:resource_identifier)
+        resource.resource_identifier
+      when resource.respond_to?(:id)
+        resource.id
+      else
+        nil
+      end
+    end
+
+    def representation
+      @representation ||= Representation.new(controller)
+    end
+
+    class Representation
+      attr_reader :controller
+
+      def initialize(controller)
+        @controller = controller
+      end
+
+      def dictionary?
+        controller.representation == :dictionary
+      end
+
+      def content_type
+        mime, payload = controller.request.format.to_s.split("/", 2)
+        "#{mime}/vnd.cookpad.dictionary+#{payload}"
+      end
+    end
+
+    class DataRenderer
+      JSON_ESCAPE_TABLE = { "<" => '\u003C', ">" => '\u003E' }.freeze
+
+      def self.render(*args)
+        new(*args).render
+      end
+
+      attr_reader :data, :options
+
+      def initialize(data, options = {})
+        @data, @options = data, options
+      end
+
+      def render
+        Oj.dump(converted_data, mode: :compat).gsub(/([<>])/, JSON_ESCAPE_TABLE)
+      end
+
+      private
+
+      def dictionary?
+        !!options[:dictionary]
+      end
+
+      def convertible_to_dictionary?
+        dictionary? && data.is_a?(Array) && data.all? {|datum| datum.respond_to?(:[]) }
+      end
+
+      def indexed_data
+        data.index_by {|datum| datum["id"] }
+      end
+
+      def converted_data
+        if convertible_to_dictionary?
+          indexed_data
+        else
+          data
+        end
+      end
+    end
+  end
+end

data/lib/garage/meta/engine.rb

@@ -0,0 +1,16 @@
+require "garage/meta/remote_service"
+
+module Garage
+  module Meta
+    class Engine < ::Rails::Engine
+      isolate_namespace Garage::Meta
+
+      initializer "garage.meta.engine.routes" do
+        Engine.routes.append do
+          resources :services
+          resources :docs
+        end
+      end
+    end
+  end
+end

data/lib/garage/meta/remote_service.rb

@@ -0,0 +1,78 @@
+module Garage
+  module Meta
+    class RemoteService
+      class << self
+        def configure(&block)
+          @config = Config.new
+          @config.instance_eval(&block)
+        end
+
+        def configuration
+          @config or raise "Garage::Meta::RemoteService.configure must be called in initializer"
+        end
+
+        def all
+          configuration.services
+        end
+
+        def build_permissions(perms, other, target)
+          perms.permits! :read
+        end
+      end
+
+      include Garage::Representer
+      include Garage::Authorizable
+
+      property :namespace
+      property :name
+      property :endpoint
+      property :alternate_endpoints
+
+      attr_accessor :namespace, :name, :endpoint
+
+      def alternate_endpoints
+        @alternate_endpoints ||= {}
+      end
+
+      class Config
+        attr_reader :services
+
+        def initialize
+          @services = []
+        end
+
+        def service(&block)
+          service = ServiceDSL.new
+          service.instance_eval(&block)
+          @services << service.build
+        end
+      end
+
+      class ServiceDSL
+        def initialize
+          @service = RemoteService.new
+        end
+
+        def namespace(arg)
+          @service.namespace = arg.to_s
+        end
+
+        def name(arg)
+          @service.name = arg
+        end
+
+        def endpoint(arg)
+          @service.endpoint = arg
+        end
+
+        def alternate_endpoint(rel, url)
+          @service.alternate_endpoints[rel] = url
+        end
+
+        def build
+          @service
+        end
+      end
+    end
+  end
+end

data/lib/garage/meta.rb

@@ -0,0 +1,6 @@
+require 'garage/meta/engine'
+
+module Garage
+  module Meta
+  end
+end

data/lib/garage/meta_resource.rb

@@ -0,0 +1,17 @@
+# Public: proxy object to handle model Class as a resource
+module Garage
+  class MetaResource
+    include Garage::Authorizable
+
+    attr_reader :resource_class
+
+    def initialize(resource_class, args = {})
+      @resource_class = resource_class
+      @args = args
+    end
+
+    def build_permissions(perms, user)
+      resource_class.build_permissions(perms, user, @args)
+    end
+  end
+end