{"id":1324,"date":"2025-09-23T13:45:37","date_gmt":"2025-09-23T16:45:37","guid":{"rendered":"https:\/\/acsiv.com.br\/blog\/?p=1324"},"modified":"2025-09-23T14:11:22","modified_gmt":"2025-09-23T17:11:22","slug":"camadas-declarativas-um-padrao-flexivel-para-ruby","status":"publish","type":"post","link":"https:\/\/acsiv.com.br\/blog\/2025\/09\/23\/camadas-declarativas-um-padrao-flexivel-para-ruby\/","title":{"rendered":"Camadas Declarativas: Um Padr\u00e3o Flex\u00edvel para Ruby"},"content":{"rendered":"\n

Em Ruby<\/strong> , os blocos s\u00e3o uma das ferramentas mais elegantes e expressivas \u00e0 nossa disposi\u00e7\u00e3o. Eles permitem que m\u00e9todos recebam comportamento como argumento e ajudam a manter o c\u00f3digo conciso e leg\u00edvel. De estruturas como each<\/code>, map<\/code>e File.open<\/code>at\u00e9 bibliotecas como RSpec<\/strong> e Rails<\/strong> , os blocos s\u00e3o essenciais para o estilo de programa\u00e7\u00e3o Ruby<\/strong> .<\/p>\n\n\n\n

Qualquer pessoa familiarizada com Ruby<\/strong> certamente j\u00e1 se deparou com um bloco em algum momento. Mas antes de prosseguir, uma r\u00e1pida explica\u00e7\u00e3o sobre o que exatamente \u00e9 um bloco e por que ele \u00e9 t\u00e3o \u00fatil no ecossistema Ruby<\/strong> . Sinta-se \u00e0 vontade para pular para o pr\u00f3ximo cap\u00edtulo se voc\u00ea j\u00e1 se sentir confort\u00e1vel em us\u00e1-lo.<\/p>\n\n\n\n

O que \u00e9 um bloco<\/h2>\n\n\n\n

Um bloco \u00e9 um peda\u00e7o de c\u00f3digo que pode ser passado como par\u00e2metro e executado em um contexto diferente daquele em que foi declarado. Em Ruby, podemos invoc\u00e1-lo usando o yield<\/code>m\u00e9todo e at\u00e9 mesmo passar argumentos para ele. Se o bloco for opcional, o block_given?<\/code>m\u00e9todo nos permite verificar com seguran\u00e7a se um bloco foi fornecido.<\/p>\n\n\n\n

Tamb\u00e9m podemos capturar explicitamente o bloco usando &block<\/code>, o que permite que ele seja tratado como um Proc<\/code>objeto, facilitando sua reutiliza\u00e7\u00e3o ou encaminhamento para outros m\u00e9todos.<\/p>\n\n\n\n

Vejamos alguns exemplos abaixo:<\/p>\n\n\n\n

def  greetings
   puts \"Oi!\" 
  yield  if block_given? 
  puts \"Tchau!\" 
end

 greetings do
   puts \"Como vai voc\u00ea?\" 
end 

# => 
# Oi! 
# Como vai voc\u00ea? 
# Tchau! 

def  execute_two_times ( &block ) 
  block.call 
  block.call 
end

 execute_two_times do
   puts \"Chamando o bloco!\" 
end 

# => 
# Chamando o bloco! 
# Chamando o bloco!<\/pre>\n\n\n\n
Com esses exemplos simples, podemos ver como Ruby<\/strong> pode ser altamente expressivo, abrindo caminho para alguns recursos bem DRY<\/strong> (Don’t Repeat Yourself). Ao longo dos anos trabalhando com Ruby, fiz uso extensivo de blocos em helpers<\/code>, services<\/code>, concerns<\/code>… E a lista continua.<\/p>\n\n\n\n
Camada Declarativa<\/h2>\n\n\n\n
Com o tempo, usando o Rails<\/strong> , sempre me impressionei com a eleg\u00e2ncia com que a gem <\/strong>ActsAsTenant<\/strong> permite definir o tenant<\/strong> com base no dom\u00ednio ou subdom\u00ednio. Com uma \u00fanica linha, declaramos a l\u00f3gica que vincula a solicita\u00e7\u00e3o ao tenant<\/strong> correto :<\/strong><\/strong><\/strong><\/p>\n\n\n\n
definir_locat\u00e1rio_atual_por_subdom\u00ednio_ou_dom\u00ednio( :conta , :subdom\u00ednio , :dom\u00ednio )<\/pre>\n\n\n\n
Este m\u00e9todo \u00e9 chamado diretamente dentro do controller<\/code>, lado a lado com m\u00e9todos cl\u00e1ssicos como before_action<\/code>ou helper_method<\/code>, e implementa um comportamento altamente espec\u00edfico \u2014 mas de forma t\u00e3o fluida, t\u00e3o perfeitamente integrado ao ambiente Rails<\/strong> , que quase parece um comando nativo do pr\u00f3prio framework. \u00c9 uma daquelas constru\u00e7\u00f5es que exemplifica perfeitamente o que veio a ser conhecido como o Estilo Rails<\/strong> : simples, leg\u00edvel e incrivelmente poderoso.<\/p>\n\n\n\n
Essa sutileza me inspira h\u00e1 muito tempo. Sempre tive a esperan\u00e7a de um dia criar algo que tivesse essa mesma eleg\u00e2ncia \u2014 uma maneira de encapsular comportamentos complexos por meio de uma interface declarativa, direta e natural.<\/p>\n\n\n\n
Primeira tentativa<\/strong><\/h2>\n\n\n\n
Minha primeira tentativa de criar algo t\u00e3o elegante quanto a defini\u00e7\u00e3o de tenant<\/strong> surgiu da necessidade de filtrar algumas consultas por meio de par\u00e2metros de URL<\/strong> , e faz\u00ea-lo com comportamento condicional e expressividade. A ideia principal era permitir que os escopos fossem ativados automaticamente quando determinados par\u00e2metros fossem usados. Deveria ser usado da seguinte forma:<\/p>\n\n\n\n
classe  MyController < ApplicationController
   add_scope :type_a
   add_scope :type_b
   add_scope :type_c , if: -> { condi\u00e7\u00e3o? } 

  # ... 
fim<\/pre>\n\n\n\n
Se a URL contiver os termos-chave type_a<\/code>, type_b<\/code>e type_c<\/code>e as condi\u00e7\u00f5es correspondentes (se houver) forem avaliadas como verdadeiras, o escopo apropriado ser\u00e1 aplicado automaticamente \u00e0 consulta. Para atingir esse comportamento, implementei um concern<\/code>que estende os m\u00e9todos de classe de qualquer modelo que o inclua:<\/p>\n\n\n\n
m\u00f3dulo MyConcern 
  estender ActiveSupport::Concern 

  def  self .included(base) 
    base.class_eval do
       estender ClassMethods 
      class_attribute :scopes 
      self .scopes = [] 
    fim 
  fim 

  m\u00f3dulo ClassMethods 
    def  add_scope ( escopo, **op\u00e7\u00f5es ) 
      escopos << { escopo: , **op\u00e7\u00f5es } 
    fim 
  fim 

  # Implementa\u00e7\u00e3o do recurso de escopo que \u00e9 irrelevante por enquanto... 
fim<\/pre>\n\n\n\n
A implementa\u00e7\u00e3o acima cria um concern<\/code>que, quando inclu\u00eddo por uma classe (representada pelo base<\/code>par\u00e2metro), adiciona comportamentos a essa classe via class_eval<\/code>. A linha extend ClassMethods<\/code>significa que o ClassMethods<\/code>m\u00f3dulo fornecer\u00e1 m\u00e9todos de classe<\/strong> \u2014 em outras palavras, m\u00e9todos que podem ser chamados diretamente na classe, em vez de em suas inst\u00e2ncias.<\/p>\n\n\n\n
\n
O nome ClassMethods<\/code>\u00e9 apenas uma conven\u00e7\u00e3o amplamente utilizada na comunidade Rails<\/strong> ; qualquer outro nome tamb\u00e9m funcionaria. Na verdade, ao estender ActiveSupport::Concern<\/code>, podemos simplificar essa defini\u00e7\u00e3o usando o class_methods<\/code>bloco, que encapsula m\u00e9todos de classe de uma forma mais elegante e concisa.<\/p>\n<\/blockquote>\n\n\n\n
Isso concern<\/code>define uma lista chamada scopes<\/code>e um m\u00e9todo add_scope<\/code>, que adiciona elementos a essa lista de forma simples e declarativa. Este atributo reside no escopo da classe<\/strong> , o que traz uma vantagem importante em contextos como controladores Rails .<\/strong><\/p>\n\n\n\n
Em uma aplica\u00e7\u00e3o web, cada requisi\u00e7\u00e3o HTTP (como uma chamada REST) \u200b\u200bresulta na cria\u00e7\u00e3o de uma nova inst\u00e2ncia do controlador \u2014 ou seja, os objetos que manipulam as requisi\u00e7\u00f5es n\u00e3o compartilham o estado entre si<\/strong> . Isso significa que quaisquer dados armazenados em vari\u00e1veis \u200b\u200bou m\u00e9todos de inst\u00e2ncia s\u00e3o transit\u00f3rios<\/strong> , existindo apenas durante a execu\u00e7\u00e3o daquela requisi\u00e7\u00e3o espec\u00edfica.<\/p>\n\n\n\n
Atributos de classe (como self.scopes<\/code>), por outro lado, residem no escopo da pr\u00f3pria classe<\/strong> , sendo compartilhados entre todas as inst\u00e2ncias. Isso permite que configura\u00e7\u00f5es ou declara\u00e7\u00f5es feitas por meio dela add_scope<\/code>sejam persistentemente registradas e acess\u00edveis por qualquer inst\u00e2ncia futura do controlador.<\/p>\n\n\n\n
Segunda Tentativa<\/h2>\n\n\n\n
Minha segunda tentativa surgiu da necessidade de atribuir dinamicamente comportamento estruturado a diferentes classes ActiveModel<\/strong> de forma elegante (de prefer\u00eancia). O uso pretendido seria algo assim:<\/p>\n\n\n\n
Classe MyModel < MyRootModel 
  define_slots do tipo
     de slot : :a , requer: \"MySubClassOfTypeA\" tipo     de slot : :a tipo de     slot : :b fim fim  
 
 
  <\/pre>\n\n\n\n
A ideia aqui \u00e9 que o modelo<\/strong> tenha tr\u00eas slots: dois do tipo a<\/code>e um do tipo b<\/code>, e um dos slots do tipo a<\/code>deve necessariamente conter um objeto da classe MySubClassOfTypeA<\/code>.<\/p>\n\n\n\n
Meu objetivo era obter um hash<\/em> estruturado com os slots dispon\u00edveis para cada modelo<\/strong> , e a implementa\u00e7\u00e3o foi a seguinte:<\/p>\n\n\n\n
classe  MyRootModel 
  classe << auto 
    def  define_slots ( &block ) 
      @slot_rules = [] 

      dsl = Classe .new do 
        def  inicializar ( slots ) 
          @slots = slots 
        fim 

        def  slot ( **kwargs ) 
          @slots << kwargs 
        fim 
      fim

       dsl.new( @slot_rules ).instance_eval(&block) 
    fim 
  fim 
fim<\/pre>\n\n\n\n
Esta implementa\u00e7\u00e3o demonstra um uso mais sofisticado de blocos. O m\u00e9todo define_slots<\/code>recebe um bloco e o executa dentro do contexto de uma classe interna, criada exclusivamente para interpretar aquele dom\u00ednio espec\u00edfico. O comando slot<\/code>por si s\u00f3 n\u00e3o tem significado no escopo externo \u2014 ele n\u00e3o pertence a ActiveRecord<\/code>ou a MyRootModel<\/code>. Mas, quando interpretado dentro de uma inst\u00e2ncia dessa classe an\u00f4nima, ele ganha contexto e prop\u00f3sito. Assim, um simples bloco se transforma em uma linguagem declarativa espec\u00edfica do dom\u00ednio, com seu pr\u00f3prio vocabul\u00e1rio. E a melhor parte: estender essa “linguagem” \u00e9 t\u00e3o simples quanto adicionar um novo m\u00e9todo \u00e0 classe DSL.<\/p>\n\n\n\n
Com essa abordagem, qualquer modelo<\/strong> que herde de MyRootModel<\/code>pode definir seus slots usando define_slots<\/code>e acessar as regras declaradas via @slot_rules<\/code>. Em algum momento, refatorei essa l\u00f3gica \u2014 extraindo a classe an\u00f4nima para seu pr\u00f3prio arquivo e dando uma estrutura mais robusta aos slot<\/code>argumentos (substituindo o uso direto de **kwargs<\/code>) \u2014 mas isso est\u00e1 al\u00e9m do escopo atual. A vers\u00e3o apresentada aqui j\u00e1 \u00e9 suficiente para demonstrar a ideia central: como o uso consciente de blocos pode permitir peda\u00e7os elegantes e reutiliz\u00e1veis, perfeitamente alinhados com a expressividade do Ruby.<\/p>\n\n\n\n
Terceira Tentativa<\/h2>\n\n\n\n
Minha terceira e mais recente tentativa tamb\u00e9m foi a que mais me entusiasmou. No meu trabalho na Acsiv, os dados necess\u00e1rios para um recurso \u00e0s vezes variam entre os contextos. Um bom exemplo \u00e9 o cadastro de indiv\u00edduos. Dependendo da associa\u00e7\u00e3o, s\u00e3o necess\u00e1rios atributos diferentes.<\/p>\n\n\n\n
Por lei, o registro do requerente<\/strong> de um ato notarial deve incluir nome, e-mail e n\u00famero de telefone, enquanto o registro de funcion\u00e1rio<\/strong> n\u00e3o exige informa\u00e7\u00f5es de contato. A situa\u00e7\u00e3o fica ainda mais curiosa quando falamos de certid\u00f5es:<\/p>\n\n\n\n
    \n
  • para uma certid\u00e3o de nascimento<\/strong> , precisamos da data de nascimento;<\/li>\n\n\n\n
  • para uma certid\u00e3o de \u00f3bito<\/strong> , precisamos da data do \u00f3bito.<\/li>\n<\/ul>\n\n\n\n
    Portanto, temos um model<\/code>que est\u00e1 associado a muitos outros, e a valida\u00e7\u00e3o de seus atributos depende de qual deles est\u00e1 relacionado<\/strong> . A solu\u00e7\u00e3o \u00f3bvia seria definir as valida\u00e7\u00f5es dentro do model<\/code>pr\u00f3prio objeto, mas, nesse caso, ele precisaria saber a que est\u00e1 relacionado, e o c\u00f3digo ficaria mais ou menos assim:<\/p>\n\n\n\n
    valida :email , presen\u00e7a:  true , se: -> { personable.is_a?(Request) } 
    valida :date_of_birth , presen\u00e7a:  true , se: -> { personable.is_a?(Birth) } 
    valida :date_of_death , presen\u00e7a:  true , se: -> { personable.is_a?(Death) }<\/pre>\n\n\n\n
    Diga ol\u00e1 ao\u00a0alto acoplamento<\/strong>\u00a0e\u00a0\u00e0 baixa coes\u00e3o<\/strong>\u00a0😊<\/p>\n\n\n\n
    E como bons seguidores do C\u00f3digo Limpo<\/em> do Tio Bob<\/strong> , sabemos que n\u00e3o \u00e9 assim que deveria ser:<\/em><\/p>\n\n\n\n
    \n
    \u201cC\u00f3digo limpo \u00e9 c\u00f3digo com alta coes\u00e3o e baixo acoplamento.\u201d<\/p>\n<\/blockquote>\n\n\n\n
    A solu\u00e7\u00e3o:validates_association<\/code><\/h2>\n\n\n\n
    Para resolver o problema da forma mais elegante poss\u00edvel e sem violar os princ\u00edpios de design, validates_association<\/code>surgiu a ideia de criar. \u00c9 muito f\u00e1cil: permitir que a classe que define a rela\u00e7\u00e3o<\/strong> ( Birth<\/code>, Death<\/code>, etc.) tamb\u00e9m defina as valida\u00e7\u00f5es de associa\u00e7\u00e3o<\/strong> , exatamente como faria com validates<\/code>, mas dentro de um bloco personalizado. Exemplo:<\/p>\n\n\n\n
    classe  Nascimento
       tem_um :pessoa
       valida_associa\u00e7\u00e3o :pessoa  faz
         valida :data_de_nascimento , presen\u00e7a:  verdadeiro 
      fim 
    fim 

    classe  Morte
       tem_um :pessoa
       valida_associa\u00e7\u00e3o :pessoa  faz
         valida :data_de_morte , presen\u00e7a:  verdadeiro 
      fim 
    fim<\/pre>\n\n\n\n
    Veja abaixo como podemos criar o m\u00e9todo:<\/p>\n\n\n\n
    m\u00f3dulo AssociationValidatable 
      estender ActiveSupport::Concern 

      class_methods do 
        def  validates_association ( associa\u00e7\u00e3o, &bloco ) 
          reflection = reflect_on_association(associa\u00e7\u00e3o) 
          klass = reflection.klass 
          foreign_key = reflection.type 

          dsl = Class .new do 
            def  initialize ( klass, foreign_key, refer\u00eancia ) 
              @klass        = klass 
              @foreign_key = foreign_key 
              @reference    = refer\u00eancia 
            fim   

            def  validates ( *atributos, **op\u00e7\u00f5es ) 
              fk = @foreign_key
               ref = @reference

               condi\u00e7\u00e3o = -> { atributos[fk] == ref } 
              op\u00e7\u00f5es[ :if ] = condi\u00e7\u00e3o 

              @klass .validates(*atributos, **op\u00e7\u00f5es) 
            fim 
          fim

           dsl.new(klass, foreign_key, nome).instance_eval(&bloco) 
        fim 
      fim 
    fim<\/pre>\n\n\n\n
    Com essa implementa\u00e7\u00e3o, a ideia de permitir que a classe que define o relacionamento tamb\u00e9m defina as valida\u00e7\u00f5es dessa associa\u00e7\u00e3o \u2014 desde que a associa\u00e7\u00e3o aponte para ela \u2014 torna-se realidade. Observe que aqui usamos class_methods<\/code>, como explicado anteriormente. Por meio dele, models<\/code>os include AssociationValidatable<\/code>obt\u00eam acesso ao validates_association<\/code>m\u00e9todo. Esse m\u00e9todo, por sua vez, instancia uma classe an\u00f4nima<\/strong> (como vimos na segunda tentativa), que define um validates<\/code>m\u00e9todo com a mesma assinatura da ActiveModel<\/code>vers\u00e3o original \u2014 e, por fim, delega a chamada a ele.<\/p>\n\n\n\n
    Voc\u00ea pode ter notado as vari\u00e1veis fk<\/code>\u200b\u200be ref<\/code>e se perguntado por que elas s\u00e3o usadas. Isso \u00e9 necess\u00e1rio devido ao modo como os closures (lambdas\/procs)<\/strong> funcionam em Ruby<\/strong> . Vari\u00e1veis \u200b\u200bde inst\u00e2ncia como @foreign_key<\/code>e @reference<\/code>s\u00e3o avaliadas no contexto do objeto onde o lambda \u00e9 executado, n\u00e3o onde foi definido<\/strong> . Em outras palavras, o bloco -> { attributes[@foreign_key] == @reference }<\/code>seria executado dentro da inst\u00e2ncia de associa\u00e7\u00e3o \u2014 e, como essa inst\u00e2ncia n\u00e3o possui<\/strong> as vari\u00e1veis @foreign_key<\/code>\u200b\u200be @reference<\/code>, o resultado seria sempre nil<\/code>. Ao atribuir esses valores a vari\u00e1veis \u200b\u200blocais<\/strong> ( fk<\/code>, ref<\/code>), garantimos que seus valores sejam capturados corretamente pelo closure<\/strong> , j\u00e1 que lambdas em Ruby capturam o escopo local no momento da defini\u00e7\u00e3o.<\/p>\n\n\n\n
    \n
    N\u00e3o se esque\u00e7a de reiniciar o servidor! Essas altera\u00e7\u00f5es afetam a defini\u00e7\u00e3o da classe, que s\u00f3 \u00e9 carregada durante a inicializa\u00e7\u00e3o.<\/p>\n<\/blockquote>\n\n\n\n
    Dito isto, ainda podemos melhorar nossa implementa\u00e7\u00e3o de v\u00e1rias maneiras, como:<\/p>\n\n\n\n
      \n
    • Cria\u00e7\u00e3o de a\u00e7\u00facar sint\u00e1tico<\/em> para simplificar c\u00f3digo repetitivo;<\/li>\n\n\n\n
    • Permitir que a associa\u00e7\u00e3o valide suas pr\u00f3prias associa\u00e7\u00f5es<\/strong> ;<\/li>\n\n\n\n
    • Tornando as valida\u00e7\u00f5es condicionais<\/strong> , se necess\u00e1rio.<\/li>\n<\/ul>\n\n\n\n
      Dentre elas, a cria\u00e7\u00e3o do a\u00e7\u00facar sint\u00e1tico<\/em> \u00e9 a mais simples \u2014 ent\u00e3o vamos come\u00e7ar com isso.<\/p>\n\n\n\n
      A ideia aqui \u00e9 permitir que voc\u00ea use uma valida\u00e7\u00e3o predefinida de forma clara e concisa, como neste exemplo:<\/p>\n\n\n\n
      validates_association :pessoa , como:  :solicitante<\/pre>\n\n\n\n
      O primeiro passo \u00e9 definir uma predefini\u00e7\u00e3o chamada :requester<\/code>. Declarei o bloco dentro da associa\u00e7\u00e3o model<\/code>, Person<\/code>neste caso.<\/p>\n\n\n\n
      classe  Pessoa 
        VALIDATION_PRESETS = { 
          solicitante:  proc  do
             valida :doc_cpf_cnpj , presen\u00e7a:  true
             valida :email , presen\u00e7a:  true
             valida :phone_number , presen\u00e7a:  true 
          fim
         } 
      fim<\/pre>\n\n\n\n
      No peda\u00e7o acima, VALIDATION_PRESETS<\/code>h\u00e1 apenas uma constante padr\u00e3o do Ruby<\/strong> , o que significa que podemos acess\u00e1-la com Person::VALIDATION_PRESETS<\/code>.<\/p>\n\n\n\n
      Agora, vamos adaptar nosso c\u00f3digo para que ele possa responder a um as:<\/code>par\u00e2metro e encontrar a predefini\u00e7\u00e3o correta:<\/p>\n\n\n\n
      m\u00f3dulo AssociationValidatable 
        extend ActiveSupport::Concern 

        class_methods do 
          def  validates_association ( association, as:  nil , &block ) 
            reflection = reflect_on_association(association) 
            klass = reflection.klass 
            foreign_key = reflection.type 
            preset = options[ :as ] 

            dsl = Class .new do 
              def  initialize ( klass, foreign_key, reference ) 
                @klass             = klass 
                @foreign_key       = foreign_key 
                @reference         = reference 
              end 

              def  validates ( *attrs, **options ) 
                fk = @foreign_key
                 ref = @reference

                 condition = -> { attributes[fk] == ref } 
                options[ :if ] = condition 

                @klass .validates(*attrs, **options) 
              end 
            end

             block | |= klass:: VALIDATION_PRESETS [preset] 

            raise ArgumentError, \"Nem bloco nem predefini\u00e7\u00e3o foram fornecidos.\"  if block. nil ? 

            dsl.new(klass, chave_estrangeira, nome).instance_eval(&bloco) 
          fim 
        fim 
      fim<\/pre>\n\n\n\n
      Com essa mudan\u00e7a, validates_association<\/code>agora suporta:<\/p>\n\n\n\n
        \n
      • um tradicional block<\/code>, com valida\u00e7\u00f5es declaradas em linha;<\/li>\n\n\n\n
      • uma as:<\/code>op\u00e7\u00e3o que aponta para uma predefini\u00e7\u00e3o previamente definida no associado model<\/code>.<\/li>\n<\/ul>\n\n\n\n
        Esta pequena adi\u00e7\u00e3o aumenta significativamente a flexibilidade e ajuda a manter o models<\/code>ambiente mais limpo e coeso.<\/p>\n\n\n\n
        Agora, vamos aos pontos restantes.<\/p>\n\n\n\n
        Imagine que Birth<\/code>est\u00e1 relacionado a Person<\/code>, e Person<\/code>, por sua vez, est\u00e1 relacionado a Address<\/code>. Queremos permitir Birth<\/code>a valida\u00e7\u00e3o n\u00e3o apenas Person<\/code>dos campos de , mas tamb\u00e9m daqueles de Address<\/code>quando existe um relacionamento entre eles.<\/p>\n\n\n\n
        O que nos leva \u00e0 seguinte quest\u00e3o: como validamos uma associa\u00e7\u00e3o de terceiro n\u00edvel?<\/strong><\/p>\n\n\n\n
        Com essa abordagem, \u00e9 bem simples! Precisamos apenas que nossa classe an\u00f4nima tenha seu pr\u00f3prio validates_association<\/code>m\u00e9todo \u2014 um que saiba como acessar a associa\u00e7\u00e3o interna, validar sua estrutura e permitir a especifica\u00e7\u00e3o de condi\u00e7\u00f5es personalizadas.<\/p>\n\n\n\n
        m\u00f3dulo AssociationValidatable 
          estender ActiveSupport::Concern 

          class_methods do 
            def  validates_association ( associa\u00e7\u00e3o, **op\u00e7\u00f5es, &bloco ) 
              reflection = reflect_on_association(associa\u00e7\u00e3o) 
              klass = reflection.klass 
              foreign_key = reflection.type 

              preset = options[ :as ] 
              if_condition = options[ :if ] 
              unless _condition = options[ :unless ] 

              dsl = Class .new do 
                def  initialize ( klass, foreign_key, refer\u00eancia, if_condition, unless _condition ) 
                  @klass             = klass 
                  @foreign_key       = foreign_key 
                  @reference         = refer\u00eancia 
                  @if_condition      = if_condition | | -> { true } 
                  @unless_condition = unless _condition | | -> { false } 
                fim 

                def  valida ( *attrs, **op\u00e7\u00f5es ) 
                  fk = @foreign_key
                   ref = @reference
                   if_condition = @if_condition 
                  unless _condition = @unless_condition
                   condi\u00e7\u00e3o = -> { atributos[fk] == ref && instance_exec(&if_condition) } 

                  se op\u00e7\u00f5es[ :if ] 
                    existente = op\u00e7\u00f5es[ :if ] 
                    op\u00e7\u00f5es[ :if ] = -> { inst\u00e2ncia_exec(&existente) && inst\u00e2ncia_exec(&condi\u00e7\u00e3o) } 
                  sen\u00e3o
                     op\u00e7\u00f5es[ :if ] = condi\u00e7\u00e3o 
                  fim 

                  se op\u00e7\u00f5es[ :unless ] 
                    existente = op\u00e7\u00f5es[ :unless ] 
                    op\u00e7\u00f5es[ :unless ] = -> { inst\u00e2ncia_exec(&existente) | | instance_exec(& unless _condition) } 
                  else
                     options[ :unless ] = unless _condition 
                  end 

                  @klass .validates(*attrs, **options) 
                end 

                def  validates_association ( associa\u00e7\u00e3o, **op\u00e7\u00f5es, &bloco ) 
                  reflection = @klass .reflect_on_association(associa\u00e7\u00e3o)
                  fk = @foreign_key
                   ref = @reference
                   preset = options[ :as ] 
                  unless _condition = options[ :unless ] 

                  if_condition = if options[ :if ] 
                                   existing = options[ :if ] 
                                   -> { instance_exec(&existing) && public_send(reflection.options[ :as ]).public_send(fk) == ref } 
                                 else
                                    -> { public_send(reflection.options[ :as ]).public_send(fk) == ref } 
                                 end 

                  @klass .validates_association(association, preset: , if: if_condition, unless:  unless _condition, &block) 
                end 
              end

               block | |= klass:: VALIDATION_PRESETS [preset] 

              raise ArgumentError, \"Nem bloco nem predefini\u00e7\u00e3o foram fornecidos.\"  if block. nil ? 

              dsl.new(klass, chave_estrangeira, nome, condi\u00e7\u00e3o_se, a menos que_condi\u00e7\u00e3o).instance_eval(&bloco) 
            fim 
          fim 
        fim<\/pre>\n\n\n\n
        O mais importante \u00e9 entender que fechamentos (lambdas\/procs)<\/strong> s\u00e3o executados no contexto da model<\/code>valida\u00e7\u00e3o, portanto, precisamos garantir que o relacionamento entre todos os objetos na cadeia esteja definido corretamente. Em nosso exemplo, Address<\/code>deve ser associado a Person<\/code>, e este Person<\/code>, por sua vez, deve ser associado corretamente a Birth<\/code>para que as valida\u00e7\u00f5es definidas em Birth<\/code>sejam aplicadas \u00e0s associa\u00e7\u00f5es aninhadas.<\/p>\n\n\n\n
        Com isso em mente, agora podemos us\u00e1-lo conforme mostrado nos exemplos a seguir:<\/p>\n\n\n\n
          validates_association :pessoa  do
             validates :data_de_nascimento , presen\u00e7a:  verdadeiro

             validates_association :endere\u00e7o  do
               validates :rua , presen\u00e7a:  verdadeiro 
            fim 
          fim<\/pre>\n\n\n\n
          validates_association :pessoa  faz
             valida :data_de_nascimento , presen\u00e7a:  verdadeiro , se: -> {condi\u00e7\u00e3o?} 

            validates_association :endere\u00e7o  faz
               valida :rua , presen\u00e7a:  verdadeiro , a menos que: -> {outra_condi\u00e7\u00e3o?} 
            fim 
          fim<\/pre>\n\n\n\n
          valida_associa\u00e7\u00e3o :pessoa , se: -> {condi\u00e7\u00e3o?} faz
             valida :data_de_nascimento , presen\u00e7a:  verdadeiro

             valida_associa\u00e7\u00e3o :endere\u00e7o , a menos que: -> {outra_condi\u00e7\u00e3o?} faz
               valida :rua , presen\u00e7a:  verdadeiro 
            fim 
          fim<\/pre>\n\n\n\n
        O que chamo de Camada Declarativa<\/strong> \u00e9 o resultado final ao qual cheguei ap\u00f3s tentar extrair todo o potencial dos blocos<\/em> . N\u00f3s os utilizamos para organizar o comportamento de forma clara e modular, focando mais na declara\u00e7\u00e3o do que na l\u00f3gica em si. Em vez de definir regras ou l\u00f3gica diretamente dentro dos m\u00e9todos, encapsulamos essas responsabilidades em camadas bem definidas que podem ser facilmente compostas, reutilizadas e testadas.<\/p>\n\n\n\n
        Explorar camadas declarativas revela um dos aspectos mais poderosos do\u00a0Ruby<\/strong>\u00a0: a capacidade de transformar c\u00f3digo em linguagem. Em vez de impor estruturas r\u00edgidas ou acoplamentos complexos, criamos espa\u00e7os onde a sem\u00e2ntica de dom\u00ednio assume o controle. O resultado s\u00e3o interfaces leg\u00edveis e extens\u00edveis que se adaptam ao problema que estamos modelando \u2014 e n\u00e3o o contr\u00e1rio. Essas camadas podem ser consideradas pequenas\u00a0DSLs<\/strong>\u00a0, permitindo que voc\u00ea crie seus pr\u00f3prios contextos. No final, o que antes parecia “apenas um bloco com um limite” torna-se uma base s\u00f3lida para projetos mais expressivos e sustent\u00e1veis.<\/p>\n\n\n\n
        Escrito por: Fillipe Palhares<\/p>\n","protected":false},"excerpt":{"rendered":"
        Esse artigo explora o uso de blocos em Ruby para criar camadas declarativas, que tornam o c\u00f3digo mais expressivo, leg\u00edvel e reutiliz\u00e1vel. Atrav\u00e9s de exemplos pr\u00e1ticos em Rails, o autor mostra como blocos permitem construir DSLs elegantes, reduzir acoplamento, aumentar coes\u00e3o e transformar l\u00f3gica complexa em interfaces simples e flex\u00edveis. Leia o artigo completo!<\/p>\n","protected":false},"author":2,"featured_media":1326,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[15,23,8],"tags":[1016,1012,1014,1017,1011,1013,1010,835,1009,1015],"yoast_head":"\r\n"Camadas Declarativas: Um Padr\u00e3o Flex\u00edvel para Ruby"<\/title>\r\n<meta name=\"description\" content=\"Aprenda como blocos em Ruby criam camadas declarativas e DSLs elegantes, deixando o c\u00f3digo mais limpo, leg\u00edvel, flex\u00edvel em projetos Rails.\" \/>\r\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\r\n<link rel=\"canonical\" href=\"https:\/\/acsiv.com.br\/blog\/2025\/09\/23\/camadas-declarativas-um-padrao-flexivel-para-ruby\/\" \/>\r\n<meta property=\"og:locale\" content=\"pt_BR\" \/>\r\n<meta property=\"og:type\" content=\"article\" \/>\r\n<meta property=\"og:title\" content=\""Camadas Declarativas: Um Padr\u00e3o Flex\u00edvel para Ruby"\" \/>\r\n<meta property=\"og:description\" content=\"Aprenda como blocos em Ruby criam camadas declarativas e DSLs elegantes, deixando o c\u00f3digo mais limpo, leg\u00edvel, flex\u00edvel em projetos Rails.\" \/>\r\n<meta property=\"og:url\" content=\"https:\/\/acsiv.com.br\/blog\/2025\/09\/23\/camadas-declarativas-um-padrao-flexivel-para-ruby\/\" \/>\r\n<meta property=\"og:site_name\" content=\"Blog da Acsiv\" \/>\r\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/acsiv\" \/>\r\n<meta property=\"article:published_time\" content=\"2025-09-23T16:45:37+00:00\" \/>\r\n<meta property=\"article:modified_time\" content=\"2025-09-23T17:11:22+00:00\" \/>\r\n<meta property=\"og:image\" content=\"https:\/\/acsiv.com.br\/blog\/wp-content\/uploads\/2025\/09\/altumcode-oZ61KFUQsus-unsplash-scaled.jpg\" \/>\r\n\t<meta property=\"og:image:width\" content=\"2048\" \/>\r\n\t<meta property=\"og:image:height\" content=\"2560\" \/>\r\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\r\n<meta name=\"author\" content=\"Eduardo Rodrigues\" \/>\r\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\r\n<meta name=\"twitter:creator\" content=\"@acsiv\" \/>\r\n<meta name=\"twitter:site\" content=\"@acsiv\" \/>\r\n<meta name=\"twitter:label1\" content=\"Escrito por\" \/>\n\t<meta name=\"twitter:data1\" content=\"Eduardo Rodrigues\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. tempo de leitura\" \/>\n\t<meta name=\"twitter:data2\" content=\"17 minutos\" \/>\r\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Organization\",\"@id\":\"https:\/\/acsiv.com.br\/blog\/#organization\",\"name\":\"Acsiv Sistema\",\"url\":\"https:\/\/acsiv.com.br\/blog\/\",\"sameAs\":[\"https:\/\/instagram.com\/acsivsistemas\",\"https:\/\/pt.linkedin.com\/company\/acsiv\",\"https:\/\/www.facebook.com\/acsiv\",\"https:\/\/twitter.com\/acsiv\"],\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"pt-BR\",\"@id\":\"https:\/\/acsiv.com.br\/blog\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/acsiv.com.br\/blog\/wp-content\/uploads\/2020\/10\/Acsiv_logotipo.png\",\"contentUrl\":\"https:\/\/acsiv.com.br\/blog\/wp-content\/uploads\/2020\/10\/Acsiv_logotipo.png\",\"width\":1564,\"height\":668,\"caption\":\"Acsiv Sistema\"},\"image\":{\"@id\":\"https:\/\/acsiv.com.br\/blog\/#\/schema\/logo\/image\/\"}},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/acsiv.com.br\/blog\/#website\",\"url\":\"https:\/\/acsiv.com.br\/blog\/\",\"name\":\"Blog da Acsiv\",\"description\":\"Conte\u00fado digital para cart\u00f3rios\",\"publisher\":{\"@id\":\"https:\/\/acsiv.com.br\/blog\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/acsiv.com.br\/blog\/?s={search_term_string}\"},\"query-input\":\"required name=search_term_string\"}],\"inLanguage\":\"pt-BR\"},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/acsiv.com.br\/blog\/2025\/09\/23\/camadas-declarativas-um-padrao-flexivel-para-ruby\/\",\"url\":\"https:\/\/acsiv.com.br\/blog\/2025\/09\/23\/camadas-declarativas-um-padrao-flexivel-para-ruby\/\",\"name\":\"\\\"Camadas Declarativas: Um Padr\u00e3o Flex\u00edvel para Ruby\\\"\",\"isPartOf\":{\"@id\":\"https:\/\/acsiv.com.br\/blog\/#website\"},\"datePublished\":\"2025-09-23T16:45:37+00:00\",\"dateModified\":\"2025-09-23T17:11:22+00:00\",\"description\":\"Aprenda como blocos em Ruby criam camadas declarativas e DSLs elegantes, deixando o c\u00f3digo mais limpo, leg\u00edvel, flex\u00edvel em projetos Rails.\",\"breadcrumb\":{\"@id\":\"https:\/\/acsiv.com.br\/blog\/2025\/09\/23\/camadas-declarativas-um-padrao-flexivel-para-ruby\/#breadcrumb\"},\"inLanguage\":\"pt-BR\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/acsiv.com.br\/blog\/2025\/09\/23\/camadas-declarativas-um-padrao-flexivel-para-ruby\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/acsiv.com.br\/blog\/2025\/09\/23\/camadas-declarativas-um-padrao-flexivel-para-ruby\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"In\u00edcio\",\"item\":\"https:\/\/acsiv.com.br\/blog\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Camadas Declarativas: Um Padr\u00e3o Flex\u00edvel para Ruby\"}]},{\"@type\":\"Article\",\"@id\":\"https:\/\/acsiv.com.br\/blog\/2025\/09\/23\/camadas-declarativas-um-padrao-flexivel-para-ruby\/#article\",\"isPartOf\":{\"@id\":\"https:\/\/acsiv.com.br\/blog\/2025\/09\/23\/camadas-declarativas-um-padrao-flexivel-para-ruby\/\"},\"author\":{\"name\":\"Eduardo Rodrigues\",\"@id\":\"https:\/\/acsiv.com.br\/blog\/#\/schema\/person\/54fd566d0efeb6dc731df7e4e38ce156\"},\"headline\":\"Camadas Declarativas: Um Padr\u00e3o Flex\u00edvel para Ruby\",\"datePublished\":\"2025-09-23T16:45:37+00:00\",\"dateModified\":\"2025-09-23T17:11:22+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/acsiv.com.br\/blog\/2025\/09\/23\/camadas-declarativas-um-padrao-flexivel-para-ruby\/\"},\"wordCount\":2406,\"publisher\":{\"@id\":\"https:\/\/acsiv.com.br\/blog\/#organization\"},\"keywords\":[\"#CleanCode\",\"#C\u00f3digoLimpo\",\"#Declarativo\",\"#DesenvolvimentoDeSoftware\",\"#DesenvolvimentoWeb\",\"#DSL\",\"#Programa\u00e7\u00e3o\",\"#Rails\",\"#Ruby\",\"#RubyOnRails\"],\"articleSection\":[\"Cart\u00f3rios\",\"Dicas\",\"Tecnologia\"],\"inLanguage\":\"pt-BR\"},{\"@type\":\"Person\",\"@id\":\"https:\/\/acsiv.com.br\/blog\/#\/schema\/person\/54fd566d0efeb6dc731df7e4e38ce156\",\"name\":\"Eduardo Rodrigues\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"pt-BR\",\"@id\":\"https:\/\/acsiv.com.br\/blog\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/fee13940cf1da650036b52bc338d5881?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/fee13940cf1da650036b52bc338d5881?s=96&d=mm&r=g\",\"caption\":\"Eduardo Rodrigues\"}}]}<\/script>\r\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"\"Camadas Declarativas: Um Padr\u00e3o Flex\u00edvel para Ruby\"","description":"Aprenda como blocos em Ruby criam camadas declarativas e DSLs elegantes, deixando o c\u00f3digo mais limpo, leg\u00edvel, flex\u00edvel em projetos Rails.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/acsiv.com.br\/blog\/2025\/09\/23\/camadas-declarativas-um-padrao-flexivel-para-ruby\/","og_locale":"pt_BR","og_type":"article","og_title":"\"Camadas Declarativas: Um Padr\u00e3o Flex\u00edvel para Ruby\"","og_description":"Aprenda como blocos em Ruby criam camadas declarativas e DSLs elegantes, deixando o c\u00f3digo mais limpo, leg\u00edvel, flex\u00edvel em projetos Rails.","og_url":"https:\/\/acsiv.com.br\/blog\/2025\/09\/23\/camadas-declarativas-um-padrao-flexivel-para-ruby\/","og_site_name":"Blog da Acsiv","article_publisher":"https:\/\/www.facebook.com\/acsiv","article_published_time":"2025-09-23T16:45:37+00:00","article_modified_time":"2025-09-23T17:11:22+00:00","og_image":[{"width":2048,"height":2560,"url":"https:\/\/acsiv.com.br\/blog\/wp-content\/uploads\/2025\/09\/altumcode-oZ61KFUQsus-unsplash-scaled.jpg","type":"image\/jpeg"}],"author":"Eduardo Rodrigues","twitter_card":"summary_large_image","twitter_creator":"@acsiv","twitter_site":"@acsiv","twitter_misc":{"Escrito por":"Eduardo Rodrigues","Est. tempo de leitura":"17 minutos"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Organization","@id":"https:\/\/acsiv.com.br\/blog\/#organization","name":"Acsiv Sistema","url":"https:\/\/acsiv.com.br\/blog\/","sameAs":["https:\/\/instagram.com\/acsivsistemas","https:\/\/pt.linkedin.com\/company\/acsiv","https:\/\/www.facebook.com\/acsiv","https:\/\/twitter.com\/acsiv"],"logo":{"@type":"ImageObject","inLanguage":"pt-BR","@id":"https:\/\/acsiv.com.br\/blog\/#\/schema\/logo\/image\/","url":"https:\/\/acsiv.com.br\/blog\/wp-content\/uploads\/2020\/10\/Acsiv_logotipo.png","contentUrl":"https:\/\/acsiv.com.br\/blog\/wp-content\/uploads\/2020\/10\/Acsiv_logotipo.png","width":1564,"height":668,"caption":"Acsiv Sistema"},"image":{"@id":"https:\/\/acsiv.com.br\/blog\/#\/schema\/logo\/image\/"}},{"@type":"WebSite","@id":"https:\/\/acsiv.com.br\/blog\/#website","url":"https:\/\/acsiv.com.br\/blog\/","name":"Blog da Acsiv","description":"Conte\u00fado digital para cart\u00f3rios","publisher":{"@id":"https:\/\/acsiv.com.br\/blog\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/acsiv.com.br\/blog\/?s={search_term_string}"},"query-input":"required name=search_term_string"}],"inLanguage":"pt-BR"},{"@type":"WebPage","@id":"https:\/\/acsiv.com.br\/blog\/2025\/09\/23\/camadas-declarativas-um-padrao-flexivel-para-ruby\/","url":"https:\/\/acsiv.com.br\/blog\/2025\/09\/23\/camadas-declarativas-um-padrao-flexivel-para-ruby\/","name":"\"Camadas Declarativas: Um Padr\u00e3o Flex\u00edvel para Ruby\"","isPartOf":{"@id":"https:\/\/acsiv.com.br\/blog\/#website"},"datePublished":"2025-09-23T16:45:37+00:00","dateModified":"2025-09-23T17:11:22+00:00","description":"Aprenda como blocos em Ruby criam camadas declarativas e DSLs elegantes, deixando o c\u00f3digo mais limpo, leg\u00edvel, flex\u00edvel em projetos Rails.","breadcrumb":{"@id":"https:\/\/acsiv.com.br\/blog\/2025\/09\/23\/camadas-declarativas-um-padrao-flexivel-para-ruby\/#breadcrumb"},"inLanguage":"pt-BR","potentialAction":[{"@type":"ReadAction","target":["https:\/\/acsiv.com.br\/blog\/2025\/09\/23\/camadas-declarativas-um-padrao-flexivel-para-ruby\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/acsiv.com.br\/blog\/2025\/09\/23\/camadas-declarativas-um-padrao-flexivel-para-ruby\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"In\u00edcio","item":"https:\/\/acsiv.com.br\/blog\/"},{"@type":"ListItem","position":2,"name":"Camadas Declarativas: Um Padr\u00e3o Flex\u00edvel para Ruby"}]},{"@type":"Article","@id":"https:\/\/acsiv.com.br\/blog\/2025\/09\/23\/camadas-declarativas-um-padrao-flexivel-para-ruby\/#article","isPartOf":{"@id":"https:\/\/acsiv.com.br\/blog\/2025\/09\/23\/camadas-declarativas-um-padrao-flexivel-para-ruby\/"},"author":{"name":"Eduardo Rodrigues","@id":"https:\/\/acsiv.com.br\/blog\/#\/schema\/person\/54fd566d0efeb6dc731df7e4e38ce156"},"headline":"Camadas Declarativas: Um Padr\u00e3o Flex\u00edvel para Ruby","datePublished":"2025-09-23T16:45:37+00:00","dateModified":"2025-09-23T17:11:22+00:00","mainEntityOfPage":{"@id":"https:\/\/acsiv.com.br\/blog\/2025\/09\/23\/camadas-declarativas-um-padrao-flexivel-para-ruby\/"},"wordCount":2406,"publisher":{"@id":"https:\/\/acsiv.com.br\/blog\/#organization"},"keywords":["#CleanCode","#C\u00f3digoLimpo","#Declarativo","#DesenvolvimentoDeSoftware","#DesenvolvimentoWeb","#DSL","#Programa\u00e7\u00e3o","#Rails","#Ruby","#RubyOnRails"],"articleSection":["Cart\u00f3rios","Dicas","Tecnologia"],"inLanguage":"pt-BR"},{"@type":"Person","@id":"https:\/\/acsiv.com.br\/blog\/#\/schema\/person\/54fd566d0efeb6dc731df7e4e38ce156","name":"Eduardo Rodrigues","image":{"@type":"ImageObject","inLanguage":"pt-BR","@id":"https:\/\/acsiv.com.br\/blog\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/fee13940cf1da650036b52bc338d5881?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/fee13940cf1da650036b52bc338d5881?s=96&d=mm&r=g","caption":"Eduardo Rodrigues"}}]}},"_links":{"self":[{"href":"https:\/\/acsiv.com.br\/blog\/wp-json\/wp\/v2\/posts\/1324"}],"collection":[{"href":"https:\/\/acsiv.com.br\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/acsiv.com.br\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/acsiv.com.br\/blog\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/acsiv.com.br\/blog\/wp-json\/wp\/v2\/comments?post=1324"}],"version-history":[{"count":1,"href":"https:\/\/acsiv.com.br\/blog\/wp-json\/wp\/v2\/posts\/1324\/revisions"}],"predecessor-version":[{"id":1325,"href":"https:\/\/acsiv.com.br\/blog\/wp-json\/wp\/v2\/posts\/1324\/revisions\/1325"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/acsiv.com.br\/blog\/wp-json\/wp\/v2\/media\/1326"}],"wp:attachment":[{"href":"https:\/\/acsiv.com.br\/blog\/wp-json\/wp\/v2\/media?parent=1324"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/acsiv.com.br\/blog\/wp-json\/wp\/v2\/categories?post=1324"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/acsiv.com.br\/blog\/wp-json\/wp\/v2\/tags?post=1324"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}