ibge-ruby 1.0.2

data/lib/ibge/municipio.rb

@@ -0,0 +1,164 @@
+module IBGE
+  class Municipio
+    attr_accessor :id, :nome, :microrregiao
+
+    def initialize(options = {})
+      @id = options['id']
+      @nome = options['nome']
+      @microrregiao = Microrregiao.new(options['microrregiao'])
+    end
+
+    # Obtém o conjunto de municípios do Brasil.
+
+    # @return [Array<Municipio>]
+    #
+    # @example
+    #           municipios = IBGE::Municipio.obter_municipios
+    #           municipios.first.nome #=> "Alta Floresta D'Oeste"
+    def self.obter_municipios
+      resposta = RestClient.get("#{BASE_URL}/municipios")
+      
+      tratar_retorno(resposta)
+    end
+
+    # Obtém o conjunto de municípios do Brasil a partir dos respectivos identificadores.
+    # Pode ser informado um único ID ou um array de IDs.
+    #
+    # @param ids [String, Integer, Array] Um ou mais identificadores de municípios.
+    # @return [Municipio, Array<Municipio>]
+    #
+    # @example
+    #           municipio = IBGE::Municipio.municipios_por_id(2307254)
+    #           municipio.nome #=> "Jijoca de Jericoacoara"
+    #
+    #           municipios = IBGE::Municipio.municipios_por_id([2307254, 2302206])
+    def self.municipios_por_id(ids)
+      ids      = IBGE.formatar(ids)
+      resposta = RestClient.get("#{BASE_URL}/municipios/#{ids}")
+    
+      tratar_retorno(resposta)
+    end
+
+    # Obtém o conjunto de municípios do Brasil a partir dos identificadores das Unidades da Federação.
+    # Pode ser informada a sigla, identificador (ID) ou um array de siglas/identificadores. 
+    # 
+    # @param ufs [String, Integer, Array]
+    # @return [Array<Municipio>]
+    #
+    # @example
+    #           municipios = IBGE::Municipio.municipios_por_uf('CE')
+    #           municipios.first.nome #=> "Abaiara"
+    #
+    #           IBGE::Municipio.municipios_por_uf(['BA', 'CE'])
+    #           IBGE::Municipio.municipios_por_uf(23) 
+    def self.municipios_por_uf(ufs)
+      ufs      = IBGE.formatar(ufs)
+      resposta = RestClient.get("#{BASE_URL}/estados/#{ufs}/municipios")
+    
+      tratar_retorno(resposta)
+    end
+
+    # Obtém o conjunto de municípios do Brasil a partir dos identificadores das regiões.
+    # Pode ser informada a sigla, identificador (ID) ou um array de siglas/identificadores.
+    #
+    # @param regioes [String, Integer, Array]
+    # @return [Array<Municipio>]
+    #
+    # @example
+    #           municipios = IBGE::Municipio.municipios_por_regiao('NE')
+    #           municipios.first.nome #=> "Açailândia"
+    #
+    #           IBGE::Municipio.municipios_por_regiao(['NE', 'N'])
+    #           IBGE::Municipio.municipios_por_regiao([1, 2])
+    def self.municipios_por_regiao(regioes)
+      regioes  = IBGE.formatar(regioes)
+      resposta = RestClient.get("#{BASE_URL}/regioes/#{regioes}/municipios")
+    
+      tratar_retorno(resposta)
+    end
+
+    # Obtém o conjunto de municípios do Brasil a partir dos identificadores das regiões imediatas.
+    # Pode ser informado um único ID ou um array de IDs.
+    #
+    # @param regioes [String, Integer, Array] Um ou mais identificadores de regiões imediatas.
+    # @return [Array<Municipio>]
+    #
+    # @example
+    #           municipios = IBGE::Municipio.municipios_por_regiao_imediata(230001)
+    #           municipios.first.nome #=> "Aquiraz"
+    #
+    #           municipios = IBGE::Municipio.municipios_por_regiao_imediata([230001, 230002])
+    def self.municipios_por_regiao_imediata(regioes)
+      regioes  = IBGE.formatar(regioes)
+      resposta = RestClient.get("#{BASE_URL}/regioes-imediatas/#{regioes}/municipios")
+    
+      tratar_retorno(resposta)
+    end
+
+    # Obtém o conjunto de municípios do Brasil a partir dos identificadores das regiões intermediárias.
+    # Pode ser informado um único ID ou um array de IDs.
+    #
+    # @param regioes [String, Integer, Array] Um ou mais identificadores de regiões intermediárias.
+    # @return [Array<Municipio>]
+    #
+    # @example
+    #           municipios = IBGE::Municipio.municipios_por_regiao_intermediaria(2301)
+    #           municipios.first.nome #=> "Acarape"
+    #
+    #           municipios = IBGE::Municipio.municipios_por_regiao_intermediaria([2301, 2302])
+    def self.municipios_por_regiao_intermediaria(regioes)
+      regioes  = IBGE.formatar(regioes)
+      resposta = RestClient.get("#{BASE_URL}/regioes-intermediarias/#{regioes}/municipios")
+    
+      tratar_retorno(resposta)
+    end
+
+    # Obtém o conjunto de municípios do Brasil a partir dos identificadores das microrregiões.
+    # Pode ser informado um único ID ou um array de IDs.
+    #
+    # @param microrregioes [String, Integer, Array] Um ou mais identificadores de microrregiões.
+    # @return [Array<Municipio>]
+    #
+    # @example
+    #           municipios = IBGE::Municipio.municipios_por_microrregiao(23016)
+    #           municipios.last.nome #=> "Pacatuba"
+    #
+    #           municipios = IBGE::Municipio.municipios_por_microrregiao([23016, 23017])
+    def self.municipios_por_microrregiao(microrregioes)
+      microrregioes = IBGE.formatar(microrregioes)
+      resposta      = RestClient.get("#{BASE_URL}/microrregioes/#{microrregioes}/municipios")
+
+      tratar_retorno(resposta)
+    end
+
+    # Obtém o conjunto de municípios do Brasil a partir dos identificadores das mesorregiões.
+    # Pode ser informado um único ID ou um array de IDs.
+    #
+    # @param mesorregioes [String, Integer, Array] Um ou mais identificadores de mesorregiões.
+    # @return [Array<Municipio>]
+    #
+    # @example
+    #           municipios = IBGE::Municipio.municipios_por_mesorregiao(2303)
+    #           municipios.first.nome #=> "Aquiraz"
+    #
+    #           municipios = IBGE::Municipio.municipios_por_mesorregiao([2303, 2304])
+    def self.municipios_por_mesorregiao(mesorregioes)
+      mesorregioes = IBGE.formatar(mesorregioes)
+      resposta     = RestClient.get("#{BASE_URL}/mesorregioes/#{mesorregioes}/municipios")
+
+      tratar_retorno(resposta)
+    end
+
+    private
+
+    def self.tratar_retorno(resposta)
+      municipios = JSON.parse(resposta.body)
+
+      if municipios.is_a?(Array) 
+        municipios.map { |municipio| Municipio.new(municipio) }
+      else
+        Municipio.new(municipios)
+      end 
+    end
+  end
+end

data/lib/ibge/pais.rb

@@ -0,0 +1,53 @@
+module IBGE
+  class Pais
+    attr_accessor :id, :nome, :regiao_intermediaria, :sub_regiao
+
+    def initialize(options = {})
+      @id                   = options['id']
+      @nome                 = options['nome']
+      @regiao_intermediaria = options['regiao-intermediaria']
+      @sub_regiao           = options['sub-regiao']
+    end
+
+    # Obtém o conjunto de países.
+    # 
+    # @return [Array<Pais>]
+    #
+    # @example
+    #           paises = IBGE::Pais.obter_paises
+    #           paises.first.nome #=> "Afeganistão"
+    #           paises.first.class #=> IBGE::Pais
+    def self.obter_paises
+      resposta = RestClient.get("#{BASE_URL}/paises")
+      
+      tratar_retorno(resposta)
+    end
+
+    # Obtém o conjunto de países a partir dos respectivos identificadores.
+    # Pode ser informado o identificador (ID) ou um array de identificadores.
+    #
+    # @param paises [Integer, String, Array]
+    # @return [Array<Pais>]
+    #
+    # @example
+    #           pais = IBGE::Pais.paises_por_identificador(76)
+    #           pais.nome #=> "Brasil"
+    #
+    #           paises = IBGE::Pais.paises_por_identificador([32, 76])
+    #           paises.map(&:nome) #=> ["Argentina", "Brasil"]
+    def self.paises_por_identificador(paises)
+      paises   = IBGE.formatar(paises)
+      resposta = RestClient.get("#{BASE_URL}/paises/#{paises}")
+      
+      tratar_retorno(resposta)
+    end
+
+    private
+
+    def self.tratar_retorno(resposta)
+      paises = JSON.parse(resposta.body)
+
+      paises.map { |pais| Pais.new(pais) }
+    end
+  end
+end

data/lib/ibge/regiao.rb

@@ -0,0 +1,55 @@
+module IBGE
+  class Regiao
+    attr_accessor :id, :nome, :sigla
+
+    def initialize(options = {})
+      @id    = options['id']
+      @nome  = options['nome']
+      @sigla = options['sigla']
+    end
+
+    # Obtém o conjunto de regiões do Brasil.
+    #
+    # @return [<Array[Regiao]>]
+    #
+    # @example
+    #           regioes = IBGE::Regiao.obter_regioes
+    #           regioes.map(&:sigla) #=> ["N", "NE", "SE", "S", "CO"]
+    def self.obter_regioes
+      resposta = RestClient.get("#{BASE_URL}/regioes")
+
+      tratar_retorno(resposta)
+    end
+
+    # Obtém o conjunto de regiões do Brasil a partir dos respectivos identificadores.
+    # Pode ser informada a sigla, identificador (ID) ou um array de siglas/identificadores.
+    #
+    # @param regioes [String, Integer, Array]
+    # @return [Regiao, <Array[Regiao]>]
+    #
+    # @example
+    #           regiao = IBGE::Regiao.regioes_por_identificador('NE')
+    #           regiao.nome #=> "Nordeste"
+    #
+    #           regioes = IBGE::Regiao.regioes_por_identificador([1, 2])
+    #           regioes.map(&:sigla) #=> ["N", "NE"]
+    def self.regioes_por_identificador(regioes)
+      regioes  = IBGE.formatar(regioes)
+      resposta = RestClient.get("#{BASE_URL}/regioes/#{regioes}")
+
+      tratar_retorno(resposta)
+    end
+    
+    private
+
+    def self.tratar_retorno(resposta)
+      regioes = JSON.parse(resposta.body)
+
+      if regioes.is_a?(Array) 
+        regioes.map { |regiao| Regiao.new(regiao) }
+      else
+        Regiao.new(regioes)
+      end 
+    end
+  end
+end

data/lib/ibge/regiao_imediata.rb

@@ -0,0 +1,110 @@
+module IBGE
+  class RegiaoImediata
+    attr_accessor :id, :nome, :regiao_intermediaria
+
+    def initialize(options = {})
+      @id                   = options['id']
+      @nome                 = options['nome']
+      @regiao_intermediaria = RegiaoIntermediaria.new(options['regiao-intermediaria'])
+    end
+
+    # Obtém o conjunto de regiões imediatas do Brasil.
+    #
+    # @return [Array<RegiaoImediata>]
+    #
+    # @example
+    #           regioes = IBGE::RegiaoImediata.obter_regioes_imediatas
+    #           regioes.first.nome #=> "Porto Velho" 
+    def self.obter_regioes_imediatas
+      resposta = RestClient.get("#{BASE_URL}/regioes-imediatas")
+      
+      tratar_retorno(resposta)
+    end
+
+    # Obtém o conjunto de regiões imediatas do Brasil a partir dos respectivos identificadores.
+    # Pode ser informado um único ID ou um array de IDs.
+    #
+    # @param ids [String, Integer, Array] Um ou mais identificadores de regiões imediatas.
+    # @return [RegiaoImediata, Array<RegiaoImediata>]
+    #
+    # @example
+    #           regiao = IBGE::RegiaoImediata.regioes_imediatas_por_id(230001)
+    #           regiao.nome #=> "Fortaleza"
+    #
+    #           regioes = IBGE::RegiaoImediata.regioes_imediatas_por_id([230001, 230002])
+    def self.regioes_imediatas_por_id(ids)
+      ids      = IBGE.formatar(ids)
+      resposta = RestClient.get("#{BASE_URL}/regioes-imediatas/#{ids}")
+
+      tratar_retorno(resposta)
+    end
+
+    # Obtém o conjunto de regiões imediatas do Brasil a partir dos identificadores das Unidades da Federação.
+    # Pode ser informada a sigla, identificador (ID) ou um array de siglas/identificadores. 
+    # 
+    # @param ufs [String, Integer, Array]
+    # @return [Array<RegiaoImediata>]
+    #
+    # @example
+    #           regioes = IBGE::RegiaoImediata.regioes_imediatas_por_uf('CE')
+    #           regioes.first.nome #=> "Fortaleza"
+    #
+    #           IBGE::RegiaoImediata.regioes_imediatas_por_uf(['BA', 'CE'])
+    #           IBGE::RegiaoImediata.regioes_imediatas_por_uf(23)
+    def self.regioes_imediatas_por_uf(ufs)
+      ufs      = IBGE.formatar(ufs)
+      resposta = RestClient.get("#{BASE_URL}/estados/#{ufs}/regioes-imediatas")
+
+      tratar_retorno(resposta)
+    end
+
+    # Obtém o conjunto de regiões imediatas do Brasil a partir dos identificadores das regiões.
+    # Pode ser informada a sigla, identificador (ID) ou um array de siglas/identificadores.
+    #
+    # @param regioes [String, Integer, Array] Um ou mais identificadores de regiões.
+    # @return [Array<RegiaoImediata>]
+    #
+    # @example
+    #           regioes = IBGE::RegiaoImediata.regioes_imediatas_por_regiao('NE')
+    #           regioes.first.nome #=> "São Luís"
+    #
+    #           IBGE::RegiaoImediata.regioes_imediatas_por_regiao(['NE', 'N'])
+    #           IBGE::RegiaoImediata.regioes_imediatas_por_regiao([1, 2])
+    def self.regioes_imediatas_por_regiao(regioes)
+      regioes  = IBGE.formatar(regioes)
+      resposta = RestClient.get("#{BASE_URL}/regioes/#{regioes}/regioes-imediatas")
+
+      tratar_retorno(resposta)
+    end
+
+    # Obtém o conjunto de regiões imediatas do Brasil a partir dos identificadores das regiões intermediárias.
+    # Pode ser informado um único ID ou um array de IDs.
+    #
+    # @param ids [String, Integer, Array] Um ou mais identificadores de regiões intermediárias.
+    # @return [Array<RegiaoImediata>]
+    #
+    # @example
+    #           regiao = IBGE::RegiaoImediata.regioes_imediatas_por_intermediaria(2301)
+    #           regiao.nome #=> "Fortaleza"
+    #
+    #           regioes = IBGE::RegiaoImediata.regioes_imediatas_por_intermediaria([2301, 2302])
+    def self.regioes_imediatas_por_intermediaria(regioes)
+      regioes  = IBGE.formatar(regioes)
+      resposta = RestClient.get("#{BASE_URL}/regioes-intermediarias/#{regioes}/regioes-imediatas")
+    
+      tratar_retorno(resposta)
+    end
+
+    private
+
+    def self.tratar_retorno(resposta)
+      regioes = JSON.parse(resposta.body)
+
+      if regioes.is_a?(Array) 
+        regioes.map { |regiao| RegiaoImediata.new(regiao) }
+      else
+        RegiaoImediata.new(regioes)
+      end 
+    end
+  end
+end

data/lib/ibge/regiao_intermediaria.rb

@@ -0,0 +1,92 @@
+module IBGE
+  class RegiaoIntermediaria
+    attr_accessor :id, :nome, :uf
+
+    def initialize(options = {})
+      @id   = options['id']
+      @nome = options['nome']
+      @uf   = UF.new(options['UF'])
+    end
+
+    # Obtém o conjunto de regiões intermediárias do Brasil.
+    #
+    # @return [Array<RegiaoIntermediaria>]
+    #
+    # @example
+    #           regioes = IBGE::RegiaoIntermediaria.obter_regioes_intermediarias
+    #           regioes.first.nome #=> "Porto Velho" 
+    def self.obter_regioes_intermediarias
+      resposta = RestClient.get("#{BASE_URL}/regioes-intermediarias")
+
+      tratar_retorno(resposta)
+    end
+
+    # Obtém o conjunto de regiões intermediárias do Brasil a partir dos respectivos identificadores.
+    # Pode ser informado um único ID ou um array de IDs.
+    #
+    # @param ids [String, Integer, Array] Um ou mais identificadores de regiões intermediárias.
+    # @return [RegiaoIntermediaria, Array<RegiaoIntermediaria>]
+    #
+    # @example
+    #           regiao = IBGE::RegiaoIntermediaria.regioes_intermediarias_por_id(2301)
+    #           regiao.nome #=> "Fortaleza"
+    #
+    #           regioes = IBGE::RegiaoIntermediaria.regioes_intermediarias_por_id([2301, 2302])
+    def self.regioes_intermediarias_por_id(ids)
+      ids      = IBGE.formatar(ids)
+      resposta = RestClient.get("#{BASE_URL}/regioes-intermediarias/#{ids}")
+      
+      tratar_retorno(resposta)
+    end
+
+    # Obtém o conjunto de regiões intermediárias do Brasil a partir dos identificadores das Unidades da Federação.
+    # Pode ser informada a sigla, identificador (ID) ou um array de siglas/identificadores. 
+    # 
+    # @param ufs [String, Integer, Array]
+    # @return [Array<RegiaoIntermediaria>]
+    #
+    # @example
+    #           regioes = IBGE::RegiaoIntermediaria.regioes_intermediarias_por_uf('CE')
+    #           regioes.first.nome #=> "Fortaleza"
+    #
+    #           IBGE::RegiaoIntermediaria.regioes_intermediarias_por_uf(['BA', 'CE'])
+    #           IBGE::RegiaoIntermediaria.regioes_intermediarias_por_uf(23)
+    def self.regioes_intermediarias_por_uf(ufs)
+      ufs      = IBGE.formatar(ufs)
+      resposta = RestClient.get("#{BASE_URL}/estados/#{ufs}/regioes-intermediarias")
+      
+      tratar_retorno(resposta)
+    end
+
+    # Obtém o conjunto de regiões intermediárias do Brasil a partir dos identificadores das regiões.
+    # Pode ser informada a sigla, identificador (ID) ou um array de siglas/identificadores.
+    #
+    # @param regioes [String, Integer, Array] Um ou mais identificadores de regiões.
+    # @return [Array<RegiaoIntermediaria>]
+    #
+    # @example
+    #           regioes = IBGE::RegiaoIntermediaria.regioes_intermediarias_por_regiao('NE')
+    #           regioes.first.nome #=> "São Luís"
+    #
+    #           IBGE::RegiaoIntermediaria.regioes_intermediarias_por_regiao(['NE', 'N'])
+    #           IBGE::RegiaoIntermediaria.regioes_intermediarias_por_regiao([1, 2])
+    def self.regioes_intermediarias_por_regiao(regioes)
+      regioes  = IBGE.formatar(regioes)
+      resposta = RestClient.get("#{BASE_URL}/regioes/#{regioes}/regioes-intermediarias")
+      
+      tratar_retorno(resposta)
+    end
+
+    private
+
+    def self.tratar_retorno(resposta)
+      regioes = JSON.parse(resposta.body)
+
+      if regioes.is_a?(Array) 
+        regioes.map { |regiao| RegiaoIntermediaria.new(regiao) }
+      else
+        RegiaoIntermediaria.new(regioes)
+      end 
+    end
+  end
+end

data/lib/ibge/subdistrito.rb

@@ -0,0 +1,160 @@
+module IBGE
+  class Subdistrito
+    attr_accessor :id, :nome, :distrito
+
+    def initialize(options = {})
+      @id = options['id']
+      @nome = options['nome']
+      @distrito = Distrito.new(options['distrito'])
+    end
+
+    # Obtém o conjunto de subdistritos do Brasil.
+    #
+    # @return [Array<Subdistrito>]
+    #
+    # @example
+    #           subdistritos = IBGE::Subdistrito.obter_subdistritos
+    #           subdistritos.first.nome #=> "Zona Central"
+    def self.obter_subdistritos
+      resposta = RestClient.get("#{BASE_URL}/subdistritos")
+      
+      tratar_retorno(resposta)
+    end
+
+    # Obtém o conjunto de subdistritos do Brasil a partir dos respectivos identificadores.
+    # Pode ser informado um único ID ou um array de IDs.
+    #
+    # @param ids [String, Integer, Array] Um ou mais identificadores de subdistritos.
+    # @return [Array<Subdistrito>]
+    #
+    # @example
+    #           subdistritos = IBGE::Subdistrito.subdistritos_por_id('23044000512')
+    #           subdistritos.first.nome #=> "Mucuripe"
+    #
+    #           subdistritos = IBGE::Subdistrito.subdistritos_por_id(['23044000512', '23044006511'])
+    def self.subdistritos_por_id(ids)
+      ids      = IBGE.formatar(ids)
+      resposta = RestClient.get("#{BASE_URL}/subdistritos/#{ids}")
+    
+      tratar_retorno(resposta)
+    end
+
+    # Obtém o conjunto de subdistritos do Brasil a partir dos identificadores das Unidades da Federação.
+    # Pode ser informada a sigla, identificador (ID) ou um array de siglas/identificadores. 
+    # 
+    # @param ufs [String, Integer, Array]
+    # @return [Array<Subdistrito>]
+    #
+    # @example
+    #           distritos = IBGE::Subdistrito.subdistritos_por_uf('CE')
+    #           distritos.first.nome #=> "Antônio Bezerra"
+    #
+    #           IBGE::Subdistrito.subdistritos_por_uf(['BA', 'CE'])
+    #           IBGE::Subdistrito.subdistritos_por_uf(23) 
+    def self.subdistritos_por_uf(ufs)
+      ufs      = IBGE.formatar(ufs)
+      resposta = RestClient.get("#{BASE_URL}/estados/#{ufs}/subdistritos")
+    
+      tratar_retorno(resposta)
+    end
+
+    # Obtém o conjunto de subdistritos do Brasil a partir dos identificadores das regiões.
+    # Pode ser informada a sigla, identificador (ID) ou um array de siglas/identificadores.
+    #
+    # @param regioes [String, Integer, Array]
+    # @return [Array<Subdistrito>]
+    #
+    # @example
+    #           subdistritos = IBGE::Subdistrito.subdistritos_por_regiao('NE')
+    #           subdistritos.first.nome #=> "RPA I"
+    #
+    #           IBGE::Subdistrito.subdistritos_por_regiao(['NE', 'N'])
+    #           IBGE::Subdistrito.subdistritos_por_regiao([1, 2])
+    def self.subdistritos_por_regiao(regioes)
+      regioes  = IBGE.formatar(regioes)
+      resposta = RestClient.get("#{BASE_URL}/regioes/#{regioes}/subdistritos")
+    
+      tratar_retorno(resposta)
+    end
+
+    # Obtém o conjunto de subdistritos do Brasil a partir dos identificadores das microrregiões.
+    # Pode ser informado um único ID ou um array de IDs.
+    #
+    # @param microrregioes [String, Integer, Array] Um ou mais identificadores de microrregiões.
+    # @return [Array<Subdistrito>]
+    #
+    # @example
+    #           subdistritos = IBGE::Subdistrito.subdistritos_por_microrregiao(23016)
+    #           subdistritos.last.nome #=> "Parangaba"
+    #
+    #           subdistritos = IBGE::Subdistrito.subdistritos_por_microrregiao([23016, 23017])
+    def self.subdistritos_por_microrregiao(microrregioes)
+      microrregioes = IBGE.formatar(microrregioes)
+      resposta      = RestClient.get("#{BASE_URL}/microrregioes/#{microrregioes}/subdistritos")
+
+      tratar_retorno(resposta)
+    end
+
+    # Obtém o conjunto de subdistritos do Brasil a partir dos identificadores das mesorregiões.
+    # Pode ser informado um único ID ou um array de IDs.
+    #
+    # @param mesorregioes [String, Integer, Array] Um ou mais identificadores de mesorregiões.
+    # @return [Array<Subdistrito>]
+    #
+    # @example
+    #           subdistritos = IBGE::Subdistrito.subdistritos_por_mesorregiao(2303)
+    #           subdistritos.first.nome #=> "Antônio Bezerra"
+    #
+    #           subdistritos = IBGE::Subdistrito.subdistritos_por_mesorregiao([2303, 2304])
+    def self.subdistritos_por_mesorregiao(mesorregioes)
+      mesorregioes = IBGE.formatar(mesorregioes)
+      resposta     = RestClient.get("#{BASE_URL}/mesorregioes/#{mesorregioes}/subdistritos")
+
+      tratar_retorno(resposta)
+    end
+
+    # Obtém o conjunto de subdistritos do Brasil a partir dos identificadores dos distritos.
+    # Pode ser informado um único ID ou um array de IDs.
+    #
+    # @param distritos [String, Integer, Array] um ou mais identificadores de distritos.
+    # @return [Array<Subdistrito>]
+    #
+    # @example
+    #           subdistritos = IBGE::Subdistrito.subdistritos_por_distrito('230440005')
+    #           subdistritos.last.nome #=> "Mucuripe"
+    #
+    #           subdistritos = IBGE::Subdistrito.subdistritos_por_distrito(['230440005', '230370905'])
+    def self.subdistritos_por_distrito(distritos)
+      distritos = IBGE.formatar(distritos)
+      resposta  = RestClient.get("#{BASE_URL}/distritos/#{distritos}/subdistritos")
+
+      tratar_retorno(resposta)
+    end
+
+    # Obtém o conjunto de subdistritos do Brasil a partir dos identificadores dos municípios.
+    # Pode ser informado um único ID ou um array de IDs.
+    #
+    # @param municipios [String, Integer, Array] um ou mais identificadores de municípios.
+    # @return [Array<Subdistrito>]
+    #
+    # @example
+    #           subdistritos = IBGE::Subdistrito.subdistritos_por_municipio('2304400')
+    #           subdistritos.last.nome #=> "Parangaba"
+    #
+    #           subdistritos = IBGE::Subdistrito.subdistritos_por_municipio(['2304400', '2927408'])
+    def self.subdistritos_por_municipio(municipios)
+      municipios = IBGE.formatar(municipios)
+      resposta   = RestClient.get("#{BASE_URL}/municipios/#{municipios}/subdistritos")
+
+      tratar_retorno(resposta)
+    end
+
+    private
+
+    def self.tratar_retorno(resposta)
+      subdistritos = JSON.parse(resposta.body)
+
+      subdistritos.map { |subdistrito| Subdistrito.new(subdistrito) }
+    end
+  end
+end