skeleton 0.3.3 → 0.4.1

data/lib/skeleton/items.rb

@@ -0,0 +1,34 @@
+require 'skeleton/schema'
+
+module Skeleton
+  class Items < Schema
+    attr_reader :items, :collection_format
+
+    def items=(value)
+      case value
+      when Hash
+        @items = Skeleton::Items.new(value)
+      else
+        @items = value
+      end
+    end
+
+    def collection_format
+      return nil unless array?
+
+      if @collection_format.nil?
+        'csv'
+      else
+        @collection_format
+      end
+    end
+
+    def collection_format=(value)
+      @collection_format = value.to_s
+    end
+
+    def items?
+      !!@items
+    end
+  end
+end

data/lib/skeleton/license.rb

@@ -1,16 +1,5 @@
-require 'skeleton/model'
-
 module Skeleton
-  class License < Model
+  class License
     attr_accessor :name, :url
-    attr_presence :name, :url
-
-    def to_h
-      hash = {}
-      hash[:name] = name if name?
-      hash[:url] = url if url?
-      hash
-    end
-    alias_method :to_swagger_hash, :to_h
   end
 end

data/lib/skeleton/model.rb

@@ -1,31 +1,27 @@
-require 'multi_json'
-require 'skeleton/attributes'
+require 'skeleton/schema'
 
 module Skeleton
-  class Model
-    extend Skeleton::Attributes
+  class Model < Schema
+    attr_reader :description, :descriptor, :name
 
-    def initialize(args={})
-      args.each do |k, v|
-        setter = "#{k}="
-        self.public_send(setter, v) if self.respond_to?(setter)
-      end
+    def describe(value)
+      @description = value
     end
 
-    def to_swagger_hash
-      raise(NotImplementedError)
+    def extends(value)
+      @descriptor = value
     end
 
-    def to_h
-      raise(NotImplementedError)
+    def required(field, options={})
+      property(field, { required: true }.merge(options))
     end
 
-    def to_json
-      MultiJson.dump(to_h)
+    def optional(field, options={})
+      property(field, { required: false }.merge(options))
     end
 
-    def to_swagger_json
-      MultiJson.dump(to_swagger_hash)
+    def property(field, options={})
+      properties[field] = Skeleton::Schema.new(options)
     end
   end
 end

data/lib/skeleton/operation.rb

@@ -1,157 +1,86 @@
-require 'skeleton/model'
-require 'skeleton/parameter'
-require 'skeleton/responses'
+require 'skeleton/response'
+require 'skeleton/parameters'
 
 module Skeleton
-  class Operation < Model
-    attr_accessor :summary, :description, :external_docs, :operation_id, :deprecated
-    attr_presence :summary, :description, :external_docs, :operation_id, :deprecated
-    attr_not_empty :tags, :consumes, :produces, :responses, :schemes, :security, :parameters
+  class Operation
+    attr_accessor :description, :summary, :id
+    attr_reader :responses
 
-    attr_writer :responses
-
-    def consumes
-      @consumes ||= []
+    def initialize
+      @responses = {}
+      @tags = {}
+      @consumes = {}
+      @produces = {}
+      @parameters = Skeleton::Parameters.new
     end
 
-    def consumes=(value)
-      @consumes = Array(value)
-    end
-
-    def produces
-      @produces ||= []
-    end
+    alias_method :summarize, :summary=
+    alias_method :describe, :description=
+    alias_method :identify, :id=
 
-    def produces=(value)
-      @produces = Array(value)
+    def deprecate
+      @deprecated = true
     end
 
-    def parameters
-      @parameters ||= []
+    def deprecated?
+      !!@deprecated
     end
 
-    def parameters=(value)
-      @parameters = Array(value)
+    def id?
+      !!@id
     end
 
-    def schemes
-      @schemes ||= []
+    def tag(*values)
+      values.each { |v| @tags[v] = true }
     end
 
-    def schemes=(value)
-      @schemes = Array(value)
+    def tags
+      @tags.map { |t,_| t.to_s }
     end
 
-    def security
-      @security ||= []
+    def consume(*values)
+      values.each { |t| @consumes[t.to_s] = true }
     end
 
-    def security=(value)
-      @security = Array(value)
+    def consumes
+      @consumes.map { |s, _| s }
     end
 
-    def responses
-      @responses ||= Skeleton::Responses.new
+    def consumes?
+      !@consumes.empty?
     end
 
-    def tags=(value)
-      @tags = Array(value)
+    def produce(*values)
+      values.each { |t| @produces[t.to_s] = true }
     end
 
-    def tags
-      @tags ||= []
-    end
-
-    def response(name, args={})
-      responses.set(name, args)
+    def produces
+      @produces.map { |s, _| s }
     end
 
-    def tag(value)
-      tags << value
+    def produces?
+      !@produces.empty?
     end
 
-    def parameter(location, name, &block)
-      param = Parameter.new(location: location, name: name)
-      yield(param) if block
-      parameters << param
+    def response(value, options={}, &block)
+      @responses[value] = Skeleton::Response.new
+      @responses[value].instance_eval(&block) if block
+      @responses[:default] = @responses[value] if options[:default]
+      @responses[value]
     end
 
-    def to_h
-      hash = {}
-      hash[:tags]          = self.tags          if self.tags?
-      hash[:summary]       = self.summary       if self.summary?
-      hash[:description]   = self.description   if self.description?
-      hash[:external_docs] = self.external_docs if self.external_docs?
-      hash[:operation_id]  = self.operation_id  if self.operation_id?
-      hash[:consumes]      = self.consumes      if self.consumes?
-      hash[:produces]      = self.produces      if self.produces?
-
-      if self.parameters?
-        hash[:parameters] = []
-        self.parameters.each do |parameter|
-          if parameter.respond_to?(:to_h)
-            hash[:parameters] << parameter.to_h
-          else
-            hash[:parameters] = parameter
-          end
-        end
+    def parameters(location=:query, &block)
+      params = Skeleton::Parameters.new
+      params.instance_eval(&block) if block
+      params.each do |p|
+        p.location = location
+        @parameters.add(p)
       end
-
-      hash[:responses]  = self.responses.to_h if self.responses?
-      hash[:schemes]    = self.schemes        if self.schemes?
-      hash[:deprecated] = self.deprecated     if self.deprecated?
-      if self.security?
-        hash[:security] = []
-        self.security.each do |sec|
-          if sec.respond_to?(:to_h)
-            hash[:secuirty] << sec.to_h
-          else
-            hash[:security] << sec
-          end
-        end
-      end
-      hash[:security] = self.deprecated if self.deprecated?
-      hash
+      @parameters
     end
 
-    def to_swagger_hash
-      hash = {}
-      hash[:tags]         = self.tags          if self.tags?
-      hash[:summary]      = self.summary       if self.summary?
-      hash[:description]  = self.description   if self.description?
-      hash[:externalDocs] = self.external_docs if self.external_docs?
-      hash[:operationId]  = self.operation_id  if self.operation_id?
-      hash[:consumes]     = self.consumes      if self.consumes?
-      hash[:produces]     = self.produces      if self.produces?
-
-      if self.parameters?
-        hash[:parameters] = []
-        self.parameters.each do |parameter|
-          if parameter.respond_to?(:to_swagger_hash)
-            hash[:parameters] << parameter.to_swagger_hash
-          else
-            hash[:parameters] = parameter
-          end
-        end
-      end
-
-      hash[:responses]  = self.responses.to_swagger_hash if self.responses?
-
-      hash[:schemes]    = self.schemes    if self.schemes?
-      hash[:deprecated] = self.deprecated if self.deprecated?
-
-      if self.security?
-        hash[:security] = []
-        self.security.each do |sec|
-          if sec.respond_to?(:to_swagger_hash)
-            hash[:secuirty] << sec.to_swagger_hash
-          else
-            hash[:security] << sec
-          end
-        end
-      end
-      hash[:security] = self.deprecated if self.deprecated?
-      hash
+    def parameters?
+      !@parameters.empty?
     end
   end
 end

data/lib/skeleton/parameter.rb

@@ -1,112 +1,55 @@
-require 'skeleton/model'
+require 'skeleton/schema'
+require 'skeleton/items'
 
 module Skeleton
-  class Parameter < Model
-    attr_accessor :name, :location, :description, :required, :schema, :type,
-                  :format, :items, :collection_format, :default, :maximum,
-                  :exclusive_maximum, :minimum, :exclusive_minimum, :max_length,
-                  :min_length, :unique_items, :multiple_of, :min_items,
-                  :max_items, :pattern
+  class Parameter < Schema
+    attr_reader :name, :location, :items, :schema
 
-    attr_writer :enum
-    attr_presence :pattern, :multiple_of, :unique_items, :max_items, :min_items,
-                  :min_length, :max_length, :minimum, :maximum, :default,
-                  :collection_format, :items, :format, :type, :schema, :required,
-                  :description, :location, :name, :exclusive_maximum,
-                  :exclusive_minimum, :unique_items
-
-    def enum
-      @enum ||= []
+    def items?
+      !!@items
     end
 
-    def enum?
-      !enum.empty?
+    def items=(hash)
+      self.type = 'array'
+      @items = Skeleton::Items.new(hash)
     end
+    alias_method :array=, :items=
 
-    def array?
-      @type == 'array'
+    def schema?
+      !!@schema
     end
 
-    def string?
-      @type == 'string'
+    def schema=(value)
+      case value
+      when Hash
+        @schema = Skeleton::Schema.new(value)
+      else
+        @schema = value
+      end
     end
 
-    def number?
-      @type == 'number'
+    def name=(value)
+      @name = value.to_s
     end
 
-    def integer?
-      @type == 'integer'
+    def location=(value)
+      @location = value.to_s
     end
 
-    def boolean?
-      @type == 'boolean'
+    def body?
+      @location == 'body'
     end
 
-    def file?
-      @type == 'file'
+    def query?
+      @location == 'query'
     end
 
-    def to_h
-      hash = {}
-      hash[:name]              = name              if name?
-      hash[:location]          = location          if location?
-      hash[:description]       = description       if description?
-      hash[:required]          = required          if required?
-
-      hash[:schema] = schema.to_h if schema?
-
-      hash[:type]              = type              if type?
-      hash[:format]            = format            if format?
-
-      hash[:items] = items.to_h if items?
-
-      hash[:collection_format] = collection_format if collection_format?
-      hash[:default]           = default           if default?
-      hash[:maximum]           = maximum           if maximum?
-      hash[:exclusive_maximum] = exclusive_maximum if exclusive_maximum?
-      hash[:minimum]           = minimum           if minimum?
-      hash[:exclusive_minimum] = exclusive_minimum if exclusive_minimum?
-      hash[:max_length]        = max_length        if max_length?
-      hash[:min_length]        = min_length        if min_length?
-      hash[:unique_items]      = unique_items      if unique_items?
-      hash[:multiple_of]       = multiple_of       if multiple_of?
-      hash[:min_items]         = min_items         if min_items?
-      hash[:max_items]         = max_items         if max_items?
-      hash[:pattern]           = pattern           if pattern?
-      hash[:enum]              = enum              if enum?
-      hash
+    def path?
+      @location == 'path'
     end
 
-    def to_swagger_hash
-      hash = {}
-      hash[:name]             = name              if name?
-      hash[:in]               = location          if location?
-      hash[:description]      = description       if description?
-      hash[:required]         = required          if required?
-
-      hash[:schema] = schema.to_swagger_json if schema?
-
-      hash[:type]             = type              if type?
-      hash[:format]           = format            if format?
-
-      hash[:items] = items.to_swagger_json if items?
-
-      hash[:collectionFormat] = collection_format if collection_format?
-      hash[:default]          = default           if default?
-      hash[:maximum]          = maximum           if maximum?
-      hash[:exclusiveMaximum] = exclusive_maximum if exclusive_maximum?
-      hash[:minimum]          = minimum           if minimum?
-      hash[:exclusiveMinimum] = exclusive_minimum if exclusive_minimum?
-      hash[:maxLength]        = max_length        if max_length?
-      hash[:minLength]        = min_length        if min_length?
-      hash[:uniqueItems]      = unique_items      if unique_items?
-      hash[:multipleOf]       = multiple_of       if multiple_of?
-      hash[:minItems]         = min_items         if min_items?
-      hash[:maxItems]         = max_items         if max_items?
-      hash[:pattern]          = pattern           if pattern?
-      hash[:enum]             = enum              if enum?
-      hash
+    def header?
+      @location == 'header'
     end
   end
 end