hyperdrive 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 26dee10778c01ac284135a3aeac9a9f33af6741c
-  data.tar.gz: f6e4adf3982bef03df48d8fdc333b09fead28833
+  metadata.gz: 898b32e10dc9b2836f112818125fcb5a07f28ce0
+  data.tar.gz: 917e3c1f3f9ba879170bbbaefc216593de6e2288
 SHA512:
-  metadata.gz: bc67ee73c8f6866e8200bfd861a857a61b95dbb4f5573b361471b6bb7130dce6b04e622a996cf75ff3e047ea98359682922ea21374ab3cf136db49e978f07ae9
-  data.tar.gz: eb7e54a97ebd50a00ca77c748bd027987c3f883e5cd9f5c8759bae37f0478cd0bb0e5c01eade331f02261b6019d7dde4b8169235e82f89e98aba46e3059a5311
+  metadata.gz: 055bf9088099afc3dadb018b7042a44a2589a52d91117e7c7e70eeeaf1e4fc16642980d6a5500a84fd3cffac9511c164f6ed3c51687469cdc24dfbc57b5986ad
+  data.tar.gz: 6dd19b1ddbd02b84a400ddd3aa22a952a7b06172e6164badd1de7a03b8b3037fb2f66ec90c9c206277c7dda561f89108739e3ab273f0f11bc9285f7c77b23a81

data/.travis.yml

@@ -1,6 +1,14 @@
 language: ruby
 rvm:
-  - 2.1.0  
-  - 1.9.3
-  - jruby-head
-  - rbx-2.1.1
+- 2.1.1
+- 1.9.3
+- jruby-head
+- rbx-2.1.1
+matrix:
+  allow_failures:
+    - rvm: jruby-head
+    - rvm: rbx-2.1.1
+env:
+  global:
+    secure: Tl3oBsBZRI5bMrtNH5mtTDvSTlTxNbsKaAnQ7KQ2KMyiH/eHolOSIbUYB9NB3GRMC6XSyFShRCaYPA/ET36HI+Jw3PFT/XADdiOdFqlk6VyJEUPznNQ1nlp8AsyNn+IexZXIl8DdqmZxGHlY6YKDbQV/U1v+FeW8X5j3TLN1mcw=
+before_install: gem install bundler

data/Gemfile

@@ -19,4 +19,6 @@ group :test do
   gem 'minitest-spec-context', require: false
   gem 'minitest-reporters', require: false
   gem 'rack-test', require: false
+  gem 'rubinius-coverage', require: false, platforms: :rbx
+  gem 'codeclimate-test-reporter', require: false
 end

data/hyperdrive.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |gem|
   gem.authors       = ['StyleSeek Engineering']
   gem.email         = ['engineering@styleseek.com']
   gem.summary       = %q{Hypermedia State Machine}
-  gem.description   = %q{Ruby DSL for defining self-documenting, HATEOAS™ complaint, Hypermedia API endpoints.}
+  gem.description   = %q{Ruby DSL for defining self-documenting, HATEOAS™ compliant, Hypermedia API endpoints.}
   gem.homepage      = "https://github.com/styleseek/hyperdrive"
   gem.license       = "MIT"
 
@@ -18,7 +18,11 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
   
-  gem.add_dependency 'rack'
   gem.add_dependency 'linguistics'
+  gem.add_dependency 'oj'
+  gem.add_dependency 'rack'
+  gem.add_dependency 'rack-cache'
+  gem.add_dependency 'rack-ssl'
+  gem.add_dependency 'rack-accept'
   gem.add_dependency 'thor'
 end

data/lib/hyperdrive/docs.rb

@@ -12,13 +12,13 @@ module Hyperdrive
       out = ""
       resources.each_value do |resource|
         out += header(resource.name)
-        out += paragraph(resource.desc)
+        out += paragraph(resource.description)
         out += header("Endpoint URL", 2)
         out += paragraph(bullet(code(resource.endpoint), 1))
         out += header("Params", 2)
-        out += list(resource.allowed_params)
+        out += list(resource.params.map { |_,param| param.to_hash })
         out += header("Filters", 2)
-        out += list(resource.filters)
+        out += list(resource.filters.map { |_,filter| filter.to_hash })
       end
       out
     end
@@ -53,16 +53,15 @@ module Hyperdrive
 
     def list(items)
       list = ""
-      items.each do |key, value|
-        list += bullet(bold(key), 1)
+      items.each do |item|
+        list += bullet(bold(item[:name]), 1)
+        item.each do |key, value|
+          list += bullet(italics(key), 2)
 
-        value.each do |subkey, subvalue|
-          list += bullet(italics(subkey), 2)
-
-          if subvalue.kind_of? Array
-            list += bullet(code_options(subvalue), 3)
+          if value.kind_of? Array
+            list += bullet(code_options(value), 3)
           else
-            list += bullet(subvalue, 3)
+            list += bullet(value, 3)
           end
         end
       end

data/lib/hyperdrive/dsl/resource.rb

@@ -3,18 +3,19 @@
 module Hyperdrive
   module DSL
     class Resource
+      include Values
       attr_reader :resource
-      def initialize(key, &block)
-        @resource = ::Hyperdrive::Resource.new(key)
-        instance_eval(&block) if block_given?
+      def initialize(name, hyperdrive_config)
+        @resource = ::Hyperdrive::Resource.new(name, hyperdrive_config)
+        instance_eval(&Proc.new) if block_given?
       end
 
       def name(name)
         resource.name = name
       end
 
-      def desc(description)
-        resource.desc = description
+      def description(description)
+        resource.description = description
       end
 
       def param(*args)
@@ -25,17 +26,11 @@ module Hyperdrive
         resource.register_filter(*args)
       end
 
-      def request(method, &block)
-        unless definable_request_methods.include? method
-          raise Errors::DSL::UnknownArgument.new(method, 'request')
+      def request(request_method)
+        unless definable_request_methods.include? request_method
+          raise Errors::DSL::UnknownArgument.new(request_method, 'request')
         end
-        resource.define_request_handler(method, block)
-      end
-
-      private
-
-      def definable_request_methods
-        [:get, :post, :put, :patch, :delete].freeze
+        resource.register_request_handler(request_method, Proc.new)
       end
     end
   end

data/lib/hyperdrive/dsl.rb

@@ -1,9 +1,55 @@
 # encoding: utf-8
 
-require 'hyperdrive/dsl/main'
 require 'hyperdrive/dsl/resource'
 
+module Hyperdrive
+  module DSL
+    include Values
+    extend self
+    attr_reader :config, :resources
+
+    def instance
+      @config ||= default_config.dup
+      @resources ||= {}
+      self
+    end
+
+    private
+    
+    def name(name)
+      @config[:name] = name
+    end
+
+    def description(description)
+      @config[:description] = description
+    end
+
+    def vendor(vendor)
+      @config[:vendor] = vendor
+    end
+
+    def media_types(media_types)
+      @config[:media_types] = media_types
+    end
+
+    def cors(options = {})
+      allowed_options = default_cors_options.keys
+      options = Utils.sanitize_keys(allowed_options, options)
+      @config[:cors] = config[:cors].merge(options)
+    end
+
+    def resource(name)
+      @resources[name] = Resource.new(name, @config, &Proc.new).resource
+    end
+
+    def reset! # not terribly useful outside of a test environment :(
+      @config = default_config.dup
+      @resources = {}
+    end
+  end
+end
+
 def hyperdrive(&block)
-  Hyperdrive::DSL::Main.instance.instance_eval(&block) if block_given?
-  Hyperdrive::DSL::Main.instance
+  Hyperdrive::DSL.instance.instance_eval(&block) if block_given?
+  Hyperdrive::DSL.instance
 end

data/lib/hyperdrive/endpoint.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+module Hyperdrive
+  class Endpoint
+
+    def self.call(env)
+      @env = env
+      @request = Rack::Request.new(@env)
+      @media_type = env['hyperdrive.media_type']
+      @params = env['hyperdrive.params']
+      @resource = env['hyperdrive.resource']
+      @headers = Hyperdrive::Values.default_headers.dup
+      @headers.merge!('Allow' => resource.allowed_methods, 'Content-Type' => @media_type)
+
+      response.finish
+    end
+
+    private
+
+    class << self
+      attr_reader   :env, :request, :media_type, :params, :resource
+      attr_accessor :headers
+    end
+
+    def self.json?
+      media_type =~ /json$/
+    end
+
+    def self.xml?
+      media_type =~ /xml$/
+    end
+
+    def self.render(body)
+      case body
+      when Array, Hash
+        Oj.dump(body, mode: :compat) if json?
+      when String
+        body
+      else
+        body.to_s
+      end
+    end
+
+    def self.status
+      case env['REQUEST_METHOD']
+      when 'POST'
+        201
+      when 'DELETE'
+        204
+      else
+        200
+      end
+    end
+
+    def self.body
+      body = instance_eval(&resource.request_handler(env['REQUEST_METHOD']))
+      body = '' if env['REQUEST_METHOD'] == 'DELETE'
+      body
+    end
+
+    def self.response
+      ::Rack::Response.new(body, status, headers)
+    end
+  end
+end

data/lib/hyperdrive/errors/missing_required_param.rb

@@ -0,0 +1,19 @@
+module Hyperdrive
+  module Errors
+    class MissingRequiredParam < HTTPError
+      attr_reader :param, :http_request_method
+      def initialize(param, http_request_method)
+        @param = param
+        @http_request_method = http_request_method
+      end
+
+      def message
+        "The #{param} param is required by #{http_request_method} requests."
+      end
+
+      def http_status_code
+        400
+      end
+    end
+  end
+end

data/lib/hyperdrive/errors/not_acceptable.rb

@@ -0,0 +1,18 @@
+module Hyperdrive
+  module Errors
+    class NotAcceptable < HTTPError
+      def initialize(http_accept)
+        @http_accept = http_accept
+      end
+
+      def message
+        "This resource is not capable of generating content in the format requested by the Accept headers (#{@http_accept})."
+      end
+
+      def http_status_code
+        406
+      end
+    end
+  end
+end
+

data/lib/hyperdrive/errors.rb

@@ -1,10 +1,15 @@
 # encoding: utf-8
 
-require 'hyperdrive/errors/http_error'
-require 'hyperdrive/errors/bad_request'
-require 'hyperdrive/errors/internal_server_error'
-require 'hyperdrive/errors/method_not_allowed'
-require 'hyperdrive/errors/not_found'
-require 'hyperdrive/errors/not_implemented'
-require 'hyperdrive/errors/unauthorized'
-require 'hyperdrive/errors/dsl/unknown_argument'
+# DSL Errors
+require 'hyperdrive/errors/dsl/unknown_argument'
+
+# HTTP Errors
+require 'hyperdrive/errors/http_error' # 500 (Catch All)
+require 'hyperdrive/errors/bad_request' # 400 (Generic)
+require 'hyperdrive/errors/internal_server_error' # 500 (Generic)
+require 'hyperdrive/errors/method_not_allowed' # 405
+require 'hyperdrive/errors/missing_required_param' # 400 (Specific)
+require 'hyperdrive/errors/not_acceptable' # 406
+require 'hyperdrive/errors/not_found' # 404
+require 'hyperdrive/errors/not_implemented' # 501
+require 'hyperdrive/errors/unauthorized' # 401

data/lib/hyperdrive/filter.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Hyperdrive
+  class Filter < Param
+    def initialize(name, description, options = {})
+      @name = name.to_s
+      @description = description
+      options = default_options.merge(options)
+      @required = if options[:required] == true
+                    %w(GET HEAD)
+                  elsif options[:required] == false
+                    []
+                  else
+                    Array(options[:required])
+                  end
+      @type = options[:type]
+      @constraints = "#{required_constraint} #{options[:constraints]}"
+    end
+  end
+end

data/lib/hyperdrive/hateoas.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+module Hyperdrive
+  class HATEOAS
+    extend Hyperdrive::Values
+
+    def self.call(env)
+      if hyperdrive.resources.empty? || env['PATH_INFO'] != '/'
+        raise Hyperdrive::Errors::NotFound
+      end
+
+      endpoints = hyperdrive.resources.map do |_,resource|
+        resource.to_hash
+      end
+
+      api = {
+              _links: { self: { href: '/' } },
+              name: hyperdrive.config[:name],
+              description: hyperdrive.config[:description],
+              vendor: hyperdrive.config[:vendor],
+              resources: endpoints
+            }
+
+      media_types = %w(hal+json json).map do |media_type|
+        "application/vnd.#{hyperdrive.config[:vendor]}+#{media_type}"
+      end
+
+      media_types += %w(application/hal+json application/json)
+      content_type = env['hyperdrive.accept'].best_of(media_types)
+      body = if content_type =~ /json$/
+                Oj.dump(api, mode: :compat)
+              else
+                raise Hyperdrive::Errors::NotAcceptable.new(env['HTTP_ACCEPT'])
+              end
+
+      status = 200
+      headers = {}
+      headers['Access-Control-Allow-Origin'] = '*'
+      headers['Access-Control-Allow-Methods'] = 'GET, HEAD, OPTIONS'
+      headers['Allow'] = 'GET, HEAD, OPTIONS'
+      headers['Content-Type'] = content_type
+      [status, headers, [body]]
+    end
+  end
+end

data/lib/hyperdrive/middleware/accept.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+module Hyperdrive
+  module Middleware
+    class Accept
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        env['hyperdrive.accept'] = Rack::Accept::MediaType.new(env['HTTP_ACCEPT'])
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/hyperdrive/middleware/content_negotiation.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module Hyperdrive
+  module Middleware
+    class ContentNegotiation
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        accept = env['hyperdrive.accept']
+        acceptable_content_types = env['hyperdrive.resource'].acceptable_content_types(env['REQUEST_METHOD'])
+        env['hyperdrive.media_type'] = accept.best_of(acceptable_content_types)
+        raise Hyperdrive::Errors::NotAcceptable.new(env['HTTP_ACCEPT']) unless env['hyperdrive.media_type']
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/hyperdrive/middleware/cors.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+module Hyperdrive
+  module Middleware
+    class CORS
+      def initialize(app, options = {})
+        @app = app
+        @options = options
+      end
+
+      def call(env)
+        status, headers, body = @app.call(env)
+        allowed_methods = '*'
+        unless env['hyperdrive.resource'].nil?
+          allowed_methods = env['hyperdrive.resource'].allowed_methods
+        end
+        cors = cors_headers(allowed_methods)
+        headers.merge!(cors)
+        [status, headers, body]
+      end
+
+      private
+
+      def cors_headers(allowed_methods = '*')
+        {
+          'Access-Control-Allow-Origin'      => Array(@options[:origins]).join(", "),
+          'Access-Control-Allow-Methods'     => Array(allowed_methods).join(", "),
+          'Access-Control-Allow-Headers'     => Array(@options[:allow_headers]).join(", "),
+          'Access-Control-Allow-Credentials' => (@options[:credentials] || false).to_s,
+          'Access-Control-Max-Age'           => @options[:max_age].to_i.to_s,
+          'Access-Control-Expose-Headers'    => Array(@options[:expose_headers]).join(", ")
+        }
+      end
+    end
+  end
+end

data/lib/hyperdrive/middleware/error.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+module Hyperdrive
+  module Middleware
+    class Error
+      include Hyperdrive::Values
+      
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      rescue Hyperdrive::Errors::HTTPError => e
+        status = e.http_status_code
+        headers = { 'Content-Type' => 'application/json',
+                    'Allow' => supported_request_methods.join(', ') }
+        body = Oj.dump(error_message(e), mode: :compat)
+        [status, headers, [body]]
+      end
+
+      private
+      
+      def error_message(e)
+        {
+          _links: { root: { href: '/', title: 'API Root' } },
+          error: { 
+            type: "#{e.class.to_s.split('::').last}",
+            message: e.message
+          }
+        }
+      end
+    end
+  end
+end

data/lib/hyperdrive/middleware/request_method.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+module Hyperdrive
+  module Middleware
+    class RequestMethod
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        http_request_method = env['REQUEST_METHOD']
+
+        unless request_method_supported?(http_request_method)
+          raise Hyperdrive::Errors::NotImplemented.new(http_request_method)
+        end
+
+        unless env['hyperdrive.resource'].request_method_allowed?(http_request_method)
+          raise Hyperdrive::Errors::MethodNotAllowed.new(http_request_method)
+        end
+
+        @app.call(env)
+      end
+
+      private
+  
+      def request_method_supported?(http_request_method)
+        Hyperdrive::Values.http_request_methods.key?(http_request_method)
+      end
+    end
+  end
+end

data/lib/hyperdrive/middleware/required_params.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+module Hyperdrive
+  module Middleware
+    class RequiredParams
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @env = env
+        if %w(GET HEAD).include? env['REQUEST_METHOD']
+          check_required_params(env['hyperdrive.resource'].filters)
+        elsif %W(POST PUT PATCH DELETE).include? env['REQUEST_METHOD']
+          check_required_params(env['hyperdrive.resource'].params)
+        end
+        @app.call(env)
+      end
+
+      def check_required_params(params)
+        params.each do |param, options|
+          if @env['hyperdrive.resource'].required?(param, @env['REQUEST_METHOD'])
+            if @env['hyperdrive.params'].key?(param)
+              if @env['hyperdrive.params'][param] == ''
+                raise Errors::MissingRequiredParam.new(param, @env['REQUEST_METHOD'])
+              end
+            else
+              raise Errors::MissingRequiredParam.new(param, @env['REQUEST_METHOD'])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hyperdrive/middleware/resource.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+# Internal: Adds the requested resource to rack's env
+module Hyperdrive
+  module Middleware
+    class Resource
+      def initialize(app, resource)
+        @app = app
+        @resource = resource
+      end
+
+      def call(env)
+        env['hyperdrive.resource'] = @resource
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/hyperdrive/middleware/sanitize_params.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module Hyperdrive
+  module Middleware
+    class SanitizeParams
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        unless %w(OPTIONS TRACE).include? env['REQUEST_METHOD']
+          request = Rack::Request.new(env)
+          params = Hyperdrive::Utils.symbolize_keys(request.params)
+          if %w(GET HEAD).include? env['REQUEST_METHOD']
+            params_to_keep = env['hyperdrive.resource'].filters.keys
+          else
+            params_to_keep = env['hyperdrive.resource'].params.keys
+          end
+          env['hyperdrive.params'] = Hyperdrive::Utils.sanitize_keys(params_to_keep, params)
+        end
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/hyperdrive/middleware.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+require 'hyperdrive/middleware/accept'
+require 'hyperdrive/middleware/cors'
+require 'hyperdrive/middleware/content_negotiation'
+require 'hyperdrive/middleware/error'
+require 'hyperdrive/middleware/resource'
+require 'hyperdrive/middleware/request_method'
+require 'hyperdrive/middleware/required_params'
+require 'hyperdrive/middleware/sanitize_params'