diesel-api-dsl 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YWYzZDNhNzk5OWE5MDgxOWM1MzE4MjZlNDg2YWFjMDUyNzlmNjNkOQ==
+  data.tar.gz: !binary |-
+    ODhkYmQ4ZDFjMTBjZjZiMTUxMDU4NTI4NjhkMzQ5NTUzODg5OGQxNA==
+SHA512:
+  metadata.gz: !binary |-
+    ZDViYzZlNzlkOGYyYWRiZDY1ZmNhZTRlM2U2OWQwNmJkZmQzZmI5OGEwMTZh
+    OWZlZjExOTA4NjRiN2E0MjZiZmE5N2JiYzJjMjFkMGQ1NWI5ZTQ0OGM0YTZk
+    M2M5MTk3ZWRiYzk1YTIxNTQ3ZDU2NzQ3MjQ2YjNmNDYyYWQ1ZmQ=
+  data.tar.gz: !binary |-
+    NjhlOGZkZTg2ODhiYmNkYjQ5MmYwZjVjYTRjOWZkNjhhZTI5NjZlMTUyYzhj
+    NjlhMzkyNTljZDQ1Y2IzZWM1YmRmODVlNzdlNDBkMmNjZWYyZmJlNjdhMzU1
+    MDJiYjk2NDFhNThhNTkzZTIwODRkYjE1Nzc4MTJhODgyZjQ4Yzc=

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.swp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in diesel.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Calvin Yu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Diesel
+
+Create API Clients From an DSL
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'diesel'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install diesel
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/apis/pivotal_tracker.rb

@@ -0,0 +1,55 @@
+apis do
+  description "PivotalTracker API v5"
+  api_version "5"
+  base_path "https://www.pivotaltracker.com/services/v5"
+
+  api_key "X-TrackerToken" do
+    nickname :api_token
+    pass_as :header
+  end
+
+  header "Content-Type" => "application/json"
+
+  resource "projects/{project_id}/stories" do
+    description "Operations on stories"
+
+    operation :create_story do
+      reference_url "https://www.pivotaltracker.com/help/api/rest/v5#projects_project_id_stories_post"
+      method :post
+
+      parameter "project_id" do
+        param_type :path
+        required
+      end
+
+      body "story" do
+        data_type "NewStory"
+        required
+      end
+    end
+  end
+
+  complex_type "NewStory" do
+    required :name 
+    property :cl_numbers
+    property :current_state do
+      enum :accepted, :delivered, :finished, :started, :rejected, :unstarted, :unscheduled
+    end
+    property :external_id
+    property :deadline
+    property :description
+    property :estimate
+    property :integration_id
+    property :planned_iteration_number
+    property :requested_by_id
+    property :accepted_at
+    property :before_id
+    property :created_at
+    property :after_id
+    property :name
+    property :story_type do
+      enum :feature, :bug, :chore, :release
+    end
+  end
+
+end

data/apis/slack.rb

@@ -0,0 +1,36 @@
+apis do
+  description "Slack"
+  api_version "1"
+  base_path "https://scoutmob.slack.com/services/hooks"
+
+  api_key "token" do
+    nickname :api_token
+    pass_as :query_parameter
+  end
+
+  header "Content-Type" => "application/json"
+
+  resource "incoming-webhook" do
+    description "Incoming Webhook"
+
+    operation :send_message do
+      reference_url "https://my.slack.com/services/new/incoming-webhook"
+      method :post
+
+      body "payload" do
+        data_type "Payload"
+      end
+    end
+  end
+
+  complex_type "Payload" do
+    required :text 
+    property :text
+    property :channel
+    property :username
+    property :icon_url
+    property :icon_emoji
+  end
+
+end
+

data/diesel.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'diesel/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "diesel-api-dsl"
+  spec.version       = Diesel::VERSION
+  spec.authors       = ["Calvin Yu"]
+  spec.email         = ["me@sourcebender.com"]
+  spec.description   = %q{Create API Clients From an DSL}
+  spec.summary       = %q{Create API Clients From an DSL}
+  spec.homepage      = "http://github.com/cyu/diesel"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake", "~> 10.1"
+
+  spec.add_dependency "httparty", "~> 0.12"
+end

data/examples/create_pivotal_task.rb

@@ -0,0 +1,13 @@
+require 'diesel'
+require 'logger'
+PivotalTracker = Diesel.load_api 'apis/pivotal_tracker'
+api = PivotalTracker.new
+api.logger = Logger.new(STDOUT)
+api.logger.level = Logger::DEBUG
+api.api_token = YOUR_API_TOKEN
+p api.create_story(
+  project_id: YOUR_PROJECT_ID,
+  story: {
+    name: 'Testing Pivotal API',
+    :story_type => :chore
+  })

data/examples/post_slack_message.rb

@@ -0,0 +1,8 @@
+require 'diesel'
+require 'logger'
+
+Slack = Diesel.load_api 'apis/slack'
+api = Slack.new
+api.logger = Logger.new STDOUT
+api.api_token = YOUR_API_TOKEN
+puts api.send_message(payload: {text: 'testing', channel: '#developers', username: 'calvin'})

data/lib/diesel/action/http.rb

@@ -0,0 +1,92 @@
+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

@@ -0,0 +1,33 @@
+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/api_builder.rb

@@ -0,0 +1,68 @@
+require 'diesel/action/http'
+require 'diesel/complex_type_builder'
+require 'diesel/container_builder'
+
+module Diesel
+  class APIBuilder
+    attr_reader :profile
+
+    def initialize(profile)
+      @profile = profile
+    end
+
+    def build
+      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)
+        #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) }
+      end
+
+      def create_api_class
+        Class.new(Diesel::API)
+      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)
+              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 }
+      end
+
+      def create_class_name(name)
+        string = name.to_s.sub(/.*\./, '')
+        string = string.sub(/^[a-z\d]*/) { $&.capitalize }
+        string.gsub(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }.gsub('/', '::')
+      end
+
+  end
+end

data/lib/diesel/auth/api_key.rb

@@ -0,0 +1,39 @@
+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

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

data/lib/diesel/auth/oauth2.rb

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,24 @@
+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

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

data/lib/diesel/dsl.rb

@@ -0,0 +1,239 @@
+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

data/lib/diesel/endpoint.rb

@@ -0,0 +1,43 @@
+module Diesel
+  class Endpoint
+    attr_reader :path
+    attr_accessor :action
+
+    def initialize(path)
+      @path = path
+    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)
+    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
+
+        #attributes.each do |attr_name, options|
+        #  if options[:required] and context.attributes[attr_name].nil?
+        #    raise ArgumentError, "require attribute: #{attr_name}"
+        #  end
+        #end
+      end
+  end
+end

data/lib/diesel/model_builder.rb

@@ -0,0 +1,9 @@
+module Diesel
+  class ModelBuilder
+    attr_reader :model
+
+    def initialize(model)
+      @model = model
+    end
+  end
+end

data/lib/diesel/profile.rb

@@ -0,0 +1,112 @@
+require 'diesel/api'
+require 'diesel/authenticator'
+
+module Diesel
+  module Profile
+    class Base
+      attr_accessor :description
+    end
+
+    class Authorization < Base
+      attr_accessor :name, :nickname, :pass_as, :type
+    end
+
+    class Property < Base
+      attr_accessor :name, :enum
+    end
+
+    class Model < Base
+      attr_accessor :name
+    end
+
+    class ComplexType < Model
+      attr_accessor :required, :properties
+
+      def required
+        @required ||= []
+      end
+
+      def properties 
+        @properties ||= []
+      end
+    end
+
+    class Container < Model
+      attr_accessor :type
+    end
+
+    class Parameter < Base
+      PRIMITIVE_TYPES = [
+        :integer,
+        :long,
+        :float,
+        :double,
+        :string,
+        :byte,
+        :boolean,
+        :date,
+        :date_time
+      ]
+
+      attr_accessor :param_type, :name, :value, :data_type, :required
+
+      def complex?
+        !data_type.nil? && !primitive?
+      end
+
+      def primitive?
+        PRIMITIVE_TYPES.include?(data_type)
+      end
+
+      def required?
+        !!required
+      end
+    end
+
+    class Operation < Base
+      attr_accessor :nickname, :reference_url, :method, :parameters
+
+      def parameters
+        @parameters ||= []
+      end
+    end
+
+    class Resource < Base
+      attr_accessor :path, :operations
+
+      def initialize(path)
+        @path = path
+      end
+
+      def operations
+        @operations ||= []
+      end
+    end
+
+    class API < Base
+      attr_reader :name
+      attr_accessor :api_version, :base_path, :auth_type, :auth_options, :resources, :parameters, :authorizations
+
+      def initialize(name)
+        @name = name
+      end
+
+      def parameters 
+        @parameters ||= []
+      end
+
+      def resources
+        @resources ||= []
+      end
+
+      def models
+        @models ||= []
+      end
+
+      def authorizations
+        @authorizations ||= []
+      end
+    end
+
+  end
+end

data/lib/diesel/request_context.rb

@@ -0,0 +1,30 @@
+module Diesel
+  class RequestContext
+    attr_reader :api, :endpoint, :attributes
+
+    def initialize(api, endpoint, attributes)
+      @api, @endpoint, @attributes = api, endpoint, attributes
+    end
+
+    def logger
+      api.logger
+    end
+
+    def get_attribute(name)
+      name = name.to_sym
+      attributes[name]
+    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
+    end
+
+    def perform
+      endpoint.perform(self)
+    end
+  end
+end

data/lib/diesel/version.rb

@@ -0,0 +1,3 @@
+module Diesel
+  VERSION = "0.0.1"
+end

data/lib/diesel.rb

@@ -0,0 +1,10 @@
+require "diesel/version"
+require 'diesel/dsl'
+require 'diesel/api_builder'
+
+module Diesel
+  def self.load_api(name)
+    profile = DSL.load_profile(name, "#{name}.rb")
+    Diesel::APIBuilder.new(profile).build
+  end
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: diesel-api-dsl
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Calvin Yu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.1'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.12'
+description: Create API Clients From an DSL
+email:
+- me@sourcebender.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- apis/pivotal_tracker.rb
+- apis/slack.rb
+- diesel.gemspec
+- examples/create_pivotal_task.rb
+- examples/post_slack_message.rb
+- lib/diesel.rb
+- lib/diesel/action/http.rb
+- lib/diesel/api.rb
+- lib/diesel/api_builder.rb
+- lib/diesel/auth/api_key.rb
+- lib/diesel/auth/base.rb
+- lib/diesel/auth/oauth2.rb
+- lib/diesel/authenticator.rb
+- lib/diesel/complex_type_builder.rb
+- lib/diesel/container_builder.rb
+- lib/diesel/dsl.rb
+- lib/diesel/endpoint.rb
+- lib/diesel/model_builder.rb
+- lib/diesel/profile.rb
+- lib/diesel/request_context.rb
+- lib/diesel/version.rb
+homepage: http://github.com/cyu/diesel
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Create API Clients From an DSL
+test_files: []