typo 5.0.2 → 5.0.3.98

data/app/models/category.rb

@@ -71,7 +71,7 @@ class Category < ActiveRecord::Base
   end
 
   def permalink_url(anchor=nil, only_path=true)
-    blog = Blog.find(1) # remove me...
+    blog = Blog.default # remove me...
 
     blog.url_for(
       :controller => '/categories',

data/app/models/comment.rb

@@ -17,13 +17,6 @@ class Comment < Feedback
     end
   end
 
-  def notify_user_via_jabber(user)
-    if user.notify_via_jabber?
-      JabberNotify.send_message(user, "New comment", "A new comment was posted to '#{article.title}' on #{blog.blog_name} by #{author}:
-        #{body}", self.html(:body))
-    end
-  end
-
   def interested_users
     users = User.find_boolean(:all, :notify_on_comments)
     self.notify_users = users

data/app/models/content.rb

@@ -5,8 +5,6 @@ class Content < ActiveRecord::Base
   include Observable
 
   belongs_to :text_filter
-  belongs_to :blog
-  validates_presence_of :blog_id
 
   has_many :notifications, :foreign_key => 'content_id'
   has_many :notify_users, :through => :notifications,
@@ -36,11 +34,6 @@ class Content < ActiveRecord::Base
   @@content_fields = Hash.new
   @@html_map       = Hash.new
 
-  def initialize(*args, &block)
-    super(*args, &block)
-    set_default_blog
-  end
-
   def invalidates_cache?(on_destruction = false)
     if on_destruction
       just_changed_published_status? || published?
@@ -49,12 +42,6 @@ class Content < ActiveRecord::Base
     end
   end
 
-  def set_default_blog
-    if self.blog_id.nil? || self.blog_id == 0
-      self.blog = Blog.default
-    end
-  end
-
   class << self
     # Quite a bit of this isn't needed anymore.
     def content_fields(*attribs)
@@ -113,6 +100,41 @@ class Content < ActiveRecord::Base
         find_published(what, options)
       end
     end
+    
+    def find_by_published_at(column_name = :published_at)
+      from_where = "FROM #{self.table_name} WHERE #{column_name} > 0 AND type='#{self.name}'"
+
+      # Implement adapter-specific groupings below, or allow us to fall through to the generic ruby-side grouping
+      
+      if defined?(ActiveRecord::ConnectionAdapters::MysqlAdapter) && self.connection.is_a?(ActiveRecord::ConnectionAdapters::MysqlAdapter)
+        # MySQL uses date_format
+        find_by_sql("SELECT date_format(#{column_name}, '%Y-%m') AS publication #{from_where} GROUP BY publication ORDER BY publication DESC")
+        
+      elsif defined?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter) && self.connection.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
+        # PostgreSQL uses to_char
+        find_by_sql("SELECT to_char(#{column_name}, 'YYYY-MM') AS publication #{from_where} GROUP BY publication ORDER BY publication DESC")
+        
+      else
+        # If we don't have an adapter-safe conversion from date -> YYYY-MM,
+        # we'll do the GROUP BY server-side. There won't be very many objects
+        # in this array anyway.
+        date_map = {}
+        dates = find_by_sql("SELECT #{column_name} AS publication #{from_where}")
+    
+        dates.map! do |d|
+          d.publication = Time.parse(d.publication).strftime('%Y-%m')
+          d.freeze
+          if !date_map.has_key?(d.publication)
+            date_map[d.publication] = true
+            d
+          end
+        end
+        dates.reject!{|d| d.blank? || d.publication.blank?}
+        dates.sort!{|a,b| b.publication <=> a.publication}
+        
+        dates
+      end
+    end
   end
 
   def content_fields
@@ -165,7 +187,7 @@ class Content < ActiveRecord::Base
   end
 
   # Grab the text filter for this object.  It's either the filter specified by
-  # self.text_filter_id, or the default specified in the blog object.
+  # self.text_filter_id, or the default specified in the default blog object.
   def text_filter
     if self[:text_filter_id] && !self[:text_filter_id].zero?
       TextFilter.find(self[:text_filter_id])
@@ -194,9 +216,8 @@ class Content < ActiveRecord::Base
     end
   end
 
-  # FIXME -- this feels wrong.
   def blog
-    self[:blog] ||= blog_id.to_i.zero? ? Blog.default : Blog.find(blog_id)
+    Blog.default
   end
 
   def publish!
@@ -215,7 +236,6 @@ class Content < ActiveRecord::Base
 
   def send_notification_to_user(user)
     notify_user_via_email(user)
-    notify_user_via_jabber(user)
   end
 
   def really_send_notifications
@@ -274,7 +294,9 @@ class Content < ActiveRecord::Base
   end
 
   def atom_content(xml)
-    xml.content html(:all), :type => 'html'
+    xml.content(:type => 'xhtml') do
+      xml.div(:xmlns => 'http://www.w3.org/1999/xhtml') { xml << html(:all) }
+    end
   end
 
 

data/app/models/feedback.rb

@@ -25,6 +25,14 @@ class Feedback < Content
     'created_at ASC'
   end
 
+  def to_param
+    guid
+  end
+
+  def parent
+    article
+  end
+
   def permalink_url(anchor=:ignored, only_path=true)
     article.permalink_url("#{self.class.to_s.downcase}-#{id}",only_path)
   end

data/app/models/notification_mailer.rb

@@ -21,6 +21,14 @@ class NotificationMailer < ActionMailer::Base
     @body[:trackback] = trackback
   end
 
+  def notif_user(user)
+    @body[:user] = user
+    @body[:blog] = Blog.default
+    @recipients  = user.email
+    @from        = Blog.default.email_from
+    @headers     = {'X-Mailer' => "Typo #{TYPO_VERSION}"}
+  end
+
   private
   def setup(user, content)
     @body[:user] = user
@@ -28,7 +36,6 @@ class NotificationMailer < ActionMailer::Base
     @recipients  = user.email
     @from        = content.blog.email_from
     @headers     = {'X-Mailer' => "Typo #{TYPO_VERSION}"}
-    @blog_name   = content.blog.blog_name
   end
 
 end

data/app/models/page.rb

@@ -21,6 +21,11 @@ class Page < Content
     )
   end
 
+  def self.find_by_published_at
+    super(:created_at)
+  end
+
+
   def edit_url
     blog.url_for(:controller => "/admin/pages", :action =>"edit", :id => id)
   end

data/app/models/page_cache.rb

@@ -1,28 +1,43 @@
-class PageCache < ActiveRecord::Base
+class PageCache
+  def self.logger
+    RAILS_DEFAULT_LOGGER
+  end
+
+  def logger
+    RAILS_DEFAULT_LOGGER
+  end
+
   def self.public_path
     ActionController::Base.page_cache_directory
   end
 
   def self.sweep_all
-    logger.debug "PageCache - sweep_all called"
+    logger.debug "PageCache - sweep_all called by #{caller[1].inspect}"
     unless Blog.default && Blog.default.cache_option == "caches_action_with_params"
-      self.zap_pages('index.*', 'articles', 'pages')
+      self.zap_pages(%w{index.* articles.* pages page
+                     pages.* feedback feedback.*
+                     comments comments.*
+                     category categories.* xml
+                     tag tags.* category archive.*})
+
+      self.zap_pages((1990..2020))
+      self.zap_pages([*1990..2020].collect { |y| "#{y}.*" })
     end
   end
 
   def self.sweep_theme_cache
-    logger.debug "PageCache - sweep_theme_cache called"
-    self.zap_pages('images/theme', 'stylesheets/theme', 'javascripts/theme')
+    logger.debug "PageCache - sweep_theme_cache called by #{caller[1].inspect}"
+    self.zap_pages(%{images/theme stylesheets/theme javascripts/theme})
   end
 
-  def self.zap_pages(*paths)
+  def self.zap_pages(paths)
     logger.debug "PageCache - About to zap: #{paths.inspect}"
     srcs = paths.inject([]) { |o,v|
       o + Dir.glob(public_path + "/#{v}")
     }
     return true if srcs.empty?
     logger.debug "PageCache - About to delete: #{srcs.inspect}"
-    trash = Dir::tmpdir + "/typodel.#{UUID.random_create}"
+    trash = RAILS_ROOT + "/tmp/typodel.#{UUID.random_create}"
     FileUtils.makedirs(trash)
     FileUtils.mv(srcs, trash, :force => true)
     FileUtils.rm_rf(trash)

data/app/models/profile.rb

@@ -1,3 +1,13 @@
 class Profile < ActiveRecord::Base
+  serialize :modules
   validates_uniqueness_of :label
+  
+  def modules
+    read_attribute(:modules) || []
+  end
+  
+  def modules=(perms)
+    perms = perms.collect {|p| p.to_sym unless p.blank? }.compact if perms
+    write_attribute(:modules, perms)
+  end
 end

data/app/models/right.rb

@@ -0,0 +1,4 @@
+class Right < ActiveRecord::Base
+  validates_uniqueness_of :name
+  has_and_belongs_to_many :profiles
+end

data/app/models/sidebar.rb

@@ -1,6 +1,5 @@
 class Sidebar < ActiveRecord::Base
   serialize :config
-  belongs_to :blog
 
   class Field
     attr_accessor :key
@@ -188,8 +187,16 @@ class Sidebar < ActiveRecord::Base
     end
   end
 
-  def initialize(*args, &block)
-    super(*args, &block)
+  def blog
+    Blog.default
+  end
+
+  def initialize(*args)
+    if block_given?
+      super(*args) { |instance| yield instance }
+    else
+      super(*args)
+    end
     self.class.fields.each do |field|
       unless config.has_key?(field.key)
         config[field.key] = field.default

data/app/models/tag.rb

@@ -1,7 +1,7 @@
 class Tag < ActiveRecord::Base
   has_and_belongs_to_many :articles, :order => 'created_at DESC'
   validates_uniqueness_of :name
-
+ 
   def self.get(name)
     tagname = name.tr(' ', '').downcase
     tag = find_by_name_or_display_name(tagname, name)
@@ -22,15 +22,16 @@ class Tag < ActiveRecord::Base
   end
 
   def ensure_naming_conventions
-    if self.display_name.blank?
+    if self.display_name.blank? or self.display_name != self.name
       self.display_name = self.name
     end
+    self.name = self.name.tr('.', '-')
     self.name = self.name.tr(' ', '').downcase
   end
 
   before_save :ensure_naming_conventions
 
-  def self.find_all_with_article_counters(limit = 20)
+  def self.find_all_with_article_counters(limit=20, orderby='article_counter DESC', start=0)
     # Only count published articles
     self.find_by_sql([%{
       SELECT tags.id, tags.name, tags.display_name, COUNT(articles_tags.article_id) AS article_counter
@@ -40,9 +41,13 @@ class Tag < ActiveRecord::Base
         ON articles_tags.article_id = articles.id
       WHERE articles.published = ?
       GROUP BY tags.id, tags.name, tags.display_name
-      ORDER BY article_counter DESC
-      LIMIT ?
-      },true, limit]).each{|item| item.article_counter = item.article_counter.to_i }
+      ORDER BY #{orderby} 
+      LIMIT ? OFFSET ? 
+      },true, limit, start]).each{|item| item.article_counter = item.article_counter.to_i }
+  end
+
+  def self.merge(from, to)
+    self.update_by_sql([%{UPDATE article_tags SET tag_id = #{to} WHERE tag_id = #{from} }])
   end
 
   def self.find_by_permalink(*args)
@@ -52,7 +57,13 @@ class Tag < ActiveRecord::Base
   def self.to_prefix
     'tag'
   end
-
+   
+  # Return all tags with the char or string 
+  # send by parameter
+  def self.find_with_char(char)
+    find :all, :conditions => ['name LIKE ? ', "%#{char}%"], :order => 'name ASC'
+  end
+  
   def published_articles
     articles.find_already_published
   end
@@ -62,7 +73,7 @@ class Tag < ActiveRecord::Base
   end
 
   def permalink_url(anchor=nil, only_path=true)
-    blog = Blog.find(1) # remove me...
+    blog = Blog.default # remove me...
 
     blog.url_for(
       :controller => 'tags',
@@ -82,4 +93,5 @@ class Tag < ActiveRecord::Base
   def to_param
     permalink
   end
+  
 end

data/app/models/trackback.rb

@@ -5,7 +5,7 @@ class Trackback < Feedback
   content_fields :excerpt
   validates_presence_of :title, :excerpt, :url
 
-  attr_accessible :blog_id, :url, :blog_name, :title, :excerpt, :ip, :published, :article_id
+  attr_accessible :url, :blog_name, :title, :excerpt, :ip, :published, :article_id
 
   def initialize(*args, &block)
     super(*args, &block)

data/app/models/url_policy.rb

@@ -0,0 +1,179 @@
+require 'singleton'
+
+# Helper method for hash
+class Hash
+  def prefix_keys(prefix)
+    inject({}) {|o, (k,v)|
+      returning(o) do
+        if k.respond_to?(:to_str) || k.instance_of?(Symbol)
+          o["#{prefix}_#{k}".to_sym] = v
+        else
+          o[k] = v
+        end
+      end
+    }
+  end
+
+  def coalesce_params
+    inject({}) { |o, (k, v)|
+      returning(o) do
+        if v.instance_of?(Hash)
+          o.merge!(v.prefix_keys(k.to_s.singularize))
+        else
+          o[k] = v
+        end
+      end
+    }
+  end
+end
+
+class UrlPolicy
+  class CollectionProxy
+    attr_reader :parent
+    def initialize(parent)
+      @parent = parent
+    end
+
+    def new_record?
+      false
+    end
+
+    def characteristic_hash
+      {}
+    end
+  end
+
+  include ::Singleton
+  include ::ActionController::UrlWriter
+
+  def self.default_url_options
+    @default_url_options ||=
+      begin
+        uri = URI.parse(Blog.default.base_url)
+        returning(:host => uri.host) do |opts|
+          opts.merge(:port => uri.port) unless uri.port == 80
+          opts.merge(:protocol => uri.scheme) unless uri.scheme == 'http'
+        end
+      end
+  end
+
+  def url_for_with_policy(*args)
+    options = (Hash === args.last) ? args.pop.symbolize_keys : {}
+    with_options(options.reverse_merge(:only_path => true)) do |o|
+      case args.size
+        when 0
+        o.url_for_without_policy()
+      when 2
+        o.url_for_chain(*args)
+      else
+        if  association_collection? args.first
+          return o.url_for_collection(*args)
+        end
+
+        case args.first
+        when Class
+          return o.url_for_class(*args)
+        when ActiveRecord::Base, CollectionProxy
+          return o.url_for_object(*args)
+        else
+          return o.url_for_without_policy(*args)
+        end
+      end
+    end
+  end
+
+  alias_method_chain :url_for, :policy
+
+
+  def url_for_class(klass, opts = {})
+    url_for opts.reverse_merge(:controller => klass.name.pluralize.underscore)
+  end
+
+  def url_for_object(object, opts = {})
+    suggested_params = params_for(object)
+    if opts.has_key? :controller
+      suggested_params.delete(:action)
+    end
+
+    url_for(suggested_params.merge(opts))
+  end
+
+  def association_collection?(object)
+    object.respond_to?(:proxy_reflection) && object.respond_to?(:count)
+  end
+
+  def url_for_collection(collection, opts = {})
+    owner = collection.proxy_owner;
+    controller = collection.proxy_reflection.klass.name.pluralize.underscore
+    url_for(CollectionProxy.new(owner),
+            opts.merge(:controller => controller))
+  end
+
+  def url_for_chain(parent, klass, opts = { })
+    url_for(CollectionProxy.new(parent),
+            opts.merge(:controller => klass.name.pluralize.underscore))
+  end
+
+  def params_for(object)
+    resource_params(object).coalesce_params.reverse_merge(default_controller_and_action_for(object))
+  end
+
+  def coalesce_params(params_hash)
+    params_hash.coalesce_params
+  end
+
+  def default_controller_and_action_for(object)
+    { :controller => object.class.name.pluralize.underscore,
+      :action => object.new_record? ? :new : :show }
+  end
+
+  def edit_url_for(object, opts = {})
+    with_options(opts) { |o|
+      url_for(params_for(object).merge(:action => object.new_record? ? :new : :edit))
+    }
+  end
+
+  def characteristic_hash(resource)
+    raise ArgumentErrror, "#{resource}.new_record? must not be true" if resource.new_record?
+
+    if resource.respond_to? :characteristic_hash
+      return resource.characteristic_hash
+    end
+
+    class_specific_method_name = "characteristic_#{resource.class.name.underscore}_hash"
+    if self.respond_to?(class_specific_method_name)
+      self.send(class_specific_method_name, resource)
+    else
+      return { :id => resource.to_param }
+    end
+  end
+
+  def characteristic_article_hash(article)
+    date = article.published_at
+    return { :year   => date.year,
+      :month  => '%02i' % date.month,
+      :day    => '%02i' % date.day,
+      :id     => article.permalink }
+  end
+
+  def resource_params(resource)
+    returning(ancestors_hash(resource)) do |params|
+      unless resource.new_record?
+        params.merge! characteristic_hash(resource)
+      end
+    end
+  end
+
+  alias_method :article_params, :resource_params
+  alias_method :feedback_params, :resource_params
+
+  def ancestors_hash(resource, collector = {})
+    returning(collector) do |ret|
+      if resource.respond_to?(:parent)
+        collector[resource.parent.class.name.downcase.underscore] =
+          characteristic_hash(resource.parent)
+        ancestors_hash(resource.parent, collector)
+      end
+    end
+  end
+end