sinatra-swagger 0.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MmJlMmY4Y2NiMTI5NTljNDAyNGIxODBkY2ZlZmI3OTFiYWU2ODNjMQ==
+  data.tar.gz: !binary |-
+    MTFiY2Q2NDRhYTJmMmU5ODAyYzgxMDg4OGJjYzRlNDg3NzZiMjgyZg==
+SHA512:
+  metadata.gz: !binary |-
+    YjZmMDE4YTZiMDIzMTUyODAwZDhlYjM4YThkZjFkNjNhYTNjNjc5ZWQwM2M5
+    MTc3MzY4NjlmM2E3ZGMyYzExNWY3MjA0OGNiMDI1N2I2NjlkYjBlMTA2YmEx
+    NmVkMGUwZGJkZWU4ZDBhYjhiOWFmMjA0NmY1NTNjOWY0ZGVjZGI=
+  data.tar.gz: !binary |-
+    YWQ0NjIzOGJmZTA4NzU2YjIyNGMyN2IwZWJkYWQxMjU4Nzg0ZjA4OTY5ZTRj
+    ZmE2OTdlNzIyNzNiNzNhYTQ4YzIwMTdkMDkxNzgxZmZlMzJiOTg4MjZlY2I1
+    ZjdmYjZjMjhiNjJkYmQzNzg4OWQxYTI1NGZjZWNhOTc3ZGNiZjQ=

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+config/
+bin/
+vendor/
+log/
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+rvm:
+- 2.0.0
+- 2.1.2
+deploy:
+  provider: rubygems
+  api_key:
+    secure: f3c7U1z9hulitL8sjYztJmEEgGsCC/X/q/VybFYOC2wsp5D2WggYJ4CTaWcNjCSAWXgVl5L0kOkjKYyItdxVJoyhBa4Mc3MfZo8Dp2UCYpdA+FGd7UbOqbITkr9ZyD22oWk7PgfKeNKoLyffdG9HH/OYJ5ezSa7PB2XMN+Ae2W8=
+  gem: sinatra-swagger
+  on:
+    tags: true
+    repo: jphastings/sinatra-swagger

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/README.md

@@ -0,0 +1,3 @@
+# Sinatra::Swagger
+
+Helper methods for accesing your swagger documentation from within your sinatra routes.

data/Rakefile

@@ -0,0 +1,23 @@
+require "rake"
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+task :default => :build
+task :build => :test
+
+desc "Runs all tests"
+task :test => :spec
+
+desc "Run all rspec tests"
+begin
+  require "rspec/core/rake_task"
+
+  RSpec::Core::RakeTask.new(:spec) do |t|
+    t.pattern = "spec/**/*_spec.rb"
+  end
+rescue LoadError => e
+  raise e
+  task :spec do
+    $stderr.puts "Please install rspec: `gem install rspec`"
+  end
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/sinatra/swagger/spec_enforcer.rb

@@ -0,0 +1,68 @@
+require "yaml"
+require "swagger/rack"
+
+module Sinatra
+  module Swagger
+    module SpecEnforcer
+      def swagger(filepath)
+        set :swagger, ::Swagger::Base.new(filepath)
+      end
+
+      def self.registered(app)
+        app.helpers Helpers
+
+        app.before do
+          spec = swagger_spec
+          unless spec.nil?
+            _, captures, spec = spec.values
+
+            invalidities = Hash[(spec['parameters'] || []).map { |details|
+              param_name = details['name']
+
+              parameter = case details['in']
+              when "query"
+                params[param_name]
+              when "path"
+                captures[param_name]
+              else
+                raise NotImplementedError, "Can't cope with #{details['in']} parameters right now"
+              end
+
+              if !parameter
+                next [param_name, :missing] if details['required'] && details['required'] != "false"
+                next unless details['default']
+                parameter = details['default']
+              end
+
+              begin
+                parameter = ::Swagger.cast(parameter.to_s, details['type']) if parameter
+              rescue ArgumentError
+                next [param_name, :incorrect_type]
+              end
+
+              if %w{integer number}.include? details['type']
+                too_large = details['maximum'] && parameter > details['maximum']
+                too_small = details['minimum'] && parameter < details['minimum']
+                next [param_name, :out_of_range] if too_large || too_small
+              end
+
+              params[param_name] = parameter
+
+              nil
+            }.compact]
+
+            halt 400, invalidities.to_json if invalidities.any?
+          end
+        end
+      end
+
+      module Helpers
+        def swagger_spec
+          settings.swagger.request_spec(env: env)
+        end
+      end
+    end
+  end
+
+  register Swagger::SpecEnforcer
+end

data/lib/sinatra/swagger/version.rb

@@ -0,0 +1,5 @@
+module Sinatra
+  module Swagger
+    VERSION = File.read(File.join(__dir__, "../../../VERSION")) rescue "0.0.0"
+  end
+end

data/lib/sinatra/swagger.rb

@@ -0,0 +1,2 @@
+require "sinatra/swagger/version"
+require "sinatra/swagger/spec_enforcer"

data/lib/swagger/base.rb

@@ -0,0 +1,33 @@
+require "json-schema"
+
+module Swagger
+  # Casts a string value to the ruby datatype as definied in the swagger spec
+  def self.cast(value, type = "string")
+    raise ArgumentError, "#{value} is not a string" unless value.is_a?(String)
+    case type
+    when "string"
+      value
+    when "integer"
+      raise ArgumentError, "#{value} is not an integer" unless value =~ /^-?\d+$/
+      value.to_i
+    when "number"
+      raise ArgumentError, "#{value} is not a float" unless value =~ /^-?\d+(?:\.\d+)?$/
+      value.to_f
+    else
+      raise NotImplementedError
+    end
+  end
+
+  class Base
+    # Pre-load JSON-schema files used for validation
+    Dir.glob(File.join(__dir__, "../../schema/*-schema.json")) do |schema|
+      data = JSON.parse(File.read(schema))
+      JSON::Validator.add_schema(JSON::Schema.new(data, data['id']))
+    end
+
+    def initialize(filepath)
+      @spec = YAML.load(open(filepath))
+      JSON::Validator.validate!({ "$ref" => "http://swagger.io/v2/schema.json#" }, @spec)
+    end
+  end
+end

data/lib/swagger/rack.rb

@@ -0,0 +1,42 @@
+require "swagger/base"
+
+module Swagger
+  module RackHelpers
+    def request_spec(env: nil)
+      path = env['REQUEST_PATH']
+      verb = env['REQUEST_METHOD'].downcase
+      matching_paths = (@spec['paths'] || {}).map { |spec_path, spec|
+        next unless spec[verb]
+        matches = match_string(spec_path, path)
+        next if matches.nil?
+        {
+          path: spec_path,
+          captures: matches,
+          spec: spec[verb]
+        }
+      }.compact
+
+      case matching_paths.size
+      when 0
+        return nil
+      when 1
+        return matching_paths.first
+      else
+        spec_paths = matching_paths.map { |p| p[:path] }
+        raise "Your API documentation is non-deterministic for the path: #{path} (#{spec_paths.join(', ')})"
+      end
+    end
+
+    private
+
+    def match_string(bracketed_string, match_string)
+      re = bracketed_string.gsub(/\{([^}]+)\}/, "(?<\\1>.+?)")
+      matches = Regexp.new("^#{re}$").match(match_string)
+      return nil if matches.nil?
+      captures = matches.captures
+      Hash[matches.names.zip(captures)]
+    end
+  end
+
+  Base.include(RackHelpers)
+end

data/schema/README.md

@@ -0,0 +1,5 @@
+# Schema
+
+These schema are the ones needed to validate Swagger 2.0 documentation without requiring access to the internet.
+
+If the Swagger 2.x schema updates then the files here should also be updated. Any file matching `*-schema.json` will be loaded as a JSON Schema file (and will cause errors if it does not validate itself)

data/schema/draft4-schema.json

@@ -0,0 +1,150 @@
+{
+    "id": "http://json-schema.org/draft-04/schema#",
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Core schema meta-schema",
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#" }
+        },
+        "positiveInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "positiveIntegerDefault0": {
+            "allOf": [ { "$ref": "#/definitions/positiveInteger" }, { "default": 0 } ]
+        },
+        "simpleTypes": {
+            "enum": [ "array", "boolean", "integer", "null", "number", "object", "string" ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "minItems": 1,
+            "uniqueItems": true
+        }
+    },
+    "type": "object",
+    "properties": {
+        "id": {
+            "type": "string",
+            "format": "uri"
+        },
+        "$schema": {
+            "type": "string",
+            "format": "uri"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": {},
+        "multipleOf": {
+            "type": "number",
+            "minimum": 0,
+            "exclusiveMinimum": true
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "boolean",
+            "default": false
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxLength": { "$ref": "#/definitions/positiveInteger" },
+        "minLength": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "additionalItems": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "items": {
+            "anyOf": [
+                { "$ref": "#" },
+                { "$ref": "#/definitions/schemaArray" }
+            ],
+            "default": {}
+        },
+        "maxItems": { "$ref": "#/definitions/positiveInteger" },
+        "minItems": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxProperties": { "$ref": "#/definitions/positiveInteger" },
+        "minProperties": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "required": { "$ref": "#/definitions/stringArray" },
+        "additionalProperties": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "definitions": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "dependencies": {
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "$ref": "#/definitions/stringArray" }
+                ]
+            }
+        },
+        "enum": {
+            "type": "array",
+            "minItems": 1,
+            "uniqueItems": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/definitions/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" }
+    },
+    "dependencies": {
+        "exclusiveMaximum": [ "maximum" ],
+        "exclusiveMinimum": [ "minimum" ]
+    },
+    "default": {}
+}