diesel-api-dsl 0.0.1 → 0.1.0

data/lib/diesel/swagger/parser.rb

@@ -0,0 +1,70 @@
+require 'multi_json'
+require 'diesel/utils/inflections'
+require 'diesel/swagger/specification'
+
+
+module Diesel
+  module Swagger
+    class Parser
+      include Diesel::Utils::Inflections
+
+      def parse(spec)
+        build_specification(MultiJson.load(spec))
+      end
+
+      def build_specification(json)
+        specification = build_node(Specification, json)
+        specification.info = build_node(Info, json['info'])
+        specification.external_docs = build_node(ExternalDocs, json['externalDocs'])
+        specification.schemes = json['schemes']
+        specification.produces = json['produces'] || []
+        specification.security_definitions = build_node_hash(Swagger::SecurityDefinition, json, 'securityDefinitions')
+        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)
+              op.external_docs = build_node(ExternalDocs, op_json['externalDocs'])
+              op.parameters = build_node_list(Parameter, op_json, 'parameters')
+              path.send("#{method}=".to_sym, op)
+            end
+          end
+        end
+        specification.definitions = build_node_hash(Swagger::Definition, json, 'definitions') do |definition, def_json|
+          definition.properties = build_node_hash(Swagger::Property, def_json, 'properties') do |prop, prop_json|
+            prop.enum = prop_json['enum']
+          end
+        end
+        specification
+      end
+
+      protected
+
+        def build_node(model_class, json)
+          if json
+            model = model_class.new
+            model_class.attribute_names.each do |att|
+              model.send("#{att}=".to_sym, json[camelize(att.to_s, false)])
+            end
+            model
+          end
+        end
+
+        def build_node_list(model_class, json, json_list_key)
+          (json[json_list_key] || []).map do |node_json|
+            node = build_node(model_class, node_json)
+            yield(node, node_json) if block_given?
+            node
+          end
+        end
+
+        def build_node_hash(model_class, json, json_hash_key)
+          (json[json_hash_key] || {}).reduce({}) do |m, (k, v)|
+            m[k] = node = build_node(model_class, v)
+            yield(node, v) if block_given?
+            m
+          end
+        end
+
+    end
+  end
+end

data/lib/diesel/swagger/path.rb

@@ -0,0 +1,27 @@
+require 'diesel/swagger/node'
+require 'diesel/swagger/operation'
+
+module Diesel
+  module Swagger
+    class Path < Node
+      attribute :get, validate: true
+      attribute :put, validate: true
+      attribute :post, validate: true
+      attribute :delete, validate: true
+      attribute :options, validate: true
+      attribute :head, validate: true
+      attribute :patch, validate: true
+
+      list :parameters, validate: true
+
+      def operations_map
+        [:get, :put, :post, :delete, :options, :head, :patch].reduce({}) do |m, method|
+          if op = __send__(method)
+            m[method] = op
+          end
+          m
+        end
+      end
+    end
+  end
+end

data/lib/diesel/swagger/property.rb

@@ -0,0 +1,8 @@
+require 'diesel/swagger/data_type_field'
+
+module Diesel
+  module Swagger
+    class Property < DataTypeField
+    end
+  end
+end

data/lib/diesel/swagger/security_definition.rb

@@ -0,0 +1,15 @@
+require 'diesel/swagger/node'
+
+module Diesel
+  module Swagger
+    class SecurityDefinition < Node
+      attribute :type
+      attribute :description
+      attribute :name
+      attribute :in, symbolize: true
+      attribute :flow
+      attribute :authorization_url
+      attribute :token_url
+    end
+  end
+end

data/lib/diesel/swagger/specification.rb

@@ -0,0 +1,30 @@
+require 'diesel/swagger/info'
+require 'diesel/swagger/external_docs'
+require 'diesel/swagger/security_definition'
+require 'diesel/swagger/path'
+require 'diesel/swagger/definition'
+# require 'diesel/swagger/response'
+
+module Diesel
+  module Swagger
+    class Specification < Node
+      attribute :swagger
+      attribute :info, validate: true
+      attribute :host
+      attribute :base_path
+      attribute :external_docs, validate: true
+
+      list :schemes
+      list :consumes
+      list :produces
+      list :tags, validate: true
+
+      hash :paths, validate: true
+      hash :definitions, validate: true
+      hash :parameters, validate: true
+      hash :responses, validate: true
+      hash :security_definitions, validate: true
+      hash :security
+    end
+  end
+end

data/lib/diesel/utils/inflections.rb

@@ -0,0 +1,46 @@
+module Diesel
+  module Utils
+    module Inflections
+
+      def self.acronyms
+        @@acronyms ||= {}
+      end
+
+      def self.acronym_regex
+        @@acronym_regex ||= /(?=a)b/
+      end
+
+      def camelize(term, uppercase_first_letter = true)
+        string = term.to_s
+        if uppercase_first_letter
+          string = string.sub(/^[a-z\d]*/) { ::Diesel::Utils::Inflections.acronyms[$&] || $&.capitalize }
+        else
+          string = string.sub(/^(?:#{::Diesel::Utils::Inflections.acronym_regex}(?=\b|[A-Z_])|\w)/) { $&.downcase }
+        end
+        string.gsub!(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{::Diesel::Utils::Inflections.acronyms[$2] || $2.capitalize}" }
+        string.gsub!('/', '::')
+        string
+      end
+
+      def underscore(camel_cased_word)
+        word = camel_cased_word.to_s.gsub('::', '/')
+        word.gsub!(/(?:([A-Za-z\d])|^)(#{::Diesel::Utils::Inflections.acronym_regex})(?=\b|[^a-z])/) { "#{$1}#{$1 && '_'}#{$2.downcase}" }
+        word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        word.tr!("-", "_")
+        word.downcase!
+        word
+      end
+
+      def constantize(camel_cased_word)
+        unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ camel_cased_word
+          raise NameError, "#{camel_cased_word.inspect} is not a valid constant name!"
+        end
+
+        Object.module_eval("::#{$1}", __FILE__, __LINE__)
+      end
+    end
+  end
+end
+
+Diesel::Utils::Inflections.extend(Diesel::Utils::Inflections)

data/lib/diesel/version.rb

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

data/spec/diesel/api_builder_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+require 'diesel'
+
+describe Diesel::APIBuilder do
+
+  let(:specification) do
+    Diesel.parse_specification(File.join(File.dirname(__FILE__), '..', 'files', 'pivotal_tracker.json'))
+  end
+
+  it "should build a API class from specification" do
+    api = Diesel::APIBuilder.new(specification).build
+  end
+
+end

data/spec/diesel/swagger/parser_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+require 'diesel/swagger/parser'
+
+describe Diesel::Swagger::Parser do
+  subject { Diesel::Swagger::Parser }
+
+  let(:specification_json) do
+    File.read(File.join(File.dirname(__FILE__), '..', '..', 'files', 'pivotal_tracker.json'))
+  end
+
+  it "should parse a diesel specification" do
+    specification = Diesel::Swagger::Parser.new.parse(specification_json)
+    expect(specification).to_not be_nil
+
+    expect(specification.host).to eq "www.pivotaltracker.com"
+    expect(specification.schemes).to include "https"
+    expect(specification.base_path).to eq "/services/v5"
+
+    expect(specification.info).to_not be_nil
+    expect(specification.info.title).to eq "PivotalTracker"
+    expect(specification.info.version).to eq "5"
+
+    api_token = specification.security_definitions['apiToken']
+    expect(api_token).to_not be_nil
+    expect(api_token.type).to eq "apiKey"
+    expect(api_token.in).to eq "header"
+    expect(api_token.name).to eq "X-TrackerToken"
+
+    expect(specification.produces).to include "application/json"
+
+    expect(specification.paths.count).to eq 1
+
+    path = specification.paths["/projects/{projectId}/stories"]
+    expect(path).to_not be_nil
+
+    expect(path.post).to_not be_nil
+    expect(path.post.operation_id).to eq "createStory"
+    expect(path.post.external_docs.url).to eq "https://www.pivotaltracker.com/help/api/rest/v5#projects_project_id_stories_post"
+
+    expect(path.post.parameters.count).to eq 2
+
+    param1 = path.post.parameters[0]
+    expect(param1).to_not be_nil
+    expect(param1.in).to eq :path
+    expect(param1.name).to eq "projectId"
+    expect(param1).to be_required
+
+    param2 = path.post.parameters[1]
+    expect(param2).to_not be_nil
+    expect(param2.in).to eq :body
+    expect(param2.name).to eq "body"
+    expect(param2).to be_required
+    expect(param2.schema).to eq "NewStory"
+
+    expect(specification.definitions.count).to eq 1
+
+    definition = specification.definitions["NewStory"]
+    expect(definition).to_not be_nil
+    expect(definition.required).to eq ["name"]
+
+    expect(definition.properties.count).to eq 15
+
+    prop1 = definition.properties["cl_numbers"]
+    expect(prop1).to_not be_nil
+    expect(prop1.type).to eq :string
+
+    prop2 = definition.properties["current_state"]
+    expect(prop2).to_not be_nil
+    expect(prop2.type).to eq :string
+    expect(prop2.enum).to eq [
+      "accepted",
+      "delivered",
+      "finished",
+      "started",
+      "rejected",
+      "unstarted",
+      "unscheduled"
+    ]
+  end
+end

data/spec/diesel_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'diesel'
+require 'logger'
+
+describe Diesel do
+
+  def load_api(name)
+    fn = File.join(File.dirname(__FILE__), 'files', "#{name}.json")
+    Diesel.load_api(fn)
+  end
+
+  it "should be able to build a PivotalTracker API client" do
+    PivotalTracker = load_api('pivotal_tracker')
+    client = PivotalTracker.new(api_token: 'afaketoken')
+    client.logger = Logger.new(STDOUT)
+    client.logger.level = Logger::DEBUG
+
+    VCR.use_cassette('pivotal_tracker_create_story') do
+      result = client.create_story(
+        project_id: '1053124',
+        story: {
+          name: 'Testing Pivotal API',
+          story_type: :chore
+        })
+      expect(result['kind']).to eq 'story'
+      expect(result).to have_key('id')
+      expect(result.response.code).to eq "200"
+    end
+  end
+
+  it "should be able to build a Honeybadger API client" do
+    Honeybadger = load_api('honeybadger')
+    client = Honeybadger.new(auth_token: 'afaketoken')
+    client.logger = Logger.new(STDOUT)
+    client.logger.level = Logger::DEBUG
+
+    VCR.use_cassette('honeybadger') do
+      results = client.get_faults(project_id: 3167)
+      expect(results['results'].first).to have_key('project_id')
+      expect(results.response.code).to eq "200"
+    end
+  end
+end

data/spec/files/honeybadger.json

@@ -0,0 +1,80 @@
+{
+  "swagger": "2.0",
+
+  "info": {
+    "title": "Honeybadger",
+    "description": "Honeybadger Read API v1",
+    "version": "1"
+  },
+
+  "host": "api.honeybadger.io",
+
+  "basePath": "/v1",
+
+  "schemes": ["https"],
+
+  "produces": ["application/json"],
+
+  "paths": {
+    "/projects/{projectId}/faults": {
+      "get": {
+        "summary": "Returns a list of faults for the given project",
+        "externalDocs": {
+          "url": "https://www.honeybadger.io/documentation/read_api"
+        },
+        "operationId": "getFaults",
+        "parameters": [
+          {
+            "name": "projectId",
+            "in": "path",
+            "required": true,
+            "type": "string"
+          },
+          {
+            "name": "page",
+            "in": "query"
+          }
+        ]
+      }
+    },
+    "/projects/{projectId}/faults/{faultId}/notices": {
+      "get": {
+        "summary": "Returns a list of notices for the given fault",
+        "externalDocs": {
+          "url": "https://www.honeybadger.io/documentation/read_api"
+        },
+        "operationId": "getNotices",
+        "parameters": [
+          {
+            "name": "projectId",
+            "in": "path",
+            "required": true,
+            "type": "string"
+          },
+          {
+            "name": "faultId",
+            "in": "path",
+            "required": true,
+            "type": "string"
+          },
+          {
+            "name": "page",
+            "in": "query"
+          }
+        ]
+      }
+    }
+  },
+
+  "securityDefinitions": {
+    "authToken": {
+      "type": "apiKey",
+      "name": "auth_token",
+      "in": "query"
+    }
+  },
+
+  "security": {
+    "authToken": []
+  }
+}

data/spec/files/pivotal_tracker.json

@@ -0,0 +1,94 @@
+{
+  "swagger": "2.0",
+
+  "info": {
+    "title": "PivotalTracker",
+    "description": "Agile project management tool for software teams",
+    "version": "5"
+  },
+
+  "host": "www.pivotaltracker.com",
+
+  "basePath": "/services/v5",
+
+  "schemes": ["https"],
+
+  "produces": ["application/json"],
+
+  "paths": {
+    "/projects/{projectId}/stories": {
+      "post": {
+        "summary": "Create a new story",
+        "externalDocs": {
+          "url": "https://www.pivotaltracker.com/help/api/rest/v5#projects_project_id_stories_post"
+        },
+        "operationId": "createStory",
+        "parameters": [
+          {
+            "name": "projectId",
+            "in": "path",
+            "required": true,
+            "type": "string"
+          },
+          {
+            "name": "story",
+            "in": "body",
+            "required": true,
+            "schema": "NewStory"
+          }
+        ]
+      }
+    }
+  },
+
+  "definitions": {
+    "NewStory": {
+      "title": "New Story",
+      "type": "object",
+      "properties": {
+        "cl_numbers": { "type": "string" },
+        "current_state": {
+          "type": "string",
+          "enum": [
+            "accepted",
+            "delivered",
+            "finished",
+            "started",
+            "rejected",
+            "unstarted",
+            "unscheduled"
+          ]
+        },
+        "external_id": { "type": "string" },
+        "deadline": { "type": "string" },
+        "description": { "type": "string" },
+        "estimate": { "type": "string" },
+        "integration_id": { "type": "string" },
+        "planned_iteration_number": { "type": "string" },
+        "requested_by_id": { "type": "string" },
+        "accepted_at": { "type": "string" },
+        "before_id": { "type": "string" },
+        "created_at": { "type": "string" },
+        "after_id": { "type": "string" },
+        "name": { "type": "string" },
+        "story_type": {
+          "type": "string",
+          "enum": [ "feature", "bug", "chore", "release" ]
+        }
+      },
+      "required": [ "name" ]
+    }
+  },
+
+  "securityDefinitions": {
+    "apiToken": {
+      "type": "apiKey",
+      "name": "X-TrackerToken",
+      "in": "header"
+    }
+  },
+
+  "security": {
+    "apiToken": []
+  }
+}