webgen 0.5.17 → 1.0.0.beta1

data/lib/webgen/tag/meta_info.rb

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+require 'cgi'
+
+module Webgen
+  class Tag
+
+    # Provides easy access to the meta information of a node.
+    module MetaInfo
+
+      # Treat +tag+ as a meta information key and return its value from the content node.
+      def self.call(tag, body, context)
+        output = ''
+        if tag == 'lang'
+          output = context.content_node.lang
+        elsif context.content_node[tag]
+          output = context.content_node[tag].to_s
+          output = CGI::escapeHTML(output) if context[:config]['tag.meta_info.escape_html']
+        else
+          context.website.logger.error do
+            ["No meta info key '#{tag}' found in <#{context.content_node}> (referenced in <#{context.ref_node}>)",
+             "Add the meta info key '#{tag}' to <#{context.content_node}> or remove the" +
+             " reference in <#{context.ref_node}> to fix this error."]
+          end
+        end
+        output
+      end
+
+    end
+
+  end
+end

data/lib/webgen/tag/relocatable.rb

@@ -2,49 +2,58 @@
 
 require 'uri'
 
-module Webgen::Tag
-
-  # Makes a path relative. This is very useful for templates. For example, you normally include a
-  # stylesheet in a template. If you specify the filename of the stylesheet directly, the reference
-  # to the stylesheet in the output file of a page file that is not in the same directory as the
-  # template would be invalid.
-  #
-  # By using the +relocatable+ tag you ensure that the path stays valid.
-  class Relocatable
-
-    include Webgen::Tag::Base
-
-    # Return the relativized path for the path provided in the tag definition.
-    def call(tag, body, context)
-      path = param('tag.relocatable.path')
-      result = ''
-      begin
-        result = (Webgen::Node.url(path, false).absolute? ? path : resolve_path(path, context))
-      rescue URI::InvalidURIError => e
-        raise Webgen::RenderError.new("Error while parsing path '#{path}': #{e.message}",
-                                      self.class.name, context.dest_node, context.ref_node)
+module Webgen
+  class Tag
+
+    # Makes a path relative.
+    #
+    # For example, you normally include a stylesheet in a template. If you specify the path name of
+    # the stylesheet directly, the reference to the stylesheet in the output file of a page file
+    # that is not in the same directory as the template would be invalid.
+    #
+    # By using the relocatable tag you ensure that the path stays valid.
+    module Relocatable
+
+      # Return the relativized path for the path provided in the tag definition.
+      def self.call(tag, body, context)
+        path = context[:config]['tag.relocatable.path']
+        result = ''
+        begin
+          result = (Webgen::Path.url(path, false).absolute? ? path : resolve_path(path, context))
+        rescue URI::InvalidURIError => e
+          context.website.logger.warn do
+            ["Could not parse path '#{path}' for tag.relocatable in <#{context.ref_node}>",
+             e.message]
+          end
+        end
+        result
       end
-      result
-    end
 
-    #######
-    private
-    #######
-
-    # Resolve the path +path+ using the reference node and return the correct relative path from the
-    # destination node.
-    def resolve_path(path, context)
-      dest_node = context.ref_node.resolve(path, context.dest_node.lang)
-      if dest_node
-        context.dest_node.node_info[:used_meta_info_nodes] << dest_node.alcn
-        context.dest_node.route_to(dest_node)
-      else
-        log(:error) { "Could not resolve path '#{path}' in <#{context.ref_node}>" }
-        context.dest_node.flag(:dirty)
-        ''
+      # Resolve the path using the reference node and return the correct relative path from the
+      # destination node.
+      def self.resolve_path(path, context)
+        fragment = ''
+
+        if context[:config]['tag.relocatable.ignore_unknown_fragment']
+          file, *fragments = path.split('#')
+          fragment = '#' << fragments.join('#') unless fragments.empty?
+          dest_node = context.ref_node.resolve(file, context.dest_node.lang, true)
+          context.website.logger.vinfo do
+            "Ignoring unknown fragment part of path '#{path}' for tag.relocatable in <#{context.ref_node}>"
+          end if dest_node && fragment.length > 0
+        else
+          dest_node = context.ref_node.resolve(path, context.dest_node.lang, true)
+        end
+
+        if dest_node
+          context.website.ext.item_tracker.add(context.dest_node, :node_meta_info, dest_node.alcn)
+          context.dest_node.route_to(dest_node) + fragment
+        else
+          ''
+        end
       end
+
     end
 
   end
-
 end

data/lib/webgen/tag/tikz.rb

@@ -1,116 +1,40 @@
 # -*- encoding: utf-8 -*-
 
-require 'erb'
-require 'tempfile'
-require 'fileutils'
+require 'webgen/path'
 
-module Webgen::Tag
+module Webgen
+  class Tag
 
-  # This tag allows the creation and inclusion of complex graphics using the PGF/TikZ library of
-  # LaTeX. You will need a current LaTeX distribution and the +convert+ utility from ImageMagick.
-  class TikZ
+    # This tag allows you to create and use complex graphics using the PGF/TikZ library of LaTeX. It
+    # uses Webgen::ContentProcessor::Tikz for doing the hard work.
+    module Tikz
 
-    include Webgen::Tag::Base
-    include Webgen::WebsiteAccess
+      # Create a graphic (i.e. an HTML img tag) from the commands in the body of the tag.
+      def self.call(tag, body, context)
+        path = Webgen::Path.append(context.ref_node.parent.alcn, context[:config]['tag.tikz.path'])
+        path = Webgen::Path.new(path)
 
-    LATEX_TEMPLATE = <<EOF
-\\nonstopmode \\documentclass{article} \\usepackage{tikz} \\pagestyle{empty}
-<% if param('tag.tikz.libraries') %>
-\\usetikzlibrary{<%= param('tag.tikz.libraries').join(',') %>}
-<% end %>
-\\begin{document}
-<% if param('tag.tikz.opts') %>
-\\begin{tikzpicture}[<%= param('tag.tikz.opts') %>]
-<% else %>
-\\begin{tikzpicture}
-<% end %>
-<%= body %>
-\\end{tikzpicture}
-\\end{document}
-EOF
+        add_tikz_options!(path, context)
 
-    # Create a graphic from the commands in the body of the tag.
-    def call(tag, body, context)
-      path = param('tag.tikz.path')
-      path = Webgen::Path.make_absolute(context.ref_node.parent.alcn, path)
+        node = context.website.ext.path_handler.create_secondary_nodes(path, body, 'copy', context.ref_node.alcn).first
 
-      mem_handler = website.cache.instance('Webgen::SourceHandler::Memory')
-      src_path = context.ref_node.node_info[:src]
-      parent = website.blackboard.invoke(:create_directories, context.ref_node.tree.root, File.dirname(path), src_path)
-      params = @params
-
-      node = website.blackboard.invoke(:create_nodes, Webgen::Path.new(path, src_path), mem_handler) do |node_path|
-        mem_handler.create_node(node_path, context.ref_node.alcn) do |pic_node|
-          set_params(params)
-          document = ERB.new(LATEX_TEMPLATE).result(binding)
-          pic_path = compile(document, File.extname(path), context)
-          set_params(nil)
-          if pic_path
-            io = Webgen::Path::SourceIO.new { File.open(pic_path, 'rb') }
-          else
-            pic_node.flag(:dirty)
-            nil
-          end
-        end
-      end.first
-      attrs = {'alt' => ''}.merge(param('tag.tikz.img_attr')).collect {|name,value| "#{name.to_s}=\"#{value}\"" }.sort.unshift('').join(' ')
-      "<img src=\"#{context.dest_node.route_to(node)}\"#{attrs} />"
-    end
-
-    #######
-    private
-    #######
-
-    # Compile the LaTeX +document+ and convert the resulting PDF to the correct output image format
-    # specified by +ext+ (the extension needs to include the dot).
-    def compile(document, ext, context)
-      file = Tempfile.new('webgen-tikz')
-      file.write(document)
-      file.close
-
-      FileUtils.mv(file.path, file.path + '.tex')
-      cmd_prefix = "cd #{File.dirname(file.path)}; "
-      output = `#{cmd_prefix} pdflatex --shell-escape -interaction=batchmode #{File.basename(file.path)}.tex`
-      if $?.exitstatus != 0
-        errors = output.scan(/^!(.*\n.*)/).join("\n")
-        raise Webgen::RenderError.new("Error while creating a TikZ picture: #{errors}",
-                                      self.class.name, context.dest_node, context.ref_node)
-      else
-        cmd = cmd_prefix + "pdfcrop #{File.basename(file.path)}.pdf #{File.basename(file.path)}.pdf; "
-        return unless run_command(cmd, context)
-
-        render_res, output_res = param('tag.tikz.resolution').split(' ')
-        if param('tag.tikz.transparent') && ext =~ /\.png/i
-          cmd = cmd_prefix +
-            "gs -dSAFER -dBATCH -dNOPAUSE -r#{render_res} -sDEVICE=pngalpha -dGraphicsAlphaBits=4 -dTextAlphaBits=4 " +
-            "-sOutputFile=#{File.basename(file.path)}#{ext} #{File.basename(file.path)}.pdf"
-        else
-          cmd = cmd_prefix + "convert -density #{render_res} #{File.basename(file.path)}.pdf #{File.basename(file.path)}#{ext}"
-        end
-        return unless run_command(cmd, context)
+        attrs = {'alt' => ''}.merge(context[:config]['tag.tikz.img_attr']).collect do |name, value|
+          "#{name.to_s}=\"#{value}\""
+        end.sort.unshift('').join(' ')
+        "<img src=\"#{context.dest_node.route_to(node)}\"#{attrs} />"
+      end
 
-        if render_res != output_res
-          cmd = cmd_prefix + "identify #{File.basename(file.path)}#{ext}"
-          return unless (output = run_command(cmd, context))
-          width, height = output.scan(/\s\d+x\d+\s/).first.strip.split('x').collect {|s| s.to_f * output_res.to_f / render_res.to_f }
-          cmd = cmd_prefix + "convert -resize #{width}x#{height} #{File.basename(file.path)}#{ext} #{File.basename(file.path)}#{ext}"
-          return unless run_command(cmd, context)
+      # Add all needed options for Webgen::ContentProcessor::Tikz to the given path.
+      def self.add_tikz_options!(path, context)
+        %w[content_processor.tikz.resolution content_processor.tikz.transparent
+           content_processor.tikz.libraries content_processor.tikz.opts].each do |opt|
+          path.meta_info[opt] = context[:config][opt]
         end
-        file.path + ext
+        path.meta_info['pipeline'] = 'tikz'
       end
-    end
+      private_class_method :add_tikz_options!
 
-    # Runs the command +cmd+ and returns it's output if successful or +nil+ otherwise.
-    def run_command(cmd, context)
-      output = `#{cmd}`
-      if $?.exitstatus != 0
-        raise Webgen::RenderError.new("Error while running a command for a TikZ picture: #{output}",
-                                      self.class.name, context.dest_node, context.ref_node)
-      else
-        output
-      end
     end
 
   end
-
 end

data/lib/webgen/task.rb

@@ -0,0 +1,99 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/extension_manager'
+
+module Webgen
+
+  # Namespace for all tasks.
+  #
+  # == About
+  #
+  # Tasks provide the main entrance point for doing things with a website, like creating it,
+  # generating it, and much more.
+  #
+  # == Implementing a task
+  #
+  # A task object only needs to respond to one method called +call+ which takes the website as first
+  # parameter and may take an arbitrary number of additional arguments. The method should return
+  # +true+ if the task was executed sucessfully or else +false+.
+  #
+  # Due to this there are basically two ways to implement a task since: Either as a class with a
+  # class method called +call+. Or as a Proc object.
+  #
+  # If the task needs to be configured to work correctly, use additional parameters or configuration
+  # options.
+  #
+  # The task has to be registered so that webgen knows about it, see #register for more information.
+  #
+  # == Sample Task
+  #
+  # The following sample task just outputs the value of its configuration option:
+  #
+  #   class OutputTask
+  #
+  #     def self.call(website, options)
+  #       website.logger.vinfo("The output task configuration value follows")
+  #       website.logger.info(website.config['task.output.option'])
+  #       true
+  #     end
+  #
+  #   end
+  #
+  #   website.config.define_option('task.output.option', nil, 'The configuration option')
+  #   website.ext.task.register OutputTask, :name => 'output'
+  #
+  class Task
+
+    include Webgen::ExtensionManager
+
+    # Create a new task manager for the given website.
+    def initialize(website)
+      super()
+      @website = website
+    end
+
+    # Register a task.
+    #
+    # The parameter +klass+ can either be a String containing the name of a class/module (which has
+    # to respond to :call) or an object that responds to :call. If the class is located under this
+    # namespace, only the class name without the hierarchy part is needed, otherwise the full
+    # class/module name including parent module/class names is needed.
+    #
+    # Instead of registering an object that responds to :call, you can also provide a block.
+    #
+    # === Options:
+    #
+    # [:name] The name for the task. If not set, it defaults to the snake-case version of the class
+    #         name (without the hierarchy part). It should only contain letters.
+    #
+    # [:data] Associates arbitrary data with the task object. This data can be retrieved using the
+    #         #data method.
+    #
+    # === Examples:
+    #
+    #   task.register('CreateWebsite')     # registers Webgen::Task::CreateWebsite
+    #
+    #   task.register('::CreateWebsite')   # registers CreateWebsite !!!
+    #
+    #   task.register('doit') do |website|
+    #     # task commands go here
+    #   end
+    #
+    def register(klass, options={}, &block)
+      name = do_register(klass, options, true, &block)
+      ext_data(name).data = options[:data]
+    end
+
+    # Execute the task identified by the given name.
+    def execute(name, *options)
+      extension(name).call(@website, *options)
+    end
+
+    # Return the task data for the given task.
+    def data(name)
+      ext_data(name).data
+    end
+
+  end
+
+end

data/lib/webgen/task/create_bundle.rb

@@ -0,0 +1,73 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/task'
+require 'webgen/utils'
+require 'fileutils'
+
+module Webgen
+  class Task
+
+    # Creates an extension bundle.
+    #
+    # An extension bundle is a collection of webgen extensions. This task can either create a local
+    # bundle (in the +ext+ directory of the current website) or a bundle which can be distributed
+    # via Rubygems.
+    #
+    module CreateBundle
+
+      TEMPLATE_DIR = 'bundle_template_files'
+
+      # Create an extension bundle with the given name and of the given type (either :local or :gem).
+      #
+      # If the type is :gem, the directory in which the bundle should be created can optionally be
+      # specified.
+      #
+      # Returns +true+ if the bundle has been created.
+      def self.call(website, name, type, directory = name)
+        dir = if type == :gem
+                create_distribution_bundle(website, directory, name)
+              else
+                create_local_bundle(website, name)
+              end
+        website.logger.info { "Bundle '#{name}' of type '#{type}' created at <#{dir}>" }
+
+        true
+      end
+
+      def self.create_distribution_bundle(website, directory, bundle_name) #:nodoc:
+        bundle_dir = File.join(directory, 'lib', 'webgen', 'bundle', bundle_name)
+
+        create_directory(directory)
+        create_directory(bundle_dir)
+        create_file(File.join(directory, 'Rakefile'), 'Rakefile.erb', bundle_name)
+        create_file(File.join(directory, 'README.md'), 'README.md.erb', bundle_name)
+        create_file(File.join(bundle_dir, 'info.yaml'), 'info.yaml.erb', bundle_name)
+        create_file(File.join(bundle_dir, 'init.rb'), 'init.rb.erb', bundle_name)
+        directory
+      end
+
+      def self.create_local_bundle(website, bundle_name) #:nodoc:
+        bundle_dir =  File.join(website.directory, 'ext', bundle_name)
+
+        create_directory(bundle_dir)
+        create_file(File.join(bundle_dir, 'info.yaml'), 'info.yaml.erb', bundle_name)
+        create_file(File.join(bundle_dir, 'init.rb'), 'init.rb.erb', bundle_name)
+        bundle_dir
+      end
+
+      def self.create_directory(dir) #:nodoc:
+        raise "The directory '#{dir}' does already exist" if File.exist?(dir)
+        FileUtils.mkdir_p(dir)
+      end
+
+      def self.create_file(dest, source, bundle_name) #:nodoc:
+        File.open(dest, 'w+') do |f|
+          erb = ERB.new(File.read(File.join(Webgen::Utils.data_dir, TEMPLATE_DIR, source)))
+          f.write(erb.result(binding))
+        end
+      end
+
+    end
+
+  end
+end

data/lib/webgen/task/create_website.rb

@@ -0,0 +1,94 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/website'
+require 'webgen/task'
+require 'webgen/error'
+require 'tmpdir'
+
+module Webgen
+  class Task
+
+    #
+    # == About
+    #
+    # Creates the website.
+    #
+    # This task assumes that the website directory does not exist and populates it from a specified
+    # template. webgen extensions can provide additional website templates, see below.
+    #
+    # For each created file a verbose log message is recorded in the format used when webgen
+    # generates a website (because, actually, webgen's website generating facilities are used to
+    # create the website structure).
+    #
+    # == Creating a website template
+    #
+    # A website template is just a directory holding all the files necessary for a webgen website
+    # and therefore looks very similar to an actual webgen website directory. However, the template
+    # is not just copied but processed ('generated') by webgen itself.
+    #
+    # What this means is:
+    #
+    # * A Webgen::Website object is created for a temporary directory.
+    # * The 'destination' configuration option is set to the to-be-created website directory (ie. to
+    #   Website#directory of the current website).
+    # * The 'sources' configuration option is set to use the website template directory.
+    # * All path handlers are deactivated except Webgen::PathHandler::Copy and the latter is used
+    #   for processing all source paths.
+    #
+    # Thus one can use Erb or any other supported content processor to customize the generated
+    # files!
+    #
+    # Once a website template has been created, it needs to be registered with a template name, like
+    # this:
+    #
+    #   website.ext.task.data(:create_website)[:templates][TEMPLATE_NAME] = ABSOLUTE_DIR_PATH
+    #
+    module CreateWebsite
+
+      # This error is raised when there is a problem creating the website.
+      class Error < Webgen::Error; end
+
+      # Create the website from the given template.
+      #
+      # This actually uses webgen's file copying/generating facilities to populate the website
+      # directory. Kind of bootstrapping really.
+      #
+      # Returns +true+ if the website has been created.
+      def self.call(website, template = nil)
+        if File.exists?(website.directory)
+          raise Error.new("Directory <#{website.directory}> does already exist!")
+        end
+        if template && !website.ext.task.data(:create_website)[:templates].has_key?(template)
+          raise Error.new("Unknown template '#{template}' specified!")
+        end
+
+        begin
+          Dir.mktmpdir do |tmpdir|
+            ws = Webgen::Website.new(tmpdir) do |ws|
+              ws.config['sources'] = [['/', :file_system, File.join(Webgen::Utils.data_dir, 'basic_website_template')]]
+              if template
+                ws.config['sources'] = [(['/', :file_system, website.ext.task.data(:create_website)[:templates][template]])]
+              end
+              ws.config['destination'] = [:file_system, File.expand_path(website.directory)]
+              ws.ext.path_handler.registered_extensions.each do |name, data|
+                data.patterns = []
+              end
+              ws.ext.path_handler.registered_extensions[:copy].patterns = ['**/*', '**/']
+              ws.logger.level = ::Logger::INFO
+              ws.logger.formatter = Proc.new do |severity, timestamp, progname, msg|
+                website.logger.vinfo(msg) if msg =~ /\[create\]/
+              end
+            end
+            ws.execute_task(:generate_website)
+          end
+        rescue Webgen::Error => e
+          raise Error.new("Could not create website from template: #{e.message}")
+        end
+
+        true
+      end
+
+    end
+
+  end
+end