dokkit 0.2.0 → 0.3.0

data/lib/dokkit/document.rb

@@ -0,0 +1,221 @@
+#
+# File 'document.rb' created on 13 gen 2008 at 18:49:57.
+#
+# See 'dokkit.rb' or +LICENSE+ for licence information.
+#
+# (C) 2006, 2007 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors).
+#
+
+require 'ostruct'
+require 'yaml'
+require 'erb'
+require 'dokkit/logger'
+require 'dokkit/consolelog'
+require 'dokkit/pathhelper'
+require 'dokkit/cachemanager'
+require 'dokkit/recursivemerge'
+require 'dokkit/pathhelper'
+require 'dokkit/filters/all'
+require 'dokkit/extension/filehelper'
+
+module Dokkit
+  class Document
+    DEFAULT_FILTER_CHAIN = { 
+      'html' => ['deplate-html'],
+      'latex' => ['deplate-latex'],
+      'text' => ['deplate-text'],
+      'nil' => ['nil']
+    }    
+    include Extension::FileHelper, PathHelper
+    attr_reader :document, :taskconfig
+    attr_reader :document_basename
+    attr_reader :configs, :targets, :layouts
+    attr_reader :filter_chain
+    attr_reader :configuration
+    attr_reader :source_text
+    attr_reader :prerequisites
+    attr_reader :logger
+    def initialize(document, taskconfig, rendered = [], &blk)
+      @logger = Log::ConsoleLog.consolelog
+      @document, @taskconfig, @rendered = document, taskconfig, rendered
+      @document_basename = File.basename(document)
+      @stripped_document = strip_ext(@document)
+      @layouts, @targets, @prerequisites, @filter_chain = { }, { }, { }, { }
+      @configs = []      
+      @configuration = Hash.new do |h, k|
+        @logger.warn("Configuration key '#{k}' not defined in '#{targets[@format]}'!")
+        h[k] = "'#{k}' not defined!"
+      end
+      @configuration.extend ConfigHash
+      @source_text = read_source
+      @cache = CacheManager.instance
+      
+      yield self if block_given?
+      
+      collect_resources
+    end
+    def render(format)
+      @format = format
+      unless @source_text.nil?
+        erb = ERB.new(@source_text)
+        erb.filename = @document
+        @content_for_layout = apply_filters(erb.result(binding), format)
+      end
+      unless @layouts[format].empty?
+       @layouts[format].each do |layout_fn|
+         erb = ERB.new(File.read(layout_fn)) 
+         erb.filename = layout_fn
+         @content_for_layout = erb.result(binding)
+       end  
+      end
+      @content_for_layout
+    end
+    
+    private
+
+    def extract_meta!(text)
+      meta_regexp = /\A-{3}$(.*?)-{3}$/m
+      meta = text.scan(meta_regexp).to_s
+      text.sub!(meta_regexp, '')
+      return meta
+    end
+    def render_partial(document_fn, format = @format, &blk)
+      unless @rendered.include?(document)
+        result = Document.new(File.join(@taskconfig.document_dir, document_fn), @taskconfig, @rendered << document, &blk).render(format)
+        @cache.add_dependency(targets[format], File.join(@taskconfig.document_dir, document_fn))
+        @rendered.clear
+      else
+        @logger.error("Circular dependency detected in '#{document}', aborting.")
+      end
+      result
+    end
+    def collect_resources
+      collect_configs
+      collect_targets
+      collect_layouts
+      collect_prerequisites
+    end    
+    def collect_prerequisites
+      @targets.each_key do |format|
+        @prerequisites[format] = []
+        @prerequisites[format] << document
+        @prerequisites[format].concat @configs
+        @prerequisites[format].concat(@layouts[format]) if @layouts[format]
+        @prerequisites
+      end
+    end
+    def collect_configs
+      @configs << (config_fn_helper(@stripped_document, @taskconfig)) if File.exists?(config_fn_helper(@stripped_document, @taskconfig))
+      @configs.concat(resolve_common_configs(File.dirname(@document)))
+      @configs << (@stripped_document + '.yaml') if File.exists?(@stripped_document + '.yaml')
+      
+      meta_configuration = YAML::load(extract_meta!(@source_text))
+      if meta_configuration
+        if meta_configuration.has_key?('config')
+          (@configs << get_config_fns(meta_configuration['config'])).flatten!
+          meta_configuration.delete('config')
+        end        
+      end
+      
+      @configs.each do |config_fn|
+        @configuration.recursive_merge!(YAML::load(File.open(config_fn)))
+        if @configuration.has_key?('config')
+          (@configs << get_config_fns(@configuration['config'])).flatten!
+          @configuration.delete('config')
+        end
+      end
+      
+      @configuration.recursive_merge!(meta_configuration) if meta_configuration  
+    end
+    def resolve_common_configs(dir, arr = [])
+      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 build_config_fn(fn)
+      result_fn = fn
+      if File.extname(fn).empty?
+        result_fn += '.yaml'
+      end
+      result_fn = File.join(@taskconfig.config_dir, result_fn)
+    end
+    def get_config_fns(configuration)
+      if configuration.is_a?(String)
+        result = build_config_fn(configuration)
+      elsif configuration.is_a?(Array)
+        result = configuration.collect do |fn|
+          fn = build_config_fn(fn)
+        end
+      else
+        @logger.fail('Invalid config file value.')
+      end
+      result
+    end
+    def collect_targets
+      if @configuration.has_key?('render_in')
+        @configuration['render_in'].each do |fmt|
+          if fmt.class != Hash
+            @targets[fmt] = output_fn_helper(@stripped_document, ".#{fmt}", @taskconfig)
+            @filter_chain[fmt] = DEFAULT_FILTER_CHAIN[fmt]
+          else
+            fmt.each do |format, configuration|
+              if(configuration.empty?)
+                @targets[format] = output_fn_helper(@stripped_document, ".#{format}")
+                @filter_chain[fmt] = DEFAULT_FILTER_CHAIN[fmt]                
+              else
+                output, ext = @taskconfig.output_dir, ".#{format}"
+                ext = configuration['ext'] if configuration.has_key?('ext')
+                output = File.join(@taskconfig.output_dir, configuration['output']) if configuration.has_key?('output')
+                @targets[format] = File.join(output, strip_ext(@document_basename) + ext)
+                if configuration.has_key?('filters')
+                  @filter_chain[format] = configuration['filters']
+                end
+              end
+            end
+          end
+        end
+      else
+        @targets['html'] = output_fn_helper(@stripped_document, '.html', @taskconfig)
+        @filter_chain['html'] = DEFAULT_FILTER_CHAIN['html']
+      end
+    end
+    def collect_layouts
+      @targets.each do |format, target|
+        layout_fn = []        
+        layout_ext = File.extname(target)
+        layout_fn << (layout_fn_helper(@stripped_document, layout_ext, @taskconfig)) if File.exists?(layout_fn_helper(@stripped_document, layout_ext, @taskconfig))
+        layout_fn << (@stripped_document + layout_ext) if File.exists?(@stripped_document + layout_ext)
+        if @configuration.has_key?('layout')
+          @configuration['layout'].each do |layout|
+            config_layout_fn = strip_ext(layout)
+            layout_fn << File.join(@taskconfig.layout_dir, config_layout_fn + layout_ext) if File.exists?(File.join(@taskconfig.layout_dir, config_layout_fn + layout_ext))
+            layout_fn << (config_layout_fn + layout_ext) if File.exists?(config_layout_fn + layout_ext)
+          end
+        end
+        @logger.warn("Layout not found for '#{target}'!") if layout_fn.empty?
+        @layouts[format] = layout_fn.uniq.reverse
+      end
+    end
+    def read_source
+      File.read(document)
+    end
+    def apply_filters(text, target)
+      filters = []
+      chain = @filter_chain[target]
+      if chain
+        @filter_chain[target].each do |name|
+          begin
+            filters << Filters[name]
+          rescue
+            @logger.warn("Filter '#{name}' not found, ignored.")
+          end
+        end
+        filters.inject(text) { |s, f| f.filter(s) }
+      else
+        @logger.error("Don't know how to render in '#{target}' format!")
+      end
+    end
+  end
+end

data/lib/dokkit/dokkitlib.rb

@@ -0,0 +1,68 @@
+#                                                                          
+# File 'dokkitlib.rb' created on 18 feb 2008 at 17:54:20.                    
+#
+# See 'dokkit.rb' or +LICENSE+ for licence information.                      
+#                                                                          
+# (C) 2008 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
+#                                                                          
+
+require 'ostruct'
+require 'rake'
+require 'rake/tasklib'
+require 'dokkit/defaults'
+require 'dokkit/taskconfig'
+require 'dokkit/pathhelper'
+require 'dokkit/consolelog'
+
+module Dokkit
+  class DokkitLib < Rake::TaskLib
+    include PathHelper, Rake::TaskManager
+    attr_reader :ns
+    attr_reader :logger
+    attr_reader :model
+    attr_accessor :config
+    def initialize(model, namespace = 'dokkit', opts = { })      
+      @ns = namespace
+      @model = model
+      @config = model.config
+      @logger = Log::ConsoleLog.consolelog
+      
+      pre_block_configuration
+      
+      yield self if block_given?
+      
+      post_block_configuration
+      
+      check_directories if opts[:check_dir]
+      define_dokkit_tasks 
+    end
+    def dokkit_task(*args, &block)
+      task_name, arg_names, needs = resolve_args(args.dup)
+      task(*args, &block) unless Rake::Task.task_defined?("#{@ns}:#{task_name}")
+    end
+    
+    private
+    
+    def check_directories
+      unless @config.directories.empty?
+        @config.directories.each_value do |dir|
+          @logger.error("Directory '#{dir}' does not exist") unless (dir =~ /output|cache/ || File.exists?(dir))
+        end
+      end
+    end
+    def pre_block_configuration
+      nil
+    end
+    def post_block_configuration
+      nil
+    end
+    def define_dokkit_tasks
+      namespace @ns do
+        private_methods.select { |meth| meth =~ /define_dokkit_/ and not meth =~ /define_dokkit_tasks/ }.each do |method|
+          self.send(method)
+        end
+      end
+    end
+  end
+end
+

data/lib/dokkit/extension/extension.rb

@@ -0,0 +1,15 @@
+#                                                                          
+# File 'extension.rb' created on 28 feb 2008 at 16:39:38.                    
+#
+# See 'dokkit.rb' or +LICENSE+ for licence information.                      
+#                                                                          
+# (C) 2008 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
+#                                                                          
+
+require 'dokkit'
+
+module Dokkit
+  module Extension
+    # space left blank
+  end
+end

data/lib/dokkit/extension/filehelper.rb

@@ -0,0 +1,25 @@
+#                                                                          
+# File 'filehelper.rb' created on 28 feb 2008 at 16:40:57.                    
+#
+# See 'dokkit.rb' or +LICENSE+ for licence information.                      
+#                                                                          
+# (C) 2008 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
+#                                                                          
+
+require 'dokkit/extension/extension'
+
+module Dokkit
+  module Extension
+    module FileHelper
+      def relative(href)
+        thr = href
+        if thr.is_a?(String) && href[0,1] == '/'     
+          dtfn = File.dirname(document[/^#{taskconfig.document_dir}\/(.*)/,1]) + '/'
+          count = dtfn == './' ? 0 : dtfn.split('/').length
+          thr = ('../' * count) + href[1..href.length]
+        end        
+        thr
+      end      
+    end
+  end
+end

data/lib/dokkit/fileselection.rb

@@ -0,0 +1,44 @@
+#                                                                          
+# File 'fileselection.rb' created on 07 feb 2008 at 15:52:42.                    
+#
+# See 'dokkit.rb' or +LICENSE+ for licence information.                      
+#                                                                          
+# (C) 2006, 2007 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
+#                                                                          
+
+require 'rake'
+
+module Dokkit
+  module ExtMapping
+    attr_reader :extmapping
+    def extend(regexp=/.*/, &blk)
+      @extmapping ||= { }
+      (files.select { |file| file =~ regexp }).each do |file|
+        @extmapping[file] = blk
+      end
+    end
+  end
+  class FileSelection
+    attr_accessor :base_dir
+    alias :dir :base_dir
+    alias :dir= :base_dir=
+    def initialize(base_dir = '.')
+      @base_dir = base_dir
+      @includes = []
+      @excludes = []
+      yield self if block_given?
+    end
+    def include(*patterns)
+      patterns.each { |pattern| @includes << pattern }
+    end
+    def exclude(*patterns)
+      patterns.each { |pattern| @excludes << pattern }
+    end
+    def files
+      FileList.new(@base_dir) do |fl|
+        fl.exclude *@excludes.collect { |exclude| File.join(@base_dir, exclude) } unless @excludes.empty?
+        fl.include *@includes.collect { |include| File.join(@base_dir, include) } unless @includes.empty?
+      end.uniq.select { |fn| not File.directory?(fn) }
+    end
+  end
+end

data/lib/dokkit/filters/all.rb

@@ -0,0 +1,18 @@
+#                                                                          
+# File 'all_filters.rb' created on 18 feb 2008 at 17:13:12.                    
+#
+# See 'dokkit.rb' or +LICENSE+ for licence information.                      
+#                                                                          
+# (C) 2008 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
+#                                                                          
+
+require 'dokkit/filters/base'
+
+Dir[File.join(File.dirname(__FILE__), '*.rb')].each do |fn|
+  begin
+    require fn unless fn =~ /[\\\/]base.rb$/ or fn == 'all.rb'
+  rescue LoadError
+    nil
+  end
+end
+

data/lib/dokkit/filters/base.rb

@@ -0,0 +1,18 @@
+#                                                                          
+# File 'base.rb' created on 15 feb 2008 at 22:56:37.                    
+#
+# See 'dokkit.rb' or +LICENSE+ for licence information.                      
+#                                                                          
+# (C) 2008 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
+#                                                                          
+
+module Dokkit
+  module Filters
+    class Base
+      def filter(text)
+        nil
+      end
+    end
+  end
+end
+

data/lib/dokkit/filters/deplate.rb

@@ -6,38 +6,34 @@
 
 require 'deplate/converter'
 require 'deplate/core'
-require 'rote/filters/base'
+require 'dokkit/filters'
+require 'dokkit/filters/base'
 require 'dokkit/deplate/fmt/latex-notemplate'
 require 'dokkit/deplate/fmt/html-notemplate'
 
 module Dokkit
   module Filters
-
-    def Filters.declare_formatters
-      ::Deplate::Core.declare_formatter(::Deplate::Formatter::LatexNoTemplate,'latex-notemplate')
-      ::Deplate::Core.declare_formatter(::Deplate::Formatter::HTMLNoTemplate,'html-notemplate')
-    end
-
-    #####
-    ## Page filter that converts emacs-wiki formatting in various formats (tex, html,
-    ## docbook, plain text, etc.) using deplate.
-    ##
-    class Deplate < Rote::Filters::TextFilter
-
-      Filters.declare_formatters
-
-      # Create a new filter instance. If a block is defined returns a Deplate::Converter instance.
-      # You can supply options directly to the instance. See deplate docs for a full list
-      # of options.
-      def initialize(formatter)
-        super()
-        @deplate = ::Deplate::Converter.new(formatter) { |instance| yield(instance) if block_given? }
-      end      
-      
-      def handler(text,page)
-        @deplate.convert_string(text) 
+    class DeplateHTML < Base
+      def filter(text)
+        ::Deplate::Core.declare_formatter(::Deplate::Formatter::HTMLNoTemplate,'html-notemplate')        
+        ::Deplate::Converter.new('html-notemplate').convert_string(text)
       end      
     end    
+    class DeplateLatex < Base
+      def filter(text)
+        ::Deplate::Core.declare_formatter(::Deplate::Formatter::LatexNoTemplate,'latex-notemplate')        
+        ::Deplate::Converter.new('latex-notemplate').convert_string(text)
+      end      
+    end        
+    class DeplateText < Base
+      def filter(text)
+        ::Deplate::Converter.new('plain').convert_string(text)
+      end      
+    end            
   end
 end
     
+Dokkit::Filters.register('deplate-html') { Dokkit::Filters::DeplateHTML.new  }
+Dokkit::Filters.register('deplate-latex') { Dokkit::Filters::DeplateLatex.new }
+Dokkit::Filters.register('deplate-text') { Dokkit::Filters::DeplateText.new }
+

data/lib/dokkit/filters/maruku.rb

@@ -0,0 +1,23 @@
+#                                                                          
+# File 'maruku.rb' created on 15 feb 2008 at 22:58:04.                    
+#
+# See 'dokkit.rb' or +LICENSE+ for licence information.                      
+#                                                                          
+# (C) 2008 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
+#                                                                          
+
+require 'dokkit/filters/base'
+require 'dokkit/filters'
+require 'maruku'
+
+module Dokkit
+  module Filters
+    class MarukuHTML < Base
+      def filter(text)
+        Maruku.new(text).to_html
+      end
+    end
+  end
+end
+
+Dokkit::Filters.register('maruku-html') { Dokkit::Filters::MarukuHTML.new }

data/lib/dokkit/filters/nil.rb

@@ -0,0 +1,23 @@
+#                                                                          
+# File 'nil.rb' created on 18 mar 2008 at 12:41:27.                    
+#
+# See 'dokkit.rb' or +LICENSE+ for licence information.                      
+#                                                                          
+# (C) 2008 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
+#                                                                          
+
+require 'dokkit/filters/base'
+require 'dokkit/filters'
+
+module Dokkit
+  module Filters
+    class Nil < Base
+      def filter(text)
+        text
+      end
+    end
+  end
+end
+
+Dokkit::Filters.register('nil') { Dokkit::Filters::Nil.new }
+

data/lib/dokkit/filters.rb

@@ -1,26 +1,34 @@
-#--
-# Require all filters
-# (c)2005, 2006 Ross Bamford (and contributors)
+#                                                                          
+# File 'filters.rb' created on 18 feb 2008 at 14:25:19.                    
 #
-# See 'rote.rb' or LICENSE for licence information.
-# $Id: filters.rb 156 2006-01-05 01:13:43 +0000 (Thu, 05 Jan 2006) roscopeco $
-#++
+# See 'dokkit.rb' or +LICENSE+ for licence information.                      
+#                                                                          
+# (C) 2006, 2007 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
+#                                                                          
 
-# Everyone requires this, we need to get it loaded first.
-require 'rote/filters/base'
-
-# This now requires conservatively, ignoring any filters that
-# throw a LoadError. This allows a simple 'require rote/filters' to
-# be used to load all filters _for which dependencies are
-# available_.
-Dir[File.join(File.dirname(__FILE__), 'filters/*.rb')].each do |fn|
-  begin
-    require fn unless fn =~ /[\\\/]base.rb$/
-  rescue LoadError
-
-    # ignore, different filters require different library
-    # support.
+require 'dokkit'
+require 'dokkit/consolelog'
 
+module Dokkit
+  module Filters
+    @filters = { }
+    @logger = Log::ConsoleLog.consolelog
+    def Filters.register(name, &blk)
+      @filters[name] = blk
+    end
+    def Filters.[](name)
+      filter = @filters[name]
+      if filter
+        @filters[name].call
+      else
+        @logger.error("Filter '#{name}' is not defined!")
+      end
+    end
+    def Filters.filters
+      return @filters
+    end
+    def Filters.clean
+      @filters = { }
+    end
   end
 end
-

data/lib/dokkit/logger.rb

@@ -0,0 +1,73 @@
+#                                                                          
+# File 'logger.rb' created on 23 feb 2008 at 15:46:54.                    
+#
+# See 'dokkit.rb' or +LICENSE+ for licence information.                      
+#                                                                          
+# (C) 2008 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
+#                                                                          
+
+#require 'dokkit'
+
+module Dokkit
+  module Log
+    ERROR = 0
+    WARNING = 1
+    INFO = 2
+    DEBUG = 3
+    class LogMessage
+      attr_reader :text
+      attr_reader :level
+      def initialize(text, level)
+        @text, @level = text, level
+      end
+    end
+    class Logger
+      class << self
+        def logger
+          @logger ||= Logger.new
+        end
+        def clear
+          @logger = nil
+        end
+      end
+      attr_reader :observers
+      attr_reader :last_message
+      attr_reader :level
+      def initialize
+        @observers = []
+        @level = INFO
+      end
+      def level=(new_level)
+        new_level = Log::DEBUG if new_level > Log::DEBUG
+        new_level = Log::ERROR if new_level < Log::ERROR
+        @level = new_level
+      end
+      def attach(observer)
+        (@observers << observer).last
+      end
+      def detach(observer)
+        @observers.delete(observer)
+      end
+      def notify
+        @observers.each { |observer| observer.update }
+      end
+      def message(message)
+        @last_message = message
+        notify
+        @last_message
+      end
+      def info(text)
+        message({ :text => text, :level => Log::INFO }) if level >= INFO
+      end
+      def error(text)
+        message({ :text => text, :level => ERROR }) if level >= ERROR
+      end
+      def warn(text)
+        message({ :text => text, :level => WARNING }) if level >= WARNING
+      end
+      def debug(text)
+        message({ :text => text, :level => Log::DEBUG }) if level >= DEBUG
+      end      
+    end
+  end
+end

data/lib/dokkit/model.rb

@@ -0,0 +1,34 @@
+#                                                                          
+# File 'model.rb' created on 10 mar 2008 at 13:39:48.                    
+#
+# See 'dokkit.rb' or +LICENSE+ for licence information.                      
+#                                                                          
+# (C) 2008 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
+#                                                                          
+
+require 'yaml'
+require 'dokkit/taskconfig'
+require 'dokkit/cachemanager'
+
+module Dokkit
+  class Model
+    class << self
+      def init(name = 'model', &blk)
+        @model ||= Model.new(name, &blk)
+      end
+    end
+    attr_accessor :config
+    attr_reader :name, :cache
+    def initialize(name, &blk)
+      @name = name
+      @config = TaskConfig.new       
+              
+      yield self if block_given?
+
+      @cache = CacheManager.instance
+      @cache.init('deps.yaml', @config.cache_dir)
+      
+      self      
+    end
+  end
+end