diesel-api-dsl 0.0.1 → 0.1.0

data/lib/diesel/middleware/set_parameter_base.rb

@@ -0,0 +1,33 @@
+module Diesel
+  module Middleware
+    class SetParameterBase
+
+      def initialize(app, options)
+        @app = app
+        @name = options[:name]
+        @schema = options[:schema]
+      end
+
+      def call(env)
+        value = find_parameter_value(env)
+        apply_parameter_value(env, value)
+        @app.call(env)
+      end
+
+      protected
+
+        def find_parameter_value(env)
+          if @schema
+            @schema.build(@name, env)
+          else
+            context = env[:context]
+            context.get_attribute(@name)
+          end
+        end
+
+        def apply_parameter_value(env, value)
+          raise NotImplementedError
+        end
+    end
+  end
+end

data/lib/diesel/middleware/set_path_parameter.rb

@@ -0,0 +1,17 @@
+require 'diesel/middleware/set_parameter_base'
+
+module Diesel
+  module Middleware
+    class SetPathParameter < SetParameterBase
+
+      def initialize(app, options)
+        super
+        @regex = Regexp.new(Regexp.quote("{#{@name}}"))
+      end
+
+      def apply_parameter_value(env, value)
+        env[:url] = env[:url].gsub(@regex, value.to_s)
+      end
+    end
+  end
+end

data/lib/diesel/middleware/set_query_parameter.rb

@@ -0,0 +1,13 @@
+require 'diesel/middleware/set_parameter_base'
+
+module Diesel
+  module Middleware
+    class SetQueryParameter < SetParameterBase
+      def apply_parameter_value(env, value)
+        unless value.nil?
+          env[:params][@name] = value
+        end
+      end
+    end
+  end
+end

data/lib/diesel/middleware_builder.rb

@@ -0,0 +1,15 @@
+module Diesel
+  class MiddlewareBuilder
+    def initialize(middlewares)
+      @middlewares = middlewares
+    end
+
+    def build(&block)
+      instance_eval(&block)
+    end
+
+    def use(middleware_klass, options = {})
+      @middlewares << [middleware_klass, options]
+    end
+  end
+end

data/lib/diesel/middleware_stack.rb

@@ -0,0 +1,21 @@
+module Diesel
+  class MiddlewareStack
+
+    def initialize(middlewares)
+      cur = ->(env){}
+      middlewares.reverse.each do |(klass, options)|
+        cur = if klass.instance_method(:initialize).arity == 1
+          klass.new(cur)
+        else
+          klass.new(cur, options)
+        end
+      end
+      @first = cur
+    end
+
+    def call(env)
+      @first.call(env)
+    end
+
+  end
+end

data/lib/diesel/request_context.rb

@@ -1,30 +1,55 @@
+require 'httparty'
+require 'diesel/utils/inflections'
+
 module Diesel
   class RequestContext
-    attr_reader :api, :endpoint, :attributes
+    include Diesel::Utils::Inflections
+
+    attr_reader :options, :group, :endpoint, :attributes
 
-    def initialize(api, endpoint, attributes)
-      @api, @endpoint, @attributes = api, endpoint, attributes
+    def initialize(options, group, endpoint, attributes)
+      @options, @group, @endpoint, @attributes = options, group, endpoint, attributes
     end
 
-    def logger
-      api.logger
+    def perform
+      env = {
+        method: endpoint.request_method,
+        url: endpoint.url,
+        params: {},
+        request_headers: {},
+        logger: logger,
+        context: self
+      }
+      endpoint.middleware_stack.call(env)
+      perform_request(env)
     end
 
-    def get_attribute(name)
-      name = name.to_sym
-      attributes[name]
+    def authenticator
+      group.authenticator
     end
 
     def endpoint_url
-      url = api.class.base_path.dup
-      url << "/" unless url =~ /\/$/
-      endpoint_path = endpoint.path
-      url << (endpoint_path =~ /^\// ? endpoint_path[1..-1] : endpoint_path)
-      url
+      endpoint.url
     end
 
-    def perform
-      endpoint.perform(self)
+    def logger
+      group.logger
     end
+
+    def get_attribute(name)
+      name = name.to_sym
+      unless attributes.has_key?(name)
+        name = underscore(name).to_sym
+      end
+      attributes[name]
+    end
+
+    protected
+      def perform_request(env)
+        HTTParty.send(env[:method], env[:url],
+                      headers: env[:request_headers],
+                      query: env[:params],
+                      body: env[:body])
+      end
   end
 end

data/lib/diesel/swagger/data_type_field.rb

@@ -0,0 +1,25 @@
+require 'diesel/swagger/node'
+
+module Diesel
+  module Swagger
+    class DataTypeField < Node
+      attribute :type, symbolize: true
+      attribute :format
+      attribute :default_value
+      attribute :multiple_of
+      attribute :maximum
+      attribute :exclusive_maximum, type: :boolean
+      attribute :minimum
+      attribute :exclusive_minimum, type: :boolean
+      attribute :max_length
+      attribute :min_length
+      attribute :pattern
+      attribute :max_items
+      attribute :min_items
+      attribute :unique_items, type: :boolean
+
+      list :enum
+      list :items
+    end
+  end
+end

data/lib/diesel/swagger/definition.rb

@@ -0,0 +1,12 @@
+require 'diesel/swagger/node'
+require 'diesel/swagger/property'
+
+module Diesel
+  module Swagger
+    class Definition < Node
+      attribute :required
+      attribute :discriminator
+      hash :properties
+    end
+  end
+end

data/lib/diesel/swagger/external_docs.rb

@@ -0,0 +1,10 @@
+require 'diesel/swagger/node'
+
+module Diesel
+  module Swagger
+    class ExternalDocs < Node
+      attribute :description
+      attribute :url
+    end
+  end
+end

data/lib/diesel/swagger/info.rb

@@ -0,0 +1,14 @@
+require 'diesel/swagger/node'
+
+module Diesel
+  module Swagger
+    class Info < Node
+      attribute :title
+      attribute :description
+      attribute :terms_of_service
+      attribute :contact
+      attribute :license
+      attribute :version
+    end
+  end
+end

data/lib/diesel/swagger/node.rb

@@ -0,0 +1,140 @@
+require 'diesel/utils/inflections'
+
+module Diesel
+  module Swagger
+    class Node
+      include Diesel::Utils::Inflections
+
+      class << self
+        def inherited(base)
+          base.instance_variable_set(:@attribute_names, attribute_names.dup)
+          base.instance_variable_set(:@list_names, list_names.dup)
+          base.instance_variable_set(:@hash_names, hash_names.dup)
+        end
+
+        def attribute_names
+          @attribute_names || []
+        end
+
+        def list_names
+          @list_names || []
+        end
+
+        def hash_names
+          @hash_names || []
+        end
+
+        def attribute(name, options = {})
+          name = name.to_sym
+          (@attribute_names ||= []) << name
+          attr_accessor name
+          if options[:type] == :boolean
+            define_method("#{name}?".to_sym) do
+              !!send(name)
+            end
+          elsif options[:symbolize]
+            define_method("#{name}=".to_sym) do |value|
+              instance_variable_set("@#{name}".to_sym, value.nil? ? nil : value.to_sym)
+            end
+          end
+          (@validates_children ||= []) << name if options[:validate]
+        end
+
+        def list(name, options = {})
+          attr_accessor name
+          (@list_names ||= []) << name
+          (@validates_children ||= []) << name if options[:validate]
+        end
+
+        def hash(name, options = {})
+          attr_accessor name
+          (@hash_names ||= []) << name
+          (@validates_children ||= []) << name if options[:validate]
+        end
+
+        def collect_errors(node, all_errors = [])
+          if @validates_children
+            @validates_children.each do |name|
+              if attr_val = node.send(name)
+                if @hash_names && @hash_names.include?(name)
+                  attr_val.each_pair { |k,v| v.collect_errors(all_errors) }
+
+                elsif @list_names && @list_names.include?(name)
+                  attr_val.each { |v| v.collect_errors(all_errors) }
+
+                else
+                  unless attr_val.respond_to? :collect_errors
+                    raise "Expecting #{name} to be a node"
+                  end
+                  attr_val.collect_errors(all_errors)
+                end
+              end
+            end
+          end
+          all_errors
+        end
+      end
+
+      attr_reader :errors
+
+      def initialize
+        @errors = []
+      end
+
+      def validate
+      end
+
+      def valid?
+        validate
+        @errors.any?
+      end
+
+      def collect_errors(all_errors = [])
+        validate; all_errors.concat(errors)
+        self.class.collect_errors(self, all_errors)
+      end
+
+      def serializable_hash
+        h = {}
+
+        if self.class.attribute_names
+          self.class.attribute_names.each do |nm|
+            if v = __send__(nm)
+              h[camelize(nm, false)] = value_or_serializable_hash(v)
+            end
+          end
+        end
+
+        if self.class.list_names
+          self.class.list_names.each do |nm|
+            if arr = __send__(nm)
+              result = arr.map do |v|
+                value_or_serializable_hash(v)
+              end
+              h[camelize(nm, false)] = result if result.any?
+            end
+          end
+        end
+
+        if self.class.hash_names
+          self.class.hash_names.each do |nm|
+            if value_hash = __send__(nm)
+              result = value_hash.reduce({}) do |m,(k,v)|
+                m[k] = value_or_serializable_hash(v); m
+              end
+              h[camelize(nm, false)] = result if result.any?
+            end
+          end
+        end
+
+        h
+      end
+
+      private
+
+        def value_or_serializable_hash(v)
+          v.respond_to?(:serializable_hash) ? v.serializable_hash : v
+        end
+    end
+  end
+end

data/lib/diesel/swagger/operation.rb

@@ -0,0 +1,22 @@
+require 'diesel/swagger/node'
+require 'diesel/swagger/parameter'
+
+module Diesel
+  module Swagger
+    class Operation < Node
+      attribute :summary
+      attribute :description
+      attribute :external_docs, validate: true
+      attribute :operation_id
+      attribute :deprecated
+
+      list :tags
+      list :consumes
+      list :produces
+      list :parameters, validate: true
+      list :responses, validate: true
+      list :schemes
+      list :security, validate: true
+    end
+  end
+end

data/lib/diesel/swagger/parameter.rb

@@ -0,0 +1,32 @@
+require 'diesel/swagger/data_type_field'
+
+module Diesel
+  module Swagger
+    class Parameter < DataTypeField
+      VALID_TYPES = %w(
+        string
+        number
+        integer
+        boolean
+        array
+        file
+      )
+
+      attribute :name
+      attribute :in, symbolize: true
+      attribute :description
+      attribute :required, type: :boolean
+      attribute :schema
+
+      def schema?
+        !!schema
+      end
+
+      def validate
+        if type == :path && !required?
+          errors << "Path parameters must be defined as required"
+        end
+      end
+    end
+  end
+end