oas_rails 0.16.0 → 0.17.0

data/lib/oas_rails/builders/request_body_builder.rb

@@ -1,61 +0,0 @@
-module OasRails
-  module Builders
-    class RequestBodyBuilder
-      def initialize(specification)
-        @specification = specification
-        @request_body = Spec::RequestBody.new(specification)
-      end
-
-      def from_oas_route(oas_route)
-        tag_request_body = oas_route.tags(:request_body).first
-        if tag_request_body.nil? && OasRails.config.autodiscover_request_body
-          detect_request_body(oas_route) if %w[create update].include? oas_route.method
-        elsif !tag_request_body.nil?
-          from_tags(tag: tag_request_body, examples_tags: oas_route.tags(:request_body_example))
-        end
-
-        self
-      end
-
-      def from_tags(tag:, examples_tags: [])
-        if Utils.active_record_class?(tag.klass)
-          from_model_class(klass: tag.klass, description: tag.text, required: tag.required, content_type: tag.content_type, examples_tags:)
-        else
-          @request_body.description = tag.text
-          @request_body.content = ContentBuilder.new(@specification, :incoming).with_schema(tag.schema).with_examples_from_tags(examples_tags).with_content_type(tag.content_type).build
-          @request_body.required = tag.required
-        end
-
-        self
-      end
-
-      def from_model_class(klass:, **kwargs)
-        @request_body.description = kwargs[:description] || klass.to_s
-        @request_body.content = ContentBuilder.new(@specification, :incoming).from_model_class(klass).with_examples_from_tags(kwargs[:examples_tags] || {}).with_content_type(kwargs[:content_type]).build
-        @request_body.required = kwargs[:required]
-
-        self
-      end
-
-      def build
-        return {} if @request_body.content == {}
-
-        @request_body
-      end
-
-      def reference
-        return {} if @request_body.content == {}
-
-        @specification.components.add_request_body(@request_body)
-      end
-
-      private
-
-      def detect_request_body(oas_route)
-        return unless (klass = Utils.find_model_from_route(oas_route.controller))
-
-        from_model_class(klass:, required: true)
-      end
-    end
-  end
-end

data/lib/oas_rails/builders/response_builder.rb

@@ -1,40 +0,0 @@
-module OasRails
-  module Builders
-    class ResponseBuilder
-      def initialize(specification)
-        @specification = specification
-        @response = Spec::Response.new(specification)
-      end
-
-      def with_description(description)
-        @response.description = description
-
-        self
-      end
-
-      def with_content(content)
-        @response.content = content
-
-        self
-      end
-
-      def with_code(code)
-        @response.code = code
-
-        self
-      end
-
-      def from_tag(tag)
-        @response.code = tag.name.to_i
-        @response.description = tag.text
-        @response.content = ContentBuilder.new(@specification, :outgoing).with_schema(tag.schema).build
-
-        self
-      end
-
-      def build
-        @response
-      end
-    end
-  end
-end

data/lib/oas_rails/builders/responses_builder.rb

@@ -1,81 +0,0 @@
-module OasRails
-  module Builders
-    class ResponsesBuilder
-      def initialize(specification)
-        @specification = specification
-        @responses = Spec::Responses.new(specification)
-      end
-
-      def from_oas_route(oas_route)
-        oas_route.tags(:response).each do |tag|
-          content = ContentBuilder.new(@specification, :outgoing).with_schema(tag.schema).with_examples_from_tags(oas_route.tags(:response_example).filter { |re| re.code == tag.name }).build
-          response = ResponseBuilder.new(@specification).with_code(tag.name.to_i).with_description(tag.text).with_content(content).build
-
-          @responses.add_response(response)
-        end
-
-        self
-      end
-
-      def add_autodiscovered_responses(oas_route)
-        return self if !OasRails.config.autodiscover_responses || oas_route.tags(:response).any?
-
-        new_responses = Extractors::RenderResponseExtractor.extract_responses_from_source(@specification, source: oas_route.source_string)
-
-        new_responses.each do |new_response|
-          @responses.add_response(new_response) if @responses.responses[new_response.code].blank?
-        end
-
-        self
-      end
-
-      def add_default_responses(oas_route, security)
-        return self unless OasRails.config.set_default_responses
-
-        common_errors = determine_common_errors(oas_route, security)
-        add_responses_for_errors(common_errors)
-
-        self
-      end
-
-      def build
-        @responses
-      end
-
-      private
-
-      def determine_common_errors(oas_route, security)
-        common_errors = []
-        common_errors.push(:unauthorized, :forbidden, :internal_server_error) if security
-
-        case oas_route.method
-        when "show", "destroy"
-          common_errors.push(:not_found)
-        when "create"
-          common_errors.push(:unprocessable_entity)
-        when "update"
-          common_errors.push(:not_found, :unprocessable_entity)
-        end
-
-        OasRails.config.possible_default_responses & common_errors
-      end
-
-      def add_responses_for_errors(errors)
-        errors.each do |error|
-          response_body = resolve_response_body(error)
-          content = ContentBuilder.new(@specification, :outgoing).with_schema(JsonSchemaGenerator.process_string(response_body)[:json_schema]).build
-          code = Utils.status_to_integer(error)
-          response = ResponseBuilder.new(@specification).with_code(code).with_description(Utils.get_definition(code)).with_content(content).build
-
-          @responses.add_response(response) if @responses.responses[response.code].blank?
-        end
-      end
-
-      def resolve_response_body(error)
-        OasRails.config.public_send("response_body_of_#{error}")
-      rescue StandardError
-        OasRails.config.response_body_of_default
-      end
-    end
-  end
-end

data/lib/oas_rails/extractors/oas_route_extractor.rb

@@ -1,66 +0,0 @@
-module OasRails
-  module Extractors
-    module OasRouteExtractor
-      def extract_summary(oas_route:)
-        oas_route.tags(:summary).first.try(:text) || generate_crud_name(oas_route.method, oas_route.controller.downcase) || "#{oas_route.verb} #{oas_route.path}"
-      end
-
-      def extract_operation_id(oas_route:)
-        "#{oas_route.method}#{oas_route.path.gsub('/', '_').gsub(/[{}]/, '')}"
-      end
-
-      def extract_tags(oas_route:)
-        tags = oas_route.tags(:tags).first
-        if tags.nil?
-          default_tags(oas_route:)
-        else
-          tags.text.split(",").map(&:strip).map(&:titleize)
-        end
-      end
-
-      def default_tags(oas_route:)
-        tags = []
-        if OasRails.config.default_tags_from == :namespace
-          tag = oas_route.path.split('/').reject(&:empty?).first.try(:titleize)
-          tags << tag unless tag.nil?
-        else
-          tags << oas_route.controller.gsub("/", " ").titleize
-        end
-        tags
-      end
-
-      def extract_security(oas_route:)
-        return [] if oas_route.tags(:no_auth).any?
-
-        if (methods = oas_route.tags(:auth).first)
-          OasRails.config.security_schemas.keys.map { |key| { key => [] } }.select do |schema|
-            methods.types.include?(schema.keys.first.to_s)
-          end
-        elsif OasRails.config.authenticate_all_routes_by_default
-          OasRails.config.security_schemas.keys.map { |key| { key => [] } }
-        else
-          []
-        end
-      end
-
-      private
-
-      def generate_crud_name(method, controller)
-        controller_name = controller.to_s.underscore.humanize.downcase.pluralize
-
-        case method.to_sym
-        when :index
-          "List #{controller_name}"
-        when :show
-          "View #{controller_name.singularize}"
-        when :create
-          "Create new #{controller_name.singularize}"
-        when :update
-          "Update #{controller_name.singularize}"
-        when :destroy
-          "Delete #{controller_name.singularize}"
-        end
-      end
-    end
-  end
-end

data/lib/oas_rails/json_schema_generator.rb

@@ -1,132 +0,0 @@
-require 'json'
-
-module OasRails
-  # The JsonSchemaGenerator module provides methods to transform string representations
-  # of data types into JSON schema formats.
-  module JsonSchemaGenerator
-    # Processes a string representing a data type and converts it into a JSON schema.
-    #
-    # @param str [String] The string representation of a data type.
-    # @return [Hash] A hash containing the required flag and the JSON schema.
-    def self.process_string(str)
-      parsed = parse_type(str)
-      {
-        required: parsed[:required],
-        json_schema: to_json_schema(parsed)
-      }
-    end
-
-    # Parses a string representing a data type and determines its JSON schema type.
-    #
-    # @param str [String] The string representation of a data type.
-    # @return [Hash] A hash containing the type, whether it's required, and any additional properties.
-    def self.parse_type(str)
-      required = str.start_with?('!')
-      type = str.sub(/^!/, '').strip
-
-      case type
-      when /^Hash\{(.+)\}$/i
-        { type: :object, required:, properties: parse_object_properties(::Regexp.last_match(1)) }
-      when /^Array<(.+)>$/i
-        { type: :array, required:, items: parse_type(::Regexp.last_match(1)) }
-      when ->(t) { Utils.active_record_class?(t) }
-        Builders::EsquemaBuilder.build_outgoing_schema(klass: type.constantize)
-      else
-        { type: type.downcase.to_sym, required: }
-      end
-    end
-
-    # Parses the properties of an object type from a string.
-    #
-    # @param str [String] The string representation of the object's properties.
-    # @return [Hash] A hash where keys are property names and values are their JSON schema types.
-    def self.parse_object_properties(str)
-      properties = {}
-      stack = []
-      current_key = ''
-      current_value = ''
-
-      str.each_char.with_index do |char, index|
-        case char
-        when '{', '<'
-          stack.push(char)
-          current_value += char
-        when '}', '>'
-          stack.pop
-          current_value += char
-        when ','
-          if stack.empty?
-            properties[current_key.strip.to_sym] = parse_type(current_value.strip)
-            current_key = ''
-            current_value = ''
-          else
-            current_value += char
-          end
-        when ':'
-          if stack.empty?
-            current_key = current_value
-            current_value = ''
-          else
-            current_value += char
-          end
-        else
-          current_value += char
-        end
-
-        properties[current_key.strip.to_sym] = parse_type(current_value.strip) if index == str.length - 1 && !current_key.empty?
-      end
-
-      properties
-    end
-
-    # Converts a parsed data type into a JSON schema format.
-    #
-    # @param parsed [Hash] The parsed data type hash.
-    # @return [Hash] The JSON schema representation of the parsed data type.
-    def self.to_json_schema(parsed)
-      case parsed[:type]
-      when :object
-        schema = {
-          type: 'object',
-          properties: {}
-        }
-        required_props = []
-        parsed[:properties].each do |key, value|
-          schema[:properties][key] = to_json_schema(value)
-          required_props << key.to_s if value[:required]
-        end
-        schema[:required] = required_props unless required_props.empty?
-        schema
-      when :array
-        {
-          type: 'array',
-          items: to_json_schema(parsed[:items])
-        }
-      when nil
-        parsed
-      else
-        ruby_type_to_json_schema_type(parsed[:type])
-      end
-    end
-
-    # Converts a Ruby data type into its corresponding JSON schema type.
-    #
-    # @param type [Symbol, String] The Ruby data type.
-    # @return [Hash, String] The JSON schema type or a hash with additional format information.
-    def self.ruby_type_to_json_schema_type(type)
-      case type.to_s.downcase
-      when 'string' then { type: "string" }
-      when 'integer' then { type: "integer" }
-      when 'float' then { type: "float" }
-      when 'boolean' then { type: "boolean" }
-      when 'array' then { type: "array" }
-      when 'hash' then { type: "hash" }
-      when 'nil' then { type: "null" }
-      when 'date' then { type: "string", format: "date" }
-      when 'datetime' then { type: "string", format: "date-time" }
-      when 'file' then { type: "string", format: "binary" }
-      else type.to_s.downcase
-      end
-    end
-  end
-end

data/lib/oas_rails/oas_route.rb

@@ -1,21 +0,0 @@
-module OasRails
-  class OasRoute
-    attr_accessor :controller_class, :controller_action, :controller, :controller_path, :method, :verb, :path,
-                  :rails_route, :docstring, :source_string
-    attr_writer :tags
-
-    def initialize(attributes = {})
-      attributes.each { |key, value| send("#{key}=", value) }
-    end
-
-    def path_params
-      @rails_route.path.spec.to_s.scan(/:(\w+)/).flatten.reject! { |e| e == 'format' }
-    end
-
-    def tags(name = nil)
-      return @tags if name.nil?
-
-      @tags.select { |tag| tag.tag_name.to_s == name.to_s }
-    end
-  end
-end

data/lib/oas_rails/spec/components.rb

@@ -1,96 +0,0 @@
-module OasRails
-  module Spec
-    class Components
-      include Specable
-
-      attr_accessor :schemas, :parameters, :security_schemes, :request_bodies, :responses, :headers, :examples, :links, :callbacks
-
-      def initialize(specification)
-        @specification = specification
-        @schemas = {}
-        @parameters = {}
-        @security_schemes = OasRails.config.security_schemas
-        @request_bodies = {}
-        @responses = {}
-        @headers = {}
-        @examples = {}
-        @links = {}
-        @callbacks = {}
-      end
-
-      def oas_fields
-        [:request_bodies, :examples, :responses, :schemas, :parameters, :security_schemes]
-      end
-
-      def add_response(response)
-        key = response.hash_key
-        @responses[key] = response unless @responses.key? key
-
-        response_reference(key)
-      end
-
-      def add_parameter(parameter)
-        key = parameter.hash_key
-        @parameters[key] = parameter unless @parameters.key? key
-
-        parameter_reference(key)
-      end
-
-      def add_request_body(request_body)
-        key = request_body.hash_key
-        @request_bodies[key] = request_body unless @request_bodies.key? key
-
-        request_body_reference(key)
-      end
-
-      def add_schema(schema)
-        key = nil
-        if OasRails.config.use_model_names
-          if schema[:type] == 'array'
-            arr_schema = schema[:items]
-            arr_key = arr_schema['title']
-            key = "#{arr_key}List" unless arr_key.nil?
-          else
-            key = schema['title']
-          end
-        end
-
-        key = Hashable.generate_hash(schema) if key.nil?
-
-        @schemas[key] = schema if @schemas[key].nil?
-        schema_reference(key)
-      end
-
-      def add_example(example)
-        key = Hashable.generate_hash(example)
-        @examples[key] = example if @examples[key].nil?
-
-        example_reference(key)
-      end
-
-      def create_reference(type, name)
-        "#/components/#{type}/#{name}"
-      end
-
-      def schema_reference(name)
-        Reference.new(create_reference('schemas', name))
-      end
-
-      def response_reference(name)
-        Reference.new(create_reference('responses', name))
-      end
-
-      def parameter_reference(name)
-        Reference.new(create_reference('parameters', name))
-      end
-
-      def example_reference(name)
-        Reference.new(create_reference('examples', name))
-      end
-
-      def request_body_reference(name)
-        Reference.new(create_reference('requestBodies', name))
-      end
-    end
-  end
-end

data/lib/oas_rails/spec/contact.rb

@@ -1,18 +0,0 @@
-module OasRails
-  module Spec
-    class Contact
-      include Specable
-      attr_accessor :name, :url, :email
-
-      def initialize(**kwargs)
-        @name = kwargs[:name] || ''
-        @url = kwargs[:url] || ''
-        @email = kwargs[:email] || ''
-      end
-
-      def oas_fields
-        [:name, :url, :email]
-      end
-    end
-  end
-end

data/lib/oas_rails/spec/hashable.rb

@@ -1,39 +0,0 @@
-module OasRails
-  module Spec
-    require 'digest'
-
-    module Hashable
-      def hash_key
-        Hashable.generate_hash(hash_representation)
-      end
-
-      def hash_representation
-        public_instance_variables.sort.to_h { |var| [var, instance_variable_get(var)] }
-      end
-
-      def self.generate_hash(obj)
-        Digest::MD5.hexdigest(hash_representation_recursive(obj).to_s)
-      end
-
-      def public_instance_variables
-        instance_variables.select do |var|
-          method_name = var.to_s.delete('@')
-          respond_to?(method_name) || respond_to?("#{method_name}=")
-        end
-      end
-
-      def self.hash_representation_recursive(obj)
-        case obj
-        when Hash
-          obj.transform_values { |v| hash_representation_recursive(v) }
-        when Array
-          obj.map { |v| hash_representation_recursive(v) }
-        when Hashable
-          obj.hash_representation
-        else
-          obj
-        end
-      end
-    end
-  end
-end

data/lib/oas_rails/spec/info.rb

@@ -1,66 +0,0 @@
-module OasRails
-  module Spec
-    class Info
-      include Specable
-      attr_accessor :title, :summary, :description, :terms_of_service, :contact, :license, :version
-
-      def initialize(**kwargs)
-        @title = kwargs[:title] || default_title
-        @summary = kwargs[:summary] || default_summary
-        @description = kwargs[:description] || default_description
-        @terms_of_service = kwargs[:terms_of_service] || ''
-        @contact = Spec::Contact.new
-        @license = Spec::License.new
-        @version = kwargs[:version] || '0.0.1'
-      end
-
-      def oas_fields
-        [:title, :summary, :description, :terms_of_service, :contact, :license, :version]
-      end
-
-      def default_title
-        "OasRails #{VERSION}"
-      end
-
-      def default_summary
-        "OasRails: Automatic Interactive API Documentation for Rails"
-      end
-
-      def default_description
-        "# Welcome to OasRails
-
-OasRails automatically generates interactive documentation for your Rails APIs using the OpenAPI Specification 3.1 (OAS 3.1) and displays it with a nice UI.
-
-## Getting Started
-
-You've successfully mounted the OasRails engine. This default documentation is based on your routes and automatically gathered information.
-
-## Enhancing Your Documentation
-
-To customize and enrich your API documentation:
-
-1. Generate an initializer file:
-
-  ```
-  rails generate oas_rails:config
-  ```
-2. Edit the created `config/initializers/oas_rails.rb` file to override default settings and add project-specific information.
-
-3. Use Yard tags in your controller methods to provide detailed API endpoint descriptions.
-
-## Features
-
-- Automatic OAS 3.1 document generation
-- [RapiDoc](https://github.com/rapi-doc/RapiDoc) integration for interactive exploration
-- Minimal setup required for basic documentation
-- Extensible through configuration and Yard tags
-
-Explore your API documentation and enjoy the power of OasRails!
-
-For more information and advanced usage, visit the [OasRails GitHub repository](https://github.com/a-chacon/oas_rails).
-
-      "
-      end
-    end
-  end
-end

data/lib/oas_rails/spec/license.rb

@@ -1,18 +0,0 @@
-module OasRails
-  module Spec
-    class License
-      include Specable
-
-      attr_accessor :name, :url
-
-      def initialize(**kwargs)
-        @name = kwargs[:name] || 'GPL 3.0'
-        @url = kwargs[:url] || 'https://www.gnu.org/licenses/gpl-3.0.html#license-text'
-      end
-
-      def oas_fields
-        [:name, :url]
-      end
-    end
-  end
-end

data/lib/oas_rails/spec/media_type.rb

@@ -1,24 +0,0 @@
-module OasRails
-  module Spec
-    class MediaType
-      include Specable
-
-      attr_accessor :schema, :example, :examples, :encoding
-
-      # Initializes a new MediaType object.
-      #
-      # @param schema [Hash] the schema of the media type.
-      # @param kwargs [Hash] additional keyword arguments.
-      def initialize(specification)
-        @specification = specification
-        @schema = {}
-        @example =  {}
-        @examples = {}
-      end
-
-      def oas_fields
-        [:schema, :example, :examples, :encoding]
-      end
-    end
-  end
-end

data/lib/oas_rails/spec/operation.rb

@@ -1,25 +0,0 @@
-module OasRails
-  module Spec
-    class Operation
-      include Specable
-
-      attr_accessor :specification, :tags, :summary, :description, :operation_id, :parameters, :request_body, :responses, :security
-
-      def initialize(specification)
-        @specification = specification
-        @summary = ""
-        @operation_id = ""
-        @tags = []
-        @description = @summary
-        @parameters = []
-        @request_body = {}
-        @responses =  Spec::Responses.new(specification)
-        @security = []
-      end
-
-      def oas_fields
-        [:tags, :summary, :description, :operation_id, :parameters, :request_body, :responses, :security]
-      end
-    end
-  end
-end