thewoolleyman-webgen 0.5.8.20090419

data/lib/webgen/output.rb

@@ -0,0 +1,82 @@
+# -*- encoding: utf-8 -*-
+
+module Webgen
+
+  # Namespace for all classes that know how to write out node content.
+  #
+  # == Implementing an output class
+  #
+  # Output classes know how to write rendered node data to an output location.
+  #
+  # An output class must respond to three methods
+  #
+  # [<tt>exists?(path)</tt>]
+  #   Return +true+ if the output path exists.
+  # [<tt>delete(path)</tt>]
+  #   Delete the given output path.
+  # [<tt>write(path, data, type)</tt>]
+  #   Write the +data+ to the given output +path+. The parameter +data+ is either a String with the
+  #   content or a Webgen::Path::SourceIO object. The parameter +type+ specifies the type of the to
+  #   be written path: <tt>:file</tt> or <tt>:directory</tt>.
+  # [<tt>read(path)</tt>]
+  #   Return the content of the given path if it exists or raise an error otherwise.
+  #
+  #   It seems a bit odd that an output instance has to implement reading functionality. However,
+  #   consider the case where you want webgen to render a website programmatically and *use* the
+  #   output. In this case you need a way to get to content of the written files! This functionality
+  #   is used, for example, in the webgui.
+  #
+  # == Sample Output Class
+  #
+  # Following is a simple but actually used (by the webgui) output class which stores the written
+  # nodes in a hash in memory:
+  #
+  #   class MemoryOutput
+  #     include Webgen::WebsiteAccess
+  #
+  #     attr_reader :data
+  #
+  #     def initialize
+  #       @data = {}
+  #     end
+  #
+  #     def exists?(path)
+  #       @data.has_key?(path)
+  #     end
+  #
+  #     def delete(path)
+  #       @data.delete(path)
+  #     end
+  #
+  #     def write(path, io, type = :file)
+  #       @data[path] = [(io.kind_of?(String) ? io : io.data), type]
+  #     end
+  #
+  #     def read(path)
+  #       path = File.join('/', path)
+  #       raise "No such file #{path}" unless @data[path] && @data[path].last == :file
+  #       @data[path].first
+  #     end
+  #   end
+  #
+  #   WebsiteAccess.website.config.output(['MemoryOutput'])
+  #
+  # The last line is used to tell webgen to use this new output class instead of the default one.
+  #
+  module Output
+
+    autoload :FileSystem, 'webgen/output/filesystem'
+
+    # Returns an instance of the configured output class.
+    def self.instance
+      classes = (WebsiteAccess.website.cache.volatile[:classes] ||= {})
+      unless classes.has_key?(:output_instance)
+        klass, *args = WebsiteAccess.website.config['output']
+        classes[:output_instance] = Object.constant(klass).new(*args)
+      end
+      classes[:output_instance]
+    end
+
+  end
+
+end

data/lib/webgen/output/filesystem.rb

@@ -0,0 +1,69 @@
+# -*- 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 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+.
+    def read(path)
+      File.open(File.join(@root, path), 'rb') {|f| f.read}
+    end
+
+  end
+
+end

data/lib/webgen/page.rb

@@ -0,0 +1,153 @@
+# -*- encoding: utf-8 -*-
+
+require 'yaml'
+
+module Webgen
+
+  # A single block within a Page object. The content of the block can be rendered using the #render method.
+  class Block
+
+    # The name of the block.
+    attr_reader :name
+
+    # The content of the block.
+    attr_reader :content
+
+    # The options set specifically for this block.
+    attr_reader :options
+
+    # Create a new block with the name +name+ and the given +content+ and +options+.
+    def initialize(name, content, options)
+      @name, @content, @options = name, content, options
+    end
+
+    # Render the block using the provided context object.
+    #
+    # The context object needs to respond to <tt>#[]</tt> and <tt>#[]=</tt> (e.g. a Hash is a valid
+    # context object) and the key <tt>:processors</tt> needs to contain a Hash which maps processor
+    # names to processor objects that respond to <tt>#call</tt>.
+    #
+    # Uses the content processors specified in the +pipeline+ key of the +options+ attribute to do
+    # the actual rendering.
+    #
+    # Returns the given context with the rendered content.
+    def render(context)
+      context[:content] = @content.dup
+      context[:block] = self
+      @options['pipeline'].to_s.split(/,/).each do |processor|
+        raise "No such content processor available: #{processor}" unless context[:processors].has_key?(processor)
+        context[:processors][processor].call(context)
+      end
+      context
+    end
+
+  end
+
+
+  # Raised during parsing of data in Webgen Page Format if the data is invalid.
+  class WebgenPageFormatError < RuntimeError; end
+
+  # A Page object wraps a meta information hash and an array of Block objects. It is normally
+  # generated from a file or string in Webgen Page Format using the provided class methods.
+  class Page
+
+    # :stopdoc:
+    RE_META_INFO_START = /\A---\s*(?:\n|\r|\r\n)/m
+    RE_META_INFO = /\A---\s*(?:\n|\r|\r\n).*?(?:\n|\r|\r\n)(?=---.*?(?:\n|\r|\r\n)|\Z)/m
+    RE_BLOCKS_OPTIONS = /^--- *?(?: *((?:\w+:[^\s]* *)*))?$|^$/
+    RE_BLOCKS_START = /^--- .*?$|^--- *$/
+    RE_BLOCKS = /(?:(#{RE_BLOCKS_START})|\A)(.*?)(?:(?=#{RE_BLOCKS_START})|\Z)/m
+    # :startdoc:
+
+    class << self
+
+      # Parse the given string +data+ in Webgen Page Format and initialize a new Page object with
+      # the information. The +meta_info+ parameter can be used to provide default meta information.
+      def from_data(data, meta_info = {})
+        md = /(#{RE_META_INFO})?(.*)/m.match(normalize_eol(data))
+        meta_info = meta_info.merge(parse_meta_info(md[1], data))
+        blocks = parse_blocks(md[2] || '', meta_info)
+        new(meta_info, blocks)
+      end
+
+      # Parse the given string +data+ in Webgen Page Format and return the found meta information.
+      def meta_info_from_data(data)
+        md = /(#{RE_META_INFO})?/m.match(normalize_eol(data))
+        parse_meta_info(md[1], data)
+      end
+
+      #######
+      private
+      #######
+
+      # Normalize the end-of-line encodings to Unix style.
+      def normalize_eol(data)
+        data.gsub(/\r\n?/, "\n")
+      end
+
+      # Parse the meta info string in +mi_data+ and return the hash with the meta information. The
+      # original +data+ is used for checking the validness of the meta information block.
+      def parse_meta_info(mi_data, data)
+        if mi_data.nil? && data =~ RE_META_INFO_START
+          raise WebgenPageFormatError, 'Found start line for meta information block but no valid meta information block'
+        elsif mi_data.nil?
+          {}
+        else
+          begin
+            meta_info = YAML::load(mi_data.to_s)
+            unless meta_info.kind_of?(Hash)
+              raise WebgenPageFormatError, "Invalid structure of meta information block: expected YAML hash but found #{meta_info.class}"
+            end
+          rescue ArgumentError => e
+            raise WebgenPageFormatError, e.message
+          end
+          meta_info
+        end
+      end
+
+      # Parse all blocks in +data+ and return them. Meta information can be provided in +meta_info+
+      # which is used for setting the block names and options.
+      def parse_blocks(data, meta_info)
+        scanned = data.scan(RE_BLOCKS)
+        raise(WebgenPageFormatError, 'No content blocks specified') if scanned.length == 0
+
+        blocks = {}
+        scanned.each_with_index do |block_data, index|
+          options, content = *block_data
+          md = RE_BLOCKS_OPTIONS.match(options.to_s)
+          raise(WebgenPageFormatError, "Found invalid blocks starting line for block #{index+1}: #{options}") if content =~ /\A---/ || md.nil?
+          options = Hash[*md[1].to_s.scan(/(\w+):([^\s]*)/).map {|k,v| [k, (v == '' ? nil : YAML::load(v))]}.flatten]
+          options = (meta_info['blocks']['default'] || {} rescue {}).
+            merge((meta_info['blocks'][index+1] || {} rescue {})).
+            merge(options)
+
+          name = options.delete('name') || (index == 0 ? 'content' : 'block' + (index + 1).to_s)
+          raise(WebgenPageFormatError, "Previously used name '#{name}' also used for block #{index+1}") if blocks.has_key?(name)
+          content ||= ''
+          content.gsub!(/^(\\+)(---.*?)$/) {|m| "\\" * ($1.length / 2) + $2}
+          content.strip!
+          blocks[name] = blocks[index+1] = Block.new(name, content, options)
+        end
+        meta_info.delete('blocks')
+        blocks
+      end
+
+    end
+
+
+    # The contents of the meta information block.
+    attr_reader :meta_info
+
+    # The hash of blocks for the page.
+    attr_reader :blocks
+
+    # Create a new Page object with the meta information provided in +meta_info+ and the given
+    # +blocks+.
+    def initialize(meta_info = {}, blocks = {})
+      @meta_info = meta_info
+      @blocks = blocks
+    end
+
+  end
+
+end

data/lib/webgen/path.rb

@@ -0,0 +1,194 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/languages'
+
+module Webgen
+
+  # A path object provides information about a specific path as well as methods for accessing its
+  # content.
+  #
+  # A webgen source class needs to derive a specialized path class from this class and implement an
+  # approriate #changed? method that returns +true+ if the path's content has changed since the last
+  # webgen run.
+  class Path
+
+    # Helper class for easy access to the content of a path.
+    class SourceIO
+
+      # Create a new SourceIO object. A block has to be specified that returns an IO object.
+      def initialize(&block)
+        @block = block
+        raise ArgumentError, 'Need to provide a block which returns an IO object' if @block.nil?
+      end
+
+      # Provide direct access to the wrapped IO object.
+      def stream
+        io = @block.call
+        yield(io)
+      ensure
+        io.close
+      end
+
+      # Return the content of the wrapped IO object as string.
+      def data
+        stream {|io| io.read}
+      end
+
+    end
+
+
+    # Return +true+ if the given +path+ matches the given +pattern+ (trailing slashes of directories
+    # are not respected). For information on which patterns are supported, have a look at the
+    # documentation of File.fnmatch.
+    def self.match(path, pattern)
+      path = path.to_s.chomp('/') unless path == '/'
+      pattern = pattern.to_s.chomp('/') unless pattern == '/'
+      File.fnmatch(pattern, path, File::FNM_DOTMATCH|File::FNM_CASEFOLD|File::FNM_PATHNAME)
+    end
+
+
+    include Comparable
+
+    # The full path.
+    attr_accessor :path
+
+    # The source path that lead to the creation of this path.
+    attr_accessor :source_path
+
+    # The basename part of the path.
+    attr_accessor :basename
+
+    # The directory part of the path.
+    attr_accessor :directory
+
+    # The canonical name without the extension.
+    attr_accessor :cnbase
+
+    # The extension.
+    attr_accessor :ext
+
+    # Extracted meta information for the path.
+    attr_accessor :meta_info
+
+    # Create a new Path object for +path+. The optional +source_path+ parameter specifies the path
+    # that lead to the creation of this path. The optional block needs to return an IO object for
+    # the content of the path.
+    def initialize(path, source_path = path, &ioblock)
+      @meta_info = {}
+      @io = block_given? ? SourceIO.new(&ioblock) : nil
+      @source_path = source_path
+      analyse(path)
+    end
+
+    # Mount this path at the mount point +mp+ optionally stripping +prefix+ from the path and return
+    # the new path object.
+    def mount_at(mp, prefix = nil)
+      temp = dup
+      temp.path = temp.path.sub(/^#{Regexp.escape(prefix.chomp("/"))}/, '') if prefix     #"
+      reanalyse = (@path == '/' || temp.path == '/')
+      temp.path = File.join(mp, temp.path)
+      temp.source_path = temp.path if @path == @source_path
+      if reanalyse
+        temp.send(:analyse, temp.path)
+      else
+        temp.directory = File.join(File.dirname(temp.path), '/')
+      end
+      temp
+    end
+
+    # Has the content of this path changed since the last webgen run? This default implementation
+    # always returns +true+, a specialized sub class needs to override this behaviour!
+    def changed?
+      true
+    end
+
+    # Duplicate the path object.
+    def dup
+      temp = super
+      temp.meta_info = @meta_info.dup
+      temp
+    end
+
+    # The SourceIO object associated with the path.
+    def io
+      if @io
+        @io
+      else
+        raise "No IO object defined for the path #{self}"
+      end
+    end
+
+    # The canonical name created from the filename (created from cnbase and extension).
+    def cn
+      @cnbase + (@ext.length > 0 ? '.' + @ext : '')
+    end
+
+    # Utility method for creating the lcn from +cn+ and the language +lang+.
+    def self.lcn(cn, lang)
+      if lang.nil?
+        cn
+      else
+        cn.split('.').insert(1, lang.to_s).join('.')
+      end
+    end
+
+    # The localized canonical name created from the filename.
+    def lcn
+      self.class.lcn(cn, @meta_info['lang'])
+    end
+
+    # Compare this object to another Path or a String.
+    def ==(other)
+      if other.kind_of?(Path)
+        other.path == @path
+      elsif other.kind_of?(String)
+        other == @path
+      else
+        false
+      end
+    end
+    alias_method(:eql?, :==)
+
+    # Implemented sothat a Path looks like a String when used as key in a hash.
+    def <=>(other)
+      @path <=> other.to_str
+    end
+
+    # Implemented sothat a Path looks like a String when used as key in a hash.
+    def hash
+      @path.hash
+    end
+
+    def to_s #:nodoc:
+      @path.dup
+    end
+    alias_method :to_str, :to_s
+
+    def inspect #:nodoc:
+      "#<Path: #{@path}>"
+    end
+
+    #######
+    private
+    #######
+
+    FILENAME_RE = /^(?:(\d+)\.)?([^.]*?)(?:\.(\w\w\w?)(?=.))?(?:\.(.*))?$/
+
+    # Analyse the +path+ and fill the object with the extracted information.
+    def analyse(path)
+      @path = path
+      @basename = File.basename(path)
+      @directory = File.join(File.dirname(path), '/')
+      matchData = FILENAME_RE.match(@basename)
+
+      @meta_info['sort_info'] = (matchData[1].nil? ? nil : matchData[1].to_i)
+      @cnbase                 = matchData[2]
+      @meta_info['lang']      = Webgen::LanguageManager.language_for_code(matchData[3])
+      @ext                    = (@meta_info['lang'].nil? && !matchData[3].nil? ? matchData[3].to_s + '.' : '') + matchData[4].to_s
+
+      @meta_info['title']     = @cnbase.tr('_-', ' ').capitalize
+    end
+
+  end
+
+end