openapi_slicer 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7261d0affd63001036a1b223672a24cbad3e4cfe6422255d5cf3eee54cb6e994
+  data.tar.gz: 8e64dec7fb3c9dfcd9aa981e3c442562d11ee9e29b986fafff8542930a353f04
+SHA512:
+  metadata.gz: 507012991091f89621f4a6e2d7cc12d831326df7183c8823f2107a9bdc86de482eec0e58330064f3a61b70976e64a31f4141389267d8583d0cbbdf19a0cf96ca
+  data.tar.gz: b76b6c24c3b8d2ff23baafe2398ded1aee07d385ea037d8748f4e82cd15ea19a65428cacfa7d92c3e371a7785613f7130955ea1baf59cabaf589dab5652e77f9

data/README.md

@@ -0,0 +1,128 @@
+
+# OpenAPI Slicer
+
+`openapi_slicer` is a Ruby gem designed to extract specific parts of an OpenAPI specification (either in JSON or YAML format) based on a regular expression. It slices paths from the spec that match the given regex and ensures that all necessary tag and component dependencies are included in the result. You can export the filtered OpenAPI spec to a file in JSON or YAML format.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'openapi_slicer'
+```
+
+Then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install openapi_slicer
+```
+
+## Usage
+
+### Initializing the Slicer
+
+First, initialize an `OpenapiSlicer` instance by providing the path to a JSON or YAML OpenAPI spec file.
+
+```ruby
+require 'openapi_slicer'
+
+slicer = OpenapiSlicer.new(file_path: 'path/to/openapi_spec.yaml')
+```
+
+### Filtering by Paths
+
+To filter the OpenAPI spec based on a regular expression, use the `filter` method:
+
+```ruby
+# Filter the spec for all paths under '/pets'
+filtered_spec = slicer.filter(%r{^/pets})
+```
+
+This will return a new spec that contains only the paths that match `/pets`, along with all the necessary components, tags, and other dependencies.
+
+### Exporting the Filtered Spec
+
+You can also directly export the filtered spec to a file using the `export` method:
+
+```ruby
+# Export the filtered spec to a new JSON file
+slicer.export(%r{^/pets}, 'filtered_spec.json')
+
+# Or export to a YAML file
+slicer.export(%r{^/pets}, 'filtered_spec.yaml')
+```
+
+### Example
+
+Suppose you have the following paths in your OpenAPI spec:
+
+- `/pets`
+- `/pets/{petId}`
+- `/pets/{petId}/health`
+- `/owners/{ownerId}`
+
+Using the `filter` method, you can slice out only the paths under `/pets`:
+
+```ruby
+filtered_spec = slicer.filter(%r{^/pets})
+```
+
+This will return a spec containing:
+- `/pets`
+- `/pets/{petId}`
+- `/pets/{petId}/health`
+
+Any necessary `$ref` components or tag dependencies will also be included in the filtered spec.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run the tests using:
+
+```bash
+rake test
+```
+
+To install this gem onto your local machine, run:
+
+```bash
+bundle exec rake install
+```
+
+
+## Command-Line Interface (CLI)
+
+To use the CLI, run the `ruby scripts/openapi_slicer` command with the following options:
+
+- `-i`, `--input FILE`: **Required.** The path to the input OpenAPI specification file (in JSON or YAML format).
+- `-r`, `--regex REGEX`: **Required.** A regular expression used to filter the paths from the OpenAPI file.
+- `-o`, `--output FILE`: (Optional) The path where the filtered output will be saved. If not provided, the filtered result will be printed to the console.
+- `-h`, `--help`: Displays help information for the available options.
+
+### Example
+
+Filter an OpenAPI spec file and print the result to the console:
+```bash
+ruby scripts/openapi_slicer -i openapi.json -r '/api/v1/users'
+```
+
+Filter an OpenAPI spec file and save the result to an output file:
+```bash
+ruby scripts/openapi_slicer -i openapi.json -r '/api/v1/users' -o filtered_spec.json
+```
+
+If required options are missing, the CLI will display an error message and terminate.
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at [https://github.com/thescubageek/openapi_slicer](https://github.com/thescubageek/openapi_slicer).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/openapi_slicer.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "json"
+require "set"
+
+# OpenapiSlicer is a tool that slices an OpenAPI spec based on a regular expression,
+# and filters out necessary paths and components, ensuring that all dependent components
+# (schemas, parameters, etc.) are included.
+class OpenapiSlicer
+  # The current version of the OpenapiSlicer
+  VERSION = "0.2.0"
+
+  # @return [Hash] the OpenAPI specification loaded from the file
+  attr_accessor :spec
+
+  # Initializes the OpenapiSlicer.
+  #
+  # @param file_path [String] the path to the OpenAPI spec file (JSON or YAML)
+  # @raise [RuntimeError] if the file is not a JSON or YAML file
+  def initialize(file_path:)
+    raise "Invalid file type. Only JSON and YAML are supported." unless file_path.match?(/\.(json|ya?ml)$/)
+
+    @file_path = file_path
+    @spec = load_spec(file_path)
+    @components = {}
+    @tags = Set.new
+  end
+
+  # Filters the OpenAPI spec paths based on a regular expression and extracts the
+  # necessary components and tags.
+  #
+  # @param regex [Regexp] the regular expression to match against the paths
+  # @return [Hash] the filtered OpenAPI spec with paths and dependencies
+  def filter(regex)
+    paths = @spec["paths"].select { |path, _| path.match?(regex) }
+    dependencies = extract_dependencies(paths)
+    slice_spec(paths, dependencies)
+  end
+
+  # Exports the filtered OpenAPI spec to a file.
+  #
+  # @param regex [Regexp] the regular expression to match against the paths
+  # @param target_file [String] the file path to write the filtered spec to
+  def export(regex, target_file)
+    result = filter(regex)
+    File.open(target_file, "w") do |f|
+      if target_file.match?(/\.json$/)
+        f.write(result.to_json)
+      else
+        f.write(result.to_yaml)
+      end
+    end
+  end
+
+  private
+
+  # Loads the OpenAPI spec from the file.
+  #
+  # @param file_path [String] the path to the OpenAPI spec file
+  # @return [Hash] the loaded OpenAPI spec
+  def load_spec(file_path)
+    if file_path.end_with?(".json")
+      JSON.parse(File.read(file_path))
+    else
+      YAML.load_file(file_path)
+    end
+  end
+
+  # Extracts all component and tag dependencies from the filtered paths.
+  #
+  # @param paths [Hash] the filtered OpenAPI paths
+  # @return [Set] a set of dependencies found in the paths
+  def extract_dependencies(paths)
+    dependencies = Set.new
+    paths.each_value do |operations|
+      operations.each_value do |operation|
+        extract_from_operation(operation, dependencies)
+      end
+    end
+    dependencies
+  end
+
+  # Extracts $ref dependencies from a given operation.
+  #
+  # @param operation [Hash] the operation to extract dependencies from
+  # @param dependencies [Set] the set to store discovered dependencies
+  def extract_from_operation(operation, dependencies)
+    operation["parameters"]&.each { |param| resolve_ref(param["$ref"], dependencies) if param["$ref"] }
+    operation["responses"]&.each_value do |response|
+      resolve_response_refs(response, dependencies)
+    end
+    @tags.merge(operation["tags"]) if operation["tags"]
+  end
+
+  # Resolves component references recursively and adds them to the dependency set.
+  #
+  # @param ref [String] the $ref string pointing to a component
+  # @param dependencies [Set] the set to store discovered dependencies
+  def resolve_ref(ref, dependencies)
+    return unless ref
+
+    component = ref.split("/").last
+    return if dependencies.include?(component)
+
+    dependencies.add(component)
+
+    component_data = slice_component_data(component)
+    return unless component_data
+
+    resolve_component_property_refs(component_data, dependencies)
+    resolve_nested_refs(component_data, dependencies)
+  end
+
+  # Resolves response references recursively.
+  #
+  # @param response [Hash] the response object to resolve references from
+  # @param dependencies [Set] the set to store discovered dependencies
+  def resolve_response_refs(response, dependencies)
+    resolve_ref(response["$ref"], dependencies) if response["$ref"]
+    response["content"]&.each_value do |media_type|
+      resolve_ref(media_type.dig("schema", "$ref"), dependencies) if media_type.dig("schema", "$ref")
+    end
+  end
+
+  # Resolves references based on component properties
+  #
+  # @param component_data [Hash] component spec data
+  # @param dependencies []
+  def resolve_component_property_refs(component_data, dependencies)
+    return unless component_data&.[]("properties")
+
+    component_data["properties"].each_value do |property|
+      resolve_ref(property["$ref"], dependencies) if property["$ref"]
+    end
+  end
+
+
+  # Resolves references based on component properties
+  #
+  # @param component_data [Hash] component spec data
+  # @param dependencies []
+  def resolve_nested_refs(component_data, dependencies)
+    return unless component_data&.[]("allOf")
+
+    component_data["allOf"].each { |sub| resolve_ref(sub["$ref"], dependencies) if sub["$ref"] }
+  end
+
+  # Slices the component data from the specs
+  #
+  # @param component [String] component name
+  # @return [Hash|nil] component data from the specs
+  def slice_component_data(component)
+    @spec.dig("components", "schemas", component) ||
+      @spec.dig("components", "responses", component) ||
+      @spec.dig("components", "parameters", component) ||
+      @spec.dig("components", "requestBodies", component)
+  end
+
+  # Slices the spec, keeping only the filtered paths, components, and tags.
+  #
+  # @param paths [Hash] the filtered paths
+  # @param dependencies [Set] the set of component dependencies
+  # @return [Hash] the sliced OpenAPI spec
+  def slice_spec(paths, dependencies)
+    result = {
+      "openapi"    => @spec["openapi"],
+      "info"       => @spec["info"],
+      "paths"      => paths,
+      "components" => slice_components(dependencies),
+      "tags"       => slice_tags
+    }
+    result["servers"] = @spec["servers"] if @spec["servers"]
+    result
+  end
+
+  # Slices and retains only the necessary components.
+  #
+  # @param dependencies [Set] the set of component dependencies
+  # @return [Hash] the sliced components
+  def slice_components(dependencies)
+    sliced = {}
+    %w[schemas responses parameters requestBodies].each do |type|
+      next unless @spec["components"] && @spec["components"][type]
+
+      sliced[type] = @spec["components"][type].select { |name, _| dependencies.include?(name) }
+    end
+    sliced
+  end
+
+  # Slices and retains only the necessary tags.
+  #
+  # @return [Array] the sliced tags
+  def slice_tags
+    @spec["tags"]&.select { |tag| @tags.include?(tag["name"]) }
+  end
+end

data/scripts/openapi_slicer_cli.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require_relative '../lib/openapi_slicer'
+
+# Command-line interface (CLI) for the OpenAPI Slicer.
+# This class provides a way to interact with the OpenAPI Slicer via the command line,
+# allowing users to filter and export portions of an OpenAPI specification based on a regular expression.
+class OpenapiSlicerCLI
+  # @return [Hash] the options passed from the command line, including input file path, regex, and output file path.
+  attr_reader :options
+
+  # Initializes the CLI with arguments passed from the command line.
+  #
+  # @param argv [Array<String>] the array of arguments passed from the command line.
+  def initialize(argv)
+    @argv = argv
+    @options = {}
+  end
+
+  # Parses the command-line options using OptionParser.
+  # It expects the following options:
+  # - `-i`, `--input FILE`: The input OpenAPI file path (required).
+  # - `-r`, `--regex REGEX`: The regular expression used for filtering paths in the OpenAPI spec (required).
+  # - `-o`, `--output FILE`: The output file path to save the filtered result (optional).
+  # - `-h`, `--help`: Displays usage help.
+  def parse_options
+    OptionParser.new do |opts|
+      opts.banner = "Usage: openapi_slicer [options]"
+
+      opts.on("-i", "--input FILE", "Input OpenAPI file path") do |file|
+        options[:input_file] = file
+      end
+
+      opts.on("-r", "--regex REGEX", "Regex pattern for filtering") do |regex|
+        options[:regex] = regex
+      end
+
+      opts.on("-o", "--output FILE", "Output file path") do |file|
+        options[:output_file] = file
+      end
+
+      opts.on("-h", "--help", "Displays Help") do
+        puts opts
+        exit
+      end
+    end.parse!(@argv)
+  end
+
+  # Validates that the required options (`input_file` and `regex`) are provided.
+  # If any required option is missing, an error message is displayed, and the script exits with a non-zero status.
+  def validate_options
+    %i[input_file regex].each do |opt|
+      unless options[opt]
+        puts "Missing option: --#{opt.to_s.gsub('_', '-')}"
+        exit(1)
+      end
+    end
+  end
+
+  # Runs the CLI by parsing options, validating them, and invoking the OpenAPI Slicer.
+  # Depending on whether an output file is specified, it either prints the filtered result to the console
+  # or writes it to the output file.
+  def run
+    parse_options
+    validate_options
+
+    slicer = OpenapiSlicer.new(file_path: options[:input_file])
+    if options[:output_file]
+      slicer.export(options[:regex], options[:output_file])
+      puts "File created: #{options[:output_file]}"
+    else
+      pp slicer.filter(options[:regex])
+    end
+  end
+end
+
+# If this script is run directly, execute the CLI.
+if __FILE__ == $0
+  cli = OpenapiSlicerCLI.new(ARGV)
+  cli.run
+end

data/test/lib/openapi_slicer_test.rb

@@ -0,0 +1,180 @@
+# test_open_api_slicer.rb
+
+# frozen_string_literal: true
+
+require "test_helper"
+require "json"
+require "yaml"
+require_relative "../../lib/openapi_slicer"
+
+class OpenapiSlicerTest < Minitest::Test
+  def setup
+    # Create mock OpenAPI spec in both JSON and YAML format for testing
+    @mock_spec = {
+      "openapi" => "3.0.0",
+      "info" => { "title" => "Test API", "version" => "1.0.0" },
+      "paths" => {
+        "/pets" => {
+          "get" => {
+            "tags" => ["Pets"],
+            "responses" => {
+              "200" => {
+                "description" => "A list of pets",
+                "content" => {
+                  "application/json" => {
+                    "schema" => { "$ref" => "#/components/schemas/Pet" }
+                  }
+                }
+              }
+            }
+          }
+        },
+        "/pets/{petId}" => {
+          "get" => {
+            "tags" => ["Pets"],
+            "parameters" => [
+              { "$ref" => "#/components/parameters/PetId" }
+            ],
+            "responses" => {
+              "200" => {
+                "description" => "A pet",
+                "content" => {
+                  "application/json" => {
+                    "schema" => { "$ref" => "#/components/schemas/Pet" }
+                  }
+                }
+              }
+            }
+          }
+        },
+        "/pets/{petId}/health" => {
+          "get" => {
+            "tags" => ["Pets"],
+            "parameters" => [
+              { "$ref" => "#/components/parameters/PetId" }
+            ],
+            "responses" => {
+              "200" => {
+                "description" => "Pet health status",
+                "content" => {
+                  "application/json" => {
+                    "schema" => { "type" => "string" }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      "components" => {
+        "schemas" => {
+          "Pet" => {
+            "type" => "object",
+            "properties" => {
+              "id" => { "type" => "integer" },
+              "name" => { "type" => "string" }
+            }
+          }
+        },
+        "parameters" => {
+          "PetId" => {
+            "name" => "petId",
+            "in" => "path",
+            "required" => true,
+            "schema" => { "type" => "integer" }
+          }
+        }
+      },
+      "tags" => [{ "name" => "Pets", "description" => "Operations about pets" }]
+    }
+
+    # Save the mock spec to files
+    File.write("test_spec.json", @mock_spec.to_json)
+    File.write("test_spec.yaml", @mock_spec.to_yaml)
+  end
+
+  def teardown
+    # Clean up the created files
+    File.delete("test_spec.json")
+    File.delete("test_spec.yaml")
+    File.delete("sliced_spec.json") if File.exist?("sliced_spec.json")
+    File.delete("sliced_spec.yaml") if File.exist?("sliced_spec.yaml")
+  end
+
+  def test_initialize_raises_error_on_invalid_file_type
+    assert_raises(RuntimeError) do
+      ::OpenapiSlicer.new(file_path: "invalid.txt")
+    end
+  end
+
+  def test_initialize_loads_valid_json_file
+    slicer = ::OpenapiSlicer.new(file_path: "test_spec.json")
+    assert_equal "3.0.0", slicer.spec["openapi"]
+    assert_equal "Test API", slicer.spec["info"]["title"]
+  end
+
+  def test_initialize_loads_valid_yaml_file
+    slicer = ::OpenapiSlicer.new(file_path: "test_spec.yaml")
+    assert_equal "3.0.0", slicer.spec["openapi"]
+    assert_equal "Test API", slicer.spec["info"]["title"]
+  end
+
+  def test_filter_slices_paths_and_dependencies_matching_regex
+    slicer = ::OpenapiSlicer.new(file_path: "test_spec.json")
+    result = slicer.filter(%r{^/pets})
+
+    assert_includes result["paths"], "/pets"
+    assert_includes result["paths"], "/pets/{petId}"
+    assert_includes result["paths"], "/pets/{petId}/health"
+    assert_includes result["components"]["schemas"], "Pet"
+    assert_includes result["components"]["parameters"], "PetId"
+    assert_includes result["tags"].map { |tag| tag["name"] }, "Pets"
+  end
+
+  def test_filter_returns_only_nested_paths_under_pets_petid
+    slicer = ::OpenapiSlicer.new(file_path: "test_spec.json")
+    result = slicer.filter(%r{^/pets/\{petId\}})
+
+    assert_includes result["paths"], "/pets/{petId}"
+    assert_includes result["paths"], "/pets/{petId}/health"
+    assert_equal 2, result["paths"].size
+    assert_includes result["components"]["schemas"], "Pet"
+    assert_includes result["components"]["parameters"], "PetId"
+  end
+
+  def test_filter_returns_empty_result_for_non_matching_paths
+    slicer = ::OpenapiSlicer.new(file_path: "test_spec.json")
+    result = slicer.filter(%r{^/nonexistent})
+
+    assert_empty result["paths"]
+    assert_empty result["components"]["schemas"]
+    assert_empty result["components"]["parameters"]
+    assert_empty result["tags"]
+  end
+
+  def test_export_correctly_exports_filtered_spec_to_json
+    slicer = ::OpenapiSlicer.new(file_path: "test_spec.json")
+    slicer.export(%r{^/pets}, "sliced_spec.json")
+
+    sliced_spec = JSON.parse(File.read("sliced_spec.json"))
+    assert_includes sliced_spec["paths"], "/pets"
+    assert_includes sliced_spec["paths"], "/pets/{petId}"
+    assert_includes sliced_spec["paths"], "/pets/{petId}/health"
+    assert_includes sliced_spec["components"]["schemas"], "Pet"
+    assert_includes sliced_spec["components"]["parameters"], "PetId"
+    assert_includes sliced_spec["tags"].map { |tag| tag["name"] }, "Pets"
+  end
+
+  def test_export_correctly_exports_filtered_spec_to_yaml
+    slicer = ::OpenapiSlicer.new(file_path: "test_spec.yaml")
+    slicer.export(%r{^/pets}, "sliced_spec.yaml")
+
+    sliced_spec = YAML.load_file("sliced_spec.yaml")
+    assert_includes sliced_spec["paths"], "/pets"
+    assert_includes sliced_spec["paths"], "/pets/{petId}"
+    assert_includes sliced_spec["paths"], "/pets/{petId}/health"
+    assert_includes sliced_spec["components"]["schemas"], "Pet"
+    assert_includes sliced_spec["components"]["parameters"], "PetId"
+    assert_includes sliced_spec["tags"].map { |tag| tag["name"] }, "Pets"
+  end
+end

data/test/scripts/openapi_slicer_cli_test.rb

@@ -0,0 +1,65 @@
+require 'stringio'
+require 'test_helper'
+require_relative "../../scripts/openapi_slicer_cli"
+
+class OpenapiSlicerCLITest < Minitest::Test
+  def setup
+    # Redirect stdout and stderr to capture outputs for assertions
+    @original_stdout = $stdout
+    $stdout = StringIO.new
+    @original_stderr = $stderr
+    $stderr = StringIO.new
+  end
+
+  def teardown
+    # Restore stdout and stderr
+    $stdout = @original_stdout
+    $stderr = @original_stderr
+  end
+
+  def test_missing_required_options
+    argv = []
+    cli = ::OpenapiSlicerCLI.new(argv)
+    # Expect the script to exit due to missing options
+    assert_raises(SystemExit) { cli.run }
+    output = $stdout.string
+    assert_match(/Missing option: --input-file/, output)
+  end
+
+  def test_help_option
+    argv = ['-h']
+    cli = ::OpenapiSlicerCLI.new(argv)
+    # Expect the script to exit after displaying help
+    assert_raises(SystemExit) { cli.run }
+    output = $stdout.string
+    assert_match(/Usage: openapi_slicer/, output)
+  end
+
+  def test_run_with_output_file
+    # Mock the OpenapiSlicer instance
+    slicer_mock = Minitest::Mock.new
+    slicer_mock.expect(:export, nil, ['users.*', 'output.yaml'])
+    OpenapiSlicer.stub(:new, slicer_mock) do
+      argv = ['-i', 'input.yaml', '-r', 'users.*', '-o', 'output.yaml']
+      cli = ::OpenapiSlicerCLI.new(argv)
+      cli.run
+      output = $stdout.string
+      assert_match(/File created: output.yaml/, output)
+    end
+    slicer_mock.verify
+  end
+
+  def test_run_without_output_file
+    # Mock the OpenapiSlicer instance
+    slicer_mock = Minitest::Mock.new
+    slicer_mock.expect(:filter, { data: 'filtered_data' }, ['users.*'])
+    OpenapiSlicer.stub(:new, slicer_mock) do
+      argv = ['-i', 'input.yaml', '-r', 'users.*']
+      cli = ::OpenapiSlicerCLI.new(argv)
+      cli.run
+      output = $stdout.string
+      assert_match(/:data=>"filtered_data"/, output)
+    end
+    slicer_mock.verify
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "../lib/openapi_slicer"
+
+require 'minitest/autorun'

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: openapi_slicer
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- TheScubaGeek
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-10-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: OpenapiSlicer allows you to slice OpenAPI specs, selecting paths and
+  their dependencies based on regular expressions.
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/openapi_slicer.rb
+- scripts/openapi_slicer_cli.rb
+- test/lib/openapi_slicer_test.rb
+- test/scripts/openapi_slicer_cli_test.rb
+- test/test_helper.rb
+homepage: https://rubygems.org/gems/openapi_slicer
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key:
+specification_version: 4
+summary: A tool to slice OpenAPI specs based on regular expressions
+test_files: []