rack-spec 0.0.5 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bf3a96b091fcf262c279bfd214379e55ed856c7a
-  data.tar.gz: 313b5fd8342e4ddd245fced70fad0d348db2092f
+  metadata.gz: a554761d92c1fbeb80f0983023a2cc61970cb9f6
+  data.tar.gz: 578034987add0a2733821b66a3d7fa9743e9aaac
 SHA512:
-  metadata.gz: 2ef09a48686f6e9818fbd4e2c8aef235b8d45981a26f4703e54efe051deb7f057a57dee84ab6d93cb3fb41e327691dd717db083b41835ef50d3e5796170d6368
-  data.tar.gz: f625b179cae1770d3877b050492d3e93fa9b05e226a4f84ad359a5acaad62b176277cf0eb8b1afd862bd8c77b69bed2d866a2247b441e4eda909cd779a922f60
+  metadata.gz: c12e918bd0224e9968dc856e0bd3fcc89293b1133bd1d6ed35c6c49d02ee8bff9ed988078f3281fd34947b99b128f8453bf22350eb820fad334262613e807e47
+  data.tar.gz: c95c7728c4d01ffb2066b3193102e08a44ef9202c9da36b343027352f7e77d1f76219a39762e23c954b6b34ad4f4afa6f2e69a81636e65436eb095fbd16c6809

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+## v0.1.0
+* Rebuilt entire code based on JSON schema
+
 ## v0.0.5
 * Change RESTful resource API (#get, #post, #put, and #delete)
 

data/README.md

@@ -1,135 +1,11 @@
 # Rack::Spec
-Spec based web-application middleware for Rack.
+Generate API server from [JSON Schema](http://json-schema.org/).
 
-* Rack::Spec - all-in-one middleware
- * Rack::Spec::Validation - validates requests along given specifications
- * Rack::Spec::ExceptionHandler - rescues exceptions raised from Rack::Spec::Validation
- * Rack::Spec::Restful - provides strongly-conventional RESTful API endpoints
+## RequestValidation
+* Raise `Rack::Spec::RequestValidation::LinkNotFound` when given request is not defined in schema
+* Raise `Rack::Spec::RequestValidation::InvalidContentType` for invalid content type
+* Raise `Rack::Spec::RequestValidation::InvalidParameter` for invalid request parameter
 
 ```ruby
-use Rack::Spec, spec: YAML.load_file("spec.yml")
-run ->(env) { [404, {}, ["Not Found"]] }
-```
-
-```yaml
-# spec.yml
-meta:
-  baseUri: http://api.example.com/
-
-endpoints:
-  /recipes:
-    GET:
-      parameters:
-        page:
-          type: integer
-          minimum: 1
-          maximum: 10
-        private:
-          type: boolean
-        rank:
-          type: float
-        time:
-          type: iso8601
-        kind:
-          type: string
-          only:
-            - mono
-            - di
-            - tri
-    POST:
-      parameters:
-        title:
-          type: string
-          minimumLength: 3
-          maximumLength: 10
-          required: true
-```
-
-## Rack::Spec::Validation
-Rack::Spec::Validation is a rack-middleware and works as a validation layer for your rack-application.
-It loads spec definition (= a pure Hash object in specific format) to validate each request.
-If the request is not valid on your definition, it will raise Rack::Spec::Exceptions::ValidationError.
-Rack::Spec::ExceptionHandler is a utility rack-middleware to rescue validation error and return 400.
-
-```ruby
-use Rack::Spec::ExceptionHandler
-use Rack::Spec::Validation, spec: YAML.load_file("spec.yml")
-```
-
-### Custom Validator
-Custom validator can be defined by inheriting Rack::Spec::Validators::Base.
-The following FwordValidator rejects any parameter starting with "F".
-See [lib/rack/spec/validators](https://github.com/r7kamura/rack-spec/tree/master/lib/rack/spec/validators) for more examples.
-
-```ruby
-# Example:
-#
-# parameters:
-#   title:
-#     fword: false
-#
-class FwordValidator < Rack::Spec::Validators::Base
-  register_as "fword"
-
-  def valid?
-    value.nil? || !value.start_with?("F")
-  end
-end
-```
-
-### Exception Handling
-Replace Rack::Spec::ExceptionHandler to customize error behavior.
-
-```ruby
-use MyExceptionHandler # Rack::Spec::Exceptions::ValidationError must be rescued
-use Rack::Spec::Validation, spec: YAML.load_file("spec.yml")
-```
-
-## Rack::Spec::Restful
-Rack::Spec::Restful provides strongly-conventional RESTful API endpoints as a rack-middleware.
-
-### Convention
-It recognizes a preferred instruction from the request method & path, then tries to call it.
-
-| verb   | path          | instruction           |
-| ----   | ----          | ----                  |
-| GET    | /recipes      | Recipe.get(params)    |
-| GET    | /recipes/{id} | Recipe.get(params)    |
-| POST   | /recipes      | Recipe.post(params)   |
-| PUT    | /recipes/{id} | Recipe.put(params)    |
-| DELETE | /recipes/{id} | Recipe.delete(params) |
-
-### Example
-You must implement correspondent class & methods for your API.
-
-```ruby
-class Recipe
-  def self.index(params)
-    order(params[:order]).page(params[:page])
-  end
-
-  def self.show(id, params)
-    find(id)
-  end
-end
-
-require "rack"
-require "rack/spec"
-require "yaml"
-
-use Rack::Spec::Restful, spec: YAML.load_file("spec.yml")
-run ->(env) do
-  [404, {}, ["Not Found"]]
-end
-```
-
-## Development
-```sh
-# setup
-git clone git@github.com:r7kamura/rack-spec.git
-cd rack-spec
-bundle install
-
-# testing
-bundle exec rspec
+use Rack::Spec::RequestValidation, schema: JSON.parse("schema.json")
 ```

data/lib/rack/spec.rb

@@ -1,37 +1,7 @@
-require "rack/builder"
-require "rack/spec/exception_handler"
-require "rack/spec/exceptions/base"
-require "rack/spec/exceptions/validation_error"
-require "rack/spec/restful"
-require "rack/spec/spec"
-require "rack/spec/validation"
-require "rack/spec/validators/base"
-require "rack/spec/validators/null_validator"
-require "rack/spec/validator_factory"
-require "rack/spec/validators/maximum_length_validator"
-require "rack/spec/validators/maximum_validator"
-require "rack/spec/validators/minimum_length_validator"
-require "rack/spec/validators/minimum_validator"
-require "rack/spec/validators/null_validator"
-require "rack/spec/validators/only_validator"
-require "rack/spec/validators/parameters_validator"
-require "rack/spec/validators/required_validator"
-require "rack/spec/validators/type_validator"
-require "rack/spec/version"
-
-module Rack
-  class Spec
-    def initialize(app, options)
-      @app = Rack::Builder.app do
-        use Rack::Spec::ExceptionHandler
-        use Rack::Spec::Validation, options
-        use Rack::Spec::Restful, options
-        run app
-      end
-    end
+require "json"
+require "json_schema"
+require "multi_json"
 
-    def call(env)
-      @app.call(env)
-    end
-  end
-end
+require "rack/spec/request_validation"
+require "rack/spec/schema"
+require "rack/spec/version"

data/lib/rack/spec/request_validation.rb

@@ -0,0 +1,153 @@
+module Rack
+  module Spec
+    class RequestValidation
+      # Behaves as a rack-middleware
+      # @param app [Object] Rack application
+      # @param schema [Hash] Schema object written in JSON schema format
+      # @raise [JsonSchema::SchemaError]
+      def initialize(app, schema: nil)
+        @app = app
+        @schema = Schema.new(schema)
+      end
+
+      # Behaves as a rack-middleware
+      # @param env [Hash] Rack env
+      def call(env)
+        Validator.call(env: env, schema: @schema)
+        @app.call(env)
+      end
+
+      class Validator
+        # Utility wrapper method
+        def self.call(**args)
+          new(**args).call
+        end
+
+        # @param env [Hash] Rack env
+        # @param schema [JsonSchema::Schema] Schema object
+        def initialize(env: nil, schema: nil)
+          @env = env
+          @schema = schema
+        end
+
+        # Raises an error if any error detected
+        # @raise [Rack::Spec::RequestValidation::Error]
+        def call
+          case
+          when !has_link_for_current_action?
+            raise LinkNotFound
+          when has_body? && !has_valid_content_type?
+            raise InvalidContentType
+          when has_schema? && !has_valid_parameter?
+            raise InvalidParameter
+          end
+        end
+
+        private
+
+        # @return [true, false] True if request parameters are all valid
+        def has_valid_parameter?
+          valid, errors = link.schema.validate(parameters)
+          valid
+        rescue MultiJson::ParseError
+          false
+        end
+
+        # @return [true, false] True if any schema is defined for the current action
+        def has_schema?
+          !!link.schema
+        end
+
+        # @return [true, false] True if request body is not empty
+        def has_body?
+          !body.empty?
+        end
+
+        # @return [true, false] True if no or matched content type given
+        def has_valid_content_type?
+          content_type.nil? || Rack::Mime.match?(link.enc_type, content_type)
+        end
+
+        # @return [true, false] True if link is defined for the current action
+        def has_link_for_current_action?
+          !!link
+        end
+
+        # @return [JsonSchema::Schema::Link, nil] Link for the current action
+        def link
+          if instance_variable_defined?(:@link)
+            @link
+          else
+            @link = @schema.link_for(method: method, path: path)
+          end
+        end
+
+        # Treats env as a utility object to easily extract method and path
+        # @return [Rack::Request]
+        def request
+          @request ||= Rack::Request.new(@env)
+        end
+
+        # @return [String] HTTP request method
+        # @example
+        #   method #=> "GET"
+        def method
+          request.request_method
+        end
+
+        # @return [String] Request path
+        # @example
+        #   path #=> "/recipes"
+        def path
+          request.path_info
+        end
+
+        # @return [String] Request content type
+        # @example
+        #   path #=> "application/json"
+        def content_type
+          request.content_type
+        end
+
+        # @return [String] request body
+        def body
+          if instance_variable_defined?(:@body)
+            @body
+          else
+            @body = request.body.read
+            request.body.rewind
+            @body
+          end
+        end
+
+        # @return [Hash] Request parameters decoded from JSON
+        # @raise [MultiJson::ParseError]
+        def parameters
+          @parameters ||= begin
+            if has_body?
+              MultiJson.decode(body)
+            else
+              {}
+            end
+          end
+        end
+      end
+
+      # Base error class for Rack::Spec::RequestValidation
+      class Error < StandardError
+      end
+
+      # Error class for case when no link defined for given request
+      class LinkNotFound < Error
+      end
+
+      # Error class for invalid request content type
+      class InvalidContentType < Error
+      end
+
+      # Error class for invalid request parameter
+      class InvalidParameter < Error
+      end
+    end
+  end
+end

data/lib/rack/spec/schema.rb

@@ -0,0 +1,55 @@
+module Rack
+  module Spec
+
+    # Utility wrapper class for JsonSchema::Schema
+    class Schema
+      # Recursively extracts all links in given JSON schema
+      # @param json_schema [JsonSchema::Schema]
+      # @return [Array] An array of JsonSchema::Schema::Link
+      def self.extract_links(json_schema)
+        links = json_schema.links.select {|link| link.method && link.href }
+        links + json_schema.properties.map {|key, schema| extract_links(schema) }.flatten
+      end
+
+      # @param schema [Hash]
+      # @raise [JsonSchema::SchemaError]
+      # @example
+      #   hash = JSON.parse("schema.json")
+      #   schema = Rack::Spec::Schema.new(hash)
+      def initialize(schema)
+        @json_schema = JsonSchema.parse!(schema).tap(&:expand_references!)
+      end
+
+      # @param method [String] Uppercase HTTP method name (e.g. GET, POST)
+      # @param path [String] Path string, which may include URI template
+      # @return [JsonSchema::Scheam::Link, nil] Link defined for the given method and path
+      # @example
+      #   schema.has_link_for?(method: "GET", path: "/recipes/{+id}") #=> nil
+      def link_for(method: nil, path: nil)
+        links_indexed_by_method[method].find do |link|
+          %r<^#{link.href.gsub(/\{(.*?)\}/, "[^/]+")}$> === path
+        end
+      end
+
+      private
+
+      # @return [Array] All links defined in given JSON schema
+      # @example
+      #   schema.links #=> [#<JsonSchema::Schema::Link>]
+      def links
+        @links ||= self.class.extract_links(@json_schema)
+      end
+
+      # @return [Hash] A key-value pair of HTTP method and an Array of links
+      # @note This Hash always returns an Array for any key
+      # @example
+      #   schema.links_indexed_by_method #=> { "GET" => [#<JsonSchema::Schema::Link>] }
+      def links_indexed_by_method
+        @links_indexed_by_method ||= links.inject(Hash.new {|hash, key| hash[key] = [] }) do |result, link|
+          result[link.method.to_s.upcase] << link
+          result
+        end
+      end
+    end
+  end
+end

data/lib/rack/spec/version.rb

@@ -1,5 +1,5 @@
 module Rack
-  class Spec
-    VERSION = "0.0.5"
+  module Spec
+    VERSION = "0.1.0"
   end
 end

data/rack-spec.gemspec

@@ -1,7 +1,6 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'rack/spec/version'
+require "rack/spec/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "rack-spec"
@@ -18,13 +17,12 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "activesupport"
-  spec.add_dependency "addressable"
-  spec.add_dependency "rack"
+  spec.add_dependency "json_schema"
+  spec.add_dependency "multi_json"
   spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "pry"
   spec.add_development_dependency "rack-test"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", "2.14.1"
-  spec.add_development_dependency "rspec-json_matcher", "0.1.3"
+  spec.add_development_dependency "rspec-console"
 end