oas_rails 0.4.5 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5285e5cf1a83ddb32b2d4b74a79d5694175fa2e7959211f264ab58a0b9dadf36
-  data.tar.gz: d16c39e306c501bda6fd38d842df96820cc7621bf29b76026e4a0ea8e1070588
+  metadata.gz: 1f833de18481bb481d9f698a2f10a3b7f1a1512623cd335932659736f94b2161
+  data.tar.gz: 343243f10ae846b8eb42ca75cdd3d69332fe19b41192959bb355603fa2148242
 SHA512:
-  metadata.gz: 638314dfa65ce344c4fdb8c7e725503f6556a7276aa4839c406d738a7d06b9bfd8533e68dcf720bf95573e4b75f7d91f0600528b4fd00670e2c94990a92f5a04
-  data.tar.gz: 606103ec7b8640f5fbbcc1afcbd9c56d5671df6dbacd89e7ab1c30ead4b2480f583cb2f6bc31a6cf4a731399d77e101e1a5b4d7f8465c548da49307ad170f4d3
+  metadata.gz: 3e41ce594245affa26d85f05bba1fbdb1b6dacbb1d112c42aaa63c0837654a56d4afdd9eb442bc7000f3ceda90fb254aea5712a5e2d3aeff58d1505d869957a3
+  data.tar.gz: 1be4b42da76e635d82ee95f663ea9ca950873b2c6037779598cfa0c284076a022a05aaeb772dd66f5a08b76bedbac7be3ac27453db0a07a4be8e7e0b3213bca9

data/README.md

@@ -29,7 +29,7 @@ OasRails is a Rails engine for generating **automatic interactive documentation
 
 After experiencing the interactive documentation in Python's fast-api framework, I sought similar functionality in Ruby on Rails. Unable to find a suitable solution, I [asked on Stack Overflow](https://stackoverflow.com/questions/71947018/is-there-a-way-to-generate-an-interactive-documentation-for-rails-apis) years ago. Now, with some free time while freelancing as an API developer, I decided to build my own tool.
 
-**Note**: This is not yet a production-ready solution. The code may be rough and behave unexpectedly, but I am actively working on improving it. If you like the idea, please consider contributing to its development.
+**Note: This is not yet a production-ready solution. The code may be rough and behave unexpectedly, but I am actively working on improving it. If you like the idea, please consider contributing to its development.**
 
 The goal is to minimize the effort required to create comprehensive documentation. By following REST principles in Rails, we believe this is achievable. You can enhance the documentation using [Yard](https://yardoc.org/) tags.
 
@@ -120,7 +120,7 @@ Then fill it with your data. Below are the available configuration options:
 
 - `config.possible_default_responses`: Array with possible default errors.(Some will be added depending on the endpoint, example: not_found only works with show/update/delete). Default: [:not_found, :unauthorized, :forbidden]. It should be HTTP status code symbols from the list: `[:not_found, :unauthorized, :forbidden, :internal_server_error, :unprocessable_entity]`
 
-- `config.response_body_of_default`: body for use in default responses. It must be a Hash. Default: { message: String }
+- `config.response_body_of_default`: body for use in default responses. It must be a String hash like the used in request body tags. Default: "{ message: String }"
 
 ## Usage
 
@@ -158,12 +158,19 @@ Represents a parameter for the endpoint. The position can be: `header`, `path`,
 <details>
 <summary style="font-weight: bold; font-size: 1.2em;">@request_body</summary>
 
-**Structure**: `@request_body text [type] structure`
+**Structure**: `@request_body text [type<structure>]`
 
 Documents the request body needed by the endpoint. The structure is optional if you provide a valid Active Record class. Use `!` to indicate a required request body.
 
 **Example**:
-`# @request_body The user to be created [Hash] {user: {name: String, age: Integer, password: String}}`
+
+`# @request_body The user to be created [!Hash{user: {name: String, age: Integer, password: String}}]`
+
+`# @request_body The user to be created [!User]`
+
+`# @request_body The user to be created [User]`
+
+`# @request_body The user to be created [!Hash{user: {name: String, age: Integer, password: String, surnames: Array<String>, coords: Hash{lat: String, lng: String}}}]`
 
 </details>
 
@@ -182,12 +189,30 @@ Adds examples to the provided request body.
 <details>
 <summary style="font-weight: bold; font-size: 1.2em;">@response</summary>
 
-**Structure**: `@response text(code) [type] structure`
+**Structure**: `@response text(code) [type<structure>]`
 
 Documents the responses of the endpoint and overrides the default responses found by the engine.
 
 **Example**:
-`# @response User not found by the provided Id(404) [Hash] {success: Boolean, message: String}`
+
+`# @response User not found by the provided Id(404) [Hash{success: Boolean, message: String}]`
+
+`# @response Validation errors(422) [Hash{success: Boolean, errors: Array<Hash{field: String, type: String, detail: Array<String>}>}]`
+
+</details>
+
+<details>
+<summary style="font-weight: bold; font-size: 1.2em;">@response_example</summary>
+
+**Structure**: `@response_example text(code) [String Hash]`
+
+Documents response examples of the endpoint associated to a response code.
+
+**Example**:
+
+`# @response_example Invalida Email(422) [{success: "false", errors: [{field: "email", type: "email", detail: ["Invalid email"]}] }]`
+
+`# @response_example Id not exists (404) [{success: "false", message: "Nothing found with the provided ID." }]`
 
 </details>
 
@@ -250,9 +275,9 @@ class UsersController < ApplicationController
   # This method show a User by ID. The id must exist of other way it will be returning a **`404`**.
   #
   # @parameter id(path) [Integer] Used for identify the user.
-  # @response Requested User(200) [Hash] {user: {name: String, email: String, created_at: DateTime }}
-  # @response User not found by the provided Id(404) [Hash] {success: Boolean, message: String}
-  # @response You don't have the right permission for access to this resource(403) [Hash] {success: Boolean, message: String}
+  # @response Requested User(200) [Hash{user: {name: String, email: String, created_at: DateTime }}]
+  # @response User not found by the provided Id(404) [Hash{success: Boolean, message: String}]
+  # @response You don't have the right permission for access to this resource(403) [Hash{success: Boolean, message: String}]
   def show
     render json: @user
   end
@@ -260,7 +285,7 @@ class UsersController < ApplicationController
   # @summary Create a User
   # @no_auth
   #
-  # @request_body The user to be created. At least include an `email`. [User!]
+  # @request_body The user to be created. At least include an `email`. [!User]
   # @request_body_example basic user [Hash] {user: {name: "Luis", email: "luis@gmail.ocom"}}
   def create
     @user = User.new(user_params)
@@ -276,7 +301,7 @@ class UsersController < ApplicationController
   # - There is no option
   # - It must work
   # @tags users, update
-  # @request_body User to be created [Hash] {user: { name: String, email: String, age: Integer}}
+  # @request_body User to be created [!Hash{user: { name: String, email: !String, age: Integer, available_dates: Array<Date>}}]
   # @request_body_example Update user [Hash] {user: {name: "Luis", email: "luis@gmail.com"}}
   # @request_body_example Complete User [Hash] {user: {name: "Luis", email: "luis@gmail.com", age: 21}}
   def update

data/lib/oas_rails/builders/responses_builder.rb

@@ -8,14 +8,17 @@ module OasRails
 
       def from_oas_route(oas_route)
         oas_route.docstring.tags(:response).each do |tag|
-          @responses.add_response(ResponseBuilder.new(@specification).from_tag(tag).build)
+          content = ContentBuilder.new(@specification, :outgoing).with_schema(tag.schema).with_examples_from_tags(oas_route.docstring.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 unless OasRails.config.autodiscover_responses
+        return self if !OasRails.config.autodiscover_responses || oas_route.docstring.tags(:response).any?
 
         new_responses = Extractors::RenderResponseExtractor.extract_responses_from_source(@specification, source: oas_route.source_string)
 
@@ -29,7 +32,7 @@ module OasRails
       def add_default_responses(oas_route, security)
         return self unless OasRails.config.set_default_responses
 
-        content = ContentBuilder.new(@specification, :outgoing).with_schema(Utils.hash_to_json_schema(OasRails.config.response_body_of_default)).build
+        content = ContentBuilder.new(@specification, :outgoing).with_schema(JsonSchemaGenerator.process_string(OasRails.config.response_body_of_default)[:json_schema]).build
         common_errors = []
         common_errors.push(:unauthorized, :forbidden) if security
 

data/lib/oas_rails/configuration.rb

@@ -26,7 +26,7 @@ module OasRails
       @security_schemas = {}
       @set_default_responses = true
       @possible_default_responses = [:not_found, :unauthorized, :forbidden]
-      @response_body_of_default = { message: String }
+      @response_body_of_default = "Hash{ success: !Boolean, message: String }"
     end
 
     def security_schema=(value)

data/lib/oas_rails/json_schema_generator.rb

@@ -0,0 +1,127 @@
+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)) }
+      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])
+        }
+      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" }
+      else type.to_s.downcase
+      end
+    end
+  end
+end

data/lib/oas_rails/version.rb

@@ -1,3 +1,3 @@
 module OasRails
-  VERSION = "0.4.5"
+  VERSION = "0.6.0"
 end

data/lib/oas_rails/yard/example_tag.rb

@@ -0,0 +1,12 @@
+module OasRails
+  module YARD
+    class ExampleTag < ::YARD::Tags::Tag
+      attr_accessor :content
+
+      def initialize(tag_name, text, content: {})
+        super(tag_name, text, nil, nil)
+        @content = content
+      end
+    end
+  end
+end

data/lib/oas_rails/yard/oas_rails_factory.rb

@@ -0,0 +1,176 @@
+module OasRails
+  module YARD
+    class OasRailsFactory < ::YARD::Tags::DefaultFactory
+      # Parses a tag that represents a request body.
+      # @param tag_name [String] The name of the tag.
+      # @param text [String] The tag text to parse.
+      # @return [RequestBodyTag] The parsed request body tag object.
+      def parse_tag_with_request_body(tag_name, text)
+        description, klass, schema, required = extract_description_and_schema(text)
+        RequestBodyTag.new(tag_name, description, klass, schema:, required:)
+      end
+
+      # Parses a tag that represents a request body example.
+      # @param tag_name [String] The name of the tag.
+      # @param text [String] The tag text to parse.
+      # @return [RequestBodyExampleTag] The parsed request body example tag object.
+      def parse_tag_with_request_body_example(tag_name, text)
+        description, _, hash = extract_description_type_and_content(text, process_content: true)
+        RequestBodyExampleTag.new(tag_name, description, content: hash)
+      end
+
+      # Parses a tag that represents a parameter.
+      # @param tag_name [String] The name of the tag.
+      # @param text [String] The tag text to parse.
+      # @return [ParameterTag] The parsed parameter tag object.
+      def parse_tag_with_parameter(tag_name, text)
+        name, location, schema, required, description = extract_name_location_schema_and_description(text)
+        ParameterTag.new(tag_name, name, description, schema, location, required:)
+      end
+
+      # Parses a tag that represents a response.
+      # @param tag_name [String] The name of the tag.
+      # @param text [String] The tag text to parse.
+      # @return [ResponseTag] The parsed response tag object.
+      def parse_tag_with_response(tag_name, text)
+        name, code, schema = extract_name_code_and_schema(text)
+        ResponseTag.new(tag_name, code, name, schema)
+      end
+
+      # Parses a tag that represents a response example.
+      # @param tag_name [String] The name of the tag.
+      # @param text [String] The tag text to parse.
+      # @return [ResponseExampleTag] The parsed response example tag object.
+      def parse_tag_with_response_example(tag_name, text)
+        description, code, hash = extract_name_code_and_hash(text)
+        ResponseExampleTag.new(tag_name, description, content: hash, code:)
+      end
+
+      private
+
+      # Reusable method for extracting description, type, and content with an option to process content.
+      # @param text [String] The text to parse.
+      # @param process_content [Boolean] Whether to evaluate the content as a hash.
+      # @return [Array] An array containing the description, type, and content or remaining text.
+      def extract_description_type_and_content(text, process_content: false)
+        match = text.match(/^(.*?)\s*\[(.*)\]\s*(.*)$/)
+        raise ArgumentError, "Invalid tag format: #{text}" if match.nil?
+
+        description = match[1].strip
+        type = match[2].strip
+        content = process_content ? eval_content(match[3].strip) : match[3].strip
+
+        [description, type, content]
+      end
+
+      # Specific method to extract description and schema for request body tags.
+      # @param text [String] The text to parse.
+      # @return [Array] An array containing the description, class, schema, and required flag.
+      def extract_description_and_schema(text)
+        description, type, = extract_description_type_and_content(text)
+        klass, schema, required = type_text_to_schema(type)
+        [description, klass, schema, required]
+      end
+
+      # Specific method to extract name, location, and schema for parameters.
+      # @param text [String] The text to parse.
+      # @return [Array] An array containing the name, location, schema, and required flag.
+      def extract_name_location_schema_and_description(text)
+        match = text.match(/^(.*?)\s*\[(.*?)\]\s*(.*)$/)
+        name, location = extract_text_and_parentheses_content(match[1].strip)
+        schema, required = type_text_to_schema(match[2].strip)[1..]
+        description = match[3].strip
+        [name, location, schema, required, description]
+      end
+
+      # Specific method to extract name, code, and schema for responses.
+      # @param text [String] The text to parse.
+      # @return [Array] An array containing the name, code, and schema.
+      def extract_name_code_and_schema(text)
+        name, code = extract_text_and_parentheses_content(text)
+        _, type, = extract_description_type_and_content(text)
+        schema = type_text_to_schema(type)[1]
+        [name, code, schema]
+      end
+
+      # Specific method to extract name, code, and hash for responses examples.
+      # @param text [String] The text to parse.
+      # @return [Array] An array containing the name, code, and schema.
+      def extract_name_code_and_hash(text)
+        name, code = extract_text_and_parentheses_content(text)
+        _, type, = extract_description_type_and_content(text)
+        hash = eval_content(type)
+        [name, code, hash]
+      end
+
+      # Evaluates a string as a hash, handling errors gracefully.
+      # @param content [String] The content string to evaluate.
+      # @return [Hash] The evaluated hash, or an empty hash if an error occurs.
+      # rubocop:disable Security/Eval
+      def eval_content(content)
+        eval(content)
+      rescue StandardError
+        {}
+      end
+      # rubocop:enable Security/Eval
+
+      # Parses the position name and location from input text.
+      # @param input [String] The input text to parse.
+      # @return [Array] An array containing the name and location.
+      def extract_text_and_parentheses_content(input)
+        return unless input =~ /^(.+?)\(([^)]+)\)/
+
+        text = ::Regexp.last_match(1).strip
+        parenthesis_content = ::Regexp.last_match(2).strip
+        [text, parenthesis_content]
+      end
+
+      # Extracts the text and whether it's required.
+      # @param text [String] The text to parse.
+      # @return [Array] An array containing the text and a required flag.
+      def text_and_required(text)
+        if text.start_with?('!')
+          [text.sub(/^!/, ''), true]
+        else
+          [text, false]
+        end
+      end
+
+      # Matches and validates a description and type from text.
+      # @param text [String] The text to parse.
+      # @return [MatchData] The match data from the regex.
+      def description_and_type(text)
+        match = text.match(/^(.*?)\s*\[(.*?)\]\s*(.*)$/)
+        raise ArgumentError, "The request body tag is not valid: #{text}" if match.nil?
+
+        match
+      end
+
+      # Checks if a given text refers to an ActiveRecord class.
+      # @param text [String] The text to check.
+      # @return [Boolean] True if the text refers to an ActiveRecord class, false otherwise.
+      def active_record_class?(text)
+        klass = text.constantize
+        klass.ancestors.include? ActiveRecord::Base
+      rescue StandardError
+        false
+      end
+
+      # Converts type text to a schema, checking if it's an ActiveRecord class.
+      # @param text [String] The type text to convert.
+      # @return [Array] An array containing the class, schema, and required flag.
+      def type_text_to_schema(text)
+        type_text, required = text_and_required(text)
+
+        if active_record_class?(type_text)
+          klass = type_text.constantize
+          schema = Builders::EsquemaBuilder.build_outgoing_schema(klass:)
+        else
+          schema = JsonSchemaGenerator.process_string(type_text)[:json_schema]
+          klass = Object
+        end
+        [klass, schema, required]
+      end
+    end
+  end
+end

data/lib/oas_rails/yard/parameter_tag.rb

@@ -0,0 +1,14 @@
+module OasRails
+  module YARD
+    class ParameterTag < ::YARD::Tags::Tag
+      attr_accessor :schema, :required, :location
+
+      def initialize(tag_name, name, text, schema, location, required: false)
+        super(tag_name, text, nil, name)
+        @schema = schema
+        @required = required
+        @location = location
+      end
+    end
+  end
+end

data/lib/oas_rails/yard/request_body_example_tag.rb

@@ -0,0 +1,11 @@
+module OasRails
+  module YARD
+    class RequestBodyExampleTag < ExampleTag
+      attr_accessor :content
+
+      def initialize(tag_name, text, content: {})
+        super
+      end
+    end
+  end
+end

data/lib/oas_rails/yard/request_body_tag.rb

@@ -0,0 +1,15 @@
+module OasRails
+  module YARD
+    class RequestBodyTag < ::YARD::Tags::Tag
+      attr_accessor :klass, :schema, :required
+
+      def initialize(tag_name, text, klass, schema: {}, required: false)
+        # initialize(tag_name, text, types = nil, name = nil)
+        super(tag_name, text, nil, nil)
+        @klass = klass
+        @schema = schema
+        @required = required
+      end
+    end
+  end
+end

data/lib/oas_rails/yard/response_example_tag.rb

@@ -0,0 +1,12 @@
+module OasRails
+  module YARD
+    class ResponseExampleTag < ExampleTag
+      attr_accessor :code
+
+      def initialize(tag_name, text, content: {}, code: 200)
+        super(tag_name, text, content:)
+        @code = code
+      end
+    end
+  end
+end

data/lib/oas_rails/yard/response_tag.rb

@@ -0,0 +1,13 @@
+module OasRails
+  module YARD
+    class ResponseTag < ::YARD::Tags::Tag
+      attr_accessor :schema
+
+      # TODO: name == code. The name MUST be changed to code for better understanding
+      def initialize(tag_name, name, text, schema)
+        super(tag_name, text, nil, name)
+        @schema = schema
+      end
+    end
+  end
+end

data/lib/oas_rails.rb

@@ -9,6 +9,7 @@ module OasRails
   autoload :Configuration, "oas_rails/configuration"
   autoload :OasRoute, "oas_rails/oas_route"
   autoload :Utils, "oas_rails/utils"
+  autoload :JsonSchemaGenerator, "oas_rails/json_schema_generator"
 
   module Builders
     autoload :OperationBuilder, "oas_rails/builders/operation_builder"
@@ -45,7 +46,13 @@ module OasRails
   end
 
   module YARD
-    autoload :OasYARDFactory, 'oas_rails/yard/oas_yard_factory'
+    autoload :RequestBodyTag, 'oas_rails/yard/request_body_tag'
+    autoload :ExampleTag, 'oas_rails/yard/example_tag'
+    autoload :RequestBodyExampleTag, 'oas_rails/yard/request_body_example_tag'
+    autoload :ParameterTag, 'oas_rails/yard/parameter_tag'
+    autoload :ResponseTag, 'oas_rails/yard/response_tag'
+    autoload :ResponseExampleTag, 'oas_rails/yard/response_example_tag'
+    autoload :OasRailsFactory, 'oas_rails/yard/oas_rails_factory'
   end
 
   module Extractors
@@ -73,12 +80,13 @@ module OasRails
     end
 
     def configure_yard!
-      ::YARD::Tags::Library.default_factory = YARD::OasYARDFactory
+      ::YARD::Tags::Library.default_factory = YARD::OasRailsFactory
       yard_tags = {
         'Request body' => [:request_body, :with_request_body],
         'Request body Example' => [:request_body_example, :with_request_body_example],
         'Parameter' => [:parameter, :with_parameter],
         'Response' => [:response, :with_response],
+        'Response Example' => [:response_example, :with_response_example],
         'Endpoint Tags' => [:tags],
         'Summary' => [:summary],
         'No Auth' => [:no_auth],

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: oas_rails
 version: !ruby/object:Gem::Version
-  version: 0.4.5
+  version: 0.6.0
 platform: ruby
 authors:
 - a-chacon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-08-22 00:00:00.000000000 Z
+date: 2024-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: method_source
@@ -108,6 +108,7 @@ files:
 - lib/oas_rails/extractors/oas_route_extractor.rb
 - lib/oas_rails/extractors/render_response_extractor.rb
 - lib/oas_rails/extractors/route_extractor.rb
+- lib/oas_rails/json_schema_generator.rb
 - lib/oas_rails/oas_route.rb
 - lib/oas_rails/spec/components.rb
 - lib/oas_rails/spec/contact.rb
@@ -129,7 +130,13 @@ files:
 - lib/oas_rails/spec/tag.rb
 - lib/oas_rails/utils.rb
 - lib/oas_rails/version.rb
-- lib/oas_rails/yard/oas_yard_factory.rb
+- lib/oas_rails/yard/example_tag.rb
+- lib/oas_rails/yard/oas_rails_factory.rb
+- lib/oas_rails/yard/parameter_tag.rb
+- lib/oas_rails/yard/request_body_example_tag.rb
+- lib/oas_rails/yard/request_body_tag.rb
+- lib/oas_rails/yard/response_example_tag.rb
+- lib/oas_rails/yard/response_tag.rb
 homepage: https://github.com/a-chacon/oas_rails
 licenses:
 - GPL-3.0-only

data/lib/oas_rails/yard/oas_yard_factory.rb

@@ -1,160 +0,0 @@
-module OasRails
-  module YARD
-    class RequestBodyTag < ::YARD::Tags::Tag
-      attr_accessor :klass, :schema, :required
-
-      def initialize(tag_name, text, klass, schema: {}, required: false)
-        # initialize(tag_name, text, types = nil, name = nil)
-        super(tag_name, text, nil, nil)
-        @klass = klass
-        @schema = schema
-        @required = required
-      end
-    end
-
-    class RequestBodyExampleTag < ::YARD::Tags::Tag
-      attr_accessor :content
-
-      def initialize(tag_name, text, content: {})
-        super(tag_name, text, nil, nil)
-        @content = content
-      end
-    end
-
-    class ParameterTag < ::YARD::Tags::Tag
-      attr_accessor :schema, :required, :location
-
-      def initialize(tag_name, name, text, schema, location, required: false)
-        super(tag_name, text, nil, name)
-        @schema = schema
-        @required = required
-        @location = location
-      end
-    end
-
-    class ResponseTag < ::YARD::Tags::Tag
-      attr_accessor :schema
-
-      def initialize(tag_name, name, text, schema)
-        super(tag_name, text, nil, name)
-        @schema = schema
-      end
-    end
-
-    class OasYARDFactory < ::YARD::Tags::DefaultFactory
-      ## parse_tag is a prefix used by YARD
-
-      def parse_tag_with_request_body(tag_name, text)
-        match = text.match(/^(.*?)\s*\[(.*?)\]\s*(.*)$/)
-        if !match.nil?
-          text = match[1].strip
-          type, required = parse_type(match[2].strip)
-
-          if type.constantize == Hash
-            hash_string = match[3].strip
-
-            begin
-              hash = eval(hash_string)
-              hash = Utils.hash_to_json_schema(hash)
-            rescue StandardError
-              hash = {}
-            end
-          end
-
-          RequestBodyTag.new(tag_name, text, type.constantize, schema: hash, required:)
-        else
-          Rails.logger.debug("Error parsing request_body tag: #{text}")
-        end
-      end
-
-      def parse_tag_with_request_body_example(tag_name, text)
-        match = text.match(/^(.*?)\s*\[(.*?)\]\s*(.*)$/)
-        if !match.nil?
-          text = match[1].strip
-          type = match[2]
-
-          if type.constantize == Hash
-            hash_string = match[3].strip
-
-            begin
-              hash = eval(hash_string)
-            rescue StandardError
-              hash = {}
-            end
-          end
-          RequestBodyExampleTag.new(tag_name, text, content: hash)
-        else
-          Rails.logger.debug("Error parsing request body example tag: #{text}")
-        end
-      end
-
-      def parse_tag_with_parameter(tag_name, text)
-        match = text.match(/^(.*?)\s*\[(.*?)\]\s*(.*)$/)
-        if !match.nil?
-          text = match[1].strip
-          name, location = parse_position_name(text)
-          type, required = parse_type(match[2].strip)
-          schema = Utils.type_to_schema(type)
-
-          ParameterTag.new(tag_name, name, match[3].strip, schema, location, required:)
-        else
-          Rails.logger.debug("Error parsing request body example tag: #{text}")
-        end
-      end
-
-      def parse_tag_with_response(tag_name, text)
-        match = text.match(/^(.*?)\s*\[(.*?)\]\s*(.*)$/)
-        if !match.nil?
-          name, code = parse_position_name(match[1].strip)
-
-          begin
-            hash = parse_str_to_hash(match[3].strip)
-            hash = Utils.hash_to_json_schema(hash)
-          rescue StandardError
-            hash = {}
-          end
-
-          ResponseTag.new(tag_name, code, name, hash)
-        else
-          Rails.logger.debug("Error parsing request body example tag: #{text}")
-        end
-      end
-
-      def parse_position_name(input)
-        return unless input =~ /^([^(]+)\((.*)\)$/
-
-        name = ::Regexp.last_match(1)
-        location = ::Regexp.last_match(2)
-        [name, location]
-      end
-
-      def parse_type(type_string)
-        if type_string.end_with?('!')
-          [type_string.chomp('!'), true]
-        else
-          [type_string, false]
-        end
-      end
-
-      def parse_str_to_hash(str)
-        str = str.gsub(/^\{|\}$/, '') # Remove leading { and trailing }
-        pairs = str.split(',').map(&:strip)
-
-        pairs.each_with_object({}) do |pair, hash|
-          key, value = pair.split(':').map(&:strip)
-          key = key.to_sym
-          hash[key] = case value
-                      when 'String' then String
-                      when 'Integer' then Integer
-                      when 'Float' then Float
-                      when 'Boolean' then [TrueClass, FalseClass]
-                      when 'Array' then Array
-                      when 'Hash' then Hash
-                      when 'DateTime' then DateTime
-                      else value
-                      end
-        end
-      end
-    end
-  end
-end