dokkit 0.2.0 → 0.3.0

data/README

@@ -1,32 +0,0 @@
-= WHAT'S dokkit?
-
-+dokkit+ is an open source documentation environment based on
-ruby. 
-
-+dokkit+ puts together the flexibility of +rote+ and the great
-variety of +deplate+'s output formats.
-
-With +dokkit+ you can:
-
-* generate many types of documentation in many formats (html, tex,
- docbook, plain text, etc.)
-* write your documents using a simple wiki syntax (emacs-wiki like)
-* generate different output formats from the same source document
-* use a big set of models to quickly generate the documents you want (technical report, invoice, howto,
- guides, presentation, website, etc.)
-* simply derive new document models from the existing ones
-* simply modify existing models to fit your needs
-
-+dokkit+'s success keys are:
-
-* a smart task system based on +rake+ a consistent documentation
-   per-model framework organized in templates, layouts, ruby classes,
-   configuration files, resources based on +rote+ 
-* a powerful templating system based on +erb+ 
-* a simple and flexible configuration system based on +yaml+
-
-+dokkit+ aims to be modular and extensible: you can easily add
-new filters, formatters and document models.
-
-See http://dokkit.rubyforge.org for further information.
-

data/lib/dokkit/#render_task_factory.rb#

@@ -1,94 +0,0 @@
-#                                                                          
-# File 'render_task_factory.rb' created on 18 Nov 2007 at 16:01:42.                    
-#
-# See 'dokkit.rb' or +LICENSE+ for licence information.                      
-#                                                                          
-# (C) 2006, 2007 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
-#                                                                          
-
-require 'singleton'
-require 'rote/format/html'
-require 'dokkit/filters'
-require 'dokkit/dokkittasks'
-
-module Dokkit
-  class RenderTaskFactory
-    include Singleton
-    def create_render_html(name = :render_html)
-      Rote::DocTask.new(name) do |task|
-        task.output_dir = 'html'
-
-        task.layout_dir = 'doc/layouts'
-        task.config_dir = 'doc/config'
-
-        task.pages.dir = 'doc/pages'
-        task.pages.include('**/*')
-        task.pages.exclude('**/*.yaml')
-
-        task.res.dir = 'doc/res/html'
-        task.res.include('**/*')
-        
-        yield task if block_given?
-        
-        task.ext_mapping(/dpl/, 'html', task.output_dir) do |page|
-          page.extend Rote::Format::HTML
-          page.page_filter Dokkit::Filters::Deplate.new('html-notemplate')
-        end
-      end
-    end
-    def create_render_tex(name = :render_tex)
-      Rote::DocTask.new(name) do |task|
-        task.output_dir = 'tex'
-
-        task.layout_dir = 'doc/layouts'
-        task.layout_defext = '.tex'
-        
-        task.config_dir = 'doc/config'
-
-        task.pages.dir = 'doc/pages'
-        task.pages.include('**/*')
-        task.pages.exclude('**/*.yaml')
-
-        task.res.dir = 'doc/res/tex'
-        task.res.include('**/*')
-        
-        yield task if block_given?
-        
-        task.ext_mapping(/dpl/, 'tex', task.output_dir) do |page|
-          #FIXME: render_tex task must have its own format extension
-          page.extend Rote::Format::HTML
-          page.page_filter Dokkit::Filters::Deplate.new('latex-notemplate')
-        end
-      end
-    end
-    def create_render_text(name = :render_text)
-      Rote::DocTask.new(name) do |task|
-        task.output_dir = 'text'
-
-        task.layout_dir = 'doc/layouts'
-        task.layout_defext = '.text'
-        
-        task.config_dir = 'doc/config'
-
-        task.pages.dir = 'doc/pages'
-        task.pages.include('**/*')
-        task.pages.exclude('**/*.yaml')
-
-        task.res.dir = 'doc/res/text'
-        task.res.include('**/*')
-        
-        yield task if block_given?
-        
-        task.ext_mapping(/dpl/, 'text', task.output_dir) do |page|
-          #FIXME: render_text task must have its own format extension
-          page.extend Rote::Format::HTML
-          page.page_filter Dokkit::Filters::Deplate.new('plain')
-        end
-      end
-    end
-    def create_render_pdf
-      Rake::Task.new 
-    end
-  end
-end
-

data/lib/dokkit/dokkittasks.rb

@@ -1,99 +0,0 @@
-#
-# File 'dokkittasks.rb' created on 09 ott 2007 at 17:08:49.
-#
-# See 'dokkit.rb' or +LICENSE+ for licence information.
-#
-# (C) 2006, 2007 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors).
-#
-# Rake tasklib for Dokkit.
-
-require 'rote/rotetasks.rb'
-require 'dokkit/page'
-require 'dokkit/hash'
-
-module Rote
-
-  class DocTask
-
-    # Base directories used by the task.
-    attr_accessor :config_dir
-    attr_accessor :config_page
-    attr_accessor :layout_defext
-
-    def initialize(name = :doc) # :yield: self if block_given?
-      @name = name
-      @config_page = { }
-      @output_dir = '.'
-      @pages = FilePatterns.new('.')
-      @res = FilePatterns.new('.')
-      @monitor_interval = 1
-      @ext_mappings = ExtHash.new
-      @show_page_tasks = false
-
-      DEFAULT_SRC_EXCLUDES.each { |excl| @pages.exclude(excl) }
-
-      yield self if block_given?
-
-      @config_page = {
-        :layout_dir => layout_dir,
-        :config_dir => config_dir,
-        :pages_dir  => pages.dir,
-        :layout_defext => layout_defext
-      }
-
-      define
-    end
-
-    # define a task for each page, and 'all pages' task
-    def define_page_tasks
-      pages_fl = pages.to_filelist
-
-      gen_files = pages_fl.select { |fn| not File.directory?(fn) }.map do |fn|
-        tfn, blk = target_fn(/^#{pages.dir}/, fn)
-
-        desc "#{fn} => #{tfn}" #if show_file_tasks?
-        file tfn => [fn] do
-          dn = File.dirname(tfn)
-          mkdir_p dn unless File.exists?(dn)
-          puts "tr #{fn} => #{tfn}"
-          begin
-            File.open(tfn, 'w+') do |f|
-              # new page, run extension block, render out, throw away
-              f << Page.new( {:fn => fn}.merge(config_page), &blk).render
-            end
-          rescue => e
-            # Oops... Unlink file and dump backtrace
-            File.unlink(tfn)
-            bt = e.backtrace
-            end_idx = bt.each_with_index do |entry, idx|
-              break idx if entry =~ /^#{File.dirname(__FILE__)}/
-            end
-            puts bt[0...end_idx]
-            raise
-          end
-        end
-
-        # Each page depends properly on source and common - thx again
-        # Jonathan :)
-        src_rb = Page::page_ruby_filename(fn)
-        if File.exists?(src_rb)
-          file tfn => [src_rb]
-        end
-
-        common_rbs = Page::resolve_common_rubys(File.dirname(fn))
-        file tfn => common_rbs unless common_rbs.empty?
-
-        tfn
-      end
-
-      desc "Render new/changed documentation pages"
-      task "#{name}_pages" => gen_files
-      task "clobber_#{name}_pages" do
-        gen_files.each do |f|
-          rm_f f
-        end
-      end
-    end
-
-  end
-end

data/lib/dokkit/hash.rb

@@ -1,41 +0,0 @@
-#                                                                          
-# File 'hash.rb' created on 09 ott 2007 at 15:59:11.                    
-#
-# See 'dokkit.rb' or LICENSE for licence information.                      
-#                                                                          
-# (c)2006, 2007 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
-#                                                                          
-
-class Hash
-  # Set the default values for keyword arguments.
-  # See http://www.lukeredpath.co.uk/2006/7/27/using-ruby-hashes-as-keyword-arguments-with-easy-defaults
-  # for a complete discussion.
-  def with_defaults!(defaults)
-    self.merge!(defaults) { |key, old, new| old.nil? ? new : old }
-  end
-  # Non-desctructive version of Hash#with_defaults method.
-  def with_defaults(defaults)
-    self.merge(defaults) { |key, old, new| old.nil? ? new : old } 
-  end
-  # Hash#recursive_merge merges two arbitrarily deep hashes into a single hash. 
-  # The hash is followed recursively, so that deeply nested hashes that are at 
-  # the same level will be merged when the parent hashes are merged.
-  def recursive_merge!(other_hash)
-    merge!(other_hash) do |key, value, other_value|
-      if(value.class == Hash && other_value.class == Hash)
-        value.recursive_merge other_value
-      elsif(value.class == Array && other_value.class == Array)
-        value.concat(other_value)
-      else
-        store(key, other_value)
-      end
-    end
-  end
-  # Non-destructive version of Hash#recursive_merge method.
-  def recursive_merge(other_hash)
-    dup.recursive_merge!(other_hash)
-  end
-end
-
-
-

data/lib/dokkit/models/share/builtin.rf

@@ -1,28 +0,0 @@
-require 'rubygems'
-require 'dokkit'
-require 'dokkit/app'
-
-EXCLUDE_FL = /TEMPLATE/
-
-desc "Bootstrap a new documentation project based on #{ENV['PROJECT']} model."
-task :create do
-  rule '' do |t|
-      base_path = File.join(Dokkit.fetch_models[ENV['PROJECT']], 'lib/model')
-      file_to_copy = FileList.new(["#{base_path}/doc/**/*", "#{base_path}/[A-Z]*"]) do |fl|
-        fl.exclude(EXCLUDE_FL).to_a      
-      end
-      copy_model_files base_path, file_to_copy, t.name
-  end
-end
-
-def copy_model_files(base_path, source_fl, dest_dir)
-  puts "Creating model structure on directory '#{dest_dir}'"
-  source_fl.each do |complete_fn|
-    next if File.directory?(complete_fn)
-    complete_fn.scan(/#{base_path}\/(.*)/) do |file_to_copy|
-      dirname = File.join(dest_dir, File.dirname(file_to_copy.to_s))
-      mkdir_p(dirname, :verbose => false) unless File.exists?(dirname)
-      cp complete_fn, dirname, :verbose => true
-    end
-  end
-end

data/lib/dokkit/page.rb

@@ -1,195 +0,0 @@
-#                                                                          
-# File 'page.rb' created on 09 ott 2007 at 15:56:08.                    
-#
-# See 'dokkit.rb' or +LICENSE+ for licence information.                      
-#                                                                          
-# (C) 2006, 2007 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
-#                                                                          
-
-require 'yaml'
-require 'dokkit/hash'
-
-class Module
-  def track_methods
-    @methods_in_order = []
-    class << self
-      attr_reader :methods_in_order
-      def method_added( method_name )
-        @methods_in_order << method_name.id2name
-      end
-    end
-  end
-end
-
-module DokkitPage
-
-  # The base path for config resolution
-  attr_reader :config_path
-
-  def init(config_page, &blk)
-    self.class.methods_in_order.each do |init_meth|
-      self.send(init_meth, config_page, &blk) if init_meth =~ /init\_/
-    end
-  end
-
-  def load_model_config
-    load_config('model.yaml')
-  end
-  
-  def config(basename)
-    basename.each { |fn| @config_files.push "#{fn}#{@config_defext if File.extname(fn).empty?}" } if basename
-  end    
-
-  def load_configs
-    @config_files.each { |fn| load_config(fn) }
-    @config
-  end
-
-  def load_config(fn)
-    complete_fn = config_fn(fn)
-    if File.exists?(complete_fn) 
-      Rake.register_dependency(complete_fn)
-      result = @config.recursive_merge!( YAML::load( File.open(complete_fn) ) )
-      if result.has_key?('document')
-        if result['document'].has_key?('config')
-          config(result['document'].delete('config'))
-        end
-        if result['document'].has_key?('layout')
-          layout(result['document'].delete('layout'))
-        end
-      end
-      result
-    else
-      nil
-    end
-  end
-
-  def config_fn(fn)
-    if File.exists?( complete_fn = fn)
-      return complete_fn
-    elsif File.exists?( complete_fn = File.join(base_path, File.dirname(template_name), fn) )
-      return complete_fn
-    elsif File.exists?( complete_fn = File.join(config_path, fn))
-      return complete_fn
-    elsif File.exists?( complete_fn = File.join(Dokkit.model_config_dir(@config['model']['name']), fn))
-      return complete_fn
-    elsif File.exists?( complete_fn = File.join(Dokkit.model_config_dir(@config['model']['name']), @config['model']['name'] + @config_defext))
-      return complete_fn
-    else
-#      warn "WARNING: Config file #{fn} not found!"
-      return fn
-    end
-  end
-
-  # Find all COMMON.yaml files from given dir up to FS root.
-  def resolve_common_configs(dir, arr = []) # :nodoc:
-    # defer to parent dir first
-    parent = File.expand_path(File.join(dir, '..'))
-    resolve_common_configs(parent,arr) unless parent == dir # at root    
-    fn = File.join(dir,'COMMON.yaml')    
-    arr << fn if (File.exists?(fn) && File.readable?(fn))
-    arr
-  end  
-  
-  def config_hash(key)
-    return @config[key] if @config.has_key?(key)
-    nil
-  end
-
-  # Find and evaluate all COMMON.yaml files from page dir up to FS root.
-  def eval_common_configs
-    common_configs = resolve_common_configs(File.expand_path(File.dirname(template_filename)))            
-    common_configs.each { |fn| @config_files.push fn }
-  end # method
-  
-end
-
-module Rote
-
-  class Page
-
-    include DokkitPage
-
-    track_methods
-    alias page_initialize initialize
-
-    def initialize(config_page, &blk)
-      init(config_page, &blk)
-    end
-
-    def page_initialize(config_page)
-      config_page = { :pages_dir => '.', :layout_dir => '.' }.merge(config_page)
-      @template_text = nil
-      @template_name = nil
-      @layout_names = []
-      @content_for_layout = nil
-      @result = nil
-      @layout_defext = config_page[:layout_defext]
-      @layout_path = config_page[:layout_dir][STRIP_SLASHES,1]
-      @layout_text = nil
-      @base_path = config_page[:pages_dir][STRIP_SLASHES,1]
-      
-      @page_filters, @post_filters = [], []
-
-      # read in the template. Layout _may_ get configured later in page code
-      # We only add the pages_dir if it's not already there, because it's
-      # easier to pass the whole relative fn from rake...
-      # template_name always needs with no prefix.
-      tfn = @template_name = config_page[:fn]
-      read_template(tfn)
-      
-      layout(File.basename(tfn, config_page[:template_defext]))
-      
-      # Yield to the (extension mapping) block
-      yield self if block_given?
-      
-      # Eval COMMON.rb's
-      eval_common_rubys
-      
-      # get script filenames, and eval them if found
-      tfn = ruby_filename # nil if no file      
-      instance_eval(File.read(tfn),tfn) if tfn         
-    end
-
-    def init_dokkit_page(config_page, &blk)
-      config_page.with_defaults!(
-       { :pages_dir => '.', 
-         :layout_dir => '.', 
-         :config_dir => '.',
-         :layout_defext => '.html',
-         :config_defext => '.yaml',
-         :template_defext => '.dpl'
-       }
-      )
-     @config_files = []
-     @config = { }
-     @config_path = config_page[:config_dir][STRIP_SLASHES,1]
-     @config_defext = config_page[:config_defext]
-     
-     @template_name = tfn = config_page[:fn] 
-     @base_path = config_page[:pages_dir][STRIP_SLASHES,1]      
-      
-     page_initialize(config_page, &blk)
-           
-     load_model_config
-     eval_common_configs
-     config(File.basename(tfn, config_page[:template_defext]))
-     @config = load_configs
-    end
-
-    private
-        
-    def layout_fn(fn = nil)
-      if File.exists?(complete_fn = File.join(layout_path,fn))
-        return complete_fn
-      elsif File.exists?(complete_fn = File.join(Dokkit.model_layout_dir(@config['model']['name']), fn))
-        return complete_fn
-      elsif File.exists?(complete_fn = File.join(Dokkit.model_layout_dir(@config['model']['name']), @config['model']['name'] + @layout_defext))
-        return complete_fn
-      else
-        raise "Layout file #{fn} not found!"
-      end
-    end
-    
-  end
-end

data/lib/dokkit/render_task_factory.rb

@@ -1,91 +0,0 @@
-#                                                                          
-# File 'render_task_factory.rb' created on 18 Nov 2007 at 16:01:42.                    
-#
-# See 'dokkit.rb' or +LICENSE+ for licence information.                      
-#                                                                          
-# (C) 2006, 2007 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
-#                                                                          
-
-require 'singleton'
-require 'rote/format/html'
-require 'dokkit/filters'
-require 'dokkit/dokkittasks'
-
-module Dokkit
-  class RenderTaskFactory
-    include Singleton
-    def create_render_html(name = :render_html)
-      Rote::DocTask.new(name) do |task|
-        task.output_dir = 'html'
-
-        task.layout_dir = 'doc/layouts'
-        task.config_dir = 'doc/config'
-
-        task.pages.dir = 'doc/pages'
-        task.pages.include('**/*')
-        task.pages.exclude('**/*.yaml')
-
-        task.res.dir = 'doc/res/html'
-        task.res.include('**/*')
-        
-        yield task if block_given?
-        
-        task.ext_mapping(/dpl/, 'html', task.output_dir) do |page|
-          page.extend Rote::Format::HTML
-          page.page_filter Dokkit::Filters::Deplate.new('html-notemplate')
-        end
-      end
-    end
-    def create_render_tex(name = :render_tex)
-      Rote::DocTask.new(name) do |task|
-        task.output_dir = 'tex'
-
-        task.layout_dir = 'doc/layouts'
-        task.layout_defext = '.tex'
-        
-        task.config_dir = 'doc/config'
-
-        task.pages.dir = 'doc/pages'
-        task.pages.include('**/*')
-        task.pages.exclude('**/*.yaml')
-
-        task.res.dir = 'doc/res/tex'
-        task.res.include('**/*')
-        
-        yield task if block_given?
-        
-        task.ext_mapping(/dpl/, 'tex', task.output_dir) do |page|
-          #FIXME: render_tex task must have its own format extension
-          page.extend Rote::Format::HTML
-          page.page_filter Dokkit::Filters::Deplate.new('latex-notemplate')
-        end
-      end
-    end
-    def create_render_text(name = :render_text)
-      Rote::DocTask.new(name) do |task|
-        task.output_dir = 'text'
-
-        task.layout_dir = 'doc/layouts'
-        task.layout_defext = '.text'
-        
-        task.config_dir = 'doc/config'
-
-        task.pages.dir = 'doc/pages'
-        task.pages.include('**/*')
-        task.pages.exclude('**/*.yaml')
-
-        task.res.dir = 'doc/res/text'
-        task.res.include('**/*')
-        
-        yield task if block_given?
-        
-        task.ext_mapping(/dpl/, 'text', task.output_dir) do |page|
-          #FIXME: render_text task must have its own format extension
-          page.extend Rote::Format::HTML
-          page.page_filter Dokkit::Filters::Deplate.new('plain')
-        end
-      end
-    end
-  end
-end
-

data/tests/data/output/simple_document/README

@@ -1,57 +0,0 @@
-This is 'simple_document' a simple document model included in the core
-distribution of dokkit. Check http://rubyforge.org/dokkit/ for other
-models. 
-
-To modify this document simply edit 'doc/pages/simple_document.dpl'. To get further
-information about the wiki syntax to be used please check http://deplate.sf.net/
-
-To render this document in html, type:
-
-  dokkit render_html
-
-from any subdirectory contained in the top-level directory (this one).
-  
-To render this document in TeX, type:
-
-  dokkit render_tex
-
-In either case, you should get the output in a (created) 'output'
-directory:
-
-  in 'output/html' you get html output
-  in 'output/tex' you get tex output
-
-  ... and so on...
-
-Once you have rendered the document, running the command again will appear
-to do nothing, because only changed resources are re-rendered. To
-clean the output and start over:
-
-  dokkit clobber
-
-Alternatively, modify the page or resource files, and rerun 
-
-  dokkit render_html
-
-  or
-
-  dokkit render_tex
-
-to transform only the modified resource.
-
-* WHAT'S NEXT?
-
- - See what else you can do by typing:
-
-    dokkit --tasks
-
- - Modify the configuration of the document by editing
-   'doc/config/simple_document.yaml'
-
- - Create a new document by typing: 
-     
-    dokkit create_new_page new_document
-
-For further information about dokkit see http://dokkit.rubyforge.org/
-
-

data/tests/data/output/simple_document/Rakefile

@@ -1,7 +0,0 @@
-# Rakefile for simple_document project model
-
-require 'dokkit'
-require 'dokkit/app'
-import File.join(Dokkit.projects_dir,"simple_document","lib/rakefile.rf")
-
-

data/tests/data/output/simple_document/doc/config/simple_document.yaml

@@ -1,5 +0,0 @@
-title: A Simple Document
-author: John Doe
-
-
-

data/tests/data/output/simple_document/doc/pages/simple_document.dpl

@@ -1,12 +0,0 @@
-* Abstract
-From a document of Jim{cite: author:jim}
-
-* Introduction
-
-* Main section
-
-** Subsection One
-** Subsection Two
-
-* Conclusions
-