cbf_calendario 0.3.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e9f80f797d23bf64dad179c1baf17f12c3bada78eb661eeda597bd121d0567ac
-  data.tar.gz: d5a7130a8c70bb594e014b0d82f557ab3f87e14025b9cafcec3b6db269844b0d
+  metadata.gz: 8df4a89b5bf5374d476138e47f0be488c3034dd67ad858fca6ac15ae842f7181
+  data.tar.gz: 1bbb1b57977d00b54ea99ce64a9abf0b6f45f665c20edcf342711ceb94b25a9f
 SHA512:
-  metadata.gz: e161e22aaf7d4445367436f72dedc23a16b3fd4bc5adf0fdc53bf79ed818eca3481aa8f6c2a8780a201b5322b0b184ce22c84771d428ffbab0e85e029b7cbb80
-  data.tar.gz: 403ce1fcccb386a7507e2740df54dd7c008f8088005cba73cc92eb0015bc0177ad36b8f4ffd388ef0fe3b1845b468452c07f4adb0a024d5629c5a645ea8dcfd9
+  metadata.gz: b3827b32b1dafa53a360854fb7bbc7e486381fb0dd22e8c03cabb384df89998864374b1ce4f4422d25c6179e6f62fe5e3af80df2c41efb7f73b615c01ecca175
+  data.tar.gz: 7225d5da60496872dc09c83aa79b96d2583a80d7a396fc57ec30d4a96b99124a53f2015055e403e266566c451ae3e68f42cdde9afae391d4353fa3992197f861

data/CHANGELOG.md

@@ -1,11 +1,36 @@
 # Changelog
 
+## [0.4.1] - 2026-05-11
+
+- Renomeação: `jogos_pendentes_no_dia` → `jogos_do_dia` em `CbfCalendario` e `CbfCalendario::Client` (sem alias)
+
+## [0.4.0] - 2026-05-11
+
+- `Client#jogos_pendentes_no_dia` / `CbfCalendario.jogos_pendentes_no_dia`: passa a listar **todos** os jogos do dia (não só os sem placar na API)
+- Cada linha inclui `placar` (`"M x V"` quando mandante e visitante têm `gols` na API; caso contrário `nil`) além de `horario`
+- README e gemspec atualizados para refletir o novo comportamento
+
+## [0.3.3] - 2026-05-11
+
+- Suíte de testes Minitest completa no padrão Rails (`test/`) cobrindo módulo principal, `Client`, `PartidaStats` e `Urls`
+- `Rakefile` com task `rake test` para execução local da suíte
+- CI no GitHub Actions (`.github/workflows/test.yml`) para rodar testes em push/PR nas versões Ruby 3.2, 3.3 e 3.4
+- Dependências de desenvolvimento adicionadas: `rake` e `minitest (~> 5.22)`
+
+## [0.3.2] - 2026-05-11
+
+- Ajustes internos de robustez HTTP no cliente
+- Suporte a redirecionamentos HTTP (ex.: 308) nas requisições internas do cliente
+- README atualizado
+
+## [0.3.1] - 2026-05-11
+
+- `Client#jogos_pendentes_no_dia`: chave renomeada de `placar_ou_horario` para `horario`
+- README atualizado para refletir o novo formato de retorno dos jogos pendentes
+
 ## [0.3.0] - 2026-05-11
 
-- `Client#atletas_do_clube` e atalho `CbfCalendario.atletas_do_clube`
-- `Client#atleta_por_id` e atalho `CbfCalendario.atleta_por_id`
-- `Client#clube_por_id` e atalho `CbfCalendario.clube_por_id`
-- Novos erros de validação: `InvalidClubIdError` e `InvalidAthleteIdError`
+- Melhorias incrementais no cliente HTTP e na documentação
 - README simplificado e atualizado com as novas funções e exemplos de retorno
 
 ## [0.2.0] - 2026-05-10

data/README.md

@@ -4,11 +4,8 @@ Gem Ruby para consultar a API pública da CBF e retornar dados prontos para uso.
 
 ## O que a gem faz
 
-- Lista jogos pendentes (sem placar) por dia.
+- Lista todos os jogos do dia (calendário da API).
 - Busca a partida completa por `id_jogo`.
-- Busca atletas por `id_clube`.
-- Busca atleta por `id_atleta`.
-- Busca clube por `id_clube`.
 - Gera estatísticas agregadas da súmula.
 - Monta URLs públicas da CBF (partida e times).
 - Retorna hashes Ruby para facilitar integração.
@@ -39,20 +36,32 @@ require 'cbf_calendario'
 ```ruby
 require 'cbf_calendario'
 
-jogos = CbfCalendario.jogos_pendentes_no_dia('10/05/2026')
+jogos = CbfCalendario.jogos_do_dia('10/05/2026')
 partida = CbfCalendario.partida_completa('832031')
 jogo = CbfCalendario.jogo_partida('832031')
-atletas = CbfCalendario.atletas_do_clube('20001')
-atleta = CbfCalendario.atleta_por_id('12345')
-clube = CbfCalendario.clube_por_id('20001')
 stats = CbfCalendario.estatisticas_agregadas(jogo)
 ```
 
+## `partida_completa` e `jogo_partida`
+
+Os dois consultam o mesmo endpoint da CBF: `GET /api/cbf/jogos/:id`. A diferença é **o que é devolvido**:
+
+- **`partida_completa(id_jogo)`** — retorna o **payload inteiro** da API (hash com chaves string), em geral no formato `{ "jogo" => { ... } }`. Use quando precisar do JSON completo da resposta (incluindo o envelope com `"jogo"` e qualquer outra chave de topo que a API enviar).
+
+- **`jogo_partida(id_jogo)`** — retorna **apenas** o hash interno `"jogo"` (mandante, visitante, `registros`, etc.). É o equivalente a `partida_completa(id_jogo)['jogo']`, útil quando você só trabalha com os dados da partida.
+
+| Método | Retorno típico |
+|--------|----------------|
+| `partida_completa` | `{ "jogo" => { ... } }` |
+| `jogo_partida` | `{ "id_jogo" => ..., "mandante" => {...}, ... }` |
+
+Se você já chamou `partida = CbfCalendario.partida_completa(id)`, prefira `partida['jogo']` em vez de chamar `jogo_partida(id)` de novo na mesma rotina (evita uma segunda requisição HTTP idêntica).
+
 ## Funcionalidades principais
 
-### 1) Jogos pendentes por data
+### 1) Jogos do dia
 
-Retorna apenas partidas ainda sem placar no dia informado.
+Retorna todas as partidas previstas ou já disputadas naquela data, conforme o calendário da CBF. Quando a API já trouxer placar, o campo `placar` vem preenchido (ex.: `"2 x 1"`); caso contrário, `placar` fica `nil` e `horario` reflete o horário previsto, se existir.
 
 ### 2) Partida completa por ID
 
@@ -71,29 +80,21 @@ Monta links da página da partida e das páginas de times.
 ### Módulo `CbfCalendario` (atalhos)
 
 - `CbfCalendario.parse_data_br!(str)`
-- `CbfCalendario.jogos_pendentes_no_dia(data, **opts)`
+- `CbfCalendario.jogos_do_dia(data, **opts)`
 - `CbfCalendario.partida_completa(id_jogo, **opts)`
 - `CbfCalendario.jogo_partida(id_jogo, **opts)`
-- `CbfCalendario.atletas_do_clube(id_clube, **opts)`
-- `CbfCalendario.atleta_por_id(id_atleta, **opts)`
-- `CbfCalendario.clube_por_id(id_clube, **opts)`
 - `CbfCalendario.estatisticas_agregadas(jogo)`
 
 ### Classe `CbfCalendario::Client`
 
 - `CbfCalendario::Client.new(base_url: ..., read_timeout: ..., open_timeout: ...)`
-- `client.jogos_pendentes_no_dia(data)`
+- `client.jogos_do_dia(data)`
 - `client.calendario_json(data)`
 - `client.partida_completa(id_jogo)`
 - `client.jogo_partida(id_jogo)`
-- `client.atletas_do_clube(id_clube)`
-- `client.atleta_por_id(id_atleta)`
-- `client.clube_por_id(id_clube)`
 - `CbfCalendario::Client.parse_data_br!(str)`
 - `CbfCalendario::Client.coerce_date!(data)`
 - `CbfCalendario::Client.normalize_id_jogo!(id_jogo)`
-- `CbfCalendario::Client.normalize_id_clube!(id_clube)`
-- `CbfCalendario::Client.normalize_id_atleta!(id_atleta)`
 
 ### Módulo `CbfCalendario::PartidaStats`
 
@@ -120,7 +121,7 @@ Monta links da página da partida e das páginas de times.
 # => #<Date: 2026-12-25 ...>
 ```
 
-### `CbfCalendario.jogos_pendentes_no_dia('10/05/2026')`
+### `CbfCalendario.jogos_do_dia('10/05/2026')`
 
 ```ruby
 # => [
@@ -129,12 +130,26 @@ Monta links da página da partida e das páginas de times.
 #        serie: "Série A",
 #        mandante: "Flamengo",
 #        visitante: "Bahia",
-#        placar_ou_horario: "16:00",
+#        horario: "16:00",
+#        placar: nil,
 #        data: "10/05/2026",
 #        data_iso: "2026-05-10",
 #        local: "Maracanã",
 #        rodada: "6",
 #        id_jogo: "832031"
+#      },
+#      {
+#        campeonato: "Campeonato Brasileiro",
+#        serie: "Série A",
+#        mandante: "Palmeiras",
+#        visitante: "São Paulo",
+#        horario: "",
+#        placar: "1 x 0",
+#        data: "10/05/2026",
+#        data_iso: "2026-05-10",
+#        local: "Allianz Parque",
+#        rodada: "6",
+#        id_jogo: "832032"
 #      }
 #    ]
 ```
@@ -179,53 +194,6 @@ Monta links da página da partida e das páginas de times.
 #    }
 ```
 
-### `CbfCalendario.atletas_do_clube('20001')`
-
-```ruby
-# => {
-#      clube_id: "20001",
-#      atletas: [
-#        {
-#          "id_atleta" => 12345,
-#          "nome_popular" => "Atleta Exemplo",
-#          "nome_completo" => "Atleta Exemplo da Silva",
-#          "posicao" => "MEI",
-#          ...
-#        }
-#      ]
-#    }
-```
-
-### `CbfCalendario.atleta_por_id('12345')`
-
-```ruby
-# => {
-#      atleta_id: "12345",
-#      atleta: {
-#        "id_atleta" => 12345,
-#        "nome_popular" => "Atleta Exemplo",
-#        "nome_completo" => "Atleta Exemplo da Silva",
-#        "posicao" => "ATA",
-#        ...
-#      }
-#    }
-```
-
-### `CbfCalendario.clube_por_id('20001')`
-
-```ruby
-# => {
-#      clube_id: "20001",
-#      clube: {
-#        "id_clube" => 20001,
-#        "nome" => "Time Exemplo",
-#        "sigla" => "TEX",
-#        "escudo" => "https://...",
-#        ...
-#      }
-#    }
-```
-
 ### `CbfCalendario.estatisticas_agregadas(jogo)`
 
 ```ruby
@@ -256,8 +224,6 @@ Monta links da página da partida e das páginas de times.
 
 - `CbfCalendario::InvalidDateError`: data inválida (formato esperado: `dd/mm/aaaa`).
 - `CbfCalendario::InvalidGameIdError`: `id_jogo` inválido (somente dígitos).
-- `CbfCalendario::InvalidClubIdError`: `id_clube` inválido (somente dígitos).
-- `CbfCalendario::InvalidAthleteIdError`: `id_atleta` inválido (somente dígitos).
 - `CbfCalendario::HttpError`: erro HTTP ou payload inválido da API.
 - `CbfCalendario::Error`: classe base.
 
@@ -271,335 +237,15 @@ class CbfCalendarioSyncJob < ApplicationJob
 
   def perform(data_iso: nil)
     data = data_iso ? Date.iso8601(data_iso) : Date.current
-    CbfCalendario.jogos_pendentes_no_dia(data)
-  end
-end
-```
-
-## Requisitos
-
-- Ruby >= 3.0
-
-## Licença
-
-MIT. Veja `LICENSE.txt`.
-# cbf_calendario
-
-Cliente Ruby para a API pública da [CBF](https://www.cbf.com.br): **calendário** (jogos pendentes por dia), **partida** (`/api/cbf/jogos/:id`), **estatísticas derivadas** da súmula e **montagem de URLs** do site. Retornos em **hashes** Ruby para uso em **Rails** ou scripts.
-
-## Instalação
-
-```ruby
-# Gemfile
-gem 'cbf_calendario', '~> 0.2'
-```
-
-```bash
-bundle install
-```
-
-Em qualquer script Ruby (sem Bundler no load path):
-
-```bash
-gem install cbf_calendario
-```
-
-```ruby
-require 'cbf_calendario'
-```
-
----
-
-## Uso direto (mesmo processo da requisição)
-
-Ideal só para testes ou endpoints muito leves. Para produção, prefira **enfileirar um job** (seção seguinte).
-
-```ruby
-require 'cbf_calendario'
-
-# Data como String dd/mm/aaaa, Date ou Time
-jogos = CbfCalendario.jogos_pendentes_no_dia('10/05/2026')
-# => [{ campeonato: "...", serie: "...", mandante: "...", ... }, ...]
-
-jogos = CbfCalendario.jogos_pendentes_no_dia(Date.current)
-
-# Cliente com opções (timeout HTTP, etc.)
-client = CbfCalendario::Client.new(read_timeout: 45)
-client.jogos_pendentes_no_dia('01/06/2026')
-
-# Payload bruto da API (Hash) para o dia
-client.calendario_json(Date.today)
-
-# Parsing de data brasileira
-CbfCalendario.parse_data_br!('25/12/2026') # => Date
-```
-
-### Partida (resultado / súmula completa da API)
-
-Mesmo endpoint usado em `show_game.rb`: **`GET /api/cbf/jogos/:id`**. O retorno é o **JSON completo** como `Hash` em Ruby (chaves **string**, igual ao JSON da CBF).
-
-```ruby
-# Payload inteiro: tipicamente { "jogo" => { ... registros, atletas, árbitros, ... } }
-payload = CbfCalendario.partida_completa('832031')
-
-jogo = payload['jogo']
-puts jogo.dig('mandante', 'nome')
-puts jogo.dig('mandante', 'gols')
-puts jogo.dig('visitante', 'gols')
-
-# Só o objeto jogo (atalho)
-jogo = CbfCalendario.jogo_partida(832031)
-
-# Estatísticas derivadas dos registros (gols por tipo, cartões, substituições…)
-stats = CbfCalendario.estatisticas_agregadas(jogo)
-# => { por_tipo_evento: {...}, gols_mandante_em_eventos: N, ... }
-
-# URLs públicas (mandante/visitante/página da partida), mesma regra do show_game
-cp = jogo['campeonato']
-ano = (cp['ano'] || jogo['ano']).to_s
-pagina = CbfCalendario::Urls.url_pagina_partida(jogo)
-mandante_url = CbfCalendario::Urls.url_time(cp['nome'], cp['nome_categoria'], ano, jogo.dig('mandante', 'id'))
-```
-
-Timeouts maiores (como no script original):
-
-```ruby
-CbfCalendario.partida_completa('832031', read_timeout: 45, open_timeout: 15)
-```
-
-Erros extras: `CbfCalendario::InvalidGameIdError` (ID inválido), `CbfCalendario::HttpError` (HTTP ou resposta sem `jogo`).
-
----
-
-## Referência das funções públicas
-
-### Módulo `CbfCalendario` (atalhos)
-
-| Função | Descrição |
-|--------|-----------|
-| `parse_data_br!(str)` | Converte `"dd/mm/aaaa"` em `Date`. Lança `InvalidDateError`. |
-| `jogos_pendentes_no_dia(data, **opts)` | Jogos do dia **ainda sem placar** na API. `data`: `String` BR, `Date` ou `Time`. Retorna `Array<Hash>` com **chaves símbolo**. `**opts` repassa para `Client.new`. |
-| `partida_completa(id_jogo, **opts)` | `GET /api/cbf/jogos/:id` — payload JSON completo. Retorna `Hash` com **chaves string** (como o JSON). |
-| `jogo_partida(id_jogo, **opts)` | Mesmo endpoint; retorna só `payload["jogo"]` (`Hash` ou levanta erro se ausente). |
-| `estatisticas_agregadas(jogo)` | Agrega eventos da súmula (`registros`, substituições, etc.). Espera o **Hash `jogo`** vindo da API. Retorna `Hash` com **chaves símbolo**. |
-
-### Classe `CbfCalendario::Client`
-
-Construtor: `Client.new(base_url: "https://www.cbf.com.br", read_timeout: 30, open_timeout: 15)`.
-
-| Método | Descrição |
-|--------|-----------|
-| `jogos_pendentes_no_dia(data)` | Igual ao atalho do módulo. |
-| `calendario_json(data)` | Payload bruto do calendário: `GET /api/cbf/calendario/jogos/AAAA/MM/DD` (`Hash`, chaves string). |
-| `partida_completa(id_jogo)` | Payload bruto da partida (`GET /api/cbf/jogos/:id`). |
-| `jogo_partida(id_jogo)` | Somente o objeto `jogo`. |
-| `Client.parse_data_br!(str)` | Igual `CbfCalendario.parse_data_br!`. |
-| `Client.coerce_date!(data)` | Normaliza `Date` / `Time` / string `dd/mm/aaaa`. |
-| `Client.normalize_id_jogo!(id)` | Valida ID numérico (`String` de dígitos) ou levanta `InvalidGameIdError`. |
-
-### `CbfCalendario::PartidaStats`
-
-| Método | Descrição |
-|--------|-----------|
-| `agregadas(jogo)` | Implementação central das agregações; mesmo resultado que `CbfCalendario.estatisticas_agregadas(jogo)`. |
-
-Chaves típicas no **retorno** de `estatisticas_agregadas` / `PartidaStats.agregadas`:
-
-| Chave (símbolo) | Conteúdo |
-|-----------------|----------|
-| `:por_tipo_evento` | Contagem por `tipo` em `registros` (ex.: `GOL`, `PENALIDADE`). |
-| `:gols_por_classificacao_sumula` | Contagem por campo `resultado` nos eventos de gol. |
-| `:gols_mandante_em_eventos` | Gols do mandante contados nos registros `GOL`. |
-| `:gols_visitante_em_eventos` | Idem visitante. |
-| `:cartoes_por_resultado` | Contagem por `resultado` em eventos `PENALIDADE`. |
-| `:total_substituicoes_mandante` | Quantidade de substituições no mandante. |
-| `:total_substituicoes_visitante` | Idem visitante. |
-
-### `CbfCalendario::Urls` (links do site, sem HTTP)
-
-Constante: `CbfCalendario::Urls::SITE_ROOT` (`"https://www.cbf.com.br"`).
-
-| Método | Descrição |
-|--------|-----------|
-| `slug_segment(str)` | Slug à URL (remove acentos, minúsculas, hífens). |
-| `segmento_campeonato(nome)` | Segmento do campeonato na URL (ex.: `campeonato-brasileiro`). |
-| `segmento_categoria(nome_serie)` | Segmento da categoria/série (`serie-a`, `sub-20`, etc.). |
-| `path_pagina_jogo(jogo)` | Path relativo da página da partida no site. |
-| `url_pagina_partida(jogo, base: SITE_ROOT)` | URL absoluta da partida. |
-| `url_time(campeonato_nome, categoria_nome, ano, clube_id, base: SITE_ROOT)` | URL da página do clube na temporada. |
-
-O objeto `jogo`/`payload` usado em `Urls` deve ser o **Hash da API** (como em `jogo_partida`), com `campeonato`, `mandante`, `visitante`, `id_jogo`, etc.
-
----
-
-## Rails: Solid Queue e jobs em background (recomendado)
-
-A API da CBF é chamada via rede; **não bloqueie** requisições HTTP longas no processo web (ex.: Puma). Use **[Solid Queue](https://github.com/rails/solid_queue)** (Rails 8+):
-
-1. Inclua `cbf_calendario` no `Gemfile`.
-2. Configure o adapter **`solid_queue`** para o Active Job.
-3. Implemente um **Active Job** que chama `CbfCalendario`.
-4. Rode o worker **`bin/jobs`** (processo separado do servidor web).
-
-### 1. Adapter Solid Queue
-
-No `Gemfile`, garanta a gem (no Rails 8 costuma vir por padrão; confira o guia do seu app):
-
-```ruby
-gem 'cbf_calendario'
-gem 'solid_queue'
-```
-
-`config/application.rb` (ou ambiente de produção):
-
-```ruby
-config.active_job.queue_adapter = :solid_queue
-```
-
-Em desenvolvimento e produção, mantenha `config.active_job.queue_adapter = :solid_queue` e rode `bin/jobs` quando precisar processar filas fora do ciclo de request.
-
-### 2. Job com Active Job
-
-`app/jobs/cbf_calendario_sync_job.rb`:
-
-```ruby
-# frozen_string_literal: true
-
-class CbfCalendarioSyncJob < ApplicationJob
-  queue_as :default
-
-  # data_iso: "2026-05-10" ou nil para usar Date.current
-  def perform(data_iso: nil)
-    data =
-      if data_iso.present?
-        Date.iso8601(data_iso.to_s)
-      else
-        Date.current
-      end
-
-    jogos = CbfCalendario.jogos_pendentes_no_dia(data)
-
-    # Exemplo: persistir, notificar, cachear — adapte ao seu domínio
-    Rails.logger.info("[CBF] #{jogos.size} jogos pendentes em #{data}")
-
-    jogos.each do |jogo|
-      ExternalFixtureUpsertService.call(jogo) # seu serviço
-    end
-
-    jogos
-  rescue CbfCalendario::HttpError => e
-    Rails.logger.error("[CBF] HTTP: #{e.message}")
-    raise # deixa o Active Job aplicar retry conforme configuração
-  rescue CbfCalendario::InvalidDateError => e
-    Rails.logger.warn("[CBF] data inválida: #{e.message}")
-    raise
+    CbfCalendario.jogos_do_dia(data)
   end
 end
 ```
 
-Enfileirar (controller, outro job, scheduler):
-
-```ruby
-# data específica
-CbfCalendarioSyncJob.perform_later(data_iso: '2026-05-10')
-
-# “hoje” no servidor
-CbfCalendarioSyncJob.perform_later
-
-# com delay
-CbfCalendarioSyncJob.set(wait: 5.minutes).perform_later(data_iso: Date.tomorrow.iso8601)
-```
-
-### 3. Processar a fila (`bin/jobs`)
-
-Com Solid Queue, o worker padrão processa os jobs enfileirados:
-
-```bash
-bin/jobs
-```
-
-Rode em **processo separado** do `rails server` / Puma. Em produção, trate `bin/jobs` como serviço (systemd, container, Plataforma como serviço, etc.).
-
-### 4. Agendamento periódico (Solid Queue)
-
-Use o **recurring** do Solid Queue (ex.: `config/recurring.yml` no seu app) para enfileirar `CbfCalendarioSyncJob.perform_later` no horário desejado. A sintaxe e os arquivos exatos dependem da versão do Solid Queue — veja a [documentação do Solid Queue](https://github.com/rails/solid_queue) (seção *Recurring / cron*).
-
-### 5. Serviço systemd (exemplo): `bin/jobs` no ar
-
-Ajuste usuário, path e caminho do Ruby:
-
-```ini
-[Unit]
-Description=Solid Queue — processador de jobs (Rails + cbf_calendario)
-After=network.target
-
-[Service]
-Type=simple
-User=deploy
-WorkingDirectory=/var/www/seu_app/current
-Environment=RAILS_ENV=production
-ExecStart=/home/deploy/.rbenv/shims/bundle exec bin/jobs
-Restart=always
-RestartSec=10
-
-[Install]
-WantedBy=multi-user.target
-```
-
-```bash
-sudo systemctl daemon-reload
-sudo systemctl enable --now solid-queue-jobs.service
-```
-
-(O nome do arquivo `.service` pode ser o que preferir; o importante é executar `bundle exec bin/jobs`.)
-
----
-
-## API dos hashes retornados (calendário / pendentes)
-
-A tabela abaixo vale para **cada item** de `jogos_pendentes_no_dia` (chaves **símbolo**). O objeto **`jogo`** de `partida_completa` / `jogo_partida` segue o JSON da CBF (chaves **string**: `"mandante"`, `"registros"`, `"arbitros"`, etc.) — veja a referência completa acima.
-
-| Chave | Significado |
-|-------|-------------|
-| `:campeonato` | Nome do campeonato |
-| `:serie` | Série / divisão |
-| `:mandante` | Time mandante |
-| `:visitante` | Time visitante |
-| `:placar_ou_horario` | Horário previsto ou placar, se houver |
-| `:data` | Data como string na API |
-| `:data_iso` | Data no formato `YYYY-MM-DD` |
-| `:local` | Local do jogo |
-| `:rodada` | Rodada |
-| `:id_jogo` | Identificador do jogo na CBF |
-
-### Erros
-
-| Classe | Quando |
-|--------|--------|
-| `CbfCalendario::InvalidDateError` | Data em formato inválido |
-| `CbfCalendario::InvalidGameIdError` | ID de jogo não numérico |
-| `CbfCalendario::HttpError` | Falha HTTP ao chamar a API |
-| `CbfCalendario::Error` | Classe base |
-
-Em jobs, costuma-se **relançar** `HttpError` para retry exponencial; datas inválidas podem ser descartadas sem retry.
-
-### Rails: responder JSON a partir dos hashes
-
-```ruby
-def index
-  jogos = CbfCalendario.jogos_pendentes_no_dia(params.require(:data))
-  render json: jogos.map(&:stringify_keys)
-end
-```
-
-Para não bloquear o request em produção, prefira só enfileirar o job e devolver `202 Accepted`, ou ler resultado de cache/banco preenchido pelo job.
-
----
-
 ## Requisitos
 
 - Ruby >= 3.0
 
 ## Licença
 
-MIT — veja [LICENSE.txt](LICENSE.txt).
+MIT. Veja `LICENSE.txt`.

data/cbf_calendario.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Betbrothers']
   spec.summary       = 'Cliente Ruby para o calendário de jogos da CBF (hashes, uso em Rails)'
   spec.description   = <<~DESC
-    Consulta a API pública de calendário da CBF e devolve jogos pendentes (sem placar)
+    Consulta a API pública de calendário da CBF e devolve todos os jogos do dia
     para uma data, como Array de hashes Ruby — adequado para uso em Ruby on Rails.
   DESC
   spec.license       = 'MIT'
@@ -24,4 +24,7 @@ Gem::Specification.new do |spec|
     %w[LICENSE.txt README.md CHANGELOG.md cbf_calendario.gemspec] + Dir['lib/**/*.rb']
   end
   spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'minitest', '~> 5.22'
+  spec.add_development_dependency 'rake'
 end

data/lib/cbf_calendario/client.rb

@@ -13,8 +13,6 @@ module CbfCalendario
   class HttpError < Error; end
   class InvalidDateError < Error; end
   class InvalidGameIdError < Error; end
-  class InvalidClubIdError < Error; end
-  class InvalidAthleteIdError < Error; end
 
   class Client
     DEFAULT_BASE = 'https://www.cbf.com.br'
@@ -42,45 +40,6 @@ module CbfCalendario
       partida_completa(id_jogo)['jogo']
     end
 
-    # GET /api/cbf/atletas/:id_clube — retorna hash com dados dos atletas.
-    # Saída: { clube_id: "123", atletas: [ ... ] }
-    def atletas_do_clube(id_clube)
-      cid = Client.normalize_id_clube!(id_clube)
-      payload = get_json(api_path_atletas_clube(cid))
-      atletas =
-        if payload.is_a?(Array)
-          payload
-        elsif payload.is_a?(Hash) && payload['atletas'].is_a?(Array)
-          payload['atletas']
-        else
-          raise HttpError, 'Resposta sem lista de atletas'
-        end
-
-      { clube_id: cid, atletas: atletas }
-    end
-
-    # Busca dados completos de um clube por ID.
-    # Saída: { clube_id: "123", clube: { ... } }
-    def clube_por_id(id_clube)
-      cid = Client.normalize_id_clube!(id_clube)
-      payload = buscar_clube_payload(cid)
-      clube = extrair_clube_do_payload(payload, cid)
-      raise HttpError, 'Resposta sem dados do clube' unless clube.is_a?(Hash) && !clube.empty?
-
-      { clube_id: cid, clube: clube }
-    end
-
-    # Busca dados completos de um atleta por ID.
-    # Saída: { atleta_id: "123", atleta: { ... } }
-    def atleta_por_id(id_atleta)
-      aid = Client.normalize_id_atleta!(id_atleta)
-      payload = buscar_atleta_payload(aid)
-      atleta = extrair_atleta_do_payload(payload, aid)
-      raise HttpError, 'Resposta sem dados do atleta' unless atleta.is_a?(Hash) && !atleta.empty?
-
-      { atleta_id: aid, atleta: atleta }
-    end
-
     def self.normalize_id_jogo!(id_jogo)
       s = id_jogo.to_s.strip
       raise InvalidGameIdError, 'id_jogo deve conter só dígitos (ex.: 832024)' unless s.match?(/\A\d+\z/)
@@ -88,28 +47,15 @@ module CbfCalendario
       s
     end
 
-    def self.normalize_id_clube!(id_clube)
-      s = id_clube.to_s.strip
-      raise InvalidClubIdError, 'id_clube deve conter só dígitos (ex.: 20001)' unless s.match?(/\A\d+\z/)
-
-      s
-    end
-
-    def self.normalize_id_atleta!(id_atleta)
-      s = id_atleta.to_s.strip
-      raise InvalidAthleteIdError, 'id_atleta deve conter só dígitos (ex.: 12345)' unless s.match?(/\A\d+\z/)
-
-      s
-    end
-
     # Aceita Date, Time ou String "dd/mm/aaaa".
-    # Retorna Array<Hash> com símbolos como chaves, ordenado e sem IDs duplicados.
-    # Cada hash: +campeonato+, +serie+, +mandante+, +visitante+, +placar_ou_horario+,
+    # Retorna todos os jogos do dia no calendário (pendentes e já realizados).
+    # Array<Hash> com símbolos como chaves, ordenado e sem IDs duplicados.
+    # Cada hash: +campeonato+, +serie+, +mandante+, +visitante+, +horario+, +placar+,
     # +data+, +data_iso+, +local+, +rodada+, +id_jogo+.
-    def jogos_pendentes_no_dia(data)
+    def jogos_do_dia(data)
       date = Client.coerce_date!(data)
       payload = get_json(api_path_calendario(date))
-      jogos = extrair_jogos_pendentes(payload, date)
+      jogos = extrair_jogos_do_dia(payload, date)
       dedup_and_sort(jogos)
     end
 
@@ -150,36 +96,17 @@ module CbfCalendario
       "/api/cbf/jogos/#{id_jogo}"
     end
 
-    def api_path_atletas_clube(id_clube)
-      "/api/cbf/atletas/#{id_clube}"
-    end
-
-    def api_path_atleta(id_atleta)
-      "/api/cbf/atleta/#{id_atleta}"
-    end
-
-    def api_path_atletas_detalhes(id_atleta)
-      "/api/cbf/atletas/detalhes/#{id_atleta}"
-    end
-
-    def api_path_clube(id_clube)
-      "/api/cbf/clubes/#{id_clube}"
-    end
-
-    def api_path_time(id_clube)
-      "/api/cbf/times/#{id_clube}"
-    end
-
-    def api_path_clube_detalhes(id_clube)
-      "/api/cbf/clubes/detalhes/#{id_clube}"
-    end
-
     def get_json(path)
       uri = URI.join(base_url, path)
       request_json(uri)
     end
 
     def request_json(uri)
+      res = perform_get(uri, accept: 'application/json')
+      JSON.parse(res.body)
+    end
+
+    def perform_get(uri, accept:, redirects_left: 5)
       Net::HTTP.start(
         uri.host,
         uri.port,
@@ -190,13 +117,24 @@ module CbfCalendario
         cert_store: ssl_cert_store
       ) do |http|
         req = Net::HTTP::Get.new(uri)
-        req['Accept'] = 'application/json'
+        req['Accept'] = accept
         res = http.request(req)
+
+        if res.is_a?(Net::HTTPRedirection)
+          raise HttpError, 'Muitas redireções na requisição HTTP' if redirects_left <= 0
+
+          location = res['location'].to_s
+          raise HttpError, 'Redirecionamento HTTP sem header Location' if location.empty?
+
+          next_uri = URI.join(uri.to_s, location)
+          return perform_get(next_uri, accept: accept, redirects_left: redirects_left - 1)
+        end
+
         unless res.is_a?(Net::HTTPSuccess)
           raise HttpError, "HTTP #{res.code}: #{res.message}"
         end
 
-        JSON.parse(res.body)
+        res
       end
     end
 
@@ -210,22 +148,19 @@ module CbfCalendario
       end
     end
 
-    def placar_ou_horario(jogo)
-      gm = jogo.dig('mandante', 'gols')
-      gv = jogo.dig('visitante', 'gols')
-
-      return "#{gm} x #{gv}" unless gm.nil? || gv.nil?
-
+    def horario_jogo(jogo)
       jogo['hora'].to_s.strip
     end
 
-    def jogo_sem_placar?(jogo)
+    def placar_partida(jogo)
       gm = jogo.dig('mandante', 'gols')
       gv = jogo.dig('visitante', 'gols')
-      gm.nil? || gv.nil?
+      return nil if gm.nil? || gv.nil?
+
+      "#{gm} x #{gv}"
     end
 
-    def extrair_jogos_pendentes(payload, data_calendario)
+    def extrair_jogos_do_dia(payload, data_calendario)
       raiz = payload['jogos'] || {}
       linhas = []
 
@@ -236,14 +171,13 @@ module CbfCalendario
           next unless lista.is_a?(Array)
 
           lista.each do |jogo|
-            next unless jogo_sem_placar?(jogo)
-
             linhas << {
               campeonato: campeonato.to_s.strip,
               serie: serie.to_s.strip,
               mandante: jogo.dig('mandante', 'nome').to_s.strip,
               visitante: jogo.dig('visitante', 'nome').to_s.strip,
-              placar_ou_horario: placar_ou_horario(jogo),
+              horario: horario_jogo(jogo),
+              placar: placar_partida(jogo),
               data: jogo['data'].to_s.strip,
               data_iso: data_calendario.strftime('%Y-%m-%d'),
               local: jogo['local'].to_s.strip,
@@ -270,80 +204,5 @@ module CbfCalendario
       out.sort_by { |j| [j[:campeonato], j[:serie], j[:rodada].to_i, j[:id_jogo]] }
     end
 
-    def buscar_atleta_payload(id_atleta)
-      paths = [
-        api_path_atleta(id_atleta),
-        api_path_atletas_detalhes(id_atleta),
-        api_path_atletas_clube(id_atleta)
-      ]
-
-      errors = []
-      paths.each do |path|
-        begin
-          return get_json(path)
-        rescue HttpError => e
-          errors << "#{path}: #{e.message}"
-        end
-      end
-
-      raise HttpError, "Não foi possível buscar o atleta #{id_atleta}. Tentativas: #{errors.join(' | ')}"
-    end
-
-    def extrair_atleta_do_payload(payload, id_atleta)
-      if payload.is_a?(Hash)
-        return payload if campo_id_atleta(payload) == id_atleta
-        return payload['atleta'] if payload['atleta'].is_a?(Hash)
-        return payload
-      end
-
-      return {} unless payload.is_a?(Array)
-
-      payload.find { |item| item.is_a?(Hash) && campo_id_atleta(item) == id_atleta } ||
-        payload.find { |item| item.is_a?(Hash) } || {}
-    end
-
-    def campo_id_atleta(hash)
-      hash['id_atleta'].to_s.strip.empty? ? hash['id'].to_s.strip : hash['id_atleta'].to_s.strip
-    end
-
-    def buscar_clube_payload(id_clube)
-      paths = [
-        api_path_clube(id_clube),
-        api_path_time(id_clube),
-        api_path_clube_detalhes(id_clube)
-      ]
-
-      errors = []
-      paths.each do |path|
-        begin
-          return get_json(path)
-        rescue HttpError => e
-          errors << "#{path}: #{e.message}"
-        end
-      end
-
-      raise HttpError, "Não foi possível buscar o clube #{id_clube}. Tentativas: #{errors.join(' | ')}"
-    end
-
-    def extrair_clube_do_payload(payload, id_clube)
-      if payload.is_a?(Hash)
-        return payload if campo_id_clube(payload) == id_clube
-        return payload['clube'] if payload['clube'].is_a?(Hash)
-        return payload['time'] if payload['time'].is_a?(Hash)
-        return payload
-      end
-
-      return {} unless payload.is_a?(Array)
-
-      payload.find { |item| item.is_a?(Hash) && campo_id_clube(item) == id_clube } ||
-        payload.find { |item| item.is_a?(Hash) } || {}
-    end
-
-    def campo_id_clube(hash)
-      return hash['id_clube'].to_s.strip unless hash['id_clube'].to_s.strip.empty?
-      return hash['id_time'].to_s.strip unless hash['id_time'].to_s.strip.empty?
-
-      hash['id'].to_s.strip
-    end
   end
 end

data/lib/cbf_calendario/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CbfCalendario
-  VERSION = '0.3.0'
+  VERSION = '0.4.1'
 end

data/lib/cbf_calendario.rb

@@ -12,9 +12,9 @@ module CbfCalendario
     Client.parse_data_br!(str)
   end
 
-  # Atalho sem instanciar +Client+.
-  def jogos_pendentes_no_dia(data, **client_options)
-    Client.new(**client_options).jogos_pendentes_no_dia(data)
+  # Atalho sem instanciar +Client+. Lista todos os jogos do dia (calendário completo).
+  def jogos_do_dia(data, **client_options)
+    Client.new(**client_options).jogos_do_dia(data)
   end
 
   # GET /api/cbf/jogos/:id — Hash completo da API (chaves string).
@@ -27,21 +27,6 @@ module CbfCalendario
     Client.new(**client_options).jogo_partida(id_jogo)
   end
 
-  # Hash com todos os atletas do clube.
-  def atletas_do_clube(id_clube, **client_options)
-    Client.new(**client_options).atletas_do_clube(id_clube)
-  end
-
-  # Hash com os dados de um atleta específico.
-  def atleta_por_id(id_atleta, **client_options)
-    Client.new(**client_options).atleta_por_id(id_atleta)
-  end
-
-  # Hash com os dados de um clube específico.
-  def clube_por_id(id_clube, **client_options)
-    Client.new(**client_options).clube_por_id(id_clube)
-  end
-
   # Estatísticas derivadas dos registros (+show_game.rb+).
   def estatisticas_agregadas(jogo)
     PartidaStats.agregadas(jogo)

metadata

@@ -1,16 +1,44 @@
 --- !ruby/object:Gem::Specification
 name: cbf_calendario
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Betbrothers
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.22'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |
-  Consulta a API pública de calendário da CBF e devolve jogos pendentes (sem placar)
+  Consulta a API pública de calendário da CBF e devolve todos os jogos do dia
   para uma data, como Array de hashes Ruby — adequado para uso em Ruby on Rails.
 executables: []
 extensions: []