skeleton 0.3.3 → 0.4.1

data/lib/skeleton/responses.rb

@@ -1,59 +0,0 @@
-require 'skeleton/model'
-require 'skeleton/response'
-
-module Skeleton
-  class Responses < Model
-    attr_accessor :default
-    attr_presence :default
-
-    def initialize(args={})
-      @responses = {}
-      args.each { |k, v| set(k, v) }
-    end
-
-    def get(code)
-      @responses[code]
-    end
-    alias_method :[], :get
-
-    def set(code, value)
-      case value
-      when Hash
-        @responses[code] = Skeleton::Response.new(value)
-      else
-        @responses[code] = value
-      end
-    end
-    alias_method :[]=, :set
-
-    def empty?
-      @responses.empty?
-    end
-
-    def to_h
-      hash = {}
-      hash[:default] = default.to_h if default?
-      @responses.each do |code, response|
-        if response.respond_to?(:to_h)
-          hash[code] = response.to_h
-        else
-          hash[code] = response
-        end
-      end
-      hash
-    end
-
-    def to_swagger_hash
-      hash = {}
-      hash[:default] = default.to_h if default?
-      @responses.each do |code, response|
-        if response.respond_to?(:to_swagger_hash)
-          hash[code] = response.to_swagger_hash
-        else
-          hash[code] = response
-        end
-      end
-      hash
-    end
-  end
-end

data/lib/skeleton/scopes.rb

@@ -1,24 +0,0 @@
-require 'skeleton/model'
-
-module Skeleton
-  class Scopes < Model
-    attr_reader :scopes
-
-    def initialize
-      @scopes = {}
-    end
-
-    def [](name)
-      @scopes[name]
-    end
-
-    def []=(name, description)
-      @scopes[name] = description
-    end
-
-    def to_h
-      @scopes
-    end
-    alias_method :to_swagger_hash, :to_h
-  end
-end

data/lib/skeleton/security_definitions.rb

@@ -1,46 +0,0 @@
-require 'skeleton/model'
-require 'skeleton/security_scheme'
-
-module Skeleton
-  class SecurityDefinitions < Model
-    def initialize(args={})
-      @schemes = {}
-      args.each { |k, v| set(k, v) }
-    end
-
-    def get(name)
-      @schemes[name]
-    end
-    alias_method :[], :get
-
-    def set(name, value)
-      case value
-      when Hash
-        @schemes[name] = Skeleton::SecurityScheme.new(value)
-      else
-        @schemes[name] = value
-      end
-    end
-    alias_method :[]=, :set
-
-    def empty?
-      !@schemes.empty?
-    end
-
-    def to_h
-      hash = {}
-      @schemes.each do |name, scheme|
-        hash[name] = scheme.to_h
-      end
-      hash
-    end
-
-    def to_swagger_hash
-      hash = {}
-      @schemes.each do |name, scheme|
-        hash[name] = scheme.to_swagger_hash
-      end
-      hash
-    end
-  end
-end

data/lib/skeleton/security_requirement.rb

@@ -1,29 +0,0 @@
-require 'skeleton/model'
-
-module Skeleton
-  class SecurityRequirement < Model
-    def initialize(args={})
-      @requirements = []
-      args.each { |name, value| set(name, value) }
-    end
-
-    def get(name)
-      @requirements[name]
-    end
-    alias_method :[], :get
-
-    def set(name, value)
-      @requirements[name] = Array(value)
-    end
-    alias_method :[]=, :set
-
-    def to_h
-      hash = {}
-      @requirements.each do |name, definition|
-        hash[name] = definition
-      end
-      hash
-    end
-    alias_method :to_swagger_hash, :to_h
-  end
-end

data/spec/integrations/use_case_spec.rb

@@ -1,131 +0,0 @@
-require 'spec_helper'
-
-require 'skeleton'
-
-describe 'A simple use case' do
-  describe 'validating the first case' do
-    it 'works' do
-      @structure = Skeleton.build do |s|
-        s.host = 'api.example.com'
-        s.info.version = '1.0'
-        s.info.title = 'Waffles Emporium API'
-        s.info.description = 'A test integration'
-
-        s.info.contact.name = 'WarmWaffles'
-        s.info.contact.email = 'warmwaffles@gmail.com'
-        s.info.contact.url = 'https://github.com/warmwaffles/skeleton'
-
-        s.info.license.name = 'MIT'
-
-        s.schemes = %w(https)
-        s.consumes = %(application/json)
-        s.produces = %(application/json)
-
-        s.path('/users') do |path|
-          path.get do |o|
-            o.tag('users')
-            o.parameter(:query, 'limit') do |p|
-              p.description = 'maximum number of results to return'
-              p.type = 'integer'
-              p.format = 'int32'
-              p.required = false
-            end
-            o.parameter(:query, 'offset') do |p|
-              p.description = 'offset within the results returned'
-              p.type = 'integer'
-              p.format = 'int32'
-              p.required = false
-            end
-          end
-
-          path.post do |o|
-            o.tag('user')
-            o.parameter(:body, 'user[email]') do |p|
-              p.description = 'the user email'
-              p.type = 'string'
-              p.required = true
-            end
-            o.parameter(:body, 'user[name]') do |p|
-              p.description = 'the user name'
-              p.type = 'string'
-              p.required = true
-            end
-            o.parameter(:body, 'user[password]') do |p|
-              p.description = 'the user password'
-              p.type = 'string'
-              p.required = true
-            end
-            o.parameter(:body, 'user[password_confirmation]') do |p|
-              p.description = 'the user password confirmation'
-              p.type = 'string'
-              p.required = true
-            end
-          end
-        end
-
-        s.path('/users/{user_id}') do |path|
-          path.get do |o|
-            o.tag('user')
-            o.parameter(:query, 'user_id') do |p|
-              p.description = 'the user id'
-              p.type = 'string'
-              p.format = 'uuid'
-              p.required = true
-            end
-          end
-
-          path.put do |o|
-            o.tag('user')
-            o.parameter(:body, 'user[email]') do |p|
-              p.description = 'the user email'
-              p.type = 'string'
-              p.required = false
-            end
-            o.parameter(:body, 'user[name]') do |p|
-              p.description = 'the user name'
-              p.type = 'string'
-              p.required = false
-            end
-            o.parameter(:body, 'user[password]') do |p|
-              p.description = 'the user password'
-              p.type = 'string'
-              p.required = false
-            end
-            o.parameter(:body, 'user[password_confirmation]') do |p|
-              p.description = 'the user password confirmation'
-              p.type = 'string'
-              p.required = false
-            end
-          end
-
-          path.patch do |o|
-            o.tag('user')
-            o.parameter(:body, 'user[email]') do |p|
-              p.description = 'the user email'
-              p.type = 'string'
-              p.required = false
-            end
-            o.parameter(:body, 'user[name]') do |p|
-              p.description = 'the user name'
-              p.type = 'string'
-              p.required = false
-            end
-            o.parameter(:body, 'user[password]') do |p|
-              p.description = 'the user password'
-              p.type = 'string'
-              p.required = false
-            end
-            o.parameter(:body, 'user[password_confirmation]') do |p|
-              p.description = 'the user password confirmation'
-              p.type = 'string'
-              p.required = false
-            end
-          end
-        end
-      end
-      @structure.to_json
-      @structure.to_swagger_json
-    end
-
-  end
-end

data/spec/skeleton/operation_spec.rb

@@ -1,113 +0,0 @@
-require 'spec_helper'
-
-require 'skeleton/operation'
-
-describe Skeleton::Operation do
-  describe '#summary=' do
-    it 'sets the summary' do
-      operation = Skeleton::Operation.new
-      operation.summary = 'foo bar'
-      assert_equal('foo bar', operation.summary)
-    end
-  end
-
-  describe '#summary?' do
-    context 'when not set' do
-      it 'returns false' do
-        operation = Skeleton::Operation.new
-        refute(operation.summary?)
-      end
-    end
-
-    context 'when set' do
-      it 'returns true' do
-        operation = Skeleton::Operation.new(summary: 'foo bar')
-        assert(operation.summary?)
-      end
-    end
-  end
-
-  describe '#consumes' do
-    context 'when not set' do
-      it 'returns an empty array' do
-        operation = Skeleton::Operation.new
-        assert_empty(operation.consumes)
-      end
-    end
-
-    context 'when set' do
-      it 'returns strings' do
-        operation = Skeleton::Operation.new({consumes: ['application/json', 'application/xml']})
-        assert_includes(operation.consumes, 'application/json')
-        assert_includes(operation.consumes, 'application/xml')
-      end
-    end
-  end
-
-  describe '#consumes?' do
-    context 'when not set' do
-      it 'returns an empty array' do
-        operation = Skeleton::Operation.new
-        refute(operation.consumes?)
-      end
-    end
-
-    context 'when set' do
-      it 'returns strings' do
-        operation = Skeleton::Operation.new({consumes: ['application/json', 'application/xml']})
-        assert(operation.consumes?)
-      end
-    end
-  end
-
-  describe '#produces' do
-    context 'when not set' do
-      it 'returns an empty array' do
-        operation = Skeleton::Operation.new
-        assert_empty(operation.produces)
-      end
-    end
-
-    context 'when set' do
-      it 'returns strings' do
-        operation = Skeleton::Operation.new({produces: ['application/json', 'application/xml']})
-        assert_includes(operation.produces, 'application/json')
-        assert_includes(operation.produces, 'application/xml')
-      end
-    end
-  end
-
-  describe '#produces?' do
-    context 'when not set' do
-      it 'returns an empty array' do
-        operation = Skeleton::Operation.new
-        refute(operation.produces?)
-      end
-    end
-
-    context 'when set' do
-      it 'returns strings' do
-        operation = Skeleton::Operation.new({produces: ['application/json', 'application/xml']})
-        assert(operation.produces?)
-      end
-    end
-  end
-
-  describe '#to_h' do
-    context 'when nothing is set' do
-      it 'returns an empty hash' do
-        operation = Skeleton::Operation.new
-        assert_empty(operation.to_h)
-      end
-    end
-
-    context 'when consumes is set' do
-      it 'returns a hash with the consumes field' do
-        operation = Skeleton::Operation.new({consumes: ['application/json', 'application/xml']})
-        hash = operation.to_h
-        refute_empty(hash, 'expected the hash to contain data')
-        assert(hash.key?(:consumes), 'expected the hash to contain :consumes')
-      end
-    end
-  end
-end

data/spec/skeleton/serializers/contact_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-require 'skeleton/contact'
-
-describe Skeleton::Contact do
-  before do
-    @contact = Skeleton::Contact.new
-  end
-
-  describe '#name=' do
-    it 'sets the name' do
-      @contact.name = 'foo'
-      assert_equal('foo', @contact.name)
-    end
-  end
-
-  describe '#email=' do
-    it 'sets the email' do
-      @contact.email = 'foo'
-      assert_equal('foo', @contact.email)
-    end
-  end
-
-  describe '#url=' do
-    it 'sets the url' do
-      @contact.url = 'foo'
-      assert_equal('foo', @contact.url)
-    end
-  end
-end

data/spec/skeleton/serializers/documentation_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-
-require 'skeleton/documentation'
-
-describe Skeleton::Documentation do
-  before do
-    @documentation = Skeleton::Documentation.new
-  end
-
-  describe '#description=' do
-    it 'sets the description' do
-      @documentation.description = 'foo'
-      assert_equal('foo', @documentation.description)
-    end
-  end
-
-  describe '#url=' do
-    it 'sets the url' do
-      @documentation.url = 'foo'
-      assert_equal('foo', @documentation.url)
-    end
-  end
-end