TurboGears - Bahasa Template Genshi

Genshi adalah bahasa template berbasis XML. Ini mirip denganKid, yang dulunya adalah mesin templat untuk versi TurboGears sebelumnya. Genshi serta Kid terinspirasi oleh bahasa template terkenal lainnya sepertiHSLT, TAL dan PHP.

Template Genshi terdiri dari arahan pemrosesan. Direktif ini adalah elemen dan atribut dalam template. Arahan Genshi didefinisikan dalam namespacehttp://genshi.edgewall.org/. Oleh karena itu namespace ini perlu dideklarasikan di elemen root template.

<html xmlns = "http://www.w3.org/1999/xhtml"
   xmlns:py = "http://genshi.edgewall.org/"
   lang = "en">
...
</html>

Deklarasi di atas berarti namespace default disetel ke XHTML dan perintah Genshi memiliki awalan 'py'.

Arahan Genshi

Sejumlah arahan didefinisikan dalam Genshi. Daftar berikut menyebutkan arahan Genshi -

py:if
py:choose
py:for
py:def
py:match
py:with
py:replace
py:content
py:attrs
py:strip

Bagian Bersyarat

Genshi menyediakan dua arahan untuk rendering bersyarat dari konten− py: if dan py: pilih.

py: jika

Isi elemen direktif ini hanya akan dirender jika ekspresi dalam if clausemengevaluasi menjadi benar. Dengan asumsi bahwa data dalam konteks templat adalah{‘foo’:True, ‘bar’:’Hello’}, direktif berikut -

<div>
   <b py:if = "foo">${bar}</b>
</div>

akan menghasilkan

Hello

Namun, keluaran ini tidak akan ditampilkan jika ‘foo’ is set to False.

Arahan ini juga dapat digunakan sebagai elemen. Pada kasus ini<py:if> harus ditutup sesuai </py:if>

<div>
   <py:if test = "foo">
      <b>${bar}</b>
   </py:if>
</div>

py: pilih

Pemrosesan bersyarat lanjutan dimungkinkan dengan penggunaan py:choose dalam kombinasi dengan py:when dan py:otherwisearahan. Fitur ini mirip denganswitch – case membangun C/C++.

Ekspresi dalam py:choose direktif diperiksa dengan nilai berbeda yang diidentifikasi dengan py:whenalternatif dan konten terkait akan diberikan. Alternatif default dapat diberikan dalam bentukpy:otherwise pengarahan.

<div py:choose = "foo”>
   <span py:when = "0">0</span>
   <span py:when = "1">1</span>
   <span py:otherwise = "">2</span>
</div>

Contoh berikut mengilustrasikan penggunaan py:choose dan py:whenarahan. Formulir HTML memposting data ke / menandai URL. Itumarks() fungsi mengalihkan tanda dan hasil dalam bentuk objek kamus ke total.htmltemplate. Tampilan bersyaratresult Pass/Fail dicapai dengan menggunakan py:choose dan py:when arahan.

Script HTML memasukkan tanda (marks.html) adalah sebagai berikut -

<html>
   <body>
      <form action = "http://localhost:8080/marks" method = "post">
         <p>Marks in Physics:</p>
         <p><input type = "text" name = "phy" /></p>
         <p>Marks in Maths:</p>
         <p><input type = "text" name = "maths" /></p>
         <p><input type = "submit" value = "submit" /></p>
      </form>
   </body>
</html>

Kode lengkap root.pyadalah sebagai berikut. Itumarks() pengontrol mengirimkan tanda dan hasil ke total.html template -

from hello.lib.base import BaseController
from tg import expose, request

class RootController(BaseController):
   @expose("hello.templates.marks")
      def marksform(self):
      return {}
		
   @expose("hello.templates.total")
      def marks(self, **kw):
      phy = kw['phy']
      maths = kw['maths']
      ttl = int(phy)+int(maths)
      avg = ttl/2
		
      if avg ≥ 50:
         mydata = {'phy':phy, 'maths':maths, 'total':ttl, 'result':2}
      else:
         mydata = {'phy':phy, 'maths':maths, 'total':ttl,'result':1}
	
      return mydata

Itu total.html dalam folder templates menerima data kamus dan mem-parsingnya dalam keluaran html secara bersyarat sebagai berikut -

<html xmlns = "http://www.w3.org/1999/xhtml"
   xmlns:py = "http://genshi.edgewall.org/"
   lang = "en">
	
   <head>
      <title>TurboGears Templating Example</title>
   </head>
	
   <body>
      <h2>Hello, Welcome to TurboGears!.</h2>
      <h3>Marks in Physics: ${phy}.</h3>
      <h3>Marks in Maths: ${maths}.</h3>
      <h3>Total Marks: ${total}</h3>
		
      <div py:choose = "result">
         <span py:when = "1"><h2>Result: Fail</h2></span>
         <span py:when = "2"><h2>Result: Pass</h2></span>
      </div>
		
   </body>
</html>

Mulai server (jika belum berjalan)

Gearbox server –reload –debug

Memasukkan http://localhost::8080/marksform di browser -

Itu total.html akan membuat keluaran berikut -

py: untuk

Elemen di py: untuk direktif diulangi untuk setiap item dalam iterable, biasanya objek Python List. Jikaitems = [1,2,3] hadir dalam konteks template, dapat diulangi dengan mengikuti py: for directive -

<ul>
   <li py:for = "item in items">${item}</li>
</ul>

Output berikut akan dirender -

1
2
3

Contoh berikut menunjukkan data formulir HTML yang dirender dalam total.html template menggunakan py: untuk direktif juga dapat digunakan sebagai berikut -

<py:for each = "item in items">
   <li>${item}</li>
</py:for>

Skrip Formulir HTML

<html>
   <body>
	
      <form action = "http://localhost:8080/loop" method="post">
         <p>Marks in Physics:</p>
         <p><input type = "text" name = "phy" /></p>
         <p>Marks in Chemistry:</p>
         <p><input type = "text" name = "che" /></p>
         <p>Marks in Maths:</p>
         <p><input type = "text" name = "maths" /></p>
         <p><input type = "submit" value = "submit" /></p>
      </form>
		
   </body>
</html>

Itu loop() controller membaca data formulir dan mengirimkannya ke total.template dalam bentuk objek daftar.

from hello.lib.base import BaseController
from tg import expose, request

class RootController(BaseController):
   @expose("hello.templates.marks")
   def marksform(self):
   return {}
	
   @expose("hello.templates.temp")
   def loop(self, **kw):
      phy = kw['phy']
      maths = kw['maths']
      che = kw['che']
      l1 = []
      l1.append(phy)
      l1.append(che)
      l1.append(maths)
		
   return ({'subjects':['physics', 'Chemistry', 'Mathematics'], 'marks':l1})

Template temp.html menggunakan py: for loop untuk merender konten objek dict dalam bentuk tabel.

<html xmlns = "http://www.w3.org/1999/xhtml" 
   xmlns:py = "http://genshi.edgewall.org/" lang = "en">
	
   <body>
      <b>Marks Statement</b>
      <table border = '1'>
         <thead>
            <py:for each = "key in subjects"><th>${key}</th></py:for>
         </thead>
         <tr>
            <py:for each = "key in marks"><td>${key}</td></py:for>
         </tr>
      </table>
   </body>
</html>

Mulai server (jika belum berjalan)

gearbox server –reload –debug

Memasukkan http://localhost::8080/marksform di browser.

Output berikut akan ditampilkan di browser saat formulir di atas dikirimkan.

py: def

Direktif ini digunakan untuk membuat makro. Makro adalah cuplikan kode template yang dapat digunakan kembali. Sama seperti fungsi Python, ia memiliki nama dan secara opsional dapat memiliki parameter. Output dari makro ini dapat disisipkan di sembarang tempat di templat.

Direktif py: def mengikuti sintaks berikut -

<p py:def = "greeting(name)">
   Hello, ${name}!
</p>

Makro ini dapat dirender dengan nilai variabel ke parameter 'name'.

${greeting('world')}
${greeting('everybody)}

Direktif ini juga dapat digunakan dengan versi sintaks lain sebagai berikut -

<py:def function = "greeting(name)">
   <p>Hello, ${name}! </p>
</py:def>

Dalam contoh berikut, macro() pengontrol dalam root.py mengirimkan a dict objek dengan dua kunci name1 dan name2 ke template macro.html.

from hello.lib.base import BaseController
from tg import expose, request

class RootController(BaseController):
   @expose('hello.templates.macro')
   def macro(self):
      return {'name1':'TutorialPoint', 'name2':'TurboGears'}

Template macro.html ini berisi definisi makro yang disebut salam. Ini digunakan untuk menghasilkan pesan ucapan untuk data yang diterima dari pengontrol.

<html xmlns = "http://www.w3.org/1999/xhtml"
   xmlns:py = "http://genshi.edgewall.org/"
   lang = "en">
	
   <body>
      <h2>py:def example</h2>
		
      <div>
         <div py:def = "greeting(name)">
            Hello, Welcome to ${name}!
         </div>
				
         <b>
            ${greeting(name1)}
            ${greeting(name2)}
         </b>
			
      </div>
   </body>
</html>

Mulai server menggunakan gearbox

gearbox serve –reload –debug

Panggil pengontrol makro () dengan memasukkan URL berikut di browser -

http://localhost:8080/macro

Output berikut akan ditampilkan di browser -

py: dengan

Direktif ini memungkinkan Anda menetapkan ekspresi ke variabel lokal. Variabel lokal ini membuat ekspresi di dalam menjadi lebih pendek dan lebih efisien.

Dengan asumsi bahwa x = 50 diberikan dalam data konteks untuk template, berikut akan menjadi py: dengan direktif -

<div>
   <span py:with = "y = 50; z = x+y">$x $y $z</span>
</div>

Ini akan menghasilkan output berikut -

50 50 100

Versi alternatif untuk py: dengan direktif juga tersedia -

<div>
   <py:with = "y = 50; z = x+y">$x $y $z</py:with>
</div>

Dalam contoh berikut, pengontrol makro () mengembalikan objek dict dengan kunci nama, phy, dan matematika.

from hello.lib.base import BaseController
from tg import expose, request

class RootController(BaseController):
   @expose('hello.templates.macro')
   def macro(self):
      return {'name':'XYZ', 'phy':60, 'maths':70}

Template macro.html menambahkan nilai kunci phy dan matematika menggunakan py: dengan direktif.

<html xmlns = "http://www.w3.org/1999/xhtml"
   xmlns:py = "http://genshi.edgewall.org/"
   lang = "en">
	
   <body>
      <h2>py:with example</h2>
      <h3>Marks Statement for : ${name}!</h3>
		
      <b>Phy: $phy Maths: $maths
         <span py:with = "ttl = phy+maths">Total: $ttl</span>
      </b>
		
   </body>
	
</html>

Browser akan membuat keluaran berikut sebagai tanggapan atas URL http://localhost:8080/macro

Arahan Manipulasi Struktur

Itu py:attrs direktif menambahkan, mengubah atau menghapus atribut dari elemen.

<ul>
   <li py:attrs = "foo">Bar</li>
</ul>

Jika foo = {‘class’:’collapse’} hadir dalam konteks template, yang akan dirender cuplikan di atas.

<ul>
   <li class = "collapse">Bar</li>
</ul>

Itu py:content direktif menggantikan konten bersarang dengan hasil evaluasi ekspresi -

<ul>
   <li py:content = "bar">Hello</li>
</ul>

Diberikan bar = 'Bye' dalam data konteks, ini akan menghasilkan

<ul>
   <li>Bye</li>
</ul>

Itu py:replace direktif menggantikan elemen itu sendiri dengan hasil evaluasi ekspresi -

<div>
   <span py:replace = "bar">Hello</span>
</div>

Diberikan bar = 'Bye' dalam data konteks, itu akan menghasilkan

<div>
   Bye
</div>