webgen 0.4.7 → 0.5.0

data/lib/webgen/output.rb

@@ -0,0 +1,31 @@
+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 +type+ specifies the type of the
+  #   to be written path: +:file+ or +:directory+.
+  #
+  module Output
+
+    autoload :FileSystem, 'webgen/output/filesystem'
+
+    # Returns an instance of the configured output class.
+    def self.instance
+      klass, *args = WebsiteAccess.website.config['output']
+      Object.constant(klass).new(*args)
+    end
+
+  end
+
+end

data/lib/webgen/output/filesystem.rb

@@ -0,0 +1,61 @@
+require 'fileutils'
+
+module Webgen::Output
+
+  # This class is used to write rendered nodes out to the file system.
+  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
+
+  end
+
+end

data/lib/webgen/page.rb

@@ -0,0 +1,129 @@
+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. 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
+
+    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))/m
+    RE_BLOCKS_OPTIONS = /^--- *?(?: *((?:\w+:[^\s]* *)*))?$|^$/
+    RE_BLOCKS_START = /^--- .*?$|^--- *$/
+    RE_BLOCKS = /(?:(#{RE_BLOCKS_START})|\A)(.*?)(?:(?=#{RE_BLOCKS_START})|\Z)/m
+
+    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))
+        raise(WebgenPageFormatError, 'Invalid structure of meta information part') if md[1].nil? && data =~ RE_META_INFO_START
+        meta_info = meta_info.merge(md[1].nil? ? {} : parse_meta_info(md[1]))
+        blocks = parse_blocks(md[2] || '', meta_info)
+        new(meta_info, blocks)
+      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 +data+ and return the hash with the meta information.
+      def parse_meta_info(data)
+        begin
+          meta_info = YAML::load(data)
+          raise(WebgenPageFormatError, 'Invalid structure of meta information part') unless meta_info.kind_of?(Hash)
+        rescue ArgumentError => e
+          raise WebgenPageFormatError, e.message
+        end
+        meta_info
+      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") if content =~ /\A---/ || md.nil?
+          options = Hash[*md[1].to_s.scan(/(\w+):([^\s]*)/).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, "Same name used for more than one block: #{name}") 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 array 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 = nil)
+      @meta_info = meta_info
+      @blocks = blocks
+    end
+
+  end
+
+end

data/lib/webgen/path.rb

@@ -0,0 +1,172 @@
+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.
+  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
+
+
+    include Comparable
+
+    # The full source path.
+    attr_accessor :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 block needs to return an IO object for the
+    # content of the path.
+    def initialize(path, &ioblock)
+      @meta_info = {}
+      @io = SourceIO.new(&ioblock) if block_given?
+      analyse(path)
+    end
+
+    # Mount this path at the mount point +mp+ and return the new path object.
+    def mount_at(mp)
+      temp = dup
+      temp.path = File.join(mp, @path)
+      if @path == '/'
+        temp.send(:analyse, temp.path)
+      else
+        temp.directory = File.join(File.dirname(temp.path), '/')
+      end
+      temp
+    end
+
+    # Duplicate the path object.
+    def dup
+      temp = super
+      temp.meta_info = @meta_info.dup
+      temp
+    end
+
+    # The IO 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?, :==)
+
+    # Return +true+ if the localized path matches the given +pattern+. For information on which
+    # patterns are supported, have a look at the documentation of File.fnmatch.
+    def =~(pattern)
+      File.fnmatch(pattern, File.join(@directory, lcn), File::FNM_DOTMATCH|File::FNM_CASEFOLD|File::FNM_PATHNAME)
+    end
+
+    # 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].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

data/lib/webgen/source.rb

@@ -0,0 +1,24 @@
+module Webgen
+
+  # Namespace for all classes that provide source paths.
+  #
+  # = Implementing a source class
+  #
+  # Source classes provide access to the source paths on which the source handlers act.
+  #
+  # 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) which is not implemented in the
+  # default Path class. One can either derive a specialized path class or define singleton methods
+  # on each path object.
+  #
+  module Source
+
+    autoload :Base, 'webgen/source/base'
+    autoload :FileSystem, 'webgen/source/filesystem'
+    autoload :Stacked, 'webgen/source/stacked'
+    autoload :Resource, 'webgen/source/resource'
+
+  end
+
+end

data/lib/webgen/source/filesystem.rb

@@ -0,0 +1,56 @@
+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) { File.open(fs_path, 'r') }
+        @fs_path = fs_path
+        WebsiteAccess.website.cache[[:fs_path, @fs_path]] = 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|
+        temp = File.expand_path(f.sub(/^#{Regexp.escape(@root)}\/?/, '/'))
+        temp += '/' if File.directory?(f) && temp[-1] != ?/
+        path = Path.new(temp, f)
+        path
+      end
+    end
+
+  end
+
+end