Module: OasRails::Utils

Defined in:
lib/oas_rails/utils.rb

Constant Summary collapse

TYPE_MAPPING = 
{
  'String' => 'string',
  'Integer' => 'number',
  'Float' => 'number',
  'TrueClass' => 'boolean',
  'FalseClass' => 'boolean',
  'Boolean' => 'boolean',
  'NilClass' => 'null',
  'Hash' => 'object',
  'Object' => 'object',
  'DateTime' => 'string'
}.freeze
HTTP_STATUS_DEFINITIONS = 
{
  404 => "The requested resource could not be found.",
  401 => "You are not authorized to access this resource. You need to authenticate yourself first.",
  403 => "You are not allowed to access this resource. You do not have the necessary permissions.",
  500 => "An unexpected error occurred on the server. The server was unable to process the request.",
  422 => "The server could not process the request due to semantic errors. Please check your input and try again."
}.freeze

Class Method Summary collapse

Class Method Details

.class_to_symbol(klass) ⇒ Object 



95
96
97
 
# File 'lib/oas_rails/utils.rb', line 95

def class_to_symbol(klass)
  klass.name.underscore.to_sym
end

.detect_test_framework ⇒ Object

Method for detect test framework of the Rails App It is used for generate examples in operations



27
28
29
30
31
32
33
34
35
 
# File 'lib/oas_rails/utils.rb', line 27

def detect_test_framework
  if defined?(FactoryBot)
    :factory_bot
  elsif ActiveRecord::Base.connection.table_exists?('ar_internal_metadata')
    :fixtures
  else
    :unknown
  end
end

.find_model_from_route(path) ⇒ Object 



99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
 
# File 'lib/oas_rails/utils.rb', line 99

def find_model_from_route(path)
  parts = path.split('/')
  model_name = parts.last.singularize.camelize

  namespace_combinations = (0..parts.size).map do |i|
    parts.first(i).map(&:camelize).join('::')
  end

  namespace_combinations.reverse.each do |namespace|
    full_class_name = [namespace, model_name].reject(&:empty?).join('::')
    begin
      return full_class_name.constantize
    rescue NameError
      next
    end
  end

  nil # Return nil if no matching constant is found
end

.get_definition(status_code) ⇒ String

Converts a status code to its corresponding text description.

Parameters:

  • status_code (Integer) —

    The status code.

Returns:

  • (String) —

    The text description of the status code.



91
92
93
 
# File 'lib/oas_rails/utils.rb', line 91

def get_definition(status_code)
  HTTP_STATUS_DEFINITIONS[status_code] || "Definition not found for status code #{status_code}"
end

.hash_to_json_schema(hash) ⇒ Object 



49
50
51
52
53
54
55
 
# File 'lib/oas_rails/utils.rb', line 49

def hash_to_json_schema(hash)
  {
    type: 'object',
    properties: hash_to_properties(hash),
    required: []
  }
end

.hash_to_properties(hash) ⇒ Object 



57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/oas_rails/utils.rb', line 57

def hash_to_properties(hash)
  hash.transform_values do |value|
    if value.is_a?(Hash)
      hash_to_json_schema(value)
    elsif value.is_a?(Class)
      { type: ruby_type_to_json_type(value.name) }
    else
      { type: ruby_type_to_json_type(value.class.name) }
    end
  end
end

.ruby_type_to_json_type(ruby_type) ⇒ Object 



69
70
71
 
# File 'lib/oas_rails/utils.rb', line 69

def ruby_type_to_json_type(ruby_type)
  TYPE_MAPPING.fetch(ruby_type, 'string')
end

.status_to_integer(status) ⇒ Integer

Converts a status symbol or string to an integer.

Parameters:

  • status (String, Symbol, nil) —

    The status to convert.

Returns:

  • (Integer) —

    The status code as an integer.



77
78
79
80
81
82
83
84
85
 
# File 'lib/oas_rails/utils.rb', line 77

def status_to_integer(status)
  return 200 if status.nil?

  if status.to_s =~ /^\d+$/
    status.to_i
  else
    Rack::Utils.status_code(status.to_sym)
  end
end

.type_to_schema(type_string) ⇒ Object 



37
38
39
40
41
42
43
44
45
46
47
 
# File 'lib/oas_rails/utils.rb', line 37

def type_to_schema(type_string)
  if type_string.start_with?('Array<')
    inner_type = type_string[/Array<(.+)>$/, 1]
    {
      "type" => "array",
      "items" => type_to_schema(inner_type)
    }
  else
    { "type" => TYPE_MAPPING.fetch(type_string, 'string') }
  end
end