swaggable 0.6.0 → 0.7.0

data/lib/swaggable/grape_adapter.rb

@@ -64,8 +64,8 @@ module Swaggable
       api_endpoint.summary = grape_endpoint.route_description
       api_endpoint.path = extract_path(grape_endpoint, grape)
 
-      api_endpoint.produces.merge grape.content_types.values
-      api_endpoint.consumes.merge grape.content_types.values
+      api_endpoint.produces.merge! grape.content_types.values
+      api_endpoint.consumes.merge! grape.content_types.values
 
       api_endpoint.tags.add_new do |t|
         t.name = grape.name

data/lib/swaggable/mime_type_definition.rb

@@ -0,0 +1,73 @@
+module Swaggable
+  class MimeTypeDefinition
+    def initialize id
+      @type, @subtype, @options = case id
+                                  when String then parse_string id
+                                  when Symbol then parse_symbol id
+                                  else raise "#{id.inspect} not valid"
+                                  end
+    end
+
+    def name
+      "#{type}/#{subtype}"
+    end
+
+    alias to_s name
+
+    def http_string
+      http = name
+      http += options if options
+      http
+    end
+
+    def to_sym
+      string = if type == 'application'
+                 subtype
+               else
+                 name
+               end
+
+      string.gsub(/[-\.\/]+/,'_').to_sym
+    end
+
+    def inspect
+      "#<Swaggable::ContentTypeDefinition: #{type}/#{subtype}>"
+    end
+
+    def == other
+      case other
+      when self.class then name == other.name
+      when String, Symbol then name == self.class.new(other).name
+      else false
+      end
+    end
+
+    alias eql? ==
+
+    def hash
+      name.hash
+    end
+
+    private
+
+    attr_reader :type, :subtype, :options
+
+    def parse_string id
+      type, subtype, options = id.match(/(?<type>[^\/]+)\/?(?<subtype>[^;]*)(?<options>.*)/).captures
+
+      type = nil if type == ""
+      subtype = nil if subtype == ""
+      options = nil if options == ""
+
+      [type, subtype, options]
+    end
+
+    def parse_symbol id
+      type = 'application'
+      subtype = id.to_s.gsub('_','-')
+      options = nil
+
+      [type, subtype, options]
+    end
+  end
+end

data/lib/swaggable/mime_types_collection.rb

@@ -0,0 +1,60 @@
+module Swaggable
+  class MimeTypesCollection
+    include Enumerable
+    extend Forwardable
+
+    def_delegators(
+      :@list,
+      :last,
+      :first,
+      :count,
+    )
+
+    def initialize
+      @list = []
+    end
+
+    def << entry
+      entry = case entry
+              when Symbol, String then MimeTypeDefinition.new entry
+              else entry
+              end
+
+      if n = list.index(entry)
+        list[n] = entry
+      else
+        list << entry
+      end
+    end
+
+    def each *args, &block
+      list.each(*args, &block)
+    end
+
+    def [] key
+      list.detect {|e| e == key }
+    end
+
+    def inspect
+      "#<Swaggable::MimeTypesCollection: #{list.map(&:name).join(', ')}>"
+    end
+
+    def merge! other
+      other.each {|e| self << e }
+    end
+
+    def == other
+      count == other.count && other.each {|e| include? e }
+    end
+
+    alias eql? ==
+
+    def hash
+      name.hash
+    end
+
+    protected
+
+    attr_reader :list
+  end
+end

data/lib/swaggable/parameter_definition.rb

@@ -10,6 +10,7 @@ module Swaggable
       :required,
       :type,
       :schema,
+      :value,
     )
 
     attr_enum :location, [:path, :query, :header, :body, :form, nil]
@@ -26,6 +27,24 @@ module Swaggable
       )
     end
 
+    def name= value
+      @name = value.to_s
+    end
+
+    def == other
+      if other.respond_to?(:name) && other.respond_to?(:location)
+        [name, location] == [other.name, other.location]
+      else
+        false
+      end
+    end
+
+    alias eql? ==
+
+    def hash
+      [name, location].hash
+    end
+
     private
 
     def build_schema

data/lib/swaggable/query_params.rb

@@ -0,0 +1,50 @@
+module Swaggable
+  class QueryParams < Delegator
+    def initialize arg = nil
+      case arg
+      when String then self.string = arg
+      when Hash then self.hash = arg
+      when NilClass then self.hash = {}
+      else raise("#{arg.inspect} not supported. Use Hash or String")
+      end
+    end
+
+    def __getobj__
+      string && hash
+    end
+
+    def string
+      @string
+    end
+
+    def hash
+      parse(string).freeze
+    end
+
+    def string= value
+      @string = value
+    end
+
+    def hash= value
+      self.string = serialize(value)
+    end
+
+    def []= key, value
+      self.hash= hash.merge(key => value)
+    end
+
+    private
+
+    def serialize hash
+      hash.map{|k, v| "#{CGI.escape k.to_s}=#{CGI.escape v.to_s}" }.join("&")
+    end
+
+    def parse string
+      CGI.parse(string).inject({}){|a,h| k,v = h; a[k]=v.first; a} 
+    end
+
+    def binding
+      ::Kernel.binding
+    end
+  end
+end

data/lib/swaggable/rack_request_adapter.rb

@@ -0,0 +1,88 @@
+require 'json'
+require 'ostruct'
+
+module Swaggable
+  class RackRequestAdapter
+    def initialize env
+      @env = env || raise("env hash is required")
+    end
+
+    def [] key
+      env[key]
+    end
+
+    def query_parameters
+      @query_parameters ||= QueryParams.new env['QUERY_STRING']
+    end
+
+    def query_parameters= p
+      @query_parameters = QueryParams.new p
+    end
+
+    def path
+      env['PATH_INFO']
+    end
+
+    def body
+      @body ||= if stream = env['rack.input']
+                  string = stream.read
+                  string == '' ? nil : string
+                else
+                  nil
+                end
+    end
+
+    def parsed_body
+      case content_type
+      when 'application/json' then JSON.parse body
+      else
+        raise "Don't know how to parse #{env['CONTENT_TYPE'].inspect}"
+      end
+    end
+
+    def parameters endpoint = endpoint_stub
+      build_path_parameters(endpoint) +
+      build_query_parameters
+    end
+
+    def content_type
+      env['CONTENT_TYPE']
+    end
+
+    def content_type= value
+      env['CONTENT_TYPE'] = value
+    end
+
+    private
+
+    attr_reader :env
+
+    def rack_request
+      @rack_request = Rack::Request.new env
+    end
+
+    def build_query_parameters
+      query_parameters.map do |name, value|
+        ParameterDefinition.new(name: name, value: value, location: :query)
+      end
+    end
+
+    def build_path_parameters endpoint
+      if endpoint
+        endpoint.path_parameters_for(path).map do |name, value|
+          ParameterDefinition.new(name: name, value: value, location: :path)
+        end
+      else
+        []
+      end
+    end
+
+    def endpoint_stub
+      Object.new.tap do |o|
+        def o.path_parameters_for _
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/swaggable/rack_response_adapter.rb

@@ -0,0 +1,49 @@
+module Swaggable
+  class RackResponseAdapter
+    def initialize rack_response = default_rack_response
+      @rack_response = rack_response
+    end
+
+    def content_type
+      rack_headers['Content-Type']
+    end
+
+    def content_type= value
+      rack_headers['Content-Type'] = value
+    end
+
+    def code
+      rack_response[0]
+    end
+
+    def code= value
+      rack_response[0] = value
+    end
+
+    def == other
+      if other.respond_to? :rack_response, true
+        rack_response == other.rack_response
+      else
+        false
+      end
+    end
+
+    alias eql? ==
+
+    def hash
+      rack_response.hash
+    end
+
+    protected
+
+    attr_accessor :rack_response
+
+    def default_rack_response
+      [200, {}, []]
+    end
+
+    def rack_headers
+      rack_response[1]
+    end
+  end
+end

data/lib/swaggable/swagger_2_serializer.rb

@@ -44,7 +44,7 @@ module Swaggable
     def serialize_endpoints endpoints
       endpoints.inject({}) do |out, endpoint|
         out[endpoint.path] ||= {}
-        out[endpoint.path][endpoint.verb] = serialize_endpoint(endpoint)
+        out[endpoint.path][endpoint.verb.downcase.to_sym] = serialize_endpoint(endpoint)
         out
       end
     end
@@ -52,8 +52,8 @@ module Swaggable
     def serialize_endpoint endpoint
       {
         tags: endpoint.tags.map(&:name),
-        consumes: endpoint.consumes.to_a,
-        produces: endpoint.produces.to_a,
+        consumes: endpoint.consumes.map(&:http_string),
+        produces: endpoint.produces.map(&:http_string),
         parameters: endpoint.parameters.map{|p| serialize_parameter p },
         responses: serialize_responses(endpoint.responses),
       }.

data/lib/swaggable/validating_rack_app.rb

@@ -0,0 +1,30 @@
+module Swaggable
+  class ValidatingRackApp
+    attr_accessor(
+      :app,
+      :definition,
+    )
+
+    def initialize args = {}
+      @app = args[:app]
+      @definition = args[:definition]
+    end
+
+    def call rack_req
+      req = RackRequestAdapter.new rack_req
+
+      validator = ApiValidator.new definition: definition, request: req
+
+      errors = validator.errors_for_request
+      raise(errors) if errors.any?
+
+      rack_resp = app.call rack_req
+      resp = RackResponseAdapter.new rack_resp
+
+      errors = validator.errors_for_response resp
+      raise(errors) if errors.any?
+
+      rack_resp
+    end
+  end
+end

data/lib/swaggable/version.rb

@@ -1,3 +1,3 @@
 module Swaggable
-  VERSION = '0.6.0'
+  VERSION = '0.7.0'
 end

data/spec/{swaggable/integration_spec.rb → integration/dsl_spec.rb}

@@ -1,46 +1,6 @@
 require_relative '../spec_helper'
-require 'rack/test'
-require 'grape'
 
 RSpec.describe 'Integration' do
-  context 'RackApp' do
-    include Rack::Test::Methods
-
-    def app
-      subject
-    end
-
-    subject { rack_app }
-    let(:rack_app) { Swaggable::RackApp.new(api_definition: api_def) }
-    let(:api_def) { Swaggable::ApiDefinition.from_grape_api(grape_api) }
-
-    let(:grape_api) do
-      Class.new(Grape::API).tap do |g|
-        g.params do
-          requires :user_uuid
-        end
-
-        g.get '/' do
-          status 200
-          body({some: 'body'})
-        end
-
-      end.tap do |grape|
-        stub_const('MyGrapeApi', grape)
-      end
-    end
-
-    it 'has status 200 OK' do
-      get '/'
-      expect(last_response.status).to eq 200
-      expect(last_response.headers['Content-Type']).to eq 'application/json'
-    end
-
-    it 'validates' do
-      expect(subject.validate!).to be true
-    end
-  end
-
   context 'dsl' do
     let(:rack_app) { Swaggable::RackApp.new(api_definition: api) }