sinatra-schema 0.0.2 → 0.0.3

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MDY3YmZhNWJiOTc1YmI1NWU5OTk1MmVkZDg2ZjkyZTA3ZmZiMzZiOA==
+    MGZiZDNiMDcyM2EzNzM1MjdmZWUxOTkzZGNjY2QxNmVmN2RmODRiMg==
   data.tar.gz: !binary |-
-    ODVkYjE3NDFiODdhMjdiOGNkYmRhYTU4NjIzMTE3Nzk4OGJjYThhZQ==
+    ODY0YjViYzM3YmJhYjIzODc3Y2U3ZmMwMzJmM2Q5YzRiN2M4ZjNmYw==
 SHA512:
   metadata.gz: !binary |-
-    ZDhmNDgxZDhlY2FkODI3MDczMmJhMTE4OWFjYWZhMzM2MWQ2NTgzMWY2N2Zm
-    MWEyYzU5ZWI2Y2Q5ZmQ5MGFkMzMwZWEyMmNhNDcyM2RiZjU4MTA4M2VjYzgy
-    MDk2N2MwM2ZiNDA5MDRiYjBlMzdjODVjODM5ZWQ2MGNjZmE0ODI=
+    MDQwY2YwMzU3MTg3ZDkzMGNiMDY2MTFlNjM0MWFkNjYzNzdhZTQzMWVlYjg1
+    NzdhNzk2NjZlM2YyNjQ1MzQxZjA5ZTNiNWQ0NGI5MjYxYjI3MTUzYjYxODMx
+    NDJhYzMyNDI2NDZjZGJlNjVhYzQxMTQ0OTdjOTRkN2Q1ZmQ3NmY=
   data.tar.gz: !binary |-
-    MTZjNDNjODZhYmE1OTEyODU4MmY3MjBmZTAyZWRlYTY3OWUzYjVhMDEyM2Iw
-    YWY4OTE5MWU2ZGIxN2RlNzc3NDEwODllZDAwMWY2Y2VlNDdiMDAzNTA5ZmE1
-    NDI4NTFjNjViYWI1ZTc5MDA5NzJhNWQwMGQyZGY2Y2U3YWU0NjQ=
+    YjE1MWY4MTVhYTMxYzEyODU0Mjk3Y2NiY2I5YTA5YjBkMTlmOGE4MmZlOTMw
+    NDlkNzU2MmU2OTg0ZGNiYzdkNWRkZjAwYmQ5OWE0MzNhNGE0MDVjZmVkZWFk
+    NzM3MDNkZmEwOGI1OTY4ZWQ3NTg2ODY0MjBiODRlNDU5YTZlOGE=

data/README.md

@@ -65,6 +65,20 @@ resource("/albums") do |res|
 end
 ```
 
+### Nested params
+
+These are also casted and validated as you'd expect:
+
+```ruby
+resource("/albums") do |res|
+  resource.link(:post) do |link|
+    link.nested :artist do |a|
+      a.property.text :name
+    end
+  end
+end
+```
+
 ### JSON Schema
 
 The extension will serve a JSON Schema dump at `GET /schema` for you.

data/lib/sinatra/schema/definition.rb

@@ -1,7 +1,7 @@
 module Sinatra
   module Schema
     class Definition
-      attr_accessor :description, :example, :format, :id, :type
+      attr_accessor :description, :example, :id, :type
 
       def initialize(options={})
         @description = options[:description]
@@ -15,10 +15,10 @@ module Sinatra
         return unless value
 
         case type
-        when "string"
-          value.to_s
         when "boolean"
           %w( t true 1 ).include?(value.to_s)
+        when "email", "string", "uuid"
+          value.to_s
         end
       end
 
@@ -27,10 +27,41 @@ module Sinatra
         return if value.nil?
 
         case type
+        when "boolean"
+          [true, false].include?(value)
+        when "email"
+          value.to_s =~ /\A[^@\s]+@([^@\s]+\.)+[^@\s]+\z/
         when "string"
           value.is_a?(String)
+        when "uuid"
+          value.to_s =~ /\A[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}\Z/
+        end
+      end
+
+      def to_schema
+        schema_type, schema_format = json_schema_type_and_format
+        attrs = { type: schema_type }
+        if schema_format
+          attrs[:format] = schema_format
+        end
+        if description
+          attrs[:description] = description
+        end
+        attrs
+      end
+
+      protected
+
+      def json_schema_type_and_format
+        case type
         when "boolean"
-          [true, false].include?(value)
+          "boolean"
+        when "email"
+          ["string", "email"]
+        when "string"
+          "string"
+        when "uuid"
+          ["string", "uuid"]
         end
       end
     end

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

@@ -2,23 +2,40 @@ module Sinatra
   module Schema
     module DSL
       class Definitions
-        attr_accessor :definition, :resource, :options
+        attr_accessor :definition, :resource, :options, :targets
 
-        def initialize(resource, options={})
-          @options  = options
+        def initialize(resource, targets)
           @resource = resource
+          # array of hashes to receive the definition, first is the resource defs
+          @targets  = targets
         end
 
-        def text(id, local_options={})
-          def_options = options.merge(local_options)
-          def_options.merge!(id: id, type: "string")
-          add Definition.new(def_options)
+        def text(id, options={})
+          options.merge!(id: id, type: "string")
+          add Definition.new(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)
+        def bool(id, options={})
+          options.merge!(id: id, type: "boolean")
+          add Definition.new(options)
+        end
+
+        def uuid(id, options={})
+          options.merge!(id: id, type: "uuid")
+          add Definition.new(options)
+        end
+
+        def email(id, options={})
+          options.merge!(id: id, type: "email")
+          add Definition.new(options)
+        end
+
+        def nested(id)
+          # add a space in the definitions/properties for the nested def:
+          targets.each { |h| h[id] = {} }
+
+          # yield a new DSL with updated targets
+          yield Definitions.new(resource, targets.map { |h| h[id] })
         end
 
         def ref(id)
@@ -33,14 +50,12 @@ module Sinatra
         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
+          targets.each_with_index do |hash, i|
+            # here's the trick, and here's why the first target is always the
+            # resource def: skip it when adding a reference (eg: it's already)
+            # in the resource def, just add the property!
+            next if reference && i == 0
+            hash[definition.id] = definition
           end
         end
       end

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

@@ -28,13 +28,13 @@ module Sinatra
         end
 
         def property
-          DSL::Definitions.new(resource, link: link, serialize: false)
+          DSL::Definitions.new(resource, [resource.defs, link.properties])
         end
 
         protected
 
         def build_link
-          full_href = "#{resource.path}/#{href.chomp("/")}".chomp("/")
+          full_href = "#{resource.path}/#{href}".gsub("//", "/").chomp("/")
           Link.new(resource: resource, method: method, href: full_href)
         end
       end

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

@@ -14,7 +14,7 @@ module Sinatra
         end
 
         def property
-          DSL::Definitions.new(resource, serialize: true)
+          DSL::Definitions.new(resource, [resource.defs, resource.properties])
         end
 
         def link(method, href="/", &blk)

data/lib/sinatra/schema/link.rb

@@ -11,12 +11,16 @@ module Sinatra
       end
 
       def register(app)
+        app.send(method.downcase, href, &handler)
+      end
+
+      def handler
         link = self
-        app.send(method.downcase, href) do
+        lambda do
           begin
             schema_params = parse_params(link.properties)
             validate_params!(schema_params, link.properties)
-            res = link.action_block.call(schema_params)
+            res = instance_exec(schema_params, &link.action_block)
             link.resource.validate_response!(res)
             res
           rescue RuntimeError => e

data/lib/sinatra/schema/{param_handling.rb → param_parsing.rb}

@@ -1,6 +1,6 @@
 module Sinatra
   module Schema
-    module ParamHandling
+    module ParamParsing
       def parse_params(properties)
         case request.media_type
         when nil, "application/json"
@@ -29,12 +29,18 @@ module Sinatra
         raise "Invalid JSON"
       end
 
-      def cast_regular_params(properties)
-        casted_params = params.inject({}) do |casted, (k, v)|
+      def cast_regular_params(properties, root=params)
+        casted_params = root.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
+
+          # handle nested params
+          if definition.is_a?(Hash) || v.is_a?(Hash)
+            casted[k] = cast_regular_params(definition, v)
+          else
+            # if there's no definition just leave the original param,
+            # let the validation raise on this later:
+            casted[k]  = definition ? definition.cast(v) : v
+          end
           casted
         end
         indifferent_params(casted_params)

data/lib/sinatra/schema/param_validation.rb

@@ -13,8 +13,13 @@ module Sinatra
         end
 
         properties.each do |id, definition|
-          unless definition.valid?(params[id])
-            raise "Bad param: #{id}"
+          # handle nested params
+          if definition.is_a?(Hash)
+            validate_params!(params[id], definition)
+          else
+            unless definition.valid?(params[id])
+              raise "Bad param: #{id}"
+            end
           end
         end
       end

data/lib/sinatra/schema/resource.rb

@@ -38,10 +38,7 @@ module Sinatra
           description: description,
           type: "object",
           definitions: defs.inject({}) { |h, (id, definition)|
-            h[id] = {
-              description: definition.description,
-              type:        definition.type,
-            }
+            h[id] = definition.to_schema
             h
           },
           links: links.map { |link|

data/lib/sinatra/schema/version.rb

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

data/lib/sinatra/schema.rb

@@ -5,7 +5,7 @@ require "multi_json"
 
 require "sinatra/schema/definition"
 require "sinatra/schema/link"
-require "sinatra/schema/param_handling"
+require "sinatra/schema/param_parsing"
 require "sinatra/schema/param_validation"
 require "sinatra/schema/resource"
 require "sinatra/schema/root"
@@ -17,7 +17,7 @@ require "sinatra/schema/dsl/resources"
 module Sinatra
   module Schema
     def self.registered(app)
-      app.helpers ParamHandling
+      app.helpers ParamParsing
       app.helpers ParamValidation
       app.get "/schema" do
         content_type("application/schema+json")

data/spec/definition_spec.rb

@@ -0,0 +1,64 @@
+require "spec_helper"
+
+describe Sinatra::Schema::Definition do
+  let(:definition) { Sinatra::Schema::Definition.new }
+
+  describe "#cast" do
+    it "casts booleans" do
+      definition.type = "boolean"
+      assert_equal true, definition.cast("t")
+      assert_equal true, definition.cast("true")
+      assert_equal true, definition.cast("1")
+      assert_equal false, definition.cast("0")
+      assert_equal false, definition.cast("false")
+    end
+
+    it "casts text" do
+      definition.type = "string"
+      assert_equal "123", definition.cast(123)
+    end
+  end
+
+  describe "#valid?" do
+    it "detects booleans" do
+      definition.type = "boolean"
+      assert definition.valid?(true)
+      assert definition.valid?(false)
+      refute definition.valid?("true")
+    end
+
+    it "detects emails" do
+      definition.type = "email"
+      assert definition.valid?("foo@bar.com")
+      refute definition.valid?("foobar.com")
+    end
+
+    it "detects text" do
+      definition.type = "string"
+      assert definition.valid?("foo")
+      refute definition.valid?(123)
+    end
+
+    it "detects uuids" do
+      definition.type = "uuid"
+      assert definition.valid?(SecureRandom.uuid)
+      refute definition.valid?("wrong")
+    end
+  end
+
+  describe "#to_schema" do
+    it "dumps emails" do
+      definition.type = "email"
+      schema = definition.to_schema
+      assert_equal "string", schema[:type]
+      assert_equal "email", schema[:format]
+    end
+
+    it "dumps uuids" do
+      definition.type = "uuid"
+      schema = definition.to_schema
+      assert_equal "string", schema[:type]
+      assert_equal "uuid", schema[:format]
+    end
+  end
+end

data/spec/dsl/definitions_spec.rb

@@ -2,8 +2,7 @@ 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(:dsl)      { described_class.new(resource, [resource.defs, resource.properties]) }
   let(:root)     { Sinatra::Schema::Root.instance }
 
   it "adds a string definition to the resource" do
@@ -18,9 +17,18 @@ describe Sinatra::Schema::DSL::Definitions do
     assert_equal "boolean", resource.defs[:foobar].type
   end
 
+  it "adds nested definitions" do
+    dsl.nested(:user) do |prop|
+      prop.text :email
+      prop.bool :admin
+    end
+    assert_equal 2, resource.defs[:user].size
+    assert_equal "string", resource.defs[:user][:email].type
+    assert_equal "boolean", resource.defs[:user][:admin].type
+  end
+
   describe "#ref" do
-    let(:definition) { Sinatra::Schema::Definition.new }
-    before { options[:serialize] = true }
+    let(:definition) { Sinatra::Schema::Definition.new(id: :foobar) }
 
     it "adds a reference to another definition in the resource" do
       resource.defs[:foobar] = definition

data/spec/dsl/resources_spec.rb

@@ -21,5 +21,13 @@ describe Sinatra::Schema::DSL::Resources do
       assert_equal 1, dsl.resource.properties.size
       assert dsl.resource.properties.has_key?(:foo)
     end
+
+    it "supports nested properties" do
+      dsl.property.nested :user do |prop|
+        prop.text :email
+        prop.bool :admin
+      end
+      assert_equal 2, dsl.resource.properties[:user].size
+    end
   end
 end

data/spec/{param_handling_spec.rb → param_parsing_spec.rb}

@@ -1,9 +1,9 @@
 require "spec_helper"
 
-describe Sinatra::Schema::ParamHandling do
+describe Sinatra::Schema::ParamParsing do
   before do
     @rack_app = Sinatra.new do
-      helpers Sinatra::Schema::ParamHandling
+      helpers Sinatra::Schema::ParamParsing
       post("/") do
         MultiJson.encode(parse_params($properties))
       end
@@ -31,6 +31,12 @@ describe Sinatra::Schema::ParamHandling do
       post "/", MultiJson.encode(params)
       assert_equal params, last_json
     end
+
+    it "preserves nested params" do
+      params = { "foo" => { "bar" => 42 }}
+      post "/", MultiJson.encode(params)
+      assert_equal params, last_json
+    end
   end
 
   describe "form-encoded params" do
@@ -43,8 +49,16 @@ describe Sinatra::Schema::ParamHandling do
       assert_equal({ "some_text" => "true", "some_bool" => true }, last_json)
     end
 
+    it "handles nested params" do
+      $properties = {
+        foo: { bar: Sinatra::Schema::Definition.new(type: "boolean") }
+      }
+      post "/", foo: { bar: "true" }
+      assert_equal({ "foo" => { "bar" => true }}, last_json)
+    end
+
     it "leaves params without the corresponding property untouched" do
-      $properies = {}
+      $properties = {}
       params = { "foo" => "bar" }
       post "/", params
       assert_equal params, last_json

data/spec/param_validation_spec.rb

@@ -32,4 +32,12 @@ describe Sinatra::Schema::ParamValidation do
       post "/", MultiJson.encode(bool: "omg")
     end
   end
+
+  it "supports nested params" do
+    $properties = { foo: { bar: Sinatra::Schema::Definition.new(type: "boolean") }}
+    assert_raises(RuntimeError) do
+      post "/", MultiJson.encode(foo: { bar: "omg" })
+      puts last_response.body
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sinatra-schema
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Pedro Belo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-06 00:00:00.000000000 Z
+date: 2014-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -139,19 +139,20 @@ files:
 - 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_parsing.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/definition_spec.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_parsing_spec.rb
 - spec/param_validation_spec.rb
 - spec/resource_spec.rb
 - spec/spec_helper.rb