diesel-api-dsl 0.0.1 → 0.1.0

data/lib/diesel/action/http.rb

@@ -1,92 +0,0 @@
-require 'httparty'
-
-module Diesel
-  module Action
-    class HTTP
-      attr_accessor :filters, :request_method
-
-      def filters
-        @filters ||= []
-      end
-
-      def perform(context)
-        req = Request.new(request_method, context.endpoint_url)
-        [context.api.class.authenticator].concat(filters).each do |filter|
-          filter.apply_filter(req, context)
-        end
-
-        if context.logger && context.logger.debug?
-          context.logger.debug("Request Method: #{request_method}")
-          context.logger.debug("URL: #{req.url}")
-          context.logger.debug("Options: #{req.http_options.inspect}")
-        end
-
-        req.perform
-      end
-
-      class Request
-        attr_reader :method, :headers, :query
-        attr_accessor :url, :body
-
-        def initialize(method, url)
-          @method = method
-          @url = url
-          @headers = {} 
-          @query = {}
-        end
-
-        def perform
-          HTTParty.send(method, url, http_options)
-        end
-
-        def http_options
-          {headers: headers, query: query, body: body}
-        end
-
-        def add_query_parameter(name, value)
-          @url = if url.index('?')
-            "#{url}&#{URI.escape(name)}=#{URI.escape(value)}"
-          else
-            "#{url}?#{URI.escape(name)}=#{URI.escape(value)}"
-          end
-        end
-      end
-
-      class ParameterFilter
-        attr_reader :parameter
-
-        def initialize(parameter)
-          @parameter = parameter
-        end
-
-        def apply_filter(request, context)
-          v = find_parameter_value(context)
-          case parameter.param_type
-          when :query
-            request.query[parameter.name] = v
-          when :path
-            request.url = request.url.gsub(path_regex, v.to_s)
-          when :body
-            request.body = v
-          when :header
-            request.headers[parameter.name] = v
-          end
-        end
-
-        def find_parameter_value(context)
-          if parameter.complex?
-            model = context.api.class.models[parameter.data_type]
-            model.build(parameter, context)
-          else
-            parameter.value || context.get_attribute(parameter.name)
-          end
-        end
-
-        protected
-          def path_regex
-            Regexp.new(Regexp.quote("{#{parameter.name}}"))
-          end
-      end
-    end
-  end
-end

data/lib/diesel/api.rb

@@ -1,33 +0,0 @@
-module Diesel
-  class API
-    attr_accessor :logger
-
-    class << self
-      def base_path; @base_path; end
-      def base_path=(base_path)
-        @base_path = base_path
-      end
-
-      def endpoints; @endpoints ||= []; end
-      def endpoints=(endpoints)
-        @endpoints = endpoints
-      end
-
-      def authenticator; @authenticator; end
-      def authenticator=(auth)
-        @authenticator = auth
-        @authenticator.activate(self)
-      end
-
-      def models; @models ||= {}; end
-      def models=(models)
-        @models = models
-      end
-    end
-
-    protected
-      def execute(endpoint, options)
-        RequestContext.new(self, endpoint, options).perform
-      end
-  end
-end

data/lib/diesel/auth/api_key.rb

@@ -1,39 +0,0 @@
-require 'diesel/auth/base'
-
-module Diesel
-  module Auth
-    class APIKey < Base
-      attr_accessor :nickname, :pass_as, :name
-
-      def self.build(authorization)
-        auth = new
-        auth.name     = authorization.name
-        auth.nickname = authorization.nickname
-        auth.pass_as  = authorization.pass_as
-        auth
-      end
-
-      def activate(api_class)
-        header_name = name
-        api_class.__send__(:define_method, "#{nickname}=".to_sym) do |header_value|
-            (@_auth_http_headers ||= {})[header_name] = header_value
-          end
-        api_class.send(:include, InstanceMethods)
-      end
-
-      def apply_filter(request, context)
-        if pass_as.to_sym == :header
-          request.headers[name] = context.api.auth_http_headers[name]
-        elsif pass_as.to_sym == :query_parameter
-          request.add_query_parameter(name, context.api.auth_http_headers[name])
-        end
-      end
-
-      module InstanceMethods
-        def auth_http_headers
-          @_auth_http_headers
-        end
-      end
-    end
-  end
-end

data/lib/diesel/auth/base.rb

@@ -1,8 +0,0 @@
-module Diesel
-  module Auth
-    class Base
-      attr_accessor :name
-    end
-  end
-end
-

data/lib/diesel/auth/oauth2.rb

@@ -1,13 +0,0 @@
-module Diesel
-  module Auth
-    class OAuth2
-      def self.activate(api_class, options)
-        api_class.send :attr_accessor, :access_token
-      end
-
-      def self.append_authentication(context, http_options)
-        (http_options[:headers] ||= {})['Authorization'] = "Bearer #{context.api.access_token}"
-      end
-    end
-  end
-end

data/lib/diesel/authenticator.rb

@@ -1,35 +0,0 @@
-module Diesel
-  class Authenticator
-    attr_reader :strategies
-
-    def self.build(authorizations)
-      strategies = authorizations.map do |auth|
-        case auth.type
-        when :oauth2
-          require 'diesel/auth/oauth2'
-          Diesel::Auth::OAuth2.build(auth)
-        when :api_key
-          require 'diesel/auth/api_key'
-          Diesel::Auth::APIKey.build(auth)
-        else
-          raise "Unsupported authentication: #{auth.type}"
-        end
-      end
-
-      new(strategies)
-    end
-
-    def initialize(strategies)
-      @strategies = strategies
-    end
-
-    def activate(api_class)
-      @strategies.each { |s| s.activate(api_class) }
-    end
-
-    def apply_filter(request, context)
-      @strategies.each { |s| s.apply_filter(request, context) }
-    end
-  end
-end
-

data/lib/diesel/complex_type_builder.rb

@@ -1,24 +0,0 @@
-require 'multi_json'
-require 'diesel/model_builder'
-
-module Diesel
-  class ComplexTypeBuilder < ModelBuilder
-    def build(parameter, context)
-      h = context.get_attribute(parameter.name)
-      unless h
-        if parameter.required?
-          raise "Missing required parameter #{parameter.name}"
-        else
-          return nil
-        end
-      end
-      if model.required.detect { |r| h[r].nil? }
-        raise "Missing required value #{r} in #{parameter.name}"
-      end
-      json = model.properties.reduce({}) do |m, property|
-        m[property.name] = h[property.name] if h[property.name]; m
-      end
-      MultiJson.dump(json)
-    end
-  end
-end

data/lib/diesel/container_builder.rb

@@ -1,6 +0,0 @@
-require 'diesel/model_builder'
-
-module Diesel
-  class ContainerBuilder < ModelBuilder
-  end
-end

data/lib/diesel/dsl.rb

@@ -1,239 +0,0 @@
-require 'diesel/profile'
-require 'diesel/endpoint'
-require 'diesel/request_context'
-
-module Diesel
-  module DSL
-    def self.load_profile(name, filename)
-      loader = DSL::Loader.new(name)
-      loader.instance_eval File.read(filename), filename
-      loader.profile
-    end
-
-    class LoaderBase
-      attr_reader :object
-
-      class << self
-        def attribute(name)
-          define_method(name) do |val|
-            @object.__send__("#{name}=".to_sym, val)
-          end
-        end
-      end
-
-      attribute :description
-    end
-
-    module Parameters
-      def header(*args, &block)
-        ParameterLoader.load_parameters(@object, :header, *args, &block)
-      end
-
-      def body(*args, &block)
-        ParameterLoader.load_parameters(@object, :body, *args, &block)
-      end
-
-      def parameter(*args, &block)
-        ParameterLoader.load_parameters(@object, nil, *args, &block)
-      end
-    end
-
-    #class PartLoader
-    #  attr_reader :part
-
-    #  def initialize(*args)
-    #    @part = Part.new(*args)
-    #  end
-
-    #  def header name, value
-    #    @part.set_header(name, value)
-    #  end
-
-    #  def body value
-    #    @part.body = value
-    #  end
-    #end
- 
-    #class ActionLoader < PartLoader
-    #  attr_reader :action
-
-    #  def initialize(endpoint, method, options)
-    #    @part = @action = Action.new(endpoint, method, options)
-    #  end
-
-    #  def multipart(options = {}, &block)
-    #    loader = MultipartLoader.new(options)
-    #    loader.instance_eval(&block)
-    #    action.multipart = loader.multipart
-    #  end
-    #end
-
-    #class MultipartLoader
-    #  attr_reader :multipart
-
-    #  def initialize(options)
-    #    @multipart = Multipart.new(options)
-    #  end
-
-    #  def part(*args, &block)
-    #    loader = PartLoader.new(*args)
-    #    loader.instance_eval(&block) if block
-    #    multipart.add_part(loader.part)
-    #  end
-    #end
-
-    class AuthorizationLoader < LoaderBase
-      attribute :name
-      attribute :nickname
-      attribute :pass_as
-      attribute :type
-
-      def initialize
-        @object = Diesel::Profile::Authorization.new
-      end
-    end
-
-    class PropertyLoader < LoaderBase
-      attribute :name
-
-      def initialize
-        @object = Diesel::Profile::Property.new
-      end
-
-      def enum(*values)
-        @object.enum = values
-      end
-    end
-
-    class ComplexTypeLoader < LoaderBase
-      attribute :name
-
-      def initialize
-        @object = Diesel::Profile::ComplexType.new
-      end
-
-      def required(*required_properties)
-        @object.required = required_properties
-      end
-
-      def property(name, &block)
-        l = PropertyLoader.new
-        l.name(name)
-        l.instance_eval(&block) if block
-        @object.properties << l.object
-      end
-    end
-
-    class OperationLoader < LoaderBase
-      include Parameters
-
-      attribute :nickname
-      attribute :reference_url
-      attribute :method
-
-      def initialize
-        @object = Diesel::Profile::Operation.new
-      end
-    end
-
-    class ResourceLoader < LoaderBase
-      def initialize(path)
-        @object = Diesel::Profile::Resource.new(path)
-      end
-
-      def operation(nickname, &block)
-        l = OperationLoader.new
-        l.nickname(nickname)
-        l.instance_eval(&block)
-        @object.operations << l.object
-      end
-    end
-
-    class ParameterLoader < LoaderBase
-      attribute :param_type
-      attribute :name
-      attribute :value
-      attribute :required
-      attribute :data_type
-
-      def initialize
-        @object = Diesel::Profile::Parameter.new
-      end
-
-      def required(required = true)
-        @object.required = required
-      end
-
-      def self.load_parameters(target, param_type, *args, &block)
-        if args.first.is_a?(::Hash)
-          args.shift.each_pair do |name, value|
-            l = new
-            l.param_type(param_type)
-            l.name(name)
-            l.value(value)
-            target.parameters << l.object
-          end
-        else
-          l = new
-          l.param_type(param_type)
-          l.name(args.first)
-          l.instance_eval(&block) if block
-          target.parameters << l.object
-        end
-      end
-    end
-
-    class APILoader < LoaderBase
-      include Parameters
-
-      attribute :api_version
-      attribute :base_path
-
-      def initialize(api_profile)
-        @object = api_profile
-      end
-
-      def resource(path, &block)
-        l = ResourceLoader.new(path)
-        l.instance_eval(&block)
-        @object.resources << l.object
-      end
-
-      def complex_type(name, &block)
-        l = ComplexTypeLoader.new
-        l.name(name)
-        l.instance_eval(&block)
-        @object.models << l.object
-      end
-
-      def container_type(name, &block)
-        l = ContainerTypeLoader.new
-        l.name(name)
-        l.instance_eval(&block)
-        @object.models << l.object
-      end
-
-      def api_key(name, &block)
-        l = AuthorizationLoader.new
-        l.name(name)
-        l.type(:api_key)
-        l.instance_eval(&block)
-        @object.authorizations << l.object
-      end
-    end
-
-    class Loader
-      attr_reader :name
-      attr_reader :profile
-
-      def initialize(name)
-        @name = name
-      end
-
-      def apis(&block)
-        @profile = Profile::API.new(name)
-        APILoader.new(@profile).instance_eval(&block)
-      end
-    end
- end
-end