Rendre une ERB modèle avec des valeurs de hachage

Je dois être oublié quelque chose de très simple ici, mais je n'arrive pas à comprendre comment rendre une simple ERB modèle avec des valeurs de hachage-carte.

Je suis relativement nouveau à ruby, venant de python. J'ai une ERB modèle (pas en HTML), dont j'ai besoin rendus avec le contexte à partir d'un hash-carte, que je reçois à partir d'une source externe.

Toutefois, la documentation de ERB, les états qui la ERB.result méthode prend un binding. J'ai appris qu'ils sont quelque chose que tenir la variable contextes en ruby (quelque chose comme locals() et globals() en python, je suppose?). Mais, je ne sais pas comment je peux construire un objet de liaison de mon hash-carte.

Un peu (un beaucoup, en fait) une recherche sur google m'a donné ceci: http://refactormycode.com/codes/281-given-a-hash-of-variables-render-an-erb-template, qui utilise ruby métaprogrammation magie qui m'échappe.

Donc, n'est-ce pas là une solution simple à ce problème? Ou est-il un meilleur moteur de template (non liées à HTML) mieux adapté pour cela? (J'ai seulement choisi ERB parce que ses dans la stdlib).

  • Je ne sais pas du tout Ruby moteurs de template qui sont "attachés" au format HTML; un modèle est un modèle. Aussi ne savez pas quel est le problème avec la solution que vous liez-est de la question de l'obtention de la valeur de hachage dans le module?
  • Dave, Rien de mal à cela tant que tel. Juste que je pensais qu'il pouvait être une solution plus élégante pour un problème simple que d'aller à la mesure de l'utilisation de la métaprogrammation.
  • cette? stackoverflow.com/questions/1338960/...
  • Exemple: gist.github.com/bastman/55f1c5a5bb474e472d5e
InformationsquelleAutor Shrikant Sharat | 2012-01-21
  1. 56

    Je ne sais pas si cela est admissible à titre de "plus élégant" ou pas:

    require 'erb'
require 'ostruct'

class ErbalT < OpenStruct
  def render(template)
    ERB.new(template).result(binding)
  end
end

et = ErbalT.new({ :first => 'Mislav', 'last' => 'Marohnic' })
puts et.render('Name: <%= first %> <%= last %>')

    Ou à partir d'une méthode de classe:

    class ErbalT < OpenStruct
  def self.render_from_hash(t, h)
    ErbalT.new(h).render(t)
  end

  def render(template)
    ERB.new(template).result(binding)
  end
end

template = 'Name: <%= first %> <%= last %>'
vars = { :first => 'Mislav', 'last' => 'Marohnic' }
puts ErbalT::render_from_hash(template, vars)

    (ErbalT a Erb, T pour le modèle, et des sons comme "thé à base de plantes". En nommant des choses est difficile.)

    • Merci Dave. Oui, cette solution semble un peu mieux, mais je n'ai aucune idée sur OpenStruct. Je vais arriver à la docs, pas de problème 🙂
    • il est en fait plus ou moins la même chose, mais c'est l'OS qui fait le méta.
    InformationsquelleAutor Dave Newton
  2. 74
    require 'erb'
require 'ostruct'

def erb(template, vars)
  ERB.new(template).result(OpenStruct.new(vars).instance_eval { binding })
end

    e.g

    1.9.2p290 :008 > erb("Hey, <%= first_name %> <%= last_name %>", :first_name => "James", :last_name => "Moriarty")
 => "Hey, James Moriarty"
    • +1, c'est un super-élégant, de manière à créer une liaison à partir d'un hash.
    • A l'air sympa au premier abord, mais malheureusement la liaison hérite également les habitants et les méthodes dans le contexte dans lequel le OpenStruct est instancié. Cela donne le modèle de l'accès à beaucoup plus que prévu, et pourrait conduire à des insectes ou même une faille de sécurité, par exemple gist.github.com/aspiers/ad6549058ee423819976
    InformationsquelleAutor Moriarty
  3. 32

    Si vous pouvez utiliser Erubis vous avez cette fonctionnalité déjà:

    irb(main):001:0> require 'erubis'
#=> true
irb(main):002:0> locals = { first:'Gavin', last:'Kistner' }
#=> {:first=>"Gavin", :last=>"Kistner"}
irb(main):003:0> Erubis::Eruby.new("I am <%=first%> <%=last%>").result(locals)
#=> "I am Gavin Kistner"
    • Merci pour cette suggestion, Phrongz. Mais je pense que je vais m'en tenir à stdlib pour cette fois.
    • C'est pratique car les Rails 4 utilise Erubis pour ERB pour son moteur de rendu maintenant.
    • pour ceux qui sont à l'aide de Rails, celui-ci semble le meilleur
    InformationsquelleAutor Phrogz
  4. 25

    Ruby 2.5 a ERB#result_with_hash qui fournit cette fonctionnalité:

    $ ruby -rerb -e 'p ERB.new("Hi <%= name %>").result_with_hash(name: "Tom")'
"Hi Tom"
    • Cette réponse est la meilleure réponse. La plus récente ruby, il est beaucoup plus facile que d'utiliser une liaison.
    InformationsquelleAutor Tom Copeland
  5. 8

    La partie la plus délicate ici est de ne pas polluer la liaison de la redondance des variables locales (comme dans top-rated réponses):

    require 'erb'

class TemplateRenderer
  def self.empty_binding
    binding
  end

  def self.render(template_content, locals = {})
    b = empty_binding
    locals.each { |k, v| b.local_variable_set(k, v) }

    # puts b.local_variable_defined?(:template_content) #=> false

    ERB.new(template_content).result(b)
  end
end

# use it
TemplateRenderer.render('<%= x %> <%= y %>', x: 1, y: 2) #=> "1 2"

# use it 2: read template from file
TemplateRenderer.render(File.read('my_template.erb'), x: 1, y: 2)
    • Je suis confus, quand vous avez dit "ne pas polluer la liaison de la redondance des variables locales (comme dans top-rated réponses)", comme je l'ai fait un test de haut accepté de répondre, et là où aucun supplément de variables locales dans la liaison liant spécifiquement.local_variables.inspecter revenu juste les variables prévu. Je suis d'accord que votre solution est un peu plus efficace que OpenStruct utilise method_missing.
    • elle était polluée quand je l'ai testé il y a plusieurs années. Bien qu'il n'a pas d'importance maintenant, puisque vous pouvez le faire en natif dans ruby 2.5 par exemple. ERB.new("Hi <%= name %>").result_with_hash(name: "Tom")
    InformationsquelleAutor Lev Lukomsky
  6. 6

    Solution Simple à l'aide de La liaison:

    b = binding
b.local_variable_set(:a, 'a')
b.local_variable_set(:b, 'b')
ERB.new(template).result(b)
    InformationsquelleAutor asfer
  7. 4

    Si vous voulez faire les choses très simplement, vous pouvez toujours utiliser explicite de hachage des recherches à l'intérieur de l'ERB modèle. Dire que vous utilisez "contraignant" pour passer d'un hachage variable appelée "hash" dans le modèle, il devrait ressembler à ceci:

    <%= hash["key"] %>
    • Mais comment utiliser binding pour passer le hachage variable?
    • Facile. Juste stocker le hash dans une variable. Puis, dans le même champ d'application que la variable, appel ERB.new(template).result(binding). Kernel#binding permettra de saisir toutes les variables qui sont dans la portée, et ils seront disponibles à l'intérieur de l'ERB modèle.
    • Merci de cette info appartient plus à votre principale réponse que dans un commentaire. Mais n'est-ce pas une approche souffrent de la même fuite de données / des problèmes de sécurité qui je l'ai noté ci-dessus que le instance_evalde réponse souffre?
    • Sans doute vous contrôlez le contenu de votre ERB modèles, de sorte que la sécurité n'est pas un sujet de préoccupation. Si les modèles sont non fiables, vous avez beaucoup plus de problèmes que de "fuite de données" causé par l'utilisation de binding. Depuis ERB modèles peuvent contenir arbitraire de code Ruby, vous avez à regarder le bac à sable de l'ensemble du processus qui rend les modèles. (...ce qui est clairement hors de portée de la question posée ici.)
    • Ouais, bon je suppose que ce n'est pas tellement un problème de sécurité ensuite, mais il y a toujours un risque de fautes de frappe etc ... accidentellement en se référant à quelque chose en dehors de l'ensemble de données destinées à la consommation par le modèle.
    InformationsquelleAutor Alex D