diesel-api-dsl 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1d4d0c9b3ef66d9ba223bc4f9844a5ca7785c087
-  data.tar.gz: bdce05f100ab2fa3207150fa5fcd867052aa180f
+  metadata.gz: 78e75164894839881d3adf47cef1575c25970140
+  data.tar.gz: 3ac675a70ef2bf4373a1e4a1b1601a68f8daaa65
 SHA512:
-  metadata.gz: 747c888131145da4de241043438788ccdd6b9657da281efe64a83f4b781bf2705e65a31cfd848f3c7a2e8d420e3f597fa7d8f831c76faa6027a083e2bbf99dbb
-  data.tar.gz: ff267d0ab287faf7e07a1806955996453e58a9aa7ae40c1991769734b993b767ca1a2c692263031d64ebd8c27013d8d68f3cb287bb60e41295af967752868776
+  metadata.gz: eceaffc1b439c45851509eb72f4f1e109a16c01b7a8901c104f8c023818f337a43875ef40f77e273d9eb14f8f0fbb99049e0986853a07cfe3c7d3c6720981771
+  data.tar.gz: b7be5c3cfdb6bf224263dc13c02f3f0aeab75af8574364a0d9f44133ff3f6a1a77fd20f9d39a86ae060b988c5c5ae96dc717fa0eba3fa5303f5b72300f4be4cb

data/Gemfile

@@ -1,4 +1,8 @@
 source 'https://rubygems.org'
 
+group :development do
+  gem "pry-byebug"
+end
+
 # Specify your gem's dependencies in diesel.gemspec
 gemspec

data/diesel.gemspec

@@ -25,5 +25,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "webmock", "~> 1.20.0"
 
   spec.add_dependency "httparty", "~> 0.12"
-  spec.add_dependency "multi_json", "~> 1.10.1"
+  spec.add_dependency "multi_json", ">= 1.3"
 end

data/lib/diesel/api_builder.rb

@@ -3,9 +3,11 @@ require 'diesel/api_error'
 require 'diesel/utils/inflections'
 require 'diesel/api_base'
 require 'diesel/data_model'
+require 'diesel/uri'
 
 require 'diesel/middleware/debug'
 require 'diesel/middleware/set_header'
+require 'diesel/middleware/convert_json_body'
 
 module Diesel
   class APIBuilder
@@ -25,8 +27,8 @@ module Diesel
           APIGroup.new.tap do |group|
             group.endpoints = build_endpoints
             group.endpoints.each do |endpoint|
-              klass.send(:define_method, endpoint.name.to_sym) do |parameters|
-                group.execute(self.options, endpoint, parameters)
+              klass.send(:define_method, endpoint.name.to_sym) do |*args|
+                group.execute(self.options, endpoint, *args)
               end
             end
           end
@@ -50,15 +52,13 @@ module Diesel
       end
 
       def build_endpoint_url(specification, path)
-        base_path     = specification.base_path.chomp('/')
-        resource_path = path.sub(/^([^\/])/, '/\1').chomp('/')
-        [
-          specification.schemes.first,
-          '://',
-          specification.host,
-          base_path,
-          resource_path
-        ].join('')
+        uri = Diesel::URI.new
+        uri.scheme = specification.schemes.first
+        uri.host = specification.host
+        uri.base_host = specification.extensions[:base_host]
+        uri.base_path = specification.base_path.chomp('/')
+        uri.resource_path = path.sub(/^([^\/])/, '/\1').chomp('/')
+        uri
       end
 
       def build_endpoints
@@ -72,30 +72,73 @@ module Diesel
 
             Diesel::Endpoint.new(endpoint_name, endpoint_url, method).tap do |endpoint|
               endpoint.config_middleware do
-                use Diesel::Middleware::Debug
+                consumes =
+                    (operation.consumes && operation.consumes.first) ||
+                    (spec.consumes && spec.consumes.first) 
+
+                produces =
+                    (operation.produces && operation.produces.first) ||
+                    (spec.produces && spec.produces.first) 
 
+                security = operation.security || spec.security
+
+                use Diesel::Middleware::Debug
                 use Diesel::Middleware::SetHeader, 'User-Agent' => "diesel-rb/#{Diesel::VERSION}"
 
-                if spec.produces.any?
-                  use Diesel::Middleware::SetHeader, 'Content-Type' => spec.produces.first
+                if consumes
+                  use Diesel::Middleware::SetHeader, 'Content-Type' => consumes
                 end
 
-                spec.security_definitions.each_pair do |name, security_def|
-                  case security_def.type
-                  when 'apiKey'
-                    require 'diesel/middleware/auth/api_key'
-                    use Diesel::Middleware::Auth::APIKey,
-                        id: Diesel::Utils::Inflections.underscore(name).to_sym,
-                        in: security_def.in,
-                        name: security_def.name
-                  when 'oauth2'
-                    require 'diesel/middleware/auth/oauth2'
-                    use Diesel::Middleware::Auth::OAuth2,
-                        id: Diesel::Utils::Inflections.underscore(name).to_sym,
-                        in: security_def.in,
-                        name: security_def.name
-                  else
-                    raise APIError, "Unsupported security definition: #{security_def.type}"
+                if produces
+                  use Diesel::Middleware::SetHeader, 'Accept' => produces
+                end
+
+                security_ids = if security && !security.empty?
+                                 security.keys
+                               else
+                                 if operation.security_definitions && !operation.security_definitions.empty?
+                                   [operation.security_definitions.keys.first]
+                                 elsif spec.security_definitions && !spec.security_definitions.empty?
+                                   [spec.security_definitions.keys.first]
+                                 else
+                                   []
+                                 end
+                               end
+
+                unless security_ids.empty?
+                  security_defs = spec.security_definitions || {}
+                  if operation.security_definitions
+                    security_defs = security_defs.merge(operation.security_definitions)
+                  end
+
+                  security_ids.each do |name|
+                    security_def = security_defs[name]
+
+                    if security_def.nil?
+                      raise APIError, "Missing security definition: #{name}, operation=#{endpoint_name}, method=#{method}"
+                    end
+
+                    case security_def.type
+                    when 'apiKey'
+                      require 'diesel/middleware/auth/api_key'
+                      use Diesel::Middleware::Auth::APIKey,
+                          id: Diesel::Utils::Inflections.underscore(name).to_sym,
+                          in: security_def.in,
+                          name: security_def.name,
+                          format: security_def.extensions[:format]
+                    when 'oauth2'
+                      require 'diesel/middleware/auth/oauth2'
+                      use Diesel::Middleware::Auth::OAuth2,
+                          id: Diesel::Utils::Inflections.underscore(name).to_sym,
+                          in: security_def.in,
+                          name: security_def.name
+                    when "basic"
+                      require "diesel/middleware/auth/basic"
+                      use Diesel::Middleware::Auth::Basic,
+                          id: Diesel::Utils::Inflections.underscore(name).to_sym
+                    else
+                      raise APIError, "Unsupported security definition: #{security_def.type}"
+                    end
                   end
                 end
 
@@ -106,14 +149,21 @@ module Diesel
                   param_class = Diesel::Utils::Inflections.constantize(param_class_name)
                   middleware_opts = {name: parameter.name}
                   if parameter.schema?
-                    unless schema = data_models[parameter.schema]
-                      raise APIError, "Unspecified schema: #{parameter.schema}"
+                    schema = parameter.schema
+                    if schema.kind_of? String
+                      schema = data_models[parameter.schema]
+                    end
+                    unless schema
+                      raise APIError, "Unspecified schema: #{parameter.schema}; parameter=#{parameter.name}"
                     end
                     middleware_opts[:schema] = schema
                   end
                   use param_class, middleware_opts
                 end
 
+                if consumes == "application/json"
+                  use Diesel::Middleware::ConvertJSONBody
+                end
               end
             end
           end

data/lib/diesel/api_group.rb

@@ -20,8 +20,9 @@ module Diesel
       @data_models = data_models
     end
 
-    def execute(options, endpoint, parameters)
-      RequestContext.new(options, self, endpoint, parameters).perform
+    def execute(options, endpoint, *parameters)
+      params = parameters.last || {}
+      RequestContext.new(options, self, endpoint, params).perform
     end
   end
 end

data/lib/diesel/middleware/auth/api_key.rb

@@ -8,19 +8,31 @@ module Diesel
           @id = options[:id]
           @in = options[:in]
           @name = options[:name]
+          @format = options[:format]
         end
 
         def call(env)
           context = env[:context]
-          value = context.options[@id]
+          value = format_value(context.options[@id])
           if @in == :header
             env[:request_headers][@name] = value
           elsif @in == :query
             env[:params][@name] = value
+          elsif @in == :body
+            env[:body] = if body = env[:body]
+              body.merge(@name => value)
+            else
+              { @name => value }
+            end
           end
           @app.call(env)
         end
 
+        protected
+          def format_value(val)
+            return val unless @format
+            @format % val
+          end
       end
     end
   end

data/lib/diesel/middleware/auth/basic.rb

@@ -0,0 +1,27 @@
+module Diesel
+  module Middleware
+    module Auth
+      class Basic
+
+        AUTHORIZATION_HEADER = 'Authorization'.freeze
+
+        def initialize(app, options)
+          @app = app
+          @id = options[:id]
+        end
+
+        def call(env)
+          context = env[:context]
+          auth_options = context.options[@id]
+          username = auth_options[:username]
+          password = auth_options[:password]
+          value = Base64.encode64([username, password].join(':'))
+          value.gsub!("\n", '')
+          env[:request_headers][AUTHORIZATION_HEADER] = "Basic #{value}"
+          @app.call(env)
+        end
+
+      end
+    end
+  end
+end

data/lib/diesel/middleware/auth/oauth2.rb

@@ -3,8 +3,8 @@ module Diesel
     module Auth
       class OAuth2
 
-        AUTHORIZATION_HEADER = 'Authorization'
-        AUTHORIZATION_HEADER_FORMAT = 'Bearer %s'
+        AUTHORIZATION_HEADER = 'Authorization'.freeze
+        AUTHORIZATION_HEADER_FORMAT = 'Bearer %s'.freeze
 
         def initialize(app, options)
           @app = app

data/lib/diesel/middleware/convert_json_body.rb

@@ -0,0 +1,15 @@
+module Diesel
+  module Middleware
+    class ConvertJSONBody
+      def initialize(app)
+        @app = app
+      end
+      def call(env)
+        @app.call(env)
+        if body = env[:body]
+          env[:body] = MultiJson.dump(body)
+        end
+      end
+    end
+  end
+end

data/lib/diesel/middleware/set_body_parameter.rb

@@ -4,7 +4,11 @@ module Diesel
   module Middleware
     class SetBodyParameter < SetParameterBase
       def apply_parameter_value(env, value)
-        env[:body] = value
+        env[:body] = if body = env[:body]
+          body.merge(value)
+        else
+          value
+        end
       end
     end
   end

data/lib/diesel/middleware/set_path_parameter.rb

@@ -10,7 +10,8 @@ module Diesel
       end
 
       def apply_parameter_value(env, value)
-        env[:url] = env[:url].gsub(@regex, value.to_s)
+        uri = env[:url]
+        uri.resource_path = uri.resource_path.gsub(@regex, value.to_s)
       end
     end
   end

data/lib/diesel/request_context.rb

@@ -12,6 +12,10 @@ module Diesel
     end
 
     def perform
+      if endpoint.url.base_host
+        endpoint.url.subdomain = options[:subdomain]
+      end
+
       env = {
         method: endpoint.request_method,
         url: endpoint.url,
@@ -20,6 +24,7 @@ module Diesel
         logger: logger,
         context: self
       }
+
       endpoint.middleware_stack.call(env)
       perform_request(env)
     end
@@ -46,7 +51,8 @@ module Diesel
 
     protected
       def perform_request(env)
-        HTTParty.send(env[:method], env[:url],
+        HTTParty.send(env[:method],
+                      env[:url].to_s,
                       headers: env[:request_headers],
                       query: env[:params],
                       body: env[:body])

data/lib/diesel/swagger/definition.rb

@@ -11,7 +11,7 @@ module Diesel
 
       hash :properties
 
-      def initialize(id)
+      def initialize(id = "<Inline>")
         super()
         @id = id
       end

data/lib/diesel/swagger/operation.rb

@@ -19,7 +19,9 @@ module Diesel
       list :parameters, validate: true
       list :responses, validate: true
       list :schemes
-      list :security, validate: true
+
+      hash :security_definitions, validate: true
+      hash :security, validate: true
 
       def initialize(id)
         super()

data/lib/diesel/swagger/parser.rb

@@ -18,32 +18,48 @@ module Diesel
         specification.external_docs = build_node(ExternalDocs, json['externalDocs'])
         specification.schemes = json['schemes']
         specification.produces = json['produces'] || []
-        specification.security_definitions = build_node_hash(SecurityDefinition, json, 'securityDefinitions')
-        specification.security = (json['security'] || {}).reduce({}) do |memo, (k,v)|
-          memo[k] = security = Security.new(k)
-          security.scopes = v
-          memo
-        end
+        specification.consumes = json['consumes'] || []
+        build_security_definition_hash(specification, json)
+        build_security_hash(specification, json)
         specification.paths = build_node_hash(Path, json, 'paths') do |path, path_json|
           [:get, :put, :post, :delete, :options, :head, :patch].each do |method|
             if op_json = path_json[method.to_s]
               op = build_node(Operation, op_json, constructor_args: [method])
               op.external_docs = build_node(ExternalDocs, op_json['externalDocs'])
-              op.parameters = build_node_list(Parameter, op_json, 'parameters')
+              op.parameters = build_node_list(Parameter, op_json, 'parameters') do |param, param_json|
+                if param_json["schema"] && param_json["schema"].kind_of?(Hash)
+                  schema_json = param_json["schema"]
+                  param.schema = build_node(Definition, schema_json)
+                end
+              end
+              build_security_definition_hash(specification, json)
+              build_security_hash(op, op_json)
               path.send("#{method}=".to_sym, op)
             end
           end
         end
         specification.definitions = build_node_hash(Definition, json, 'definitions') do |definition, def_json|
           definition.properties = build_node_hash(Property, def_json, 'properties') do |prop, prop_json|
-            prop.enum = prop_json['enum']
-            prop.items = prop_json['items']
+            prop.enum = prop_json["enum"]
+            prop.items = prop_json["items"]
           end
         end
         specification
       end
 
       protected
+        def build_security_hash(parent_node, json)
+          sec_json = json['security']
+          parent_node.security = (sec_json || {}).reduce({}) do |memo, (k,v)|
+            memo[k] = security = Security.new(k)
+            security.scopes = v
+            memo
+          end
+        end
+
+        def build_security_definition_hash(parent_node, json)
+          parent_node.security_definitions = build_node_hash(SecurityDefinition, json, 'securityDefinitions')
+        end
 
         def build_node(model_class, json, options = {})
           if json

data/lib/diesel/uri.rb

@@ -0,0 +1,36 @@
+module Diesel
+  class URI
+
+    components = [:scheme, :host, :base_host, :subdomain, :base_path, :resource_path]
+
+    attr_reader *components
+
+    components.each do |comp|
+      define_method "#{comp}=".to_sym do |v|
+        instance_variable_set("@#{comp}", v)
+        build_url
+      end
+    end
+
+    def to_s
+      build_url
+    end
+
+    protected
+
+      def build_url
+        host = if base_host && subdomain
+                 [subdomain, base_host].join('.')
+               else
+                 self.host
+               end
+        [
+          scheme,
+          '://',
+          host,
+          base_path,
+          resource_path
+        ].join('')
+      end
+  end
+end