typo 4.0.3 → 4.1

data/app/models/notification.rb

@@ -0,0 +1,4 @@
+class Notification < ActiveRecord::Base
+  belongs_to :notify_content, :class_name => 'Content', :foreign_key => 'content_id'
+  belongs_to :notify_user, :class_name => 'User', :foreign_key => 'user_id'
+end

data/app/models/notification_mailer.rb

@@ -1,30 +1,30 @@
 class NotificationMailer < ActionMailer::Base
   helper :mail
-
-  def article(controller, article, user)
-    setup(controller, user, article)
+  
+  def article(article, user)
+    setup(user, article)
     @subject        = "[#{article.blog.blog_name}] New article: #{article.title}"
     @body[:article] = article
   end
 
-  def comment(controller, comment, user)
-    setup(controller, user, comment)
+  def comment(comment, user)
+    setup(user, comment)
     @subject        = "[#{comment.blog.blog_name}] New comment on #{comment.article.title}"
     @body[:article] = comment.article
     @body[:comment] = comment
   end
 
   def trackback(sent_at = Time.now)
-    setup(controller, user, trackback)
+    setup(user, trackback)
     @subject          = "[#{trackback.blog.blog_name}] New trackback on #{trackback.article.title}"
     @body[:article]   = trackback.article
     @body[:trackback] = trackback
   end
 
   private
-  def setup(controller, user, content)
+  def setup(user, content)
     @body[:user] = user
-    @body[:controller] = controller
+    @body[:blog] = content.blog
     @recipients  = user.email
     @from        = content.blog.email_from
     @headers     = {'X-Mailer' => "Typo #{TYPO_VERSION}"}

data/app/models/page.rb

@@ -10,11 +10,25 @@ class Page < Content
   end
 
   def location(anchor=nil, only_path=true)
-    blog.url_for(:only_path => only_path, :action => 'view_page',
-                 :name => name, :anchor => anchor)
+    typo_deprecated "Use permalink_url"
+    permalink_url(anchor, only_path)
+  end
+  
+  def permalink_url(anchor=nil, only_path=true)
+    blog.url_for(
+      :controller => '/articles',
+      :action => 'view_page',
+      :name => name, 
+      :anchor => anchor,
+      :only_path => only_path
+    )
   end
 
-  protected
-
-  def default_text_filter_config_key; 'text_filter'; end
+  def edit_url
+    blog.url_for(:controller => "/admin/pages", :action =>"edit", :id => id)
+  end
+  
+  def delete_url
+    blog.url_for(:controller => "/admin/pages", :action =>"destroy", :id => id)
+  end
 end

data/app/models/ping.rb

@@ -4,6 +4,9 @@ class Ping < ActiveRecord::Base
   belongs_to :article
 
   class Pinger
+    attr_accessor :article
+    attr_accessor :blog
+
     def send_pingback_or_trackback
       begin
         @response = Net::HTTP.get_response(URI.parse(ping.url))
@@ -39,14 +42,6 @@ class Ping < ActiveRecord::Base
       @ping
     end
 
-    def article
-      ping.article
-    end
-
-    def config
-      ping.config
-    end
-
     def send_xml_rpc(*args)
       ping.send(:send_xml_rpc, *args)
     end
@@ -83,57 +78,49 @@ class Ping < ActiveRecord::Base
     def initialize(origin_url, ping)
       @origin_url = origin_url
       @ping       = ping
+      # Make sure these are fetched now for thread safety purposes.
+      self.article = ping.article
+      self.blog    = article.blog
     end
   end
 
   def send_pingback_or_trackback(origin_url)
-    t = Thread.start do
-      Pinger.new(origin_url, self).send_pingback_or_trackback
-    end
-    t.join if defined? $TESTING
+    Pinger.new(origin_url, self).send_pingback_or_trackback
   end
 
   def send_trackback(trackback_url, origin_url)
-    t = Thread.start do
-      trackback_uri = URI.parse(trackback_url)
-
-      post = "title=#{CGI.escape(article.title)}"
-      post << "&excerpt=#{CGI.escape(article.body_html.strip_html[0..254])}"
-      post << "&url=#{origin_url}"
-      post << "&blog_name=#{CGI.escape(article.blog.blog_name)}"
-
-      Net::HTTP.start(trackback_uri.host, trackback_uri.port) do |http|
-        path = trackback_uri.path
-        path += "?#{trackback_uri.query}" if trackback_uri.query
-        http.post(path, post, 'Content-type' => 'application/x-www-form-urlencoded; charset=utf-8')
-      end
+    trackback_uri = URI.parse(trackback_url)
+
+    post = "title=#{CGI.escape(article.title)}"
+    post << "&excerpt=#{CGI.escape(article.html(:body).strip_html[0..254])}"
+    post << "&url=#{origin_url}"
+    post << "&blog_name=#{CGI.escape(article.blog.blog_name)}"
+
+    Net::HTTP.start(trackback_uri.host, trackback_uri.port) do |http|
+      path = trackback_uri.path
+      path += "?#{trackback_uri.query}" if trackback_uri.query
+      http.post(path, post, 'Content-type' => 'application/x-www-form-urlencoded; charset=utf-8')
     end
-    t.join if defined? $TESTING
   end
 
   def send_weblogupdatesping(server_url, origin_url)
-    t = Thread.start do
-      send_xml_rpc(self.url, "weblogUpdates.ping", article.blog.blog_name, server_url, origin_url)
-    end
-    t.join if defined? $TESTING
+    send_xml_rpc(self.url, "weblogUpdates.ping", article.blog.blog_name,
+                 server_url, origin_url)
   end
 
   protected
 
   def send_xml_rpc(xml_rpc_url, name, *args)
-    t = Thread.start do
-      begin
-        server = XMLRPC::Client.new2(URI.parse(xml_rpc_url).to_s)
+    begin
+      server = XMLRPC::Client.new2(URI.parse(xml_rpc_url).to_s)
 
-        begin
-          result = server.call(name, *args)
-        rescue XMLRPC::FaultException => e
-          logger.error(e)
-        end
-      rescue Exception => e
+      begin
+        result = server.call(name, *args)
+      rescue XMLRPC::FaultException => e
         logger.error(e)
       end
+    rescue Exception => e
+      logger.error(e)
     end
-    t.join if defined? $TESTING
   end
 end

data/app/models/sidebar.rb

@@ -1,32 +1,262 @@
 class Sidebar < ActiveRecord::Base
-#  acts_as_list
   serialize :config
+  belongs_to :blog
 
-  def self.find_all_visible
-    find :all, :conditions => 'active_position is not null', :order => 'active_position'
+  class Field
+    attr_accessor :key
+    attr_accessor :options
+    attr_accessor :default
+    include ApplicationHelper
+    include ActionView::Helpers::TagHelper
+    include ActionView::Helpers::FormTagHelper
+    include ActionView::Helpers::FormOptionsHelper
+
+    def initialize(key, default, options = { })
+      @key, @default, @options = key.to_s, default, options
+    end
+
+    def label
+      options[:label] || key.humanize.gsub(/url/i, 'URL')
+    end
+
+    def label_html(sidebar)
+      content_tag('label', label)
+    end
+
+    def input_html(sidebar)
+      text_field_tag(input_name(sidebar), sidebar.config[key], options)
+    end
+
+    def line_html(sidebar)
+      label_html(sidebar) +  "<br />" + input_html(sidebar) + "<br />"
+    end
+
+    def input_name(sidebar)
+      "configure[#{sidebar.id}][#{key}]"
+    end
+
+    def canonicalize(value)
+      value
+    end
+
+    class SelectField < self
+      def input_html(sidebar)
+        select_tag(input_name(sidebar),
+                   options_for_select(options[:choices], sidebar.config[key]),
+                   options)
+      end
+    end
+
+    class TextAreaField < self
+      def input_html(sidebar)
+        html_options = { "rows" => "10", "cols" => "30", "style" => "width:255px"}.update(options.stringify_keys)
+        text_area_tag(input_name(sidebar), h(sidebar.config[key]), html_options)
+      end
+    end
+
+    class RadioField < self
+      def input_html(sidebar)
+        options[:choices].collect do |choice|
+          value = value_for(choice)
+          radio_button_tag(input_name(sidebar), value,
+                           value == sidebar.config[key], options) +
+            content_tag('label', label_for(choice))
+        end.join("<br />")
+      end
+
+      def label_for(choice)
+        choice.is_a?(Array) ? choice.last : choice.to_s.humanize
+      end
+
+      def value_for(choice)
+        choice.is_a?(Array) ? choice.first : choice
+      end
+    end
+
+    class CheckBoxField < self
+      def input_html(sidebar)
+        check_box_tag(input_name(sidebar), 1, sidebar.config[key], options)+
+        hidden_field_tag(input_name(sidebar),0)
+      end
+
+      def line_html(sidebar)
+        input_html(sidebar) + ' ' + label_html(sidebar) + '<br >'
+      end
+
+      def canonicalize(value)
+        case value
+        when "0"
+          false
+        else
+          true
+        end
+      end
+    end
+
+    def self.build(key, default, options)
+      field = class_for(options).new(key, default, options)
+    end
+
+    def self.class_for(options)
+      case options[:input_type]
+      when :text_area
+        TextAreaField
+      when :textarea
+        TextAreaField
+      when :radio
+        RadioField
+      when :checkbox
+        CheckBoxField
+      when :select
+        SelectField
+      else
+        if options[:choices]
+          SelectField
+        else
+          self
+        end
+      end
+    end
   end
 
-  def self.find_all_staged
-    find :all, :conditions => 'staged_position is not null', :order => 'staged_position'
+  class << self
+    attr_accessor :view_root
+
+    def find_all_visible
+      find :all, :conditions => 'active_position is not null', :order => 'active_position'
+    end
+
+    def find_all_staged
+      find :all, :conditions => 'staged_position is not null', :order => 'staged_position'
+    end
+
+    def purge
+      delete_all('active_position is null and staged_position is null')
+    end
+
+    def setting(key, default=nil, options = { })
+      return if instance_methods.include?(key.to_s)
+      fields << Field.build(key.to_s, default, options)
+      fieldmap.update(key.to_s => fields.last)
+      self.send(:define_method, key) do
+        self.config[key.to_s]
+      end
+      self.send(:define_method, "#{key}=") do |newval|
+        self.config[key.to_s] = newval
+      end
+    end
+
+    def fieldmap
+      @fieldmap ||= {}
+    end
+
+    def fields
+      @fields ||= []
+    end
+
+    def fields=(newval)
+      @fields = newval
+    end
+
+    def description(desc = nil)
+      if desc
+        @description = desc
+      else
+        @description
+      end
+    end
+
+    def lifetime(timeout = nil)
+      if timeout
+        @lifetime = timeout
+      else
+        @lifetime
+      end
+    end
+
+    def short_name
+      self.to_s.underscore.split(%r{_}).first
+    end
+
+    def display_name(new_dn = nil)
+      @display_name = new_dn if new_dn
+      @display_name || short_name.humanize
+    end
+
+    def available_sidebars
+      Sidebar.subclasses.sort_by { |klass| klass.to_s }
+    end
   end
 
-  def self.purge
-    delete_all('active_position is null and staged_position is null')
+  def initialize(*args, &block)
+    super(*args, &block)
+    self.class.fields.each do |field|
+      unless config.has_key?(field.key)
+        config[field.key] = field.default
+      end
+    end
   end
 
+
   def publish
     self.active_position=self.staged_position
   end
 
+  def config
+    self[:config] ||= { }
+  end
+
   def sidebar_controller
     @sidebar_controller ||= SidebarController.available_sidebars.find { |s| s.short_name == self.controller }
   end
 
-  def config
-    self[:config]||{}
+  def html_id
+    short_name + '-' + id.to_s
   end
 
-  def html_id
-    controller+'-'+id.to_s
+  def parse_request(contents, params)
+  end
+
+  def fields
+    self.class.fields
+  end
+
+  def fieldmap(field = nil)
+    if field
+      self.class.fieldmap[field.to_s]
+    else
+      self.class.fieldmap
+    end
+  end
+
+  def description
+    self.class.description
+  end
+
+  def short_name
+    self.class.short_name
+  end
+
+  def display_name
+    self.class.display_name
+  end
+
+  def content_partial
+    "/sidebars/#{short_name}/content"
+  end
+
+  def to_locals_hash
+    fields.inject({ :sidebar => self }) do |hash, field|
+      hash.merge(field.key => config[field.key])
+    end
+  end
+
+  def lifetime
+    self.class.lifetime
+  end
+
+  def view_root
+    self.class.view_root
   end
 end
+