typo 3.99.0

data/app/helpers/admin/users_helper.rb

@@ -0,0 +1,2 @@
+module Admin::UsersHelper
+end

data/app/helpers/application_helper.rb

@@ -0,0 +1,92 @@
+# The methods added to this helper will be available to all templates in the application.
+require 'digest/sha1'
+
+module ApplicationHelper
+  def server_url_for(options = {})
+    url_for options.update(:only_path => false)
+  end
+
+  def config_value(name)
+    this_blog[name]
+  end
+
+  def config
+    this_blog
+  end
+
+  def item_link(title, item, anchor=nil)
+    link_to title, item.location(anchor)
+  end
+
+  alias_method :article_link,     :item_link
+  alias_method :page_link,        :item_link
+  alias_method :comment_url_link, :item_link
+
+  def url_of(item, only_path=true, anchor=nil)
+    item.location(anchor, only_path)
+  end
+
+  alias_method :trackback_url, :url_of
+  alias_method :comment_url,   :url_of
+  alias_method :article_url,   :url_of
+  alias_method :page_url,      :url_of
+
+  def pluralize(size, word)
+    case size
+    when 0 then "no #{word}s"
+    when 1 then "1 #{word}"
+    else        "#{size} #{word}s"
+    end
+  end
+
+  def comments_link(article)
+    article_link(pluralize(article.comments.size, "comment"),
+                 article, 'comments')
+  end
+
+  def trackbacks_link(article)
+    article_link(pluralize(article.trackbacks.size, "trackback"),
+                 article, 'trackbacks')
+  end
+
+  def check_cache(aggregator, *args)
+    hash = "#{aggregator.to_s}_#{args.collect { |arg| Digest::SHA1.hexdigest(arg) }.join('_') }".to_sym
+    controller.cache[hash] ||= aggregator.new(*args)
+  end
+
+  def js_distance_of_time_in_words_to_now(date)
+    time = date.utc.strftime("%a, %d %b %Y %H:%M:%S GMT")
+    "<span class=\"typo_date\" title=\"#{time}\">#{time}</span>"
+  end
+
+  def meta_tag(name, value)
+    tag :meta, :name => name, :content => value unless value.blank?
+  end
+
+  def date(date)
+    "<span class=\"typo_date\">#{date.utc.strftime("%d. %b")}</span>"
+  end
+
+  def render_theme(options)
+    options[:controller]=Themes::ThemeController.active_theme_name
+    render_component(options)
+  end
+
+  def toggle_effect(domid, true_effect, true_opts, false_effect, false_opts)
+    "$('#{domid}').style.display == 'none' ? new #{false_effect}('#{domid}', {#{false_opts}}) : new #{true_effect}('#{domid}', {#{true_opts}}); return false;"
+  end
+
+  def article_html(article, what = :all)
+    article.html(@controller, what)
+  end
+
+  def comment_html(comment)
+    comment.html(@controller, :body)
+  end
+
+  def page_html(page)
+    page.html(@controller,:body)
+  end
+
+  def strip_html(text) text.strip_html end
+end

data/app/helpers/articles_helper.rb

@@ -0,0 +1,163 @@
+module ArticlesHelper
+  def admin_tools_for(model)
+    type = model.class.to_s.downcase
+    tag = []
+    tag << content_tag("div",
+      link_to_remote('nuke', {
+          :url => { :action => "nuke_#{type}", :id => model },
+          :complete => visual_effect(:puff, "#{type}-#{model.id}", :duration => 0.6),
+          :confirm => "Are you sure you want to delete this #{type}?"
+        }, :class => "admintools") <<
+      link_to('edit', {
+        :controller => "admin/#{type.pluralize}/article/#{model.article.id}",
+        :action => "edit", :id => model
+        }, :class => "admintools"),
+      :id => "admin_#{type}_#{model.id}", :style => "display: none")
+    tag.join(" | ")
+  end
+
+  def onhover_show_admin_tools(type, id = nil)
+    tag = []
+    tag << %{ onmouseover="if (getCookie('is_admin') == 'yes') { Element.show('admin_#{[type, id].compact.join('_')}'); }" }
+    tag << %{ onmouseout="Element.hide('admin_#{[type, id].compact.join('_')}');" }
+    tag
+  end
+
+  def render_errors(obj)
+    return "" unless obj
+    tag = String.new
+
+    unless obj.errors.empty?
+      tag << %{<ul class="objerrors">}
+
+      obj.errors.each_full do |message|
+        tag << "<li>#{message}</li>"
+      end
+
+      tag << "</ul>"
+    end
+
+    tag
+  end
+
+  def page_title
+    if @page_title
+      @page_title
+    else
+      this_blog.blog_name || "Typo"
+    end
+  end
+
+  def page_header
+    page_header_includes = contents.collect { |c| c.whiteboard }.collect { |w| w.select {|k,v| k =~ /^page_header_/}.collect {|(k,v)| v} }.flatten.uniq
+    (
+    <<-HTML
+<meta http-equiv="content-type" content="text/html; charset=utf-8" />
+  #{ meta_tag 'ICBM', this_blog.geourl_location unless this_blog.geourl_location.empty? }
+  <link rel="EditURI" type="application/rsd+xml" title="RSD" href="#{ server_url_for :controller => 'xml', :action => 'rsd' }" />
+  <link rel="alternate" type="application/atom+xml" title="Atom" href="#{ @auto_discovery_url_atom }" />
+  <link rel="alternate" type="application/rss+xml" title="RSS" href="#{ @auto_discovery_url_rss }" />
+  #{ javascript_include_tag "cookies" }
+  #{ javascript_include_tag "prototype" }
+  #{ javascript_include_tag "effects" }
+  #{ javascript_include_tag "typo" }
+  #{ page_header_includes.join("\n") }
+  <script type="text/javascript">#{ @content_for_script }</script>
+    HTML
+    ).chomp
+  end
+
+  def article_links(article)
+    returning code = [] do
+      code << category_links(article)   unless article.categories.empty?
+      code << tag_links(article)        unless article.tags.empty?
+      code << comments_link(article)    if article.allow_comments?
+      code << trackbacks_link(article)  if article.allow_pings?
+    end.join("&nbsp;<strong>|</strong>&nbsp;")
+  end
+
+  def category_links(article)
+    "Posted in " + article.categories.collect { |c| link_to h(c.name),
+    { :controller => "articles", :action => "category", :id => c.permalink },
+      :rel => "tag"
+    }.join(", ")
+  end
+
+  def tag_links(article)
+    "Tags " + article.tags.collect { |tag| link_to tag.display_name,
+      { :controller => "articles", :action => "tag", :id => tag.name },
+      :rel => "tag"
+    }.sort.join(", ")
+  end
+
+  def author_link(article)
+    if this_blog.link_to_author and article.user and article.user.email.to_s.size>0
+      "<a href=\"mailto:#{h article.user.email}\">#{h article.user.name}</a>"
+    elsif article.user and article.user.name.to_s.size>0
+      h article.user.name
+    else
+      h article.author
+    end
+  end
+
+  def next_link(article)
+    n = article.next
+    return  n ? article_link("#{n.title} &raquo;", n) : ''
+  end
+
+  def prev_link(article)
+    p = article.previous
+    return p ? article_link("&laquo; #{p.title}", p) : ''
+  end
+
+  def render_sidebars
+    # ugly ugly hack to fix the extremely verbose sidebar logging
+    options = { :controller => SidebarController,
+                :action => 'display_plugins',
+                :params => {:contents => contents,
+                            :request_params => params} }
+    render_component(options)
+  end
+
+  # Generate the image tag for a commenters gravatar based on their email address
+  # Valid options are described at http://www.gravatar.com/implement.php
+  def gravatar_tag(email, options={})
+    options.update(:gravatar_id => Digest::MD5.hexdigest(email.strip))
+    options[:default] = CGI::escape(options[:default]) if options.include?(:default)
+    options[:size] ||= 60
+
+    image_tag("http://www.gravatar.com/avatar.php?" <<
+      options.map { |key,value| "#{key}=#{value}" }.sort.join("&"), :class => "gravatar")
+  end
+
+  def calc_distributed_class(articles, max_articles, grp_class, min_class, max_class)
+    (grp_class.to_prefix rescue grp_class.to_s) +
+      ((max_articles == 0) ?
+           min_class.to_s :
+         (min_class + ((max_class-min_class) * articles.to_f / max_articles).to_i).to_s)
+  end
+
+  def link_to_grouping(grp)
+    link_to( grp.display_name, urlspec_for_grouping(grp),
+             :rel => "tag", :title => title_for_grouping(grp) )
+  end
+
+  def urlspec_for_grouping(grouping)
+    { :controller => "articles", :action => grouping.class.to_prefix, :id => grouping.permalink }
+  end
+
+  def title_for_grouping(grouping)
+    "#{pluralize(grouping.article_counter, 'post')} with #{grouping.class.to_s.underscore} '#{grouping.display_name}'"
+  end
+
+  def ul_tag_for(grouping_class)
+    case grouping_class
+    when Tag
+      %{<ul id="taglist" class="tags">}
+    when Category
+      %{<ul class="categorylist">}
+    else
+      '<ul>'
+    end
+  end
+end

data/app/helpers/backend_helper.rb

@@ -0,0 +1,2 @@
+module BackendHelper
+end

data/app/helpers/content_helper.rb

@@ -0,0 +1,3 @@
+require 'digest/sha1'
+module ContentHelper
+end

data/app/helpers/mail_helper.rb

@@ -0,0 +1,6 @@
+module MailHelper
+  def article_url(controller, article, only_path = true, anchor = nil)
+    controller.url_for :controller=>"/articles", :action =>"permalink", :year => article.created_at.year, :month => sprintf("%.2d", article.created_at.month), :day => sprintf("%.2d", article.created_at.day), :title => article.permalink, :anchor => anchor
+  end
+end
+

data/app/helpers/redirect_helper.rb

@@ -0,0 +1,2 @@
+module RedirectHelper
+end

data/app/helpers/sidebar_helper.rb

@@ -0,0 +1,22 @@
+module SidebarHelper
+  def render_sidebar(sidebar)
+    begin
+      # another ugly ugly hack like in articles_helper.rb
+      options = { :layout => false,
+                  :controller => sidebar.sidebar_controller,
+                  :action=>'index',
+                  :params => params.merge({:sidebar => sidebar}) }
+
+      render_component(options)
+    rescue => e
+      content_tag :p, e.message, :class => 'error'
+    end
+  end
+
+  def page_header
+    javascript_include_tag("cookies") +
+      javascript_include_tag("prototype") +
+      javascript_include_tag("effects") +
+      javascript_include_tag("type")
+  end
+end

data/app/helpers/sidebars/plugin_helper.rb

@@ -0,0 +1,2 @@
+module Sidebars::PluginHelper
+end

data/app/helpers/text_filter_plugin_helper.rb

@@ -0,0 +1,2 @@
+module TextFilterPluginHelper
+end

data/app/helpers/textfilter_helper.rb

@@ -0,0 +1,2 @@
+module TextfilterHelper
+end

data/app/helpers/theme_helper.rb

@@ -0,0 +1,23 @@
+module ThemeHelper
+
+  # NB: This overrides an undocumented rails function in order to add
+  # a search path. We need this to get themes working, but I'd be
+  # happier if we didn't have to override undocumented methods. Ho
+  # hum. -- pdcawley
+
+  def search_paths
+    ["../themes/#{this_blog.theme}/views",     # for components
+     "../../themes/#{this_blog.theme}/views",  # for normal views
+     ".",
+     "../app/views"]
+  end
+
+  def full_template_path(template_path, extension)
+    search_paths.each do |path|
+      themed_path = File.join(@base_path, path, "#{template_path}.#{extension}")
+      return themed_path if File.exist?(themed_path)
+    end
+    # Can't find a themed version, so fall back to the default behaviour
+    super
+  end
+end

data/app/helpers/xml_helper.rb

@@ -0,0 +1,21 @@
+module XmlHelper
+  def pub_date(time)
+    time.rfc822
+  end
+
+  def post_title(post)
+    h(post.title)
+  end
+
+  def item_link(item)
+    item.location(nil, false)
+  end
+
+  alias_method :post_link,      :item_link
+  alias_method :comment_link,   :item_link
+  alias_method :trackback_link, :item_link
+
+  def blog_title
+    this_blog.blog_name || "Unnamed blog"
+  end
+end

data/app/models/aggregations/audioscrobbler.rb

@@ -0,0 +1,54 @@
+require 'open-uri'
+require 'time'
+require 'rexml/document'
+
+class Audioscrobbler
+  include REXML
+
+  attr_accessor :url, :items, :link, :artist, :title
+
+  # This object holds given information of an item
+  class AudioscrobblerItem < Struct.new(:link, :artist, :title, :date)
+    def to_s; title end
+  end
+
+  # Pass the url to the RSS feed you would like to keep tabs on
+  # by default this will request the rss from the server right away and
+  # fill the items array
+  def initialize(url, refresh = true)
+	self.items  = []
+	self.url    = url
+	self.refresh if refresh
+  end
+
+  # This method lets you refresh the items in the items array
+  # useful if you keep the object cached in memory and
+  def refresh
+    open(@url) do |http|
+      parse(http.read)
+    end
+  end
+
+  private
+
+  def parse(body)
+
+    xml = Document.new(body)
+
+    self.items        = []
+    self.link         = XPath.match(xml, "//channel/link/text()").to_s
+    self.title        = XPath.match(xml, "//channel/title/text()").to_s
+
+    XPath.each(xml, "//item/") do |elem|
+
+      item = AudioscrobblerItem.new
+      item.title       = XPath.match(elem, "dc:title/text()").to_s
+      item.artist       = XPath.match(elem, "mm:Artist/dc:creator/dc:title/text()").to_s
+      item.link        = XPath.match(elem, "link/text()").to_s
+      item.date        = Time.mktime(*ParseDate.parsedate(XPath.match(elem, "dc:date/text()").to_s))
+      items << item
+    end
+
+    self.items = items.sort_by { |item| item.date }.reverse
+  end
+end

data/app/models/aggregations/backpack.rb

@@ -0,0 +1,57 @@
+require 'backpack_api'
+require 'redcloth'
+
+# Example:
+#
+# backpack = Backpack.new('<nick>', '<token>'[, '<page id>'])
+# backpack.items.each do |item|
+#   puts "#{item.title} @ #{item.link} updated at #{item.date}"
+# end
+#
+class Backpack
+  attr_accessor :username, :token, :page_id, :items, :title
+
+  # This object holds given information of an item
+  class BackpackItem < Struct.new(:completed, :id, :content)
+    def to_s
+      # Use REXML::Text#value as a workaround for entity decoding
+      RedCloth.new(REXML::Text.new(self.content).value).to_html(:textile).gsub(/^<p>|<\/p>$/, '')
+    end
+  end
+
+  # Pass the username, token, and page id for the Backpack page
+  # you wish to view the list items for.
+  # By default this will request the items right away
+  def initialize(username, token, page_id, refresh = true)
+    @items    = []
+    @username = username
+    @token    = token
+    @page_id  = page_id
+    @title    = ''
+    self.refresh if refresh
+  end
+
+  # This method lets you refresh the items in the items array
+  # useful if you keep the object cached in memory and
+  def refresh
+    bp = BackpackAPI.new(@username, @token)
+    begin
+      page = bp.show_page(@page_id)['page'].first
+    rescue
+      # Exception occurs if @page_id isn't valid
+      @items = []
+      @title = ''
+    else
+      @items = parse(page['items'].first)
+      @title = page['title']
+    end
+  end
+
+  private
+
+  def parse(result)
+    result['item'].collect do |item|
+      BackpackItem.new((item['completed'] == 'true'), item['id'], item['content'])
+    end
+  end
+end