glyph 0.1.0 → 0.2.0

data/book/text/changelog.glyph

@@ -0,0 +1,76 @@
+%[=
+macro :issue do
+	exact_parameters 2
+	ident, desc = @params
+	encode %{
+		tr[
+			td[\=>[http://github.com/h3rald/glyph/issues/closed#issue/#{ident}\|##{ident}]]
+			td[textile[#{desc}]]
+		]
+	}
+end
+
+macro :features do
+	verb = (@name == :features) ? "Implemented" : "Fixed"
+	total = @node.children.length
+	encode %{
+		section[header[#{total} #{@name.to_s.capitalize} #{verb}]
+			table[
+				tr[
+					th[ID]
+					th[Description]
+				]
+				#@value
+			]
+		]
+	}
+end
+
+macro :release do
+	exact_parameters 3
+	number, date, contents = @params
+	interpret %{
+		section[header[v#{number} – #{date}]
+			#{decode contents}
+		]
+	}
+end
+
+
+macro_alias :bugs => :features
+
+=]--[
+	?[%[lite?]|*[=
+			%:[%>|"#@value macro"]
+			%:[#>|"#@value command"]
+		=]
+	]
+]
+release[0.2.0|May 9th 2010|
+	features[
+		issue[62|A new %>[highlight] is available to highlight source code (CodeRay or UltraViolet requireed).]
+		issue[76|It is now possible to use Glyph programmatically via the new @Glyph#filter@ and @Glyph#compile@ methods.]
+		issue[87|It is now possible to define snippets inside a Glyph source file using the %>[snippet:].]	
+		issue[88|It is now possible to change configuration settings inside a Glyph source file using the %>[config:] (Jabbslad).]	
+		issue[89|It is now possible to compile a single Glyph source file without creating a Glyph project.]
+		issue[92|6 new macros have been defined to allow conditional processing (\.%>[condition], %>[eq], %>[not], %>[and], %>[or], %>[match])]
+		issue[94|It is now possible to add _validators_ to macros, for example to check the number of parameters they take.]
+		issue[97|The #>[compile] command can now take an extra @--auto@ switch to trigger document auto-regeneration whenever a source file is changed (koraktor).]
+		issue[99|Added a @document.draft@ setting. If set to @true@, comments and TODOs are rendered in output files.]
+		issue[100|#[system_css]Glyph CSS files are no longer copied to new projects, but they can be referenced as if they were (see also =>[#css_not_copied|#93]).]
+		issue[108|It is now possible to define Glyph macros within Glyph source files using the %>[macro:].]
+	]
+	bugs[
+		issue[86|Warning and error messages have been updated, and it is now possible to show additional debug information. Additionally, syntax errors are now handled before the document is processed.] 
+		issue[93|#[css_not_copied]Default css files were not copied when creating a new project. The issue has been resolved by allowing the %>[style] to reference Glyph's system styles (see also =>[#system_css|#100]).]
+		issue[95|The #>[config] did not save data to YAML configuration files. This has been fixed ensuring that internal configuration overrides are not saved to the YAML file too.]
+		issue[98|Glyph is now fully compatible with Ruby 1.9.1 and JRuby 1.4.0.]
+		issue[101|Additional tests have been developed to improve Textile support. There should no longer be errors when using textile block elements inside Glyph macros.]
+		issue[103|Fixed a bug that caused test failures when deleting the test project directory.]
+		issue[104|Nested Glyph macros calling @Macro#interpret@ no longer ignore escape delimiters.]
+		issue[107|Added the possibility to encode (using the %>[encode]) and decode (using the %>[decode]) macros so that they can be interpreted later.]
+	]
+]
+release[0.1.0|April 8th 2010|
+	Initial release.
+]

data/book/text/extending.glyph

@@ -0,0 +1,224 @@
+Glyph was created wih extensibility in mind. You can freely extend &[glang] by creating or overriding macros, to do whatever you like. Macro definitions are written in pure Ruby code and placed in @.rb@ files within the @lib/macros/@ folder of your project.
+
+tip[Alternatively, you can also define macros right in your document, using the %>[macro:].]
+
+section[header[Anatomy of a Macro]
+
+This is the source code of a fairly simple macro used to format a note :
+
+<notextile>
+highlight[=ruby|
+macro :note do
+  %{<div class="#{@name}"><span class="note-title">#{@name.to_s.capitalize}</span>
+		#{@value}
+
+    </div>}
+end=]
+</notextile>
+
+The @macro@ method takes a single  @Symbol@ or @String@ parameter, corresponding to the name of the macro. In this case, the entire block (or _body_ of the macro) is a @String@ corresponding to what we want the macro to evaluate to: a @<div>@ tag containing a note. 
+
+The body of the macro is evaluated in the context of the =>[http://yardoc.org/docs/glyph/Glyph/Macro|@Glyph::Macro@] class, therefore its instance variables (like codeph[@name] or codeph[@value]) can be used directly.
+
+box[Why using codeph[@name] instead of just "note"?|
+For the @note@ macro, it absolutely makes no difference. However, by using codeph[@name] it is possible to re-use the same code for the @tip@, @important@ and @caution@ macros as well, which are in fact only aliases of the @note@ macro:
+
+@macro_alias :important => :note@
+@macro_alias :tip => :note@
+@macro_alias :caution => :note@
+] --[End box]
+
+The following table lists all the instance variables that can be used inside macros:
+
+table[
+  tr[
+    th[Variable]
+    th[Description]
+  ]
+  tr[
+    td[codeph[@node]]
+    td[A =>[http://yardoc.org/docs/glyph/Node|@Node@] containing information about the macro, within the document syntax tree. Useful for accessing parent and child macros, and the current =>[http://yardoc.org/docs/glyph/Glyph/Document|@Document@]. Normally, macro nodes contain the following keys:
+* @:name@, the name of the macro.
+* @:value@, the value (i.e. the contents, within the delimiters) of the macro
+* @:source@, a @String@ identifying the source of the macro (a file, a snippet, etc.) 
+* @:document@, the parsed document tree.
+
+Note that the first three keys can also be accessed via instance variables.]
+  ]
+  tr[
+    td[codeph[@name]]
+    td[The name of the macro]
+  ]
+  tr[
+    td[codeph[@value]]
+    td[The full contents (including parameters and nested macros) inside the macro delimiters.]
+  ]
+  tr[
+    td[codeph[@source]]
+    td[A @String@ identifying the source of the macro (a file, a snippet, etc.) ]
+  ]
+  tr[
+    td[codeph[@params]]
+    td[The parameters passed to the macro. In other words, the value of the macro split by pipes (@\|@).]
+  ]
+] --[End Table]
+
+]
+
+section[header[Bookmarks and Headers]
+
+The =>[http://yardoc.org/docs/glyph/Glyph/Macro|@Glyph::Macro@] class also includes a few methods to check and store bookmarks and headers. Consider for example the following source code for the %>[anchor]:
+
+<notextile>
+highlight[=ruby|
+macro :anchor do 
+  ident, title = @params
+  macro_error "Bookmark '#{ident}' already exists" if bookmark? ident
+  bookmark :id => ident, :title => title
+  %{<a id="#{ident}">#{title}</a>}
+end
+=] 
+</notextile>
+
+The @bookmark?@ method can be used to check the existance of a particular ID within the whole document, while the @bookmark@ method is used to store bookmark IDs and titles. In a similar way, you can use @header?@ and @header@ methods to check the existance of headers within the documents or store new ones.
+
+]
+
+section[header[Using Placeholders]
+
+Sometimes you may need to access some data that will not be available until the entire document has been fully parsed and analyzed. For example, in order to be able to validate internal links, it is necessary to know in advance if the bookmark ID referenced in the link exists or not, either before (that's easy) or even _after_ the link. 
+
+Here's the source code of the %>[link]:
+
+<notextile>
+highlight[=ruby|
+macro :link do
+  href, title = @params
+  if href.match /^#/ then
+    anc = href.gsub(/^#/, '').to_sym
+    bmk = bookmark? anc
+    if bmk then
+      title \|\|= bmk[:title]
+    else
+      plac = placeholder do \|document\|
+        macro_error "Bookmark '#{anc}' does not exist" unless document.bookmarks[anc] 
+        document.bookmarks[anc][:title]
+      end
+      title \|\|= plac
+    end
+  end
+  title \|\|= href
+  %{<a href="#{href}">#{title}</a>}
+end
+=]
+</notextile>
+
+If there's already a bookmark stored in the current document, then it is possible to retrieve its title and use it as link text. Otherwise, it is necessary to wait until the entire document has been fully processed and then check if the bookmark exists. To do so, use the @placeholder@ method. When called, this method returns an unique placeholder, which is then substituted with the value of the block, right before the document is finalized.
+
+Within the @placeholder@ block, the @document@ parameter is, by all means, the fully analyzed document.
+]
+
+section[header[Using Validators]
+If you need to make sure that a macro is used properly, consider using =>[http://yardoc.org/docs/glyph/Glyph/Macro/Validators|validators]. These methods can be used anywhere within the macro code to check whether certain conditions are met or not. Some default validators are provided to check the number of parameters of a macro, and they are actually used in some system macros.
+
+If you want to create your own validators, you can call the generic @validate@ method which takes the message to display in case of error, a Hash of options and a block containing the validation to perform.
+
+box[Validating macro placement|
+You can, of course, create your own validators to check whether a macro is used within another. While this may seem a good idea to enforce constraints into the way documents are created, it has one major drawback: if you define a macro with such validation, you're effectively limiting its usage, so for example you won't be able to use within snippets or other custom macros.
+
+Suppose, for example, that the %>[header] is only allowed within a @section@ macro. This means that, for example:
+* the macro cannot be used within @chapter@ or @appendix@ macros.
+* the macro cannot be used in snippets
+
+Even if you consider all the possibilities within the scope of the default macros provided with Glyph, this would also make the @header@ macro unusable within custom macros.
+]
+
+]
+
+section[header[Interpreting Glyph Code]
+
+What if you need to evaluate some Glyph code _within_ a macro? Say for example you want to transform a parameter in a link, and you want to make sure that link gets validated exactly like the others, in this case, you can use the @interpret@ method, as follows:
+
+<notextile>
+highlight[=ruby|
+macro :fmi do
+  topic, href = @params
+  link = placeholder do \|document\| 
+    interpret "link[#{href}]"
+  end
+  %{<span class="fmi">for more information on #{topic}, see #{link}</span>}
+end
+=] 
+</notextile>
+
+When the @interpret@ method is called, the following happens:
+# A new Glyph document is created from the @String@ passed to the method.
+# The bookmarks, headers and placeholders are passed from the main document to the new one. Because they are stored in arrays and hashes, they are passed by reference, so for example any new bookmark stored in the new document will also become available in the main document.
+# Any macro included in the @String@ is evaluated, and the resulting text is returned by the method. Note that this new document does not get finalized: in other words, placeholders will be left as they are, and they'll eventually be replaced when _the main document_ is finalized.
+
+section[header[Encoding and Decoding Glyph Code|encode_decode]
+When you use the @interpret@ method, keep in mind that the code is interpreted _before_ the macro execution ends. This may not always be what you want: if you're nesting macros interpreting @section@ and @header@ macros,for example, your Table of Contents may get messed up, with child sections showing up before their parents. 
+
+To avoid this, you can use the @encode@ and @decode@ methods, as shown in the macros defined for Glyph's =>[http://github.com/h3rald/glyph/blob/master/book/text/changelog.glyph|Changelog]:
+
+<notextile>
+highlight[=ruby|
+macro :issue do
+  exact_parameters 2
+  ident, desc = @params
+  encode %{
+    tr[
+      td[\=>[http://github.com/h3rald/glyph/issues/closed#issue/#{ident}\|##{ident}]]
+      td[textile[#{desc}]]
+    ]
+  }
+end
+
+macro :features do
+  verb = (@name == :features) ? "Implemented" : "Fixed"
+  total = @node.children.length
+  encode %{
+    section[header[#{total} #{@name.to_s.capitalize} #{verb}]
+      table[
+        tr[
+          th[ID]
+          th[Description]
+        ]
+        #@value
+      ]
+    ]
+  }
+end
+
+macro :release do
+  exact_parameters 3
+  number, date, contents = @params
+  interpret %{
+    section[header[v#{number} &ndash; #{date}]
+      #{decode contents}
+    ]
+  }
+end
+=]
+</notextile>
+
+In this case, @issue@ macros are nested within a @features@ macro, which in turn is nested within a @release@ macro. Note that none of these macros have any side effect: they are just used for text expansion. Because we're always going to nest these macros in this way, there's no to have each one interpret Glyph code: it will be the @release@ macro's job to do so. Instead, the @features@ and @issue@ macros just encode text which will then be decoded by the @release@ macro, before being interpreted. 
+
+When you _encode_ a macro, its delimiters (@\[@, @\]@, and @\|@) will be escaped (into ‡\.‡¤\.91\.¤‡\.‡, ‡\.‡¤\.93\.¤‡\.‡, and ‡\.‡¤\.124\.¤‡\.‡ respectively), and when you _decode_ it, they will be unescaped. In a nutshell, you may want to use the encode/decode mechanism when:
+* When you're nesting macros interpreting Glyph code, without side effects.
+* When all you want is to copy some Glyph code from child macros into their parents.
+
+note[These methods are also wrapped in the %>[encode] and in the %>[decode].]
+]
+]
+
+section[header[Further Reading]
+
+For more examples on how to create more complex macros, have a look at the =>[http://github.com/h3rald/glyph/tree/master/macros/|source code] of the existing ones.
+
+To gain a deeper understanding on how macros are executed, have a look at the following Glyph classes:
+* =>[http://yardoc.org/docs/glyph/Glyph/Macro|@Glyph::Macro@]
+* =>[http://yardoc.org/docs/glyph/Glyph/Interpreter|@Glyph::Interpreter@]
+* =>[http://yardoc.org/docs/glyph/Glyph/Document|@Glyph::Document@]
+* =>[http://yardoc.org/docs/glyph/Glyph/Node|@Node@]
+]

data/book/text/{getting_started.textile → getting_started.glyph}

@@ -12,15 +12,15 @@ That's it. You just created a new Glyph project in the @test_document@ directory
 
 box[Glyph's dependencies|
 Glyph requires the following gems:
-- extlib
-- gli
-- treetop
-- rake
+* extlib
+* gli
+* treetop
+* rake
 
 Additionally, some Glyph macros may require additional gems, such as:
-- RedCloth (_textile_ macro)
-- Maruku _or_ Kramdown _or_ BlueCloth (_markdown_ macro)
-- Haml (if you want to load .sass files with the _style_ macro)
+* RedCloth (\.%>[textile])
+* BlueCloth _or_ RDiscount _or_ Maruku _or_ Kramdown (\.%>[markdown])
+* Haml (if you want to load .sass files with the %>[style])
 ]
 
 Every Glyph project is comprised of the following directories:
@@ -33,15 +33,15 @@ Every Glyph project is comprised of the following directories:
 Additionally, the following files are also created at top level:
 * @config.yml@ -- containing your =>[#cfg|Project Configuration].
 * @document.glyph@ -- containing your =>[#struct|Document Structure]
-* @snippets.yml@ -- containing your text snippets. todo[Link to Snippets section]
+* @snippets.yml@ -- containing your text =>[#incl|snippets].
 
 ]
 
 section[header[Document Structure|struct]
 
-Every Glyph project contains a @document.glyph@ file that is typically used to define the document structure. The default @document.glyph@
-generated automatically when creating a new project is the following:
+Every Glyph project contains a @document.glyph@ file that is typically used to define the document structure. The default @document.glyph@ generated automatically when creating a new project is the following:
 
+<notextile>
 code[=
 document[
   head[style[default.css]]
@@ -72,17 +72,19 @@ document[
     ]
   ]
 ]=]
+</notextile>
+
 
 Even without knowing anything about &[glang], you can easily figure out that this file defines a document with a Table of Contents, a Preface and some Chapters. @frontmatter\[\]@, @preface\[\]@, @chapter\[\]@, etc. are all Glyph _macros_ used to define -- in this case -- some structural elements. In practice, this means that if you plan to generate an HTML document, they'll be converted into @<div>@ tags.
 
 Be aware that other macros, on the other hand, are used to do something completely different, e.g.:
 * @toc\[\]@ generates the document's Table of Contents
-* codeph[=@\[\]=] or its alias @include\[\]@ is used to copy the contents of another file stored anywhere in the @/text@ directory.
+* codeph[=@\[\]=] or its alias @include\[\]@ is used to copy the contents of another file stored anywhere in the @text/@ directory.
 
 Let's now analyze this @document.glyph@ more in detail.
 * The @document\[\]@ macro wraps every other macro. This is necessary to create the initial @<html>@ tag.
 * Similarly, @head\[\]@ and @body\[\]@ are used to generate the respective HTML tags. Actually, @head\[\]@ already sets some metadata for you, by default (author and copyright).
-* Within @head\[\]@, the @style\[\]@ macro is used to load the @default.css@ stylesheet, which is included by default the @/styles@ directory of every Glyph project.
+* Within @head\[\]@, the @style\[\]@ macro is used to load the @default.css@ stylesheet, which is one of the =>[#default_styles|default Glyph styleseets].
 * Immediately after the @body\[\]@ macro, the @titlepage\[\]@ macro is used to define (guess...) the first page of your document. @title\[\]@, @author\[\]@  and @pubdate\[\]@ insert the title of the document, its author and the publication date (retrieved from the project's =>[#cfg|configuration settings]).
 * Then, the @frontmatter\[\]@, @bodymatter\[\]@ and @backmatter\[\]@ macros are used to further divide the portions of your document according to the rules of =>[http://en.wikipedia.org/wiki/Book_design|book design]. They are not mandatory, but they can be used, for example, to number your appendixes with letters instead of numbers and similar.
 * @preface\[\]@, @chapter\[\]@, @appendix\[\]@ are just a way to wrap content in @<div>@ tags, from an HTML point of view, but they are also necessary to nest the content of your document and generate the Table of Contents automatically, together with the @header\[\]@ macro.
@@ -100,9 +102,9 @@ When compiling, Glyph loads all these configuration files and merges them accord
 * A setting configured in the _Project Configuration_ overrides the same setting in both Global and System configuration.
 * A setting configured in the _Global Configuration_ overrides the same setting in the _System Configuration_
 
-Typically, you should use the _Project Configuration_ for all project-specific settings and the _Global Configuration_ for settings affecting all your projects (for example, you may want to set 'document.author' in the Global Configuration instead of setting it in the Project Configuration of all your Glyph projects). The _System Configuration_ is best left untouched.
+Typically, you should use the _Project Configuration_ for all project-specific settings and the _Global Configuration_ for settings affecting all your projects (for example, you may want to set the $>[document.author] in the Global Configuration instead of setting it in the Project Configuration of all your Glyph projects). The _System Configuration_ is best left untouched.
 
-Instead of editing your configuration settings directly, you can use the @glyph config@ command, as follows:
+Instead of editing your configuration settings directly, you can use the #>[config], as follows:
 
 @glyph config@ _setting_ _\[value\]_
 
@@ -112,23 +114,27 @@ To change the value of a configuration setting, specify a value right after the
 
 @glyph config document.author "John Smith"@
 
+tip[It is also possible to change configuration settings inside your document, using the %>[config:].]
+
 In this way, the document author will be set to _John Smith_ for the current project. To save this setting globally, add a @-g@ option, like this:
 
 @glyph config -g document.author "John Smith"@
 
 box[Regarding configuration values and data types...|
 Glyph attempts to "guess" the data type of a configuration values by evaluation (@Kernel#instance_eval@) if the value:
-- is wrapped in quotes (@"@ or @'@) &rarr; String
-- starts with a colon (@:@) &rarr; Symbol
-- is wrapped in square brackets (@\[@ and @\]@) &rarr; Array
-- is wrapped in curly brackets (@\{@ and @\}@) &rarr; Hash
-- is _true_ or _false_ &rarr; Boolean
-- If the value is _nil_ &rarr; NilClass
+* is wrapped in quotes (@"@ or @'@) &rarr; @String@
+* starts with a colon (@:@) &rarr; @Symbol@
+* is wrapped in square brackets (@\[@ and @\]@) &rarr; @Array@
+* is wrapped in curly brackets (@{@ and @}@) &rarr; @Hash@
+* is _true_ or _false_ &rarr; @Boolean@
+* is _nil_ &rarr; @NilClass@
 
 Note that this guessing is far from being foolproof: If you type something like _{:test, 2}_, for example, you'll get an error. 
 ]
 
-There are plenty of configuration settings that can be modified, but most of them are best if left alone (and in the System Configuration file). For a complete reference, see =>[#cfg_ref]. Normally, you may just want to change the following ones:
+There are plenty of configuration settings that can be modified, but most of them are best if left alone (and in the System Configuration file). 
+
+For a complete reference, see =>[#cfg_ref]. Normally, you may just want to change the following ones:
 
 table[
 	tr[
@@ -136,15 +142,15 @@ table[
 		th[Description]
 	]
 	tr[
-		td[*document.author*]
+		th[@document.author@]
 		td[The author of the document]
 	]
 	tr[
-		td[*document.title*]
+		th[@document.title@]
 		td[The title of the document]
 	]
 	tr[
-		td[*document.filename*]
+		th[@document.filename@]
 		td[The document file name]
 	]
 ]

data/book/text/{introduction.textile → introduction.glyph}

@@ -1,10 +1,13 @@
-Glyph is a _Rapid Document Authoring Framework_. 
+--[
+&:[prince|=>[http://www.princexml.com/|Prince]]
+
+]Glyph is a _Rapid Document Authoring Framework_. 
 
 Think of it like a sort of =>[http://www.rubyonrails.org|Ruby on Rails] but for creating text documents instead of web sites. With Glyph, you can manage your documents tidily in _projects_ that can be used to generate deliverables in different formats such as HTML or PDF (through &[prince]).
 
 section[header[Main Features]
 
-Glyph uses a =>[#macros_nutshell|simple macro system] to perform a wide variety of advanced tasks:
+Glyph uses a simple macro system to perform a wide variety of advanced tasks:
 * Generate block-level HTML tags not commonly managed by lightweight markups, like @head@, @body@, @div@ and @table@.
 * Create and validate internal and external links.
 * Include and validate images and figures.
@@ -13,11 +16,15 @@ Glyph uses a =>[#macros_nutshell|simple macro system] to perform a wide variety
 * Store common snippets of text in a single YAML file and use them anywhere in your document, as many times as you need.
 * Store configuration settings in a YAML file and use them anywhere in your document, as many times as you need.
 * Evaluate Ruby code within your document.
-* Call macros from other macros (including snippets), carefully avoiding mutual calls.
+* Include content only if certain conditions are satisfied.
+* Define macros, snippets and configuration settings directly within your document.
+* Highlight source code.
+* Call macros from other macros (including snippets), avoiding mutual calls.
 * Include text files in other text files.
-* Include the contents of configuration settings (author, title) in the document.
+* Include the value of any configuration setting (like author, title) in the document.
 * Filter input explicitly or implicitly, based on file extensions when including files. 
-* Manage comments and todo items.
+* Manage draft comments and todo items.
+
 ]
 
 section[header[Installation]
@@ -28,12 +35,14 @@ section[header[Installation]
 
 section[header[Essential Glyph commands]
 
-Glyph is 100% command line. Its interface resambles =>[http://git-scm.com/|Git's] for its simplicity and power (thanks to the =>[http://github.com/davetron5000/gli|Gli] gem). Here are some example commands: 
+Glyph is 100% command line. Its interface resambles =>[http://git-scm.com/|Git's] for its simplicity and power (thanks to the =>[http://github.com/davetron5000/gli|gli] gem). Here are some example commands: 
 
 * @glyph init@ -- to initialize a new Glyph project in the current (empty) directory.
 * @glyph add introduction.textile@ -- to create a new file called _introduction.textile_.
 * @glyph compile@ -- to compile the current document into a single HTML file.
+* @glyph compile --auto@ -- to keep recompiling the current document every time a file is changed.
 * @glyph compile -f pdf@ -- to compile the current document into HTML and then transform it into PDF using &[prince].
+* @glyph compile readme.glyph@ -- to compile a _readme.glyph_ located in the current directory into a single HTML file.
 
 ]
 
@@ -48,18 +57,17 @@ section[header[Something about Glyph]
 You can use Glyph macros in conjunction
  with _Textile_ or _Markdown_ to
 produce HTML files effortlessly.
-  section[header[What about PDFs?|pdf]
+  section[header[What about PDFs?\|pdf]
 Once you have a single, well-formatted HTML 
 file, converting it to PDF is
 extremely easy with a 3rd-party 
-renderer like =>[http://www.princexml.com|Prince].
+renderer like =>[http://www.princexml.com\|Prince].
   ]   
 ]
 =]
 
 **HTML Output:**
 
-<notextile>
 code[=
 <div class="section">
   <h2 id="h_10">Something about Glyph</h2>
@@ -74,7 +82,7 @@ code[=
       like <a href="http://www.princexml.com">Prince</a>.</p>
   </div>
 </div>
-=]</notextile>
+=]
 ]
 
 section[header[Resources]
@@ -82,7 +90,9 @@ section[header[Resources]
 * Home Page: =>[http://www.h3rald.com/glyph/]
 * Repository: =>[http://www.github.com/h3rald/glyph/]
 * Bug Tracking: =>[http://www.github.com/h3rald/glyph/issues]
-* Book (PDF): =>[http://github.com/h3rald/glyph/raw/master/book/output/pdf/glyph.pdf]
-* Reference Documentation: =>[http://yardoc.org/docs/h3rald-glyph/]
+* Development Wiki =>[http://wiki.github.com/h3rald/glyph]
+* RubyGem Download =>[http://www.rubygems.org/gems/glyph]
+* Book (PDF): =>[http://github.com/h3rald/glyph/raw/\.%[Glyph::VERSION.strip]/book/output/pdf/glyph.pdf]
+* Reference Documentation: =>[http://yardoc.org/docs/glyph/]
 * User Group: =>[http://groups.google.com/group/glyph-framework]
 ]