BuildMaster 0.7.0 → 0.8.0

data/lib/buildmaster/site_tester.rb

@@ -2,6 +2,7 @@ module BuildMaster
 
 require 'watir'
 require 'set'
+require 'uri'
 
 class SiteTester
   URL_PATTERN = /^https?\:\/\/([^\/]*)/
@@ -44,10 +45,9 @@ class SiteTester
   end
   
   def check_page
-    if (@visited_pages.include?(@ie.url))
+    if (url_visited?(@ie.url))
       return
     end
-    @visited_pages.add(@ie.url)
     check_links
     errors = @errors[@ie.url]
     if (errors && errors.length > 0)
@@ -55,6 +55,18 @@ class SiteTester
     end
   end
   
+  def url_visited?(url)
+    index = url.index('#')
+    if (index)
+      url = url[0, index]
+    end
+    if (@visited_pages.include?(url))
+      return true
+    end
+    @visited_pages.add(url)
+    return false
+  end
+  
   def check_links
     current = @ie.url
     @ie.links.each do |link|

data/lib/buildmaster/source_content.rb

@@ -0,0 +1,11 @@
+module BuildMaster
+class SourceContent
+  attr_reader :path, :document
+  
+  def initialize(path, document)
+    @path = path
+    @document = document
+  end
+  
+end
+end

data/lib/buildmaster/source_file_handler.rb

@@ -27,15 +27,20 @@ class SourceFileHandler < WEBrick::HTTPServlet::AbstractServlet
       path = "#{path}index.html"
       extension = '.html'
     end
-    if (extension.casecmp('.html') == 0)
+    file_processor = FileProcessor.for_request_path(path, @spec)
+    if (file_processor.is_html?)
       begin
-        serve_generated_file(path[0, path.length - 5], req, res)
+        content = file_processor.generate_document.to_s
       rescue Exception
         @logger.error("error serving the file #{path}")
         @logger.error($!)
         raise WEBrick::HTTPStatus::InternalServerError, 
           "#{$!}", caller
       end
+      res['content-type'] = 'text/html'
+      res['content-length'] = content.length
+      res['last-modified'] = DateTime.new
+      res.body = content
     else
       @delegate.service(req, res)
     end

data/lib/buildmaster/svn_driver.rb

@@ -1,21 +1,33 @@
+require 'stringio'
 require 'rexml/document'
 
 module BuildMaster
 
 class SvnInfo
-    attr_reader :path, :repository_root
-    
-    def initialize(path)
-        @path = path
-        analyze_entry_file(File.join(path, ".svn", "entries"))
+  attr_reader :path, :repository_root
+  
+  def initialize(path)
+    @path = path
+    analyze_entry_file(File.join(path, ".svn", "entries"))
+  end
+  
+  def analyze_entry_file(path)
+    content = load_content(path)
+    xml = REXML::Document.new(content)
+    xml.root.each_element_with_attribute('name', '', 1) do |element|
+      @repository_root = element.attributes['repos']
     end
-    
-    def analyze_entry_file(file)
-        xml = REXML::Document.new(File.open(file))
-        xml.root.each_element_with_attribute('name', '', 1) do |element|
-            @repository_root = element.attributes['repos']
-        end
+  end
+  
+  def load_content(path)
+    buffer = StringIO.new
+    File.open(path, 'r') do |file|
+      while (line = file.gets)
+        buffer.puts(line)
+      end
     end
+    return buffer.string
+  end
 end
 
 class SvnDriver

data/lib/buildmaster/template_exception.rb

@@ -0,0 +1,8 @@
+$:.unshift File.dirname(__FILE__)
+
+module BuildMaster
+
+  class TemplateException < Exception
+  end
+
+end

data/lib/buildmaster/template_runner.rb

@@ -1,16 +1,24 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'template_exception'
+
 module BuildMaster
   class TemplateRunner
-  BuildMaster::NAMESPACE = "http://buildmaster.rubyforge.org/xtemplate/1.0"
+    @@NAMESPACE = 'http://buildmaster.rubyforge.org/xtemplate/1.0'
+    attr_reader :templatelets
+    attr_writer :templatelets
 
-    def initialize(result, template, source, &evaluator)
-      @result = result
+    def initialize(target, template, source, &evaluator)
+      @templatelets = Hash.new
+      @target = target
       @template = template
-      @source = source
+      @source_instance = source
+      @templatelets = templatelets
       @evaluator = evaluator
     end
         
     def process
-      process_children(@result, @template)
+      process_children(@target, @template)
     end
         
     private
@@ -35,13 +43,16 @@ module BuildMaster
     end
         
     def template_directive?(element)
-      element.namespace == NAMESPACE
+      element.namespace == @@NAMESPACE
     end
         
     def process_directive(target, template_element)
       message = "process_#{template_element.name}_directive"
-      raise TemplateException, "unable to process element template:#{template_element.name}" unless respond_to?(message, true)
-      send(message, target, template_element)
+      templatelet = @templatelets[template_element.name]
+      if (not templatelet)
+        raise TemplateException, "unable to process element template:#{template_element.name}"
+      end
+      templatelet.process(target, template_element, @source_instance)
     end
 
     def clone_element( template_element )
@@ -64,83 +75,5 @@ module BuildMaster
       end
     end
         
-    def process_include_directive(target_element, template_element)
-      elements_attribute = template_element.attributes["elements"]
-      if (elements_attribute)
-        REXML::XPath.match(@source, elements_attribute).each do |matched|
-          target_element.add(deep_clone(matched))
-        end
-        return
-      end
-    end
-        
-    def process_when_directive(target_element, template_element)
-      if evaluate(template_element, 'test')
-        process_children(target_element, template_element)
-      end
-    end
-        
-    def process_attribute_directive(target_element, template_element)
-      name = template_element.attributes['name']
-      target_element.attributes[name]=evaluate(template_element, 'eval')
-    end
-        
-    def process_text_directive(target_element, template_element)
-      target_element.add(REXML::Text.new(evaluate(template_element, 'eval')))
-    end
-        
-    def process_each_directive(target_element, template_element)
-      source_xml = evaluate!(template_element, 'source')
-      matched_element = REXML::XPath.match(REXML::Document.new(source_xml), template_element.attributes['select'])
-      count = attribute!(template_element, 'count')
-      count.to_i.times do |i|
-        TemplateRunner.new(target_element, template_element, matched_element[i], &@evaluator).process
-      end
-    end
-    
-    def process_link_directive(target_element, template_element)
-      current_path = @evaluator.call('relative_to_root')
-      file_name = current_path.basename(current_path.extname).to_s + ".html"
-      current_html_path = current_path.parent().join(file_name)
-      href = Pathname.new(attribute!(template_element, 'href'))
-      if (href.absolute?)
-        href = href.relative_path_from(Pathname.new('/'))
-      end
-      anchor_or_div = nil
-      if (current_html_path == href)
-        anchor_or_div = REXML::Element.new('div')
-        anchor_or_div.attributes['class']='current'
-      else
-        anchor_or_div = REXML::Element.new('a')
-        anchor_or_div.attributes['href'] = href.relative_path_from(current_html_path.parent())
-      end
-      template_element.attributes.each do |name, value|
-        anchor_or_div.attributes[name] = value unless name == 'href'
-      end
-      process_children(anchor_or_div, template_element)
-      target_element.add(anchor_or_div)
-    end
-    
-    def evaluate!(xml_element, attribute_name)
-      value = evaluate(xml_element, attribute_name)
-      message = xml_element.attributes[attribute_name]
-      if (not value)
-        raise TemplateException, "#{message} from attribute #{attribute_name} cannot be nil"
-      end
-      return value
-    end
-        
-    def evaluate(xml_element, attribute_name)
-      message = attribute!(xml_element, attribute_name)
-      return @evaluator.call(message)
-    end
-    
-    def attribute!(xml_element, attribute_name)
-      value = xml_element.attributes[attribute_name]
-      if (not value)
-        raise TemplateException, "attribute #{attribute_name} not found in #{xml_element}"
-      end
-      return value
-    end
   end
 end

data/lib/buildmaster/templatelets.rb

@@ -0,0 +1,23 @@
+$:.unshift(File.dirname(__FILE__))
+
+require 'templatelets/href'
+require 'templatelets/attribute'
+require 'templatelets/each'
+require 'templatelets/include'
+require 'templatelets/link'
+require 'templatelets/text'
+require 'templatelets/when'
+
+module REXML
+class Element
+  def attribute_value!(name)
+    value = attribute_value(name)
+    raise "attribute #{name} not found" unless value
+    return value
+  end
+  
+  def attribute_value(name)
+    return attributes[name]
+  end
+end
+end

data/lib/buildmaster/templatelets/attribute.rb

@@ -0,0 +1,16 @@
+module BuildMaster
+class Attribute
+  def initialize(expression_evaluator)
+    @evaluator = expression_evaluator
+  end
+  
+  def process(target, template, source)
+    name = template.attribute_value!('name')
+    eval = template.attribute_value!('eval')
+    if (not @evaluator.respond_to?(eval))
+      raise TemplateException, '#{@evaluator.class} cannot evaluate expression #{eval}'
+    end
+    target.attributes[name] = @evaluator.send(eval, source.path)
+  end
+end
+end

data/lib/buildmaster/templatelets/each.rb

@@ -0,0 +1,43 @@
+require 'uri'
+require 'open-uri'
+
+module BuildMaster
+class Each
+  def initialize(site_spec)
+    @site_spec = site_spec
+  end
+  
+  def process(target, template, source)
+      source_xml = load_source_xml(template)
+      matched_element = REXML::XPath.match(source_xml, template.attribute_value!('select'))
+      count = template.attribute_value!('count')
+      count.to_i.times do |i|
+        element_source = SourceContent.new(source.path, matched_element[i])
+        template_runner = TemplateRunner.new(target, template, element_source)
+        template_runner.templatelets = @site_spec.load_templatelets
+        template_runner.process
+      end
+  end
+  
+  private
+  def load_source_xml(template)
+    path = template.attribute_value!('source')
+    if (URI.parse(path).scheme.nil?)
+      return @site_spec.load_document(path)
+    end
+    return load_content_through_uri(path)
+  end
+  
+  def load_content_through_uri(uri)
+    buffer = StringIO.new
+    begin
+      open(uri) do |file|
+        buffer.puts file.gets
+      end
+      return REXML::Document.new(buffer.string)
+    rescue Exception => exception
+      raise RuntimeError, "Error loading uri: #{uri}", caller
+    end
+  end
+end
+end

data/lib/buildmaster/templatelets/href.rb

@@ -0,0 +1,39 @@
+$:.unshift(File.join('..', File.dirname(__FILE__)))
+
+require 'uri'
+
+require 'template_exception'
+require 'template_runner'
+
+module BuildMaster
+
+class Href
+  def initialize(site_spec)
+    @site_spec = site_spec
+  end
+  
+  def process(target, template, source)
+    url = template.attribute_value!('url')
+    href = construct_href(url, source.path)
+    target.attributes[name_based_on_target(target)] = href
+  end
+  
+  private
+  def construct_href(url, current_path)
+    href = url
+    if (URI.parse(url).scheme.nil?)
+      href = Pathname.new(url).relative_path_from(current_path.parent)
+    end  
+    return href
+  end
+  
+  def name_based_on_target(target)
+    name = target.name
+    if (name == 'img')
+      return 'src'
+    else
+      return 'href'
+    end
+  end
+end
+end

data/lib/buildmaster/templatelets/include.rb

@@ -0,0 +1,30 @@
+
+module BuildMaster
+class Include
+  def initialize(site_spec)  
+    @site_spec = site_spec
+  end
+  
+  def process(target, template, source)
+      elements_xpath = template.attribute_value!('elements')
+      if (elements_xpath[elements_xpath.length - 1, 1] == '*')
+        elements_xpath = elements_xpath[0, elements_xpath.length - 1]
+        REXML::XPath.each(source.document, elements_xpath) do |matched|
+          matched.each_child {|child| target.add(deep_clone(child))}
+        end
+      else
+        REXML::XPath.each(source.document, elements_xpath) {|matched| target.add(deep_clone(matched))}
+      end
+  end
+  
+  private  
+  def deep_clone(node )
+    if node.kind_of? REXML::Parent
+      node.deep_clone
+    else
+      node.clone
+    end
+  end
+        
+end
+end

data/lib/buildmaster/templatelets/link.rb

@@ -0,0 +1,41 @@
+require 'rexml/element'
+
+module BuildMaster
+class Link
+  def initialize(site_spec)
+    @site_spec = site_spec
+  end
+
+  def process(target, template, source)
+    target_path = get_href_as_relative_path(template)
+    result = nil
+    if (target_path == source.path)
+      result = REXML::Element.new('div')
+      result.attributes['class'] = 'current'
+    else
+      result = REXML::Element.new('a')
+      href = target_path.relative_path_from(source.path.parent)
+     result.attributes['href'] = href.to_s
+    end
+    template.attributes.each do |name, value|
+      result.attributes[name] = value unless name == 'href'
+    end
+    template.each_child do |element|
+      runner = TemplateRunner.new(result, template, source)
+      runner.templatelets = @site_spec.load_templatelets
+      runner.process
+    end
+    target.add(result)
+  end
+  
+  private
+  def get_href_as_relative_path(template)
+    href = Pathname.new(template.attribute_value!('href'))
+    if (href.absolute?)
+      href = href.relative_path_from(Pathname.new('/'))
+    end
+    return href
+  end
+  
+end
+end