skooma 0.1.0

data/data/oas-3.1/schema-base/2022-10-07.json

@@ -0,0 +1,23 @@
+{
+  "$id": "https://spec.openapis.org/oas/3.1/schema-base/2022-10-07",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+
+  "description": "The description of OpenAPI v3.1.x documents using the OpenAPI JSON Schema dialect, as defined by https://spec.openapis.org/oas/v3.1.0",
+
+  "$ref": "https://spec.openapis.org/oas/3.1/schema/2022-10-07",
+  "properties": {
+    "jsonSchemaDialect": { "$ref": "#/$defs/dialect" }
+  },
+
+  "$defs": {
+    "dialect": { "const": "https://spec.openapis.org/oas/3.1/dialect/base" },
+
+    "schema": {
+      "$dynamicAnchor": "meta",
+      "$ref": "https://spec.openapis.org/oas/3.1/dialect/base",
+      "properties": {
+        "$schema": { "$ref": "#/$defs/dialect" }
+      }
+    }
+  }
+}

data/lib/skooma/body_parsers.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Skooma
+  module BodyParsers
+    class << self
+      DEFAULT_PARSER = ->(body) { body }
+
+      def [](media_type)
+        parsers[media_type.to_s.strip.downcase] || DEFAULT_PARSER
+      end
+
+      attr_accessor :parsers
+
+      def register(*media_types, parser)
+        media_types.each do |media_type|
+          parsers[media_type.to_s.strip.downcase] = parser
+        end
+      end
+    end
+    self.parsers = {}
+
+    module JSONParser
+      def self.call(body)
+        JSON.parse(body)
+      rescue JSON::ParserError
+        body
+      end
+    end
+    register "application/json", JSONParser
+  end
+end

data/lib/skooma/dialects/oas_3_1.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Dialects
+    module OAS31
+      class << self
+        def call(registry, **options)
+          registry.add_source(
+            "https://spec.openapis.org/oas/3.1/",
+            JSONSkooma::Sources::Local.new(File.join(DATA_DIR, "oas-3.1").to_s, suffix: ".json")
+          )
+
+          registry.add_vocabulary(
+            "https://spec.openapis.org/oas/3.1/vocab/base",
+            Skooma::Keywords::OAS31::Dialect::Discriminator,
+            Skooma::Keywords::OAS31::Dialect::Xml,
+            Skooma::Keywords::OAS31::Dialect::ExternalDocs,
+            Skooma::Keywords::OAS31::Dialect::Example
+          )
+
+          registry.add_metaschema(
+            "https://spec.openapis.org/oas/3.1/dialect/base",
+            "https://json-schema.org/draft/2020-12/vocab/core",
+            "https://json-schema.org/draft/2020-12/vocab/applicator",
+            "https://json-schema.org/draft/2020-12/vocab/unevaluated",
+            "https://json-schema.org/draft/2020-12/vocab/validation",
+            "https://json-schema.org/draft/2020-12/vocab/format-annotation",
+            "https://json-schema.org/draft/2020-12/vocab/meta-data",
+            "https://json-schema.org/draft/2020-12/vocab/content",
+            "https://spec.openapis.org/oas/3.1/vocab/base"
+          )
+
+          registry.add_format("int32", Skooma::Validators::Int32)
+          registry.add_format("int64", Skooma::Validators::Int64)
+          registry.add_format("float", Skooma::Validators::Float)
+          registry.add_format("double", Skooma::Validators::Double)
+        end
+      end
+    end
+  end
+end

data/lib/skooma/inflector.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Skooma
+  class Inflector < Zeitwerk::Inflector
+    STATIC_MAPPING = {
+      "oas_3_1" => "OAS31",
+      "openapi" => "OpenAPI",
+      "rspec" => "RSpec"
+    }
+
+    def camelize(basename, _abspath)
+      if basename.include?("json_")
+        super.gsub("Json", "JSON")
+      else
+        STATIC_MAPPING[basename] || super
+      end
+    end
+  end
+end

data/lib/skooma/instance.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Skooma
+  class Instance < JSONSkooma::JSONNode
+    module Coercible
+      def coerce(json)
+        value = self&.value
+        return self if value.nil?
+
+        case json["type"]
+        when "integer"
+          begin
+            Integer(value, 10)
+          rescue ArgumentError
+            value
+          end
+        when "number"
+          begin
+            Float(value)
+          rescue ArgumentError
+            value
+          end
+        when "boolean"
+          return true if value == "true"
+
+          (value == "false") ? false : value
+        when "object"
+          value
+          # convert_object(value, schema)
+        when "array"
+          # convert_array(value, schema)
+          value
+        else
+          value
+        end
+      end
+    end
+
+    class Attribute < JSONSkooma::JSONNode
+      include Coercible
+
+      def initialize(value, **item_params)
+        super(value, **item_params.merge(item_class: Attribute))
+      end
+    end
+
+    class Headers < JSONSkooma::JSONNode
+      def [](key)
+        super(key.to_s.downcase)
+      end
+
+      private
+
+      def map_object_value(value)
+        value.map { |k, v| [k.to_s.downcase, Attribute.new(v, key: k.to_s, parent: self, **@item_params)] }.to_h
+      end
+    end
+
+    class Response < Attribute
+      private
+
+      def parse_value(value)
+        data = {}
+        data["status"] = JSONSkooma::JSONNode.new(value.fetch("status"), key: "status", parent: self)
+        data["headers"] = Headers.new(value.fetch("headers", {}), key: "headers", parent: self)
+        body_value = parse_body(value["body"], data["headers"]&.[]("Content-Type"))
+        data["body"] = Attribute.new(body_value, key: "body", parent: self)
+        ["object", data]
+      end
+
+      def parse_body(body, content_type)
+        return nil unless body
+
+        parser = BodyParsers[content_type&.split(";")&.first]
+        parser ? parser.call(body) : body
+      end
+    end
+
+    class Request < JSONSkooma::JSONNode
+      private
+
+      def parse_value(value)
+        data = {}
+        data["query"] = Attribute.new(value.fetch("query", ""), key: "query", parent: self)
+        data["headers"] = Headers.new(value.fetch("headers", {}), key: "headers", parent: self)
+        body_value = parse_body(value["body"], data["headers"]&.[]("Content-Type"))
+        data["body"] = Attribute.new(body_value, key: "body", parent: self)
+        ["object", data]
+      end
+
+      def parse_body(body, content_type)
+        return nil unless body
+
+        parser = BodyParsers[content_type&.split(";")&.first]
+        parser ? parser.call(body) : body
+      end
+    end
+
+    private
+
+    def parse_value(value)
+      data = {
+        "method" => JSONSkooma::JSONNode.new(value["method"], key: "method", parent: self),
+        "path" => JSONSkooma::JSONNode.new(value["path"], key: "path", parent: self)
+      }
+      data["request"] = Request.new(value["request"], key: "request", parent: self) if value["request"]
+      data["response"] = Response.new(value["response"], key: "response", parent: self) if value["response"]
+
+      ["object", data]
+    end
+  end
+end

data/lib/skooma/keywords/oas_3_1/dialect/discriminator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Keywords
+    module OAS31
+      module Dialect
+        class Discriminator < JSONSkooma::Keywords::BaseAnnotation
+          self.key = "discriminator"
+        end
+      end
+    end
+  end
+end

data/lib/skooma/keywords/oas_3_1/dialect/example.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Keywords
+    module OAS31
+      module Dialect
+        class Example < JSONSkooma::Keywords::BaseAnnotation
+          self.key = "example"
+        end
+      end
+    end
+  end
+end

data/lib/skooma/keywords/oas_3_1/dialect/external_docs.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Keywords
+    module OAS31
+      module Dialect
+        class ExternalDocs < JSONSkooma::Keywords::BaseAnnotation
+          self.key = "externalDocs"
+        end
+      end
+    end
+  end
+end

data/lib/skooma/keywords/oas_3_1/dialect/xml.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Keywords
+    module OAS31
+      module Dialect
+        class Xml < JSONSkooma::Keywords::BaseAnnotation
+          self.key = "xml"
+        end
+      end
+    end
+  end
+end

data/lib/skooma/keywords/oas_3_1/schema.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Keywords
+    module OAS31
+      class Schema < JSONSkooma::Keywords::Base
+        self.key = "schema"
+
+        def evaluate(instance, result)
+          json.evaluate(instance.coerce(json), result)
+        end
+
+        def each_schema
+          yield json
+        end
+
+        private
+
+        def wrap_value(value)
+          JSONSkooma::JSONSchema.new(
+            value,
+            key: key,
+            parent: parent_schema,
+            registry: parent_schema.registry,
+            cache_id: parent_schema.cache_id,
+            metaschema_uri: parent_schema.json_schema_dialect_uri
+          )
+        end
+      end
+    end
+  end
+end

data/lib/skooma/keywords/oas_3_1.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Keywords
+    module OAS31
+      module SchemaValue
+        def wrap_value(value)
+          return super unless value.is_a?(Hash) || value.is_a?(TrueClass) || value.is_a?(FalseClass)
+
+          Objects::OpenAPI.new(value, registry: parent_schema.registry, parent: parent_schema, key: key)
+        end
+
+        def each_schema
+          return super unless json.is_a?(Objects::OpenAPI)
+
+          yield json
+        end
+      end
+      JSONSkooma::Keywords::ValueSchemas.register_value_schema(:openapi_schema, SchemaValue)
+    end
+  end
+end

data/lib/skooma/objects/base/keywords/deprecated.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class Base
+      module Keywords
+        class Deprecated < JSONSkooma::Keywords::BaseAnnotation
+          self.key = "deprecated"
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/base/keywords/description.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class Base
+      module Keywords
+        class Description < JSONSkooma::Keywords::BaseAnnotation
+          self.key = "description"
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/base/keywords/security.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class Base
+      module Keywords
+        class Security < JSONSkooma::Keywords::BaseAnnotation
+          self.key = "security"
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/base/keywords/servers.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class Base
+      module Keywords
+        class Servers < JSONSkooma::Keywords::BaseAnnotation
+          self.key = "servers"
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/base/keywords/summary.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class Base
+      module Keywords
+        class Summary < JSONSkooma::Keywords::BaseAnnotation
+          self.key = "summary"
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/base/keywords/tags.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class Base
+      module Keywords
+        class Tags < JSONSkooma::Keywords::BaseAnnotation
+          self.key = "tags"
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/base.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class Base < JSONSkooma::JSONSchema
+      DEFAULT_OPTIONS = {
+        registry: REGISTRY_NAME
+      }.freeze
+
+      def initialize(value, **options)
+        super(value, **DEFAULT_OPTIONS.merge(options))
+      end
+
+      def bootstrap(value)
+        # nothing to do
+      end
+
+      def kw_classes
+        []
+      end
+
+      def json_schema_dialect_uri
+        root.json_schema_dialect_uri
+      end
+
+      private
+
+      def kw_class(k)
+        kw_classes.find { |kw| kw.key == k } || JSONSkooma::Keywords::Unknown[k]
+      end
+    end
+  end
+end

data/lib/skooma/objects/callback.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    # https://spec.openapis.org/oas/v3.1.0#callback-object
+    # A map of possible out-of band callbacks related to the parent operation.
+    class Callback < RefBase
+      def kw_classes
+      end
+    end
+  end
+end

data/lib/skooma/objects/components.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    # Holds a set of reusable objects for different aspects of the OAS.
+    # https://spec.openapis.org/oas/v3.1.0#components-object
+    class Components < JSONSkooma::JSONNode
+      CLASSES_MAP = {
+        "schemas" => JSONSkooma::JSONSchema,
+        "responses" => Response,
+        "parameters" => Parameter,
+        # "examples" => Example,
+        "requestBodies" => RequestBody,
+        "headers" => Header,
+        "securitySchemes" => JSONSkooma::JSONNode,
+        "links" => JSONSkooma::JSONNode,
+        # "callbacks" => Callback,
+        "pathItems" => PathItem
+      }
+
+      def map_object_value(value)
+        value.map do |k, v|
+          key = k.to_s
+          value = JSONSkooma::JSONNode.new(v, key: key, parent: self, item_class: CLASSES_MAP.fetch(key), **@item_params, metaschema_uri: parent.json_schema_dialect_uri)
+          [key, value]
+        end.to_h
+      end
+    end
+  end
+end

data/lib/skooma/objects/header/keywords/content.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class Header
+      module Keywords
+        class Content < JSONSkooma::Keywords::Base
+          self.key = "content"
+          self.value_schema = :object_of_schemas
+          self.schema_value_class = Objects::MediaType
+
+          def evaluate(instance, result)
+            return if instance&.value.nil?
+
+            media_type = result.root.instance["response"]["headers"]["Content-Type"]&.split(";")&.first&.strip&.downcase
+            media_type_object, matched_media_type = find_media_type(media_type)
+
+            return result.discard unless media_type_object
+
+            result.annotate(matched_media_type)
+            result.call(instance, matched_media_type) do |media_type_result|
+              media_type_object.evaluate(instance, media_type_result)
+              result.failure("Invalid content") unless media_type_result.passed?
+            end
+          end
+
+          private
+
+          # The key is a media type or media type range and the value describes it.
+          # For requests that match multiple keys, only the most specific key is applicable.
+          # e.g. text/plain overrides text/*
+          def find_media_type(media_type)
+            matched_media_type =
+              if json.key?(media_type)
+                media_type
+              elsif media_type &&
+                  (key = "#{media_type.split("/").first}/*") &&
+                  json.key?(key)
+                key
+              elsif json.key?("*/*")
+                "*/*"
+              end
+
+            [json[matched_media_type], matched_media_type]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/header/keywords/example.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class Header
+      module Keywords
+        class Example < JSONSkooma::Keywords::BaseAnnotation
+          self.key = "example"
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/header/keywords/examples.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class Header
+      module Keywords
+        class Examples < JSONSkooma::Keywords::BaseAnnotation
+          self.key = "examples"
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/header/keywords/explode.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class Header
+      module Keywords
+        class Explode < JSONSkooma::Keywords::BaseAnnotation
+          self.key = "explode"
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/header/keywords/required.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class Header
+      module Keywords
+        class Required < JSONSkooma::Keywords::Base
+          self.key = "required"
+
+          def evaluate(instance, result)
+            if json.value && instance.value.nil?
+              result.failure("Header is required")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/header/keywords/schema.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class Header
+      module Keywords
+        class Schema < Skooma::Keywords::OAS31::Schema
+          self.key = "schema"
+
+          def evaluate(instance, result)
+            return if instance.value.nil?
+
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/header/keywords/style.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class Header
+      module Keywords
+        class Style < JSONSkooma::Keywords::BaseAnnotation
+          self.key = "style"
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/header.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    # https://spec.openapis.org/oas/v3.1.0#header-object
+    # The Header Object follows the structure of the Parameter Object.
+    class Header < RefBase
+      def kw_classes
+        [
+          Base::Keywords::Description,
+          Base::Keywords::Deprecated,
+          Keywords::Style,
+          Keywords::Explode,
+          Keywords::Required,
+          Keywords::Schema,
+          Keywords::Example,
+          Keywords::Examples,
+          Keywords::Content
+        ]
+      end
+    end
+  end
+end