skeleton 0.3.3 → 0.4.1

data/lib/skeleton/parameters.rb

@@ -0,0 +1,40 @@
+require 'skeleton/parameter'
+
+module Skeleton
+  class Parameters
+    include Enumerable
+
+    def initialize
+      @list = []
+    end
+
+    def empty?
+      @list.empty?
+    end
+
+    def each(&block)
+      @list.each(&block)
+    end
+
+    def get(name)
+      find { |p| p.name == name }
+    end
+    alias_method :[], :get
+
+    def add(parameter)
+      @list << parameter
+      parameter
+    end
+
+    def required(name, args={})
+      opts = args.merge(name: name, required: true)
+      add(Skeleton::Parameter.new(opts))
+    end
+
+    def optional(name, args={})
+      opts = args.merge(name: name, required: false)
+      add(Skeleton::Parameter.new(opts))
+    end
+    alias_method :param, :optional
+  end
+end

data/lib/skeleton/path.rb

@@ -1,111 +1,73 @@
 require 'skeleton/operation'
-require 'skeleton/parameter'
-require 'skeleton/model'
 
 module Skeleton
-  class Path < Model
-    attr_accessor :ref
-    attr_writer :operations
-    attr_not_empty :parameters, :operations
+  class Path
+    attr_reader :operations
 
-    def operations
-      @operations ||= {}
+    def initialize
+      @operations = Hash.new
     end
 
-    def parameters=(value)
-      @parameters = Array(value)
+    def head(&block)
+      operation(:head, &block)
     end
 
-    def parameters
-      @parameters ||= []
+    def head?
+      @operations.key?(:head)
     end
 
-    def parameter(location, name, &block)
-      param = Skeleton::Parameter.new({name: name})
-      yield(param) if block
-      parameters << param
+    def get(&block)
+      operation(:get, &block)
     end
 
-    def get(&block)
-      define_operation(:get, &block)
+    def get?
+      @operations.key?(:get)
     end
 
     def put(&block)
-      define_operation(:put, &block)
+      operation(:put, &block)
+    end
+
+    def put?
+      @operations.key?(:put)
     end
 
     def post(&block)
-      define_operation(:post, &block)
+      operation(:post, &block)
+    end
+
+    def post?
+      @operations.key?(:post)
+    end
+
+    def patch(&block)
+      operation(:patch, &block)
+    end
+
+    def patch?
+      @operations.key?(:patch)
     end
 
     def delete(&block)
-      define_operation(:delete, &block)
+      operation(:delete, &block)
+    end
+
+    def delete?
+      @operations.key?(:delete)
     end
 
     def options(&block)
-      define_operation(:options, &block)
+      operation(:options, &block)
     end
 
-    def head(&block)
-      define_operation(:head, &block)
+    def options?
+      @operations.key?(:options)
     end
 
-    def patch(&block)
-      define_operation(:patch, &block)
-    end
-
-    def to_h
-      hash = {}
-      if operations?
-        operations.each do |method, operation|
-          if operation.respond_to?(:to_h)
-            hash[method] = operation.to_h
-          else
-            hash[method] = operation
-          end
-        end
-      end
-      if parameters?
-        hash[:parameters] = parameters.map do |parameter|
-          if parameter.respond_to?(:to_h)
-            parameter.to_h
-          else
-            parameter
-          end
-        end
-      end
-      hash
-    end
-
-    def to_swagger_hash
-      hash = {}
-      if operations?
-        operations.each do |method, operation|
-          if operation.respond_to?(:to_swagger_hash)
-            hash[method] = operation.to_swagger_hash
-          else
-            hash[method] = operation
-          end
-        end
-      end
-      if parameters?
-        hash[:parameters] = parameters.map do |parameter|
-          if parameter.respond_to?(:to_swagger_hash)
-            parameter.to_swagger_hash
-          else
-            parameter
-          end
-        end
-      end
-      hash
-    end
-
-    private
-
-    def define_operation(method, &block)
-      operation = Skeleton::Operation.new
-      yield(operation) if block
-      operations[method] = operation
+    def operation(type, &block)
+      @operations[type] = Skeleton::Operation.new
+      @operations[type].instance_eval(&block)
+      @operations[type]
     end
   end
 end

data/lib/skeleton/presenter.rb

@@ -0,0 +1,19 @@
+module Skeleton
+  class Presenter
+    def initialize(object)
+      @object = object
+    end
+
+    def method_missing(m, *args, &blk)
+      if @object.respond_to?(m)
+        @object.__send__ m, *args, &blk
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(m, include_private = false)
+      @object.respond_to?(m, include_private)
+    end
+  end
+end

data/lib/skeleton/property.rb

@@ -0,0 +1,6 @@
+require 'skeleton/schema'
+
+module Skeleton
+  class Property < Schema
+  end
+end

data/lib/skeleton/response.rb

@@ -1,59 +1,38 @@
-require 'skeleton/model'
-require 'skeleton/headers'
 require 'skeleton/schema'
+require 'skeleton/header'
 
 module Skeleton
-  class Response < Model
-    attr_accessor :description
-    attr_reader :headers, :schema
-    attr_presence :descriptions, :examples
-    attr_not_empty :headers, :schema
-
-    def headers=(value)
-      case value
-      when Hash
-        @headers = Skeleton::Headers.new(value)
-      else
-        @headers = value
-      end
+  class Response < Schema
+    attr_accessor :summary, :description
+
+    alias_method :summarize, :summary=
+    alias_method :describe, :description=
+
+    def headers
+      @headers ||= {}
     end
 
-    def schema=(value)
-      case value
-      when Hash
-        @schema = Skeleton::Schema.new(value)
-      else
-        @schema = value
-      end
+    def no_body
+      @schema = nil
     end
 
-    def examples=(value)
-      case value
-      when Hash
-        @examples = Skeleton::Example.new(value)
-      else
-        @examples = value
-      end
+    def schema?
+      !!@schema
     end
 
-    def to_h
-      hash = {}
-      hash[:description] = description   if description?
-      hash[:examples]    = examples.to_h if examples?
-      hash[:headers]     = headers.to_h  if headers?
-      hash[:schema]      = schema.to_h   if schema?
-      hash[:examples]    = examples.to_h if examples?
-      hash
+    def schema(value=nil, &block)
+      if block
+        @schema = Skeleton::Model.new
+        @schema.instance_eval(&block)
+      elsif value.is_a?(Hash)
+        @schema = Skeleton::Schema.new(value)
+      end
+
+      @schema
     end
 
-    def to_swagger_hash
-      hash = {}
-      hash[:description] = description              if description?
-      hash[:examples]    = examples.to_swagger_hash if examples?
-      hash[:headers]     = headers.to_swagger_hash  if headers?
-      hash[:schema]      = schema.to_swagger_hash   if schema?
-      hash[:examples]    = examples.to_swagger_hash if examples?
-      hash
+    def header(field, options={})
+      headers[field] = Skeleton::Header.new(options)
     end
   end
 end

data/lib/skeleton/schema.rb

@@ -1,70 +1,87 @@
-require 'skeleton/model'
+require 'skeleton/attributes'
 
 module Skeleton
-  class Schema < Model
-    attr_accessor :ref, :type, :format, :title, :description, :default,
-                  :multiple_of, :maximum, :exclusive_maximum, :minimum,
-                  :exclusive_minimum, :max_length, :min_length, :pattern,
-                  :max_items, :min_items, :unique_items, :max_properties,
-                  :min_properties, :required, :enum, :discriminator, :read_only,
-                  :xml, :external_docs, :example
-
-    attr_presence :required, :exclusive_maximum, :exclusive_minimum,
-                  :unique_items, :discriminator, :read_only, :xml,
-                  :external_docs, :example
-
-    def to_h
-      hash = {}
-      hash[:type]              = type              if type?
-      hash[:format]            = format            if format?
-
-      hash[:items] = items.to_hash if items?
-
-      hash[:title]             = title             if title?
-      hash[:description]       = description       if description?
-      hash[:default]           = default           if default?
-      hash[:multiple_of]       = multiple_of       if multiple_of?
-      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[:pattern]           = pattern           if pattern?
-      hash[:max_items]         = max_items         if max_items?
-      hash[:min_items]         = min_items         if min_items?
-      hash[:unique_items]      = unique_items      if unique_items?
-      hash[:max_properties]    = max_properties    if max_properties?
-      hash[:min_properties]    = min_properties    if min_properties?
-      hash[:enum]              = enum              if enum?
-      hash
+  # @abstract This is simply an abstract class
+  class Schema
+    extend Skeleton::Attributes
+
+    PRIMITIVES = %w(string number integer boolean array file)
+
+    attr_accessor :ref, :title, :description, :default, :maximum,
+      :exclusive_maximum, :minimum, :exclusive_minimum, :max_length,
+      :min_length, :pattern, :max_items, :min_items, :unique_items,
+      :max_properties, :min_properties, :required, :multiple_of
+
+    attr_reader :type, :format, :items
+
+    attr_presence :ref, :title, :description, :default, :maximum,
+      :exclusive_maximum, :minimum, :exclusive_minimum, :max_length,
+      :min_length, :pattern, :max_items, :min_items, :unique_items,
+      :max_properties, :min_properties, :required, :format, :multiple_of,
+      :items
+
+    def initialize(args={})
+      args.each do |k, v|
+        setter = "#{k}="
+        self.send(setter, v) if self.respond_to?(setter)
+      end
+    end
+
+    def items=(value)
+      case value
+      when Hash
+        @items = Skeleton::Items.new(value)
+      else
+        @items = value
+      end
+    end
+
+    def properties
+      @properties ||= {}
+    end
+
+    def properties?
+      !properties.empty?
+    end
+
+    def enum
+      @enum ||= []
+    end
+
+    def format=(value)
+      @format = value.to_s
+    end
+
+    def type=(value)
+      @type = value.to_s
+    end
+
+    def primitive?
+      PRIMITIVES.include?(@type)
+    end
+
+    def array?
+      @type == 'array'
+    end
+
+    def string?
+      @type == 'string'
+    end
+
+    def number?
+      @type == 'number'
+    end
+
+    def integer?
+      @type == 'integer'
+    end
+
+    def boolean?
+      @type == 'boolean'
     end
 
-    def to_swagger_hash
-      hash = {}
-      hash[:type]             = type              if type?
-      hash[:format]           = format            if format?
-
-      hash[:items] = items.to_swagger_hash if items?
-
-      hash[:title]            = title             if title?
-      hash[:description]      = description       if description?
-      hash[:default]          = default           if default?
-      hash[:multipleOf]       = multiple_of       if multiple_of?
-      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[:pattern]          = pattern           if pattern?
-      hash[:maxItems]         = max_items         if max_items?
-      hash[:minItems]         = min_items         if min_items?
-      hash[:uniqueItems]      = unique_items      if unique_items?
-      hash[:maxProperties]    = max_properties    if max_properties?
-      hash[:minProperties]    = min_properties    if min_properties?
-      hash[:enum]             = enum              if enum?
-      hash
+    def file?
+      @type == 'file'
     end
   end
 end