datajud 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 10c59cd9f52f93532e97686b95b2ce3a5f482c6cd42c7b110a860c21e60c268b
-  data.tar.gz: 7886282868f709f225b981e62932985630387d120020d0b0ebe962c6251fc695
+  metadata.gz: 5df3f8cadbf3eb0e40ba6891207bc56a076e5624e171cd99e1fef1ee66cf1696
+  data.tar.gz: bfc125d69fb6a639afbc0891db64d301209cf7901e14a8fee82477623e521153
 SHA512:
-  metadata.gz: 80e24e11e26c39faff385fa928f7f8b6125ed307bd40b5826527c75a09e30f51e7265213bcbe7c1ef30c2c15e86a2d0367f580d132f7e4587bd703ef1f4fc0fa
-  data.tar.gz: 29fb5433cf555e0df1df5f1a3f79f52a50c53a946ea5de7ce2c0a36107c99613fb304d0a0bf99a665bc587857d4cc4e7dc1c5c03389e39d59c6f551a08b181e6
+  metadata.gz: 6ad607e3b195cc8055bcad7b5e77854694a91297f86af88391ccd4c13cdeac5a49394315a9a0120dde19f49507526c41849ffe7ad3fc6ed2019ad921d74ad8dd
+  data.tar.gz: f9b89ba96631fa69025ae5d6b52a5cc142c4026aaccb5f1397b3459a502a5189eb9e9cc48bcdd1046b7f78cdc461697b8f6e915728e73105d51907f995afcdae

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 ## [Unreleased]
 
+## [0.1.4] - 2026-03-12
+
+- Todos os atributos e subatributos do processo agora podem ser acessados por ponto (OpenStruct), sem classes manuais.
+
+## [0.1.3] - 2026-03-12
+
+- Exposed object-oriented accessors for nested attributes (ex.: `processo.vara.nome`).
+- Standardized on `andamentos` and removed the `movimentacoes` alias.
+
+## [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.2)
+    datajud (0.1.3)
       json (~> 2.0)
       net-http (~> 0.3)
       nokogiri (~> 1.14)

data/README.md

@@ -19,19 +19,35 @@ If bundler is not being used to manage dependencies, install the gem by executin
 ```ruby
 require 'datajud'
 
+# Busca processo (tribunal pode ser explícito ou inferido)
 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" }
+# Acessa atributos principais
+puts processo.tribunal # Tribunal como objeto ou string
+puts processo.numero
+puts processo.vara
+puts processo.situacao
+puts processo.andamentos
+puts processo.documentos
+puts processo.audiencias
+puts processo.sistema
+puts processo.formato
+puts processo.data_ultima_atualizacao
+puts processo.data_ajuizamento
+puts processo.nivel_sigilo
+puts processo.id
+puts processo.timestamp
+
+# Tribunal como objeto (se disponível)
+puts processo.tribunal.nome if processo.tribunal.respond_to?(:nome)
+puts processo.tribunal.sigla if processo.tribunal.respond_to?(:sigla)
+puts processo.tribunal.esfera if processo.tribunal.respond_to?(:esfera)
+
+# Exemplos de acesso orientado a objeto
+puts processo.vara.nome if processo.vara.respond_to?(:nome)
+puts processo.vara.comarca.nome if processo.vara&.comarca&.respond_to?(:nome)
+puts processo.assunto.map(&:nome) if processo.assunto
 
 # Tabela HTML de endpoints (todos os tribunais conhecidos)
 Datajud.endpoints_table(Datajud::TRIBUNAIS_SIGLAS)
@@ -42,6 +58,8 @@ Datajud.endpoints_table(Datajud::TRIBUNAIS_SIGLAS)
 ```ruby
 # API orientada a objeto
 processo = Datajud.find("00008323520184013202", tribunal: "trf1")
+# ou
+processo = Datajud.find("00008323520184013202", "trf1")
 
 # Retorno bruto (hash)
 resultado = Datajud.processo("00008323520184013202", tribunal: "trf1")
@@ -73,7 +91,7 @@ para evitar varrer todas as bases.
 
 ```ruby
 processo = Datajud.find("0000832-35.2018.8.26.0202")
-puts processo.tribunal
+puts processo.tribunal.nome
 ```
 
 > A UF da comarca é derivada localmente pelo código IBGE do município quando disponível.

data/examples/find.rb

@@ -11,11 +11,11 @@ begin
   processo = Datajud.find("0000832-35.2018.8.26.0202")
 
   if processo
-    puts "Tribunal: #{processo.tribunal}"
+    puts "Tribunal: #{processo.tribunal.nome}"
     puts "Número: #{processo.numero}"
-    puts "Classe: #{processo.classe}"
+    puts "Classe: #{processo.classe.nome}"
     puts "Partes: #{processo.partes.map(&:nome).join(', ')}"
-    puts "Movimentações: #{processo.movimentacoes.size}"
+    puts "Andamentos: #{processo.andamentos.size}"
   else
     puts "Processo não encontrado."
   end

data/lib/datajud/api_client.rb

@@ -10,20 +10,19 @@ module Datajud
     # 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}")
-
+      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
+      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['Authorization'] = "APIKey #{Datajud.api_key}"
       request['Content-Type'] = 'application/json'
       request.body = { query: filtros }.to_json
 
       begin
-  response = Datajud.request_with_retry(http, request)
+        response = Datajud.request_with_retry(http, request)
         if response.is_a?(Net::HTTPSuccess)
           JSON.parse(response.body)
         else

data/lib/datajud/client.rb

@@ -3,7 +3,8 @@
 module Datajud
   class Client
     # Retorna uma instância de Datajud::Processo ou nil
-    def self.find(numero, tribunal: 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']
 

data/lib/datajud/process.rb

@@ -6,46 +6,63 @@ 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 self.deep_struct(obj)
+                  case obj
+                  when Hash
+                    OpenStruct.new(obj.transform_values { |v| deep_struct(v) })
+                  when Array
+                    obj.map { |v| deep_struct(v) }
+                  else
+                    obj
+                  end
+                end
+            def municipio_ibge
+              orgao = instance_variable_get(:@orgao_julgador) || instance_variable_get(:@orgao_julgador) || self.respond_to?(:orgao_julgador) ? self.orgao_julgador : nil
+              return nil unless orgao && orgao.is_a?(Hash)
+              orgao['codigoMunicipioIBGE'] || orgao[:codigoMunicipioIBGE]
+            end
+        def comarca_ibge_codigo
+          v = instance_variable_get(:@vara)
+          return nil unless v && v.is_a?(Hash)
+          comarca = v['comarca'] || v[:comarca]
+          return nil unless comarca && comarca.is_a?(Hash)
+          comarca['codigoIbge'] || comarca[:codigoIbge] || comarca['ibge'] || comarca[:ibge]
+        end
+    attr_reader :tribunal
 
     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 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]
-        )
+      processo_hash = raw[:processo] || raw['processo'] || raw
+      @tribunal = self.class.deep_struct(raw[:tribunal] || raw['tribunal'])
+      processo_hash.each do |k, v|
+        ivar = "@#{k.to_s.gsub(/([A-Z])/, '_\\1').downcase}"
+        instance_variable_set(ivar, self.class.deep_struct(v))
+        self.class.send(:attr_reader, k.to_s.gsub(/([A-Z])/, '_\\1').downcase)
       end
-    end
-
-    def movimentacoes
-      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]
-        )
+      if processo_hash['orgaoJulgador'] || processo_hash[:orgaoJulgador]
+        orgao = processo_hash['orgaoJulgador'] || processo_hash[:orgaoJulgador]
+        instance_variable_set(:@orgao_julgador, self.class.deep_struct(orgao))
+        self.class.send(:attr_reader, :orgao_julgador)
+        if orgao['codigoMunicipioIBGE'] || orgao[:codigoMunicipioIBGE]
+          vara = instance_variable_get(:@vara)
+          if vara && vara.respond_to?(:comarca)
+            comarca = vara.comarca
+            if comarca && comarca.is_a?(OpenStruct)
+              ibge = orgao['codigoMunicipioIBGE'] || orgao[:codigoMunicipioIBGE]
+              comarca.codigoIbge = ibge if comarca.respond_to?(:codigoIbge=)
+            end
+          end
+        end
       end
+
     end
 
-    def to_h
-      { tribunal: tribunal, processo: data }
+    def codigo_municipio_ibge
+      if respond_to?(:orgao_julgador) && orgao_julgador.is_a?(Hash)
+        orgao_julgador['codigoMunicipioIBGE'] || orgao_julgador[:codigoMunicipioIBGE]
+      else
+        nil
+      end
     end
+    # Only tribunal is explicit; all other fields are dynamic.
   end
 end

data/lib/datajud/version.rb

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

data/lib/datajud.rb

@@ -320,12 +320,14 @@ module Datajud
   # A implementação mais rica (retornando objetos) está em Datajud::Client
 
   # Retorna um objeto Datajud::Processo ou nil
-  def self.find(numero, tribunal: 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)
+  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 }
@@ -355,11 +357,11 @@ module Datajud
         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,
+          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'],
@@ -388,7 +390,14 @@ module Datajud
               status: aud['statusAudiencia'],
               observacao: aud['observacao']
             }
-          end
+          end,
+          sistema: proc['sistema'],
+          formato: proc['formato'],
+          dataHoraUltimaAtualizacao: proc['dataHoraUltimaAtualizacao'],
+          dataAjuizamento: proc['dataAjuizamento'],
+          nivelSigilo: proc['nivelSigilo'],
+          id: proc['id'],
+          timestamp: proc['@timestamp']
         }
       }
       break
@@ -469,7 +478,8 @@ module Datajud
     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 }
+      hash = { nome: nome, uf: uf, tribunal: sigla.upcase }
+      return hash
     end
 
     nome = comarca || orgao_julgador['nome']
@@ -483,7 +493,11 @@ module Datajud
 
     return nil unless nome
 
-    { nome: nome, uf: uf, tribunal: sigla.upcase }
+    hash = { nome: nome, uf: uf, tribunal: sigla.upcase }
+    if orgao_julgador['codigoMunicipioIBGE']
+      hash[:codigoIbge] = orgao_julgador['codigoMunicipioIBGE']
+    end
+    hash
   end
 
   def self.ibge_uf_from(codigo_municipio)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datajud
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - PablUoo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-11 00:00:00.000000000 Z
+date: 2026-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri