skooma 0.3.4 → 0.3.6

data/data/oas-3.1/schema-base/2025-02-13.json

@@ -0,0 +1,25 @@
+{
+  "$id": "https://spec.openapis.org/oas/3.1/schema-base/2025-02-13",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "description": "The description of OpenAPI v3.1.x Documents using the OpenAPI JSON Schema dialect",
+  "$ref": "https://spec.openapis.org/oas/3.1/schema/2025-02-13",
+  "properties": {
+    "jsonSchemaDialect": {
+      "$ref": "#/$defs/dialect"
+    }
+  },
+  "$defs": {
+    "dialect": {
+      "const": "https://spec.openapis.org/oas/3.1/dialect/2024-11-10"
+    },
+    "schema": {
+      "$dynamicAnchor": "meta",
+      "$ref": "https://spec.openapis.org/oas/3.1/dialect/2024-11-10",
+      "properties": {
+        "$schema": {
+          "$ref": "#/$defs/dialect"
+        }
+      }
+    }
+  }
+}

data/lib/skooma/coverage.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Skooma
   class NoopCoverage
     def track_request(*)
@@ -24,7 +26,7 @@ module Skooma
       end
     end
 
-    def self.new(schema, mode: nil, format: nil)
+    def self.new(schema, mode: nil, format: nil, storage: nil)
       case mode
       when nil, false
         NoopCoverage.new
@@ -35,14 +37,23 @@ module Skooma
       end
     end
 
-    attr_reader :mode, :format, :defined_paths, :covered_paths, :schema
+    attr_reader :mode, :format, :defined_paths, :storage, :schema
+    attr_accessor :covered_paths
 
-    def initialize(schema, mode:, format:)
+    def initialize(schema, mode:, format:, storage:)
       @schema = schema
       @mode = mode
       @format = format || SimpleReport
-      @defined_paths = find_defined_paths(schema)
-      @covered_paths = Set.new
+      @storage = storage || CoverageStore.new
+
+      stored_data = @storage.load_data
+      @defined_paths = stored_data[:defined_paths]
+      @covered_paths = stored_data[:covered_paths]
+
+      if @defined_paths.empty?
+        @defined_paths = find_defined_paths(schema)
+        @storage.save_data(@defined_paths, @covered_paths)
+      end
     end
 
     def track_request(result)
@@ -57,6 +68,7 @@ module Skooma
         end
       end
       covered_paths << operation
+      storage.save_data(Set.new, Set.new([operation]))
     end
 
     def uncovered_paths
@@ -68,7 +80,10 @@ module Skooma
     end
 
     def report
+      stored_data = storage.load_data
+      self.covered_paths = stored_data[:covered_paths]
       format.new(self).report
+      storage.clear
       exit 1 if mode == :strict && uncovered_paths.any?
     end
 

data/lib/skooma/coverage_store.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Skooma
+  class CoverageStore
+    DEFAULT_FILE_PATH = File.join(Dir.pwd, "tmp", "skooma_coverage.json")
+
+    attr_reader :file_path
+
+    def initialize(file_path: DEFAULT_FILE_PATH)
+      @file_path = file_path
+      ensure_file_exists
+    end
+
+    def load_data
+      with_lock("r") do |file|
+        parse_data(file.read)
+      end
+    end
+
+    def save_data(new_defined_paths, new_covered_paths)
+      with_lock("r+") do |file|
+        existing_data = parse_data(file.read)
+        merged_data = merge_data(existing_data, new_defined_paths, new_covered_paths)
+
+        file.rewind
+        file.write(JSON.generate(merged_data))
+        file.flush
+        file.truncate(file.pos)
+      end
+    end
+
+    def clear
+      File.delete(file_path) if File.exist?(file_path)
+    end
+
+    private
+
+    def ensure_file_exists
+      FileUtils.mkdir_p(File.dirname(@file_path))
+      FileUtils.touch(@file_path) unless File.exist?(@file_path)
+    end
+
+    def parse_data(content)
+      return {defined_paths: Set.new, covered_paths: Set.new} if content.strip.empty?
+
+      data = JSON.parse(content, symbolize_names: true)
+      {
+        defined_paths: Set.new(data[:defined_paths]),
+        covered_paths: Set.new(data[:covered_paths])
+      }
+    end
+
+    def merge_data(existing_data, new_defined_paths, new_covered_paths)
+      {
+        defined_paths: (existing_data[:defined_paths] | new_defined_paths).to_a,
+        covered_paths: (existing_data[:covered_paths] | new_covered_paths).to_a
+      }
+    end
+
+    def with_lock(mode)
+      File.open(@file_path, mode) do |file|
+        file.flock(File::LOCK_EX)
+        yield(file)
+      ensure
+        file.flock(File::LOCK_UN)
+      end
+    end
+  end
+end

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

@@ -22,7 +22,7 @@ module Skooma
               properties_result = result.sibling(instance, "properties")
               instance.each_key do |name|
                 res = properties_result&.children&.[](instance[name]&.path)&.[]name
-                forbidden << name.tap { puts "adding #{name}" } if annotation_exists?(res, key: only_key)
+                forbidden << name.tap { puts "adding #{name}" } if res && annotation_exists?(res, key: only_key)
               end
             end
 

data/lib/skooma/matchers/wrapper.rb

@@ -44,7 +44,7 @@ module Skooma
         end
       end
 
-      def initialize(helper_methods_module, openapi_path, base_uri: "https://skoomarb.dev/", path_prefix: "", enforce_access_modes: false, **params)
+      def initialize(helper_methods_module, openapi_path, base_uri: "https://skoomarb.dev/", path_prefix: "", enforce_access_modes: false, use_patterns_for_path_matching: false, **params)
         super()
 
         registry = create_test_registry
@@ -59,7 +59,12 @@ module Skooma
         @schema.path_prefix = path_prefix
         @schema.enforce_access_modes = enforce_access_modes
 
-        @coverage = Coverage.new(@schema, mode: params[:coverage], format: params[:coverage_format])
+        storage = Skooma::CoverageStore.new(
+          file_path: File.join(Dir.pwd, "tmp", "skooma_coverage_#{Digest::SHA256.hexdigest(source_uri)[0..8]}.json")
+        )
+        @coverage = Coverage.new(@schema, mode: params[:coverage], format: params[:coverage_format], storage: storage)
+
+        @schema.use_patterns_for_path_matching = use_patterns_for_path_matching
 
         include DefaultHelperMethods
         include helper_methods_module

data/lib/skooma/minitest.rb

@@ -39,7 +39,9 @@ module Skooma
     def initialize(openapi_path, **params)
       super(HelperMethods, openapi_path, **params)
 
-      ::Minitest.after_run { coverage.report }
+      ::Minitest.after_run do
+        coverage.report
+      end
     end
   end
 end

data/lib/skooma/objects/components.rb

@@ -9,12 +9,12 @@ module Skooma
         "schemas" => JSONSkooma::JSONSchema,
         "responses" => Response,
         "parameters" => Parameter,
-        # "examples" => Example,
+        "examples" => JSONSkooma::JSONNode,
         "requestBodies" => RequestBody,
         "headers" => Header,
         "securitySchemes" => JSONSkooma::JSONNode,
         "links" => JSONSkooma::JSONNode,
-        # "callbacks" => Callback,
+        "callbacks" => JSONSkooma::JSONNode,
         "pathItems" => PathItem
       }
 

data/lib/skooma/objects/openapi/keywords/openapi.rb

@@ -12,7 +12,12 @@ module Skooma
               raise Error, "Only OpenAPI version 3.1.x is supported, got #{value}"
             end
 
-            parent_schema.metaschema_uri = "https://spec.openapis.org/oas/3.1/schema-base/2022-10-07"
+            parent_schema.metaschema_uri = if value.to_s.start_with? "3.1.0"
+              "https://spec.openapis.org/oas/3.1/schema-base/2022-10-07"
+            else
+              "https://spec.openapis.org/oas/3.1/schema-base/2025-02-13"
+            end
+
             parent_schema.json_schema_dialect_uri = "https://spec.openapis.org/oas/3.1/dialect/base"
 
             super

data/lib/skooma/objects/openapi/keywords/paths.rb

@@ -13,14 +13,6 @@ module Skooma
 
           def initialize(parent_schema, value)
             super
-            @regexp_map = json.filter_map do |path, subschema|
-              next unless path.include?("{") && path.include?("}")
-
-              path_regex = path.gsub(ROUTE_REGEXP, "(?<\\1>[^/?#]+)")
-              path_regex = Regexp.new("\\A#{path_regex}\\z")
-
-              [path, path_regex, subschema]
-            end
           end
 
           def evaluate(instance, result)
@@ -44,11 +36,34 @@ module Skooma
 
           private
 
+          def regexp_map
+            @regexp_map ||= json.filter_map do |path, subschema|
+              next unless path.include?("{") && path.include?("}")
+
+              pattern_hash = if json.root.use_patterns_for_path_matching?
+                create_hash_of_patterns(subschema)
+              else
+                {}
+              end
+
+              path_regex = path.gsub(ROUTE_REGEXP) do |match|
+                param = match[1..-2]
+                if pattern_hash.key?(param)
+                  "(?<#{param}>#{pattern_hash[param]})"
+                else
+                  "(?<#{param}>[^/?#]+)"
+                end
+              end
+              path_regex = Regexp.new("\\A#{path_regex}\\z")
+
+              [path, path_regex, subschema]
+            end
+          end
+
           def find_route(instance_path)
             instance_path = instance_path.delete_prefix(json.root.path_prefix)
             return [instance_path, {}, json[instance_path]] if json.key?(instance_path)
-
-            @regexp_map.reduce(nil) do |result, (path, path_regex, subschema)|
+            regexp_map.reduce(nil) do |result, (path, path_regex, subschema)|
               next result unless path.include?("{") && path.include?("}")
 
               match = instance_path.match(path_regex)
@@ -58,6 +73,57 @@ module Skooma
               [path, match.named_captures, subschema]
             end
           end
+
+          def get_child(parent, child_name)
+            if parent
+              parent_to_use = if parent.key?("$ref")
+                parent.resolve_ref(parent["$ref"])
+              else
+                parent
+              end
+              if parent_to_use.key?(child_name)
+                parent_to_use[child_name]
+              end
+            end
+          end
+
+          def create_hash_of_patterns(subschema)
+            output = {}
+            parameters = []
+            parameters = parameters.concat(subschema["parameters"]) if subschema["parameters"]
+            %w[get post put patch delete].each do |method|
+              parameters = parameters.concat(subschema[method]["parameters"]) if subschema[method] && subschema[method]["parameters"]
+            end
+            parameters.each do |parameter|
+              if get_child(parameter, "in") == "path"
+                pattern = "[^/?#]+"
+                new_pattern = get_child(parameter, "pattern")
+                pattern = new_pattern if new_pattern
+                new_pattern = get_child(get_child(parameter, "schema"), "pattern")
+                pattern = new_pattern if new_pattern
+
+                output[get_child(parameter, "name").to_s] = filter_pattern(pattern)
+              end
+            end
+            output
+          end
+
+          def filter_pattern(pattern)
+            to_return = pattern.to_s
+            if to_return.start_with?("^")
+              to_return = to_return[1..]
+            end
+            if to_return.start_with?('\A')
+              to_return = to_return[2..]
+            end
+            if to_return.end_with?("$")
+              to_return = to_return[0..-2]
+            end
+            if to_return.end_with?('\Z', '\z')
+              to_return = to_return[0..-3]
+            end
+            to_return
+          end
         end
       end
     end

data/lib/skooma/objects/openapi.rb

@@ -49,6 +49,16 @@ module Skooma
         @enforce_access_modes
       end
 
+      def use_patterns_for_path_matching=(value)
+        raise ArgumentError, "Use patterns for path matching must be a boolean" unless [true, false].include?(value)
+
+        @use_patterns_for_path_matching = value
+      end
+
+      def use_patterns_for_path_matching?
+        @use_patterns_for_path_matching
+      end
+
       def path_prefix
         @path_prefix || ""
       end

data/lib/skooma/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Skooma
-  VERSION = "0.3.4"
+  VERSION = "0.3.6"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: skooma
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.3.6
 platform: ruby
 authors:
 - Svyatoslav Kryukov
 bindir: bin
 cert_chain: []
-date: 2025-01-14 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zeitwerk
@@ -47,13 +47,18 @@ files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
+- data/oas-3.1/dialect/2024-11-10.json
 - data/oas-3.1/dialect/base.json
+- data/oas-3.1/meta/2024-11-10.json
 - data/oas-3.1/meta/base.json
 - data/oas-3.1/schema-base/2022-10-07.json
+- data/oas-3.1/schema-base/2025-02-13.json
 - data/oas-3.1/schema/2022-10-07.json
+- data/oas-3.1/schema/2025-02-13.json
 - lib/skooma.rb
 - lib/skooma/body_parsers.rb
 - lib/skooma/coverage.rb
+- lib/skooma/coverage_store.rb
 - lib/skooma/dialects/oas_3_1.rb
 - lib/skooma/env_mapper.rb
 - lib/skooma/inflector.rb
@@ -165,7 +170,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Validate API implementations against OpenAPI documents.
 test_files: []