diesel-api-dsl 0.0.1 → 0.1.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    YWYzZDNhNzk5OWE5MDgxOWM1MzE4MjZlNDg2YWFjMDUyNzlmNjNkOQ==
-  data.tar.gz: !binary |-
-    ODhkYmQ4ZDFjMTBjZjZiMTUxMDU4NTI4NjhkMzQ5NTUzODg5OGQxNA==
+SHA1:
+  metadata.gz: 4c09f2251953d171164fa4883b9aad83e9a1d7d9
+  data.tar.gz: 7c885dc69abd71c3e3c897e20bfcbf5ca141c166
 SHA512:
-  metadata.gz: !binary |-
-    ZDViYzZlNzlkOGYyYWRiZDY1ZmNhZTRlM2U2OWQwNmJkZmQzZmI5OGEwMTZh
-    OWZlZjExOTA4NjRiN2E0MjZiZmE5N2JiYzJjMjFkMGQ1NWI5ZTQ0OGM0YTZk
-    M2M5MTk3ZWRiYzk1YTIxNTQ3ZDU2NzQ3MjQ2YjNmNDYyYWQ1ZmQ=
-  data.tar.gz: !binary |-
-    NjhlOGZkZTg2ODhiYmNkYjQ5MmYwZjVjYTRjOWZkNjhhZTI5NjZlMTUyYzhj
-    NjlhMzkyNTljZDQ1Y2IzZWM1YmRmODVlNzdlNDBkMmNjZWYyZmJlNjdhMzU1
-    MDJiYjk2NDFhNThhNTkzZTIwODRkYjE1Nzc4MTJhODgyZjQ4Yzc=
+  metadata.gz: 8347d51bde9ca019c77d813ce453199603736228b00e69294bc4af670959101b978218d39bf18ef1f7b04afdfe2483d7b2fae19eb9bde26f51c528592d442496
+  data.tar.gz: b67551247eab1cde0aa09fb14f34f60e1d6e4824d1d4016eae690d3f34d92662b1d2e738e032a81b33295151a59613e021ba43d5ae0d7135c857093f9d86f1ba

data/Rakefile

@@ -1 +1,6 @@
 require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/diesel.gemspec

@@ -20,6 +20,10 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake", "~> 10.1"
+  spec.add_development_dependency "rspec", "~> 3.0.0"
+  spec.add_development_dependency "vcr", "~> 2.9.0"
+  spec.add_development_dependency "webmock", "~> 1.20.0"
 
   spec.add_dependency "httparty", "~> 0.12"
+  spec.add_dependency "multi_json", "~> 1.10.1"
 end

data/lib/diesel.rb

@@ -1,10 +1,18 @@
-require "diesel/version"
-require 'diesel/dsl'
+require 'diesel/version'
+require 'diesel/swagger/parser'
 require 'diesel/api_builder'
 
+
 module Diesel
-  def self.load_api(name)
-    profile = DSL.load_profile(name, "#{name}.rb")
-    Diesel::APIBuilder.new(profile).build
+  def self.parse_specification(path)
+    Diesel::Swagger::Parser.new.parse(File.read(path))
+  end
+
+  def self.build_api(specification)
+    Diesel::APIBuilder.new(specification).build
+  end
+
+  def self.load_api(path)
+    build_api(parse_specification(path))
   end
 end

data/lib/diesel/api_base.rb

@@ -0,0 +1,27 @@
+require 'diesel/api_group'
+
+module Diesel
+  class APIError < Exception; end
+end
+
+module Diesel
+  class APIBase
+    attr_accessor :logger, :options
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def logger=(logger)
+      @logger = logger
+      self.class.api_groups.each { |g| g.logger = logger }
+    end
+
+    class << self
+      def api_groups; @api_groups ||= []; end
+      def api_groups=(api_groups)
+        @api_groups = api_groups
+      end
+    end
+  end
+end

data/lib/diesel/api_builder.rb

@@ -1,61 +1,125 @@
-require 'diesel/action/http'
-require 'diesel/complex_type_builder'
-require 'diesel/container_builder'
+require 'diesel/api_error'
+require 'diesel/utils/inflections'
+require 'diesel/api_base'
+require 'diesel/data_model'
+
+require 'diesel/middleware/debug'
+require 'diesel/middleware/set_header'
 
 module Diesel
   class APIBuilder
-    attr_reader :profile
+    include Diesel::Utils::Inflections
+
+    attr_reader :specification
 
-    def initialize(profile)
-      @profile = profile
+    def initialize(specification)
+      @specification = specification
     end
 
     def build
+      validate!
+
       create_api_class.tap do |klass|
-        klass.base_path = profile.base_path
-        unless profile.authorizations.empty?
-          klass.authenticator = Diesel::Authenticator.build(profile.authorizations)
-        end
-        build_endpoints(klass)
-        build_models(klass)
+        klass.api_groups = [
+          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)
+              end
+            end
+          end
+        ]
+
         #Diesel.const_set create_class_name(name), klass
       end
     end
 
     protected
-      def global_filters
-        @global_filters ||= profile.parameters.map { |p| Diesel::Action::HTTP::ParameterFilter.new(p) }
+
+      def validate!
+        api_errors = specification.collect_errors
+        if api_errors.any?
+          raise APIError, "API specification is invalid: \n #{api_errors.join("\n")}"
+        end
       end
 
       def create_api_class
-        Class.new(Diesel::API)
+        Class.new(Diesel::APIBase)
+      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('')
       end
 
-      def build_endpoints(klass)
-        klass.endpoints = profile.resources.map do |resource|
-          resource.operations.map do |operation|
-            Diesel::Endpoint.new(resource.path).tap do |endpoint|
-              action = Diesel::Action::HTTP.new
-              action.request_method = operation.method
-              action.filters.concat(global_filters)
-              action.filters.concat(operation.parameters.map { |p| Diesel::Action::HTTP::ParameterFilter.new(p) })
-              endpoint.action = action
-              klass.__send__(:define_method, operation.nickname) do |parameters|
-                execute(endpoint, parameters)
+      def build_endpoints
+        spec = specification
+        data_models = self.data_models
+
+        spec.paths.map do |path, path_model|
+          path_model.operations_map.map do |(method, operation)|
+            endpoint_name = underscore(operation.operation_id)
+            endpoint_url  = build_endpoint_url(spec, path)
+
+            Diesel::Endpoint.new(endpoint_name, endpoint_url, method).tap do |endpoint|
+              endpoint.config_middleware do
+                use Diesel::Middleware::Debug
+
+                if spec.produces.any?
+                  use Diesel::Middleware::SetHeader, 'Content-Type' => spec.produces.first
+                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
+                  else
+                    raise APIError, "Unsupported security definition: #{security_def.type}"
+                  end
+                end
+
+                operation.parameters.each do |parameter|
+                  param_class_path = "diesel/middleware/set_#{parameter.in}_parameter"
+                  require param_class_path
+                  param_class_name = Diesel::Utils::Inflections.camelize(param_class_path)
+                  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}"
+                    end
+                    middleware_opts[:schema] = schema
+                  end
+                  use param_class, middleware_opts
+                end
+
               end
             end
           end
         end.flatten.compact
       end
 
-      def build_models(klass)
-        klass.models = profile.models.map do |model|
-          if model.is_a? Diesel::Profile::Container
-            Diesel::ContainerBuilder.new(model)
-          else
-            Diesel::ComplexTypeBuilder.new(model)
-          end
-        end.reduce({}) { |m,b| m[b.model.name] = b; m }
+      def data_models
+        @data_models ||= build_data_models
+      end
+
+      def build_data_models
+        specification.definitions.reduce({}) do |m, (name, definition)|
+          m[name] = DataModel.new(definition)
+          m
+        end
       end
 
       def create_class_name(name)

data/lib/diesel/api_error.rb

@@ -0,0 +1,3 @@
+module Diesel
+  class APIError < Exception; end
+end

data/lib/diesel/api_group.rb

@@ -0,0 +1,27 @@
+require 'diesel/request_context'
+require 'diesel/endpoint'
+
+module Diesel
+  class APIGroup
+    attr_accessor :logger
+
+    def endpoints; @endpoints ||= []; end
+    def endpoints=(endpoints)
+      @endpoints = endpoints
+    end
+
+    def authenticators; @authenticators; end
+    def authenticators=(auth)
+      @authenticators = auth
+    end
+
+    def data_models; @data_models ||= {}; end
+    def data_models=(data_models)
+      @data_models = data_models
+    end
+
+    def execute(options, endpoint, parameters)
+      RequestContext.new(options, self, endpoint, parameters).perform
+    end
+  end
+end

data/lib/diesel/data_model.rb

@@ -0,0 +1,24 @@
+require 'multi_json'
+
+module Diesel
+  class DataModel
+    attr_reader :definition
+
+    def initialize(definition)
+      @definition = definition
+    end
+
+    def build(parameter_name, env)
+      context = env[:context]
+      h = context.get_attribute(parameter_name)
+      return nil unless h
+
+      json = definition.properties.reduce({}) do |m, (name, property)|
+        name = name.to_sym
+        m[name] = h[name] if h[name]; m
+      end
+
+      MultiJson.dump(json)
+    end
+  end
+end

data/lib/diesel/endpoint.rb

@@ -1,43 +1,25 @@
+require 'diesel/middleware_builder'
+require 'diesel/middleware_stack'
+
 module Diesel
   class Endpoint
-    attr_reader :path
-    attr_accessor :action
+    attr_reader :name, :url, :request_method
 
-    def initialize(path)
-      @path = path
+    def initialize(name, url, request_method)
+      @name, @url, @request_method = name, url, request_method
     end
 
-    def perform(context)
-      raise 'action required for endpoint' unless action
-
-      assert_attributes(context)
-
-      #unless action.accept? context
-      #  raise 'endpoint does not support this context'
-      #end
-
-      action.perform(context)
+    def middlewares
+      @middlewares ||= []
     end
 
-    private
-      def assert_attributes(context)
-        #if attributes.nil?
-        #  unless context.attributes.empty?
-        #    raise ArgumentError, "invalid attributes #{atts.keys.join(', ')}"
-        #  end
-        #  return
-        #end
-
-        #invalid_atts = context.attributes.keys.map!(&:intern) - attributes.keys
-        #unless invalid_atts.empty?
-        #  raise ArgumentError, "invalid attributes #{invalid_atts.join(', ')}"
-        #end
+    def middleware_stack
+      @middleware_stack ||= MiddlewareStack.new(middlewares)
+    end
 
-        #attributes.each do |attr_name, options|
-        #  if options[:required] and context.attributes[attr_name].nil?
-        #    raise ArgumentError, "require attribute: #{attr_name}"
-        #  end
-        #end
-      end
+    def config_middleware(&block)
+      builder = MiddlewareBuilder.new(middlewares)
+      builder.build(&block)
+    end
   end
 end

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

@@ -0,0 +1,27 @@
+module Diesel
+  module Middleware
+    module Auth
+      class APIKey
+
+        def initialize(app, options)
+          @app = app
+          @id = options[:id]
+          @in = options[:in]
+          @name = options[:name]
+        end
+
+        def call(env)
+          context = env[:context]
+          value = context.options[@id]
+          if @in == :header
+            env[:request_headers][@name] = value
+          elsif @in == :query
+            env[:params][@name] = value
+          end
+          @app.call(env)
+        end
+
+      end
+    end
+  end
+end

data/lib/diesel/middleware/debug.rb

@@ -0,0 +1,20 @@
+module Diesel
+  module Middleware
+    class Debug
+      def initialize(app)
+        @app = app
+      end
+      def call(env)
+        @app.call(env)
+        logger = env[:logger]
+        if logger && logger.debug?
+          logger.debug("Request Method: #{env[:method]}")
+          logger.debug("URL: #{env[:url]}")
+          logger.debug("Request Headers: #{env[:request_headers].inspect}")
+          logger.debug("Params: #{env[:params].inspect}")
+          logger.debug("Body: #{env[:body]}")
+        end
+      end
+    end
+  end
+end

data/lib/diesel/middleware/set_body_parameter.rb

@@ -0,0 +1,11 @@
+require 'diesel/middleware/set_parameter_base'
+
+module Diesel
+  module Middleware
+    class SetBodyParameter < SetParameterBase
+      def apply_parameter_value(env, value)
+        env[:body] = value
+      end
+    end
+  end
+end

data/lib/diesel/middleware/set_header.rb

@@ -0,0 +1,15 @@
+module Diesel
+  module Middleware
+    class SetHeader
+      def initialize(app, headers)
+        @app = app
+        @headers = headers
+      end
+
+      def call(env)
+        env[:request_headers].merge!(@headers)
+        @app.call(env)
+      end
+    end
+  end
+end