concurso_hub 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8c7322f931071bf6109d00a6359faab176c639da4073bf3147807c0a04860262
+  data.tar.gz: bb8af9915024a3bb6134f401dd1d60e8a5b5256e3abe54888d24e20375001f12
+SHA512:
+  metadata.gz: '0294a2295e608584c7c92b425d809b53e61acd1c6a752e98a69d0027590a1198c8183d3e772a0e9ec186b92c752a752a090cd9d3fa89c9a09f5c9f298bfb469b'
+  data.tar.gz: 37d8ea5a7e53692a5cedbc905abc0a6157709da4d6d16dac3f55d3f26b9d1648b8fb12918b874ede0f3580c99cf37b5091ba0036afb537c2a9eb6806281f8005

data/README.md

@@ -0,0 +1,511 @@
+# ConcursoHub
+
+Gem Ruby para busca e extração de dados de concursos públicos brasileiros a partir do [PCI Concursos](https://pciconcursos.com.br).
+
+Projetada com **arquitetura hexagonal (Ports & Adapters)**, a biblioteca mantém o núcleo de negócio completamente desacoplado de I/O — tornando-a ideal para uso em **APIs backend** (Rails, Sinatra, Grape, etc.) que precisam expor dados de concursos para um frontend consumir.
+
+---
+
+## Sumário
+
+- [Instalação](#instalação)
+- [Uso via CLI](#uso-via-cli)
+- [Uso como gem em uma API backend](#uso-como-gem-em-uma-api-backend)
+  - [ConcursoHub.search](#concursoscrapersearch)
+  - [ConcursoHub.edital](#concursoscraperedital)
+  - [ConcursoHub.provas](#concursoscraperprovas)
+  - [Exemplo completo em Rails](#exemplo-completo-em-rails)
+- [Uso avançado (injeção de dependências)](#uso-avançado-injeção-de-dependências)
+  - [Listar concursos](#listar-concursos)
+  - [Ver edital completo](#ver-edital-completo)
+  - [Baixar PDFs de um edital](#baixar-pdfs-de-um-edital)
+  - [Baixar provas e gabaritos](#baixar-provas-e-gabaritos)
+- [Arquitetura](#arquitetura)
+- [Entidades de Domínio](#entidades-de-domínio)
+- [Filtros disponíveis](#filtros-disponíveis)
+- [Customizando adaptadores](#customizando-adaptadores)
+- [Dependências](#dependências)
+
+---
+
+## Instalação
+
+> **Nota:** A gem ainda não foi publicada no RubyGems. Para uso local ou como dependência privada, adicione ao seu `Gemfile`:
+
+```ruby
+gem 'concurso_hub', path: '/caminho/para/concurso_test'
+# ou via git:
+# gem 'concurso_hub', github: 'seu-usuario/concurso_hub'
+```
+
+Para instalar as dependências do projeto:
+
+```bash
+bundle install
+```
+
+---
+
+## Uso via CLI
+
+O projeto inclui uma interface de linha de comando para uso rápido e testes.
+
+```bash
+# Listar concursos abertos (padrão)
+ruby main.rb
+
+# Filtrar por estado
+ruby main.rb --estado SP
+
+# Filtrar por nível de escolaridade
+ruby main.rb --nivel Superior
+
+# Busca por texto (instituição ou cargo)
+ruby main.rb --busca "analista"
+
+# Limitar número de resultados
+ruby main.rb --limite 10
+
+# Filtrar por ano de inscrição
+ruby main.rb --ano 2026
+
+# Combinar filtros
+ruby main.rb --estado RJ --nivel Medio --limite 20
+
+# Listar concursos encerrados (requer --busca)
+ruby main.rb --encerrados --busca "policia federal"
+
+# Ver o edital completo de um concurso
+ruby main.rb --ver https://pciconcursos.com.br/concurso/...
+
+# Baixar os PDFs do edital de um concurso
+ruby main.rb --baixar https://pciconcursos.com.br/concurso/...
+
+# Baixar provas e gabaritos anteriores
+ruby main.rb --baixar-provas https://pciconcursos.com.br/concurso/...
+
+# Especificar pasta de destino para downloads
+ruby main.rb --baixar https://... --dir ~/Downloads/concursos
+
+# Ajuda
+ruby main.rb --help
+```
+
+---
+
+## Uso como gem em uma API backend
+
+A maneira mais simples de usar a gem é através do módulo `ConcursoHub`, que expõe uma API de alto nível. Você só precisa adicionar o `require` e chamar os métodos — sem precisar saber nada sobre a arquitetura interna.
+
+```ruby
+require 'concurso_hub'
+```
+
+---
+
+### ConcursoHub.search
+
+Busca concursos com filtros opcionais. Retorna um hash com `concursos` (array) e `metadata`.
+
+```ruby
+# Busca simples — 1 requisição HTTP
+resultado = ConcursoHub.search(estado: 'SP', nivel: 'Superior', limite: 10)
+
+resultado[:concursos]
+# => [
+#   { instituicao: "TRF-3", estado: "SP", vagas: "50", salario: "R$ 8.529",
+#     cargos: "Analista Judiciário", nivel: "Superior",
+#     prazo: "10/06/2026", url: "https://pciconcursos.com.br/concurso/..." },
+#   ...
+# ]
+
+resultado[:metadata]
+# => { total_scraped: 120, modo: :abertos }
+```
+
+**Com dados do edital** — inclui PDFs e descrição para cada concurso (`+1 req por concurso`):
+
+```ruby
+resultado = ConcursoHub.search(estado: 'RJ', limite: 5, with_edital: true)
+
+resultado[:concursos].first[:edital]
+# => {
+#   titulo:          "Edital nº 1/2026 — TRF-2",
+#   descricao:       "...",
+#   data_publicacao: "15/04/2026",
+#   pdfs: [
+#     { titulo: "Edital completo", url: "https://..." },
+#     { titulo: "Retificação nº 1", url: "https://..." }
+#   ],
+#   provas_url: "https://pciconcursos.com.br/provas/...",  # nil se não houver
+#   blocos: [...],
+#   url: "https://pciconcursos.com.br/concurso/..."
+# }
+```
+
+**Com provas e gabaritos** — inclui tudo acima mais a listagem de provas anteriores (`+N reqs por concurso` — use `limite`):
+
+```ruby
+resultado = ConcursoHub.search(estado: 'SP', limite: 2, with_provas: true)
+
+resultado[:concursos].first[:provas]
+# => [
+#   {
+#     cargo: "Analista Judiciário — Área Administrativa",
+#     pdfs: [
+#       { titulo: "Prova Objetiva — 2023", url: "https://..." },
+#       { titulo: "Gabarito Preliminar — 2023", url: "https://..." }
+#     ]
+#   },
+#   ...
+# ]
+```
+
+**Parâmetros disponíveis:**
+
+| Parâmetro     | Tipo              | Padrão     | Descrição                                               |
+|---------------|-------------------|------------|---------------------------------------------------------|
+| `estado`      | `String \| nil`   | `nil`      | UF (ex: `'SP'`, `'MG'`)                                |
+| `nivel`       | `String \| nil`   | `nil`      | Escolaridade (ex: `'Superior'`, `'Médio'`)              |
+| `busca`       | `String \| nil`   | `nil`      | Texto livre — obrigatório para `modo: :encerrados`      |
+| `limite`      | `Integer \| nil`  | `nil`      | Máximo de resultados                                    |
+| `ano`         | `String \| nil`   | `nil`      | Ano do prazo de inscrição (ex: `'2026'`)                |
+| `modo`        | `Symbol`          | `:abertos` | `:abertos` ou `:encerrados`                             |
+| `with_edital` | `Boolean`         | `false`    | Inclui edital com PDFs (+1 req/concurso)                |
+| `with_provas` | `Boolean`         | `false`    | Inclui provas/gabaritos — implica `with_edital`         |
+
+---
+
+### ConcursoHub.edital
+
+Retorna o edital completo de um concurso a partir da URL.
+
+```ruby
+edital = ConcursoHub.edital('https://pciconcursos.com.br/concurso/...')
+
+edital[:titulo]          # => "Edital nº 1/2026"
+edital[:data_publicacao] # => "15/04/2026"
+edital[:descricao]       # => "..."
+edital[:pdfs]            # => [{ titulo:, url: }, ...]
+edital[:blocos]          # => [{ tipo: :secao|:paragrafo|:item, texto: }, ...]
+edital[:url]             # => URL original
+```
+
+---
+
+### ConcursoHub.provas
+
+Retorna a listagem de provas e gabaritos anteriores. Recebe a mesma URL do concurso retornada pelo `search` — não precisa passar nenhuma URL intermediária.
+
+```ruby
+# url vem diretamente de search()
+concurso_url = resultado[:concursos].first[:url]
+
+provas = ConcursoHub.provas(concurso_url)
+
+provas
+# => [
+#   {
+#     cargo: "Analista Judiciário — Área Administrativa",
+#     pdfs: [
+#       { titulo: "Prova Objetiva — 2023", url: "https://..." },
+#       { titulo: "Gabarito Preliminar — 2023", url: "https://..." }
+#     ]
+#   }
+# ]
+```
+
+---
+
+### Exemplo completo em Rails
+
+**`Gemfile`**
+```ruby
+gem 'concurso_hub', path: '../concurso_test'
+# ou após publicar: gem 'concurso_hub', '~> 1.0'
+```
+
+**`app/controllers/concursos_controller.rb`**
+```ruby
+require 'concurso_hub'
+
+class ConcursosController < ApplicationController
+  # GET /concursos?estado=SP&nivel=Superior&limite=10
+  def index
+    resultado = ConcursoHub.search(
+      estado: params[:estado],
+      nivel:  params[:nivel],
+      busca:  params[:busca],
+      limite: params[:limite]&.to_i,
+      ano:    params[:ano]
+    )
+    render json: resultado
+  rescue => e
+    render json: { error: e.message }, status: :bad_gateway
+  end
+
+  # GET /concursos/edital?url=https://pciconcursos.com.br/concurso/...
+  def edital
+    render json: ConcursoHub.edital(params[:url])
+  rescue => e
+    render json: { error: e.message }, status: :bad_gateway
+  end
+
+  # GET /concursos/provas?url=https://pciconcursos.com.br/concurso/...
+  # (mesma url retornada pelo /concursos)
+  def provas
+    render json: ConcursoHub.provas(params[:url])
+  rescue => e
+    render json: { error: e.message }, status: :bad_gateway
+  end
+end
+```
+
+**`config/routes.rb`**
+```ruby
+get '/concursos',        to: 'concursos#index'
+get '/concursos/edital', to: 'concursos#edital'
+get '/concursos/provas', to: 'concursos#provas'  # ?url= é a URL do concurso
+```
+
+---
+
+## Uso avançado (injeção de dependências)
+
+Se precisar de mais controle — mock para testes, presenter customizado, troca de repositório — você pode instanciar os use cases diretamente.
+
+### Listar concursos
+
+```ruby
+require 'concurso_hub'  # ou os requires individuais de src/
+
+# Presenter que coleta os dados em vez de imprimir
+class MeuPresenter < Application::Ports::Presenter
+  attr_reader :concursos, :metadata
+
+  def show(concursos, metadata: {}) = (@concursos = concursos) && (@metadata = metadata)
+  def error(msg)                    = raise msg
+  def show_loading                  = nil
+  def show_edital(_)                = nil
+  def show_provas(_)                = nil
+  def show_download_start(*)        = nil
+  def show_download_done(_)         = nil
+end
+
+repository = Infrastructure::Repositories::PciConcursoRepository.new
+presenter  = MeuPresenter.new
+
+Application::UseCases::ListarConcursos.new(
+  repository: repository,
+  presenter:  presenter
+).execute(
+  Application::FiltrosConcurso.new(estado: 'SP', nivel: 'Superior', limite: 10, modo: :abertos)
+)
+
+presenter.concursos  # Array<Domain::Entities::Concurso>
+presenter.metadata   # Hash
+```
+
+### Ver edital completo
+
+```ruby
+class EditalPresenter < Application::Ports::Presenter
+  attr_reader :edital
+
+  def show_edital(edital) = @edital = edital
+  def error(msg)          = raise msg
+  def show(*)             = nil
+  def show_loading        = nil
+  def show_provas(_)      = nil
+  def show_download_start(*) = nil
+  def show_download_done(_)  = nil
+end
+
+presenter = EditalPresenter.new
+Application::UseCases::VerEdital.new(
+  repository: Infrastructure::Repositories::PciConcursoRepository.new,
+  presenter:  presenter
+).execute(Application::VerEditalRequest.new(url: 'https://pciconcursos.com.br/concurso/...'))
+
+presenter.edital.titulo    # => String
+presenter.edital.pdfs      # => [{ titulo:, url: }]
+presenter.edital.provas_url # => String | nil
+```
+
+### Baixar PDFs de um edital
+
+```ruby
+require 'application/use_cases/baixar_edital'
+require 'application/baixar_edital_request'
+require 'infrastructure/http/http_file_downloader'
+
+Application::UseCases::BaixarEdital.new(
+  repository: Infrastructure::Repositories::PciConcursoRepository.new,
+  downloader: Infrastructure::Http::HttpFileDownloader.new,
+  presenter:  presenter  # qualquer presenter com show_download_start/done
+).execute(
+  Application::BaixarEditalRequest.new(
+    url:      'https://pciconcursos.com.br/concurso/...',
+    dest_dir: '/tmp/editais'
+  )
+)
+# PDFs salvos em dest_dir
+```
+
+### Baixar provas e gabaritos
+
+```ruby
+require 'application/use_cases/baixar_provas'
+require 'application/baixar_provas_request'
+
+Application::UseCases::BaixarProvas.new(
+  repository: Infrastructure::Repositories::PciConcursoRepository.new,
+  downloader: Infrastructure::Http::HttpFileDownloader.new,
+  presenter:  presenter
+).execute(
+  Application::BaixarProvasRequest.new(
+    url:      'https://pciconcursos.com.br/concurso/...',  # mesma URL do concurso
+    dest_dir: '/tmp/provas'
+  )
+)
+# PDFs salvos em dest_dir organizados por cargo
+```
+
+---
+
+## Arquitetura
+
+O projeto segue a **arquitetura hexagonal (Ports & Adapters)** com separação estrita de camadas:
+
+```
+┌─────────────────────────────────────────────────────┐
+│  Apresentação (Adaptadores de entrada)              │
+│  CLI: CliOptionsParser → CliController              │
+│  API: Controller Rails/Sinatra/etc. (você implementa)│
+│  TerminalPresenter  ←→  JsonPresenter (custom)      │
+└──────────────────────┬──────────────────────────────┘
+                       │ Request objects
+┌──────────────────────▼──────────────────────────────┐
+│  Aplicação (Núcleo — sem dependências de framework) │
+│  Use Cases: ListarConcursos, VerEdital,             │
+│             BaixarEdital, BaixarProvas              │
+│  Ports (interfaces): ConcursoRepository,            │
+│                      FileDownloader, Presenter      │
+│  Value Objects: FiltrosConcurso, *Request           │
+└──────────────────────┬──────────────────────────────┘
+                       │ Entidades de domínio
+┌──────────────────────▼──────────────────────────────┐
+│  Domínio (Puro, sem dependências externas)          │
+│  Entities: Concurso, Edital (imutáveis/frozen)      │
+└──────────────────────┬──────────────────────────────┘
+                       │ implementa ports
+┌──────────────────────▼──────────────────────────────┐
+│  Infraestrutura (Adaptadores de saída)              │
+│  PciConcursoRepository (implementa ConcursoRepository)│
+│  HttpClient, HttpFileDownloader                     │
+│  PciHtmlParser (Nokogiri)                           │
+└─────────────────────────────────────────────────────┘
+```
+
+**Princípio central:** os use cases dependem apenas das interfaces (ports) — nunca de infraestrutura diretamente. Isso permite trocar a fonte de dados (outro site, banco de dados, mock) sem alterar o núcleo.
+
+---
+
+## Entidades de Domínio
+
+### `Domain::Entities::Concurso`
+
+| Atributo     | Tipo     | Descrição                                  |
+|--------------|----------|--------------------------------------------|
+| `instituicao`| `String` | Nome do órgão/instituição                  |
+| `estado`     | `String` | UF (ex: `SP`, `RJ`)                        |
+| `vagas`      | `String` | Número de vagas                            |
+| `salario`    | `String` | Faixa salarial                             |
+| `cargos`     | `String` | Cargos disponíveis                         |
+| `nivel`      | `String` | Nível de escolaridade exigido              |
+| `prazo`      | `String` | Data-limite de inscrição                   |
+| `url`        | `String` | URL do edital no PCI Concursos             |
+
+### `Domain::Entities::Edital`
+
+| Atributo          | Tipo             | Descrição                                            |
+|-------------------|------------------|------------------------------------------------------|
+| `titulo`          | `String`         | Título do edital                                     |
+| `descricao`       | `String`         | Descrição resumida                                   |
+| `data_publicacao` | `String`         | Data de publicação                                   |
+| `blocos`          | `Array<Hash>`    | Conteúdo estruturado: `{ tipo:, texto: }`            |
+| `pdfs`            | `Array<Hash>`    | Lista de PDFs: `{ titulo:, url: }`                   |
+| `provas_url`      | `String \| nil`  | URL da página de provas anteriores (se disponível)   |
+| `url`             | `String`         | URL canônica do edital                               |
+
+Os tipos de bloco em `blocos` são: `:secao`, `:paragrafo`, `:item`.
+
+---
+
+## Filtros disponíveis
+
+`Application::FiltrosConcurso` é um `Struct` com os seguintes campos:
+
+| Campo    | Tipo              | Descrição                                        | Exemplo         |
+|----------|-------------------|--------------------------------------------------|-----------------|
+| `estado` | `String \| nil`   | Filtrar por UF                                   | `'SP'`, `'MG'`  |
+| `nivel`  | `String \| nil`   | Nível de escolaridade                            | `'Superior'`    |
+| `busca`  | `String \| nil`   | Busca textual (obrigatório para `:encerrados`)   | `'analista'`    |
+| `limite` | `Integer \| nil`  | Máximo de resultados retornados                  | `10`            |
+| `modo`   | `Symbol`          | `:abertos` (padrão) ou `:encerrados`             | `:abertos`      |
+| `ano`    | `String \| nil`   | Ano do prazo de inscrição                        | `'2026'`        |
+
+---
+
+## Customizando adaptadores
+
+A arquitetura foi pensada para facilitar extensão. Você pode substituir qualquer adaptador sem tocar no núcleo.
+
+### Repositório mock para testes
+
+```ruby
+require 'application/ports/concurso_repository'
+require 'domain/entities/concurso'
+
+class MockConcursoRepository < Application::Ports::ConcursoRepository
+  def fetch_abertos
+    concursos = [
+      Domain::Entities::Concurso.new(
+        instituicao: 'TRF-1',
+        estado:      'DF',
+        vagas:       '50',
+        salario:     'R$ 8.000',
+        cargos:      'Analista Judiciário',
+        nivel:       'Superior',
+        prazo:       '30/06/2026',
+        url:         'https://example.com/concurso'
+      )
+    ]
+    [concursos, { total_scraped: 1, modo: :abertos }]
+  end
+
+  # Implementar outros métodos conforme necessário para os testes...
+end
+
+# Injetar na ConcursoHub ou diretamente nos use cases
+resultado = ConcursoHub.search(estado: 'DF')
+# Para usar o mock, injete via uso direto dos use cases (seção anterior)
+```
+
+---
+
+## Dependências
+
+| Gem        | Versão   | Uso                          |
+|------------|----------|------------------------------|
+| `nokogiri` | `~> 1.16`| Parsing de HTML              |
+
+Todo o restante utiliza apenas a biblioteca padrão do Ruby: `net/http`, `uri`, `optparse`.
+
+**Versão mínima de Ruby:** 3.1 (usa pattern matching e hash shorthand syntax).
+
+---
+
+## Contribuindo
+
+Pull requests são bem-vindos. Ao adicionar suporte a uma nova fonte de dados (além do PCI Concursos), implemente a interface `Application::Ports::ConcursoRepository` e injete o novo adaptador — o núcleo não precisa ser alterado.

data/lib/concurso_hub/version.rb

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

data/lib/concurso_hub.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require_relative 'concurso_hub/version'
+
+$LOAD_PATH.unshift(File.join(__dir__, '..', 'src'))
+
+require 'application/filtros_concurso'
+require 'application/ver_edital_request'
+require 'application/ports/presenter'
+require 'application/use_cases/listar_concursos'
+require 'application/use_cases/ver_edital'
+require 'application/use_cases/listar_provas'
+require 'infrastructure/repositories/pci_concurso_repository'
+
+module ConcursoHub
+  def self.search(
+    estado: nil,
+    nivel: nil,
+    busca: nil,
+    limite: nil,
+    ano: nil,
+    modo: :abertos,
+    with_edital: false,
+    with_provas: false
+  )
+    repository = build_repository
+    presenter  = SilentPresenter.new
+
+    Application::UseCases::ListarConcursos.new(
+      repository: repository,
+      presenter:  presenter
+    ).execute(
+      Application::FiltrosConcurso.new(
+        estado: estado, nivel: nivel, busca: busca,
+        limite: limite, ano: ano, modo: modo
+      )
+    )
+
+    raise presenter.erro if presenter.erro
+
+    concursos = presenter.concursos.map { |c| serialize_concurso(c) }
+
+    if with_edital || with_provas
+      concursos.each do |c|
+        edital_data = fetch_edital_hash(c[:url], repository)
+        c[:edital]  = edital_data
+
+        if with_provas && edital_data[:provas_url]
+          c[:provas] = fetch_provas_array(edital_data[:provas_url], repository)
+        else
+          c[:provas] = [] if with_provas
+        end
+      end
+    end
+
+    { concursos: concursos, metadata: presenter.metadata }
+  end
+
+  def self.edital(url)
+    fetch_edital_hash(url, build_repository)
+  end
+
+  def self.provas(url)
+    repository = build_repository
+    edital     = fetch_edital_hash(url, repository)
+
+    raise "Nenhuma prova disponível para este concurso." unless edital[:provas_url]
+
+    fetch_provas_array(edital[:provas_url], repository)
+  end
+
+  private_class_method def self.build_repository
+    Infrastructure::Repositories::PciConcursoRepository.new
+  end
+
+  private_class_method def self.fetch_edital_hash(url, repository)
+    presenter = SilentPresenter.new
+    Application::UseCases::VerEdital.new(
+      repository: repository,
+      presenter:  presenter
+    ).execute(Application::VerEditalRequest.new(url: url))
+
+    raise presenter.erro if presenter.erro
+
+    serialize_edital(presenter.edital)
+  end
+
+  private_class_method def self.fetch_provas_array(url, repository)
+    presenter = SilentPresenter.new
+    Application::UseCases::ListarProvas.new(
+      repository: repository,
+      presenter:  presenter
+    ).execute(Application::VerEditalRequest.new(url: url))
+
+    return [] if presenter.erro
+
+    presenter.provas
+  end
+
+  private_class_method def self.serialize_concurso(c)
+    {
+      instituicao: c.instituicao,
+      estado:      c.estado,
+      vagas:       c.vagas,
+      salario:     c.salario,
+      cargos:      c.cargos,
+      nivel:       c.nivel,
+      prazo:       c.prazo,
+      url:         c.url
+    }
+  end
+
+  private_class_method def self.serialize_edital(e)
+    {
+      titulo:          e.titulo,
+      descricao:       e.descricao,
+      data_publicacao: e.data_publicacao,
+      pdfs:            e.pdfs,
+      provas_url:      e.provas_url,
+      blocos:          e.blocos,
+      url:             e.url
+    }
+  end
+
+  class SilentPresenter < Application::Ports::Presenter
+    attr_reader :concursos, :edital, :provas, :metadata, :erro
+
+    def show(concursos, metadata: {})
+      @concursos = concursos
+      @metadata  = metadata
+    end
+
+    def show_edital(edital)  = @edital = edital
+    def show_provas(provas)  = @provas = provas
+    def error(message)       = @erro   = message
+
+    def show_loading           = nil
+    def show_download_start(*) = nil
+    def show_download_done(_)  = nil
+  end
+  private_constant :SilentPresenter
+end
+

data/src/application/baixar_edital_request.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Application
+  BaixarEditalRequest = Struct.new(:url, :dest_dir, keyword_init: true)
+end

data/src/application/baixar_provas_request.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Application
+  BaixarProvasRequest = Struct.new(:url, :dest_dir, keyword_init: true)
+end

data/src/application/filtros_concurso.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Application
+  FiltrosConcurso = Struct.new(
+    :estado,
+    :nivel,
+    :busca,
+    :limite,
+    :modo,
+    :ano,
+    keyword_init: true
+  ) do
+    def abertos?    = modo != :encerrados
+    def encerrados? = modo == :encerrados
+  end
+end