glyph 0.3.0 → 0.4.0

data/book/text/extending/further_reading.glyph

@@ -1,5 +1,3 @@
-section[
-	@title[Further Reading]
 	txt[
 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.
 
@@ -10,4 +8,3 @@ To gain a deeper understanding on how macros are executed, have a look at the fo
 * class[Glyph::Document]
 * class[Glyph::Macro]
 	]
-]

data/book/text/extending/internals.glyph

@@ -1,8 +1,6 @@
-section[
-	@title[A quick look at Glyph's internals]
 	p[If you plan on extending Glyph, knowing how it works inside helps. It is not mandatory by any means, but it definitely helps, especially when creating complex macros.]
 	p[What happens behind the scenes when you call code[glyph compile]? Glyph's code is parsed, analyzed and then translated into text, and here's how:]
-	figure[document_generation.png|A sequence diagram for document generation]
+	figure[glyph/document_generation.png|A sequence diagram for document generation]
 	txt[From the diagram, it is possible to divide the document generation process into three phases:
 * The _Parsing Phase_ starts when a chunk of Glyph code is passed (by the code[generate:document] Rake task, for example) to a class[Glyph::Interpreter]. The interpreter initializes a class[Glyph::Parser] that parses the code and returns an _Abstract Syntax Tree_ (AST) of class[Glyph::SyntaxNode] objects.
 * The _Analysis Phase_ (Processing) starts when the interpreter method calls the @analyze@ method, instantiating a new class[Glyph::Document]. The @Glyph::Document@ object evaluates the AST expanding all macro nodesth (that's when macros are executed) and generates string.
@@ -67,7 +65,8 @@ section[
 		]
 		p[Finally, when the document is finalized, placeholders and escape sequences are removed and the final result is the following:]
 		highlight[=html|
-<span class="fmi">for more information on something, see <a href="#test">Test Section</a></span>
+<span class="fmi">for more information on something, 
+  see <a href="#test">Test Section</a></span>
 [...]
 <div class="section">
 <h2 id="test">Test Section</h2>
@@ -76,4 +75,3 @@ section[
 </div>
 	=]
 	]
-]

data/book/text/extending/interpreting.glyph

@@ -1,6 +1,3 @@
-section[
-	@title[Interpreting Glyph Code]
-	@id[interpreting]
 
 	txt[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:]
 
@@ -48,4 +45,3 @@ rewrite:[issue\|
 		p[Within the %>[rewrite:], it is possible to use a special syntax to call the code[raw_attr] or code[raw_param] methods: br[]
 			code[{{]em[parameter_number] or em[attribute_name]code[}}]]
 	]
-]

data/book/text/extending/layouts.glyph

@@ -0,0 +1,68 @@
+txt[
+When generating =>[#topics|topic]-based outputs, Glyph uses _layouts_ to render topics as standalone documents. By default, the following two layout are used:
+* code[topic] -- used to render standard topics.
+* code[index] -- used to render the index page of your document.
+
+Layouts are nothing more than "fancy" Glyph macros defined using the Glyph language (i.e. by using =>[#rewriting|macro rewriting]) within a single code[.glyph] file.
+]
+section[
+	@title[Topic Layout]
+	p[The default layout used to render all web topics (the layout used for web5 topics is very similar) is defined as follows:]
+	highlight[=html|
+document[
+  head[
+    style[default.css]
+  ]
+  body[
+    @class[topic]
+    section[
+      @title[{{title}}]
+      @id[{{id}}]
+      navigation[{{id}}]
+{{contents}}
+      navigation[{{id}}]
+    ]
+  ]
+]
+	=]
+	txt[Note that it takes the following attributes, passed automatically by Glyph when processing each topic:
+* code[title] -- the title of the topic.
+* code[id] -- the ID of the topic.
+* code[contents] -- the body of the topic.
+	]
+]
+section[
+	@title[Index Layout]
+	@id[index_layout]
+	p[The default layout used to render the web index page (the layout used for the web5 index is very similar) is defined as follows:]
+	highlight[=html|
+document[
+  head[
+    style[default.css]
+  ]
+  body[
+    @class[topic]
+    halftitlepage[
+      title[]
+      subtitle[]
+      author[]
+    ]
+    frontmatter[
+      toc[]
+    ]
+  ]
+]
+	=]
+	p[Index layouts do not take any attribute or parameter (basically because they are used to produce only one page).]
+]
+section[
+	@title[Creating a Custom Layout]
+	txt[
+To create a custom layout, proceed as follows:
+* Create a @.glyph@ file in the @lib/layouts@ directory, within your project, e.g. @mytopic.glyph@
+* Add the layout code, making sure (for topic layouts) that all the attributes (@title@, @id@, @contents@) are specified correctly.
+* Set the @output.*.layouts.topic@ setting to the name of the new layout (@mytopic@).
+	]
+	tip[You can override which layout to use on a specific topic by specifying it in a code[@layout] attribute.]
+]
+

data/book/text/extending/macro_def.glyph

@@ -1,6 +1,3 @@
-section[
-	@title[Defining Macros]
-	@id[macro_def]
 	txt[
 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.
 
@@ -60,5 +57,3 @@ Note that the first two keys can also be accessed via instance variables.
     td[A code[String] identifying the source of the macro (a file, a snippet, etc.).]
   	]
 	]
-]
-

data/book/text/extending/output_format.glyph

@@ -0,0 +1,78 @@
+txt[
+As shown in =>[#cmd_tasks_arch], the #>[compile] command calls specific tasks defined in the @generate:@ Rake namespace to generate output files in a particular format.
+
+More specifically, when a @--format@ option is specified, the command looks for a task with the same name within the @generate:@ namespace. This makes adding new output formats to Glyph a fairly easy task, without the need to specify custom commands or similar. 
+
+The following sections explain how the @h3rald@ output format was created to integrate this book into the =>[http://www.h3rald.com|H3RALD.com] website.
+]
+section[
+	@title[Output Configuration]
+	txt[
+The first step required to add a new output format to Glyph is extending Glyph's configuration by adding the appropriate output hash, as follows:
+	]
+	highlight[=yaml|
+:output: 
+  :h3rald: 
+    :multifile: true
+    :extension: '.html'
+    :filter_target: 'html'
+    :base: '/glyph/book/'
+    :macro_dirs: ['html']
+    :layout_dirs: ['web']
+    :layouts: 
+      :topic: bookpage
+      :index: bookindex
+	=]
+	txt[
+In particular, the following keys are mandatory:
+* multifile
+* extension
+* filter_target
+* base
+* macro_dirs
+* layout_dirs
+	]
+]
+section[
+	@title[Creating a 'generate:h3rald' task]
+	txt[
+The next (and final) step involves creating a custom @h3rald@ task within the @generate:@ namespace. This task can be placed in any @.rake@ file within the @lib/tasks@ directory:
+	]
+	highlight[=ruby|
+namespace :generate do
+  desc "Create output for h3rald.com integration"
+  task :h3rald => [:web] do
+    dir = Glyph::PROJECT/'output/h3rald'
+    (dir/"glyph/book").mkpath
+    # Copy files in subdir
+    (dir).find do \|i\|
+      if i.file? then
+        next if 
+          i.to_s.match(Regexp.escape(dir/'glyph')) \|\| 
+          i.to_s.match(Regexp.escape(dir/'images')) \|\| 
+          i.to_s.match(Regexp.escape(dir/'styles'))
+        dest = dir/"glyph/book/#{i.relative_path_from(Glyph::PROJECT/dir)}"
+        src = i.to_s
+        Pathname.new(dest).parent.mkpath
+        file_copy src, dest
+      end
+    end
+    # Remove files
+    dir.children.each do \|c\|
+      unless [dir/'glyph', dir/'images', dir/'styles'].include? c then
+        c.directory? ? c.rmtree : c.unlink
+      end
+    end
+    (dir/'images/glyph/glyph.eps').unlink 
+    (dir/'images/glyph/glyph.svg').unlink
+    # Create project page
+    project = Glyph.filter %{layout:project[
+        @contents[#{file_load(Glyph::PROJECT/'text/introduction.glyph')}]
+      ]}
+    file_write dir/"glyph.textile", project
+  end  
+end
+	=]
+	p[In this case, this task does not actually renders files in a different format, it just moves the files generated by the @generate:web@ task in different subdirectories.]
+	p[Additionally, it also generates the =>[http://www.h3rald.com/glyph/|Glyph project page] from the book's introduction (note the usage of a raw custom layout macro).]
+]

data/book/text/extending/params_attrs.glyph

@@ -1,5 +1,3 @@
-section[
-	@title[Parameters and Attributes]
 	txt[
 Perhaps the most common things to do in a macro definition is accessing parameters and attributes. When doing so, it is important to consider whether we want to retrieve the _raw value_ of and attribute or parameter or its _expanded value_. The difference between the two will become clearer in the following sections and also in the =>[#interpreting] section.
 	]
@@ -67,4 +65,3 @@ To access raw values, use the following methods:
 * @raw_attribute@ (or @raw_attr@): Returns the attribute value of the attribute specified by name.
 		]
 	]
-]

data/book/text/extending/placeholders.glyph

@@ -1,5 +1,3 @@
-section[
-	@title[Using Placeholders]
 	txt[
 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. 
 
@@ -30,5 +28,3 @@ If there's already a bookmark stored in the current document, then it is possibl
 
 Within the @placeholder@ block, the @document@ parameter is, by all means, the fully analyzed document.
 	]
-]
-

data/book/text/extending/task.glyph

@@ -0,0 +1,46 @@
+txt[
+Glyph relies on =>[http://rake.rubyforge.org/|Rake] to perform most of its core operations. Typically, Rake tasks are used do define the high level logic that is used by Glyph commands to, for example, compile a project or load configuration files.
+
+Furthermore, Rake provides an easy mechanism to create dependencies among tasks: for example, to make sure that Glyph's configuration files are loaded before everything else happens.
+]
+section[
+	@title[Creating a 'custom:generate' task]
+	@id[custom_generate_task]
+	txt[
+A custom task has been defined for the Glyph project used to produce this document. This custom task is used to compile a few of the documents files into standalone files, deployed in Glyph's root folder:
+* @book/text/introduction.glyph@ → @README.textile@
+* @book/text/changelog.glyph@ → @CHANGELOG.textile@
+* @book/text/license.glyph@ → @LICENSE.textile@
+* @book/text/acknowledgement.glyph@ → @AUTHORS.textile@
+
+First of all, create a @lib/tasks@ folder in your project directory. Then, create a @.rake@ file within it, e.g. @tasks.rake@. 
+
+Finally, here's the source of the task:
+	]
+	highlight[=ruby|
+namespace :custom do
+  task :generate, [:file] do \|t, args\|
+    generate = lambda do \|source, destination\|
+      Glyph.info "Generating #{destination}..."
+      Glyph.compile Glyph::PROJECT/"text/#{source}.glyph", 
+        Glyph::PROJECT/"../#{destination}.textile"
+    end
+    files = {
+      :AUTHORS => :acknowledgements, 
+      :CHANGELOG => :changelog, 
+      :LICENSE => :license, 
+      :README => :introduction
+    }
+    arg = args[:file].upcase.to_sym
+		raise RuntimeError, "Unknown file '#{arg}.glyph'" 
+      unless files.keys.include? arg
+		generate.call files[arg], arg
+    Glyph.info "Done."
+  end
+end
+	=]
+	txt[
+That's it. Note that this task is pretty useless without a command that calls it, and it won't even show up if you run @rake -T@ within your project directory. fmi[creating custom commands|#custom_command].
+	]
+]
+

data/book/text/extending/validators.glyph

@@ -1,16 +1,15 @@
-section[
-	@title[Using Validators]
 	p[If you need to make sure that a macro is used properly, consider using =>[&[yardoc]/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.]
 	p[If you want to create your own validators, you can call the generic code[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|
 		txt[
-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.
+You can, of course, create your own validators to check whether a macro is used directly 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 %>[box] is only allowed within a @section@ macro. This means that, for example:
+Suppose, for example, that the %>[box] is only allowed directly under 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 @box@ macro unusable within custom macros.
+Even if you consider all the possibilities within the scope of the default macros provided with Glyph, this could still make the @box@ macro unusable within custom macros. 
+
+For the specific cases where a macro does not make sense unless is within another (e.g. the %>[eq]), a @within@ validator is used. Note though, that this validator only checks that the macro is used within another, but it is not necessarily its child.
 		]
 	]
-]

data/book/text/getting_started/configuration.glyph

@@ -1,6 +1,3 @@
-section[
-	@title[Project Configuration]
-	@id[cfg]
 
 	textile[
 Glyph stores configuration settings in the following YAML files:
@@ -18,7 +15,7 @@ Instead of editing your configuration settings directly, you can use the #>[conf
 
 @glyph config@ _setting_ _\[value\]_
 
-If no _value_ is specified, glyph prints the value of the configuration setting, so typing @glyph config document.author@ right after creating a project (assuming you didn't set this in the Global Configuration) will print nothing, because this setting is blank by default.
+If no _value_ is specified, Glyph prints the value of the configuration setting, so typing @glyph config document.author@ right after creating a project (assuming you didn't set this in the Global Configuration) will print nothing, because this setting is blank by default.
 
 To change the value of a configuration setting, specify a value right after the setting, like this:
 
@@ -46,4 +43,3 @@ There are plenty of configuration settings that can be modified, but most of the
 
 For a complete reference, see =>[#cfg_ref]. For everyday use, you may just want to change the settings defined in the =>[#cfg_document] namespace.
 	] --[End textile]
-]

data/book/text/getting_started/create_project.glyph

@@ -1,7 +1,4 @@
-section[
-	@title[Creating your first Glyph Project]
-
-	textile[
+textile[
 To install Glyph, simply run @gem install glyph@, like with any other Ruby gem. Then, create a new directory and initialize a new Glyph project, like so:
 
 @mkdir@ _==test_document==_
@@ -37,5 +34,4 @@ Additionally, the following files are also created at top level:
 * @config.yml@ -- containing your =>[#cfg|Project Configuration].
 * @document.glyph@ -- containing the =>[#struct|structure] of your document.
 * @snippets.yml@ -- containing your text =>[#incl|snippets].
-	]
 ]

data/book/text/getting_started/structure.glyph

@@ -1,6 +1,3 @@
-section[
-	@title[Document Structure]
-	@id[struct]
 
 	p[Every Glyph project contains a code[document.glyph] file that is typically used to define the document structure. The default code[document.glyph] generated automatically when creating a new project is the following:]
 
@@ -52,4 +49,3 @@ More specifically, in this @document.glyph@ file:
 * Then, the code[@frontmatter], code[@bodymatter], and code[@backmatter] attributes are used to 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 through code[@title] attributes.
 	]
-]

data/book/text/introduction.glyph

@@ -1,63 +1,45 @@
-&:[prince|=>[http://www.princexml.com/|Prince]]
-Glyph is a _Rapid Document Authoring Framework_. 
-
-With Glyph, you can manage your documents tidily in _projects_ and generate deliverables in different formats such as HTML or PDF (through &[prince]).
-
-section[
-@title[Main Features]
-
-Glyph comes with its very own 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.
-* Automatically determine header levels based on the document structure.
-* Automatically generate a Table of Contents based on the document structure.
-* 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.
-* 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 within other text files.
-* Include the value of any configuration setting (like author, title) in the document.
-* Filter input explicitly or implicitly (based on file extensions). 
-* Manage draft comments and todo items.
-* Provide a simple, less-verbose syntax to write XML code.
-
-]
-
-section[
-@title[Installation]
-
-@gem install glyph@ -- simple, as always.
-
-]
-
-section[
-@title[Essential Glyph commands]
-
+.[
+	&:[prince|=>[http://www.princexml.com/|Prince]]
+	&:[wkhtml|=>[http://code.google.com/p/wkhtmltopdf/|wkhtmltopdf]]
+	macro:[=?txt|
+if Glyph.lite? then
+	interpret "section[#{raw_value}]"
+else
+	interpret "txt[#{raw_value}]"
+end  
+	=]
+	macro:[=?sep|
+if Glyph['document.output'] == "h3rald" then
+	%{<br style="clear:both" />}
+end
+	=]
+]?txt[Glyph is a _Rapid Document Authoring Framework_. 
+
+With Glyph, creating and maintaining any kind of document becomes as easy as... _programming_. Glyph enables you to minimize text duplication, focus on content rather than presentation, manage references seamlessly and automate tedious tasks through a simple but effective macro language, specifically geared towards customization and extensibility.
+
+	?sep[]
+
+	section[
+		@title[Main Features]
+
+		section[
+			@title[Command Line Interface]
 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 -f pdf@ -- to compile the current document into HTML and then transform it into PDF.
 * @glyph compile readme.glyph@ -- to compile a _readme.glyph_ located in the current directory into a single HTML file.
 * @glyph outline -l 2@ -- Display the document outline, up to second-level headers.
+* @glyph stats@ -- Display project statistics.
+		]
 
-]
-
-section[
-@title[Glyph macros in a nutshell]
-@id[macros_nutshell]
-
-Format your documents using Textile or Markdown, and use Glyph Macros to do everything else:
-
-**Glyph Source:**
-
-codeblock[=
+		section[
+			@title[Minimalist Syntax]
+Glyph syntax rules can be explained using Glyph itself:
+			codeblock[=
 section[
   @title[Something about Glyph]
   txt[
@@ -65,24 +47,22 @@ You can use Glyph macros in conjunction
 with _Textile_ or _Markdown_ to
 produce HTML files effortlessly.
   ]
-  p[
-Alternatively, you can just use em[Glyph itself]
-to generate HTML tags.
-  ]
+  p[Alternatively, you can just use em[Glyph itself] to generate HTML tags.]
   section[
     @title[What about PDFs?]
     @id[pdf]
+    p[
 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].
+extremely easy with a free 3rd-party 
+renderer like =>[http://www.princexml.com\|Prince] 
+or =>[http://code.google.com/p/wkhtmltopdf/\|wkhtmltopdf].
+    ]
   ]   
 ]
-=]
-
-**HTML Output:**
-
-codeblock[=
+			=]
+The Glyph code above corresponds to the following HTML code:
+				codeblock[=
 <div class="section">
   <h2 id="h_10">Something about Glyph</h2>
   <p>
@@ -90,32 +70,77 @@ codeblock[=
     <em>Textile</em> or <em>Markdown</em> to
     produce HTML files effortlessly.
   </p>
+  <p>
+    Alternatively, you can just use <em>Glyph itself</em>
+    to generate HTML tags.
+  </p>
   <div class="section">
    <h3 id="pdf">What about PDFs?</h3>
    <p>
      Once you have a single, well-formatted HTML 
      file, converting it to PDF is
-     extremely easy with a 3rd-party renderer 
-     like <a href="http://www.princexml.com">Prince</a>.
-   </p>
-   <p>
-     Alternatively, you can just use <em>Glyph itself</em>
-     to generate HTML tags.
+     extremely easy with a free 3rd-party renderer 
+     like <a href="http://www.princexml.com">Prince</a> 
+     or <a href="http://code.google.com/p/wkhtmltopdf/\">wkhtmltopdf</a>.
    </p>
   </div>
 </div>
-=]
+			=]
+		]
+
+		section[
+			@title[Content Reuse]
+Finding yourself repeating the same sentence over an over? Glyph allows you to create snippets. Within snippets. Within other snippets (and so on, for a long long time...) as long as you don't define a snippet by defining itself, which would be kinda nasty (and Glyph would complain!):
+			codeblock[=
+snippet:[entities\|snippets and macros]
+snippet:[custom_definitions\|
+	p[Glyph allows you to define your own &[entities].]
 ]
-
-section[
-@title[Resources]
-
+&[custom_definitions]
+			=]
+		...which results in:
+			codeblock[=
+<p>Glyph allows you to define your own snippets and macros.</p>
+			=]
+		If yourself dreaming about _parametric_ snippets, just create your own macros (see the =>[http://github.com/h3rald/glyph/blob/master/book/text/changelog.glyph|source] of Glyph's changelog, just to have an idea).
+		]
+		section[
+		@title[Automation of Common Tasks]
+If you're writing a book, you shouldn't have to worry about pagination, headers, footers, table of contents, section numbering or similar. Glyph understands you, and will take care of everything for you (with a little help from CSS3, sometimes).
+		]
+		section[
+		@title[Reference Validation]
+Feel free to add plenty of links, snippets, bookmarks, ... if Glyph doesn't find something, it will definitely complain. Broken references are a thing on the past, and you don't need to worry about it.
+		]
+		section[
+			@title[Extreme Extensibility]
+* You miss a code[=!!!=] macro to format really, _really_ important things? Create it. In under 3 seconds, in Ruby or Glyph itself. And yes, you can use special characters, too.
+* You want your own, very special special @glyph create --everything@ command to create all _you_ need in a Glyph project? You can do it. Using your own Rake tasks, too.
+* You want Glyph to output ODF files? You can do it, and you'll be able to run @glyph generate -f odf@. This would probably require a little more time, but it's trivial, from a technical point of view.
+		]
+		section[
+			@title[Convention over Configuration]
+Put your text files in @/text@, your images in @/images@, add custom macros in a @macro@ folder within your @/lib@ folder... you get the picture: Glyph has its special places.
+
+Nonetheless, you also have 1 (_one_) configuration file to customize to your heart's content (with smart defaults).
+		]	
+		section[
+		@title[Free and Open Source]
+Glyph is 100% Open Source Software, developed using the Ruby Programming Language and licensed under the very permissive terms of the =>[http://www.opensource.org/licenses/mit-license.php|MIT License].
+
+If you have Ruby installed, just run @gem install glyph@. That's all it takes.
+		]
+	]
+	section[
+		@title[Resources]
 * Home Page: =>[http://www.h3rald.com/glyph/]
 * Repository: =>[http://www.github.com/h3rald/glyph/]
 * Bug Tracking: =>[http://www.github.com/h3rald/glyph/issues]
 * 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/h3rald-glyph/]
+* Book (PDF): =>[http://github.com/downloads/h3rald/glyph/glyph.pdf]
+* Book (Web): =>[http://www.h3rald.com/glyph/book/]
+* Reference Documentation: =>[http://rubydoc.info/gems/glyph/]
 * User Group: =>[http://groups.google.com/group/glyph-framework]
+	]
 ]