BuildMaster 0.7.0 → 0.8.0

data/lib/buildmaster/templatelets/text.rb

@@ -0,0 +1,14 @@
+module BuildMaster
+class Text
+  def initialize(properties)
+    @properties = properties
+  end
+  
+  def process(target, template, source)
+      property = template.attribute_value!('property')
+      value = @properties[property]
+      raise TemplateException, "property value for '#{property}' not found" unless value
+      target.add(REXML::Text.new(value))
+  end
+end
+end

data/lib/buildmaster/templatelets/when.rb

@@ -0,0 +1,24 @@
+$:.unshift File.join(File.dirname(__FILE__), '..')
+
+require 'template_runner'
+
+module BuildMaster
+class When
+  def initialize(site_spec, expression_evaluator)
+    @site_spec = site_spec
+    @evaluator = expression_evaluator
+  end
+  
+  def process(target, template, source)
+    eval = template.attribute_value!('test')
+    if (not @evaluator.respond_to?(eval))
+      raise TemplateException, "#{@evaluator.class} cannot evaluate expression #{eval}"
+    end
+    if (@evaluator.send(eval, source.path))
+      runner = TemplateRunner.new(target, template, source)
+      runner.templatelets = @site_spec.load_templatelets
+      runner.process
+    end
+  end
+end
+end

data/lib/buildmaster/tree_to_object.rb

@@ -0,0 +1,76 @@
+require 'yaml'
+
+module BuildMaster
+
+class PropertyMatchError < StandardError
+  
+  attr_reader :property, :type, :target
+
+  def initialize(property, type, target)
+    @property = property
+    @type = type
+    @target = target
+  end
+end
+
+class TreeToObject
+  def initialize(tree, object)
+    @tree = tree
+    @object = object
+  end
+
+  def TreeToObject.from_yaml(content, object)
+    tree = {}
+    if (content.chomp!)
+      tree = YAML.load(content)
+     if (not tree.kind_of?(Hash))
+       raise "Format error for content:\n#{content}"
+     end
+   end
+    return TreeToObject.new(tree, object).convert
+  end
+
+
+  def convert
+    @tree.each_pair do |key, value|
+      if (value.kind_of?(Array))
+        convert_array(key, value)
+      elsif (value.kind_of?(Hash))
+        convert_hash(key, value)
+      else
+        convert_property(key, value)
+      end
+    end
+    return @object
+  end
+
+  private
+  def convert_hash(field, hash)
+    return TreeToObject.new(hash, property("#{field}", field, 'sub property')).convert
+  end
+
+  def convert_array(field, array)
+    array.each do |item|
+      TreeToObject.new(item, property("add_to_#{field}", field, 'array')).convert
+    end
+  end
+  
+  def convert_property(field, value)
+    method = "#{field}="
+    check_property(method, field, 'string')
+    @object.send("#{field}=", value)
+  end  
+  
+  def property(method, field, type)
+    check_property(method, field, type)
+    @object.send(method)
+  end
+  
+  def check_property(method, field, type)
+    if not @object.respond_to? method
+      message = "#{field} does not exist as #{type} in #{@object}"
+      raise PropertyMatchError.new(field, type, @object), message, caller
+    end
+  end
+end
+end

data/lib/buildmaster/xtemplate.rb

@@ -4,25 +4,24 @@ require 'rexml/document'
 require 'template_runner'
 
 module BuildMaster
-  class TemplateException < Exception
-  end
-    
   class XTemplate
-    def initialize(template_file)
+    def initialize(template_file, templatelets = Hash.new)
       @template = REXML::Document.new(template_file)
+      @templatelets = templatelets
     end
         
-    def process(content, &evaluator)
-      content_xml = REXML::Document.new(content)
-      output_xml = process_xml(content_xml, &evaluator)
+    def process(source, &evaluator)
+      output_xml = process_xml(source, &evaluator)
       return output_xml
     end
         
     private
-    def process_xml(content_xml, &evaluator)
-      result_xml = REXML::Document.new
-      TemplateRunner.new(result_xml, @template, content_xml, &evaluator).process
-      return result_xml
+    def process_xml(source, &evaluator)
+      output_xml = REXML::Document.new
+      runner = TemplateRunner.new(output_xml, @template, source, &evaluator)
+      runner.templatelets = @templatelets
+      runner.process
+      return output_xml
     end
   end
 end

data/test/buildmaster/manifest.mf

@@ -1,5 +1,5 @@
 Implementation-Version: 2.3.3
-Implementation-Build: 1000
+Implementation-Build: 1114
 
 Implementation-Vendor: Vendor
 Implementation-Number: Number

data/test/buildmaster/{tc_site.rb → site/tc_site.rb}

@@ -1,4 +1,4 @@
-$:.unshift File.join(File.dirname(__FILE__), "..", "..", "lib")
+$:.unshift File.join(File.dirname(__FILE__), "..", "..", '..', "lib")
 
 require 'test/unit'
 require 'buildmaster'

data/test/buildmaster/site/tc_template_builder.rb

@@ -0,0 +1,128 @@
+$:.unshift File.join(File.dirname(__FILE__), '..', '..', '..', 'lib')
+
+require 'test/unit'
+require 'rexml/xpath'
+require 'buildmaster/site/template_builder'
+require 'buildmaster/tree_to_object'
+require 'yaml'
+
+module BuildMaster
+class TemplateBuilderTest < Test::Unit::TestCase
+  def test_should_generate_template_document
+    builder = TemplateBuilder.new
+    document = builder.generate
+    assert_equal('include', REXML::XPath.first(document, '/html/head/title/*').name)
+    assert_css_path(document, 'buildmaster.css')
+  end
+  
+  def test_should_update_header_with_title_and_css
+    builder = TemplateBuilder.new
+    builder.title_header = 'Title Header - '
+    builder.css_path = 'mycss.css'
+    document = builder.generate
+    first_child = REXML::XPath.first(document, '/html/head/title').children[0]
+    assert_equal(REXML::Text, first_child.class)
+    assert_equal('Title Header - ', first_child.value)
+    assert_css_path(document, 'mycss.css')
+  end
+  
+  def test_should_have_logo_defaults
+    builder = TemplateBuilder.new
+    assert_equal(nil, builder.logo.path)
+    assert_equal('index.html', builder.logo.link)
+  end
+  
+  def test_should_generate_logo_and_link
+    builder = TemplateBuilder.new
+    builder.logo.path = 'gif/logo.gif'
+    builder.logo.link = 'main.html'
+    document = builder.generate
+    header = assert_first(document, '/html/body/div[@class="header"]')
+    anchor_href = assert_first(header, 'a/template:href')
+    assert_equal('main.html', anchor_href.attributes['url'])
+    img_href = assert_first(header, 'a/img/template:href')
+    assert_equal('gif/logo.gif', img_href.attributes['url'])
+  end
+  
+  def test_should_build_left_menu
+    builder = TemplateBuilder.new
+    builder.left_bottom_logo.path='http://www.example.com/logo.gif'
+    group = builder.menu_group('Software')
+    group.menu_item('Download', 'download.html')
+    group.menu_item('License', 'license.html')
+    group.more='more.html'
+    group = builder.menu_group('Documentation', 'doc/index.html')
+    group.menu_item('Getting Started', 'doc/getting-started')
+    document = builder.generate
+    groups = REXML::XPath.match(document, '/html/body/div[@class="left"]/div[@class="MenuGroup"]')
+    assert_equal(2, groups.size)
+    first_group = groups[0]
+    header = assert_first(first_group, 'h1')
+    assert_equal('Software', header.text)
+    items = REXML::XPath.match(first_group, 'ul/li')
+    assert_equal(3, items.size)
+    first_item = items[0]
+    anchor = assert_first(first_item, 'template:link')
+    assert_equal('download.html', anchor.attributes['href'])
+    assert_equal('Download', anchor.text)
+    more = items[2]
+    assert_equal('More', more.attributes['class'])
+  end
+  
+  def test_should_have_releases_info
+    builder = TemplateBuilder.new
+    releases = builder.releases
+    releases.stable_version = '0.6'
+    releases.pre_release_version = '0.7'
+    releases.snap_shot_version = 'n/a'
+    releases.download_link = 'download.html'
+    releases.versioning_link = 'versioning.html'
+    builder.generate
+  end
+
+  def test_should_read_from_yaml
+    content = <<CONTENT
+title_header: BuilderMaster -
+logo:
+  path: logo.gif
+  link: index.html
+menu_groups:
+- title: Software
+  menu_items:
+  - title: Download
+    link: download.html
+  - title: Source Repository
+    link: http://rubyforge.org/scm/?group_id=1680
+  - title: Project License
+    link: license.html
+- title: Documentation...
+  link: document.html
+  menu_items:
+  - title: Getting Started
+    link: getting-started.html
+  - title: Project Release
+    link: release-project.html
+  - title: Site Building
+    link: build-site.html
+  more: doc/index.html
+CONTENT
+    builder = TreeToObject.from_yaml(content, TemplateBuilder.new)
+    assert_equal('BuilderMaster -', builder.title_header)
+    assert_equal('logo.gif', builder.logo.path)
+    assert_equal('index.html', builder.logo.link)
+  end
+
+  private
+  def assert_css_path(document, expected)
+    href = REXML::XPath.first(document, '/html/head/link/*')
+    assert_equal('href', href.name)
+    assert_equal(expected, href.attributes['url'])
+  end  
+  
+  def assert_first(xml_model, xpath)
+    first = REXML::XPath.first(xml_model, xpath)
+    assert_not_nil(first)  
+    return first
+  end
+end
+end

data/test/buildmaster/tc_build_number_file.rb

@@ -0,0 +1,31 @@
+$:.unshift File.join(File.dirname(__FILE__), '..', '..', 'lib')
+
+require 'test/unit'
+
+require 'buildmaster/build_number_file'
+
+module BuildMaster
+class BuildNumberFileTest < Test::Unit::TestCase
+  def test_load_file
+    path = tmp_file(2)
+    build_number = BuildNumberFile.new(path)
+    assert_equal(2, build_number.number)
+  end
+  
+  def test_increase_build
+    path = tmp_file(3)
+    build_number = BuildNumberFile.new(path)
+    build_number.increase_build
+    assert_equal(4, build_number.number)
+    reloaded = BuildNumberFile.new(path)
+    assert_equal(4, reloaded.number)
+  end
+  
+  private
+  def tmp_file(build_number)
+    path = File.join(File.dirname(__FILE__), '..', '..', 'tmp', 'buildnumber')
+    File.open(path, "w") {|file| file.puts build_number}
+    return path
+  end
+end
+end

data/test/buildmaster/tc_file_processor.rb

@@ -2,32 +2,99 @@ $:.unshift File.join(File.dirname(__FILE__), "..", "..", "lib")
 
 require 'test/unit'
 require 'rexml/document'
+require 'pathname'
 require 'buildmaster/file_processor'
 require 'buildmaster/xtemplate'
 
 module BuildMaster
 class FileProcessorTest < Test::Unit::TestCase
-  def test_expression_evaluation
-    template = XTemplate.new(<<CONTENT
+  def test_should_know_content_and_target
+      template = XTemplate.new(<<CONTENT
 <html xmlns="http://www.w3.org/1999/xhtml"
         xmlns:template="http://buildmaster.rubyforge.org/xtemplate/1.0">
-<p>
-  <template:attribute name="class" eval="method_one"/>
-</p>      
 </html>
 CONTENT
 )
-    processor = FileProcessor.new(template, "content_path", self)
-    document = processor.process_html_content("<html></html>")
-    assert_equal('method one result', 
-      REXML::XPath.first(REXML::Document.new(document.to_s), '/html/p/@class').value.strip)
-    
+      site_spec = SiteSpec.new
+      current_dir = File.dirname(__FILE__)
+      site_spec.content_dir = File.join(current_dir, "content")
+      site_spec.output_dir = File.join(current_dir, "output")
+      processor = FileProcessor.new(template, File.join(current_dir, 'content', 'index.html'), site_spec)
+      assert_equal(File.join(current_dir, 'content', 'index.html'), processor.path_to_content_file)
+      assert_equal(true, processor.is_html?)
   end
   
-  def evaluate(expression, path)
-    assert_equal('method_one', expression)
-    assert_equal('content_path', path)
-    return "method one result"
+  def test_should_know_html_target
+      template = XTemplate.new(<<CONTENT
+<html xmlns="http://www.w3.org/1999/xhtml"
+        xmlns:template="http://buildmaster.rubyforge.org/xtemplate/1.0">
+</html>
+CONTENT
+)
+      site_spec = SiteSpec.new
+      current_dir = File.dirname(__FILE__)
+      site_spec.content_dir = File.join(current_dir, "content")
+      site_spec.output_dir = File.join(current_dir, "output")
+      processor = FileProcessor.new(template, File.join(current_dir, 'content', 'index.gif'), site_spec)
+      assert_equal(File.join(current_dir, 'content', 'index.gif'), processor.path_to_content_file)
+      assert_equal(false, processor.is_html?)
+      assert_equal(nil, processor.generate_document)
+  end
+  
+  def test_should_load_from_target
+      template_content = <<CONTENT
+<html xmlns="http://www.w3.org/1999/xhtml"
+        xmlns:template="http://buildmaster.rubyforge.org/xtemplate/1.0">
+</html>
+CONTENT
+      site_spec = SiteSpec.new
+      current_dir = File.dirname(__FILE__)
+      site_spec.template = template_content
+      site_spec.content_dir = File.join(current_dir, 'site', 'content')
+      site_spec.output_dir = File.join(current_dir, "output")
+      processor = FileProcessor.for_request_path('/index.html', site_spec)
+      assert_equal(File.join(site_spec.content_dir, 'index.html'), processor.path_to_content_file)
+      processor = FileProcessor.for_request_path('/index.gif', site_spec)
+      assert_equal(File.join(site_spec.content_dir, 'index.gif'), processor.path_to_content_file)
+      processor = FileProcessor.for_request_path('/textile.html', site_spec)
+      assert_equal(File.join(site_spec.content_dir, 'textile.textile'), processor.path_to_content_file)
+      processor = FileProcessor.for_request_path('/markdown.html', site_spec)
+      assert_equal(File.join(site_spec.content_dir, 'markdown.markdown'), processor.path_to_content_file)
+  end
+  
+  def output_dir
+    return 'tmp'
+  end
+  
+  def relative_to_root(path)
+    return Pathname.new('tmp')
+  end
+  
+  def test_mark_down_support
+    template_content = <<CONTENT
+<html xmlns="http://www.w3.org/1999/xhtml"
+        xmlns:template="http://buildmaster.rubyforge.org/xtemplate/1.0">
+<head><title><template:include elements="/html/head/title/text()"/></title></head>
+<body>
+  <template:include elements="/html/body/*"/>
+</body>   
+</html>
+CONTENT
+    hash = {'include' => Include.new(self)}
+    template = XTemplate.new(template_content, hash)
+
+    processor = FileProcessor.new(template, "content_path", self)
+    markdown_content = <<CONTENT
+--------------------------------------------
+Title Here
+--------------------------------------------
+Header
+=====================
+CONTENT
+    document = processor.process_markdown(markdown_content)
+    document = REXML::Document.new(document.to_s)
+    assert_equal('Title Here', REXML::XPath.first(document, '/html/head/title').text)
+    assert_equal('Header', REXML::XPath.first(document, '/html/body/h1').text)
   end
   
 end