sinatra-schema 0.0.1 → 0.0.2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MjFmZjFhMTc3NTMzOTFiNjcwZDc0NGVmMjc0MzYyNmE4MjU4ZDU5MA==
+    MDY3YmZhNWJiOTc1YmI1NWU5OTk1MmVkZDg2ZjkyZTA3ZmZiMzZiOA==
   data.tar.gz: !binary |-
-    NjljZDE3YjZkMGJhYzA2YmE2MjE2NjFjMGQzMDIyYmU3ODRkYzY2Nw==
+    ODVkYjE3NDFiODdhMjdiOGNkYmRhYTU4NjIzMTE3Nzk4OGJjYThhZQ==
 SHA512:
   metadata.gz: !binary |-
-    NmRjN2E4YjRjNzBiZGNhZTBhNTVlM2I1NWUxZGRlYzFjODBkOTQwMzQxMjFi
-    ZDQ0YTViMTQ0MzAzZDc0OTk3M2E2NzgzNzRlOGI0MWY4NTE4YTg1M2E5ZDNi
-    YzQzMWM1OGI3NDE0NWZkODkzMjYxN2EyM2M2NTUwOTM1MDkwNTQ=
+    ZDhmNDgxZDhlY2FkODI3MDczMmJhMTE4OWFjYWZhMzM2MWQ2NTgzMWY2N2Zm
+    MWEyYzU5ZWI2Y2Q5ZmQ5MGFkMzMwZWEyMmNhNDcyM2RiZjU4MTA4M2VjYzgy
+    MDk2N2MwM2ZiNDA5MDRiYjBlMzdjODVjODM5ZWQ2MGNjZmE0ODI=
   data.tar.gz: !binary |-
-    YWM3ZTI2YmE3OTk3NTdlOTRmNTQwNzM4ZGQzOTE3ODNlY2VlNDJmMmQyZDU3
-    MTQ2MGRjNDg1MzA0OWUzODJiMzAwZWNlOGYxMzU3NWU2YmE2NjZlNzgxZmUz
-    YjI0M2ViYTZkY2Q3MmM1NjFkOWZlYTBjYTQxMjI5NTg2ZjY5OTA=
+    MTZjNDNjODZhYmE1OTEyODU4MmY3MjBmZTAyZWRlYTY3OWUzYjVhMDEyM2Iw
+    YWY4OTE5MWU2ZGIxN2RlNzc3NDEwODllZDAwMWY2Y2VlNDdiMDAzNTA5ZmE1
+    NDI4NTFjNjViYWI1ZTc5MDA5NzJhNWQwMGQyZGY2Y2U3YWU0NjQ=

data/README.md

@@ -1,33 +1,124 @@
 # Sinatra Schema
 
+[![Gem version](http://img.shields.io/gem/v/sinatra-schema.svg)](https://rubygems.org/gems/sinatra-schema)
+[![Build Status](https://travis-ci.org/pedro/sinatra-schema.svg?branch=master)](https://travis-ci.org/pedro/sinatra-schema)
+
 Define a schema for your Sinatra application to get requests and responses validated. Dump it schema as a JSON Schema to aid client generation and more!
 
+**Under design**. The reference below might be outdated – please check specs to see the latest.
+
 
 ## Usage
 
-Register `Sinatra::Schema` and define resources like:
+Register `Sinatra::Schema` to define your resource like:
 
 ```ruby
 class MyApi < Sinatra::Base
   register Sinatra::Schema
 
-  resource("/accounts") do
-    title "Account"
-    description "The account of a user signed up to our service"
-    serializer AccountSerializer
+  resource("/account") do |res|
+    res.property.text :email
+
+    res.link(:get) do |link|
+      link.action do
+        # note per definition above we need to serialize "email"
+        MultiJson.encode(email: current_user.email)
+      end
+    end
+  end
+end
+```
+
+### Params
 
-    res.link(:post) do
-      title "Create"
-      description "Create a new account"
-      action do
-        Account.create(email: params[:email])
+Links can have properties too:
+
+```ruby
+resource("/account") do |res|
+  res.property.text :email
+
+  res.link(:post) do |link|
+    link.property.ref  :email # reuse the property defined above
+    link.property.bool :admin
+
+    link.action do |params|
+      user = User.new(email: params[:email])
+      if params[:admin] # params are casted accordingly!
+        # ...
       end
     end
   end
+```
+
+### Cross-resource params
+
+Reuse properties from other resources when appropriate:
+
+```ruby
+resource("/artists") do |res|
+  res.property.text :name, description: "Artist name"
 end
+
+resource("/albums") do |res|
+  res.property.text :name, description: "Album name"
+  res.property.ref :artist_name, "artists/name"
+end
+```
+
+### JSON Schema
+
+The extension will serve a JSON Schema dump at `GET /schema` for you.
+
+You can also include the `schema` Rake task to print it out. To do so, add to your `Rakefile`:
+
+```ruby
+require "./app" # load your app to have the endpoints defined
+load "sinatra/schema/tasks/schema.rake"
+```
+
+Then dump it like:
+
+```
+$ rake schema
+{
+  "$schema":"http://json-schema.org/draft-04/hyper-schema",
+  "definitions":{
+    "account":{
+      "title":"Account",
+      "type":"object",
+      "definitions":{
+        "email":{
+          "type":"string"
+        }
+      },
+      "links":[
+        {
+          "href":"/account",
+          "method":"GET"
+        }
+      ]
+    }
+  }
+}
 ```
 
 
-## See also
+## Context
+
+There are [lots of reasons why you should consider describe your API with a machine-readable format](http://pedro.by4am.com/past/2014/5/23/get_more_out_of_your_service_with_machinereadable_api_specs/):
+
+- Describe what endpoints are available
+- Validate requests and responses
+- Embrace constraints for consistent API design
+- Generate documentation
+- Generate clients
+- Generate service stubs
+
+Sinatra Schema is a thin layer on top of JSON Schema, trying to bring all of the benefits without any of the JSON.
+
+If you need more flexibility, or if you think the schema should live by itself, then you should consider writing the schema yourself. Tools like [prmd](https://github.com/interagent/prmd) can really help you get started, and [committee](https://github.com/interagent/committee) can help you get benefits out of that schema.
+
+
+## Meta
 
-- [sinatra-param](https://github.com/mattt/sinatra-param): nice take on validating request parameters.
+Created by Pedro Belo. MIT license.

data/lib/sinatra/schema/definition.rb

@@ -1,7 +1,38 @@
 module Sinatra
   module Schema
     class Definition
-      attr_accessor :description, :example, :format, :type
+      attr_accessor :description, :example, :format, :id, :type
+
+      def initialize(options={})
+        @description = options[:description]
+        @example     = options[:example]
+        @id          = options[:id]
+        @type        = options[:type]
+      end
+
+      def cast(value)
+        # do not touch nulls:
+        return unless value
+
+        case type
+        when "string"
+          value.to_s
+        when "boolean"
+          %w( t true 1 ).include?(value.to_s)
+        end
+      end
+
+      def valid?(value)
+        # always accept nils for now
+        return if value.nil?
+
+        case type
+        when "string"
+          value.is_a?(String)
+        when "boolean"
+          [true, false].include?(value)
+        end
+      end
     end
   end
 end

data/lib/sinatra/schema/dsl/definitions.rb

@@ -0,0 +1,49 @@
+module Sinatra
+  module Schema
+    module DSL
+      class Definitions
+        attr_accessor :definition, :resource, :options
+
+        def initialize(resource, options={})
+          @options  = options
+          @resource = resource
+        end
+
+        def text(id, local_options={})
+          def_options = options.merge(local_options)
+          def_options.merge!(id: id, type: "string")
+          add Definition.new(def_options)
+        end
+
+        def bool(id, local_options={})
+          def_options = options.merge(local_options)
+          def_options.merge!(id: id, type: "boolean")
+          add Definition.new(def_options)
+        end
+
+        def ref(id)
+          unless definition = resource.defs[id] || Sinatra::Schema::Root.instance.find_definition(id)
+            raise "Unknown reference: #{id}"
+          end
+          add definition, true
+        end
+
+        # TODO support other types
+
+        protected
+
+        def add(definition, reference=false)
+          unless reference
+            @resource.defs[definition.id] = definition
+          end
+          if options[:serialize]
+            @resource.properties[definition.id] = definition
+          end
+          if link = options[:link]
+            link.properties[definition.id] = definition
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sinatra/schema/dsl/links.rb

@@ -0,0 +1,43 @@
+module Sinatra
+  module Schema
+    module DSL
+      class Links
+        attr_accessor :href, :link, :method, :resource
+
+        def initialize(options)
+          @href     = options.fetch(:href)
+          @method   = options.fetch(:method)
+          @resource = options.fetch(:resource)
+          @link     = build_link
+        end
+
+        def title(title)
+          link.title = title
+        end
+
+        def rel(rel)
+          link.rel = rel
+        end
+
+        def description(description)
+          link.description = description
+        end
+
+        def action(&blk)
+          link.action_block = blk
+        end
+
+        def property
+          DSL::Definitions.new(resource, link: link, serialize: false)
+        end
+
+        protected
+
+        def build_link
+          full_href = "#{resource.path}/#{href.chomp("/")}".chomp("/")
+          Link.new(resource: resource, method: method, href: full_href)
+        end
+      end
+    end
+  end
+end

data/lib/sinatra/schema/dsl/resources.rb

@@ -0,0 +1,30 @@
+module Sinatra
+  module Schema
+    module DSL
+      class Resources
+        attr_accessor :app, :resource
+
+        def initialize(app, path)
+          @app      = app
+          @resource = Resource.new(path: path)
+        end
+
+        def description(description)
+          @resource.description = description
+        end
+
+        def property
+          DSL::Definitions.new(resource, serialize: true)
+        end
+
+        def link(method, href="/", &blk)
+          dsl = DSL::Links.new(resource: resource, method: method, href: href)
+          blk.call(dsl)
+          link = dsl.link
+          link.register(app)
+          resource.links << link
+        end
+      end
+    end
+  end
+end

data/lib/sinatra/schema/link.rb

@@ -1,47 +1,29 @@
 module Sinatra
   module Schema
     class Link
-      attr_accessor :resource, :title, :description, :href, :method, :properties, :rel, :action
+      attr_accessor :action_block, :resource, :title, :description, :href, :method, :properties, :rel
 
       def initialize(options)
-        @resource = options[:resource]
-        @method   = options[:method]
-        @href     = options[:href]
-      end
-
-      def action(&blk)
-        @action = blk
-      end
-
-      def action_block
-        @action
+        @resource   = options[:resource]
+        @method     = options[:method]
+        @href       = options[:href]
+        @properties = {}
       end
 
       def register(app)
         link = self
         app.send(method.downcase, href) do
           begin
-            link.validate_params!(params)
-            res = link.action_block.call(params)
+            schema_params = parse_params(link.properties)
+            validate_params!(schema_params, link.properties)
+            res = link.action_block.call(schema_params)
             link.resource.validate_response!(res)
-            MultiJson.encode(res)
+            res
           rescue RuntimeError => e
             halt(400)
           end
         end
       end
-
-      def validate_params!(params)
-        unless properties
-          if params.empty?
-            return
-          else
-            raise "Did not expect params"
-          end
-        end
-
-        Utils.validate_keys!(properties, params)
-      end
     end
   end
 end

data/lib/sinatra/schema/param_handling.rb

@@ -0,0 +1,44 @@
+module Sinatra
+  module Schema
+    module ParamHandling
+      def parse_params(properties)
+        case request.media_type
+        when nil, "application/json"
+          parse_json_params
+        when "application/x-www-form-urlencoded"
+          cast_regular_params(properties)
+        else
+          raise "Cannot handle media type #{request.media_type}"
+        end
+      end
+
+      protected
+
+      def parse_json_params
+        body = request.body.read
+        return {} if body.length == 0 # nothing supplied
+
+        request.body.rewind # leave it ready for other calls
+        supplied_params = MultiJson.decode(body)
+        unless supplied_params.is_a?(Hash)
+          raise "Invalid request, expecting a hash"
+        end
+
+        indifferent_params(supplied_params)
+      rescue MultiJson::ParseError
+        raise "Invalid JSON"
+      end
+
+      def cast_regular_params(properties)
+        casted_params = params.inject({}) do |casted, (k, v)|
+          definition = properties[k.to_sym]
+          # if there's no definition just leave the original param,
+          # let the validation raise on this later:
+          casted[k]  = definition ? definition.cast(v) : v
+          casted
+        end
+        indifferent_params(casted_params)
+      end
+    end
+  end
+end

data/lib/sinatra/schema/param_validation.rb

@@ -0,0 +1,23 @@
+module Sinatra
+  module Schema
+    module ParamValidation
+      def validate_params!(params, properties)
+        missing = properties.keys.map(&:to_s).sort - params.keys.map(&:to_s).sort
+        unless missing.empty?
+          raise "Missing properties: #{missing}"
+        end
+
+        extra = params.keys.map(&:to_s).sort - properties.keys.map(&:to_s).sort
+        unless extra.empty?
+          raise "Unexpected properties: #{extra}"
+        end
+
+        properties.each do |id, definition|
+          unless definition.valid?(params[id])
+            raise "Bad param: #{id}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sinatra/schema/resource.rb

@@ -1,34 +1,33 @@
 module Sinatra
   module Schema
     class Resource
-      attr_accessor :id, :path, :title, :description, :properties
+      attr_accessor :id, :path, :title, :defs, :links, :description, :properties
 
-      def initialize(app, path)
-        @app   = app
-        @path  = path.chomp("/")
-        @links = []
-        @defs  = {}
+      def initialize(options)
+        @path       = options.fetch(:path).chomp("/")
+        @links      = []
+        @defs       = {}
+        @properties = {}
       end
 
-      def define(id)
-        @defs[id] = Definition.new
-        yield @defs[id]
+      def id
+        @id ||= ActiveSupport::Inflector.singularize(path.split("/").last).to_sym
       end
 
-      def link(method, href="/", &blk)
-        href = "#{path}/#{href.chomp("/")}".chomp("/")
-        link = Link.new(resource: self, method: method, href: href)
-        yield(link)
-        link.register(@app)
-        @links << link
+      def title
+        @title ||= ActiveSupport::Inflector.singularize(path.split("/").last).capitalize
       end
 
-      def validate_response!(res)
+      def validate_response!(raw)
+        # only validate responses in tests
+        return unless ENV["RACK_ENV"] == "test"
+
+        res = MultiJson.decode(raw)
         unless res.is_a?(Hash)
           raise "Response should return a hash"
         end
 
-        if properties
+        unless properties.empty?
           Utils.validate_keys!(properties, res)
         end
       end
@@ -36,7 +35,22 @@ module Sinatra
       def to_schema
         {
           title: title,
-          description: description
+          description: description,
+          type: "object",
+          definitions: defs.inject({}) { |h, (id, definition)|
+            h[id] = {
+              description: definition.description,
+              type:        definition.type,
+            }
+            h
+          },
+          links: links.map { |link|
+            {
+              description: link.description,
+              href:        link.href,
+              method:      link.method.to_s.upcase,
+            }
+          }
         }
       end
     end

data/lib/sinatra/schema/root.rb

@@ -0,0 +1,33 @@
+module Sinatra
+  module Schema
+    class Root
+      include Singleton
+
+      attr_accessor :resources
+
+      def initialize
+        @resources = {}
+      end
+
+      def add_resource(res)
+        @resources[res.id] = res
+      end
+
+      def find_definition(id)
+        resource_id, def_id = id.to_s.split("/", 2)
+        return unless resource = resources[resource_id.to_sym]
+        resource.defs[def_id.to_sym]
+      end
+
+      def to_schema
+        {
+          "$schema" => "http://json-schema.org/draft-04/hyper-schema",
+          "definitions" => resources.inject({}) { |result, (id, resource)|
+            result[id] = resource.to_schema
+            result
+          }
+        }
+      end
+    end
+  end
+end

data/lib/sinatra/schema/tasks/schema.rake

@@ -0,0 +1,5 @@
+desc "Print out the JSON schema for this app"
+task :schema do
+  schema = Sinatra::Schema::Root.instance.to_schema
+  puts MultiJson.encode(schema, pretty: true)
+end

data/lib/sinatra/schema/utils.rb

@@ -1,16 +1,22 @@
 module Sinatra
   module Schema
     class Utils
-      def self.validate_keys!(expected, received)
-        missing = expected.map(&:to_s).sort - received.keys.map(&:to_s).sort
+      def self.validate_keys!(properties, received)
+        missing = properties.keys.map(&:to_s).sort - received.keys.map(&:to_s).sort
         unless missing.empty?
           raise "Missing properties: #{missing}"
         end
 
-        extra = received.keys.map(&:to_s).sort - expected.map(&:to_s).sort
+        extra = received.keys.map(&:to_s).sort - properties.keys.map(&:to_s).sort
         unless extra.empty?
           raise "Unexpected properties: #{extra}"
         end
+
+        properties.each do |id, definition|
+          unless definition.valid?(received[id.to_s])
+            raise "Bad response property: #{id}"
+          end
+        end
       end
     end
   end

data/lib/sinatra/schema/version.rb

@@ -0,0 +1,5 @@
+module Sinatra
+  module Schema
+    VERSION = "0.0.2"
+  end
+end

data/lib/sinatra/schema.rb

@@ -1,32 +1,40 @@
+require "active_support/inflector"
+require "sinatra/base"
+require "singleton"
+require "multi_json"
+
 require "sinatra/schema/definition"
 require "sinatra/schema/link"
+require "sinatra/schema/param_handling"
+require "sinatra/schema/param_validation"
 require "sinatra/schema/resource"
+require "sinatra/schema/root"
 require "sinatra/schema/utils"
+require "sinatra/schema/dsl/definitions"
+require "sinatra/schema/dsl/links"
+require "sinatra/schema/dsl/resources"
 
 module Sinatra
   module Schema
     def self.registered(app)
+      app.helpers ParamHandling
+      app.helpers ParamValidation
       app.get "/schema" do
-        MultiJson.encode(
-          "$schema" => "http://json-schema.org/draft-04/hyper-schema",
-          "definitions" => app.resources.inject({}) { |result, (id, resource)|
-            result[id] = resource.to_schema
-            result
-          }
-        )
+        content_type("application/schema+json")
+        response.headers["Cache-Control"] = "public, max-age=3600"
+        MultiJson.encode(app.schema_root.to_schema, pretty: true)
       end
     end
 
-    def resources
-      @resources ||= {}
+    def schema_root
+      Root.instance
     end
 
     def resource(path)
-      res = Resource.new(self, path)
-      yield(res)
-      resources[res.id] = res
+      spec = DSL::Resources.new(self, path)
+      yield(spec)
+      schema_root.add_resource(spec.resource)
     end
-
   end
 
   register Schema

data/spec/dsl/definitions_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+
+describe Sinatra::Schema::DSL::Definitions do
+  let(:resource) { Sinatra::Schema::Resource.new(path: "/foobar") }
+  let(:dsl)      { described_class.new(resource, options) }
+  let(:options)  { Hash.new }
+  let(:root)     { Sinatra::Schema::Root.instance }
+
+  it "adds a string definition to the resource" do
+    dsl.text(:foobar)
+    assert_equal 1, resource.defs.size
+    assert_equal "string", resource.defs[:foobar].type
+  end
+
+  it "adds a boolean definition to the resource" do
+    dsl.bool(:foobar)
+    assert_equal 1, resource.defs.size
+    assert_equal "boolean", resource.defs[:foobar].type
+  end
+
+  describe "#ref" do
+    let(:definition) { Sinatra::Schema::Definition.new }
+    before { options[:serialize] = true }
+
+    it "adds a reference to another definition in the resource" do
+      resource.defs[:foobar] = definition
+      dsl.ref :foobar
+      assert_equal 1, resource.defs.size
+      assert_equal 1, resource.properties.size
+    end
+
+    it "adds a reference to a definition in a different resource" do
+      other = Sinatra::Schema::Resource.new(path: "/others")
+      root.add_resource(other)
+      other.defs[:foobar] = definition
+      dsl.ref "other/foobar"
+      assert_equal 1, other.defs.size
+      assert_equal 1, resource.properties.size
+    end
+  end
+end

data/spec/dsl/links_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+describe Sinatra::Schema::DSL::Links do
+  let(:resource) { Sinatra::Schema::Resource.new(path: "/foobar") }
+  let(:dsl)      { described_class.new(options) }
+  let(:options)  {{ resource: resource, method: :get, href: "/" }}
+
+  it "sets the link title" do
+    dsl.title("foo")
+    assert_equal "foo", dsl.link.title
+  end
+
+  it "sets the link rel" do
+    dsl.rel("foo")
+    assert_equal "foo", dsl.link.rel
+  end
+
+  it "sets the link description" do
+    dsl.description("Create foo")
+    assert_equal "Create foo", dsl.link.description
+  end
+
+  it "sets the link action_block" do
+    action = lambda { :foo }
+    dsl.action(&action)
+    assert_equal action, dsl.link.action_block
+  end
+
+  describe "#property" do
+    it "adds new definiitons to the resource" do
+      dsl.property.text :foo
+      assert_equal 1, resource.defs.size
+      assert resource.defs.has_key?(:foo)
+    end
+
+    it "makes them a property of the link" do
+      dsl.property.text :foo
+      assert_equal 1, dsl.link.properties.size
+      assert dsl.link.properties.has_key?(:foo)
+    end
+  end
+end

data/spec/dsl/resources_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+describe Sinatra::Schema::DSL::Resources do
+  let(:app) { Sinatra::Application.new }
+  let(:dsl) { described_class.new(app, "/foobar") }
+
+  it "sets the resource description" do
+    dsl.description("This is a foobar")
+    assert_equal "This is a foobar", dsl.resource.description
+  end
+
+  describe "#property" do
+    it "adds new definitions to the resource" do
+      dsl.property.text :foo
+      assert_equal 1, dsl.resource.defs.size
+      assert dsl.resource.defs.has_key?(:foo)
+    end
+
+    it "makes them a property of the resource" do
+      dsl.property.text :foo
+      assert_equal 1, dsl.resource.properties.size
+      assert dsl.resource.properties.has_key?(:foo)
+    end
+  end
+end

data/spec/integration_spec.rb

@@ -7,14 +7,14 @@ describe Sinatra::Schema do
     assert_equal "hi", last_response.body
   end
 
-  it "support resource links" do
+  it "support resource gets" do
     get "/accounts"
     assert_equal 200, last_response.status
     assert_equal({ "email" => "foo@bar.com" },
       MultiJson.decode(last_response.body))
   end
 
-  it "support resource links" do
+  it "support resource posts" do
     post "/accounts", email: "omg"
     assert_equal 200, last_response.status
     assert_equal({ "email" => "omg" },
@@ -25,17 +25,4 @@ describe Sinatra::Schema do
     post "/accounts", foo: "bar"
     assert_equal 400, last_response.status
   end
-
-  it "exposes the json schema" do
-    get "/schema"
-    assert_equal 200, last_response.status
-    schema = MultiJson.decode(last_response.body)
-    assert_equal "http://json-schema.org/draft-04/hyper-schema",
-      schema["$schema"]
-    assert_equal Hash, schema["definitions"].class
-    assert_equal Hash, schema["definitions"]["account"].class
-    assert_equal "Account", schema["definitions"]["account"]["title"]
-    assert_equal "An account represents an individual signed up to use the service",
-      schema["definitions"]["account"]["description"]
-  end
 end

data/spec/json_schema_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+describe "JSON Schema" do
+  before do
+    get "/schema"
+    @schema = MultiJson.decode(last_response.body)
+  end
+
+  it "renders a 200" do
+    assert_equal 200, last_response.status
+  end
+
+  it "sets the appropriate content-type" do
+    assert_equal "application/schema+json",
+      last_response.headers["Content-Type"]
+  end
+
+  it "sets $schema to hyper-schema" do
+    assert_equal "http://json-schema.org/draft-04/hyper-schema",
+      @schema["$schema"]
+  end
+
+  it "generates definitions" do
+    assert_equal Hash, @schema["definitions"].class
+    assert_equal Hash, @schema["definitions"]["account"].class
+    assert_equal "Account", @schema["definitions"]["account"]["title"]
+    assert_equal "An account represents an individual signed up to use the service",
+      @schema["definitions"]["account"]["description"]
+  end
+end

data/spec/param_handling_spec.rb

@@ -0,0 +1,67 @@
+require "spec_helper"
+
+describe Sinatra::Schema::ParamHandling do
+  before do
+    @rack_app = Sinatra.new do
+      helpers Sinatra::Schema::ParamHandling
+      post("/") do
+        MultiJson.encode(parse_params($properties))
+      end
+    end
+  end
+
+  describe "JSON encoded request params" do
+    before do
+      header "Content-Type", "application/json"
+    end
+
+    it "handles invalid json" do
+      assert_raises(RuntimeError, "Invalid JSON") do
+        post "/", "{"
+      end
+    end
+
+    it "considers an empty body an empty hash" do
+      post "/", ""
+      assert_equal Hash.new, last_json
+    end
+
+    it "just parses the json" do
+      params = { "foo" => "bar", "baz" => 42 }
+      post "/", MultiJson.encode(params)
+      assert_equal params, last_json
+    end
+  end
+
+  describe "form-encoded params" do
+    it "casts values according to the schema" do
+      $properties = {
+        some_text: Sinatra::Schema::Definition.new(type: "string"),
+        some_bool: Sinatra::Schema::Definition.new(type: "boolean"),
+      }
+      post "/", some_text: "true", some_bool: "true"
+      assert_equal({ "some_text" => "true", "some_bool" => true }, last_json)
+    end
+
+    it "leaves params without the corresponding property untouched" do
+      $properies = {}
+      params = { "foo" => "bar" }
+      post "/", params
+      assert_equal params, last_json
+    end
+
+    it "leaves null params" do
+      $properties = { bool: Sinatra::Schema::Definition.new(type: "boolean") }
+      params = { "bool" => nil }
+      post "/", params
+      assert_equal params, last_json
+    end
+  end
+
+  it "errors out on other formats" do
+    assert_raises(RuntimeError, "Cannot handle media type application/xml") do
+      header "Content-Type", "application/xml"
+      post "/", "<omg />"
+    end
+  end
+end

data/spec/param_validation_spec.rb

@@ -0,0 +1,35 @@
+require "spec_helper"
+
+describe Sinatra::Schema::ParamValidation do
+  before do
+    @rack_app = Sinatra.new do
+      helpers Sinatra::Schema::ParamValidation
+      post("/") do
+        params = MultiJson.decode(request.body.read)
+        validate_params!(indifferent_params(params), $properties)
+        "ok"
+      end
+    end
+  end
+
+  it "errors out on unexpected params" do
+    $properties = {}
+    assert_raises(RuntimeError, "omg just realized this doesn't do shit") do
+      post "/", MultiJson.encode(foo: "bar")
+    end
+  end
+
+  it "errors out on missing params" do
+    $properties = { foo: Sinatra::Schema::Definition.new(type: "string") }
+    assert_raises(RuntimeError) do
+      post "/", "{}"
+    end
+  end
+
+  it "errors out on wrong format" do
+    $properties = { bool: Sinatra::Schema::Definition.new(type: "boolean") }
+    assert_raises(RuntimeError) do
+      post "/", MultiJson.encode(bool: "omg")
+    end
+  end
+end

data/spec/resource_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+describe Sinatra::Schema::Resource do
+  let(:resource) { Sinatra::Schema::Resource.new(path: "/artists") }
+
+  describe "#id" do
+    it "is inferred from the path" do
+      assert_equal :artist, resource.id
+    end
+  end
+
+  describe "#title" do
+    it "is inferred from the path" do
+      assert_equal "Artist", resource.title
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -3,8 +3,9 @@ ENV["RACK_ENV"] = "test"
 require "rubygems"
 require "bundler"
 
-Bundler.require(:default, :test)
+Bundler.require
 
+require "rack/test"
 require "sinatra"
 require "sinatra/schema"
 
@@ -15,6 +16,6 @@ RSpec.configure do |config|
   config.expect_with :minitest
 
   def app
-    TestApp
+    @rack_app || TestApp
   end
 end

data/spec/support/last_json.rb

@@ -0,0 +1,3 @@
+def last_json
+  @last_json ||= MultiJson.decode(last_response.body)
+end

data/spec/support/test_app.rb

@@ -6,35 +6,29 @@ class TestApp < Sinatra::Base
   end
 
   resource("/accounts") do |res|
-    res.id = :account
-    res.title = "Account"
-    res.description = "An account represents an individual signed up to use the service"
+    res.description "An account represents an individual signed up to use the service"
 
-    res.define(:email) do |d|
-      d.description = "unique email address of account"
-      d.example = "username@example.com"
-      d.format = "email"
-      d.type = :string
-    end
-
-    res.properties = [:email]
+    res.property.text :email,
+      description: "unique email address of account",
+      example:     "username@example.com",
+      format:      "email"
 
     res.link(:get) do |link|
-      link.title = "Info"
-      link.rel = "self"
-      link.description = "Info for account"
+      link.title       "Info"
+      link.rel         "self"
+      link.description "Info for account"
       link.action do
-        { email: "foo@bar.com" }
+        MultiJson.encode(email: "foo@bar.com")
       end
     end
 
     res.link(:post) do |link|
-      link.title = "Create"
-      link.rel = "create"
-      link.description = "Create a new account"
-      link.properties = [:email]
+      link.title         "Create"
+      link.rel           "create"
+      link.description   "Create a new account"
+      link.property.ref :email
       link.action do |params|
-        { email: params[:email] }
+        MultiJson.encode(email: params[:email])
       end
     end
   end

metadata

@@ -1,15 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: sinatra-schema
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Pedro Belo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-05 00:00:00.000000000 Z
+date: 2014-12-06 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: multi_json
   requirement: !ruby/object:Gem::Requirement
@@ -70,6 +90,20 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 0.6.2
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>'
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>'
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -101,11 +135,27 @@ files:
 - README.md
 - lib/sinatra/schema.rb
 - lib/sinatra/schema/definition.rb
+- lib/sinatra/schema/dsl/definitions.rb
+- lib/sinatra/schema/dsl/links.rb
+- lib/sinatra/schema/dsl/resources.rb
 - lib/sinatra/schema/link.rb
+- lib/sinatra/schema/param_handling.rb
+- lib/sinatra/schema/param_validation.rb
 - lib/sinatra/schema/resource.rb
+- lib/sinatra/schema/root.rb
+- lib/sinatra/schema/tasks/schema.rake
 - lib/sinatra/schema/utils.rb
+- lib/sinatra/schema/version.rb
+- spec/dsl/definitions_spec.rb
+- spec/dsl/links_spec.rb
+- spec/dsl/resources_spec.rb
 - spec/integration_spec.rb
+- spec/json_schema_spec.rb
+- spec/param_handling_spec.rb
+- spec/param_validation_spec.rb
+- spec/resource_spec.rb
 - spec/spec_helper.rb
+- spec/support/last_json.rb
 - spec/support/test_app.rb
 homepage: https://github.com/pedro/sinatra-schema
 licenses:
@@ -132,4 +182,3 @@ signing_key:
 specification_version: 4
 summary: Sinatra extension to support schemas
 test_files: []
-has_rdoc: