datajud 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0322247203376f73cf7f797183970f8ef7d7147e4bd782c09d8494b255104668
-  data.tar.gz: 8533fd1daf5c4ce9e9e4c6771ff07e32435a976c6bfab9b069aa8fd591012437
+  metadata.gz: 5f39081aadf1eae3fd48ec2b4c41290747c9c1d7af57e1c2277a030633ed9e64
+  data.tar.gz: aab5ae80ec67d1465641b0af7b4674b1ee2dceddcc20c5ef36fbf9263dd2a23a
 SHA512:
-  metadata.gz: c460a3f2464dd88e681bd86255948af4adb184b7006901f96e24ffabb3bd3083d07ee86492f3d259a2cc62d89687960bd318d271a97a2ba5c86aa423db729884
-  data.tar.gz: 8835e83491188e7d35864ae9c132f418fe4f1cd2d80528d9d587b1527d92bd5bdc348924ab3d59c626246e8b4bb6b5f5f5bbc41dd4d651ee7adc955f6025a879
+  metadata.gz: 8c0c96e126baf36e5a1e9fe6960a60f6bf332290931515f8386245c4e808905a89c2bae3a89dd38fb900a6de953739e9175edc2880047520d62ae054bab7c674
+  data.tar.gz: f518b69601b88db2d9a7eb452673019449504772ce4d818e2c64d65e663b8b72a1f8ec1910ce37a5839cd135b1d65386f43ba9fe67dd72b731484212cf267d53

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 ## [Unreleased]
 
+## [0.1.2] - 2026-03-12
+
+- Added `Datajud.find` to return process data via an object-oriented API.
+
 ## [0.1.0] - 2025-11-25
 
 - Initial release

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    datajud (0.1.0)
+    datajud (0.1.3)
       json (~> 2.0)
       net-http (~> 0.3)
       nokogiri (~> 1.14)

data/README.md

@@ -1,8 +1,6 @@
 # Datajud
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/datajud`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+SDK simples para consumir a API pública do DataJud (CNJ) em Ruby.
 
 ## Installation
 
@@ -16,7 +14,143 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
 ## Usage
 
-TODO: Write usage instructions here
+### Consultar processo com API orientada a objeto
+
+```ruby
+require 'datajud'
+
+processo = Datajud.find("00008323520184013202")
+
+# Com tribunal explícito
+processo = Datajud.find("00008323520184013202", tribunal: "trf1")
+
+processo.numero
+processo.classe
+processo.partes
+processo.movimentacoes
+
+# Tribunal como objeto
+processo.tribunal
+# => { nome: "TRF1", sigla: "TRF1", esfera: "Federal" }
+
+# Tabela HTML de endpoints (todos os tribunais conhecidos)
+Datajud.endpoints_table(Datajud::TRIBUNAIS_SIGLAS)
+```
+
+### Métodos de consulta disponíveis
+
+```ruby
+# API orientada a objeto
+processo = Datajud.find("00008323520184013202", tribunal: "trf1")
+
+# Retorno bruto (hash)
+resultado = Datajud.processo("00008323520184013202", tribunal: "trf1")
+
+# Consulta genérica com filtros (Elasticsearch)
+resultado = Datajud::ApiClient.buscar("trf1", match: { numeroProcesso: "00008323520184013202" })
+
+# Atalho para buscar processo (modo legado)
+resultado = Datajud::ApiClient.buscar_processo("00008323520184013202", "trf1")
+```
+
+> Dica: quando quiser ver todas as chaves retornadas pela API, prefira `Datajud.processo`.
+
+### Compatibilidade com ApiClient (modo legado)
+
+```ruby
+Datajud.configure do |config|
+    config.api_key = "SUA_API_KEY"
+end
+
+resultado = DataJud::ApiClient.buscar_processo("00008323520184013202", "trf1")
+puts resultado
+```
+
+### Auto-detectar tribunal pelo número CNJ
+
+Se o número estiver no formato CNJ, a gem tenta derivar o tribunal automaticamente
+para evitar varrer todas as bases.
+
+```ruby
+processo = Datajud.find("0000832-35.2018.8.26.0202")
+puts processo.tribunal
+```
+
+> A UF da comarca é derivada localmente pelo código IBGE do município quando disponível.
+
+### Configuração (API key, timeout e retries)
+
+```ruby
+Datajud.configure do |config|
+    config.api_key = "SUA_API_KEY"
+    config.open_timeout = 5
+    config.read_timeout = 15
+    config.retries = 2
+    config.retry_wait = 0.5
+    config.fallback_all_on_miss = true
+    config.lookup_ibge = true
+    config.ibge_base_url = "https://servicodados.ibge.gov.br/api/v1/localidades/municipios"
+end
+```
+
+Ou via variável de ambiente:
+
+```bash
+export DATAJUD_API_KEY="SUA_API_KEY"
+```
+
+### Consultar processo sem passar tribunal
+
+```ruby
+require 'datajud'
+
+resultado = Datajud.processo("00008323520184013202")
+puts resultado
+```
+
+### Consultar processo passando 1 tribunal
+
+```ruby
+require 'datajud'
+
+resultado = Datajud.processo("00008323520184013202", tribunal: "trf1")
+puts resultado
+```
+
+### Consultar processo passando vários tribunais
+
+```ruby
+require 'datajud'
+
+resultado = Datajud.processo("00008323520184013202", tribunal: ["trf1", "tjmg"])
+puts resultado
+```
+
+### Listas de tribunais disponíveis
+
+Você pode acessar as listas de siglas dos tribunais diretamente pelas constantes do módulo:
+
+```ruby
+require 'datajud'
+
+# Todos os tribunais
+Datajud::TRIBUNAIS_SIGLAS
+
+# Apenas TJs
+Datajud::TJS_SIGLAS
+
+# Apenas TRFs
+Datajud::TRFS_SIGLAS
+
+# Apenas TRTs
+Datajud::TRTS_SIGLAS
+
+# Apenas TREs
+Datajud::TRES_SIGLAS
+
+# Apenas Superiores
+Datajud::SUPERIORES_SIGLAS
+```
 
 ## Development
 
@@ -26,7 +160,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/datajud. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/datajud/blob/master/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at https://github.com/PablUoo/datajud. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/PablUoo/datajud/blob/master/CODE_OF_CONDUCT.md).
 
 ## License
 
@@ -34,4 +168,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the Datajud project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/datajud/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the Datajud project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/PablUoo/datajud/blob/master/CODE_OF_CONDUCT.md).

data/examples/find.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "../lib/datajud"
+
+Datajud.configure do |config|
+  config.open_timeout = 3
+  config.read_timeout = 5
+end
+
+begin
+  processo = Datajud.find("0000832-35.2018.8.26.0202")
+
+  if processo
+    puts "Tribunal: #{processo.tribunal}"
+    puts "Número: #{processo.numero}"
+    puts "Classe: #{processo.classe}"
+    puts "Partes: #{processo.partes.map(&:nome).join(', ')}"
+    puts "Movimentações: #{processo.movimentacoes.size}"
+  else
+    puts "Processo não encontrado."
+  end
+rescue StandardError => e
+  warn "Erro ao consultar DataJud: #{e.class} - #{e.message}"
+end

data/lib/datajud/api_client.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+
+module Datajud
+  class ApiClient
+    BASE_URL = "https://api-publica.datajud.cnj.jus.br"
+
+    # Consulta genérica: tribunal e filtros customizados
+    def self.buscar(tribunal, filtros = {})
+      endpoint = "/api_publica_#{tribunal.downcase}/_search"
+      url = URI("#{Datajud.configuration.base_endpoint}#{endpoint}")
+      http = Net::HTTP.new(url.host, url.port)
+      http.use_ssl = (url.scheme == "https")
+      http.open_timeout = Datajud.configuration.open_timeout
+      http.read_timeout = Datajud.configuration.read_timeout
+
+      request = Net::HTTP::Post.new(url)
+      request['Authorization'] = "APIKey #{Datajud.api_key}"
+      request['Content-Type'] = 'application/json'
+      request.body = { query: filtros }.to_json
+
+      begin
+        response = Datajud.request_with_retry(http, request)
+        if response.is_a?(Net::HTTPSuccess)
+          JSON.parse(response.body)
+        else
+          { error: response.message, status: response.code, body: response.body }
+        end
+      rescue SocketError => e
+        { error: "Falha de conexão: #{e.message}" }
+      rescue Errno::ECONNRESET => e
+        { error: "Conexão resetada pelo servidor: #{e.message}" }
+      rescue EOFError => e
+        { error: "Resposta inesperada da API: #{e.message}" }
+      rescue StandardError => e
+        { error: "Erro desconhecido: #{e.message}" }
+      end
+    end
+
+    # Busca por número de processo (atalho)
+    def self.buscar_processo(numero_processo, tribunal)
+      filtros = { match: { numeroProcesso: numero_processo } }
+      buscar(tribunal, filtros)
+    end
+  end
+end
+
+# Alias para compatibilidade com código legado
+module DataJud
+  ApiClient = Datajud::ApiClient
+end

data/lib/datajud/client.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Datajud
+  class Client
+    # Retorna uma instância de Datajud::Processo ou nil
+    def self.find(numero, tribunal = nil, **kwargs)
+      tribunal = kwargs[:tribunal] if tribunal.nil? && kwargs.key?(:tribunal)
+      raw = Datajud.processo(numero, tribunal: tribunal)
+      return nil unless raw && raw[:processo] || raw && raw['processo']
+
+      Datajud::Processo.new(raw)
+    end
+  end
+end

data/lib/datajud/configuration.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Datajud
+  # Configurações da gem.
+  class Configuration
+  attr_accessor :base_endpoint, :tribunais, :api_key, :open_timeout, :read_timeout,
+          :retries, :retry_wait, :fallback_all_on_miss, :lookup_ibge, :ibge_base_url
+
+    def initialize
+      @base_endpoint = "https://api-publica.datajud.cnj.jus.br"
+      @tribunais = []
+      @api_key = nil
+      @open_timeout = 5
+      @read_timeout = 15
+      @retries = 1
+      @retry_wait = 0.3
+      @fallback_all_on_miss = true
+      @lookup_ibge = true
+      @ibge_base_url = "https://servicodados.ibge.gov.br/api/v1/localidades/municipios"
+    end
+  end
+end

data/lib/datajud/process.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+
+module Datajud
+  # Representa um processo retornado pela API DataJud.
+  # Fornece acesso simples a campos comuns via métodos.
+  class Processo
+    attr_reader :tribunal, :data
+
+    def initialize(raw)
+      # raw expected: { tribunal: 'TJSP', processo: { ... } } or string-keyed
+      @tribunal = raw[:tribunal] || raw['tribunal']
+      @data = raw[:processo] || raw['processo'] || {}
+    end
+
+    def numero
+      @data['numero'] || @data[:numero]
+    end
+
+    def classe
+      @data['classe'] || @data[:classe]
+    end
+
+    def vara
+      v = @data['vara'] || @data[:vara]
+      return nil unless v
+
+      OpenStruct.new(
+        nome: v['nome'] || v[:nome],
+        codigo: v['codigo'] || v[:codigo],
+        comarca: v['comarca'] || v[:comarca]
+      )
+    end
+
+    def situacao
+      @data['situacao'] || @data[:situacao]
+    end
+
+    def origem
+      @data['origem'] || @data[:origem]
+    end
+
+    def instancia
+      @data['instancia'] || @data[:instancia]
+    end
+
+    def assunto
+      @data['assunto'] || @data[:assunto]
+    end
+
+    def partes
+      partes = @data['partes'] || @data[:partes] || []
+      partes.map do |p|
+        OpenStruct.new(
+          nome: p['nome'] || p[:nome],
+          tipo: p['tipo'] || p['tipoParte'] || p[:tipo],
+          documento: p['documento'] || p[:documento]
+        )
+      end
+    end
+
+    def andamentos
+      mov = @data['andamentos'] || @data[:andamentos] || @data['movimentacoes'] || @data[:movimentacoes]
+      (mov || []).map do |m|
+        OpenStruct.new(
+          descricao: m['descricao'] || m[:descricao],
+          data: m['data'] || m['dataHora'] || m[:data],
+          tipo: m['tipo'] || m['codigoTipoMovimento'] || m[:tipo]
+        )
+      end
+    end
+
+    def documentos
+      docs = @data['documentos'] || @data[:documentos] || []
+      docs.map do |d|
+        OpenStruct.new(
+          titulo: d['titulo'] || d['nomeDocumento'] || d[:titulo],
+          tipo: d['tipo'] || d['tipoDocumento'] || d[:tipo],
+          data: d['data'] || d['dataJuntada'] || d[:data],
+          assinatura_digital: d['assinatura_digital'] || d['assinaturaDigital'] || d[:assinatura_digital]
+        )
+      end
+    end
+
+    def audiencias
+      auds = @data['audiencias'] || @data[:audiencias] || []
+      auds.map do |a|
+        OpenStruct.new(
+          data_hora: a['data_hora'] || a['dataHora'] || a[:data_hora],
+          tipo: a['tipo'] || a[:tipo],
+          status: a['status'] || a['statusAudiencia'] || a[:status],
+          observacao: a['observacao'] || a[:observacao]
+        )
+      end
+    end
+
+    alias movimentacoes andamentos
+
+    def to_h
+      { tribunal: tribunal, processo: data }
+    end
+  end
+end

data/lib/datajud/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Datajud
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 end

data/lib/datajud.rb

@@ -1,10 +1,29 @@
 # frozen_string_literal: true
 
+require 'socket'
 require_relative "datajud/version"
 require_relative "datajud/key_fetcher"
+require_relative "datajud/configuration"
+require_relative "datajud/api_client"
+require_relative "datajud/client"
+require_relative "datajud/process"
 require 'net/http'
 require 'json'
 
+unless Socket.method(:tcp).parameters.any? { |param| param[1] == :open_timeout }
+  class << Socket
+    alias_method :tcp_without_open_timeout, :tcp
+
+    def tcp(host, port, local_host = nil, local_port = nil, **kwargs)
+      if kwargs.key?(:open_timeout) && !kwargs.key?(:connect_timeout)
+        kwargs[:connect_timeout] = kwargs.delete(:open_timeout)
+      end
+
+      tcp_without_open_timeout(host, port, local_host, local_port, **kwargs)
+    end
+  end
+end
+
 module Datajud
   BASE_ENDPT = "https://api-publica.datajud.cnj.jus.br"
   # Tribunais de Justiça Estaduais (TJs)
@@ -16,7 +35,7 @@ module Datajud
 
   # Tribunais Regionais Federais (TRFs)
   TRFS_SIGLAS = [
-    "trf1", "trf2", "trf3", "trf4", "trf5"
+    "trf1", "trf2", "trf3", "trf4", "trf5", "trf6"
   ]
 
   # Tribunais Regionais do Trabalho (TRTs)
@@ -39,11 +58,229 @@ module Datajud
     "tse", "stf", "stj", "stm", "tst"
   ]
 
+  TJM_SIGLAS = [
+    "tjmsp", "tjmrs", "tjmmg"
+  ]
+
+  SUPERIORES_NOMES = {
+    "tst" => "Tribunal Superior do Trabalho",
+    "tse" => "Tribunal Superior Eleitoral",
+    "stj" => "Tribunal Superior de Justiça",
+    "stm" => "Tribunal Superior Militar",
+    "stf" => "Supremo Tribunal Federal"
+  }.freeze
+
+  TRIBUNAL_NOMES = SUPERIORES_NOMES.merge(
+    "trf1" => "Tribunal Regional Federal da 1ª Região",
+    "trf2" => "Tribunal Regional Federal da 2ª Região",
+    "trf3" => "Tribunal Regional Federal da 3ª Região",
+    "trf4" => "Tribunal Regional Federal da 4ª Região",
+    "trf5" => "Tribunal Regional Federal da 5ª Região",
+    "trf6" => "Tribunal Regional Federal da 6ª Região",
+    "tjac" => "Tribunal de Justiça do Acre",
+    "tjal" => "Tribunal de Justiça de Alagoas",
+    "tjam" => "Tribunal de Justiça do Amazonas",
+    "tjap" => "Tribunal de Justiça do Amapá",
+    "tjba" => "Tribunal de Justiça da Bahia",
+    "tjce" => "Tribunal de Justiça do Ceará",
+    "tjdft" => "Tribunal de Justiça do Distrito Federal e Territórios",
+    "tjdf" => "Tribunal de Justiça do Distrito Federal e Territórios",
+    "tjes" => "Tribunal de Justiça do Espírito Santo",
+    "tjgo" => "Tribunal de Justiça de Goiás",
+    "tjma" => "Tribunal de Justiça do Maranhão",
+    "tjmg" => "Tribunal de Justiça de Minas Gerais",
+    "tjms" => "Tribunal de Justiça de Mato Grosso do Sul",
+    "tjmt" => "Tribunal de Justiça do Mato Grosso",
+    "tjpa" => "Tribunal de Justiça do Pará",
+    "tjpb" => "Tribunal de Justiça da Paraíba",
+    "tjpe" => "Tribunal de Justiça de Pernambuco",
+    "tjpi" => "Tribunal de Justiça do Piauí",
+    "tjpr" => "Tribunal de Justiça do Paraná",
+    "tjrj" => "Tribunal de Justiça do Rio de Janeiro",
+    "tjrn" => "Tribunal de Justiça do Rio Grande do Norte",
+    "tjro" => "Tribunal de Justiça de Rondônia",
+    "tjrr" => "Tribunal de Justiça de Roraima",
+    "tjrs" => "Tribunal de Justiça do Rio Grande do Sul",
+    "tjsc" => "Tribunal de Justiça de Santa Catarina",
+    "tjse" => "Tribunal de Justiça de Sergipe",
+    "tjsp" => "Tribunal de Justiça de São Paulo",
+    "tjto" => "Tribunal de Justiça do Tocantins",
+    "trt1" => "Tribunal Regional do Trabalho da 1ª Região",
+    "trt2" => "Tribunal Regional do Trabalho da 2ª Região",
+    "trt3" => "Tribunal Regional do Trabalho da 3ª Região",
+    "trt4" => "Tribunal Regional do Trabalho da 4ª Região",
+    "trt5" => "Tribunal Regional do Trabalho da 5ª Região",
+    "trt6" => "Tribunal Regional do Trabalho da 6ª Região",
+    "trt7" => "Tribunal Regional do Trabalho da 7ª Região",
+    "trt8" => "Tribunal Regional do Trabalho da 8ª Região",
+    "trt9" => "Tribunal Regional do Trabalho da 9ª Região",
+    "trt10" => "Tribunal Regional do Trabalho da 10ª Região",
+    "trt11" => "Tribunal Regional do Trabalho da 11ª Região",
+    "trt12" => "Tribunal Regional do Trabalho da 12ª Região",
+    "trt13" => "Tribunal Regional do Trabalho da 13ª Região",
+    "trt14" => "Tribunal Regional do Trabalho da 14ª Região",
+    "trt15" => "Tribunal Regional do Trabalho da 15ª Região",
+    "trt16" => "Tribunal Regional do Trabalho da 16ª Região",
+    "trt17" => "Tribunal Regional do Trabalho da 17ª Região",
+    "trt18" => "Tribunal Regional do Trabalho da 18ª Região",
+    "trt19" => "Tribunal Regional do Trabalho da 19ª Região",
+    "trt20" => "Tribunal Regional do Trabalho da 20ª Região",
+    "trt21" => "Tribunal Regional do Trabalho da 21ª Região",
+    "trt22" => "Tribunal Regional do Trabalho da 22ª Região",
+    "trt23" => "Tribunal Regional do Trabalho da 23ª Região",
+    "trt24" => "Tribunal Regional do Trabalho da 24ª Região",
+    "treac" => "Tribunal Regional Eleitoral do Acre",
+    "treal" => "Tribunal Regional Eleitoral de Alagoas",
+    "tream" => "Tribunal Regional Eleitoral do Amazonas",
+    "treap" => "Tribunal Regional Eleitoral do Amapá",
+    "treba" => "Tribunal Regional Eleitoral da Bahia",
+    "trece" => "Tribunal Regional Eleitoral do Ceará",
+    "tredf" => "Tribunal Regional Eleitoral do Distrito Federal",
+    "trees" => "Tribunal Regional Eleitoral do Espírito Santo",
+    "trego" => "Tribunal Regional Eleitoral de Goiás",
+    "trema" => "Tribunal Regional Eleitoral do Maranhão",
+    "tremg" => "Tribunal Regional Eleitoral de Minas Gerais",
+    "trems" => "Tribunal Regional Eleitoral do Mato Grosso do Sul",
+    "tremt" => "Tribunal Regional Eleitoral do Mato Grosso",
+    "trepa" => "Tribunal Regional Eleitoral do Pará",
+    "trepb" => "Tribunal Regional Eleitoral da Paraíba",
+    "trepe" => "Tribunal Regional Eleitoral de Pernambuco",
+    "trepi" => "Tribunal Regional Eleitoral do Piauí",
+    "trepr" => "Tribunal Regional Eleitoral do Paraná",
+    "trerj" => "Tribunal Regional Eleitoral do Rio de Janeiro",
+    "trern" => "Tribunal Regional Eleitoral do Rio Grande do Norte",
+    "trero" => "Tribunal Regional Eleitoral de Rondônia",
+    "trerr" => "Tribunal Regional Eleitoral de Roraima",
+    "trers" => "Tribunal Regional Eleitoral do Rio Grande do Sul",
+    "tresc" => "Tribunal Regional Eleitoral de Santa Catarina",
+    "trese" => "Tribunal Regional Eleitoral de Sergipe",
+    "tresp" => "Tribunal Regional Eleitoral de São Paulo",
+    "tretoc" => "Tribunal Regional Eleitoral do Tocantins",
+    "tjmsp" => "Tribunal de Justiça Militar de São Paulo",
+    "tjmrs" => "Tribunal de Justiça Militar do Rio Grande do Sul",
+    "tjmmg" => "Tribunal de Justiça Militar de Minas Gerais"
+  ).freeze
+
   # Para consultar em todos, você pode unificar todas as listas:
-  TRIBUNAIS_SIGLAS = TJS_SIGLAS + TRFS_SIGLAS + TRTS_SIGLAS + TRES_SIGLAS + SUPERIORES_SIGLAS
+  TRIBUNAIS_SIGLAS = TJS_SIGLAS + TRFS_SIGLAS + TRTS_SIGLAS + TRES_SIGLAS + SUPERIORES_SIGLAS + TJM_SIGLAS
+
+  TJ_BY_CODE = {
+    "01" => "tjac",
+    "02" => "tjal",
+    "03" => "tjap",
+    "04" => "tjam",
+    "05" => "tjba",
+    "06" => "tjce",
+    "07" => "tjdf",
+    "08" => "tjes",
+    "09" => "tjgo",
+    "10" => "tjma",
+    "11" => "tjmt",
+    "12" => "tjms",
+    "13" => "tjmg",
+    "14" => "tjpa",
+    "15" => "tjpb",
+    "16" => "tjpr",
+    "17" => "tjpe",
+    "18" => "tjpi",
+    "19" => "tjrj",
+    "20" => "tjrn",
+    "21" => "tjrs",
+    "22" => "tjro",
+    "23" => "tjrr",
+    "24" => "tjsc",
+    "25" => "tjse",
+    "26" => "tjsp",
+    "27" => "to"
+  }.freeze
+
+  UF_BY_CODE = {
+    "01" => "ac",
+    "02" => "al",
+    "03" => "ap",
+    "04" => "am",
+    "05" => "ba",
+    "06" => "ce",
+    "07" => "df",
+    "08" => "es",
+    "09" => "go",
+    "10" => "ma",
+    "11" => "mt",
+    "12" => "ms",
+    "13" => "mg",
+    "14" => "pa",
+    "15" => "pb",
+    "16" => "pr",
+    "17" => "pe",
+    "18" => "pi",
+    "19" => "rj",
+    "20" => "rn",
+    "21" => "rs",
+    "22" => "ro",
+    "23" => "rr",
+    "24" => "sc",
+    "25" => "se",
+    "26" => "sp",
+    "27" => "to"
+  }.freeze
+
+  IBGE_UF_SIGLAS = {
+    "11" => "RO",
+    "12" => "AC",
+    "13" => "AM",
+    "14" => "RR",
+    "15" => "PA",
+    "16" => "AP",
+    "17" => "TO",
+    "21" => "MA",
+    "22" => "PI",
+    "23" => "CE",
+    "24" => "RN",
+    "25" => "PB",
+    "26" => "PE",
+    "27" => "AL",
+    "28" => "SE",
+    "29" => "BA",
+    "31" => "MG",
+    "32" => "ES",
+    "33" => "RJ",
+    "35" => "SP",
+    "41" => "PR",
+    "42" => "SC",
+    "43" => "RS",
+    "50" => "MS",
+    "51" => "MT",
+    "52" => "GO",
+    "53" => "DF"
+  }.freeze
+
+  ESFERA_BY_PREFIX = {
+    "TRF" => "Federal",
+    "TJ" => "Estadual",
+    "TRT" => "Trabalhista",
+    "TRE" => "Eleitoral",
+    "STF" => "Superior",
+    "STJ" => "Superior",
+    "TST" => "Superior",
+    "STM" => "Superior",
+    "TSE" => "Superior"
+  }.freeze
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
 
   # Pega a API Key sempre atual (consulta ao site DataJud)
   def self.api_key
+    return configuration.api_key if configuration.api_key
+
+    env_key = ENV["DATAJUD_API_KEY"]
+    return env_key if env_key && !env_key.strip.empty?
+
     @api_key ||= KeyFetcher.fetch_api_key
   end
 
@@ -52,94 +289,227 @@ module Datajud
     @api_key = nil
   end
 
-  def self.processo(numero, tribunal: nil)
-    siglas_consulta = tribunal ? Array(tribunal).flatten.map { |t| t.to_s.downcase } : TRIBUNAIS_SIGLAS
+  def self.siglas_por_cnj(cnj)
+    digits = cnj.to_s.gsub(/\D/, "")
+    return nil unless digits.length == 20
+
+    j = digits[13]
+    tr = digits[14, 2]
+
+    case j
+    when "1"
+      tr_num = tr.to_i
+      return ["trf#{tr_num}"] if tr_num.between?(1, 5)
+    when "2"
+      sigla = TJ_BY_CODE[tr]
+      return [sigla] if sigla
+    when "3"
+      tr_num = tr.to_i
+      return ["trt#{tr_num}"] if tr_num.between?(1, 24)
+    when "4"
+      uf = UF_BY_CODE[tr]
+      return ["tre#{uf}"] if uf
+    when "5"
+      return ["stm"]
+    end
+
+    nil
+  end
+
+  # Retém compatibilidade com a implementação existente.
+  # A implementação mais rica (retornando objetos) está em Datajud::Client
+
+  # Retorna um objeto Datajud::Processo ou nil
+  def self.find(numero, tribunal = nil, **kwargs)
+    tribunal = kwargs[:tribunal] if tribunal.nil? && kwargs.key?(:tribunal)
+    Datajud::Client.find(numero, tribunal: tribunal)
+  end
+
+  # Mantém método antigo para compatibilidade (retorna hash com dados brutos)
+  def self.processo(numero, tribunal = nil, **kwargs)
+    tribunal = kwargs[:tribunal] if tribunal.nil? && kwargs.key?(:tribunal)
+    # A lógica original permanecida aqui para backward-compat
+    siglas_consulta = if tribunal
+                        Array(tribunal).flatten.map { |t| t.to_s.downcase }
+                      elsif (siglas_cnj = siglas_por_cnj(numero))
+                        if configuration.fallback_all_on_miss
+                          siglas_cnj + (TRIBUNAIS_SIGLAS - siglas_cnj)
+                        else
+                          siglas_cnj
+                        end
+                      elsif configuration.tribunais.any?
+                        configuration.tribunais.map { |t| t.to_s.downcase }
+                      else
+                        TRIBUNAIS_SIGLAS
+                      end
     resultado = nil
 
     siglas_consulta.each do |sigla|
-      endpoint = "#{BASE_ENDPT}/api_publica_#{sigla}/_search"
-      payload = {
-        "query": {
-          "bool": {
-            "must": [
-              { "match": { "numeroProcesso": numero } }
-            ]
-          }
+      resposta = ApiClient.buscar_processo(numero, sigla)
+      next if resposta.is_a?(Hash) && resposta[:error]
+
+      hits = resposta.is_a?(Hash) ? resposta.dig('hits', 'hits') : nil
+      next if hits.nil? || hits.empty?
+
+      proc = hits[0]['_source']
+
+      resultado = {
+        tribunal: tribunal_from(sigla, proc),
+        processo: {
+          numero: proc['numeroProcesso'],
+      vara: proc['orgaoJulgador'] ? {
+        nome: proc['orgaoJulgador']['nome'],
+        codigo: proc['orgaoJulgador']['codigo'],
+        comarca: comarca_from(proc['orgaoJulgador'], sigla)
+      } : nil,
+          situacao: proc['situacao'],
+          origem: proc['origem'],
+          instancia: proc['grau'],
+          classe: proc['classeProcessual'] || proc['classe'],
+          assunto: proc['assuntos'],
+          partes: partes_from(proc),
+          andamentos: (proc['movimentacoes'] || proc['movimentos'])&.map do |mv|
+            {
+              descricao: mv['descricao'] || mv['nome'] || mv.dig('tipoMovimento', 'nome') || mv.dig('tipo', 'nome'),
+              data: mv['dataHora'] || mv['data'],
+              tipo: mv['codigoTipoMovimento'] || mv['codigo'] || mv.dig('tipoMovimento', 'codigo') || mv.dig('tipo', 'codigo')
+            }
+          end,
+          documentos: proc['documentos']&.map do |doc|
+            {
+              titulo: doc['nomeDocumento'],
+              tipo: doc['tipoDocumento'],
+              data: doc['dataJuntada'],
+              assinatura_digital: doc['assinaturaDigital']
+            }
+          end,
+          audiencias: proc['audiencias']&.map do |aud|
+            {
+              data_hora: aud['dataHora'],
+              tipo: aud['tipo'],
+              status: aud['statusAudiencia'],
+              observacao: aud['observacao']
+            }
+          end
         }
       }
+      break
+    end
+    resultado
+  end
 
-      uri = URI(endpoint)
-      req = Net::HTTP::Post.new(uri, 'Content-Type' => 'application/json')
-      req.body = payload.to_json
-      req['Authorization'] = "APIKey #{api_key}"
+  def self.partes_from(proc)
+    partes = proc['partes'] || proc['partesProcessuais']
+    partes = Array(partes) if partes
 
-      http = Net::HTTP.new(uri.hostname, uri.port)
-      http.use_ssl = true
-      resp = http.request(req)
+    if partes.nil? || partes.empty?
+      ativos = Array(proc['poloAtivo'] || proc['parteAtiva'] || proc['partesAtivas'])
+      passivos = Array(proc['poloPassivo'] || proc['partePassiva'] || proc['partesPassivas'])
+      partes = ativos.map { |p| p.merge('polo' => 'ATIVO') } + passivos.map { |p| p.merge('polo' => 'PASSIVO') }
+    end
 
-      # Se falhar por chave expirada:
-      if [401, 403].include?(resp.code.to_i)
-        reset_api_key
-        req['Authorization'] = "APIKey #{api_key}"
-        resp = http.request(req)
-      end
+    return nil if partes.nil? || partes.empty?
 
-      next unless resp.code.to_i == 200
-
-      processos = JSON.parse(resp.body)
-      if processos['hits'] && !processos['hits']['hits'].empty?
-        proc = processos['hits']['hits'][0]['_source']
-
-        resultado = {
-          tribunal: sigla.upcase,
-          processo: {
-            numero: proc['numeroProcesso'],
-            vara: proc['orgaoJulgador'] ? {
-                nome: proc['orgaoJulgador']['nome'],
-                codigo: proc['orgaoJulgador']['codigo'],
-                comarca: proc['orgaoJulgador']['comarca'],
-                tribunal: sigla.upcase
-            } : nil,
-            situacao: proc['situacao'],
-            origem: proc['origem'],
-            instancia: proc['grau'],
-            classe: proc['classeProcessual'],
-            assunto: proc['assuntos'],
-            partes: proc['partes']&.map do |p|
-              {
-                nome: p['nome'],
-                tipo: p['tipoParte'],
-                documento: p['documento']
-              }
-            end,
-            andamentos: proc['movimentacoes']&.map do |mv|
-              {
-                descricao: mv['descricao'],
-                data: mv['dataHora'],
-                tipo: mv['codigoTipoMovimento']
-              }
-            end,
-            documentos: proc['documentos']&.map do |doc|
-              {
-                titulo: doc['nomeDocumento'],
-                tipo: doc['tipoDocumento'],
-                data: doc['dataJuntada'],
-                assinatura_digital: doc['assinaturaDigital']
-              }
-            end,
-            audiencias: proc['audiencias']&.map do |aud|
-              {
-                data_hora: aud['dataHora'],
-                tipo: aud['tipo'],
-                status: aud['statusAudiencia'],
-                observacao: aud['observacao']
-              }
-            end
-          }
-        }
-        break
+    partes.map do |p|
+      {
+        nome: p['nome'] || p['nomeParte'] || p['parteNome'],
+        tipo: p['tipoParte'] || p['tipo'] || p['polo'] || p['qualificacao'],
+        documento: p['documento'] || p['cpfCnpj'] || p['numeroDocumento']
+      }
+    end
+  end
+
+  def self.tribunal_from(sigla, proc)
+    sigla_up = sigla.to_s.upcase
+    nome = TRIBUNAL_NOMES[sigla.to_s.downcase] || proc['tribunal'] || sigla_up
+    esfera = esfera_from_sigla(sigla_up)
+
+    { nome: nome, sigla: sigla_up, esfera: esfera }
+  end
+
+  def self.esfera_from_sigla(sigla)
+    key = ESFERA_BY_PREFIX.keys.find { |prefix| sigla.start_with?(prefix) }
+    ESFERA_BY_PREFIX[key] || "Desconhecida"
+  end
+
+  def self.endpoints_table(tribunais = SUPERIORES_NOMES.keys)
+    rows = tribunais.map do |sigla|
+      nome = TRIBUNAL_NOMES[sigla] || sigla.to_s.upcase
+      endpoint_sigla = endpoint_alias(sigla)
+      url = "#{configuration.base_endpoint}/api_publica_#{endpoint_sigla}/_search"
+      "<tr><td>#{nome}</td><td><a href=\"#{url}\" target=\"_blank\" rel=\"noopener noreferrer\">#{url}</a></td></tr>"
+    end
+
+    "<table><tr><th>Tribunal</th><th>Url</th></tr>#{rows.join}</table>"
+  end
+
+  def self.endpoint_alias(sigla)
+    sigla = sigla.to_s.downcase
+    return sigla.gsub(/^tre/, 'tre-') if sigla.start_with?('tre') && !sigla.include?('-')
+
+    sigla
+  end
+
+  def self.request_with_retry(http, req)
+    attempts = 0
+    begin
+      attempts += 1
+      http.request(req)
+    rescue Net::OpenTimeout, Net::ReadTimeout, Errno::ECONNRESET, Errno::ETIMEDOUT
+      raise if attempts > configuration.retries
+
+      sleep(configuration.retry_wait) if configuration.retry_wait && configuration.retry_wait.positive?
+      retry
+    end
+  end
+
+  def self.comarca_from(orgao_julgador, sigla)
+    return nil unless orgao_julgador
+
+    comarca = orgao_julgador['comarca']
+
+    if comarca.is_a?(Hash)
+      nome = comarca['nome'] || comarca['descricao'] || comarca['nomeComarca']
+      uf = comarca['uf'] || comarca['siglaUf'] || comarca['estado']
+      return { nome: nome, uf: uf, tribunal: sigla.upcase }
+    end
+
+    nome = comarca || orgao_julgador['nome']
+    uf = nil
+    if orgao_julgador['codigoMunicipioIBGE']
+      uf = uf_from_ibge_code(orgao_julgador['codigoMunicipioIBGE'])
+      if uf.nil? && configuration.lookup_ibge
+        uf = ibge_uf_from(orgao_julgador['codigoMunicipioIBGE'])
       end
     end
-    resultado
+
+    return nil unless nome
+
+    { nome: nome, uf: uf, tribunal: sigla.upcase }
+  end
+
+  def self.ibge_uf_from(codigo_municipio)
+    @ibge_uf_cache ||= {}
+    codigo = codigo_municipio.to_s.strip
+    return @ibge_uf_cache[codigo] if @ibge_uf_cache.key?(codigo)
+
+    begin
+      uri = URI("#{configuration.ibge_base_url}/#{codigo}")
+      response = Net::HTTP.get(uri)
+      data = JSON.parse(response)
+      uf = data.dig('microrregiao', 'mesorregiao', 'UF', 'sigla') || data.dig('regiao-imediata', 'regiao-intermediaria', 'UF', 'sigla')
+      @ibge_uf_cache[codigo] = uf
+    rescue StandardError
+      @ibge_uf_cache[codigo] = nil
+    end
+
+    @ibge_uf_cache[codigo]
+  end
+
+  def self.uf_from_ibge_code(codigo_municipio)
+    codigo = codigo_municipio.to_s.strip
+    return nil if codigo.length < 2
+
+    IBGE_UF_SIGLAS[codigo[0, 2]]
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datajud
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - PablUoo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-11-25 00:00:00.000000000 Z
+date: 2026-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -72,8 +72,13 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- examples/find.rb
 - lib/datajud.rb
+- lib/datajud/api_client.rb
+- lib/datajud/client.rb
+- lib/datajud/configuration.rb
 - lib/datajud/key_fetcher.rb
+- lib/datajud/process.rb
 - lib/datajud/version.rb
 - sig/datajud.rbs
 homepage: https://github.com/PablUoo/datajud