webgen 0.5.17 → 1.0.0.beta1

data/lib/webgen/output/filesystem.rb

@@ -1,69 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'fileutils'
-
-module Webgen::Output
-
-  # This class uses the file systems as output device. On initialization a +root+ path is set and
-  # all other operations are taken relative to this root path.
-  class FileSystem
-
-    include Webgen::WebsiteAccess
-
-    # The root path, ie. the path to which the root node gets rendered.
-    attr_reader :root
-
-    # Create a new object with the given +root+ path. If +root+ is not absolute, it is taken
-    # relative to the website directory.
-    def initialize(root)
-      #TODO: copied from source/filesystem.rb
-      if root =~ /^([a-zA-Z]:|\/)/
-        @root = root
-      else
-        @root = File.join(website.directory, root)
-      end
-    end
-
-    # Return +true+ if the given path exists.
-    def exists?(path)
-      File.exists?(File.join(@root, path))
-    end
-
-    # Delete the given +path+
-    def delete(path)
-      dest = File.join(@root, path)
-      if File.directory?(dest)
-        FileUtils.rm_rf(dest)
-      else
-        FileUtils.rm(dest)
-      end
-    end
-
-    # Write the +data+ to the given +path+. The +type+ parameter specifies the type of the path to
-    # be created which can either be <tt>:file</tt> or <tt>:directory</tt>.
-    def write(path, data, type = :file)
-      dest = File.join(@root, path)
-      FileUtils.makedirs(File.dirname(dest))
-      if type == :directory
-        FileUtils.makedirs(dest)
-      elsif type == :file
-        if data.kind_of?(String)
-          File.open(dest, 'wb') {|f| f.write(data) }
-        else
-          data.stream('rb') do |source|
-            File.open(dest, 'wb') {|f| FileUtils.copy_stream(source, f) }
-          end
-        end
-      else
-        raise "Unsupported path type '#{type}' for #{path}"
-      end
-    end
-
-    # Return the content of the given +path+ which is opened in +mode+.
-    def read(path, mode = 'rb')
-      File.open(File.join(@root, path), mode) {|f| f.read}
-    end
-
-  end
-
-end

data/lib/webgen/source/filesystem.rb

@@ -1,61 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'pathname'
-require 'webgen/websiteaccess'
-require 'webgen/path'
-
-module Webgen
-
-  # This class is used to read source paths from a directory in the file system.
-  class Source::FileSystem
-
-    # A special Webgen::Path class for handling with file system paths.
-    class Path < Webgen::Path
-
-      # Create a new object with absolute path +path+ for the file system path +fs_path+.
-      def initialize(path, fs_path)
-        super(path) {|mode| File.open(fs_path, mode) }
-        @fs_path = fs_path
-        WebsiteAccess.website.cache[[:fs_path, @fs_path]] = File.mtime(@fs_path)
-        @meta_info['modified_at'] = File.mtime(@fs_path)
-      end
-
-      # Return +true+ if the file system path used by the object has been modified.
-      def changed?
-        data = WebsiteAccess.website.cache[[:fs_path, @fs_path]]
-        File.mtime(@fs_path) > data
-      end
-
-    end
-
-    # The root path from which paths 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+.
-    def initialize(root, glob = '**/*')
-      if root =~ /^([a-zA-Z]:|\/)/
-        @root = root
-      else
-        @root = File.join(WebsiteAccess.website.directory, root)
-      end
-      @glob = glob
-    end
-
-    # Return all paths under #root which match #glob.
-    def paths
-      @paths ||= Dir.glob(File.join(@root, @glob), File::FNM_DOTMATCH|File::FNM_CASEFOLD).to_set.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 = Path.new(temp, f)
-        path
-      end.compact
-    end
-
-  end
-
-end

data/lib/webgen/source/resource.rb

@@ -1,45 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'webgen/websiteaccess'
-require 'webgen/source'
-require 'webgen/common'
-
-module Webgen::Source
-
-  # This class is used to provide access to sources provided by resources.
-  class Resource
-
-    include Webgen::WebsiteAccess
-
-    # The glob (see File.fnmatch) specifying the resources.
-    attr_reader :glob
-
-    # The glob (see File.fnmatch) specifying the paths that should be used from the resources.
-    attr_reader :paths_glob
-
-    # The prefix that should optionally be stripped from the paths.
-    attr_reader :strip_prefix
-
-    # Create a new resource source for the the +glob+ and use only those paths matching +paths_glob+
-    # while stripping +strip_prefix+ off the path.
-    def initialize(glob, paths_glob = nil, strip_prefix = nil)
-      @glob, @paths_glob, @strip_prefix = glob, paths_glob, strip_prefix
-    end
-
-    # Return all paths associated with the resources identified by #glob.
-    def paths
-      if !defined?(@paths)
-        stack = Stacked.new
-        website.config['resources'].select {|name, infos| File.fnmatch(@glob, name)}.sort.each do |name, infos|
-          stack.add([['/', Webgen::Common.const_for_name(infos.first).new(*infos[1..-1])]])
-        end
-        @paths = stack.paths
-        @paths = @paths.select {|p| File.fnmatch(@paths_glob, p)} if @paths_glob
-        @paths.collect! {|p| p.mount_at('/', @strip_prefix)} if @strip_prefix
-      end
-      @paths
-    end
-
-  end
-
-end

data/lib/webgen/source/tararchive.rb

@@ -1,78 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'pathname'
-require 'webgen/websiteaccess'
-require 'webgen/path'
-require 'open-uri'
-require 'zlib'
-begin
-  require 'archive/tar/minitar'
-rescue LoadError
-  raise Webgen::LoadError.new('archive/tar/minitar', self.class.name, nil, 'archive-tar-minitar')
-end
-
-module Webgen
-
-  # This class is used to read source paths from a (gzipped) tar archive. The archive can be remote
-  # (http(s) or ftp) or local.
-  #
-  # For example, the following are all valid URIs:
-  #   http://example.com/directory/file.tgz
-  #   /home/test/my.tar.gz
-  #   ftp://ftp.example.com/archives/archive.tar
-  #
-  class Source::TarArchive
-
-    # A special Webgen::Path class for handling paths from a tar archive.
-    class Path < Webgen::Path
-
-      # Create a new tar archive path object for the entry +entry+.
-      def initialize(path, data, mtime, uri)
-        super(path) {|mode| StringIO.new(data.to_s, mode) }
-        @uri = uri
-        @mtime = mtime
-        WebsiteAccess.website.cache[[:tararchive_path, @uri, path]] = @mtime if WebsiteAccess.website
-        @meta_info['modified_at'] = @mtime
-      end
-
-      # Return +true+ if the tar archive path used by the object has been modified.
-      def changed?
-        !WebsiteAccess.website || @mtime > WebsiteAccess.website.cache[[:tararchive_path, @uri, path]]
-      end
-
-    end
-
-    # The URI of the tar archive.
-    attr_reader :uri
-
-    # The glob (see File.fnmatch for details) that is used to specify which paths in the archive should
-    # be returned by #paths.
-    attr_reader :glob
-
-    # Create a new tar archive source for the URI string +uri+.
-    def initialize(uri, glob = '**/*')
-      @uri = uri
-      @glob = glob
-    end
-
-    # Return all paths in the tar archive available at #uri.
-    def paths
-      if !defined?(@paths)
-        stream = open(@uri)
-        stream = Zlib::GzipReader.new(stream) if @uri =~ /(\.tar\.gz|\.tgz)$/
-        Archive::Tar::Minitar::Input.open(stream) do |input|
-          @paths = input.collect do |entry|
-            path = entry.full_name
-            next unless File.fnmatch(@glob, path, File::FNM_DOTMATCH|File::FNM_CASEFOLD|File::FNM_PATHNAME)
-            path += '/' if entry.directory? && path[-1,1] != '/'
-            path = '/' + path unless path[0,1] == '/'
-            Path.new(path, entry.read, Time.at(entry.mtime), @uri)
-          end.compact.to_set
-        end
-      end
-      @paths
-    end
-
-  end
-
-end

data/lib/webgen/sourcehandler.rb

@@ -1,275 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'webgen/loggable'
-require 'webgen/common'
-require 'benchmark'
-
-module Webgen
-
-  # Namespace for all classes that handle source paths.
-  #
-  # Have a look at Webgen::SourceHandler::Base for details on how to implement a source handler
-  # class.
-  module SourceHandler
-
-    autoload :Base, 'webgen/sourcehandler/base'
-    autoload :Copy, 'webgen/sourcehandler/copy'
-    autoload :Directory, 'webgen/sourcehandler/directory'
-    autoload :Metainfo, 'webgen/sourcehandler/metainfo'
-    autoload :Template, 'webgen/sourcehandler/template'
-    autoload :Page, 'webgen/sourcehandler/page'
-    autoload :Fragment, 'webgen/sourcehandler/fragment'
-    autoload :Virtual, 'webgen/sourcehandler/virtual'
-    autoload :Feed, 'webgen/sourcehandler/feed'
-    autoload :Sitemap, 'webgen/sourcehandler/sitemap'
-    autoload :Memory, 'webgen/sourcehandler/memory'
-
-    # This class is used by Website to do the actual rendering of the website. It
-    #
-    # * collects all source paths using the source classes
-    # * creates nodes using the source handler classes
-    # * writes changed nodes out using an output class
-    # * deletes old nodes
-    class Main
-
-      include WebsiteAccess
-      include Loggable
-
-      def initialize #:nodoc:
-        website.blackboard.add_service(:create_nodes, method(:create_nodes))
-        website.blackboard.add_service(:create_nodes_from_paths, method(:create_nodes_from_paths))
-        website.blackboard.add_service(:source_paths, method(:find_all_source_paths))
-        website.blackboard.add_listener(:node_meta_info_changed?, method(:meta_info_changed?))
-
-        website.blackboard.add_listener(:before_node_deleted) do |node|
-          unless node.is_fragment? || node['no_output'] || node.path == '/' || node == node.tree.dummy_root
-            website.blackboard.invoke(:output_instance).delete(node.path)
-          end
-        end if website.config['output.do_deletion']
-      end
-
-      # Render the current website. Before the actual rendering is done, the sources are checked for
-      # changes, i.e. nodes for deleted sources are deleted, nodes for new and changed sources are
-      # updated.
-      def render
-        begin
-          website.logger.mark_new_cycle if website.logger
-
-          puts "Updating tree..."
-          time = Benchmark.measure do
-            website.cache.reset_volatile_cache
-            update_tree
-          end
-          puts "...done in " + ('%2.4f' % time.real) + ' seconds'
-
-          if !website.tree.root
-            puts 'No source files found - maybe not a webgen website?'
-            return nil
-          end
-
-          puts "Writing changed nodes..."
-          time = Benchmark.measure do
-            write_tree
-          end
-          puts "...done in " + ('%2.4f' % time.real) + ' seconds'
-        end while website.tree.node_access[:alcn].any? {|name,node| node.flagged?(:created) || node.flagged?(:reinit)}
-        :success
-      rescue Webgen::Error
-        raise
-      rescue Exception => e
-        raise Webgen::Error.new(e)
-      end
-
-      #######
-      private
-      #######
-
-      # Update the <tt>website.tree</tt> by creating/reinitializing all needed nodes.
-      def update_tree
-        unused_paths = Set.new
-        referenced_nodes = Set.new
-        all_but_passive_paths = Set.new(find_all_source_paths.select {|name, path| !path.passive?}.collect {|name, path| name})
-        begin
-          used_paths = all_but_passive_paths - unused_paths
-          paths_to_use = Set.new
-          nodes_to_delete = Set.new
-          passive_nodes = Set.new
-
-          website.tree.node_access[:alcn].each do |alcn, node|
-            next if node == website.tree.dummy_root
-
-            begin
-              used_paths.delete(node.node_info[:src])
-
-              src_path = find_all_source_paths[node.node_info[:src]]
-              if !src_path
-                nodes_to_delete << node
-              elsif (!node.flagged?(:created) && src_path.changed?) || node.meta_info_changed?
-                node.flag(:reinit)
-                paths_to_use << node.node_info[:src]
-              elsif node.changed?
-                # nothing to be done here but method node.changed? has to be called
-              end
-
-              if src_path && src_path.passive?
-                passive_nodes << node
-              elsif src_path
-                referenced_nodes += node.node_info[:used_meta_info_nodes] + node.node_info[:used_nodes]
-              end
-            rescue Webgen::Error => e
-              e.alcn = node.alcn unless e.alcn
-              raise
-            rescue Exception => e
-              raise Webgen::Error.new(e, nil, node)
-            end
-          end
-
-          # add unused passive nodes to node_to_delete set
-          unreferenced_passive_nodes, other_passive_nodes = passive_nodes.partition do |pnode|
-            !referenced_nodes.include?(pnode.alcn)
-          end
-          refs = other_passive_nodes.collect {|n| (n.node_info[:used_meta_info_nodes] + n.node_info[:used_nodes]).to_a}.flatten
-          unreferenced_passive_nodes.each {|n| nodes_to_delete << n if !refs.include?(n.alcn)}
-
-          nodes_to_delete.each {|node| website.tree.delete_node(node)}
-          used_paths.merge(paths_to_use)
-          paths = create_nodes_from_paths(used_paths).collect {|n| n.node_info[:src]}
-          unused_paths.merge(used_paths - paths)
-          website.tree.node_access[:alcn].each {|name, node| website.tree.delete_node(node) if node.flagged?(:reinit)}
-          website.cache.reset_volatile_cache
-        end until used_paths.empty?
-      end
-
-      # Write out all changed nodes of the <tt>website.tree</tt>.
-      def write_tree
-        output = website.blackboard.invoke(:output_instance)
-
-        website.tree.node_access[:alcn].select do |name, node|
-          use_node = (node != website.tree.dummy_root && node.flagged?(:dirty))
-          node.unflag(:dirty_meta_info)
-          node.unflag(:created)
-          node.unflag(:dirty)
-          use_node
-        end.sort.each do |name, node|
-          begin
-            next if node['no_output'] || !(content = node.content)
-
-            puts " "*4 + name, :verbose
-            type = if node.is_directory?
-                     :directory
-                   elsif node.is_fragment?
-                     :fragment
-                   else
-                     :file
-                   end
-            output.write(node.path, content, type)
-          rescue Webgen::Error => e
-            e.alcn = node.alcn unless e.alcn
-            raise
-          rescue Exception => e
-            raise Webgen::RenderError.new(e, nil, node)
-          end
-        end
-      end
-
-      # Return a hash with all source paths.
-      def find_all_source_paths
-        if !defined?(@paths)
-          active_source = Webgen::Source::Stacked.new(website.config['sources'].collect do |mp, name, *args|
-                                                        [mp, Webgen::Common.const_for_name(name).new(*args)]
-                                                      end)
-          passive_source = Webgen::Source::Stacked.new(website.config['passive_sources'].collect do |mp, name, *args|
-                                                         [mp, Webgen::Common.const_for_name(name).new(*args)]
-                                                       end, true)
-          passive_source.paths.each {|path| path.passive = true }
-          source = Webgen::Source::Stacked.new([['/', active_source], ['/', passive_source]])
-
-          @paths = {}
-          source.paths.each do |path|
-            if !(website.config['sourcehandler.ignore'].any? {|pat| File.fnmatch(pat, path, File::FNM_CASEFOLD|File::FNM_DOTMATCH)})
-              @paths[path.source_path] = path
-            end
-          end
-        end
-        @paths
-      end
-
-      # Return only the subset of +paths+ which are handled by the source handler +name+.
-      def paths_for_handler(name, paths)
-        patterns = website.config['sourcehandler.patterns'][name]
-        return [] if patterns.nil?
-
-        options = (website.config['sourcehandler.casefold'] ? File::FNM_CASEFOLD : 0) |
-          (website.config['sourcehandler.use_hidden_files'] ? File::FNM_DOTMATCH : 0) |
-          File::FNM_PATHNAME
-        find_all_source_paths.values_at(*paths).compact.select do |path|
-          patterns.any? {|pat| File.fnmatch(pat, path, options)}
-        end
-      end
-
-      # Use the source handlers to create nodes for the +paths+ in the <tt>website.tree</tt> and
-      # return the nodes that have been created.
-      def create_nodes_from_paths(paths)
-        nodes = Set.new
-        website.config['sourcehandler.invoke'].sort.each do |priority, shns|
-          shns.each do |shn|
-            sh = website.cache.instance(shn)
-            handler_paths = paths_for_handler(shn, paths)
-            handler_paths.sort {|a,b| a.path.length <=> b.path.length}.each do |path|
-              if !website.tree[path.parent_path]
-                nodes.merge(create_nodes_from_paths([path.parent_path]))
-              end
-              nodes += create_nodes(path, sh)
-            end
-          end
-        end
-        nodes
-      end
-
-      # Prepare everything to create from the +path+ using the +source_handler+. If a block is
-      # given, the actual creation of the nodes is deferred to it. Otherwise the #create_node method
-      # of the +source_handler+ is used. After the nodes are created, it is also checked if they
-      # have all needed properties.
-      def create_nodes(path, source_handler) #:yields: path
-        path = path.dup
-        path.meta_info = default_meta_info(path, source_handler.class.name)
-        (website.cache[:sourcehandler_path_mi] ||= {})[[path.path, source_handler.class.name]] = path.meta_info.dup
-        website.blackboard.dispatch_msg(:before_node_created, path)
-        *nodes = if block_given?
-                   yield(path)
-                 else
-                   source_handler.create_node(path)
-                 end
-        nodes = nodes.flatten.compact
-        nodes.each {|node| website.blackboard.dispatch_msg(:after_node_created, node)}
-        nodes
-      rescue Webgen::Error => e
-        e.alcn = path unless e.alcn
-        raise
-      rescue Exception => e
-        raise Webgen::NodeCreationError.new(e, source_handler.class.name, path)
-      end
-
-      # Return the default meta info for the pair of +path+ and +sh_name+.
-      def default_meta_info(path, sh_name)
-        path.meta_info.merge(website.config['sourcehandler.default_meta_info'][:all]).
-          merge(website.config['sourcehandler.default_meta_info'][sh_name] || {})
-      end
-
-      # Check if the default meta information for +node+ has changed since the last run. But don't
-      # take the node's path's +modified_at+ meta information into account since that changes on
-      # every path change.
-      def meta_info_changed?(node)
-        path = node.node_info[:creation_path]
-        old_mi = website.cache[:sourcehandler_path_mi][[path, node.node_info[:processor]]]
-        old_mi.delete('modified_at')
-        new_mi = default_meta_info(@paths[path] || Webgen::Path.new(path), node.node_info[:processor])
-        new_mi.delete('modified_at')
-        node.flag(:dirty_meta_info) if !old_mi || old_mi != new_mi
-      end
-
-    end
-
-  end
-
-end