typo 4.1.1 → 5.0

data/app/helpers/authors_helper.rb

@@ -0,0 +1,5 @@
+module AuthorsHelper
+  def title_for_grouping(author)
+    "#{pluralize(author.published_articles.size, 'post')} with author #{author.display_name}"
+  end
+end

data/app/helpers/categories_helper.rb

@@ -0,0 +1,5 @@
+module CategoriesHelper
+  def ul_tag_for(_)
+    %{<ul class="categorylist">}
+  end
+end

data/app/helpers/comments_helper.rb

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

data/app/helpers/content_helper.rb

@@ -1,3 +1,93 @@
 require 'digest/sha1'
 module ContentHelper
+  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
+    when grouping_class == Tag
+      %{<ul id="taglist" class="tags">}
+    when grouping_class == Category
+      %{<ul class="categorylist">}
+    else
+      '<ul>'
+    end
+  end
+
+  def page_title
+    blog_name = this_blog.blog_name || "Typo"
+    if @page_title
+      # this is where the page title prefix (string) should go
+      (this_blog.title_prefix == 1 ? blog_name + " : " : '') + @page_title + (this_blog.title_prefix == 2 ? " : " + blog_name : '')
+    else
+      blog_name
+    end
+  end
+
+  include SidebarHelper
+
+  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 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.map { |c| link_to h(c.name), category_url(c), :rel => 'tag'}.join(", ")
+  end
+
+  def tag_links(article)
+    "Tags " + article.tags.map { |tag| link_to tag.display_name, tag.permalink_url, :rel => "tag"}.sort.join(", ")
+  end
+
+  def next_link(article)
+    n = article.next
+    return  n ? n.link_to_permalink("#{n.title} &raquo;") : ''
+  end
+
+  def prev_link(article)
+    p = article.previous
+    return p ? n.link_to_permalink("&laquo; #{p.title}") : ''
+  end
+
+  def render_to_string(*args, &block)
+    controller.send(:render_to_string, *args, &block)
+  end
 end

data/app/helpers/groupings_helper.rb

@@ -0,0 +1,5 @@
+module GroupingsHelper
+  def ul_tag_for(_)
+    '<ul>'
+  end
+end

data/app/helpers/tags_helper.rb

@@ -0,0 +1,5 @@
+module TagsHelper
+  def ul_tag_for(_)
+    %{<ul id="taglist" class="tags"}
+  end
+end

data/app/helpers/theme_helper.rb

@@ -5,19 +5,19 @@ module ThemeHelper
   # 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 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
+#   def full_template_path(template_path, extension)
+#     search_paths.each do |path|
+#       themed_path = File.join(view_paths.first, 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/models/article.rb

@@ -8,40 +8,96 @@ class Article < Content
 
   has_many :pings,      :dependent => :destroy, :order => "created_at ASC"
   has_many :comments,   :dependent => :destroy, :order => "created_at ASC"
+  with_options(:conditions => { :published => true }, :order => 'created_at DESC') do |this|
+    this.has_many :published_comments,   :class_name => "Comment", :order => "created_at ASC"
+    this.has_many :published_trackbacks, :class_name => "Trackback", :order => "created_at ASC"
+    this.has_many :published_feedback,   :class_name => "Feedback", :order => "created_at ASC"
+  end
   has_many :trackbacks, :dependent => :destroy, :order => "created_at ASC"
+  has_many :feedback,                           :order => "created_at DESC"
   has_many :resources, :order => "created_at DESC",
            :class_name => "Resource", :foreign_key => 'article_id'
+  
   has_many :categorizations
-  has_many :categories, :through => :categorizations, :uniq => true do
-    def push_with_attributes(cat, join_attrs = { :is_primary => false })
-      Categorization.with_scope(:create => join_attrs) { self << cat }
-    end
-  end
+  has_many :categories, \
+    :through => :categorizations, \
+    :uniq => true, \
+    :order => 'categorizations.is_primary DESC, categories.position'
+  
   has_and_belongs_to_many :tags, :foreign_key => 'article_id'
   belongs_to :user
   has_many :triggers, :as => :pending_item
 
+  after_save :post_trigger
   after_destroy :fix_resources
 
+  has_state(:state,
+            :valid_states  => [:new, :draft,
+                               :publication_pending, :just_published, :published,
+                               :just_withdrawn, :withdrawn],
+            :initial_state =>  :new,
+            :handles       => [:withdraw,
+                               :post_trigger,
+                               :after_save, :send_pings, :send_notifications,
+                               :published_at=, :just_published?])
+
+
+  include States
+
   def stripped_title
-    self.title.gsub(/<[^>]*>/,'').to_url
+    str = String.new(self.title)
+    
+    accents = { ['á','à','â','ä','ã','Ã','Ä','Â','À'] => 'a',
+      ['é','è','ê','ë','Ë','É','È','Ê'] => 'e',
+      ['í','ì','î','ï','I','Î','Ì'] => 'i',
+      ['ó','ò','ô','ö','õ','Õ','Ö','Ô','Ò'] => 'o',
+      ['œ'] => 'oe',
+      ['ß'] => 'ss',
+      ['ú','ù','û','ü','U','Û','Ù'] => 'u',
+      ['ç','Ç'] => 'c'
+      }
+    accents.each do |ac,rep|
+      ac.each do |s|
+        str.gsub!(s, rep)
+      end
+    end
+    
+    str.gsub(/<[^>]*>/,'').to_url
+  end
+  
+  def permalink_url_options(nesting = false)
+    {:year => published_at.year,
+     :month => sprintf("%.2d", published_at.month),
+     :day => sprintf("%.2d", published_at.day),
+     :controller => 'articles',
+     :action => 'show',
+     (nesting ? :article_id : :id) => permalink}
   end
 
   def permalink_url(anchor=nil, only_path=true)
     @cached_permalink_url ||= {}
-    @cached_permalink_url["#{anchor}#{only_path}"] ||= blog.url_for(
-      :year => published_at.year,
-      :month => sprintf("%.2d", published_at.month),
-      :day => sprintf("%.2d", published_at.day),
-      :title => permalink,
-      :anchor => anchor,
-      :only_path => only_path,
-      :controller => '/articles'
-    )
+    @cached_permalink_url["#{anchor}#{only_path}"] ||= \
+      blog.with_options(permalink_url_options) do |b|
+        b.url_for(:anchor => anchor, :only_path => only_path)
+      end
+  end
+
+  def param_array
+    @param_array ||=
+      returning([published_at.year, sprintf('%.2d', published_at.month),
+                 sprintf('%.2d', published_at.day), permalink]) do |params|
+      this = self
+      k = class << params; self; end
+      k.send(:define_method, :to_s) { params[-1] }
+    end
+  end
+
+  def to_param
+    param_array
   end
 
   def trackback_url
-    blog.url_for(:controller => "articles", :action =>"trackback", :id => id)
+    blog.url_for(permalink_url_options(true).merge(:controller => 'trackbacks', :action => 'index'))
   end
 
   def feed_url(format = :rss20)
@@ -96,10 +152,6 @@ class Article < Content
     end
   end
 
-  def send_pings
-    state.send_pings(self)
-  end
-
   def next
     blog.articles.find(:first, :conditions => ['published_at > ?', published_at],
                        :order => 'published_at asc')
@@ -112,16 +164,24 @@ class Article < Content
 
   # Count articles on a certain date
   def self.count_by_date(year, month = nil, day = nil, limit = nil)
-    from, to = self.time_delta(year, month, day)
-    Article.count(["published_at BETWEEN ? AND ? AND published = ?",
-                   from, to, true])
+    if !year.blank?
+      from, to = self.time_delta(year, month, day)
+      Article.count(["published_at BETWEEN ? AND ? AND published = ?",
+                     from, to, true])
+    else
+      Article.count(:conditions => { :published => true })
+    end
   end
 
   # Find all articles on a certain date
   def self.find_all_by_date(year, month = nil, day = nil)
-    from, to = self.time_delta(year, month, day)
-    Article.find_published(:all, :conditions => ["published_at BETWEEN ? AND ?",
-                                                 from, to])
+    if !year.blank?
+      from, to = self.time_delta(year, month, day)
+      Article.find_published(:all, :conditions => ["published_at BETWEEN ? AND ?",
+                                                   from, to])
+    else
+      Article.find_published(:all)
+    end
   end
 
   # Find one article on a certain date
@@ -130,13 +190,40 @@ class Article < Content
     find_all_by_date(year, month, day).first
   end
 
+  def self.date_from(params_hash)
+    params_hash[:article_year] \
+      ? params_hash.values_at(:article_year, :article_month, :article_day, :article_id) \
+      : params_hash.values_at(:year, :month, :day, :id)
+  end
+
   # Finds one article which was posted on a certain date and matches the supplied dashed-title
-  def self.find_by_permalink(year, month, day, title)
+  def self.find_by_permalink(year, month=nil, day=nil, title=nil)
+    unless month
+      case year
+      when Hash
+        year, month, day, title = date_from(year)
+      when Array
+        year, month, day, title = year
+      end
+    end
     from, to = self.time_delta(year, month, day)
-    find_published(:first,
-                   :conditions => ['permalink = ? AND ' +
-                                   'published_at BETWEEN ? AND ?',
-                                   title, from, to ])
+    returning(find_published(:first,
+                             :conditions => ['permalink = ? AND ' +
+                                             'published_at BETWEEN ? AND ?',
+                                             title, from, to ])) do |res|
+      if res.nil?
+        raise ActiveRecord::RecordNotFound
+      end
+    end
+  end
+
+  def self.find_by_params_hash(params = {})
+    params[:id] ||= params[:article_id]
+    if params[:id]
+      find_by_permalink(params)
+    else
+      find_by_date(*date_from(params))
+    end
   end
 
   # Fulltext searches the body of published articles
@@ -173,36 +260,51 @@ class Article < Content
 
   def notify_user_via_jabber(user)
     if user.notify_via_jabber?
-      JabberNotify.send_message(user, "New post",
-                                "A new message was posted to #{blog.blog_name}",
+      JabberNotify.send_message(user, _("New post"),
+                                _("A new message was posted to ") +  blog.blog_name,
                                 html(:body))
     end
   end
 
   def comments_closed?
-    if self.allow_comments?
-      if !self.blog.sp_article_auto_close.zero? and self.created_at.to_i < self.blog.sp_article_auto_close.days.ago.to_i
-        return true
-      else
-        return false
-      end
-    else
-      return true
-    end
+    !(allow_comments? && in_feedback_window?)
   end
 
-  def published_comments
-    comments.select {|c| c.published?}
+  def in_feedback_window?
+    self.blog.sp_article_auto_close.zero? ||
+      self.created_at.to_i > self.blog.sp_article_auto_close.days.ago.to_i
   end
 
-  def published_trackbacks
-    trackbacks.select {|c| c.published?}
+  def cast_to_boolean(value)
+    ActiveRecord::ConnectionAdapters::Column.value_to_boolean(value)
+  end
+  # Cast the input value for published= before passing it to the state.
+  def published=(newval)
+    state.published = cast_to_boolean(newval)
   end
 
   # Bloody rails reloading. Nasty workaround.
+  def allow_comments=(newval)
+    returning(cast_to_boolean(newval)) do |val|
+      if self[:allow_comments] != val
+        changed if published?
+        self[:allow_comments] = val
+      end
+    end
+  end
+
+  def allow_pings=(newval)
+    returning(cast_to_boolean(newval)) do |val|
+      if self[:allow_pings] != val
+        changed if published?
+        self[:allow_pings] = val
+      end
+    end
+  end
+
   def body=(newval)
     if self[:body] != newval
-      changed
+      changed if published?
       self[:body] = newval
     end
     self[:body]
@@ -215,7 +317,7 @@ class Article < Content
 
   def extended=(newval)
     if self[:extended] != newval
-      changed
+      changed if published?
       self[:extended] = newval
     end
     self[:extended]
@@ -239,6 +341,82 @@ class Article < Content
     [:body, :extended]
   end
 
+  ## Feed Stuff
+  def rss_trackback(xml)
+    return unless allow_pings?
+    xml.trackback :ping, trackback_url
+  end
+
+  def rss_enclosure(xml)
+    return if resources.empty?
+    res = resources.first
+    xml.enclosure(:url    => blog.file_url(res.filename),
+                  :length => res.size,
+                  :type   => res.mime)
+  end
+
+  def rss_groupings(xml)
+    categories.each { |v| v.to_rss(xml) }
+    tags.each       { |v| v.to_rss(xml) }
+  end
+
+  def rss_author(xml)
+    if link_to_author?
+      xml.author("#{user.email} (#{user.name})")
+    end
+  end
+
+  def rss_comments(xml)
+    xml.comments(permalink_url + "#comments")
+  end
+
+  def link_to_author?
+    !user.email.blank? && blog.link_to_author
+  end
+
+  def rss_title(xml)
+    xml.title title
+  end
+
+  def atom_author(xml)
+    xml.author { xml.name user.name }
+  end
+
+  def atom_title(xml)
+    xml.title title, "type" => "html"
+  end
+
+  def atom_groupings(xml)
+    categories.each {|v| v.to_atom(xml) }
+    tags.each { |v| v.to_atom(xml) }
+  end
+
+  def atom_enclosures(xml)
+    resources.each do |value|
+      xml.with_options(value.size > 0 ? { :length => value.size } : { }) do |xm|
+        xm.link "rel" => "enclosure",
+        :type => value.mime,
+        :title => title,
+        :href => blog.file_url(value.filename)
+      end
+    end
+  end
+
+  def atom_content(xml)
+    xml.summary html(:body), "type" => "html"
+    if blog.show_extended_on_rss
+      xml.content html(:all), "type" => "html"
+    end
+  end
+
+  def add_comment(params)
+    comments.build(params)
+  end
+  
+  def add_category(category, is_primary = false)
+    self.categorizations.build(:category => category, :is_primary => is_primary)
+  end
+
   protected
 
   before_create :set_defaults, :create_guid
@@ -283,10 +461,6 @@ class Article < Content
     return [from, to]
   end
 
-  def find_published(what = :all, options = {})
-    super(what, options)
-  end
-
   validates_uniqueness_of :guid
   validates_presence_of :title