dokkit 0.2.0 → 0.3.0

data/lib/dokkit/app.rb

@@ -3,96 +3,41 @@
 #
 # See 'dokkit.rb' or +LICENSE+ for licence information.                      
 #                                                                          
-# (C) 2006, 2007 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
+# (C) 2008 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
 #                                                                          
 
 require 'optparse'
 require 'rake'
+require 'dokkit/model'
+require 'dokkit/logger'
+require 'dokkit/consolelog'
+require 'dokkit/builtintask'
 
 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.
+  # Master Dokkit version. Manage this from the Rake release support.
+  DOKKITVERSION = '0.3.0'    
   class << self
-    # Current Dokkit Application
     def application
-      @application ||= Dokkit::Application.new(dokkit_lib)
+      @application ||= Application.new
     end
-    # Set the current Rake application object.
-    def application=(app)
-      @application = app
+    def release
+      @application = Rake.application = nil
     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
-      end
-      lib
-    end
-    # Return the directory containing models related files.
-    def projects_dir
-      File.join(dokkit_lib, 'dokkit', 'models')
-    end
-
-    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
-    # 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
-
-  # Command-line launcher for Dokkit.
+  end   
   class Application
-
-    attr_accessor :dokkit_lib
-    
-    DEFAULT_PROJECT_MODEL = "simpledocument"
+    DEFAULT_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.
+Where [taskN] is a valid task or target name for the current model.
+dokkit generates 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:
+In addition to the standard tasks and those provided by any
+local configuration, the following builtin tasks are recognised:
 
-  create <project>   Create a blank project from the built-in template using the #{DEFAULT_PROJECT_MODEL} project model.
+  create[model] modeldir   Create a blank project based on model template.
+  list                     List the models available.
 
 In non-standard environments, it may be necessary to set the DOKKIT_LIB
 variable to point to the location of Dokkit libraries.
@@ -103,144 +48,53 @@ EOU
         "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
-    # configuration.
-    def initialize(dokkit_lib) # :yield: self if block_given?
-      # init vars
-      @dokkit_lib = dokkit_lib
-      ENV['PROJECT'] = @project = DEFAULT_PROJECT_MODEL
-      yield self if block_given?
-    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
+    ]    
+    attr_reader :builtintask, :logger
+    def initialize
+      @rake = Rake.application
+      @logger = Log::ConsoleLog.consolelog
+      @builtintask = Dokkit::BuiltinTask.new(self)
+    end
+    def do_option(option, value)
+      case option
         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
-
-    def init
-      Rake.application.init('dokkit')
-    end
-
-    def clear
-      Rake.application.clear
-    end
-
-    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
-
-    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
-        here = Dir.pwd
+          exit        
+        when '--version'
+          print "dokkit, version #{DOKKITVERSION}\n"
+          exit        
+        when '--tasks'
+          @rake.do_option('--tasks', value)
       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
-        process_args
-        init
-        load_builtin
-        Rake.application.load_rakefile if search_for_rakefile
-        Rake.application.top_level
-        Rake.application = nil
-      end
+    def run
+      process_args
+      @rake.init('dokkit')
+      @rake.load_rakefile if search_for_rakefile
+      @rake.top_level      
     end
 
     private
-
+    
     def command_line_options
       OPTIONS.collect { |lst| lst[0..-2] }
     end
-
-    # Process commandline
     def process_args
       opts = GetoptLong.new(*command_line_options)
       opts.each { |opt, value| do_option(opt, value) }
     end
-
+    def version
+      DOKKITVERSION
+    end
     def help
       puts USAGE_PREAMBLE
       puts "Recognized options are:"
@@ -255,6 +109,23 @@ EOU
         printf "      %s\n", desc
       end
     end
-
-  end # Application
-end # Dokkit
+    # check if a Rakefile exists in the current directory or in any parent directory.
+    def have_rakefile
+      @rake.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
+          Dir.chdir(initial_dir)
+          return false
+        end
+        here = Dir.pwd
+      end
+      Dir.chdir(initial_dir)
+      true
+    end    
+  end
+end

data/lib/dokkit/builtintask.rb

@@ -0,0 +1,85 @@
+#                                                                          
+# File 'modeltask.rb' created on 23 feb 2008 at 20:45:10.                    
+#
+# See 'dokkit.rb' or +LICENSE+ for licence information.                      
+#                                                                          
+# (C) 2008 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
+#                                                                          
+
+require 'yaml'
+require 'dokkit'
+
+module Dokkit
+  class BuiltinTask
+    attr_reader :models, :local_dir, :search_in
+    def initialize(application)
+      @application = application      
+      @local_dir = DEFAULT_LOCAL_DIR
+      @search_in = [:dokkit_dir, :local_dir]
+      @logger = @application.logger
+      @models = fetch_models
+      define_builtin_tasks
+    end
+    def dokkit_dir
+      lib = nil
+      unless lib = ENV['DOKKIT_LIB']
+        $:.each do |it|
+          if File.exists?(File.join(it, 'dokkit/app.rb'))
+            lib = it
+            break
+          end
+        end
+      end
+      lib      
+    end
+    def builtin_model_dir
+      File.join(dokkit_dir, 'dokkit/models')      
+    end
+    
+    private
+    
+    def define_builtin_tasks
+      define_list_model_task
+      define_create_task      
+    end
+    def from_location(location)
+      return builtin_model_dir if location == :dokkit_dir
+      return File.join(((ENV['HOMEPATH'] if RUBY_PLATFORM =~ /win32/) || ENV['HOME']), @local_dir) if location == :local_dir
+    end
+    def fetch_models
+      models = { }
+      @search_in.each do |location|
+        Dir.glob(File.join(from_location(location), '**/model/Rakefile')).each do |model|
+          models[model.scan(/models\/(.*)\/model\/Rakefile/).flatten.to_s] = File.expand_path(File.join(File.dirname(model), '..'))
+        end      
+      end
+      models
+    end
+    def define_list_model_task
+      desc 'List the installed models'
+      task 'list' do
+        @models.each do |modelname, path|
+          @logger.info("Found model '#{modelname}' in #{path}")
+        end
+      end
+    end    
+    def define_create_task
+      desc 'Bootstrap a new documentation project'
+      task 'create', :model do |t, args|
+        model = args.model || DEFAULT_MODEL
+        if ARGV.size == 2
+          dest_dir = t.application.top_level_tasks.pop
+        else
+          @logger.error('A target directory must be provided.')          
+        end        
+        @logger.error("Directory '#{dest_dir}' exists.") if File.exists?(dest_dir)
+        @logger.error("Model '#{model}' not found.") unless @models[model]
+        @logger.info("Create '#{dest_dir}' based on '#{model}' model.")       
+        cp_r(File.join(@models[model], 'model'), dest_dir, :verbose => false)        
+        File.open(File.join(dest_dir, 'doc/configs/model.yaml'), 'w') do |file|
+          file << { 'name' => model, 'from' => @models[model] }.to_yaml   
+        end
+      end
+    end
+  end
+end

data/lib/dokkit/cachemanager.rb

@@ -0,0 +1,61 @@
+#                                                                          
+# File 'cachemanager.rb' created on 28 gen 2008 at 18:31:05.                    
+#
+# See 'dokkit.rb' or +LICENSE+ for licence information.                      
+#                                                                          
+# (C) 2006, 2007 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
+#                                                                          
+
+require 'singleton'
+require 'rake'
+require 'yaml'
+
+module Dokkit
+  class CacheManager
+    include Singleton
+    def init(cache_filename = 'deps.yaml', cache_dir = '.cache')
+      @cache_filename = cache_filename
+      @cache_dir = cache_dir
+      @complete_cache_filename = File.join(cache_dir, cache_filename)
+      @deps = {}
+      load if File.exists?(@complete_cache_filename)
+      at_exit { save }
+    end
+    def add_dependency(task_name, dep)
+      @deps[task_name] ||= []
+      @deps[task_name] << dep unless (dep.nil? or @deps[task_name].include?(dep))
+    end
+    def load
+      File.open(@complete_cache_filename) do |file|
+        @deps = YAML::load(file)
+        @deps.each do |task, dep|
+          file task => dep
+        end
+      end
+    end
+    def save
+      unless @deps.empty?
+        mkdir_p(cache_dir, :verbose => false) unless File.exists?(cache_dir)
+        File.open(@complete_cache_filename, 'w') do |file|
+          file.write YAML::dump(@deps)
+        end
+      end
+    end
+    def clean_deps
+      @deps.clear
+    end
+    def clean
+      clean_deps
+      rm_rf(cache_dir, :verbose => false) unless cache_dir == '.'
+    end
+    def deps
+      @deps
+    end
+    def cache_dir
+      @cache_dir
+    end
+    def cache_filename
+      @cache_filename
+    end
+  end
+end

data/lib/dokkit/cleantask.rb

@@ -0,0 +1,51 @@
+#                                                                          
+# File 'cleantask.rb' created on 19 feb 2008 at 19:33:03.                    
+#
+# See 'dokkit.rb' or +LICENSE+ for licence information.                      
+#                                                                          
+# (C) 2008 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
+#                                                                          
+
+require 'rake/clean'
+require 'dokkit/dokkitlib'
+
+module Dokkit
+  class CleanTask < DokkitLib
+    def initialize(model, namespace = 'clean')
+      super(model, namespace)
+    end
+    
+    private
+    
+    def pre_block_configuration
+      @config.output_dir ||= Dokkit::DEFAULT_OUTPUT_DIR
+      @config.cache_dir ||= Dokkit::DEFAULT_CACHE_DIR      
+    end
+    def define_dokkit_clean_output
+      desc 'Remove output directory'
+      dokkit_task :output do
+        if File.exists?(@config.output_dir)
+          @logger.info('Removing output directory')
+          rm_rf(@config.output_dir, :verbose => false)
+        end
+      end
+    end
+    def define_dokkit_clean_cache
+      desc 'Remove cache directory'
+      dokkit_task :cache do
+        if File.exists?(@model.cache.cache_dir)
+          @logger.info('Removing cache directory')
+          @model.cache.clean
+        end
+      end
+    end
+    def define_dokkit_clean_backup
+      desc 'Remove backup files (invoke rake:clean)'
+      dokkit_task :backup => ['rake:clean']
+    end
+    def define_dokkit_clean_all
+      desc 'Clobber all generated output and cache'
+      dokkit_task :all => [:output, :cache, :backup]
+    end
+  end
+end

data/lib/dokkit/consolelog.rb

@@ -0,0 +1,42 @@
+#                                                                          
+# File 'consolelog.rb' created on 23 feb 2008 at 16:39:59.                    
+#
+# See 'dokkit.rb' or +LICENSE+ for licence information.                      
+#                                                                          
+# (C) 2008 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
+#                                                                          
+
+require 'dokkit/logger'
+
+module Dokkit
+  module Log
+    class ConsoleLog
+      class << self
+        def consolelog
+          @consolelog ||= ConsoleLog.new(Logger.logger)
+          @consolelog.logger
+        end
+      end
+      attr_reader :logger
+      def initialize(logger)
+        @logger = logger
+        logger.attach(self)
+      end
+      def update
+        message = @logger.last_message
+        case message[:level]
+         when Log::ERROR
+          fail "[#{Time.now.asctime}][ERROR] #{message[:text]}"
+         when Log::WARNING
+          warn "[#{Time.now.asctime}][WARNING] #{message[:text]}"
+         when Log::INFO
+          puts "[#{Time.now.asctime}][INFO] #{message[:text]}"
+         when Log::DEBUG
+          puts "[#{Time.now.asctime}][DEBUG] #{message[:text]}"
+        end
+        message
+      end
+    end
+  end
+end
+

data/lib/dokkit/defaults.rb

@@ -0,0 +1,19 @@
+#                                                                          
+# File 'defaults.rb' created on 20 feb 2008 at 19:31:57.                    
+#
+# See 'dokkit.rb' or +LICENSE+ for licence information.                      
+#                                                                          
+# (C) 2008 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
+#                                                                          
+
+module Dokkit
+  DEFAULT_DOCUMENT_DIR = 'doc/pages'
+  DEFAULT_DATA_DIR = 'doc/data'
+  DEFAULT_OUTPUT_DIR = 'output'
+  DEFAULT_LAYOUT_DIR = 'doc/layouts'
+  DEFAULT_CONFIG_DIR = 'doc/configs'
+  DEFAULT_TEMPLATE_DIR = 'templates'
+  DEFAULT_CACHE_DIR = '.cache'
+  DEFAULT_LOCAL_DIR = '.dokkit/models'
+  DEFAULT_MODEL = 'simpledocument'
+end