swagger_autogenerate 1.2.8 → 2.0.0

data/lib/swagger_autogenerate/helpers.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module SwaggerAutogenerate
+  module Helpers
+    module_function
+
+    def number?(value)
+      Float(value)
+      true
+    rescue StandardError
+      false
+    end
+
+    def integer?(value)
+      Integer(value)
+      true
+    rescue StandardError
+      false
+    end
+
+    def valid_date?(string)
+      return false unless string.is_a?(String)
+
+      Date.strptime(string)
+      true
+    rescue ArgumentError
+      false
+    end
+
+    def convert_to_date(string)
+      datetime = Date.strptime(string)
+      return Date.parse(string).strftime('%Y/%m/%d') if datetime.year == 1
+
+      datetime.strftime('%Y/%m/%d')
+    rescue ArgumentError
+      string
+    end
+
+    def snake_case(text)
+      return text&.downcase if text&.match?(/\A[A-Z]+\z/)
+
+      text
+        .to_s
+        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+        .gsub(/([a-z])([A-Z])/, '\1_\2')
+        .downcase
+        .tr(' ', '_')
+    end
+
+    def convert_to_hash(obj)
+      case obj
+      when ActiveSupport::HashWithIndifferentAccess
+        obj.to_hash
+      when Hash
+        obj.transform_values { |value| convert_to_hash(value) }
+      when Array
+        obj.map { |item| convert_to_hash(item) }
+      else
+        obj
+      end
+    end
+
+    def reformat_dates_in_hash(data)
+      case data
+      when Hash
+        data.each { |key, value| data[key] = reformat_dates_in_hash(value) }
+      when Array
+        data.map! { |element| reformat_dates_in_hash(element) }
+      when String
+        valid_date?(data) ? convert_to_date(data).to_s : data
+      else
+        data
+      end
+    end
+
+    def merge_properties(old_data, new_data)
+      return old_data unless old_data.is_a?(Hash) && new_data.is_a?(Hash)
+
+      merged = old_data.dup
+      new_data.each do |key, value|
+        merged[key] =
+          if merged[key].is_a?(Hash) && value.is_a?(Hash)
+            merge_properties(merged[key], value)
+          else
+            value
+          end
+      end
+      merged
+    end
+
+    def json_example_plus_one(string)
+      if string =~ /(\d+)$/
+        string.sub(/(\d+)$/, (::Regexp.last_match(1).to_i + 1).to_s)
+      else
+        string
+      end
+    end
+
+    def format_path_to_title(path)
+      cleaned_path = path.to_s.sub(%r{^/v\d+/}, '')
+      cleaned_path.gsub!(/\{[^}]+\}/, '')
+      cleaned_path.split('/').reject(&:empty?).map(&:capitalize).join(' ')
+    end
+
+    def dump_yaml(data)
+      YAML.dump(convert_to_hash(reformat_dates_in_hash(data)))
+    end
+
+    def load_yaml(path)
+      YAML.safe_load(
+        File.read(path),
+        aliases: true,
+        permitted_classes: [Symbol, DateTime, Date, Time, ActiveSupport::HashWithIndifferentAccess],
+        permitted_symbols: []
+      )
+    end
+  end
+end

data/lib/swagger_autogenerate/parameter_builder.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module SwaggerAutogenerate
+  # Builds OpenAPI parameters and requestBody from a Rails request.
+  class ParameterBuilder
+    def initialize(request, schema_builder: SchemaBuilder.new)
+      @request = request
+      @schema = schema_builder
+      @payload_keys = []
+      @payload_hash = {}
+    end
+
+    def parameters
+      result = []
+      push_individual(result, path_parameters, required: true)
+      query_parameters.each { |name, value| push_complex(result, name.to_s, 'query', value) }
+      push_individual(result, request_parameters) if request.request_parameters.blank?
+      result
+    end
+
+    def request_body
+      return if request.request_parameters.blank?
+
+      { 'content' => json_to_content_form_data(request.request_parameters) }
+    end
+
+    def path_parameters
+      { path: request.path_parameters.except(:controller, :format, :action) }
+    end
+
+    def query_parameters
+      request.query_parameters
+    end
+
+    def request_parameters
+      { body: request.request_parameters }
+    end
+
+    private
+
+    attr_reader :request, :schema
+
+    def push_complex(parameters, name, in_type, value, required: false)
+      hash = {
+        'name' => name.to_s,
+        'in' => in_type.to_s,
+        'schema' => schema.schema_data(value)
+      }
+
+      if in_type.to_s == 'query' && hash['schema']['type'] == 'object'
+        hash['style'] = 'deepObject'
+        hash['explode'] = true
+      end
+
+      hash['required'] = required if required
+      parameters.push(hash)
+    end
+
+    def push_individual(parameters, parameter_set, required: false)
+      return if parameter_set.blank?
+
+      in_type = parameter_set.keys.first.to_s
+      params_hash = parameter_set.values.first
+
+      params_hash.each do |key, value|
+        hash = {
+          'name' => key.to_s,
+          'in' => in_type,
+          'schema' => schema.schema_data(value),
+          'example' => schema.example(value)
+        }
+
+        hash['required'] = required if required
+        hash.except!('example') if hash['example'].blank?
+        parameters.push(hash)
+      end
+    end
+
+    def json_to_content_form_data(json)
+      {
+        'multipart/form-data' => {
+          'schema' => schema.build_properties(json)
+        }
+      }
+    end
+  end
+end

data/lib/swagger_autogenerate/path_normalizer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module SwaggerAutogenerate
+  # Turns concrete request paths into OpenAPI path templates.
+  # Example: /users/42 -> /users/{id}
+  class PathNormalizer
+    def self.call(request)
+      path = request.path.dup
+
+      request.path_parameters.except(:controller, :format, :action).each do |key, value|
+        path_array = path.split('/')
+        index = path_array.rindex(value.to_s)
+        next unless index
+
+        path_array[index] = "{#{key}}"
+        path = path_array.join('/')
+      end
+
+      path
+    end
+  end
+end

data/lib/swagger_autogenerate/railtie.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module SwaggerAutogenerate
+  class Railtie < ::Rails::Railtie
+    initializer 'swagger_autogenerate.configure' do
+      config.after_initialize do
+        setup_rspec_hook!
+        auto_include_controller!
+      end
+    end
+
+    private
+
+    def setup_rspec_hook!
+      return unless defined?(RSpec)
+
+      RSpec.configure do |rspec|
+        rspec.before(:each) do |example|
+          next unless SwaggerAutogenerate.generate?
+
+          SwaggerAutogenerate::SwaggerTrace.rspec_description =
+            example&.metadata&.dig(:example_group, :description)
+        end
+      end
+    end
+
+    def auto_include_controller!
+      return unless SwaggerAutogenerate.configuration.auto_include
+      return unless SwaggerAutogenerate.test_environment?
+      return unless defined?(ApplicationController)
+      return if ApplicationController.included_modules.include?(SwaggerAutogenerate)
+
+      ApplicationController.include(SwaggerAutogenerate)
+    end
+  end
+end

data/lib/swagger_autogenerate/response_builder.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module SwaggerAutogenerate
+  # Builds OpenAPI response objects from a Rails response.
+  class ResponseBuilder
+    def initialize(response, config:, example_title:)
+      @response = response
+      @config = config
+      @example_title = example_title
+    end
+
+    def build
+      body =
+        begin
+          JSON.parse(response.body)
+        rescue JSON::ParserError
+          { 'file' => 'file/data' }
+        end
+
+      hash = {
+        'headers' => {},
+        'content' => content_json_example(body)
+      }
+      hash['description'] = config.response_status[response.status] if config.with_response_description
+
+      { response.status.to_s => hash }
+    end
+
+    private
+
+    attr_reader :response, :config, :example_title
+
+    def content_json_example(data)
+      {
+        'application/json' => {
+          'schema' => { 'type' => 'object' },
+          'examples' => {
+            example_title => {
+              'value' => data
+            }
+          }
+        }
+      }
+    end
+  end
+end

data/lib/swagger_autogenerate/schema_builder.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module SwaggerAutogenerate
+  # Infers OpenAPI schema fragments from Ruby values.
+  class SchemaBuilder
+    def schema_type(value)
+      return 'integer' if Helpers.number?(value)
+      return 'boolean' if value.to_s.downcase == 'true' || value.to_s.downcase == 'false'
+      return 'string' if value.is_a?(String) || value.is_a?(Symbol)
+      return 'array' if value.is_a?(Array)
+
+      'object'
+    end
+
+    def example(value)
+      return value.to_i if Helpers.number?(value)
+      return Helpers.convert_to_date(value) if value.is_a?(String) && Helpers.valid_date?(value)
+      return value if value.is_a?(String) || value.is_a?(Symbol)
+
+      nil
+    end
+
+    def properties_data(value)
+      value.each_with_object({}) do |(key, val), hash|
+        hash[key] = { 'type' => schema_type(val), 'example' => Helpers.convert_to_hash(val) }
+      end
+    end
+
+    def schema_data(value)
+      type = schema_type(value)
+      hash = { 'type' => type }
+      hash['properties'] = value.present? ? properties_data(value) : {} if type == 'object'
+      hash
+    end
+
+    def build_properties(json)
+      case json
+      when Hash
+        hash_properties = json.transform_values { |value| build_properties(value) if value.present? }
+        hash_properties = hash_properties.delete_if { |_k, v| v.blank? }
+
+        {
+          'type' => 'object',
+          'properties' => hash_properties
+        }
+      when Array
+        item_schemas = json.map { |item| build_properties(item) }
+        merged_schema = merge_array_schemas(item_schemas)
+
+        if merged_schema[:type] == 'object' || merged_schema['type'] == 'object'
+          { 'type' => 'array', 'items' => merged_schema }
+        else
+          { 'type' => 'array', 'items' => { 'oneOf' => item_schemas.uniq } }
+        end
+      when String
+        if Helpers.integer?(json)
+          { 'type' => 'integer', 'example' => json.to_i }
+        elsif Helpers.number?(json)
+          { 'type' => 'number', 'example' => json.to_f }
+        elsif Helpers.valid_date?(json)
+          { 'type' => 'string', 'example' => json.to_date.to_s }
+        else
+          { 'type' => 'string', 'example' => json.to_s }
+        end
+      when Integer
+        { 'type' => 'integer', 'example' => json }
+      when Float
+        { 'type' => 'number', 'example' => json }
+      when TrueClass, FalseClass
+        { 'type' => 'boolean', 'example' => json }
+      when Date, Time, DateTime
+        { 'type' => 'string', 'example' => json.to_date.to_s }
+      else
+        { 'type' => 'string', 'example' => json.to_s }
+      end
+    end
+
+    private
+
+    def merge_array_schemas(schemas)
+      return {} if schemas.empty?
+
+      schemas.reduce { |merged, schema| Helpers.merge_properties(merged, schema) }
+    end
+  end
+end