User defined filters works now :-)

Example included.

Manifest.txt

@@ -52,6 +52,7 @@ app_generators/codex/templates/dp.SyntaxHighlighter/Styles/TestPages.css
 app_generators/codex/templates/dp.SyntaxHighlighter/Templates/Test.dwt
 app_generators/codex/templates/dp.SyntaxHighlighter/VB.html
 app_generators/codex/templates/dp.SyntaxHighlighter/XML.html
+app_generators/codex/templates/filters/example_filter.rb
 app_generators/codex/templates/html/all.html
 app_generators/codex/templates/readme.txt
 app_generators/codex/templates/slides/basics.slides
@@ -61,6 +62,7 @@ app_generators/codex/templates/slides/including_code.slides
 app_generators/codex/templates/slides/including_tex.slides
 app_generators/codex/templates/slides/metadata.yml
 app_generators/codex/templates/slides/table_of_contents.slides
+app_generators/codex/templates/slides/user_defined.slides
 app_generators/codex/templates/ui/default/blank.gif
 app_generators/codex/templates/ui/default/bodybg.gif
 app_generators/codex/templates/ui/default/framing.css

app_generators/codex/codex_generator.rb

@@ -24,7 +24,7 @@ def manifest
       # Create stubs
       m.template_copy_each %w[Rakefile]
       m.template_copy_each "html/all.html"
-      %w[basics building example including_code including_tex table_of_contents].each do |slide|
+      %w[basics building example including_code including_tex table_of_contents user_defined].each do |slide|
         m.file_copy_each "slides/#{slide}.slides"
       end
       m.file_copy_each "slides/metadata.yml"
@@ -53,7 +53,7 @@ def manifest
         "pretty.css", "print.css", "s5-core.css", "slides.css", "slides.js"].each do |asset|
           m.file_copy_each "ui/default/#{asset}"
         end
-
+      m.template_copy_each "filters/example_filter.rb"
 
       m.dependency "install_rubigen_scripts", [destination_root, 'codex'],
         :shebang => options[:shebang], :collision => :force

app_generators/codex/templates/bin/pressie.rb

@@ -4,4 +4,7 @@
 require 'rubygems'
 require "codex"
 
+# Load user defined filters
+Dir.glob(Dir.pwd + "/filters/*.rb").each { |f| require f }
+
 Codex::Pressie::process

app_generators/codex/templates/filters/example_filter.rb

@@ -0,0 +1,13 @@
+# This is _my_ example filter. Define your own ;-)
+
+class TestFilter < Codex::Filter
+        tag :test
+
+        def filter_inline(text,args)
+                text.reverse
+        end
+
+        def filter_single(args)
+            args.reverse
+        end
+end

app_generators/codex/templates/slides/table_of_contents.slides

@@ -13,3 +13,8 @@ h1. Creating Slideshows
 h1. An Example     
 
 * "Some Sample Slides":example.html
+
+h1. Extra filters
+
+* "The Ritex filter":including_tex.html
+* "Defining your own":user_defined.html

app_generators/codex/templates/slides/user_defined.slides

@@ -0,0 +1,44 @@
+h1. User-defined filters
+
+h1. User-defined filters
+
+* Allow you to create your own @filters@ and @tags@
+* They go in the filters/ directory
+* There already is an example filter there
+
+h1. Example filter
+
+<div style="width: 50%; float: right">
+
+:code filters/example_filter.rb[class=code-normal]
+
+</div>
+
+
+<div style="width: 50%">
+
+* Declare a class which inherits from @Codex::Filter@
+** Set the tag you wish to use
+** Implement @filter_inline(text,args)@ 
+** Implement @filter_single(args)@
+** You can omit filter_single if you just want it to load a file and parse it through filter_inline
+
+</div>
+
+It's _that_ simple.
+
+h1. Using your filter
+
+You can now use your tags in your slides:
+
+:inlinecode
+ :inlinetest
+  Reverse this text
+ :endinlinetest
+:endinlinecode
+
+The result is:
+
+:inlinetest
+Reverse this text
+:endinlinetest

lib/codex.rb

@@ -5,4 +5,5 @@ module Codex; end
 
 require 'codex/content'
 require 'codex/pressie'
-require 'codex/filter'
+require 'codex/filter'
+require 'codex/ritex_filter'

lib/codex/content.rb

@@ -62,7 +62,7 @@ def initialize(original)
   def to_html
     textile = preprocess_inlinecode(@original)
     textile = preprocess_code(textile)
-    textile = preprocess_inlinetex(textile)
+    textile = Codex::Filters.instance.filter_all(textile)
     content = split_into_slides(textile)
     html = RedCloth.new(content).to_html
     remove_code_escaping_from(html)
@@ -108,35 +108,6 @@ def preprocess_inlinecode(text)
     result.join("\n")
   end
 
-  def preprocess_inlinetex(text)
-    state = :copying
-    inline_tex = []
-    result = []
-    parser = Ritex::Parser.new
-
-	  text.split(/\n/).each do |line|
-	    case state
-	    when :copying
-	      if line =~ /^:inlinetex/
-	        inline_tex = []
-	        state = :incode
-	      else
-	        result << line
-	      end
-	    when :incode
-	      if line =~ /^:endinlinetex/
-	        result << parser.parse(inline_tex.join("\n"))
-	        parser.flush_macros
-	        state = :copying
-	      else
-	        inline_tex << line
-	      end
-	    end
-	  end
-
-	  result.join("\n")
-  end
-
   def split_into_slides(textile)
     result = []
     slides = textile.split(/^h1/).each do |slide|

lib/codex/filter.rb

@@ -1,20 +1,22 @@
-# This is an abstract class for user defined filters.
-# It lets them declare the tag they wish to use.
+require 'singleton'
+
 module Codex 
+  # Filter is an abstract class for user defined filters.
+  # It lets them declare the tag they wish to use.
+  # When declaring a tag, it also registers with Filters.
   class Filter
+    attr_accessor :tag
     def self.tag(tag)
+      @tag = tag
       (Filters.instance)[tag] = self.new
     end
   end
 
+  # Filters contains a hash of all loaded filters. It does all parsing of the input file
+  # and send chunks to be filtered to the individual filters.
   class Filters
-    @@instance = nil
-    attr_accessor :filter_file_tags, :filter_inline_tags, :filter_inline_end_tags
-
-    def self.instance
-      @@instance = self.new if @@instance.nil?
-      @@instance
-    end
+    include Singleton
+    attr_accessor :filter_file_tags, :filter_inline_tags, :filter_inline_end_tags, :log
 
     def []=(idx,val)
       @filters[idx] = val
@@ -24,26 +26,29 @@ def [](idx)
       @filters[idx]
     end
 
-    # Look for :inlinecode /.../:endinlinecode and substitute in as if it came from a file
+    # Parse the input text and parse chunks over to filters when encountering tags
     def filter_all(text)
       state = :copying
       result = []
       tagged_lines = []
+      tag = args = nil
       text.split(/\n/).each do |line|
         case state
         when :copying
           if line =~ inline_tag
             tag = $1
             args = $2.strip
-            state = :inside_tags
+            state = :inside_tag
           elsif line =~ single_tag
-            result << @filters[tag].filter_single()
+            tag = $1
+            args = $2.strip
+            result << @filters[tag.to_sym].filter_single(args)
           else
             result << line
           end
-        when :inside_tags
+        when :inside_tag
           if line =~ /^:end/ # :endwhatever or just plain :end
-            result << @filters[tag].filter_inline(args, tagged_lines)
+            result << @filters[tag.to_sym].filter_inline(tagged_lines.join("\n"),args)
             tagged_lines = []
             state = :copying
           else
@@ -54,26 +59,28 @@ def filter_all(text)
 
       result.join("\n")
     end
-
+
+    # Creates instance and loads all the user-defined filters in the generated filter/ subdirectory
     private
     def initialize
       @filters = {}
-      # Load all user filters:
-      Dir.glob("filters/*.rb").each { |f| require f }
+    end
+
+    # Create regular expression to match single tags (tags with no end tag)
+    def single_tag
+      @single_tag_regex = tag_regexp if @single_tag_regex.nil?
+      @single_tag_regex
     end
 
+    # Create regular expression to match inline tags. By convention these are all prefixed "inline"
     def inline_tag
       @inline_tag_regex = tag_regexp("inline") if @inline_tag_regex.nil?
       @inline_tag_regex
     end
-
-    def single_tag
-      @single_tag_regex = tag_regexp if @single_tag_regex.nil?
-      @single_tag_regex    
-    end
-
+
+    # Does the actually work of creating matcher regular expressions
     def tag_regexp(prefix = "")
-      Regexp.new("^:#{prefix}(" + (@filters.map { |idx,filter| filter.tag.to_s }).join('|') + ")(.*)")
+      Regexp.new("^:#{prefix}(" + (@filters.map { |tag,filter| tag.to_s }).join('|') + ")(.*)")      
     end
   end
 end

lib/codex/ritex_filter.rb

@@ -4,10 +4,12 @@ class RitexFilter < Codex::Filter
   tag :webtex
 
   def filter_single(text,args)
+    puts "filter single"
     Ritex::Parser.new.parse(text)
   end
 
   def filter_inline(text,args)
+    puts "filter inline"
     Ritex::Parser.new.parse(text)
   end
 end

test/test_codex.rb

@@ -8,4 +8,4 @@ def setup
   def test_truth
     assert true
   end
-end
+end

test/test_filter.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestFilters < Test::Unit::TestCase
+  def setup
+  end
+
+  def teardown
+  end
+
+  def test_truth
+    assert true
+  end
+
+end