swagger_docs_rails 0.1.0

data/lib/swagger_docs_rails/schema_parser.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+# lib/swagger_docs_rails/schema_parser.rb
+#
+# Lê db/schema.rb e gera schemas OpenAPI 3.0 para cada tabela.
+# Produz três schemas por tabela:
+#   - ModelName        → schema completo (usado nas respostas)
+#   - ModelNameInput   → campos editáveis (usado em POST/PATCH genéricos)
+#   - ModelNameList    → wrapper paginado { data: [...], meta: {...} }
+
+module SwaggerDocsRails
+  class SchemaParser
+    IGNORED_COLUMNS = %w[
+      id created_by updated_by deleted_at created_at updated_at
+      encrypted_password reset_password_token reset_password_sent_at
+      remember_created_at refresh_token refresh_token_expires_at
+      token_primeiro_acesso
+    ].freeze
+
+    COLUMN_TYPE_MAP = {
+      string:   { type: "string" },
+      text:     { type: "string" },
+      integer:  { type: "integer", format: "int64" },
+      bigint:   { type: "integer", format: "int64" },
+      float:    { type: "number",  format: "float" },
+      decimal:  { type: "number",  format: "double" },
+      boolean:  { type: "boolean" },
+      date:     { type: "string",  format: "date" },
+      datetime: { type: "string",  format: "date-time" },
+      jsonb:    { type: "object" },
+      json:     { type: "object" }
+    }.freeze
+
+    attr_reader :tables
+
+    def initialize(schema_path = nil)
+      @schema_path = schema_path || Rails.root.join("db", "schema.rb")
+      @tables = {}
+      parse!
+    end
+
+    # Retorna Hash com todos os schemas OpenAPI gerados
+    def to_openapi_schemas
+      schemas = {}
+      @tables.each do |table_name, columns|
+        model = table_to_model_name(table_name)
+        schemas[model]           = build_full_schema(columns)
+        schemas["#{model}Input"] = build_input_schema(columns)
+        schemas["#{model}List"]  = build_list_schema(model)
+      end
+      schemas
+    end
+
+    def model_name_for_table(table_name)
+      table_to_model_name(table_name)
+    end
+
+    private
+
+    def parse!
+      content = File.read(@schema_path)
+
+      content.scan(/create_table\s+"(\w+)".*?do\s+\|t\|(.*?)end/m) do |table_name, body|
+        columns = [{ name: "id", type: :bigint, nullable: false, default: nil }]
+
+        body.scan(/t\.(\w+)\s+"(\w+)"(.*?)$/) do |col_type, col_name, opts|
+          next if col_type == "index"
+          columns << {
+            name:    col_name,
+            type:    col_type.to_sym,
+            nullable: !opts.include?("null: false"),
+            default: extract_default(opts)
+          }
+        end
+
+        columns << { name: "created_at", type: :datetime, nullable: false, default: nil }
+        columns << { name: "updated_at", type: :datetime, nullable: false, default: nil }
+
+        @tables[table_name] = columns
+      end
+    end
+
+    def build_full_schema(columns)
+      props    = {}
+      required = []
+      columns.each do |col|
+        prop = (COLUMN_TYPE_MAP[col[:type]] || { type: "string" }).dup
+        prop[:description] = col[:name].tr("_", " ").capitalize
+        prop[:default]     = cast_default(col[:default], col[:type]) if col[:default]
+        props[col[:name]]  = prop
+        required << col[:name] unless col[:nullable]
+      end
+      schema = { type: "object", properties: props }
+      schema[:required] = required unless required.empty?
+      schema
+    end
+
+    def build_input_schema(columns)
+      writable = columns.reject { |c| IGNORED_COLUMNS.include?(c[:name]) }
+      props    = {}
+      required = []
+      writable.each do |col|
+        prop = (COLUMN_TYPE_MAP[col[:type]] || { type: "string" }).dup
+        prop[:description] = col[:name].tr("_", " ").capitalize
+        props[col[:name]]  = prop
+        required << col[:name] if !col[:nullable] && col[:default].nil?
+      end
+      schema = { type: "object", properties: props }
+      schema[:required] = required unless required.empty?
+      schema
+    end
+
+    def build_list_schema(model)
+      {
+        type: "object",
+        properties: {
+          data: { type: "array", items: { "$ref" => "#/components/schemas/#{model}" } },
+          meta: {
+            type: "object",
+            properties: {
+              current_page: { type: "integer" },
+              total_pages:  { type: "integer" },
+              total_count:  { type: "integer" },
+              per_page:     { type: "integer" }
+            }
+          }
+        }
+      }
+    end
+
+    def table_to_model_name(table_name)
+      singular = table_name.singularize rescue table_name.sub(/s$/, "")
+      parts    = singular.split("_")
+      parts.first == "g" ? "G" + parts[1..].map(&:capitalize).join : parts.map(&:capitalize).join
+    end
+
+    def extract_default(opts)
+      m = opts.match(/default:\s*([^,\s]+)/)
+      m ? m[1] : nil
+    end
+
+    def cast_default(value, type)
+      case type
+      when :boolean        then value == "true"
+      when :integer, :bigint then value.to_i
+      when :float, :decimal  then value.to_f
+      else value.to_s.gsub(/\A["']|["']\z/, "")
+      end
+    end
+  end
+end

data/lib/swagger_docs_rails/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SwaggerDocsRails
+  VERSION = "0.1.0"
+end

data/lib/swagger_docs_rails.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require "swagger_docs_rails/version"
+require "swagger_docs_rails/configuration"
+require "swagger_docs_rails/schema_parser"
+require "swagger_docs_rails/controller_parser"
+require "swagger_docs_rails/openapi_builder"
+require "swagger_docs_rails/generator"
+require "swagger_docs_rails/engine" if defined?(Rails::Engine)
+
+module SwaggerDocsRails
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+  end
+end

data/lib/tasks/swagger_docs_rails.rake

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+namespace :swagger do
+  desc "Gera a documentação OpenAPI 3.0 a partir do schema.rb e controllers"
+  task :generate, [:output] => :environment do |_task, args|
+    require "json"
+    require "swagger_docs_rails"
+
+    config = SwaggerDocsRails.configuration
+    output_path = args[:output] || ENV["SWAGGER_OUTPUT"] || config.output_path
+
+    app_name = begin
+      Rails.application.class.module_parent_name
+    rescue StandardError
+      "API"
+    end
+
+    dados_configuracao = {
+      title: ENV.fetch("SWAGGER_TITLE", config.title || app_name),
+      version: ENV.fetch("SWAGGER_VERSION", config.version || "1.0.0"),
+      description: ENV.fetch("SWAGGER_DESC", config.description || "Documentação OpenAPI gerada automaticamente"),
+      server_url: ENV.fetch("SWAGGER_SERVER", config.server_url || "/")
+    }
+
+    puts "→ Parsing db/schema.rb..."
+    schema_parser = SwaggerDocsRails::SchemaParser.new
+    puts "   #{schema_parser.tables.size} tabelas encontradas"
+    schema_parser.tables.each_key { |tabela| puts "     • #{tabela}" }
+
+    puts "\n→ Scanning app/controllers/api/..."
+    caminhos = [Rails.root.join("app", "controllers", "api"), *Array(config.additional_controller_paths)]
+    controller_parser = SwaggerDocsRails::ControllerParser.new(caminhos)
+    puts "   #{controller_parser.to_resources.size} controllers encontradas"
+    controller_parser.to_resources.each do |recurso|
+      crud_label = recurso[:actions].any? ? "CRUD[#{recurso[:actions].join(",")}]" : "(sem ações CRUD)"
+      custom_label = recurso[:custom_actions].any? ? " + custom[#{recurso[:custom_actions].map { |acao| acao[:name] }.join(",")}]" : ""
+      puts "     • #{recurso[:controller_class]}  #{crud_label}#{custom_label}"
+    end
+
+    puts "\n→ Building OpenAPI document..."
+    documento = SwaggerDocsRails::OpenapiBuilder.new(schema_parser, controller_parser, dados_configuracao).build
+
+    puts "   #{documento[:paths].size} paths"
+    puts "   #{documento.dig(:components, :schemas)&.size || 0} schemas"
+
+    puts "\n→ Writing to #{output_path}..."
+    FileUtils.mkdir_p(File.dirname(output_path.to_s))
+    File.write(output_path.to_s, JSON.pretty_generate(documento))
+
+    tamanho_kb = (File.size(output_path.to_s) / 1024.0).round(1)
+    puts "\n✓ Concluído! #{output_path} (#{tamanho_kb} KB)"
+  end
+
+  desc "Valida o documento OpenAPI gerado (requer gem openapi_parser)"
+  task validate: :environment do
+    require "json"
+    require "openapi_parser"
+
+    path = SwaggerDocsRails.configuration.output_path
+
+    unless File.exist?(path)
+      puts "✗ Arquivo não encontrado. Rode `rails swagger:generate` primeiro."
+      exit 1
+    end
+
+    OpenAPIParser.parse(JSON.parse(File.read(path)), strict_reference_validation: true)
+    puts "✓ Documento OpenAPI válido (#{path})"
+  rescue OpenAPIParser::OpenAPIError => e
+    puts "✗ Validação falhou: #{e.message}"
+    exit 1
+  end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: swagger_docs_rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Clic API
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+description: Rails Engine para gerar documentação OpenAPI 3.0 a partir do schema.rb
+  e controllers Rails.
+email:
+- dev@clic.com.br
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- MIT-LICENSE
+- README.md
+- app/controllers/swagger_docs_rails/swagger_controller.rb
+- config/routes.rb
+- lib/generators/swagger_docs_rails/install/install_generator.rb
+- lib/generators/swagger_docs_rails/install/templates/swagger_docs_rails.rb
+- lib/swagger_docs_rails.rb
+- lib/swagger_docs_rails/configuration.rb
+- lib/swagger_docs_rails/controller_parser.rb
+- lib/swagger_docs_rails/engine.rb
+- lib/swagger_docs_rails/generator.rb
+- lib/swagger_docs_rails/openapi_builder.rb
+- lib/swagger_docs_rails/schema_parser.rb
+- lib/swagger_docs_rails/version.rb
+- lib/tasks/swagger_docs_rails.rake
+homepage: https://rubygems.org/gems/swagger_docs_rails
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://rubygems.org/gems/swagger_docs_rails
+  source_code_uri: https://rubygems.org/gems/swagger_docs_rails
+  changelog_uri: https://rubygems.org/gems/swagger_docs_rails/-/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Gerador OpenAPI e Swagger UI para APIs Rails.
+test_files: []