Bayeux 0.1.0

data/lib/filters/bayeux.rb

@@ -0,0 +1,44 @@
+###
+### Converts input in Bayeux to HTML
+###
+
+require 'json'
+
+class BayeuxFilter < Nanoc3::Filter
+  identifier :bayeux
+  type :text
+
+  def run(content, params={})
+    syntax_tree = Bayeux.new
+    syntax_tree.parse(content)
+    
+    # Update the master reference list
+    # using the data in the 'new' AST
+    $reference.update(syntax_tree)
+    
+    #puts syntax_tree.to_s
+    #text_gen = BayeuxTextGen.new(syntax_tree)
+    #puts "---"
+    #puts syntax_tree.to_s
+    #puts "---"
+    
+    puts "---"
+    puts JSON.pretty_generate(syntax_tree)
+    puts "---"
+    
+    
+    #latex_gen = BayeuxLatexGen.new(syntax_tree)
+    #puts "---"
+    #puts latex_gen.generate
+    #puts "---"
+    
+    
+    html_gen = BayeuxHTMLGen.new(syntax_tree)
+    
+    # Get the document ToC from the AST (as HTML)
+    @item[:toc] = html_gen.doc_toc
+    
+    # Return the AST rendered in HTML 
+    return html_gen.generate
+  end
+end

data/lib/filters/pandoc.rb

@@ -0,0 +1,23 @@
+###
+### Converts input in Markdown (extended) to HTML, using
+### Pandoc
+###
+
+require 'tempfile'
+
+class PandocFilter < Nanoc3::Filter
+  identifier :pandoc
+  type :text
+
+  def run(content, params={})
+    input_file = Tempfile.new('input')
+
+    input_file << content
+    input_file.close
+
+    output = `pandoc -f markdown -t textile -5 #{input_file.path}`
+
+    return output
+
+  end
+end

data/lib/filters/section_id.rb

@@ -0,0 +1,105 @@
+###
+### Adds section ID's to the HTML output
+###
+
+require "haml"
+
+class SectionIDFilter < Nanoc3::Filter
+  identifier :section_id
+  type :text
+
+  def run(content, params={})
+    parser = HTMLTokenizer.new(content)
+
+    # Table of Contents: Saved for use in the layout
+    toc = ""
+    
+    # Last level of the ToC seen
+    last_toc_level = 0
+    
+    # Final HTML returned for viewing in the browser
+    output = ""
+
+    begin
+      # Get a chunk of text, up to the next tag
+      output << parser.getText
+
+      # Process the header tags
+      next_tag = parser.getNextToken
+      if next_tag.kind_of?(HTMLTag)
+        case next_tag.tag_name
+          when "h1"
+             # Assemble the new header
+             header_text = parser.getTextAndTags("/h1")
+             output << "<h1 id=\"#{header_id(header_text)}\">"
+                          
+             last_toc_level = 1
+          
+          when "h2"
+            # Assemble the new header
+            header_text = parser.getTextAndTags("/h2")
+            output << "<h2 id=\"#{header_id(header_text)}\">"
+            
+            # Add to the Table of Contents
+            if last_toc_level != 2 then
+              toc << "%ul\n"
+            end
+            
+            toc << "%li\n"
+            toc << "  %a{:href => \"##{header_id(header_text)}\"}= \"" << header_text << "\"\n"
+                       
+            last_toc_level = 2
+              
+          when "h3"
+            # Assemble the new header
+            header_text = parser.getTextAndTags("/h3")
+            output << "<h3 id=\"#{header_id(header_text)}\">"
+            
+            # Add to the Table of Contents
+            if last_toc_level != 3 then
+              toc << "  %ul\n"
+            end
+            
+            toc << "    %li\n"
+            toc << "      %a{:href => \"##{header_id(header_text)}\"}= \"" << header_text << "\"\n"
+           
+            last_toc_level = 3
+  
+          when "h4"
+            # Assemble the new header
+            header_text = parser.getTextAndTags("/h4")
+            output << "<h4 id=\"#{header_id(header_text)}\">"
+          
+          when "h5"
+            # Assemble the new header
+            header_text = parser.getTextAndTags("/h5")
+            output << "<h5 id=\"#{header_id(header_text)}\">"
+             
+          when "h6"
+            # Assemble the new header
+            header_text = parser.getTextAndTags("/h6")
+            output << "<h6 id=\"#{header_id(header_text)}\">"
+          
+          else
+            output << next_tag.raw         
+        end
+      end
+
+    end until (parser.peekNextToken.nil?)
+
+    engine = Haml::Engine.new(toc)
+    
+    @item[:toc] = engine.render
+    
+    return output
+  end
+end
+
+# Return the header id, given a string of text
+def header_id(header_text)
+  return header_text.gsub(" ", "_").downcase
+end
+
+
+
+

data/lib/helpers/breadcrumbs.rb

@@ -0,0 +1,64 @@
+include Nanoc3::Helpers::Breadcrumbs
+
+def breadcrumbs_list
+  page_path = breadcrumbs_trail
+  
+  puts "==="
+  @site.items.each{|item|
+    puts "found: #{item.identifier}"
+  }
+  puts "==="
+  
+  # Walk the list of parent items
+  puts "---"
+  item = @item
+  until item.nil? do
+    puts "found: #{item.identifier}"
+    item = item.parent
+  end
+  puts "---"
+  
+  html_list = Array.new
+  html_item = String.new
+  first_item = true
+  
+  # Work out the page path
+  page_path.reverse_each{|path_item|
+    if not path_item.nil? then
+      if first_item then
+        html_item = "<a href=\"#{path_to_url(path_item.attributes[:filename])}\" class=\"current\">" + path_item.attributes[:title] + "</a>"
+        html_list << html_item
+        
+        first_item = false
+      else
+        html_item = "<a href=\"#{path_to_url(path_item.attributes[:filename])}\">" + path_item.attributes[:title] + "</a>"
+        html_list << html_item
+      end
+    end
+  }
+  
+  # Return the path
+  return page_path(html_list)
+end
+
+def path_to_url(path)
+  page_dir = File.dirname(path)
+  return page_dir[13..page_dir.length] + "/" + "index.html"
+end
+
+def page_path(element_list)
+  path = ""
+  first_item = true
+  
+  element_list.reverse_each{|element|
+    if first_item then
+      path << element
+      
+      first_item = false
+    else
+      path << "	&raquo; " << element
+    end
+  }
+  
+  return path
+end

data/lib/helpers/site_toc.rb

@@ -0,0 +1,11 @@
+###
+### Returns the site Table of Contents
+###
+
+require "haml"
+
+def site_toc
+  engine = Haml::Engine.new(@site.config[:site_toc])
+    
+  return engine.render
+end

data/lib/lib/uv.rb

@@ -0,0 +1,92 @@
+#encoding: ascii-8bit
+require 'fileutils'
+require 'textpow'
+require 'uv/render_processor.rb'
+
+
+module Uv
+  class << self
+    attr_accessor :render_path, :theme_path, :syntax_path, :default_style, :syntaxes
+  end
+
+  self.theme_path    = File.join(render_path, 'xhtml', 'files', 'css')
+  self.default_style = 'mac_classic'
+  self.syntaxes      = {}
+  
+  def Uv.path
+    result = []
+    result << File.join(File.dirname(__FILE__), ".." )
+  end
+
+  def self.syntax_node_for(syntax)
+    if !@syntaxes.key?(syntax)
+      filename = File.join(@syntax_path, "#{syntax}.syntax")
+      @syntaxes[syntax] = if File.exist?(filename)
+        Textpow::SyntaxNode.load(filename)
+      else
+        false
+      end
+    end
+    if !@syntaxes[syntax]
+      raise ArgumentError, "No #{syntax}.syntax file in #{@syntax_path}"
+    end
+    @syntaxes[syntax]
+  end
+
+  def Uv.copy_files output, output_dir
+    Uv.path.each do |dir|
+      dir_name = File.join( dir, "render", output, "files" )
+      FileUtils.cp_r( Dir.glob(File.join( dir_name, "." )), output_dir ) if File.exists?( dir_name )
+    end
+  end
+
+  def Uv.syntaxes
+    Dir.glob( File.join(@syntax_path, '*.syntax') ).collect do |f| 
+      File.basename(f, '.syntax')
+    end
+  end
+
+  def Uv.themes
+    Dir.glob( File.join(@theme_path, '*.css') ).collect do |f| 
+      File.basename(f, '.css')
+    end
+  end
+
+  def Uv.syntax_for_file file_name
+    init_syntaxes unless @syntaxes
+    first_line = ""
+    File.open( file_name, 'r' ) { |f|
+      while (first_line = f.readline).strip.size == 0; end
+    }
+    result = []
+    @syntaxes.each do |key, value|
+      assigned = false
+      if value.fileTypes
+        value.fileTypes.each do |t|
+          if t == File.basename( file_name ) || t == File.extname( file_name )[1..-1]
+            result << [key, value] 
+            assigned = true
+            break
+          end
+        end
+      end
+      unless assigned
+        if value.firstLineMatch && value.firstLineMatch =~ first_line
+          result << [key, value] 
+        end
+      end
+    end
+    result
+  end
+
+  def Uv.parse text, output = "xhtml", syntax_name = nil, line_number = 0, render_style = nil, headers = false
+    RenderProcessor.load(output, render_style, line_number, headers) do |processor|
+      syntax_node_for(syntax_name).parse(text, processor)
+    end.string
+  end
+
+  def Uv.debug text, syntax_name
+    syntax_node_for(syntax_name).parse(text, Textpow::DebugProcessor.new)
+  end
+
+end

data/lib/lib/uv/render_processor.rb

@@ -0,0 +1,146 @@
+require 'cgi'
+
+module Uv
+
+  class RenderProcessor
+    @@score_manager = Textpow::ScoreManager.new
+
+    attr_reader :string
+    attr_accessor :escapeHTML
+
+    def self.load(output, style = nil, line_number = 0, headers = false)
+      style  ||= Uv.default_style
+      renderer = File.join( Uv.render_path, output,"#{style}.render")
+      raise( ArgumentError, "Output for #{output} in #{style} style is not yet implemented" ) unless File.exists?(renderer)
+      options   = YAML.load_file(renderer)
+      processor = RenderProcessor.new(options, line_number, headers)
+      yield processor if block_given?
+      processor
+    end
+
+    def initialize render_options, line_number = 0, headers = true, score_manager = nil
+      @score_manager  = score_manager || @@score_manager
+      @render_options = render_options
+      @options        = {}
+      @headers        = headers
+      @escapeHTML     = true
+      
+      @line_numbers = !(line_number.nil? or (line_number == 0))
+      unless @line_numbers then
+        @line_number = 0
+      else
+        @line_number = line_number - 1
+      end
+      
+    end
+    
+    def start_parsing name
+      @stack       = [name]
+      @string      = ""
+      @line        = nil
+      print @render_options["document"]["begin"] if @headers
+      print @render_options["listing"]["begin"]
+      #         opt = options @stack
+      #         print opt["begin"] if opt
+    end
+    
+    def print string
+      @string << string
+    end
+    
+    def escape string
+      if @render_options["filter"]
+        @escaped = string
+        @escaped = self.instance_eval( @render_options["filter"] )
+        @escaped
+      else
+        string
+      end
+    end
+    
+    def open_tag name, position
+      @stack << name
+      print escape(@line[@position...position].gsub(/\n|\r/, '')) if position > @position
+      @position = position
+      opt = options @stack
+      print opt["begin"] if opt
+    end
+    
+    def close_tag name, position
+      print escape(@line[@position...position].gsub(/\n|\r/, '')) if position > @position
+      @position = position
+      opt = options @stack
+      print opt["end"] if opt
+      @stack.pop
+    end
+    
+    def close_line
+      stack = @stack[0..-1]
+      while stack.size > 1
+        opt = options stack
+        print opt["end"] if opt
+        stack.pop
+      end
+    end
+    
+    def open_line
+      stack = [@stack.first]
+      clone = @stack[1..-1]
+      while stack.size < @stack.size
+        stack << clone.shift
+        opt = options stack
+        print opt["begin"] if opt
+      end
+    end
+    
+    def new_line line
+      if @line
+        print escape(@line[@position..-1].gsub(/\n|\r/, ''))
+        close_line
+        print @render_options["line"]["end"]
+        print "\n" 
+      end
+      @position = 0
+      @line_number += 1
+      @line = line
+      print @render_options["line"]["begin"]
+      if @line_numbers
+        print @render_options["line-numbers"]["begin"] 
+        print @line_number.to_s.rjust(4).ljust(5)
+        print @render_options["line-numbers"]["end"] 
+        print " "
+      end
+      open_line
+    end
+    
+    def end_parsing name
+      if @line
+        print escape(@line[@position..-1].gsub(/\n|\r/, '')) 
+        while @stack.size > 1
+          opt = options @stack
+          print opt["end"] if opt
+          @stack.pop
+        end
+        print @render_options["line"]["end"]
+        print "\n"
+      end
+      #         opt = options @stack
+      #         print opt["end"] if opt
+      @stack.pop
+      print @render_options["listing"]["end"]
+      print @render_options["document"]["end"] if @headers
+    end
+    
+    def options stack
+      ref = stack.join ' '
+      return @options[ref] if @options.has_key? ref
+    
+      result = @render_options['tags'].max do |a, b| 
+        @score_manager.score( a['selector'], ref ) <=> @score_manager.score( b['selector'], ref )
+      end
+      result = nil if @score_manager.score( result['selector'], ref ) == 0
+      @options[ref] = result
+    end
+  end
+end
+