dokkit 0.4.4 → 0.5.0

data/lib/dokkit/resource/extensions/builtin.rb

@@ -11,9 +11,11 @@ require 'dokkit/resource/extensions/html'
 module Dokkit
   module Resource
     module Extension
+      
       module Builtin
         include HTML
       end
+      
     end
   end
 end

data/lib/dokkit/resource/extensions/url.rb

@@ -13,7 +13,7 @@ module Dokkit
         def relative(href)
           thr = href
           if thr.is_a?(String) && href[0,1] == '/'     
-            dtfn = File.dirname(source_fn[/^#{configuration[:document_dir]}\/(.*)/,1]) + '/'
+            dtfn = File.dirname(source_fn[/^#{env_configuration[:document_dir]}\/(.*)/,1]) + '/'
             count = dtfn == './' ? 0 : dtfn.split('/').length
             thr = ('../' * count) + href[1..href.length]
           end        

data/lib/dokkit/resource/filenamehelper.rb

@@ -1,16 +1,18 @@
 #                                                                          
 # File 'filenamehelper.rb' created on 21 apr 2008 at 14:25:47.                    
 #
-# See 'dokkit.rb' or +LICENSE+ for licence information.                      
+# See 'dokkit.rb' or +LICENSE+ for license information.                      
 #                                                                          
 # (C) 2006, 2007, 2008 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
 #                                                                          
 
 module Dokkit
   module Resource
+    
     # This is a helper module that aims to simplify operation with
     # filenames.
     module FilenameHelper
+    
       # Return a filename transformed in its directory part and
       # (optionally) in its extension.
       # +fn+:: is the source filename.
@@ -23,6 +25,8 @@ module Dokkit
         new_fn = new_fn << new_ext unless new_ext.empty?
         new_fn
       end    
+    
     end
+    
   end
 end

data/lib/dokkit/tasklib.rb

@@ -9,3 +9,8 @@
 require 'dokkit/tasklib/render'
 require 'dokkit/tasklib/clean'
 
+module Dokkit
+  module TaskLib
+    
+  end
+end

data/lib/dokkit/tasklib/base.rb

@@ -0,0 +1,36 @@
+#                                                                          
+# File 'base.rb' created on 15 ago 2008 at 22:34:26.                    
+#
+# See 'dokkit.rb' or +LICENSE+ for license information.                      
+#                                                                          
+# (C)2006-2008 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
+#                                                                          
+
+require 'logger'
+require 'rake/tasklib'
+
+module Dokkit
+  module TaskLib
+
+    class Base < Rake::TaskLib
+    
+      attr_reader :ns
+      attr_accessor :logger
+    
+      def initialize(ns)
+        @ns = ns
+        @logger ||= Logger.new(STDOUT)  
+      end
+      
+      protected
+      
+      def define_tasks
+        namespace @ns do
+          private_methods.select { |meth| meth =~ /define_.+_task/ }.each { |meth| send meth }
+        end
+      end
+
+    end
+    
+  end
+end

data/lib/dokkit/tasklib/clean.rb

@@ -6,6 +6,8 @@
 # (C) 2008 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
 #                                                                          
 
+require 'dokkit/tasklib/base'
+
 module Dokkit
   module TaskLib
     # The Clean task library is a collection of rake tasks devoted to
@@ -13,31 +15,22 @@ module Dokkit
     # defines a clean:output that remove the generated output folder
     # (if exists). It defines also a clean:cache task that remove the
     # cache folder (if exists).
-    class Clean
-      attr_reader :output_dir, :cache_dir
+    class Clean < Base
+      
+      attr_accessor :output_dir, :cache_dir
       
       # Initialize the library with the logger instance, an optional
       # namespace and configuration hash.
-      def initialize(logger, configuration, namespace = 'clean')
-        @namespace = namespace
-        @logger = logger
-        @configuration = configuration
-        @output_dir = configuration[:output_dir]
-        @cache_dir = configuration[:cache_dir]
+      def initialize(ns = 'clean')
+        super
+        
+        yield self if block_given?
+
         define_tasks
       end
       
       private
       
-      # Define library tasks under the given namespace.
-      def define_tasks
-        namespace @namespace do
-          define_output_task
-          define_cache_task
-          define_clean_all_task
-        end
-      end
-      
       # Define a task to remove output directory.
       def define_output_task
         desc "Remove the generated output."
@@ -60,12 +53,12 @@ module Dokkit
           rm_rf dir unless dir == '.'
         end        
       end
-      
+       
       # Define a task that clean the documentation environment
       # removing both output and cache directory.
       def define_clean_all_task
         desc "Clean the documentation environment."
-        task :all => ["#{@namespace}:output", "#{@namespace}:cache"]
+        task :all => ["#{@ns}:output", "#{@ns}:cache"]
       end
       
     end

data/lib/dokkit/tasklib/render.rb

@@ -1,18 +1,21 @@
 #                                                                          
 # File 'render.rb' created on 18 feb 2008 at 17:47:44.                    
 #
-# See 'dokkit.rb' or +LICENSE+ for licence information.                      
+# See 'dokkit.rb' or +LICENSE+ for license information.                      
 #                                                                          
 # (C) 2008 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
 #                                                                          
 
-require 'rake/tasklib'
+require 'dokkit/tasklib/base'
 
 module Dokkit
   module TaskLib
+    
     # Render task library defines a set of rake tasks devoted to the
     # transformation (rendering) of the documents and data files.
-    class Render < Rake::TaskLib
+    class Render < Base
+      
+      attr_accessor :document_fns, :data_fns, :resource_factory, :logger
       
       # Initialize a set of tasks that transform resources.
       # +namespace+:: is the namespace for the tasks defined in the library.
@@ -20,13 +23,16 @@ module Dokkit
       # +factory+:: is a factory class that creates document instances. 
       # +document_fns+:: is an array of source filenames.  
       # +data_fns+:: is an array of data files.       
-      def initialize(logger, resource_factory, document_fns, data_fns, namespace = 'render')
-        @namespace = namespace
-        @document_fns = document_fns
-        @data_fns = data_fns
-        @resource_factory = resource_factory
-        @logger = logger
+      def initialize(ns = 'render')
+        super
+        
+        yield self if block_given?
+
+        @document_fns ||= []
+        @data_fns ||= []
+
         define_tasks
+
       end
       
       # Use factory to get an instance of Dokkit::Resource::Document
@@ -62,16 +68,7 @@ module Dokkit
         mkdir(File.dirname(data.target_fn))
         cp(data.source_fn, data.target_fn, :preserve => true, :verbose => false)
       end
-      
-      # Define all tasks in library.
-      def define_tasks
-        namespace @namespace do
-          define_render_all_documents_task
-          define_data_task
-          define_render_all_task
-        end
-      end
-      
+
       # Define render all documents task.
       def define_render_all_documents_task
         desc "Render documents."
@@ -86,7 +83,7 @@ module Dokkit
       
       def render_all_targets(document)
         document.targets.each_key do |format|
-          render_target(document, format) if need_update?(document.target_for(format), document.deps_for(format))
+          render_target(document, format) if (need_update?(document.target_for(format), document.deps_for(format)) and document.render?)
         end
       end
       
@@ -94,7 +91,7 @@ module Dokkit
         @logger.info("Render '#{document.source_fn}' => '#{document.target_for(format)}'.")
         write_document(document.render(:format => format), document.target_for(format))
       end
-       
+      
       # Define data task.
       def define_data_task
         desc "Copy data files."
@@ -106,7 +103,7 @@ module Dokkit
       def copy_all_data
         @data_fns.each { |fn| copy_data(get_data(fn)) }
       end
-       
+      
       def copy_data(data)
         if need_update?(data.target_fn, data.source_fn)
           @logger.info("Copy '#{data.source_fn}' => '#{data.target_fn}'.")
@@ -117,7 +114,7 @@ module Dokkit
       # Define a task that render all documents and copy all data.
       def define_render_all_task
         desc "Render the documents and copy the data."
-        task :all => ["#{@namespace}:doc", "#{@namespace}:data"]
+        task :all => ["#{@ns}:doc", "#{@ns}:data"]
       end
       
       private
@@ -134,4 +131,3 @@ module Dokkit
     end
   end
 end
-

data/lib/models/simple/setup/setup.rb

@@ -1,10 +1,12 @@
 
 require 'dokkit/environment'
 
-include Dokkit::Environment::Basic
+include Dokkit::Environment
 
-Container.new do |c|
+environment do |env|
 
-  c.documents.include('*')
+  env.select_document do |selection|
+    selection.include('**/*')
+  end
 
 end

data/tasks/ann.rake

@@ -0,0 +1,81 @@
+# $Id$
+
+begin
+  require 'bones/smtp_tls'
+rescue LoadError
+  require 'net/smtp'
+end
+require 'time'
+
+namespace :ann do
+
+  # A prerequisites task that all other tasks depend upon
+  task :prereqs
+
+  file PROJ.ann.file do
+    ann = PROJ.ann
+    puts "Generating #{ann.file}"
+    File.open(ann.file,'w') do |fd|
+      fd.puts("#{PROJ.name} version #{PROJ.version}")
+      fd.puts("    by #{Array(PROJ.authors).first}") if PROJ.authors
+      fd.puts("    #{PROJ.url}") if PROJ.url.valid?
+      fd.puts("    (the \"#{PROJ.release_name}\" release)") if PROJ.release_name
+      fd.puts
+      fd.puts("== DESCRIPTION")
+      fd.puts
+      fd.puts(PROJ.description)
+      fd.puts
+      fd.puts(PROJ.changes.sub(%r/^.*$/, '== CHANGES'))
+      fd.puts
+      ann.paragraphs.each do |p|
+        fd.puts "== #{p.upcase}"
+        fd.puts
+        fd.puts paragraphs_of(PROJ.readme_file, p).join("\n\n")
+        fd.puts
+      end
+      fd.puts ann.text if ann.text
+    end
+  end
+
+  desc "Create an announcement file"
+  task :announcement => ['ann:prereqs', PROJ.ann.file]
+
+  desc "Send an email announcement"
+  task :email => ['ann:prereqs', PROJ.ann.file] do
+    ann = PROJ.ann
+    from = ann.email[:from] || PROJ.email
+    to   = Array(ann.email[:to])
+
+    ### build a mail header for RFC 822
+    rfc822msg =  "From: #{from}\n"
+    rfc822msg << "To: #{to.join(',')}\n"
+    rfc822msg << "Subject: [ANN] #{PROJ.name} #{PROJ.version}"
+    rfc822msg << " (#{PROJ.release_name})" if PROJ.release_name
+    rfc822msg << "\n"
+    rfc822msg << "Date: #{Time.new.rfc822}\n"
+    rfc822msg << "Message-Id: "
+    rfc822msg << "<#{"%.8f" % Time.now.to_f}@#{ann.email[:domain]}>\n\n"
+    rfc822msg << File.read(ann.file)
+
+    params = [:server, :port, :domain, :acct, :passwd, :authtype].map do |key|
+      ann.email[key]
+    end
+
+    params[3] = PROJ.email if params[3].nil?
+
+    if params[4].nil?
+      STDOUT.write "Please enter your e-mail password (#{params[3]}): "
+      params[4] = STDIN.gets.chomp
+    end
+
+    ### send email
+    Net::SMTP.start(*params) {|smtp| smtp.sendmail(rfc822msg, from, to)}
+  end
+end  # namespace :ann
+
+desc 'Alias to ann:announcement'
+task :ann => 'ann:announcement'
+
+CLOBBER << PROJ.ann.file
+
+# EOF

data/tasks/bones.rake

@@ -0,0 +1,21 @@
+# $Id$
+
+if HAVE_BONES
+
+namespace :bones do
+
+  desc 'Show the PROJ open struct'
+  task :debug do |t|
+    atr = if t.application.top_level_tasks.length == 2
+      t.application.top_level_tasks.pop
+    end
+
+    if atr then Bones::Debug.show_attr(PROJ, atr)
+    else Bones::Debug.show PROJ end
+  end
+
+end  # namespace :bones
+
+end  # HAVE_BONES
+
+# EOF

data/tasks/gem.rake

@@ -4,77 +4,114 @@ require 'rake/gempackagetask'
 
 namespace :gem do
 
-  PROJ.spec = Gem::Specification.new do |s|
+  PROJ.gem._spec = Gem::Specification.new do |s|
     s.name = PROJ.name
     s.version = PROJ.version
     s.summary = PROJ.summary
     s.authors = Array(PROJ.authors)
     s.email = PROJ.email
     s.homepage = Array(PROJ.url).first
-    s.rubyforge_project = PROJ.rubyforge_name
+    s.rubyforge_project = PROJ.rubyforge.name
 
     s.description = PROJ.description
 
-    PROJ.dependencies.each do |dep|
+    PROJ.gem.dependencies.each do |dep|
       s.add_dependency(*dep)
     end
 
-    s.files = PROJ.files
-    s.executables = PROJ.executables.map {|fn| File.basename(fn)}
-    s.extensions = PROJ.files.grep %r/extconf\.rb$/
+    s.files = PROJ.gem.files
+    s.executables = PROJ.gem.executables.map {|fn| File.basename(fn)}
+    s.extensions = PROJ.gem.files.grep %r/extconf\.rb$/
 
     s.bindir = 'bin'
     dirs = Dir["{#{PROJ.libs.join(',')}}"]
     s.require_paths = dirs unless dirs.empty?
 
-    incl = Regexp.new(PROJ.rdoc_include.join('|'))
-    excl = PROJ.rdoc_exclude.dup.concat %w[\.rb$ ^(\.\/|\/)?ext]
+    incl = Regexp.new(PROJ.rdoc.include.join('|'))
+    excl = PROJ.rdoc.exclude.dup.concat %w[\.rb$ ^(\.\/|\/)?ext]
     excl = Regexp.new(excl.join('|'))
-    rdoc_files = PROJ.files.find_all do |fn|
+    rdoc_files = PROJ.gem.files.find_all do |fn|
                    case fn
                    when excl; false
                    when incl; true
                    else false end
                  end
-    s.rdoc_options = PROJ.rdoc_opts + ['--main', PROJ.rdoc_main]
+    s.rdoc_options = PROJ.rdoc.opts + ['--main', PROJ.rdoc.main]
     s.extra_rdoc_files = rdoc_files
     s.has_rdoc = true
 
-    if test ?f, PROJ.test_file
-      s.test_file = PROJ.test_file
+    if test ?f, PROJ.test.file
+      s.test_file = PROJ.test.file
     else
-      s.test_files = PROJ.tests.to_a
+      s.test_files = PROJ.test.files.to_a
     end
 
     # Do any extra stuff the user wants
-#   spec_extras.each do |msg, val|
-#     case val
-#     when Proc
-#       val.call(s.send(msg))
-#     else
-#       s.send "#{msg}=", val
-#     end
-#   end
-  end
+    PROJ.gem.extras.each do |msg, val|
+      case val
+      when Proc
+        val.call(s.send(msg))
+      else
+        s.send "#{msg}=", val
+      end
+    end
+  end  # Gem::Specification.new
+
+  # A prerequisites task that all other tasks depend upon
+  task :prereqs
 
   desc 'Show information about the gem'
-  task :debug do
-    puts PROJ.spec.to_ruby
+  task :debug => 'gem:prereqs' do
+    puts PROJ.gem._spec.to_ruby
   end
 
-  Rake::GemPackageTask.new(PROJ.spec) do |pkg|
-    pkg.need_tar = PROJ.need_tar
-    pkg.need_zip = PROJ.need_zip
+  pkg = Rake::PackageTask.new(PROJ.name, PROJ.version) do |pkg|
+    pkg.need_tar = PROJ.gem.need_tar
+    pkg.need_zip = PROJ.gem.need_zip
+    pkg.package_files += PROJ.gem._spec.files
+  end
+  Rake::Task['gem:package'].instance_variable_set(:@full_comment, nil)
+
+  gem_file = if PROJ.gem._spec.platform == Gem::Platform::RUBY
+      "#{pkg.package_name}.gem"
+    else
+      "#{pkg.package_name}-#{PROJ.gem._spec.platform}.gem"
+    end
+
+  desc "Build the gem file #{gem_file}"
+  task :package => ['gem:prereqs', "#{pkg.package_dir}/#{gem_file}"]
+
+  file "#{pkg.package_dir}/#{gem_file}" => [pkg.package_dir] + PROJ.gem._spec.files do
+    when_writing("Creating GEM") {
+      Gem::Builder.new(PROJ.gem._spec).build
+      verbose(true) {
+        mv gem_file, "#{pkg.package_dir}/#{gem_file}"
+      }
+    }
   end
 
   desc 'Install the gem'
-  task :install => [:clobber, :package] do
-    sh "#{SUDO} #{GEM} install pkg/#{PROJ.spec.file_name}"
+  task :install => [:clobber, 'gem:package'] do
+    sh "#{SUDO} #{GEM} install --local pkg/#{PROJ.gem._spec.full_name}"
+
+    # use this version of the command for rubygems > 1.0.0
+    #sh "#{SUDO} #{GEM} install --no-update-sources pkg/#{PROJ.gem._spec.full_name}"
   end
 
   desc 'Uninstall the gem'
   task :uninstall do
-    sh "#{SUDO} #{GEM} uninstall -v '#{PROJ.version}' #{PROJ.name}"
+    installed_list = Gem.source_index.find_name(PROJ.name)
+    if installed_list and installed_list.collect { |s| s.version.to_s}.include?(PROJ.version) then
+      sh "#{SUDO} #{GEM} uninstall --version '#{PROJ.version}' --ignore-dependencies --executables #{PROJ.name}"
+    end
+  end
+
+  desc 'Reinstall the gem'
+  task :reinstall => [:uninstall, :install]
+
+  desc 'Cleanup the gem'
+  task :cleanup do
+    sh "#{SUDO} #{GEM} cleanup #{PROJ.gem._spec.name}"
   end
 
 end  # namespace :gem