[Checkins] SVN: grok/www/minitutorials/ Syntax highlighting for
macro and searching implemented (thanks also to Uli).
Darryl Cousins
darryl at darrylcousins.net.nz
Sat Aug 4 19:47:40 EDT 2007
Log message for revision 78590:
Syntax highlighting for macro and searching implemented (thanks also to Uli).
Changed:
U grok/www/minitutorials/macros.html
U grok/www/minitutorials/searching.html
-=-
Modified: grok/www/minitutorials/macros.html
===================================================================
--- grok/www/minitutorials/macros.html 2007-08-04 23:46:33 UTC (rev 78589)
+++ grok/www/minitutorials/macros.html 2007-08-04 23:47:40 UTC (rev 78590)
@@ -75,18 +75,19 @@
macros. Macros generally are attributes of the page template wherein they
are defined, but to get them rendered, we usually use views.</p>
<p>We define a view <tt class="docutils literal"><span class="pre">MyMacros</span></tt> the usual way in <tt class="docutils literal"><span class="pre">app.py</span></tt>:</p>
-<pre class="literal-block">
-import grok
+<pre class="code-block python literal-block">
+<span class="k">import</span> <span class="nn">grok</span>
-class Sample(grok.Application, grok.Container):
- pass
+<span class="k">class</span> <span class="nc">Sample</span><span class="p">(</span><span class="n">grok</span><span class="o">.</span><span class="n">Application</span><span class="p">,</span> <span class="n">grok</span><span class="o">.</span><span class="n">Container</span><span class="p">):</span>
+ <span class="k">pass</span>
-class Index(grok.View):
- pass # see app_templates/index.pt
+<span class="k">class</span> <span class="nc">Index</span><span class="p">(</span><span class="n">grok</span><span class="o">.</span><span class="n">View</span><span class="p">):</span>
+ <span class="k">pass</span> <span class="c"># see app_templates/index.pt</span>
-class MyMacros(grok.View):
- """The macro holder"""
- grok.context(Sample) # The default model this view is bound to.
+<span class="k">class</span> <span class="nc">MyMacros</span><span class="p">(</span><span class="n">grok</span><span class="o">.</span><span class="n">View</span><span class="p">):</span>
+ <span class="sd">"""The macro holder"""</span>
+ <span class="n">grok</span><span class="o">.</span><span class="n">context</span><span class="p">(</span><span class="n">Sample</span><span class="p">)</span> <span class="c"># The default model this view is bound to.</span>
+
</pre>
<p>In the associated page template <tt class="docutils literal"><span class="pre">app_templates/mymacros.pt</span></tt> we
define the macros we like to have available. You define macros with
@@ -99,16 +100,17 @@
metal:define-slot=<slot-name>
</pre>
<p>Let's define a very plain page macro:</p>
-<pre class="literal-block">
-<html metal:define-macro="mypage">
- <head></head>
- <body>
+<pre class="code-block html literal-block">
+<span class="nt"><html</span> <span class="na">metal:define-macro=</span><span class="s">"mypage"</span><span class="nt">></span>
+ <span class="nt"><head></head></span>
+ <span class="nt"><body></span>
The content:
- <div metal:define-slot="mycontent">
+ <span class="nt"><div</span> <span class="na">metal:define-slot=</span><span class="s">"mycontent"</span><span class="nt">></span>
Put your content here...
- </div>
- </body>
-</html>
+ <span class="nt"></div></span>
+ <span class="nt"></body></span>
+<span class="nt"></html></span>
+
</pre>
<p>Here we defined a single macro <tt class="docutils literal"><span class="pre">mypage</span></tt> with only one slot
<tt class="docutils literal"><span class="pre">mycontent</span></tt>.</p>
@@ -136,9 +138,10 @@
metal:use-macro="<macro-location>"
</pre>
<p>Our <tt class="docutils literal"><span class="pre">app_templates/index.pt</span></tt> can be that simple:</p>
-<pre class="literal-block">
-<html metal:use-macro="context/@@mymacros/mypage">
-</html>
+<pre class="code-block html literal-block">
+<span class="nt"><html</span> <span class="na">metal:use-macro=</span><span class="s">"context/@@mymacros/mypage"</span><span class="nt">></span>
+<span class="nt"></html></span>
+
</pre>
<p>Watching:</p>
<pre class="literal-block">
@@ -152,16 +155,17 @@
<blockquote>
metal:fill-slot="<slot-name>"</blockquote>
<p>where the slot-name must be defined in the macro. Now, change
-<tt class="docutils literal"><span class="pre">indext.pt</span></tt> to:</p>
-<pre class="literal-block">
-<html metal:use-macro="context/@@mymacros/mypage">
- <body>
- <!-- slot 'mybody' was defined in the macro above -->
- <div metal:fill-slot="mybody">
+<tt class="docutils literal"><span class="pre">index.pt</span></tt> to:</p>
+<pre class="code-block html literal-block">
+<span class="nt"><html</span> <span class="na">metal:use-macro=</span><span class="s">"context/@@mymacros/mypage"</span><span class="nt">></span>
+ <span class="nt"><body></span>
+ <span class="c"><!-- slot 'mybody' was defined in the macro above --></span>
+ <span class="nt"><div</span> <span class="na">metal:fill-slot=</span><span class="s">"mybody"</span><span class="nt">></span>
My content from index.pt
- </div>
- </body>
-</html>
+ <span class="nt"></div></span>
+ <span class="nt"></body></span>
+<span class="nt"></html></span>
+
</pre>
<p>and you will get the output:</p>
<pre class="literal-block">
@@ -219,12 +223,13 @@
objects of (nearly) any type and thus be accessed from any
other page template, just set a very general context for your macro
view:</p>
-<pre class="literal-block">
-from zope.interface import Interface
-import grok
+<pre class="code-block python literal-block">
+<span class="k">from</span> <span class="nn">zope.interface</span> <span class="k">import</span> <span class="n">Interface</span>
+<span class="k">import</span> <span class="nn">grok</span>
-class Master(grok.View):
- grok.context(Interface)
+<span class="k">class</span> <span class="nc">Master</span><span class="p">(</span><span class="n">grok</span><span class="o">.</span><span class="n">View</span><span class="p">):</span>
+ <span class="n">grok</span><span class="o">.</span><span class="n">context</span><span class="p">(</span><span class="n">Interface</span><span class="p">)</span>
+
</pre>
<p>and reference the macros of the associated pagetemplate like this:</p>
<pre class="literal-block">
@@ -244,22 +249,23 @@
good style to provide this slots with your homegrown views as well.</p>
<p>To give your pages standard Zope3 look, you can do something like
this in your page template:</p>
-<pre class="literal-block">
-<html metal:use-macro="context/@@standard_macros/page">
- <head>
- <title metal:fill-slot="title">
+<pre class="code-block html literal-block">
+<span class="nt"><html</span> <span class="na">metal:use-macro=</span><span class="s">"context/@@standard_macros/page"</span><span class="nt">></span>
+ <span class="nt"><head></span>
+ <span class="nt"><title</span> <span class="na">metal:fill-slot=</span><span class="s">"title"</span><span class="nt">></span>
Document Title
- </title>
- <metal:headers fill-slot="headers">
- <!-- Additional headers here... -->
- </metal:headers>
- </head>
- <body>
- <div metal:fill-slot="body">
+ <span class="nt"></title></span>
+ <span class="nt"><metal:headers</span> <span class="na">fill-slot=</span><span class="s">"headers"</span><span class="nt">></span>
+ <span class="c"><!-- Additional headers here... --></span>
+ <span class="nt"></metal:headers></span>
+ <span class="nt"></head></span>
+ <span class="nt"><body></span>
+ <span class="nt"><div</span> <span class="na">metal:fill-slot=</span><span class="s">"body"</span><span class="nt">></span>
Your content here...
- </div>
- </body>
-</html>
+ <span class="nt"></div></span>
+ <span class="nt"></body></span>
+<span class="nt"></html></span>
+
</pre>
</div>
Modified: grok/www/minitutorials/searching.html
===================================================================
--- grok/www/minitutorials/searching.html 2007-08-04 23:46:33 UTC (rev 78589)
+++ grok/www/minitutorials/searching.html 2007-08-04 23:47:40 UTC (rev 78590)
@@ -70,91 +70,95 @@
<p>Some applications might require specific versions of catalog. This is specified
in the "setup.py" script. The following directive indicates that zc.catalog
version 1.1.1 is required.</p>
-<pre class="literal-block">
-install_requires=['setuptools',
- 'grok',
- 'zc.catalog==1.1.1',
- 'hurry.query',
- 'hurry.workflow',
- ],
+<pre class="code-block python literal-block">
+<span class="n">install_requires</span><span class="o">=</span><span class="p">[</span><span class="s">'setuptools'</span><span class="p">,</span>
+ <span class="s">'grok'</span><span class="p">,</span>
+ <span class="s">'zc.catalog==1.1.1'</span><span class="p">,</span>
+ <span class="s">'hurry.query'</span><span class="p">,</span>
+ <span class="s">'hurry.workflow'</span><span class="p">,</span>
+ <span class="p">],</span>
+
</pre>
<p>The "hurry.query" package gives you some simple tools to perform advanced
searching. (add "hurry.query" to "zcml=" in "buildout.cfg")</p>
</div>
<div class="section">
<h2><a id="example" name="example">Example</a></h2>
-<pre class="literal-block">
-# interfaces.py
-class IProtonObject(Interface):
- """
+<pre class="code-block python literal-block">
+<span class="c"># interfaces.py</span>
+<span class="k">class</span> <span class="nc">IProtonObject</span><span class="p">(</span><span class="n">Interface</span><span class="p">):</span>
+ <span class="sd">"""
This is an interface to the class who's objects I want to index.
- """
- body = schema.Text(title=u'Body', required=False)
+ """</span>
+ <span class="n">body</span> <span class="o">=</span> <span class="n">schema</span><span class="o">.</span><span class="n">Text</span><span class="p">(</span><span class="n">title</span><span class="o">=</span><span class="s">u'Body'</span><span class="p">,</span> <span class="n">required</span><span class="o">=</span><span class="bp">False</span><span class="p">)</span>
+
</pre>
-<pre class="literal-block">
-# protonobject.py
-class ProtonObject(grok.Model):
- """
+<pre class="code-block python literal-block">
+<span class="c"># protonobject.py</span>
+<span class="k">class</span> <span class="nc">ProtonObject</span><span class="p">(</span><span class="n">grok</span><span class="o">.</span><span class="n">Model</span><span class="p">):</span>
+ <span class="sd">"""
This is the actual class.
- """
- interface.implements(interfaces.IProtonObject)
+ """</span>
+ <span class="n">interface</span><span class="o">.</span><span class="n">implements</span><span class="p">(</span><span class="n">interfaces</span><span class="o">.</span><span class="n">IProtonObject</span><span class="p">)</span>
- def __init__(self, body):
- self.body = body
+ <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">body</span><span class="p">):</span>
+ <span class="bp">self</span><span class="o">.</span><span class="n">body</span> <span class="o">=</span> <span class="n">body</span>
+
</pre>
-<pre class="literal-block">
-# app.py
-from hurry.query.query import Query, Text
-# hurry.query is a simplified search query language that
-# allows you to create ANDs and ORs.
+<pre class="code-block python literal-block">
+<span class="c"># app.py</span>
+<span class="k">from</span> <span class="nn">hurry.query.query</span> <span class="k">import</span> <span class="n">Query</span><span class="p">,</span> <span class="n">Text</span>
+<span class="c"># hurry.query is a simplified search query language that</span>
+<span class="c"># allows you to create ANDs and ORs.</span>
-class ContentIndexes(grok.Indexes):
- """
+<span class="k">class</span> <span class="nc">ContentIndexes</span><span class="p">(</span><span class="n">grok</span><span class="o">.</span><span class="n">Indexes</span><span class="p">):</span>
+ <span class="sd">"""
This is where I setup my indexes. I have two indexes;
one full-text index called "text_body",
one field index called "body".
- """
- grok.site(ProtonCMS)
+ """</span>
+ <span class="n">grok</span><span class="o">.</span><span class="n">site</span><span class="p">(</span><span class="n">ProtonCMS</span><span class="p">)</span>
- grok.context(interfaces.IProtonObject)
- # grok.context() tells Grok that objects implementing
- # the interface IProtonObject should be indexed.
+ <span class="n">grok</span><span class="o">.</span><span class="n">context</span><span class="p">(</span><span class="n">interfaces</span><span class="o">.</span><span class="n">IProtonObject</span><span class="p">)</span>
+ <span class="c"># grok.context() tells Grok that objects implementing</span>
+ <span class="c"># the interface IProtonObject should be indexed.</span>
- grok.name('proton_catalog')
- # grok.name() tells Grok what to call the catalog.
- # if you have named the catalog anything but "catalog"
- # you need to specify the name of the catalog in your
- # queries.
+ <span class="n">grok</span><span class="o">.</span><span class="n">name</span><span class="p">(</span><span class="s">'proton_catalog'</span><span class="p">)</span>
+ <span class="c"># grok.name() tells Grok what to call the catalog.</span>
+ <span class="c"># if you have named the catalog anything but "catalog"</span>
+ <span class="c"># you need to specify the name of the catalog in your</span>
+ <span class="c"># queries.</span>
- text_body = index.Text(attribute='body')
- body = index.Field(attribute='body')
- # The attribute='body' parameter is actually unnecessary if the attribute to
- # be indexed has the same name as the index.
+ <span class="n">text_body</span> <span class="o">=</span> <span class="n">index</span><span class="o">.</span><span class="n">Text</span><span class="p">(</span><span class="n">attribute</span><span class="o">=</span><span class="s">'body'</span><span class="p">)</span>
+ <span class="n">body</span> <span class="o">=</span> <span class="n">index</span><span class="o">.</span><span class="n">Field</span><span class="p">(</span><span class="n">attribute</span><span class="o">=</span><span class="s">'body'</span><span class="p">)</span>
+ <span class="c"># The attribute='body' parameter is actually unnecessary if the attribute to</span>
+ <span class="c"># be indexed has the same name as the index.</span>
-class Index(grok.View):
- grok.context(ProtonCMS)
+<span class="k">class</span> <span class="nc">Index</span><span class="p">(</span><span class="n">grok</span><span class="o">.</span><span class="n">View</span><span class="p">):</span>
+ <span class="n">grok</span><span class="o">.</span><span class="n">context</span><span class="p">(</span><span class="n">ProtonCMS</span><span class="p">)</span>
- def search_content(self, search_query):
- # The following query does a search on the field index "body".
- # It will return a list of object where the entire content of the body attribute
- # matches the search term exactly. I.e. search_query == body
- result_a = Query().searchResults(
- query.Eq(('proton_catalog', 'body'), search_query)
- )
+ <span class="k">def</span> <span class="nf">search_content</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">search_query</span><span class="p">):</span>
+ <span class="c"># The following query does a search on the field index "body".</span>
+ <span class="c"># It will return a list of object where the entire content of the body attribute</span>
+ <span class="c"># matches the search term exactly. I.e. search_query == body</span>
+ <span class="n">result_a</span> <span class="o">=</span> <span class="n">Query</span><span class="p">()</span><span class="o">.</span><span class="n">searchResults</span><span class="p">(</span>
+ <span class="n">query</span><span class="o">.</span><span class="n">Eq</span><span class="p">((</span><span class="s">'proton_catalog'</span><span class="p">,</span> <span class="s">'body'</span><span class="p">),</span> <span class="n">search_query</span><span class="p">)</span>
+ <span class="p">)</span>
- # The following query does a search on the full-text index "text_body".
- # It will return objects that match the search_query. You can use wildcards and
- # boolean operators.
- #
- # Examples:
- # "grok AND zope" returns objects where "body" contains the words "grok" and "zope"
- # "grok or dev*" returns objects where "body" contains the word "grok" or any word
- # beginning with "dev"
- result_b = Query().searchResults(
- Text( ('proton_catalog', 'text_body'), search_query)
- )
+ <span class="c"># The following query does a search on the full-text index "text_body".</span>
+ <span class="c"># It will return objects that match the search_query. You can use wildcards and</span>
+ <span class="c"># boolean operators.</span>
+ <span class="c">#</span>
+ <span class="c"># Examples:</span>
+ <span class="c"># "grok AND zope" returns objects where "body" contains the words "grok" and "zope"</span>
+ <span class="c"># "grok or dev*" returns objects where "body" contains the word "grok" or any word</span>
+ <span class="c"># beginning with "dev"</span>
+ <span class="n">result_b</span> <span class="o">=</span> <span class="n">Query</span><span class="p">()</span><span class="o">.</span><span class="n">searchResults</span><span class="p">(</span>
+ <span class="n">Text</span><span class="p">(</span> <span class="p">(</span><span class="s">'proton_catalog'</span><span class="p">,</span> <span class="s">'text_body'</span><span class="p">),</span> <span class="n">search_query</span><span class="p">)</span>
+ <span class="p">)</span>
- return result_a, result_b
+ <span class="k">return</span> <span class="n">result_a</span><span class="p">,</span> <span class="n">result_b</span>
+
</pre>
</div>
<div class="section">
More information about the Checkins
mailing list