giraffesoft-webby 0.9.5

data/lib/webby/helpers/tex_img_helper.rb

@@ -0,0 +1,133 @@
+require Webby.libpath(*%w[webby stelan mktemp])
+require 'fileutils'
+
+module Webby::Helpers
+module TexImgHelper
+
+  # The +tex2img+ method converts a a section of mathematical TeX script
+  # into an image and embeds the resulting image into the page. The TeX
+  # engine must be installed on your system along with the ImageMagick
+  # +convert+ program.
+  #
+  # Options can be passed to the TeX engine via attributes in the
+  # +tex2img+ method.
+  #
+  #    <% tex2img( "wave_eq", :path => "images", :alt => "wave equation" ) do -%>
+  #      $\psi_{tot}(x,-t_0,r) = \frac{1}{(2\pi)^2} \int\!\!\!\int
+  #      \tilde\Psi_{tot}\left(k_x,\frac{c}{2}\sqrt{k_x^2 + k_r^2},r=0\right)$
+  #    <% end -%>
+  #    
+  # The supported TeX options are the following:
+  #
+  #    :path         : where generated images will be stored
+  #                    [default is "/"]
+  #    :type         : the type of image to generate (png, jpeg, gif)
+  #                    [default is png]
+  #    :bg           : the background color of the image (color name,
+  #                    TeX color spec, or #aabbcc) [default is white]
+  #    :fg           : the foreground color of the image (color name,
+  #                    TeX color spec, or #aabbcc) [default is black]
+  #    :resolution   : the desired resolution in dpi (HxV)
+  #                    [default is 150x150]
+  #
+  #    the following options are passed as-is to the generated <img /> tag
+  #    :style    : CSS styles to apply to the <img />
+  #    :class    : CSS class to apply to the <img />
+  #    :id       : HTML identifier
+  #    :alt      : alternate text for the <img />
+  #
+  def tex2img( *args, &block )
+    opts = args.last.instance_of?(Hash) ? args.pop : {}
+    name = args.first
+    raise 'TeX graphics must have a name' if name.nil?
+
+    text = capture_erb(&block)
+    return if text.empty?
+
+    defaults = ::Webby.site.tex2img
+    path = opts.getopt(:path, defaults[:path])
+    type = opts.getopt(:type, defaults[:type])
+    bg   = opts.getopt(:bg, defaults[:bg])
+    fg   = opts.getopt(:fg, defaults[:fg])
+    res  = opts.getopt(:resolution, defaults[:resolution])
+
+    # fix color escaping
+    fg = fg =~ %r/^[a-zA-Z]+$/ ? fg : "\"#{fg}\""
+    bg = bg =~ %r/^[a-zA-Z]+$/ ? bg : "\"#{bg}\""
+
+    # generate the image filename based on the path, graph name, and type
+    # of image to generate
+    image_fn = path.nil? ? name.dup : ::File.join(path, name)
+    image_fn = ::File.join('', image_fn) << '.' << type
+
+    # generate the image using convert -- but first ensure that the
+    # path exists
+    out_dir = ::Webby.site.output_dir
+    out_file = ::File.join('..', out_dir, image_fn)
+    FileUtils.mkpath(::File.join(out_dir, path)) unless path.nil?
+
+    tex = <<-TEX
+      \\nonstopmode
+      \\documentclass{article}
+      \\usepackage[T1]{fontenc}
+      \\usepackage{amsmath,amsfonts,amssymb,wasysym,latexsym,marvosym,txfonts}
+      \\usepackage[pdftex]{color}
+      \\pagestyle{empty}
+      \\begin{document}
+      \\fontsize{12}{24}
+      \\selectfont
+      \\color{white}
+      \\pagecolor{black}
+      \\[
+      #{text}
+      \\]
+      \\end{document}
+    TEX
+    tex.gsub!(%r/\n\s+/, "\n").strip!
+
+    # make a temporarty directory to store all the TeX files
+    pwd = Dir.pwd
+    tmpdir = ::Webby::MkTemp.mktempdir('tex2img_XXXXXX')
+
+    begin
+      Dir.chdir(tmpdir)
+      File.open('out.tex', 'w') {|fd| fd.puts tex}
+      dev_null = test(?e, "/dev/null") ? "/dev/null" : "NUL:"
+
+      %x[pdflatex -interaction=batchmode out.tex &> #{dev_null}]
+
+      convert =  "\\( -density #{res} out.pdf -trim +repage \\) "
+      convert << "\\( -clone 0 -negate -background #{fg} -channel A -combine \\) "
+      convert << "\\( -clone 0 -background #{bg} -channel A -combine \\) "
+      convert << "-delete 0 -compose dst-over -composite #{out_file}"
+      %x[convert #{convert} &> #{dev_null}]
+    ensure
+      Dir.chdir(pwd)
+      FileUtils.rm_rf(tmpdir) if test(?e, tmpdir)
+    end
+
+    # generate the HTML img tag to insert back into the document
+    out = "<img src=\"#{image_fn}\""
+    %w[class style id alt].each do |atr|
+      val = opts.getopt(atr)
+      next if val.nil?
+      out << " %s=\"%s\"" % [atr, val]
+    end
+    out << " />\n"
+
+    # put some guards around the output (specifically for textile)
+    out = _guard(out)
+
+    concat_erb(out, block.binding)
+    return
+  end
+end  # module TexImgHelper
+
+if  cmd_available?(%w[pdflatex --version]) \
+and cmd_available?(%w[convert --help])
+  register(TexImgHelper)
+end
+
+end  # module Webby::Helpers
+
+# EOF

data/lib/webby/helpers/ultraviolet_helper.rb

@@ -0,0 +1,63 @@
+# This code was provided by Guillaume Carbonneau -- http://radr.ca/
+# Many thanks for his support of Webby!
+
+if try_require 'uv'
+
+module Webby::Helpers
+module UltraVioletHelper
+
+  # The +uv+ method applies syntax highlighting to source code embedded
+  # in a webpage. The UltraViolet highlighting engine is used for the HTML
+  # markup of the source code. The page sections to be highlighted are given
+  # as blocks of text to the +uv+ method.
+  #
+  # Options can be passed to the UltraViolet engine via attributes in the
+  # +uv+ method.
+  #
+  #    <% uv( :lang => "ruby", :line_numbers => true ) do -%>
+  #    # Initializer for the class.
+  #    def initialize( string )
+  #      @str = string
+  #    end
+  #    <% end -%>
+  #    
+  # The supported UltraViolet options are the following:
+  #
+  #    :lang           : the language to highlight (ruby, c, html, ...)
+  #                      [defaults to 'ruby']
+  #    :line_numbers   : true or false [defaults to false]
+  #    :theme          : see list of available themes in ultraviolet
+  #                      [defaults to 'mac_classic']
+  #
+  # The defaults can be overridden for an entire site by changing the SITE.uv
+  # options hash in the Rakefile.
+  #
+  def uv( *args, &block )
+    opts = args.last.instance_of?(Hash) ? args.pop : {}
+
+    text = capture_erb(&block)
+    return if text.empty?
+    
+    defaults = ::Webby.site.uv
+    lang = opts.getopt(:lang, defaults[:lang])
+    line_numbers = opts.getopt(:line_numbers, defaults[:line_numbers])
+    theme = opts.getopt(:theme, defaults[:theme])
+    
+    out = %Q{<div class="UltraViolet">\n}
+    out << Uv.parse(text, "xhtml", lang, line_numbers, theme)
+    out << %Q{\n</div>}
+
+    # put some guards around the output (specifically for textile)
+    out = _guard(out)
+
+    concat_erb(out, block.binding)
+    return
+  end
+end  # module UltraVioletHelper
+
+register(UltraVioletHelper)
+
+end  # module Webby::Helpers
+end  # try_require
+
+# EOF

data/lib/webby/helpers/url_helper.rb

@@ -0,0 +1,241 @@
+module Webby::Helpers
+
+#
+#
+module UrlHelper
+
+  # call-seq:
+  #    url_for( name, opts = {} ) 
+  #
+  # Creates a URL for the given _name_ and _opts_. If _name_ is a string
+  # then it is used as the URL base. If _name_ is a Resource then it is
+  # converted to a URL by calling its +url+ method.
+  #
+  # ==== Options
+  # 
+  # * <tt>:escape</tt> -- determines whether the returned URL will be HTML escaped or not (+true+ by default)
+  # * <tt>:anchor</tt> -- specifies the anchor name to be appended to the path
+  #
+  # ==== Examples
+  #
+  #    <%= url_for('/some/page.html') %>
+  #    # => /some/page
+  #
+  #    <%= url_for('/some/page.html', :anchor => 'tidbit') %>
+  #    # => /some/page#tidbit
+  #
+  #    <%= url_for(@page) %>
+  #    # => /current/page.html
+  #
+  #    <%= url_for(@page, :anchor => 'this&that') %>
+  #    # => /current/page.html#this&amp;that
+  #
+  def url_for( *args )
+    opts = Hash === args.last ? args.pop : {}
+    obj = args.first
+
+    anchor = opts.delete(:anchor)
+    escape = opts.has_key?(:escape) ? opts.delete(:escape) : true
+
+    url = Webby::Resources::Resource === obj ? obj.url : obj.to_s
+    url = escape_once(url) if escape
+    url << "#" << anchor if anchor
+
+    return url
+  end
+
+  # call-seq:
+  #    url_for_page( :key => value, :url => {} )
+  #
+  # Creates a URL for the page identified by the set of <em>:key /
+  # value</em> pairs. The <em>:url</em> options are passed to the url_for
+  # method for final URL creation; see the url_for method for
+  # documentation on those options.
+  #
+  # The Resources::DB#find method is used to locate the page; see the find
+  # method for the available options.
+  #
+  # ==== Examples
+  #
+  #    <%= url_for_page(:title => 'Funny Story', :anchor => 'punchline') %>
+  #    # => /humor/funny_story.html#punchline
+  #
+  def url_for_page( opts = {} )
+    opts = opts.symbolize_keys
+    url_opts = opts.delete(:url)
+
+    p = @pages.find(opts)
+    raise ::Webby::Error,
+          "could not find requested page: #{opts.inspect}" if p.nil?
+
+    self.url_for(p, url_opts)
+  end
+
+  # call-seq:
+  #    link_to( name, url, :attrs => {} )
+  #
+  # Create an HTTP anchor tag with 
+  #
+  # url can be a url string, a page, :back, or nothing
+  #
+  # :attrs are used to generate HTML anchor tag attributes
+  #
+  # ==== Examples
+  #
+  #    <%= link_to('Google', 'http://www.google.com/', :attrs => {:name => 'google'}) %>
+  #    # => <a href="http://www.google.com/" name="google">Google</a>
+  #
+  #    <%= link_to('A Page', @page, :anchor => 'blah') %>
+  #    # => <a href="/a/page.html#blah">A Page</a>
+  #
+  def link_to( name, *args )
+    opts = Hash === args.last ? args.pop : {}
+    obj = args.first
+    attrs = opts.delete(:attrs)
+
+    url = case obj
+      when String, Webby::Resources::Resource
+        self.url_for(obj, opts)
+      when ::Webby::Paginator::Page
+        self.url_for(obj.url, opts)
+      when :back
+        'javascript:history.back()'
+      else
+        self.url_for(name, opts)
+      end
+
+    if attrs
+      html_opts = attrs.stringify_keys
+      href = html_opts.has_key? 'href'
+      attrs = tag_options(html_opts)
+    else
+      href = false
+      attrs = nil
+    end
+
+    href_attr = href ? nil : %Q(href="#{url}")
+    "<a #{href_attr}#{attrs}>#{name || h(url)}</a>"
+  end
+
+  # call-seq:
+  #    link_to_page( name )
+  #    link_to_page( :key => value )
+  #    link_to_page( name, :key => value )
+  #    link_to_page( page )
+  #
+  # Creates a link tag of the given _name_ using a URL created by finding
+  # the associated page from the key/value pairs. If the key/value pairs are
+  # omitted, the _name_ is used in conjunction with the default site +find_by+
+  # attribute. Unless changed by the user, the default +find_by+ attribute
+  # is the page title.
+  #
+  # Pages are found using key/value pairs. The key is any of the page
+  # attributes, and the value is what that attribute should be. Any number
+  # of key/value pairs can be included, but all values must equal the
+  # corresponding page attributes for a match to be found -- i.e. the
+  # comparisons are joined by AND operations to determine a match.
+  #
+  # In the absence of any key/value pairs -- just a name was given -- then
+  # the default site +find_by+ attribute is used, and the name is compared
+  # against this attribute from the page. The default +find_by+ attribue is
+  # set in the Rakefile or in the <tt>Webby.site.find_by</tt> parameter.
+  #
+  # Several options can be passed to the method to determin how URLs are
+  # created and to specify any HTML attributes on the returned link tag. The
+  # URL options are given as a hash to the <tt>:url</tt> key. The HTML
+  # attributes are given as a hash to the <tt>:attrs</tt> key.
+  #
+  # See the +url_for+ method for a desciption of the <tt>:url</tt> options.
+  # See the +link_to+ method for a description of the <tt>:attrs</tt>
+  # options.
+  #
+  # ==== Examples
+  #
+  #    <%= link_to_page('Funny Story', :url => {:anchor => 'punchline'}) %>
+  #    # => <a href="/humor/funny_story.html#punchline">Funny Story</a>
+  #
+  #    <%= link_to_page('Hilarious', :title => 'Funny Story') %>
+  #    # => <a href="/humor/funn_story.html">Hilarious</a>
+  #
+  def link_to_page( *args )
+    self.link_to(*_find_page(args))
+  rescue ::Webby::Error => err
+    return yield if block_given?
+    raise err
+  end
+
+  # call-seq:
+  #    link_to_page_unless_current( name )
+  #    link_to_page_unless_current( :key => value )
+  #    link_to_page_unless_current( name, :key => value )
+  #    link_to_page_unless_current( page )
+  #
+  # This function operates in the same fashion as the +link_to_page+ fuction
+  # with the exception that if the page to be linked to is the current page,
+  # then only the _name_ is rendered without an HTML anchor tag.
+  #
+  # ==== Examples
+  #
+  #    <%= link_to_page_unless_current('Funny Story') %>
+  #    # => <a href="/humor/funny_story.html">Funny Story</a>
+  #
+  #    <%= link_to_page_unless_current(@page) %>
+  #    # => This Page
+  #
+  def link_to_page_unless_current( *args )
+    name, page, link_opts = _find_page(args)
+    return name if @page == page
+
+    self.link_to(name, page, link_opts)
+  rescue ::Webby::Error => err
+    return yield if block_given?
+    raise err
+  end
+
+  
+  private
+
+  # call-seq:
+  #    _find_page( name, opts = {}  )
+  #    _find_page( :key => value, [:key => value, ...], opts = {}  )
+  #    _find_page( name, :key => value, [:key => value, ...], opts = {} )
+  #    _find_page( page, opts = {} )
+  #
+  # Returns an array of the [name, page, options]. 
+  #
+  # ==== Options
+  # 
+  # * <tt>:url</tt> -- hash of options for the +url_for+ method
+  # * <tt>:attrs</tt> -- hash of options for the +link_to+ method
+  #
+  def _find_page( args )
+    raise ArgumentError, 'wrong number of arguments (0 for 1)' if args.empty?
+
+    opts = Hash === args.last ? args.pop : {}
+    name = args.first
+    link_opts = opts.delete(:url) || {}
+    link_opts[:attrs] = opts.delete(:attrs)
+
+    if Webby::Resources::Resource === name
+      p, name = name, nil
+    elsif opts.empty? && name
+      opts[Webby.site.find_by.to_sym] = name
+      p = @pages.find(opts)
+    else
+      p = @pages.find(opts)
+    end
+
+    raise ::Webby::Error,
+          "could not find requested page: #{opts.inspect}" if p.nil?
+
+    name = p.title || p.filename if name.nil?
+    return [h(name), p, link_opts]
+  end
+
+end  # module UrlHelper
+
+register(UrlHelper)
+
+end  # module Webby::Helpers
+
+# EOF

data/lib/webby/journal.rb

@@ -0,0 +1,126 @@
+
+module Webby
+
+# The Journal class is used to output simple messages regarding the creation
+# and updating of files when webby applications are run. The output messages
+# will be color coded if the terminal supports the ANSI codes.
+#
+class Journal
+
+  attr_accessor :colorize
+  attr_reader :logger
+
+  # Create a new journal
+  #
+  def initialize
+    @logger = ::Logging::Logger[self]
+    @colorize = ENV.has_key?('TERM')
+  end
+
+  # Output a message of the given _type_ using the option _color_ code. The
+  # available codes are as follows:
+  #
+  # * black
+  # * red
+  # * green
+  # * yellow
+  # * blue
+  # * magenta
+  # * cyan
+  # * white
+  #
+  # The color is specified as a string or a symbol.
+  #
+  def typed_message( type, msg, color = nil )
+    type = type.to_s.rjust(13)
+    type = self.send(color, type) unless color.nil?
+    logger.info "#{type}  #{msg.to_s}"
+  end
+
+  # Output a "create" message or an "update" message depending on whether
+  # the given _page_ already has a generated output file or not.
+  #
+  def create_or_update( page )
+    if test(?e, page.destination)
+      update(page.destination)
+    else
+      create(page.destination)
+    end
+  end
+
+  # Output a create message.
+  #
+  def create( msg )
+    typed_message('create', msg, (colorize ? :green : nil))
+  end
+
+  # Output an update message.
+  #
+  def update( msg )
+    typed_message('update', msg, (colorize ? :yellow : nil))
+  end
+
+  # Output a force message.
+  #
+  def force( msg )
+    typed_message('force', msg, (colorize ? :red : nil))
+  end
+
+  # Output a skip message.
+  #
+  def skip( msg )
+    typed_message('skip', msg, (colorize ? :yellow : nil))
+  end
+
+  # Output an exists message.
+  #
+  def exists( msg )
+    typed_message('exists', msg, (colorize ? :cyan : nil))
+  end
+
+  # Output an identical message.
+  #
+  def identical( msg )
+    typed_message('identical', msg, (colorize ? :cyan : nil))
+  end
+
+  [ [ :clear        ,   0 ],
+    [ :reset        ,   0 ],     # synonym for :clear
+    [ :bold         ,   1 ],
+    [ :dark         ,   2 ],
+    [ :italic       ,   3 ],     # not widely implemented
+    [ :underline    ,   4 ],
+    [ :underscore   ,   4 ],     # synonym for :underline
+    [ :blink        ,   5 ],
+    [ :rapid_blink  ,   6 ],     # not widely implemented
+    [ :negative     ,   7 ],     # no reverse because of String#reverse
+    [ :concealed    ,   8 ],
+    [ :strikethrough,   9 ],     # not widely implemented
+    [ :black        ,  30 ],
+    [ :red          ,  31 ],
+    [ :green        ,  32 ],
+    [ :yellow       ,  33 ],
+    [ :blue         ,  34 ],
+    [ :magenta      ,  35 ],
+    [ :cyan         ,  36 ],
+    [ :white        ,  37 ],
+    [ :on_black     ,  40 ],
+    [ :on_red       ,  41 ],
+    [ :on_green     ,  42 ],
+    [ :on_yellow    ,  43 ],
+    [ :on_blue      ,  44 ],
+    [ :on_magenta   ,  45 ],
+    [ :on_cyan      ,  46 ],
+    [ :on_white     ,  47 ] ].each do |name,code|
+
+    class_eval <<-CODE
+      def #{name.to_s}( str )
+        "\e[#{code}m\#{str}\e[0m"
+      end
+    CODE
+  end
+
+end  # class Journal
+end  # module Webby
+
+# EOF