Bayeux 0.1.0

data/lib/bayeux/text_gen.rb

@@ -0,0 +1,307 @@
+require 'facets'
+
+class BayeuxTextGen
+  
+  # Default Constructor
+  def initialize(syntax_tree)
+    @syntax_tree = syntax_tree
+    @text_string = String.new
+    @text = String.new
+  end
+  
+  # Return the AST as an HTML string (stored in @text_string)
+  def generate
+    
+    # Create a walker for the trees in the forest
+    walker = TreeWalker.new
+    
+    walker.on_before_down = self.method(:generate_node_start)
+    walker.on_after_up = self.method(:generate_node_end)
+    
+    walker.on_no_siblings = self.method(:generate_full_node)
+    walker.on_no_children = self.method(:generate_full_node)
+        
+    # Clear the internal HTML representation
+    @text_string.clear
+    
+    # Walk the forest
+    @syntax_tree.block_forest.each{|tree|
+      walker.walk_tree(tree)
+    }
+
+    return @text_string 
+  end
+  
+  ###
+  ### Walker Hooks. These are called by the tree walker on specific
+  ### events
+  ###
+  
+  # Output the full contents of the node, properly bracketed as an
+  # HTML expression. This is only called if we have no sub-nodes to
+  # deal with
+  def generate_full_node(block)
+    
+    # Check if we need to add a space
+    # Check if we need to add a space
+    if not block.content[0] =~ /\s[:;.,?!]/
+      @text_string << " "
+    end
+                
+    case block.type
+      
+      # Headers
+      when :h1, :h2, :h3, :h4, :h5, :h6
+        @text_string << "#{block.content.strip}\n"
+      
+      # Ordinary paragraphs
+      when :paragraph
+        @text_string << "#{block.content.word_wrap(70)}\n\n"
+
+      when :none
+        @text_string << "#{block.content.word_wrap(70)}"
+        
+      # Special paragraphs
+      when :block_quote
+        @text_string << "#{block.content.word_wrap(60).indent(5)}\n\n"
+      when :single_quote
+        @text_string << "\'#{block.content}\'"
+      when :double_quote
+        @text_string << "\"#{block.content}\""
+        
+      when :note
+        @text_string << "Note: #{block.content}\n\n"
+        
+      when :command
+        @text_string << "#{block.content.strip.indent(5)}\n\n"
+        
+      when :code_language
+        @code_language = block.content
+      when :code_start_number
+        @code_start_number = block.content  
+        
+      when :file
+        @text_string << "#{block.content}\n\n"
+      when :output
+        70.downto(0){|index|
+          @text_string << "-"
+        }        
+        @text_string << "\n#{block.content.strip}\n"
+        70.downto(0){|index|
+          @text_string << "-"
+        }
+        @text_string << "\n\n"
+        
+      # Special Characters
+      when :em_dash
+        @text_string << " - "
+      when :en_dash
+        @text_string << "-"
+      when :elipses
+        @text_string << "..."
+      when :elipses_stop
+        @text_string << "...."
+        
+      # Links
+      when :link_target
+        @link_target = block.content
+      when :link_text
+        @link_text = block.content
+        
+      # Lists
+      when :item
+        @text_string << " * #{block.content}"
+      
+      when :dl_header
+        @text_string << "#{block.content}: "
+      when :dl_text
+        @text_string << "#{block.content}"
+              
+      # Tags
+      when :ac
+        # Do we know anything about this acronymn?
+        if $reference.acronym_list.include?(block.content) then
+          
+          # Assemble from the reference list        
+          if $reference.acronym_list[block.content].include?('text_text') then
+            acronym = $reference.acronym_list[block.content]['text_text']
+          else
+            acronym = $reference.acronym_list[block.content]['text']
+          end
+          
+          definition = $reference.acronym_list[block.content]['def']
+          
+          @text_string << "#{acronym}"
+        else
+          # Do what we can
+          @text_string << "#{block.content}"
+        end
+            
+      when :emph 
+        @text_string << "#{block.content}"
+      
+      when :tt
+        @text_string << "#{block.content}"
+        
+    end
+  end
+  
+  # Output only the start of a node
+  def generate_node_start(block)
+    
+    # Check if we need to add a space
+    if not block.content[0] =~ /\s[:;.,?!]/
+      @text << " "
+    end
+    
+    case block.type
+      
+      # Headers
+      when :h1, :h2, :h3, :h4, :h5, :h6
+        @text_string << "#{block.content.strip}"
+      
+      # Ordinary paragraphs
+      when :paragraph
+        @text << "#{block.content}"
+        
+      when :none
+        @text << "#{block.content}"
+        
+      # Special paragraphs
+      when :block_quote
+        @text << "#{block.content}"
+      when :single_quote
+        @text << "'#{block.content}"
+      when :double_quote
+        @text << "\"#{block.content}"
+        
+      when :note
+        @text << "Note: #{block.content}"
+        
+      when :command
+        @text_string << "#{block.content.lstrip.indent(5)}\n"
+        
+      when :code_language
+        @code_language = block.content
+      when :code_start_number
+        @code_start_number = block.content
+        
+      # Special Characters
+      when :em_dash
+        @text << " - "
+      when :en_dash
+        @text << "-"
+      when :elipses
+        @text << "..."
+      when :elipses_stop
+        @text << "...."
+        
+      # Links
+      when :link_target
+        @link_target = block.content
+      when :link_text
+        @link_text = block.content
+        
+      # Lists
+      when :item
+        @text << " * #{block.content}"
+      
+      when :dl_header
+        @text << "#{block.content}: "
+      when :dl_text
+        @text << "#{block.content}"
+      
+      # Tags        
+      when :ac
+        # Do we know anything about this acronymn?
+        if $reference.acronym_list.include?(block.content) then
+        
+          # Assemble from the reference list        
+          if $reference.acronym_list[block.content].include?('text_text') then
+            acronym = $reference.acronym_list[block.content]['text_text']
+          else
+            acronym = $reference.acronym_list[block.content]['text']
+          end
+        
+          definition = $reference.acronym_list[block.content]['def']
+        
+          @text_string << "#{acronym}"
+        else
+          # Do what we can
+          @text_string << "#{block.content}"
+        end
+                
+      when :emph 
+        @text << "#{block.content}"
+        
+      when :tt
+        @text << "#{block.content}"
+        
+    end
+  end
+  
+  def generate_node_end(block)
+        
+    case block.type
+      
+      # Headers
+      when :h1, :h2, :h3, :h4, :h5, :h6
+        @text_string << @text.word_wrap(70)
+        @text = ""
+      
+      # Ordinary paragraphs
+      when :paragraph
+        @text_string << @text.indent(2).word_wrap(70) + "\n"
+        @text = ""
+      
+      # Special paragraphs
+      when :block_quote
+        @text_string << @text.indent(5).word_wrap(60) + "\n"
+        @text = ""
+      when :single_quote
+        @text_string << "'"
+      when :double_quote
+        @text_string << "\""
+        
+      when :note
+        @text_string << @text.indent(2).word_wrap(70) + "\n"
+        @text = ""
+        
+      # Special Characters
+      when :em_dash
+        @text << " - "
+      when :en_dash
+        @text << "-"
+      when :elipses
+        @text << "..."
+      when :elipses_stop
+        @text << "...."
+        
+      # Links
+      when :link
+        # Assemble the link from the sub-tree nodes
+        @text << "#{@link_text}"
+      when :link_target
+        @link_target = block.content
+      when :link_text
+        @link_text = block.content
+          
+      # Lists
+      when :item
+        @text_string << @text.indent(2).word_wrap(70) + "\n" 
+        @text = ""
+      
+      when :dl
+        @text_string << "\n" 
+        @text = ""
+      when :dl_text
+        @text_string << @text.indent(2).word_wrap(70) + "\n" 
+        @text = ""
+    end
+  end
+  
+  ###
+  ### Helper functions
+  ###
+
+end

data/lib/bayeux/tree_walker.rb

@@ -0,0 +1,166 @@
+####
+#### Defines a stack based tree walker, used by the Bayeux generators
+####
+####
+
+class TreeWalker
+  
+  ###
+  ### Accessors
+  ###
+  
+  attr_accessor :on_before_down, :on_after_down, :on_before_sideways, :on_after_sideways, :on_before_up, :on_after_up, :on_no_siblings, :on_no_children
+  
+  ###
+  ### Class Methods
+  ###
+  
+  def walk_tree(tree_root)
+    
+    # Start walking from the tree root
+    current_node = tree_root
+    
+    # Stack of node to visit
+    visit_list = Array.new
+    
+    # Points to the last 'virtual vist' we have mode. We
+    # Need to complete this path at the end of our vists
+    last_virtual = nil
+    
+    # Dump the vist list
+    dump_visit_list = -> {
+      dump_str = ""
+      visit_list.each{|node|
+        unless node.nil? then
+          dump_str << node.name.to_s + ","
+        else
+          dump_str << "nil,"
+        end
+      }
+      puts "visit list contents: #{dump_str}"
+    }
+    
+    # Do the 'virtual visits'. That is, keep moving up
+    # the tree, visiting the parents at each nil, until
+    # we manage to find something useful
+    do_virtual_visits = -> {
+      next_virtual = current_node
+      next_node = nil
+      
+      # Keep removing nil, moving up the parent list
+      # until we find something worth keeping
+      until ((not next_node.nil?) or visit_list.empty?) do
+        next_node = visit_list.pop
+        next_virtual = next_virtual.parent
+
+        if next_node.nil? then          
+          unless next_virtual.nil? then
+            #puts "^^^ v_visiting: #{next_virtual.name} from #{current_node.name} as #{next_virtual.content.to_debug_s}"
+            unless @on_after_up.nil? then
+              unless next_virtual.nil? then
+                @on_after_up.call(next_virtual.content)
+              end
+            end
+          else
+            #puts "^^^ nil visit"
+          end
+        end
+      end
+
+      current_node = next_node      
+    }
+    
+    # Start walking
+    until current_node.nil? do
+      #unless current_node.nil? then
+      #  puts "^^^ visiting: #{current_node.name} as #{current_node.content.to_debug_s}"
+      #  dump_visit_list.call
+      #end
+      
+      # Do we have any children?
+      if current_node.has_children? then
+        
+        unless @on_before_down.nil? then
+          unless current_node.nil? then
+            @on_before_down.call(current_node.content)
+          end
+        end 
+        
+        # Add the children visit list
+        child_list = current_node.children
+        unless child_list.nil? then
+          visit_list.push(nil)
+          visit_list.concat(child_list.reverse)
+        end
+        
+        #puts "   adding children"
+        #dump_visit_list.call
+        current_node = visit_list.pop
+        
+        unless @on_after_down.nil? then
+          unless current_node.nil? then
+            @on_after_down.call(current_node.content)
+          end
+        end
+        
+      else
+        
+        # Tell the caller we have no children
+        unless @on_no_children.nil? then
+          unless current_node.nil? then
+            @on_no_children.call(current_node.content)
+          end
+        end
+        
+        # We can't go down, but can we go sideways?
+        unless visit_list.last.nil? then
+          
+          unless @on_before_sideways.nil? then
+            unless current_node.nil? then
+              @on_before_sideways.call(current_node.content)
+            end
+          end
+          
+          current_node = visit_list.pop
+          
+          unless @on_after_sideways.nil? then
+            unless current_node.nil? then
+              @on_after_sideways.call(current_node.content)
+            end
+          end
+          
+        else
+          
+          # We can't go sideways, or down, so we will go up
+                    
+          unless @on_before_up.nil? then
+            unless current_node.nil? then
+              @on_before_up.call(current_node.content)
+            end
+          end
+          
+          # Do the virtual visits to the parents of this node,
+          # ready to move onto the next set of siblings
+          do_virtual_visits.call
+          
+        end
+        
+      end
+      
+    end
+    
+    # Finish the walk by going all the way back to the parent
+    current_node = last_virtual
+    until current_node == tree_root or current_node.nil? do
+      current_node = current_node.parent
+      
+      unless @on_after_up.nil? then
+        unless current_node.nil? then
+          @on_after_up.call(current_node.content)
+        end
+      end
+    end
+    
+  end
+  
+end