apiture 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 160ccb2fb353faafd6d123a0b8a85cf274105a60
+  data.tar.gz: a9a7661f0953d01ec9146fa2b406833bb83ad9fe
+SHA512:
+  metadata.gz: e182986957f2b292e3df895db859b6dd60aaabb112053b0efe467e760e1ad342568b6f8264bf14199c5631323d7121c261a75124a340966ed28770a1293193b0
+  data.tar.gz: 786d2f22e4d43157f07a81780ccf0462b297ebb7c4d912db01e6790f9330eea1689ca195e747ef76882d4fd23ca4a8d2a5685a3523ffc368d2b4b48b1c4f4af9

data/.gitignore

@@ -0,0 +1,19 @@
+*.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
+*.swo

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+group :development do
+  gem "pry-byebug"
+end
+
+# Specify your gem's dependencies in apiture.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 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,38 @@
+# Apiture Gem
+
+Create clients for REST APIs from their Swagger specification 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'apiture'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install apiture
+
+## Usage
+
+```ruby
+PivotalTracker = Apiture.load_api("pivotal_tracker.json")
+client = PivotalTracker.new(api_token: 'afaketoken')
+client.create_story(
+  project_id: '1234567',
+  story: {
+    name: 'Testing Pivotal API',
+    story_type: :chore
+  })
+```
+
+## 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,6 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/apiture.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'apiture/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "apiture"
+  spec.version       = Apiture::VERSION
+  spec.authors       = ["Calvin Yu"]
+  spec.email         = ["me@sourcebender.com"]
+  spec.description   = %q{Create clients for REST APIs from their Swagger specification }
+  spec.summary       = %q{}
+  spec.homepage      = "http://github.com/cyu/apiture"
+  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.11.0"
+  spec.add_development_dependency "rake", "~> 11.1.0"
+  spec.add_development_dependency "rspec", "~> 3.4.0"
+  spec.add_development_dependency "vcr", "~> 2.9.0"
+  spec.add_development_dependency "webmock", "~> 1.20.0"
+
+  spec.add_dependency "faraday", "~> 0.9.0"
+  spec.add_dependency "faraday_middleware", "~> 0.10.0"
+  spec.add_dependency "multi_json", "~> 1.3"
+end

data/lib/apiture.rb

@@ -0,0 +1,24 @@
+require 'apiture/version'
+require 'apiture/swagger/parser'
+require 'apiture/api_builder'
+
+
+module Apiture
+
+  def self.parse_specification(path)
+    if path.match(/\.yml$/)
+      Apiture::Swagger::Parser.new.parse_yaml(File.read(path))
+    else
+      Apiture::Swagger::Parser.new.parse_json(File.read(path))
+    end
+  end
+
+  def self.build_api(specification)
+    Apiture::APIBuilder.new(specification).build
+  end
+
+  def self.load_api(path)
+    build_api(parse_specification(path))
+  end
+
+end

data/lib/apiture/api_base.rb

@@ -0,0 +1,27 @@
+require 'apiture/api_group'
+
+module Apiture
+  class APIError < Exception; end
+end
+
+module Apiture
+  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/apiture/api_builder.rb

@@ -0,0 +1,196 @@
+require 'apiture/version'
+require 'apiture/api_error'
+require 'apiture/utils/inflections'
+require 'apiture/api_base'
+require 'apiture/data_model'
+require 'apiture/uri'
+
+require 'apiture/middleware/debug'
+require 'apiture/middleware/set_header'
+require 'apiture/middleware/convert_json_body'
+
+module Apiture
+  class APIBuilder
+    include Apiture::Utils::Inflections
+
+    attr_reader :specification
+
+    def initialize(specification)
+      @specification = specification
+    end
+
+    def build
+      validate!
+
+      create_api_class.tap do |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 |*args|
+                group.execute(self.options, endpoint, *args)
+              end
+            end
+          end
+        ]
+
+        #Apiture.const_set create_class_name(name), klass
+      end
+    end
+
+    protected
+
+      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(Apiture::APIBase)
+      end
+
+      def build_endpoint_url(specification, path)
+        uri = Apiture::URI.new
+        uri.scheme = specification.schemes.first
+        uri.host = specification.host
+        uri.base_host = specification.extensions[:base_host]
+        uri.base_path = specification.base_path.chomp('/')
+        uri.resource_path = path.sub(/^([^\/])/, '/\1').chomp('/')
+        uri
+      end
+
+      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)
+
+            Apiture::Endpoint.new(endpoint_name, endpoint_url, method).tap do |endpoint|
+              endpoint.config_middleware do
+                consumes =
+                    (operation.consumes && operation.consumes.first) ||
+                    (spec.consumes && spec.consumes.first) 
+
+                produces =
+                    (operation.produces && operation.produces.first) ||
+                    (spec.produces && spec.produces.first) 
+
+                security = operation.security || spec.security
+
+                use Apiture::Middleware::Debug
+                use Apiture::Middleware::SetHeader, 'User-Agent' => "apiture-rb/#{Apiture::VERSION}"
+
+                if consumes
+                  use Apiture::Middleware::SetHeader, 'Content-Type' => consumes
+                end
+
+                if produces
+                  use Apiture::Middleware::SetHeader, 'Accept' => produces
+                end
+
+                security_ids = if security
+                                 security.keys
+                               else
+                                 if operation.security_definitions && !operation.security_definitions.empty?
+                                   [operation.security_definitions.keys.first]
+                                 elsif spec.security_definitions && !spec.security_definitions.empty?
+                                   [spec.security_definitions.keys.first]
+                                 else
+                                   []
+                                 end
+                               end
+
+                unless security_ids.empty?
+                  security_defs = spec.security_definitions || {}
+                  if operation.security_definitions
+                    security_defs = security_defs.merge(operation.security_definitions)
+                  end
+
+                  security_ids.each do |name|
+                    security_def = security_defs[name]
+
+                    if security_def.nil?
+                      raise APIError, "Missing security definition: #{name}, operation=#{endpoint_name}, method=#{method}"
+                    end
+
+                    case security_def.type
+                    when 'apiKey'
+                      require 'apiture/middleware/auth/api_key'
+                      use Apiture::Middleware::Auth::APIKey,
+                          id: Apiture::Utils::Inflections.underscore(name).to_sym,
+                          in: security_def.in,
+                          name: security_def.name,
+                          format: security_def.extensions[:format]
+                    when 'oauth2'
+                      require 'apiture/middleware/auth/oauth2'
+                      use Apiture::Middleware::Auth::OAuth2,
+                          id: Apiture::Utils::Inflections.underscore(name).to_sym,
+                          in: security_def.in,
+                          name: security_def.name
+                    when "basic"
+                      require "apiture/middleware/auth/basic"
+                      use Apiture::Middleware::Auth::Basic,
+                          id: Apiture::Utils::Inflections.underscore(name).to_sym
+                    else
+                      raise APIError, "Unsupported security definition: #{security_def.type}"
+                    end
+                  end
+                end
+
+                operation.parameters.each do |parameter|
+                  param_class_path = "apiture/middleware/set_#{parameter.in}_parameter"
+                  param_class_name = Apiture::Utils::Inflections.camelize(param_class_path)
+                  require param_class_path unless Object::const_defined?(param_class_name)
+                  param_class = Apiture::Utils::Inflections.constantize(param_class_name)
+                  middleware_opts = {name: parameter.name}
+                  if parameter.schema?
+                    schema = parameter.schema
+                    if schema.kind_of? String
+                      schema = data_models[parameter.schema]
+                    else
+                      schema = DataModel.new(schema)
+                    end
+                    unless schema
+                      raise APIError, "Unspecified schema: #{parameter.schema}; parameter=#{parameter.name}"
+                    end
+                    middleware_opts[:schema] = schema
+                  end
+                  if spec.extensions[:version_parameter] && spec.extensions[:version_parameter]["name"] == parameter.name
+                    middleware_opts[:default] = spec.extensions[:version_parameter]["version"]
+                  end
+                  use param_class, middleware_opts
+                end
+
+                if consumes == "application/json" || (operation.parameters && operation.parameters.detect { |p| p.in == :body })
+                  use Apiture::Middleware::ConvertJSONBody
+                end
+              end
+            end
+          end
+        end.flatten.compact
+      end
+
+      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)
+        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/apiture/api_error.rb

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

data/lib/apiture/api_group.rb

@@ -0,0 +1,28 @@
+require 'apiture/request_context'
+require 'apiture/endpoint'
+
+module Apiture
+  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)
+      params = parameters.last || {}
+      RequestContext.new(options, self, endpoint, params).perform
+    end
+  end
+end

data/lib/apiture/data_model.rb

@@ -0,0 +1,24 @@
+require 'multi_json'
+
+module Apiture
+  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
+
+      json
+    end
+  end
+end