sinatra-schema 0.0.5 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: efba21adbb69d56337bf911bf277b98f99da8781
-  data.tar.gz: f90d52c93a3dc9207f01a075502c383f02f502b4
+  metadata.gz: 7ed53578697a31d2928747c5e315a6bf74e3a5b1
+  data.tar.gz: 1c8fabb80b8ee50d14186838d1a29f53d4bc039b
 SHA512:
-  metadata.gz: 7eda67c2a0f5d08c9ad7a1b4272c5260c43e96f55cb192e40a1b88f6d0fd3dd9f7c7d9f3fe68cfb1af4daf091e1766bcd75e65cf3cf769ecb83e82a50f3927a2
-  data.tar.gz: cd59d186c53e8c262309a6eae7ec232f4d878b65bc76081d4defe6702c22e15785d4ed0e4299879e6c668f40ffd830da57406f75d412b1e7011975a662d264fa
+  metadata.gz: e3a1e7c20a2737d577391748a479bddb1761183777c4797cf6dfc6009076c4caec7dc408aa174eaab7f382d34abc839f49a01728d99e2753e88e5a42c2c668ec
+  data.tar.gz: 7e12db3a44fe1ee3574f5feb3d9fa47c676820d24587a9f85e5d391b7678574288460bd2cef166d6c26055701f147d43fceef2acc5a4ae491f12594af1cf11dd

data/README.md

@@ -17,7 +17,7 @@ class MyApi < Sinatra::Base
   resource("/account") do |res|
     res.property.text :email
 
-    res.link(:get) do |link|
+    res.get do |link|
       link.action do
         # note per definition above we need to serialize "email"
         MultiJson.encode(email: current_user.email)
@@ -35,7 +35,7 @@ Links can have properties too:
 resource("/account") do |res|
   res.property.text :email
 
-  res.link(:post) do |link|
+  res.post do |link|
     link.property.ref  :email # reuse the property defined above
     link.property.text :role, optional: true
     link.property.bool :admin

data/lib/sinatra/schema.rb

@@ -2,12 +2,15 @@ require "active_support/inflector"
 require "sinatra/base"
 require "singleton"
 require "multi_json"
+require "time"
 
 require "sinatra/schema/definition"
 require "sinatra/schema/error"
+require "sinatra/schema/json_schema"
 require "sinatra/schema/link"
 require "sinatra/schema/param_parsing"
 require "sinatra/schema/param_validation"
+require "sinatra/schema/reference"
 require "sinatra/schema/resource"
 require "sinatra/schema/root"
 require "sinatra/schema/utils"
@@ -32,7 +35,7 @@ module Sinatra
       app.get "/schema" do
         content_type("application/schema+json")
         response.headers["Cache-Control"] = "public, max-age=3600"
-        MultiJson.encode(app.schema_root.to_schema, pretty: true)
+        MultiJson.encode(JsonSchema.dump(app.schema_root), pretty: true)
       end
     end
 

data/lib/sinatra/schema/definition.rb

@@ -18,6 +18,8 @@ module Sinatra
         case type
         when "boolean"
           %w( t true 1 ).include?(value.to_s)
+        when "datetime"
+          Time.parse(value.to_s)
         when "email", "string", "uuid"
           value.to_s
         end
@@ -29,6 +31,8 @@ module Sinatra
         case type
         when "boolean"
           [true, false].include?(value)
+        when "datetime"
+          value.to_s =~ /^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-2][0-9]:[0-5][0-9]:[0-5][0-9](\.[0-9]+)?(Z|[\-+][0-9]{2}:[0-5][0-9])$/
         when "email"
           value.to_s =~ /\A[^@\s]+@([^@\s]+\.)+[^@\s]+\z/
         when "string"
@@ -37,33 +41,6 @@ module Sinatra
           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"
-          "boolean"
-        when "email"
-          ["string", "email"]
-        when "string"
-          "string"
-        when "uuid"
-          ["string", "uuid"]
-        end
-      end
     end
   end
 end

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

@@ -25,6 +25,11 @@ module Sinatra
           add Definition.new(options)
         end
 
+        def datetime(id, options={})
+          options.merge!(id: id, type: "datetime")
+          add Definition.new(options)          
+        end
+
         def email(id, options={})
           options.merge!(id: id, type: "email")
           add Definition.new(options)
@@ -40,25 +45,16 @@ module Sinatra
         end
 
         def ref(id, ref_to=nil)
-          ref_to ||= id
-          unless definition = resource.defs[ref_to] || Sinatra::Schema::Root.instance.find_definition(ref_to)
-            raise BadReference.new(id)
-          end
-          add definition, true, id
+          add Reference.new(resource, id, ref_to), true
         end
 
         # TODO support other types
 
         protected
 
-        def add(definition, reference=false, id=nil)
-          id ||= definition.id
-          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[id] = definition
+        def add(definition, reference=false)
+          targets.each do |target|
+            target[definition.id] ||= definition
           end
         end
       end

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

@@ -17,12 +17,35 @@ module Sinatra
           DSL::Definitions.new(resource, [resource.defs, resource.properties])
         end
 
-        def link(method, href="/", &blk)
+        def delete(href="/", &blk)
+          build_link(:delete, href, &blk)
+        end
+
+        def get(href="/", &blk)
+          build_link(:get, href, &blk)
+        end
+
+        def patch(href="/", &blk)
+          build_link(:patch, href, &blk)
+        end
+
+        def post(href="/", &blk)
+          build_link(:post, href, &blk)
+        end
+
+        def put(href="/", &blk)
+          build_link(:put, href, &blk)
+        end
+
+        protected
+
+        def build_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
+          blk.call(dsl) if blk
+          dsl.link.tap do |link|
+            link.register(app)
+            resource.links << link
+          end
         end
       end
     end

data/lib/sinatra/schema/json_schema.rb

@@ -0,0 +1,73 @@
+module Sinatra
+  module Schema
+    class JsonSchema
+      attr_accessor :root
+
+      def self.dump(root)
+        new(root).dump_root
+      end
+
+      def initialize(root)
+        @root = root
+      end
+
+      def dump_root
+        {
+          "$schema" => "http://json-schema.org/draft-04/hyper-schema",
+          "definitions" => root.resources.inject({}) { |result, (id, resource)|
+            result.merge(id => dump_resource(resource))
+          }
+        }
+      end
+
+      def dump_resource(resource)
+        {
+          title: resource.title,
+          description: resource.description,
+          type: "object",
+          definitions: resource.defs.inject({}) { |h, (id, definition)|
+            h.merge(id => dump_definition(definition))
+          },
+          links: resource.links.map { |link| dump_link(link) }
+        }
+      end
+
+      def dump_definition(definition)
+        schema_type, schema_format = json_schema_type_and_format(definition.type)
+        attrs = { type: schema_type }
+        if schema_format
+          attrs[:format] = schema_format
+        end
+        if definition.description
+          attrs[:description] = definition.description
+        end
+        attrs
+      end
+
+      def dump_link(link)
+        {
+          description: link.description,
+          href:        link.href,
+          method:      link.method.to_s.upcase,
+        }
+      end
+
+      protected
+
+      def json_schema_type_and_format(type)
+        case type
+        when "boolean"
+          "boolean"
+        when "datetime"
+          ["string", "date-time"]
+        when "email"
+          ["string", "email"]
+        when "string"
+          "string"
+        when "uuid"
+          ["string", "uuid"]
+        end
+      end
+    end
+  end
+end

data/lib/sinatra/schema/link.rb

@@ -3,7 +3,7 @@ module Sinatra
     class Link
       attr_accessor :action_block, :resource, :title, :description, :href, :method, :properties, :rel
 
-      def initialize(options)
+      def initialize(options={})
         @resource   = options[:resource]
         @method     = options[:method]
         @href       = options[:href]
@@ -11,7 +11,7 @@ module Sinatra
       end
 
       def register(app)
-        app.send(method.downcase, href, &handler)
+        app.send(method, href, &handler)
       end
 
       def handler
@@ -26,14 +26,6 @@ module Sinatra
           end
         end
       end
-
-      def to_schema
-        {
-          description: description,
-          href:        href,
-          method:      method.to_s.upcase,
-        }
-      end
     end
   end
 end

data/lib/sinatra/schema/reference.rb

@@ -0,0 +1,36 @@
+module Sinatra
+  module Schema
+    class Reference
+      attr_accessor :id, :ref_spec, :referenced_def, :resource
+
+      # helper to lazily delegate method to the referenced definition
+      def self.delegate(attribute)
+        define_method(attribute) do |*args|
+          resolve!
+          referenced_def.send(attribute, *args)
+        end
+      end
+
+      def initialize(resource, id, ref_spec=nil)
+        @id = id
+        @ref_spec = ref_spec || id
+        @resource = resource
+      end
+
+      def resolve!
+        return if referenced_def
+        unless @referenced_def = resource.defs[ref_spec] || Sinatra::Schema::Root.instance.find_definition(ref_spec)
+          raise BadReference.new(ref_spec)
+        end
+        return @referenced_def
+      end
+
+      delegate :cast
+      delegate :description
+      delegate :example
+      delegate :optional
+      delegate :type
+      delegate :valid?
+    end
+  end
+end

data/lib/sinatra/schema/resource.rb

@@ -31,19 +31,6 @@ module Sinatra
           Utils.validate_keys!(properties, res)
         end
       end
-
-      def to_schema
-        {
-          title: title,
-          description: description,
-          type: "object",
-          definitions: defs.inject({}) { |h, (id, definition)|
-            h[id] = definition.to_schema
-            h
-          },
-          links: links.map(&:to_schema)
-        }
-      end
     end
   end
 end

data/lib/sinatra/schema/root.rb

@@ -18,16 +18,6 @@ module Sinatra
         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/version.rb

@@ -1,5 +1,5 @@
 module Sinatra
   module Schema
-    VERSION = "0.0.5"
+    VERSION = "0.1.0"
   end
 end

data/spec/definition_spec.rb

@@ -13,6 +13,19 @@ describe Sinatra::Schema::Definition do
       assert_equal false, definition.cast("false")
     end
 
+    it "casts datetime" do
+      definition.type = "datetime"
+      t = definition.cast("2014-05-01T12:13:14.15Z")
+      assert_equal 2014, t.year
+      assert_equal 5, t.month
+      assert_equal 1, t.day
+      assert_equal 12, t.hour
+      assert_equal 13, t.min
+      assert_equal 14, t.sec
+      assert_equal 150000, t.usec
+      assert_equal "UTC", t.zone
+    end
+
     it "casts text" do
       definition.type = "string"
       assert_equal "123", definition.cast(123)
@@ -20,45 +33,35 @@ describe Sinatra::Schema::Definition do
   end
 
   describe "#valid?" do
-    it "detects booleans" do
+    it "validates booleans" do
       definition.type = "boolean"
       assert definition.valid?(true)
       assert definition.valid?(false)
       refute definition.valid?("true")
     end
 
-    it "detects emails" do
+    it "validates emails" do
       definition.type = "email"
       assert definition.valid?("foo@bar.com")
       refute definition.valid?("foobar.com")
     end
 
-    it "detects text" do
+    it "validates text" do
       definition.type = "string"
       assert definition.valid?("foo")
       refute definition.valid?(123)
     end
 
-    it "detects uuids" do
+    it "validates 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]
+    it "validates date+time fields" do
+      definition.type = "datetime"
+      assert definition.valid?("1985-04-12T23:20:50.52Z")
+      refute definition.valid?("12/4/1985 23:20:50")
     end
   end
 end

data/spec/dsl/definitions_spec.rb

@@ -17,6 +17,12 @@ describe Sinatra::Schema::DSL::Definitions do
     assert_equal "boolean", resource.defs[:foobar].type
   end
 
+  it "adds a datetime definition to the resource" do
+    dsl.datetime(:foobar)
+    assert_equal 1, resource.defs.size
+    assert_equal "datetime", resource.defs[:foobar].type
+  end
+
   it "adds nested definitions" do
     dsl[:user].text :email
     dsl[:user].bool :admin
@@ -25,43 +31,14 @@ describe Sinatra::Schema::DSL::Definitions do
     assert_equal "boolean", resource.defs[:user][:admin].type
   end
 
+  it "adds references" do
+    dsl.ref(:another_property)
+    assert_equal 1, resource.defs.size
+    assert_instance_of Sinatra::Schema::Reference, resource.defs[:another_property]
+  end
+
   it "sets other options" do
     dsl.text(:foobar, optional: true)
     assert_equal true, resource.defs[:foobar].optional
   end
-
-  describe "#ref" do
-    let(:definition) { Sinatra::Schema::Definition.new(id: :foobar) }
-
-    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
-
-    it "raises when we can't resolve the ref" do
-      assert_raises(Sinatra::Schema::BadReference) do
-        dsl.ref :foobar
-      end
-    end
-
-    it "allows references to have a different id" do
-      other = Sinatra::Schema::Resource.new(path: "/others")
-      root.add_resource(other)
-      other.defs[:foobar] = definition
-      dsl.ref :my_foobar, "other/foobar"
-      assert resource.properties.has_key?(:my_foobar)
-      assert_equal :foobar, resource.properties[:my_foobar].id
-    end
-  end
 end

data/spec/dsl/resources_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 
 describe Sinatra::Schema::DSL::Resources do
-  let(:app) { Sinatra::Application.new }
+  let(:app) { Sinatra.new {} }
   let(:dsl) { described_class.new(app, "/foobar") }
 
   it "sets the resource description" do
@@ -28,4 +28,31 @@ describe Sinatra::Schema::DSL::Resources do
       assert_equal 2, dsl.resource.properties[:user].size
     end
   end
+
+  describe "building links" do
+    it "builds a DELETE" do
+      link = dsl.delete
+      assert_equal :delete, link.method
+    end
+
+    it "builds a GET" do
+      link = dsl.get
+      assert_equal :get, link.method
+    end
+
+    it "builds a PATCH" do
+      link = dsl.patch
+      assert_equal :patch, link.method
+    end
+
+    it "builds a POST" do
+      link = dsl.post
+      assert_equal :post, link.method
+    end
+
+    it "builds a PUT" do
+      link = dsl.put
+      assert_equal :put, link.method
+    end
+  end
 end

data/spec/integration_spec.rb

@@ -1,24 +1,55 @@
 require "spec_helper"
 
 describe Sinatra::Schema do
-  it "still works as a regular sinatra app" do
-    get "/regular"
-    assert_equal 200, last_response.status
-    assert_equal "hi", last_response.body
-  end
+  describe "resource access" do
+    it "still works as a regular sinatra app" do
+      get "/regular"
+      assert_equal 200, last_response.status
+      assert_equal "hi", last_response.body
+    end
+
+    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 gets" do
-    get "/accounts"
-    assert_equal 200, last_response.status
-    assert_equal({ "email" => "foo@bar.com" },
-      MultiJson.decode(last_response.body))
+    it "support resource posts" do
+      post "/accounts", email: "omg"
+      assert_equal 200, last_response.status
+      assert_equal({ "email" => "omg" },
+        MultiJson.decode(last_response.body))
+    end
   end
 
-  it "support resource posts" do
-    post "/accounts", email: "omg"
-    assert_equal 200, last_response.status
-    assert_equal({ "email" => "omg" },
-      MultiJson.decode(last_response.body))
+  describe "GET /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
 
   describe "error handling" do

data/spec/json_schema_spec.rb

@@ -1,30 +1,60 @@
 require "spec_helper"
 
-describe "JSON Schema" do
-  before do
-    get "/schema"
-    @schema = MultiJson.decode(last_response.body)
-  end
+describe Sinatra::Schema::JsonSchema do
+  let(:json_schema) { described_class.new(root) }
+  let(:root)        { Sinatra::Schema::Root.instance }
+  let(:schema)      { json_schema.dump_root }
 
-  it "renders a 200" do
-    assert_equal 200, last_response.status
-  end
+  describe "#dump_root" do
+    it "sets $schema" do
+      assert_equal "http://json-schema.org/draft-04/hyper-schema",
+        schema["$schema"]
+    end
 
-  it "sets the appropriate content-type" do
-    assert_equal "application/schema+json",
-      last_response.headers["Content-Type"]
+    it "adds a definition hash" do
+      assert_instance_of Hash, schema["definitions"]
+    end
   end
 
-  it "sets $schema to hyper-schema" do
-    assert_equal "http://json-schema.org/draft-04/hyper-schema",
-      @schema["$schema"]
+  describe "#dump_definition" do
+    let(:definition) { Sinatra::Schema::Definition.new }
+
+    it "handles simple string format" do
+      definition.type = "string"
+      schema = json_schema.dump_definition(definition)
+      assert_equal "string", schema[:type]
+      assert_nil schema[:format]
+    end
+
+    it "handles the datetime format" do
+      definition.type = "datetime"
+      schema = json_schema.dump_definition(definition)
+      assert_equal "string", schema[:type]
+      assert_equal "date-time", schema[:format]
+    end
+
+    it "handles the email format" do
+      definition.type = "email"
+      schema = json_schema.dump_definition(definition)
+      assert_equal "string", schema[:type]
+      assert_equal "email", schema[:format]
+    end
+
+    it "handles the uuid format" do
+      definition.type = "uuid"
+      schema = json_schema.dump_definition(definition)
+      assert_equal "string", schema[:type]
+      assert_equal "uuid", schema[:format]
+    end
   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"]
+  describe "#dump_link" do
+    let(:link) { Sinatra::Schema::Link.new }
+
+    it "renders the method in upcase" do
+      link.method = :get
+      schema = json_schema.dump_link(link)
+      assert_equal "GET", schema[:method]
+    end
   end
 end

data/spec/reference_spec.rb

@@ -0,0 +1,53 @@
+require "spec_helper"
+
+describe Sinatra::Schema::Reference do
+  let(:resource) { Sinatra::Schema::Root.instance.resources[:account] }
+  let(:ref) { described_class.new(resource, :foo, :email) }
+  let(:definition) { resource.defs[:email] }
+
+  describe "#resolve!" do
+    it "finds other properties in the same resource" do
+      ref.ref_spec = :foo
+      resource.defs[:foo] = definition
+      assert_equal definition, ref.resolve!
+    end
+
+    it "finds other properties elsewhere in the schema" do
+      ref.ref_spec = "account/email"
+      assert_equal definition, ref.resolve!
+    end
+
+    it "raises when it cannot resolve" do
+      ref.ref_spec = "does-not-exist"
+      assert_raises(Sinatra::Schema::BadReference) do
+        ref.resolve!
+      end
+    end
+  end
+
+  describe "delegated attributes" do
+    it "#cast" do
+      assert_equal definition.cast("foo"), ref.cast("foo")
+    end
+
+    it "#description" do
+      assert_equal definition.description, ref.description
+    end
+
+    it "#example" do
+      assert_equal definition.example, ref.example
+    end
+
+    it "#optional" do
+      assert_equal definition.optional, ref.optional
+    end
+
+    it "#type" do
+      assert_equal definition.type, ref.type
+    end
+
+    it "#valid?" do
+      assert_equal definition.valid?("foo"), ref.valid?("foo")
+    end
+  end
+end

data/spec/support/test_app.rb

@@ -13,7 +13,7 @@ class TestApp < Sinatra::Base
       example:     "username@example.com",
       format:      "email"
 
-    res.link(:get) do |link|
+    res.get do |link|
       link.title       "Info"
       link.rel         "self"
       link.description "Info for account"
@@ -22,7 +22,7 @@ class TestApp < Sinatra::Base
       end
     end
 
-    res.link(:post) do |link|
+    res.post do |link|
       link.title         "Create"
       link.rel           "create"
       link.description   "Create a new account"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sinatra-schema
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.1.0
 platform: ruby
 authors:
 - Pedro Belo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-09 00:00:00.000000000 Z
+date: 2014-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -139,9 +139,11 @@ files:
 - lib/sinatra/schema/dsl/links.rb
 - lib/sinatra/schema/dsl/resources.rb
 - lib/sinatra/schema/error.rb
+- lib/sinatra/schema/json_schema.rb
 - lib/sinatra/schema/link.rb
 - lib/sinatra/schema/param_parsing.rb
 - lib/sinatra/schema/param_validation.rb
+- lib/sinatra/schema/reference.rb
 - lib/sinatra/schema/resource.rb
 - lib/sinatra/schema/root.rb
 - lib/sinatra/schema/tasks/schema.rake
@@ -155,6 +157,7 @@ files:
 - spec/json_schema_spec.rb
 - spec/param_parsing_spec.rb
 - spec/param_validation_spec.rb
+- spec/reference_spec.rb
 - spec/resource_spec.rb
 - spec/spec_helper.rb
 - spec/support/last_json.rb