dokkit 0.1.1 → 0.2.0

data/lib/dokkit/app.rb

@@ -1,305 +1,260 @@
-# Dokkit application class
-# (c)2006 Andrea Fazzi (and contributors)
+#                                                                          
+# File 'app.rb' created on 09 ott 2007 at 16:00:28.                    
 #
-# See 'dokkit.rb' or LICENSE for licence information.
+# See 'dokkit.rb' or +LICENSE+ for licence information.                      
+#                                                                          
+# (C) 2006, 2007 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
+#                                                                          
 
 require 'optparse'
 require 'rake'
 
-DEFAULT_PROJECT_MODEL = "tech_report"
-
-module Rake
-
-  class Application
-
-    def do_option(opt, value)
-      case opt
-      when '--directory'
-	Dir.chdir( File.expand_path(value) )
-	options.directory = true
-      when '--dry-run'
-	verbose(true)
-	nowrite(true)
-	options.dryrun = true
-	options.trace = true
-      when '--help'
-	help
-	exit
-      when '--libdir'
-	$:.push(value)
-      when '--nosearch'
-	options.nosearch = true
-      when '--prereqs'
-	options.show_prereqs = true
-      when '--quiet'
-	verbose(false)
-      when '--rakefile'
-	RAKEFILES.clear
-	RAKEFILES << value
-      when '--rakelibdir'
-	options.rakelib = value.split(':')
-      when '--require'
-        begin
-          require value
-        rescue LoadError => ex
-          begin
-            rake_require value
-          rescue LoadError => ex2
-            raise ex
+module Dokkit
+  # The path from where to copy the model structure.
+  MODEL_PATH = 'lib/model'
+  # The path from which to load the built-in layout of the model. 
+  MODEL_LAYOUT_PATH = 'lib/doc/layouts'
+  # The path from which to load the built-in config of the model.
+  MODEL_CONFIG_PATH = 'lib/doc/config'
+  # Dokkit module singleton methods.
+  class << self
+    # Current Dokkit Application
+    def application
+      @application ||= Dokkit::Application.new(dokkit_lib)
+    end
+    # Set the current Rake application object.
+    def application=(app)
+      @application = app
+    end
+    # Return the original directory where the Dokkit application was started.
+    def original_dir
+      application.original_dir
+    end
+    def dokkit_lib
+      lib = nil
+      unless lib = ENV['DOKKIT_LIB']
+        $:.each do |it|
+          if File.exists?(File.join(it,'dokkit/dokkittasks.rb'))
+            lib = it
+            break
           end
         end
-      when '--silent'
-	verbose(false)
-	options.silent = true
-      when '--tasks'
-	options.show_tasks = true
-	options.show_task_pattern = Regexp.new(value || '.')
-      when '--trace'
-	options.trace = true
-	verbose(true)
-      when '--usage'
-	usage
-	exit
-      when '--verbose'
-	verbose(true)
-      when '--version'
-	puts "rake, version #{RAKEVERSION}"
-	exit
-      when '--classic-namespace'
-	require 'rake/classic_namespace'
-	options.classic_namespace = true
-      else
-	fail "Unknown option: #{opt}"
       end
+      lib
     end
-
-    def handle_options
-      options.rakelib ||= 'rakelib'
-      options.each { |opt, value| do_option(opt, value) }
+    # Return the directory containing models related files.
+    def projects_dir
+      File.join(dokkit_lib, 'dokkit', 'models')
     end
-  
-    def display_tasks_and_comments
-      displayable_tasks = Rake::Task.tasks.select { |t|
-	t.comment && t.name =~ options.show_task_pattern
-      }
-      width = displayable_tasks.collect { |t|
-	t.name.length
-      }.max
-      displayable_tasks.each do |t|
-	printf "dokkit %-#{width}s  # %s\n", t.name, t.comment
+
+    def fetch_models
+      models = { }
+      Dir["#{Gem.dir}/gems/dokkit-model-*"].each do |path|
+        path.scan(/dokkit-model-(.+)-(\d\.\d\.\d)/) { models[$1] = path }
+      end
+      Dir["#{File.expand_path("~/.dokkit/models/*")}"].each do |path|
+        path.scan(/.dokkit\/models\/(.+)/) { models[$1] = path }
       end
+      models
     end
-
-    # Search for a Rakefile
-    def search_for_rakefile
-      initial_dir = here = Dir.pwd
-        while ! have_rakefile
-	  Dir.chdir("..")
-	  if Dir.pwd == here
-            Dir.chdir(initial_dir)
-	    return false
-	  end
-	  here = Dir.pwd
-        end
-      return true
+    # Return the full path from where to copy the model.
+    def model_dir(model)
+      File.join(fetch_models[model], MODEL_PATH)
+    end
+    # Return the full path from where to copy the model.
+    def model_layout_dir(model)
+      File.join(fetch_models[model], MODEL_LAYOUT_PATH)
+    end
+    # Return the full path from where to copy the model.
+    def model_config_dir(model)
+      File.join(fetch_models[model], MODEL_CONFIG_PATH)
+    end
+    # Return the directory containing the tests
+    def tests_dir
+      File.expand_path(File.join(dokkit_lib, '..', 'tests'))
     end
-
   end
 
-end
-
-module Dokkit
-
   # Command-line launcher for Dokkit.
   class Application
 
     attr_accessor :dokkit_lib
-    attr_accessor :debug
-    attr_accessor :tasks
-    attr_accessor :trace
-    attr_accessor :usage
-    attr_accessor :version
-    attr_accessor :rake
-    attr_accessor :rakefile
-    attr_accessor :rakeopts
-    attr_accessor :rake_env
-    attr_accessor :list_projects
+    
+    DEFAULT_PROJECT_MODEL = "simpledocument"
+    USAGE_PREAMBLE = <<-EOU
+Usage: dokkit [options] [task1] .. [taskN]
+
+Where [taskN] is a valid task or target name for the current project.
+Dokkit generates targets for each page source, and also defines a number
+of top-level tasks for various things. Use the '--tasks' option to get
+a list of valid tasks.
+
+In addition to the standard render_XXX tasks and those provided by any
+local configuration, the following 'special' tasks are recognised:
+
+  create <project>   Create a blank project from the built-in template using the #{DEFAULT_PROJECT_MODEL} project model.
+
+In non-standard environments, it may be necessary to set the DOKKIT_LIB
+variable to point to the location of Dokkit libraries.
+
+EOU
+    OPTIONS =  [
+      [ "--usage", "-u", GetoptLong::NO_ARGUMENT,
+        "Display usage information." ],
+      [ "--help", "-h", GetoptLong::NO_ARGUMENT,
+        "Synonim for usage."],
+      [ "--project", "-P", GetoptLong::REQUIRED_ARGUMENT,
+        "Set the PROJECT model to create. Use --list for the full list of project models available."],
+      [ "--directory","-D", GetoptLong::REQUIRED_ARGUMENT,
+        "Change to directory DIR before reading the rakefiles or doing anything else."],
+      [ "--list",    "-l", GetoptLong::NO_ARGUMENT,
+        "Display the list of the project models available." ],
+      [ "--version", "-V", GetoptLong::NO_ARGUMENT,
+        "Display the version number and quit." ],
+      [ "--trace", "-t", GetoptLong::NO_ARGUMENT,
+        "Enable trace-level output (debugging)"],
+      [ "--tasks", "-T", GetoptLong::NO_ARGUMENT,
+        "Display the list of the tasks available."],
+      [ "--nosearch", "-N", GetoptLong::NO_ARGUMENT,
+        "Do not search parent directories for the Rakefiles. Only builtin tasks can be invoked."]
+    ]
 
     @@project_dirs = nil
 
     # Create a new Application instance, processing command-line arguments,
-    # optionally passing +self+ to the supplied block for further 
+    # optionally passing +self+ to the supplied block for further
     # configuration.
-
     def initialize(dokkit_lib) # :yield: self if block_given?
       # init vars
-      @@project_dirs = ($:.collect { |dir| File.join(dir,"dokkit/projects")}).concat(Array["~/.dokkit/projects"])
-
       @dokkit_lib = dokkit_lib
-      @debug = false
-      @tasks = false
-      @trace = false
-      @usage = false
-      @version = false
-      @list_projects = false
-      @directory = false
-      @rf = false
-      @rakefile = "#{dokkit_lib}/dokkit/builtin.rake"
-      raise "Missing builtin.rake (expected at '#{@rakefile}')!" unless File.exists?(@rakefile)
-      
-      @rakeopts = ENV['RAKE_OPTS'] || ''
-      @rake_env = "PROJECT=#{@project}"
-
       ENV['PROJECT'] = @project = DEFAULT_PROJECT_MODEL
-      
-      @rake = Rake::Application.new
-
-      process_args
-      
       yield self if block_given?
     end
-    
-    # Gets the list of the directory to search into for project models
-    def Application.get_project_dirs
-      @@project_dirs
-    end 
+    # Application options from the command line
+    def options
+      @options ||= OpenStruct.new
+    end
+    # set an option
+    def do_option(opt,value)
+      case opt
+        when '--version'
+          options.version = true
+          print "dokkit, version #{DOKKITVERSION}\n"
+          exit
+        when '--directory'
+          options.directory = value
+          Dir.chdir(options.directory)
+        when '--tasks'
+          options.tasks = true
+          Rake.application.do_option('--tasks', nil)
+        when '--project'
+          ENV['PROJECT'] = @project = options.project = value
+        when '--list'
+          options.list_projects = true
+          Dokkit.fetch_models.each_key { |key| puts key }
+          exit
+        when '--usage'
+          options.usage = options.help = true
+          help
+          exit
+        when '--help'
+          options.usage = options.help = true
+          help
+          exit
+        when '--nosearch'
+          options.nosearch = true
+          Rake.application.do_option('--nosearch', nil)
+        when '--trace'
+          options.trace = true
+          Rake.application.do_option('--trace', nil)
+      end
+    end
 
-    # Run the application with the current options.
-    def run
+    def init
+      Rake.application.init('dokkit')
+    end
 
-      @rake.do_option("--libdir",dokkit_lib)
+    def clear
+      Rake.application.clear
+    end
 
-      if @version
-        print "dokkit, version #{DOKKITVERSION}\n"
+    def load_rakefile
+      Rake.application.init('dokkit')
+      Rake.application.load_rakefile
+    end
+    def load_builtin
+      raise "#{@project} model not found!" unless model_dir = Dokkit.fetch_models[@project]
+      Dir["#{File.join(model_dir, 'lib/tasks/builtin')}/*.{rake,rf}"].each { |name| Rake.application.add_import name }
+      Rake.application.load_imports
+    end
+    def [](task_name)
+      Rake.application[task_name]
+    end
 
-      elsif @tasks
-        if @rake.search_for_rakefile
-           @rake.do_option("--rakelibdir","#{dokkit_lib}/dokkit/")
-           @rake.do_option("--tasks",nil)
-           @rake.run
-        else
-           @rake.do_option("--tasks",nil)
-           @rake.do_option("--rakefile","#{rakefile}")
-           @rake.run
-        end
-      elsif @list_projects
-          show_all_projects
-      elsif @usage
-        show_usage()
-      else
-        if @trace
-          @rake.do_option("--trace",nil)
-        elsif @debug
-          @rake.do_option("--verbose",nil)
-        elsif @rf
-          @rake.do_option("--rakefile",@rf)
-        elsif @directory
-          @rake.do_option("--directory",@directory)
-        elsif @project
-          ENV['PROJECT'] = @project
+    def task_defined?(task)
+      Rake.application.task_defined?(task)
+    end
+    # check if a Rakefile exists in the current directory or in any parent directory.
+    def have_rakefile
+      Rake.application.have_rakefile
+    end
+    # search for a Rakefile in the current directory and in all parent directory.
+    def search_for_rakefile
+      initial_dir = here = Dir.pwd
+      while ! have_rakefile
+        Dir.chdir("..")
+        if Dir.pwd == here || options.nosearch
+          Dir.chdir(initial_dir)
+          return false
         end
-
-        if @rake.search_for_rakefile
-           @rake.do_option("--rakelibdir","#{dokkit_lib}/dokkit/")
-        else
-           @rake.do_option("--rakefile","#{rakefile}")
+        here = Dir.pwd
+      end
+      Dir.chdir(initial_dir)
+      true
+    end
+    # Run the application with the current options.
+    def run(args = nil)
+      begin
+        warn "Warning: No models found on this system! The task 'create' will not work!" if Dokkit.fetch_models.empty?
+        if args
+          ARGV.clear
+          ARGV.concat(args)
         end
-
-        @rake.run
-      
+        process_args
+        init
+        load_builtin
+        Rake.application.load_rakefile if search_for_rakefile
+        Rake.application.top_level
+        Rake.application = nil
       end
     end
-    
+
     private
 
+    def command_line_options
+      OPTIONS.collect { |lst| lst[0..-2] }
+    end
+
     # Process commandline
     def process_args
-      GetoptLong.new(
-        [ "--verbose", "-v", GetoptLong::NO_ARGUMENT ],
-        [ "--tasks",   "-T", GetoptLong::NO_ARGUMENT ],
-        [ "--trace",   "-t", GetoptLong::NO_ARGUMENT ],
-        [ "--usage",   "-u", GetoptLong::NO_ARGUMENT ],
-	[ "--project", "-P", GetoptLong::REQUIRED_ARGUMENT],
-	[ "--rakefile","-f", GetoptLong::REQUIRED_ARGUMENT],
-	[ "--directory","-D", GetoptLong::REQUIRED_ARGUMENT],
-	[ "--list",    "-l", GetoptLong::NO_ARGUMENT ],
-        [ "--help",    "-h", GetoptLong::NO_ARGUMENT ],
-        [ "--version", "-V", GetoptLong::NO_ARGUMENT ]
-      ).each { |opt,arg|
-        @debug = true if opt == '--verbose'
-        @trace = true if opt == '--trace'
-        @tasks = true if opt == '--tasks'
-	@project = arg if opt == '--project'
-        @rf = arg if opt == '--rakefile'
-	@directory = arg if opt == '--directory'
-        @list_projects = true if opt == '--list'
-        @usage = true if opt == '--usage' || opt == '--help'
-        @version = true if opt == '--version'
-      }
+      opts = GetoptLong.new(*command_line_options)
+      opts.each { |opt, value| do_option(opt, value) }
     end
-    
-    # Show all the projects present in the distro default dir $DOKKIT_LIB/dokkit/projects/
-    # and into the user dir $HOME/.dokkit/projects
-    def show_all_projects
-      puts "Searching in #{dokkit_lib}.."
-      puts "Available project models are:"
-      Dir["#{dokkit_lib}/dokkit/projects/**/Rakefile"].concat(Dir["#{File.expand_path("~/.dokkit/projects/**/Rakefile")}"]).each do |project| 
-        puts File.dirname(project).scan(/projects\/\w+\/*\w+/).to_s.gsub!(/projects\//,"")
+
+    def help
+      puts USAGE_PREAMBLE
+      puts "Recognized options are:"
+      puts
+      OPTIONS.sort.each do |long, short, mode, desc|
+        if mode == GetoptLong::REQUIRED_ARGUMENT
+          if desc =~ /\b([A-Z]{2,})\b/
+            long = long + "=#{$1}"
+          end
+        end
+        printf "  %-20s (%s)\n", long, short
+        printf "      %s\n", desc
       end
     end
 
-    # Display help text
-    def show_usage
-      print <<-EOM
-Usage: dokkit [options] [task1] .. [taskN]
-
-Where [taskN] is a valid task or target name for the current project. 
-Dokkit generates targets for each page source, and also defines a number
-of top-level tasks for various things. Use the '--tasks' option to get
-a list of valid tasks.
-
-Recognised options are:
-
-  --directory=DIR -D
-	Change to directory DIR before reading the rakefiles or doing anything else.
-
-  --rakefile=FILE -f
-	Use FILE as a Rakefile.
-
-  --list      -l
-	Display the list of model projects available.
-
-  --help      -h
-	Synonym for --usage
-
-  --project=PROJECT   -P
-	Sets the model project to create. Use --list for the full list of available projects.
-
-  --tasks     -T
-	Display a list of tasks in this project.
-
-  --trace     -t		
-	Enables trace-level output (debugging).
-
-  --usage     -u
-	Display this help message and quit.
-
-  --verbose   -v
-	Enable verbose output.
-
-  --version   -V
-	Display Dokkit's version and quit
-
-In addition to the standard doc_XXX tasks and those provided by any
-local configuration, the following 'special' tasks are recognised:
-
-  create <project>   Create a blank project from the built-in template using the #{DEFAULT_PROJECT_MODEL} project model.
-
-In non-standard environments, it may be necessary to set the DOKKIT_LIB 
-variable to point to the location of Dokkit's libraries.
-  
-EOM
-    end
-        
   end # Application
 end # Dokkit

data/lib/dokkit/deplate/fmt/latex-notemplate.rb

@@ -12,10 +12,12 @@ class Deplate::Formatter::LatexNoTemplate < Deplate::Formatter::LaTeX
   self.myname = "latex-notemplate"
   self.rx     = /(la)?tex(-notemplate)?/i
 
-
   def prepare
   end
 
+  def initialize_deplate_sty  
+  end
+  
   def add_package(pkg, *options)
   end
 end

data/lib/dokkit/dokkittasks.rb

@@ -1,11 +1,15 @@
-#--
-# Rake tasklib for Dokkit
-# (c)2006 Andrea Fazzi (and contributors)
 #
-# See 'dokkit.rb' or LICENSE for licence information.
-#++
+# 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
 
@@ -13,14 +17,40 @@ module Rote
 
     # 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    
+      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) 
-                 
+        tfn, blk = target_fn(/^#{pages.dir}/, fn)
+
         desc "#{fn} => #{tfn}" #if show_file_tasks?
         file tfn => [fn] do
           dn = File.dirname(tfn)
@@ -29,7 +59,7 @@ module Rote
           begin
             File.open(tfn, 'w+') do |f|
               # new page, run extension block, render out, throw away
-              f << Page.new(fn,pages.dir,layout_dir,config_dir || pages.dir,&blk).render
+              f << Page.new( {:fn => fn}.merge(config_page), &blk).render
             end
           rescue => e
             # Oops... Unlink file and dump backtrace
@@ -42,28 +72,28 @@ module Rote
             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
-end
+end

data/lib/dokkit/filters/deplate.rb

@@ -12,19 +12,25 @@ 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 to tex using 
-    ## deplate. 
+    ## 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::Core.declare_formatter(::Deplate::Formatter::LatexNoTemplate,'latex-notemplate')
-        ::Deplate::Core.declare_formatter(::Deplate::Formatter::HTMLNoTemplate,'html-notemplate')
         @deplate = ::Deplate::Converter.new(formatter) { |instance| yield(instance) if block_given? }
       end