{"id":7130,"date":"2019-01-21T14:29:22","date_gmt":"2019-01-21T13:29:22","guid":{"rendered":"https:\/\/pi3g.com\/?p=7130"},"modified":"2019-01-21T14:35:21","modified_gmt":"2019-01-21T13:35:21","slug":"the-scope-of-ecr-within-crystal-or-how-do-i-pass-in-variables-and-objects-into-ecr-templates","status":"publish","type":"post","link":"https:\/\/pi3g.com\/de\/the-scope-of-ecr-within-crystal-or-how-do-i-pass-in-variables-and-objects-into-ecr-templates\/","title":{"rendered":"Der Anwendungsbereich von ecr in crystal: oder wie \u00fcbergebe ich Variablen und Objekte in ECR-Vorlagen?"},"content":{"rendered":"

Als Anf\u00e4nger in der Crystal-Sprache f\u00e4llt es mir immer noch schwer, einige der darin enthaltenen Konzepte zu verstehen und ein Gef\u00fchl f\u00fcr die Programmierung in Crystal zu entwickeln.<\/p>\n

Wenn ich auf schwierige Probleme sto\u00dfe, die ich l\u00f6se oder zu verstehen beginne, blogge ich dar\u00fcber, damit andere davon profitieren k\u00f6nnen - denn der Mangel an Dokumentation wird (von mir) manchmal stark empfunden.<\/p>\n

Vorw\u00e4rts!<\/p>\n

Hier ist die Dokumentation f\u00fcr ECR (in v.0.27, der derzeit letzten Version von Crystal):<\/p>\n

https:\/\/crystal-lang.org\/api\/0.27.0\/ECR.html<\/a><\/p>\n

Sie k\u00f6nnen sich den Quellcode von ECR, den eingebetteten Kristallvorlagen, hier ansehen:<\/p>\n

https:\/\/github.com\/crystal-lang\/crystal\/tree\/c9d1eef8fde5c7a03a029d64c8483ed7b4f2fe86\/src\/ecr<\/a><\/p>\n

ECR ist eine Templatesprache zur Kompilierzeit. Sie k\u00f6nnen ECR nicht verwenden, um Vorlagen zur Laufzeit zu verarbeiten!<\/p>\n

Makros, die die Welt regieren<\/h1>\n

Wenn Sie die ECR-Vorlagen in Crystal verwenden (auch wenn Sie sie mit Hilfe von Kemal verwenden), verwenden Sie Makros.<\/p>\n

Crystal verf\u00fcgt \u00fcber eine Makrosprache, mit der Sie Code abstrahieren und wiederverwenden k\u00f6nnen. Im ersten Schritt der Kompilierung werden die Makros ausgewertet und der resultierende Code wird an der Stelle \"eingef\u00fcgt\", an der der Makroaufruf stand.<\/p>\n

Anschlie\u00dfend kompiliert Crystal den Code.<\/p>\n

Wie funktioniert das bei ECR?<\/strong><\/p>\n

Nehmen wir zum Beispiel die def_to_s(Dateiname)<\/strong> Makro im Code des Beispiels:<\/p>\n

\n
erfordern \"ecr\"\n\nclass Begr\u00fc\u00dfung\n  def initialize(@name : String)\n  end\n\n  ECR.def_to_s \"greeting.ecr\"<\/font>\nend\n\n# gruss.ecr\nGru\u00df, !\n\nGru\u00df.new(\"John\").to_s #=> Gru\u00df, John!<\/code><\/pre>\n<\/blockquote>\n

<\/font><\/code><\/pre>\n
Crystal ruft das Makro def_to_s<\/strong> zur Kompilierzeit mit der \u00dcbergabe von \"greeting.ecr\".<\/font><\/pre>\n
Das Makro wird hier definiert:<\/font><\/pre>\n
https:\/\/github.com\/crystal-lang\/crystal\/blob\/c9d1eef8fde5c7a03a029d64c8483ed7b4f2fe86\/src\/ecr\/macros.cr<\/a><\/pre>\n
\n
Makro def_to_s(Dateiname)<\/p>\n
  def to_s(__io__)<\/p>\n
     ECR.embed {{Dateiname}}, \"__io__\"<\/font><\/p>\n
  Ende<\/p>\n
Ende<\/p>\n<\/blockquote>\n
wird Ihre Klasse im ersten Schritt wie folgt umgeschrieben:<\/p>\n
\n
erfordern \"ecr\"\n\nclass Begr\u00fc\u00dfung\n  def initialize(@name : String)\n  end\n\n  def to_s(__io__)<\/code><\/pre>\n
    ECR.embed \"gruss.ecr\", \"__io__\"\nend<\/code><\/pre>\n

<\/code><\/pre>\n<\/blockquote>\n
Siehst du, was gerade passiert ist? Deiner Klasse wurde eine to_s-Methode hinzugef\u00fcgt, die ihrerseits ein Makro enth\u00e4lt. Schauen wir uns an, was dieses Makro tut:<\/font><\/code><\/pre>\n
\n
Makro embed(Dateiname, io_name)<\/p>\n
    \\{{ run(\"ecr\/process\", {{filename}}, {{io_name.id.stringify}}) }}<\/p>\n
Ende<\/p>\n<\/blockquote>\n
Dies ist der Hauptaufruf von ECR. Er kompiliert (? \/ f\u00fchrt aus) eine andere Anwendung ecr\/Prozess<\/strong> und \u00fcbergibt ihm Dateiname und io_name als Parameter.<\/p>\n
Die R\u00fcckgabe ist das Ergebnis der Ausgabe dieser Anwendung.<\/p>\n
Was bedeutet der Backslash?<\/p>\n
\"Es ist m\u00f6glich, eine Makro, das eine oder mehrere Makrodefinitionen erzeugt<\/strong>. Sie m\u00fcssen Makroausdr\u00fccke des inneren Makros mit einem vorangestellten Backslash-Zeichen \\ entschl\u00fcsseln, um zu verhindern, dass sie von dem \u00e4u\u00dferen Makro ausgewertet werden.\"<\/p>\n
Es handelt sich im Wesentlichen um ein verschachteltes Makro!<\/p>\n
ecr\/process ist hier definiert:<\/p>\n
https:\/\/github.com\/crystal-lang\/crystal\/blob\/c9d1eef8fde5c7a03a029d64c8483ed7b4f2fe86\/src\/ecr\/process.cr<\/a><\/p>\n
es ist im Wesentlichen ein Wrapper um ECR.process_file (denken Sie daran, dass dies kein Makro mehr ist - dies ist eine Anwendung, deren Ausgabe schlie\u00dflich in Ihren Crystal-Code eingef\u00fcgt wird!)<\/p>\n
ecr\/processor ist hier definiert:<\/p>\n
https:\/\/github.com\/crystal-lang\/crystal\/blob\/c9d1eef8fde5c7a03a029d64c8483ed7b4f2fe86\/src\/ecr\/processor.cr<\/a><\/p>\n
Es verarbeitet die Datei und erstellt eine Zeichenkette, die es zur\u00fcckgibt.<\/p>\n
Hier ein kleiner Auszug:<\/p>\n
\n
str << Puffer_name<\/p>\n
str << " << "<\/p>\n
string.inspect(str)<\/p>\n
str << '\\n'<\/p>\n<\/blockquote>\n
buffer_name ist das, was wir oben an Crystal \u00fcbergeben haben (__io__ - identifiziert durch seine ID in io_name.id.stringify). <\/p>\n
Ausgabe- und Kontrollwerte werden ebenfalls verarbeitet. Au\u00dferdem wird die Debug-Ausgabe f\u00fcr Sie eingef\u00fcgt (mit # als Kommentar):<\/p>\n
\n
append_loc(str, dateiname, zeilen_nummer, spalten_nummer)<\/p>\n<\/blockquote>\n
Im Grunde wird der Code, den Sie in die ECR-Dateien eingeben, direkt in Ihren Code eingef\u00fcgt - an der von Ihnen angegebenen Stelle. Das alles geschieht durch Makros und einen speziellen ECR-Parser.<\/p>\n
Der ECR-Code kennt Ihre Variablen nicht - wenn Sie Bereichsfehler, undefinierte Variablen usw. erhalten, liegt das nicht daran, dass Sie sie nicht an ECR \u00fcbergeben haben, sondern daran, dass sie sich nicht im richtigen Bereich befinden.<\/p>\n
Versuchen Sie das, was Sie mit dem ECR-Code machen wollten, direkt in Ihrem Hauptcode.<\/p>\n
<\/p>\n
Demonstration<\/h1>\n
Hier ist eine Demonstration, wie Sie eine Klasse in Ihrem ECR-Code in Kemal \"verwenden\" k\u00f6nnen. Die Klasse verschachtelt ein zus\u00e4tzliches ECR-Snippet, das mit dem Kontext der Klasse gerendert wird.<\/p>\n
<\/p>\n
die Datei debug.cr:<\/strong><\/p>\n
\n
erfordern \"kemal\"<\/p>\n
require \".\/..\/macros.cr\"<\/p>\n
Modul Fehlersuche
   Makros einbeziehen<\/p>\n
      Klasse DClass
           @test : Zeichenkette 
           def initialize()
               @test = \"Testzeichenfolge\"
           Ende
           ECR.def_to_s \"src\/views\/snippets\/debug_snippet.ecr\"
       Ende<\/p>\n
  get \"\/debug\" do |env|<\/p>\n
    eingeloggt = false<\/p>\n
    mrender \"debug\"
   Ende<\/p>\n
Ende<\/p>\n<\/blockquote>\n
die Datei debug.ecr:<\/strong><\/p>\n
\n
<% content_for “main” do%>
\n
Debug-Informationen<\/h1><\/p>\n
<%= loggedin %>
\n
Eingebauter dekorierter Schnipsel<\/h1><\/p>\n
<%= DClass.new() %><\/p>\n
<% end %><\/p>\n<\/blockquote>\n
den entsprechenden Code f\u00fcr das Makro mrender, definiert in macros.cr:<\/strong><\/p>\n
\n
makro mrender(filename)
   render \"src\/views\/#{{Dateiname}}}.ecr\", \"src\/views\/layout.ecr\"
\nEnde    \n<\/p>\n<\/blockquote>\n
Es verwendet das Makro render von Kemal, mit dem Sie ein Layout f\u00fcr Ihre Ansicht angeben k\u00f6nnen. (Sie brauchen dies nicht unbedingt in Ihrem Code, es wird hier nur der Vollst\u00e4ndigkeit halber angegeben)<\/p>\n
die Datei src\/views\/snippets\/debug_snippet.ecr:<\/strong><\/p>\n
\n
Debug-Schnipsel
\n<\/b><\/p>\n<\/blockquote>\n
<\/p>\n
Das Ergebnis:<\/h2>\n
\"Bild\"<\/a><\/p>\n
Alles zusammengenommen:<\/h2>\n
    \n
  1. Der Benutzer ruft \/debug in seinem Webbrowser auf<\/li>\n
  2. Kemal 's Makro get wird f\u00fcr die Route \"\/debug\" passen. Es ist in meiner debug.cr definiert<\/li>\n
      \n
    1. Die lokale Variable eingeloggt<\/strong> wird auf false gesetzt<\/li>\n
    2. debug.ecr wird von den ECR-Makros verarbeitet und in \"debug.cr\" eingef\u00fcgt (die AST-Darstellung) eingef\u00fcgt, so als ob sie direkt von Ihnen eingegeben worden w\u00e4re<\/li>\n
        \n
      1. die lokale Variable eingeloggt <\/strong>wird als false ausgewertet (zur Laufzeit)<\/li>\n
      2. wir nennen DClass.new()<\/strong>und fragen Sie sie nach ihrer String-Repr\u00e4sentation, die durch die Methode def to_s definiert ist.<\/li>\n
          \n
        1. k\u00f6nnen wir DClass.new() aufrufen, da sie im selben Modul definiert ist, in dem wir gerade ausgef\u00fchrt werden. Stellen Sie sich einfach vor, dass Ihr ECR-Code genau dort, unterhalb der Klassendefinition, eingef\u00fcgt wird.<\/li>\n
        2. wir fragen nach der Darstellung der Zeichenkette, da wir die Syntax  verwenden<\/li>\n<\/ol>\n<\/ol>\n<\/ol>\n<\/ol>\n
          <\/p>\n
          Schauen wir uns nun an, was beim Aufruf von DClass.new passiert:<\/p>\n
                Klasse DClass
                    @test : Zeichenkette 
                     def initialize()
                         @test = \"Testzeichenfolge\"
                     Ende
                     ECR.def_to_s \"src\/views\/snippets\/debug_snippet.ecr\"
                 Ende<\/p><\/blockquote>\n
          Bei der Initialisierung wird eine Zeichenkette @test gesetzt. Dies ist eine Instanz <\/strong>der DClass-Instanz, die wir gerade erstellt haben. (Dass es sich um eine Instanzvariable handelt, erkennen Sie daran, dass ihr ein \"@\" vorangestellt ist. Zwei \"@@\" w\u00fcrden eine Klassenvariable darstellen)<\/p>\n
          Diese Instanzvariable wird in debug_snippet.ecr verwendet \/ angezeigt<\/p>\n
          Wir haben bereits besprochen, wie ECR.def_to_s funktioniert. <\/p>\n
          Nach dem Durchlaufen der Makrophase w\u00fcrde diese Klasse etwa so aussehen:<\/p>\n
                Klasse DClass
                    @test : Zeichenkette 
                     def initialize()
                         @test = \"Testzeichenfolge\"
                     Ende
                     def to_s(__io__)<\/p>\n
                          __io__ << "Debug-Snippet\\n"<\/p>\n
                          __io__ << "\"<\/p>\n
                          __io__ << @test<\/p>\n
                          __io__ << "<\/B>\"<\/p>\n
                     Ende
                 Ende<\/p>\n
          <\/p>\n
          Mit dieser Technik k\u00f6nnen Sie Klassen definieren, um Schnipsel von ECR-Code zu rendern, anstatt jeden Variablennamen manuell einzurichten und zu \u00fcbergeben.<\/p>\n
          Ich hoffe, dass dieser Artikel Ihnen hilft und dass Sie ihn finden, anstatt frustriert zu werden - ich w\u00fcnschte, ich h\u00e4tte so etwas als Leitfaden f\u00fcr meine ersten Schritte gehabt \"L\u00e4cheln\"<\/p>\n
          Referenzen<\/h1>\n
          Bezug auf Kemal:<\/p>\n