apiture 0.2.0

data/lib/apiture/swagger/external_docs.rb

@@ -0,0 +1,10 @@
+require 'apiture/swagger/node'
+
+module Apiture
+  module Swagger
+    class ExternalDocs < Node
+      attribute :description
+      attribute :url
+    end
+  end
+end

data/lib/apiture/swagger/info.rb

@@ -0,0 +1,14 @@
+require 'apiture/swagger/node'
+
+module Apiture
+  module Swagger
+    class Info < Node
+      attribute :title
+      attribute :description
+      attribute :terms_of_service
+      attribute :contact
+      attribute :license
+      attribute :version
+    end
+  end
+end

data/lib/apiture/swagger/node.rb

@@ -0,0 +1,149 @@
+require 'apiture/utils/inflections'
+
+module Apiture
+  module Swagger
+    class Node
+      include Apiture::Utils::Inflections
+
+      class << self
+        def inherited(base)
+          base.instance_variable_set(:@attribute_names, attribute_names.dup)
+          base.instance_variable_set(:@list_names, list_names.dup)
+          base.instance_variable_set(:@hash_names, hash_names.dup)
+        end
+
+        def attribute_names
+          @attribute_names || []
+        end
+
+        def list_names
+          @list_names || []
+        end
+
+        def hash_names
+          @hash_names || []
+        end
+
+        def attribute(name, options = {})
+          name = name.to_sym
+          (@attribute_names ||= []) << name
+          attr_accessor name
+          if options[:type] == :boolean
+            define_method("#{name}?".to_sym) do
+              !!send(name)
+            end
+          elsif options[:symbolize]
+            define_method("#{name}=".to_sym) do |value|
+              instance_variable_set("@#{name}".to_sym, value.nil? ? nil : value.to_sym)
+            end
+          end
+          (@validates_children ||= []) << name if options[:validate]
+        end
+
+        def list(name, options = {})
+          attr_accessor name
+          (@list_names ||= []) << name
+          (@validates_children ||= []) << name if options[:validate]
+        end
+
+        def hash(name, options = {})
+          attr_accessor name
+          (@hash_names ||= []) << name
+          (@validates_children ||= []) << name if options[:validate]
+        end
+
+        def collect_errors(node, all_errors = [])
+          if @validates_children
+            @validates_children.each do |name|
+              if attr_val = node.send(name)
+                if @hash_names && @hash_names.include?(name)
+                  attr_val.each_pair { |k,v| v.collect_errors(all_errors) }
+
+                elsif @list_names && @list_names.include?(name)
+                  attr_val.each { |v| v.collect_errors(all_errors) }
+
+                else
+                  unless attr_val.respond_to? :collect_errors
+                    raise "Expecting #{name} to be a node"
+                  end
+                  attr_val.collect_errors(all_errors)
+                end
+              end
+            end
+          end
+          all_errors
+        end
+      end
+
+      attr_reader :errors
+
+      def initialize
+        @errors = []
+      end
+
+      def extensions
+        @extensions ||= {}
+      end
+
+      def validate
+      end
+
+      def valid?
+        validate
+        @errors.any?
+      end
+
+      def collect_errors(all_errors = [])
+        validate; all_errors.concat(errors)
+        self.class.collect_errors(self, all_errors)
+      end
+
+      def serializable_hash
+        h = {}
+
+        if self.class.attribute_names
+          self.class.attribute_names.each do |nm|
+            if v = __send__(nm)
+              h[camelize(nm, false)] = value_or_serializable_hash(v)
+            end
+          end
+        end
+
+        if self.class.list_names
+          self.class.list_names.each do |nm|
+            if arr = __send__(nm)
+              result = arr.map do |v|
+                value_or_serializable_hash(v)
+              end
+              h[camelize(nm, false)] = result if result.any?
+            end
+          end
+        end
+
+        if self.class.hash_names
+          self.class.hash_names.each do |nm|
+            if value_hash = __send__(nm)
+              result = value_hash.reduce({}) do |m,(k,v)|
+                m[k] = value_or_serializable_hash(v); m
+              end
+              h[camelize(nm, false)] = result if result.any?
+            end
+          end
+        end
+
+        h
+      end
+
+      def to_json
+        MultiJson.dump(serializable_hash)
+      end
+      alias :to_s :to_json
+
+      private
+
+        def value_or_serializable_hash(v)
+          v.respond_to?(:serializable_hash) ? v.serializable_hash : v
+        end
+    end
+  end
+end

data/lib/apiture/swagger/operation.rb

@@ -0,0 +1,32 @@
+require 'apiture/swagger/node'
+require 'apiture/swagger/parameter'
+
+module Apiture
+  module Swagger
+    class Operation < Node
+      attr_reader :id
+      alias :method_name :id
+
+      attribute :summary
+      attribute :description
+      attribute :external_docs, validate: true
+      attribute :operation_id
+      attribute :deprecated
+
+      list :tags
+      list :consumes
+      list :produces
+      list :parameters, validate: true
+      list :responses, validate: true
+      list :schemes
+
+      hash :security_definitions, validate: true
+      hash :security, validate: true
+
+      def initialize(id)
+        super()
+        @id = id
+      end
+    end
+  end
+end

data/lib/apiture/swagger/parameter.rb

@@ -0,0 +1,35 @@
+require 'apiture/swagger/data_type_field'
+
+module Apiture
+  module Swagger
+    class Parameter < DataTypeField
+      VALID_TYPES = %w(
+        string
+        number
+        integer
+        boolean
+        array
+        file
+      )
+
+      attribute :name
+      attribute :in, symbolize: true
+      attribute :description
+      attribute :required, type: :boolean
+      attribute :schema
+
+      def schema?
+        !!schema
+      end
+
+      def validate
+        if self.in.nil?
+          errors << "in attribute is required"
+        end
+        if self.in == :path && !required?
+          errors << "Path parameters must be defined as required"
+        end
+      end
+    end
+  end
+end

data/lib/apiture/swagger/parser.rb

@@ -0,0 +1,148 @@
+require 'multi_json'
+require 'yaml'
+require 'apiture/utils/inflections'
+require 'apiture/swagger/specification'
+
+
+module Apiture
+  module Swagger
+
+    class ParseError < Exception; end
+
+    class Parser
+      include Apiture::Utils::Inflections
+
+      def parse_json(spec)
+        build_specification(MultiJson.load(spec))
+      end
+      alias :parse :parse_json
+
+      def parse_yaml(spec)
+        build_specification(YAML.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.consumes = json['consumes'] || []
+        build_security_definition_hash(specification, json)
+        build_security_hash(specification, json)
+        specification.paths = build_node_hash(Path, json, 'paths') do |path, path_json|
+          trace = [path.id]
+          [:get, :put, :post, :delete, :options, :head, :patch].each do |method|
+            if op_json = path_json[method.to_s]
+              trace.unshift(method)
+              op = build_node(Operation, op_json, constructor_args: [method], trace: trace)
+              op.external_docs = build_node(ExternalDocs, op_json['externalDocs'], trace: trace)
+              op.parameters = build_node_list(Parameter, op_json, 'parameters', trace: trace) do |param, param_json|
+                trace.unshift(param_json["name"])
+                if param_json["schema"] && param_json["schema"].kind_of?(Hash)
+                  trace.unshift("schema")
+                  schema_json = param_json["schema"]
+                  param.schema = build_node(Definition, schema_json, trace: trace)
+                  build_schema_content(param.schema, schema_json)
+                  trace.shift
+                end
+                trace.shift
+              end
+              build_security_definition_hash(op, json)
+              build_security_hash(op, op_json)
+              path.send("#{method}=".to_sym, op)
+              trace.shift
+            end
+          end
+          trace.shift
+        end
+        specification.definitions = build_node_hash(Definition, json, 'definitions') do |definition, def_json|
+          build_schema_content(definition, def_json)
+        end
+        specification
+      end
+
+      protected
+
+        def build_schema_content(definition, def_json)
+           definition.properties = build_node_hash(Property, def_json, 'properties') do |prop, prop_json|
+            prop.enum = prop_json["enum"]
+            prop.items = prop_json["items"]
+          end
+        end
+
+        def build_security_hash(parent_node, json)
+          # leave security nil to defer security to parent. An empty hash means
+          # no security.
+          if sec_json = json['security']
+            parent_node.security = sec_json.reduce({}) do |memo, (k,v)|
+              memo[k] = security = Security.new(k)
+              security.scopes = v
+              memo
+            end
+          end
+        end
+
+        def build_security_definition_hash(parent_node, json)
+          if json['securityDefinitions']
+            parent_node.security_definitions = build_node_hash(SecurityDefinition, json, 'securityDefinitions')
+          end
+        end
+
+        def build_node(model_class, json, options = {})
+          if json
+            model = if constructor_args = options[:constructor_args]
+              model_class.new(*constructor_args)
+            else
+              model_class.new
+            end
+            model_class.attribute_names.each do |att|
+              model.send("#{att}=".to_sym, json[camelize(att.to_s, false)])
+            end
+            assert_type json, Hash, "expecting object node", options[:trace]
+            json.each_pair do |key, value|
+              if key.match(/^x-/)
+                extension_name = underscore(key.sub(/^x-/, '')).to_sym
+                model.extensions[extension_name] = value
+              end
+            end
+            model
+          end
+        end
+
+        def build_node_list(model_class, json, json_list_key, options = {})
+          trace = options[:trace] || []
+          trace.unshift(json_list_key)
+          node_list = []
+          if json_list = json[json_list_key]
+            assert_type json_list, Array, "expecting list", trace
+            node_list = json_list.map do |node_json|
+              node = build_node(model_class, node_json, trace: trace)
+              yield(node, node_json) if block_given?
+              node
+            end
+          end
+          trace.unshift
+          node_list
+        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, constructor_args: [k])
+            yield(node, v) if block_given?
+            m
+          end
+        end
+
+        def assert_type target, expected_type, message, trace
+          unless target.kind_of?(expected_type)
+            if trace
+              message = "[#{trace.reverse.join(" / ")}] - #{message}: #{target.class.name}"
+            end
+            raise ParseError, message
+          end
+        end
+
+    end
+  end
+end

data/lib/apiture/swagger/path.rb

@@ -0,0 +1,37 @@
+require 'apiture/swagger/node'
+require 'apiture/swagger/operation'
+
+module Apiture
+  module Swagger
+    class Path < Node
+      attr_reader :id
+      alias :path_name :id
+
+      REQUEST_METHODS = [:get, :put, :post, :delete, :options, :head, :patch]
+
+      REQUEST_METHODS.each do |m|
+        attribute m, validate: true
+      end
+
+      list :parameters, validate: true
+
+      def initialize(id)
+        super()
+        @id = id
+      end
+
+      def operations
+        REQUEST_METHODS.map { |m| __send__(m) }.compact
+      end
+
+      def operations_map
+        REQUEST_METHODS.reduce({}) do |m, method|
+          if op = __send__(method)
+            m[method] = op
+          end
+          m
+        end
+      end
+    end
+  end
+end

data/lib/apiture/swagger/property.rb

@@ -0,0 +1,15 @@
+require 'apiture/swagger/data_type_field'
+
+module Apiture
+  module Swagger
+    class Property < DataTypeField
+      attr_reader :id
+
+      def initialize(id)
+        super()
+        @id = id
+      end
+
+    end
+  end
+end