webgen 0.5.17 → 1.0.0.beta1

data/lib/webgen/path_handler/virtual.rb

@@ -0,0 +1,85 @@
+# -*- encoding: utf-8 -*-
+
+require 'uri'
+require 'yaml'
+require 'webgen/path_handler/base'
+require 'webgen/path_handler/page_utils'
+
+module Webgen
+  class PathHandler
+
+    # Handles files which contain specifications for "virtual" nodes, ie. nodes that don't have real
+    # source paths.
+    #
+    # This can be used, for example, to provide multiple links to the same node or links to external
+    # URLs.
+    class Virtual
+
+      include Base
+      include PageUtils
+
+      # Create all virtual nodes which are specified in +path+.
+      def create_nodes(path, blocks)
+        nodes = []
+        if path.meta_info.delete(:virtual)
+          nodes << create_node(path)
+        else
+          read_entries(blocks) do |key, meta_info|
+            meta_info['modified_at'] = path.meta_info['modified_at']
+            meta_info['no_output'] = true
+
+            key = Webgen::Path.append(path.parent_path, key)
+            parent_path = create_directories(File.dirname(key), 'modified_at' => meta_info['modified_at'])
+
+            dest_path = meta_info.delete('dest_path') || key
+            dest_path = (URI::parse(dest_path).absolute? || dest_path =~ /^\// ?
+                         dest_path : File.join(parent_path, dest_path))
+            meta_info['dest_path'] = dest_path
+            entry_path = Webgen::Path.new(key, meta_info)
+
+            if key =~ /\/$/
+              entry_path['handler'] = 'directory'
+              nodes << @website.ext.path_handler.create_secondary_nodes(entry_path)
+            else
+              entry_path[:virtual] = true
+              entry_path['handler'] = 'virtual'
+              nodes << @website.ext.path_handler.create_secondary_nodes(entry_path)
+            end
+          end
+        end
+        nodes.flatten.compact.each do |node|
+          node.node_info[:path] = path
+        end
+      end
+
+      #######
+      private
+      #######
+
+      # Read all entries from all blocks and yield the found path as well as the meta info hash for
+      # each entry.
+      def read_entries(blocks)
+        blocks.each do |name, content|
+          YAML::load(content).each do |key, meta_info|
+            yield(key, meta_info || {})
+          end
+        end
+      end
+
+      # Create the needed parent directories for a virtual node.
+      def create_directories(directory, mi)
+        mi.merge!('no_output' => true, 'handler' => 'directory')
+        directory.sub(/^\//, '').split('/').inject('/') do |parent_path, dir|
+          parent_path = File.join(parent_path, dir) + '/'
+          path = Webgen::Path.new(parent_path, mi)
+          if !@website.tree[path.alcn]
+            @website.ext.path_handler.create_secondary_nodes(path)
+          end
+          parent_path
+        end
+      end
+
+    end
+
+  end
+end

data/lib/webgen/{webgentask.rb → rake_task.rb}

@@ -1,16 +1,15 @@
 # -*- encoding: utf-8 -*-
 
-# -*- ruby -*-
 #
 #--
-# webgentask.rb:
+# rake_task.rb:
 #
 #   Define a task library for running webgen
 #
 # Copyright (C) 2007 Jeremy Hinegardner
 #
 # Tasks restructuration by Massimiliano Filacchioni
-# Modifications for 0.5.0 by Thomas Leitner
+# Modifications for 0.5.0- by Thomas Leitner
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -43,9 +42,9 @@ module Webgen
   #
   # == Basics
   #
-  #   require 'webgen/webgentask'
+  #   require 'webgen/rake_task'
   #
-  #   Webgen::WebgenTask.new
+  #   Webgen::RakeTask.new
   #
   # == Attributes
   #
@@ -63,24 +62,24 @@ module Webgen
   # The tasks provided are :
   #
   # [webgen]
-  #   render the webgen website
+  #   generate the webgen website
   # [clobber_webgen]
-  #   remove all the files created during generation
+  #   remove all files created during generation
   #
   # == Integrate webgen in other project
   #
   # To integrate webgen tasks in another project you can use rake namespaces.  For example assuming
-  # webgen's site directory is +webgen+ under the main project directory use the following code
+  # webgen's website directory is +webgen+ under the main project directory use the following code
   # fragment in project Rakefile:
   #
-  #   require 'webgen/webgentask'
+  #   require 'webgen/rake_task'
   #
   #   namespace :dev do
-  #     Webgen::WebgenTask.new do |site|
+  #     Webgen::RakeTask.new do |site|
   #       site.directory = File.join(Dir.pwd, "webgen")
   #       site.clobber_outdir = true
-  #       site.config_block = lambda |config|
-  #         config['website.lang'] = 'de'
+  #       site.config_block = lambda |website|
+  #         website.config['website.lang'] = 'de'
   #       end
   #     end
   #   end
@@ -94,20 +93,23 @@ module Webgen
   #
   # and add dev:clobber_webgen to the main clobber task.
   #
-  class WebgenTask < ::Rake::TaskLib
+  class RakeTask < ::Rake::TaskLib
 
-    # The directory of the webgen website. This would be the directory of your <tt>config.yaml</tt>
-    # file. Or the parent directory of the <tt>src/</tt> directory for webgen.
+    # The directory of the webgen website.
     #
-    # The default for this is assumed to be <tt>Dir.pwd</tt>
+    # This would be the directory of your 'webgen.config' file. Or the parent directory of the 'src'
+    # directory.
+    #
+    # The default value is +Dir.pwd+.
     attr_accessor :directory
 
-    # The configuration block that is invoked when the Webgen::Website object is initialized. This
-    # can be used to set configuration parameters and to avoid having a <tt>config.yaml</tt> file
+    # The configuration block that is invoked when the Webgen::Website object is initialized.
+    #
+    # This can be used to set configuration parameters and to avoid having a 'webgen.config' file
     # lying around.
     attr_accessor :config_block
 
-    # During the clobber, should webgen's output directory be clobbered. The default is false.
+    # During the clobber, should webgen's output directory be clobbered? The default is false.
     attr_accessor :clobber_outdir
 
     # Create webgen tasks. You can override the task name with the parameter +name+.
@@ -127,13 +129,14 @@ module Webgen
     #######
 
     def define # :nodoc:
-      desc "Render the webgen website"
-      task @name, :verbosity, :log_level do |t, args|
+      desc "Generate the webgen website"
+      task @name, :verbose, :debug do |t, args|
         require 'webgen/website'
-        website = Webgen::Website.new(@directory, Webgen::Logger.new($stdout), &@config_block)
-        website.logger.verbosity = args[:verbosity].to_s.intern unless args[:verbosity].to_s.empty?
-        website.logger.level = args[:log_level].to_i if args[:log_level]
-        website.render
+        require 'webgen/cli'
+        website = Webgen::Website.new(@directory, Webgen::CLI::Logger.new($stdout), &@config_block)
+        website.logger.verbose = args[:verbose] && args[:verbose].to_s == 'true'
+        website.logger.level = (args[:debug] && args[:debug].to_s == 'true' ? ::Logger::DEBUG : ::Logger::INFO)
+        website.execute_task(:generate_website)
       end
 
       task :clobber => paste('clobber_', @name)
@@ -141,8 +144,9 @@ module Webgen
       desc "Remove webgen products"
       task paste('clobber_', @name) do
         require 'webgen/website'
-        website = Webgen::Website.new(@directory, Webgen::Logger.new($stdout), &@config_block)
-        website.clean(@clobber_outdir)
+        require 'webgen/cli'
+        website = Webgen::Website.new(@directory, Webgen::CLI::Logger.new($stdout), &@config_block)
+        website.ext.destination.delete('/')
       end
     end
 

data/lib/webgen/source.rb

@@ -1,28 +1,44 @@
 # -*- encoding: utf-8 -*-
 
+require 'webgen/extension_manager'
+require 'webgen/path'
+
 module Webgen
 
   # Namespace for all classes that provide source paths.
   #
-  # == Implementing a source class
+  # == About
+  #
+  # This class is used to manage source classes. A source class is a class that returns a set of
+  # Path objects when the \#paths method is called. For example, the FileSystem class uses the file
+  # system as the source for the source paths.
   #
-  # Source classes provide access to the source paths on which the source handlers act.
+  # The #register method is used for registering new source classes.
   #
-  # A source class only needs to respond to the method +paths+ which needs to return a set of paths
-  # for the source. The returned paths must respond to the method <tt>changed?</tt> (has to return
-  # +true+ if the paths has changed since the last webgen run). If a path represents a directory, it
-  # needs to have a trailing slash! The default implementation in the Path class just returns
-  # +true+. One can either derive a specialized path class or define singleton methods on each path
-  # object.
+  # To get all configured source paths, use the #paths method of this class.
   #
-  # Also note that the returned Path objects should have the meta information <tt>modified_at</tt>
-  # set to the correct last modification time of the path, ie. the value has to be a Time object!
+  # Extension writers may be interested in the #passive_sources accessor which allows one to
+  # register sources that provide paths that are only used when actually referenced.
+  #
+  # == Implementing a source class
   #
-  # == Sample Source Class
+  # A source class only needs to respond to the method +paths+ which needs to return a set of Path
+  # objects for the source. It is expected that after a source object is initialized it always
+  # returns the same path objects. The +initialize+ method of a source class must take the website
+  # object as first argument and may take an arbitrary number of additional arguments.
   #
-  # Following is a simple source class which has stored the paths and their contents in a hash:
+  # Note that the returned Path objects need to have the meta information 'modified_at' set to the
+  # correct last modification time of the path, i.e. the value has to be a Time object! This is
+  # needed to determine whether the content of the path has been changed since the last invocation
+  # of webgen.
+  #
+  # == Sample source class
+  #
+  # Following is a simple source class which stores the paths and their contents in a hash:
   #
   #   require 'stringio'
+  #   require 'set'
+  #   require 'webgen/path'
   #
   #   class MemorySource
   #
@@ -31,26 +47,92 @@ module Webgen
   #       '/directory/file.page' => "This is the content of the file"
   #     }
   #
+  #     def initialize(website, data = {})
+  #       @data = data
+  #     end
+  #
   #     def paths
-  #       CONTENT.collect do |path, content|
-  #         Webgen::Path.new(path) { StringIO.new(content.to_s) }
+  #       CONTENT.merge(@data).collect do |path, content|
+  #         Webgen::Path.new(path, 'modified_at' => Time.now) { StringIO.new(content.to_s) }
   #       end.to_set
   #     end
   #
   #   end
   #
-  # You can use this source class in your website (after placing the code in, for example,
-  # <tt>ext/init.rb</tt>) by updating the <tt>sources</tt> configuration option:
+  #   website.ext.source.register MemorySource, :name => 'memory'
   #
-  #   WebsiteAccess.website.config['sources'] << ['/', 'MemorySource']
-  #
-  module Source
+  class Source
+
+    include Webgen::ExtensionManager
+
+
+    # An array with one or more passive source definitions (a source definition is an array
+    # containing a mount point, the short name for a Source class and its arguments).
+    #
+    # The paths read from these sources will automatically be tagged with the 'passive' meta
+    # information key so that they are only used when referenced.
+    #
+    # This is very useful for providing templates, images and other paths in webgen extensions that
+    # should only be rendered when actually being referenced.
+    attr_reader :passive_sources
+
+
+    # Create a new source manager object for the given website.
+    def initialize(website)
+      super()
+      @website = website
+      @passive_sources = []
+    end
+
+    # Register a source class.
+    #
+    # The parameter +klass+ has to contain the name of the source class or the class object itself.
+    # If the class is located under this namespace, only the class name without the hierarchy part
+    # is needed, otherwise the full class name including parent module/class names is needed.
+    #
+    # === Options:
+    #
+    # [:name] The name for the source. If not set, it defaults to the snake-case version (i.e.
+    #         FileSystem → file_system) of the class name (without the hierarchy part). It should
+    #         only contain letters.
+    #
+    # === Examples:
+    #
+    #   source.register('FileSystem')   # registers Webgen::Source::FileSystem
+    #
+    #   source.register('::FileSystem') # registers FileSystem !!!
+    #
+    #   source.register('MyModule::Doit', name: 'my_doit')
+    #
+    def register(klass, options={}, &block)
+      do_register(klass, options, false, &block)
+    end
+
+    # Return all configured source paths.
+    #
+    # The source paths are taken from the sources specified in the "sources" configuration option
+    # and from passive sources array (see #passive_sources). All paths that additionally match one
+    # of the "sources.ignore_paths" patterns are ignored.
+    def paths
+      if !defined?(@paths)
+        active_source = extension('stacked').new(@website, @website.config['sources'].collect do |mp, name, *args|
+                                                   [mp, extension(name).new(@website, *args)]
+                                                 end)
+        passive_source = extension('stacked').new(@website, @passive_sources.collect do |mp, name, *args|
+                                                    [mp, extension(name).new(@website, *args)]
+                                                  end)
+        passive_source.paths.each {|path| path['passive'] = true}
+        source = extension('stacked').new(@website, [['/', active_source], ['/', passive_source]])
 
-    autoload :Base, 'webgen/source/base'
-    autoload :FileSystem, 'webgen/source/filesystem'
-    autoload :Stacked, 'webgen/source/stacked'
-    autoload :Resource, 'webgen/source/resource'
-    autoload :TarArchive, 'webgen/source/tararchive'
+        @paths = []
+        source.paths.each do |path|
+          if !(@website.config['sources.ignore_paths'].any? {|pat| Webgen::Path.matches_pattern?(path, pat)})
+            @paths << path
+          end
+        end
+      end
+      @paths
+    end
 
   end
 

data/lib/webgen/source/file_system.rb

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+
+require 'pathname'
+require 'set'
+require 'webgen/source'
+require 'webgen/path'
+
+module Webgen
+  class Source
+
+    # This class is used to read source paths from a directory in the file system.
+    class FileSystem
+
+      # The root path from which paths are read.
+      attr_reader :root
+
+      # The glob (see Dir.glob for details) that is used to specify which paths under the root path
+      # should be returned by #paths.
+      attr_reader :glob
+
+      # Create a new file system source for the root path +root+ using the provided +glob+. If
+      # +root+ is not an absolute path, the website directory will be prepended.
+      def initialize(website, root, glob = '**/*')
+        @root = File.absolute_path(root, website.directory)
+        @glob = glob
+      end
+
+      # Return all paths under the root path which match the glob.
+      def paths
+        @paths ||= Dir.glob(File.join(@root, @glob), File::FNM_DOTMATCH|File::FNM_CASEFOLD).collect do |f|
+          next unless File.exists?(f) # handle invalid links
+          temp = Pathname.new(f.sub(/^#{Regexp.escape(@root)}\/?/, '/')).cleanpath.to_s
+          temp += '/' if File.directory?(f) && temp[-1] != ?/
+          Path.new(temp, 'modified_at' => File.mtime(f)) {|mode| File.open(f, mode)}
+        end.compact.to_set
+      end
+
+    end
+
+  end
+end

data/lib/webgen/source/stacked.rb

@@ -1,63 +1,59 @@
 # -*- encoding: utf-8 -*-
 
-module Webgen::Source
-
-  # This source class is used to stack several sources together.
-  #
-  # It serves two purposes:
-  #
-  # * First, it can be used to access more than one source. This is useful when your website
-  #   consists of more than one source directory and you want to use all of them.
-  #
-  # * Second, sources can be mounted on specific directories. For example, a folder with images that
-  #   you don't want to copy to the website source directory can be mounted under <tt>/images</tt>
-  #   sothat they are available nonetheless.
-  #
-  # Also be aware that when a path is returned by a source that has already be returned by a prior
-  # source, it is discarded and not used.
-  class Stacked
-
-    # Return the stack of mount point to Webgen::Source object maps.
-    attr_reader :stack
-
-    # Specifies whether the result of #paths calls should be cached (default: +false+). If caching
-    # is activated, new maps cannot be added to the stacked source anymore!
-    attr_accessor :cache_paths
-
-    # Create a new stack. The optional +map+ parameter can be used to provide initial mappings of
-    # mount points to source objects (see #add for details). You cannot add other maps after a call
-    # to #paths if +cache_paths+ is +true+
-    def initialize(map = {}, cache_paths = false)
-      @stack = []
-      @cache_paths = cache_paths
-      add(map)
-    end
-
-    # Add all mappings found in +maps+ to the stack. The parameter +maps+ should be an array of
-    # two-element arrays which contain an absolute directory (ie. starting and ending with a slash)
-    # and a source object.
-    def add(maps)
-      raise "Cannot add new maps since caching is activated for this source" if defined?(@paths) && @cache_paths
-      maps.each do |mp, source|
-        raise "Invalid mount point specified: #{mp}" unless mp =~ /^\//
-        @stack << [mp, source]
+require 'webgen/source'
+require 'set'
+
+module Webgen
+  class Source
+
+    # This source class is used to stack several sources together.
+    #
+    # It serves two purposes:
+    #
+    # * First, it can be used to access more than one source. This is useful when your website
+    #   consists of more than one source directory and you want to use all of them.
+    #
+    # * Second, sources can be mounted on specific directories. For example, a folder with images
+    #   that you don't want to copy to the main website source directory can be mounted under
+    #   '/images' so that they are available nonetheless.
+    #
+    # Also be aware that when a path is returned by a source that has already be returned by a prior
+    # source, it is discarded and not used.
+    class Stacked
+
+      # Return the stack of [mount point, source object] entries.
+      attr_reader :stack
+
+      # Create a new stack.
+      #
+      # The optional +map+ parameter is used to provide mappings of mount points to source objects.
+      # It should be an array of two-element arrays which contain an absolute directory (ie.
+      # starting and ending with a slash) and a source object.
+      def initialize(website, map = {})
+        @stack = []
+        map.each do |mp, source|
+          raise "Invalid mount point specified: #{mp}" unless mp =~ /^\//
+          @stack << [mp, source]
+        end
       end
-    end
 
-    # Return all paths returned by the sources in the stack. Since the stack is ordered, paths
-    # returned by later source objects are not used if a prior source object has returned the same
-    # path.
-    def paths
-      return @paths if defined?(@paths) && @cache_paths
-      @paths = Set.new
-      @stack.each do |mp, source|
-        source.paths.each do |path|
-          @paths.add?(path.mount_at(mp))
+      # Return all paths returned by the sources in the stack.
+      #
+      # Since the stack is ordered, paths returned by later source objects are not used if a prior
+      # source object has returned the same path.
+      def paths
+        if !defined?(@paths)
+          @paths = Set.new
+          @stack.each do |mp, source|
+            source.paths.each do |path|
+              @paths.add?(path.mount_at(mp))
+            end
+          end
         end
+        @paths
       end
-      @paths
+
     end
 
   end
-
 end