typo 3.99.0

data/app/models/content_state/factory.rb

@@ -0,0 +1,16 @@
+module ContentState
+  class Factory
+    def self.derived_from(content)
+      state = [New, Draft, PublicationPending,
+               JustPublished, Published].detect(self) do |k|
+        k.derivable_from(content)
+      end.instance
+
+      unless state
+        raise "No derivable state for #{content.inspect}"
+      else
+        return state
+      end
+    end
+  end
+end

data/app/models/content_state/just_published.rb

@@ -0,0 +1,47 @@
+module ContentState
+  class JustPublished < Published
+    include Reloadable
+    include Singleton
+
+    class << self
+      def derivable_from(content)
+        content.new_record? &&
+          content.published &&
+          content[:published_at].nil?
+      end
+    end
+
+    def just_published?
+      true
+    end
+
+
+    def serialize_on(content)
+      content[:published] = true
+      content[:published_at] ||= Time.now
+      true
+    end
+
+    def set_published_at(content, new_time)
+      content[:published_at] = new_time
+      return if content[:published_at].nil?
+      if content.published_at > Time.now
+        content.state = PublicationPending.instance
+      end
+    end
+
+    def after_save(content)
+      content.state = Published.instance
+    end
+
+    def send_notifications(content, controller)
+      content.interested_users.each do |user|
+        content.send_notification_to_user(controller, user)
+      end
+    end
+
+    def send_pings(content)
+      content.really_send_pings
+    end
+  end
+end

data/app/models/content_state/new.rb

@@ -0,0 +1,45 @@
+module ContentState
+  class New < Base
+    include Reloadable
+    include Singleton
+    class << self
+      def derivable_from(content)
+        content.new_record? &&
+          !content.published &&
+          content.published_at.nil?
+      end
+    end
+
+    def serialize_on(content)
+      content[:published] = false
+      content[:published_at] = nil
+      true
+    end
+
+    def before_save(content)
+      super
+      content.state = Draft.instance
+    end
+
+    def change_published_state(content, boolean)
+      content[:published] = boolean
+      if content.published
+        content.state = JustPublished.instance
+      end
+    end
+
+    def set_published_at(content, new_time)
+      content[:published_at] = new_time
+      return if new_time.nil?
+      if new_time <= Time.now
+        content.state = JustPublished.instance
+      else
+        content.state = PublicationPending.instance
+      end
+    end
+
+    def draft?
+      true
+    end
+  end
+end

data/app/models/content_state/publication_pending.rb

@@ -0,0 +1,43 @@
+module ContentState
+  class PublicationPending < Base
+    include Reloadable
+    include Singleton
+    class << self
+      def derivable_from(content)
+        !content.published && content.published_at ||
+          content.new_record? && content.published_at &&
+          content.published_at > Time.now
+      end
+    end
+
+    def serialize_on(content)
+      content[:published] = false if content.new_record?
+      true
+    end
+
+    def change_published_state(content, boolean)
+      content[:published] = boolean
+      if content.published && content.published_at <= Time.now
+        content.state = JustPublished.instance
+      end
+    end
+
+    def set_published_at(content, new_time)
+      content[:published_at] = new_time
+      Trigger.remove(content, :trigger_method => 'publish!')
+      if new_time.nil?
+        content.state = Draft.instance
+      elsif new_time <= Time.now
+        content.state = JustPublished.instance
+      end
+    end
+
+    def publication_pending?
+      true
+    end
+
+    def post_trigger(content)
+      Trigger.post_action(content.published_at, content, 'publish!')
+    end
+  end
+end

data/app/models/content_state/published.rb

@@ -0,0 +1,35 @@
+module ContentState
+  class Published < Base
+    include Reloadable
+    include Singleton
+    class << self
+      def derivable_from(content)
+        !content.new_record? && content.published
+      end
+    end
+
+    def serialize_on(content)
+      true
+    end
+
+    def published?
+      true
+    end
+
+    def change_published_state(content, boolean)
+      content[:published] = boolean
+      if ! content.published
+        content[:published_at] = nil
+        content.state = Draft.instance
+      end
+    end
+
+    def set_published_at(content, new_time)
+      content[:published_at] = new_time
+      return if content.published_at.nil?
+      if content.published_at > Time.now
+        content.state = JustPublished.instance
+      end
+    end
+  end
+end

data/app/models/email_notifier.rb

@@ -0,0 +1,9 @@
+class EmailNotifier < ActiveRecord::Observer
+  observe Article, Comment
+
+  def after_save(content)
+    return true unless content.just_published?
+    content.send_notifications
+    true
+  end
+end

data/app/models/notification_mailer.rb

@@ -0,0 +1,34 @@
+class NotificationMailer < ActionMailer::Base
+  helper :mail
+
+  def article(controller, article, user)
+    setup(controller, user, article)
+    @subject        = "[#{article.blog.blog_name}] New article: #{article.title}"
+    @body[:article] = article
+  end
+
+  def comment(controller, comment, user)
+    setup(controller, 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)
+    @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)
+    @body[:user] = user
+    @body[:controller] = controller
+    @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

@@ -0,0 +1,20 @@
+class Page < Content
+  belongs_to :user
+  validates_presence_of :name, :title, :body
+  validates_uniqueness_of :name
+
+  content_fields :body
+
+  def self.default_order
+    'name ASC'
+  end
+
+  def location(anchor=nil, only_path=true)
+    blog.url_for(:only_path => only_path, :action => 'view_page',
+                 :name => name, :anchor => anchor)
+  end
+
+  protected
+
+  def default_text_filter_config_key; 'text_filter'; end
+end

data/app/models/page_cache.rb

@@ -0,0 +1,29 @@
+class PageCache < ActiveRecord::Base
+  cattr_accessor :public_path
+  @@public_path = ActionController::Base.page_cache_directory
+
+  def self.sweep(pattern)
+    destroy_all("name like '#{pattern}'")
+  end
+
+  def self.sweep_all
+    destroy_all
+  end
+
+  private
+
+  after_destroy :expire_cache
+
+  def expire_cache
+    # It'd be better to call expire_page here, except it's a
+    # controller method and we can't get to it.
+    path = PageCache.public_path + "/#{self.name}"
+
+    logger.info "Sweeping #{self.name}"
+    delete_file(path)
+  end
+
+  def delete_file(path)
+    File.delete(path) if File.file?(path)
+  end
+end

data/app/models/ping.rb

@@ -0,0 +1,129 @@
+require 'rexml/document'
+
+class Ping < ActiveRecord::Base
+  belongs_to :article
+
+  class Pinger
+    def send_pingback_or_trackback
+      begin
+        @response = Net::HTTP.get_response(URI.parse(ping.url))
+        send_pingback or send_trackback
+      rescue Timeout::Error => err
+        return
+      rescue => err
+        raise err
+        # Ignore
+      end
+    end
+
+    def pingback_url
+      if @response["X-Pingback"]
+        @response["X-Pingback"]
+      elsif
+        response.body =~ /<link rel="pingback" href="([^"]+)" ?\/?>/
+        $1
+      else
+        nil
+      end
+    end
+
+    def origin_url
+      @origin_url
+    end
+
+    def response
+      @response
+    end
+
+    def ping
+      @ping
+    end
+
+    def article
+      ping.article
+    end
+
+    def config
+      ping.config
+    end
+
+    def send_xml_rpc(*args)
+      ping.send(:send_xml_rpc, *args)
+    end
+
+    def trackback_url
+      rdfs = response.body.scan(/<rdf:RDF.*?<\/rdf:RDF>/m)
+      rdfs.each do |rdf|
+        xml = REXML::Document.new(rdf)
+        xml.elements.each("//rdf:Description") do |desc|
+          if rdfs.size == 1 || desc.attributes["dc:identifier"] == ping.url
+            return desc.attributes["trackback:ping"]
+          end
+        end
+      end
+      # Didn't find a trackback url, so fall back to the url itself.
+      @ping.url
+    end
+
+    def send_pingback
+      if pingback_url
+        send_xml_rpc(pingback_url, "pingback.ping", origin_url, ping.url)
+        return true
+      else
+        return false
+      end
+    end
+
+    def send_trackback
+      ping.send_trackback(trackback_url, origin_url)
+    end
+
+    private
+
+    def initialize(origin_url, ping)
+      @origin_url = origin_url
+      @ping       = ping
+    end
+  end
+
+  def send_pingback_or_trackback(origin_url)
+    Pinger.new(origin_url, self).send_pingback_or_trackback
+  end
+
+  def send_trackback(trackback_url, origin_url)
+    trackback_uri = URI.parse(trackback_url)
+
+    post = "title=#{URI.escape(article.title)}"
+    post << "&excerpt=#{URI.escape(article.body_html.strip_html[0..254])}"
+    post << "&url=#{origin_url}"
+    post << "&blog_name=#{URI.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
+  end
+
+
+
+  def send_weblogupdatesping(server_url, origin_url)
+    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)
+    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
+      logger.error(e)
+    end
+  end
+end

data/app/models/redirect.rb

@@ -0,0 +1,3 @@
+class Redirect < ActiveRecord::Base
+  validates_uniqueness_of :from_path
+end

data/app/models/resource.rb

@@ -0,0 +1,76 @@
+class Resource < ActiveRecord::Base
+  validates_uniqueness_of :filename
+  after_destroy :delete_filename_on_disk
+  before_validation_on_create :uniq_filename_on_disk
+  belongs_to :article
+
+  #Reads YAML file from config dir (iTunes.yml) for easy updating
+  def get_itunes_categories
+      itunes_categories_raw = YAML::load( File.open( "#{RAILS_ROOT}/config/iTunes.yml" ) )
+      itunes_categories = []
+      itunes_categories_raw.keys.sort.each do |cat|
+        itunes_categories.push cat => itunes_categories_raw[cat]
+      end
+      return itunes_categories
+  end
+
+  def validate_on_update
+    if itunes_explicit?
+      errors.add_to_base("You must check the box to activate metadata.") unless itunes_metadata?
+      errors.add_to_base("You must specify an author.") if itunes_author.blank?
+      errors.add_to_base("You must specify an subtitle.") if itunes_subtitle.blank?
+      errors.add_to_base("You must specify a summary.") if itunes_summary.blank?
+      errors.add_to_base("You must specify keywords.") if itunes_keywords.blank?
+      if !itunes_duration.blank?
+        errors.add_to_base("You must specify duration in a HH:MM:SS format.") unless itunes_duration =~ /^(\d{0,2}:)?\d{1,2}:?\d{2}$/
+      end
+      if !itunes_category.nil?
+        errors.add_to_base("You can only specify one parent category, but you can choose multiple sub categories.") if itunes_category.length > 1
+      end
+    end
+  end
+  def fullpath(file = nil)
+    "#{RAILS_ROOT}/public/files/#{file.nil? ? filename : file}"
+  end
+
+  def write_to_disk(up)
+    begin
+      # create the public/files dir if it doesn't exist
+      FileUtils.mkdir(fullpath('')) unless File.directory?(fullpath(''))
+      if up.kind_of?(Tempfile) and !up.local_path.nil? and File.exist?(up.local_path)
+        File.chmod(0600, up.local_path)
+        FileUtils.copy(up.local_path, fullpath)
+      else
+        bytes = up
+        if up.kind_of?(StringIO)
+          up.rewind
+          bytes = up.read
+        end
+        File.open(fullpath, "wb") { |f| f.write(bytes) }
+      end
+      File.chmod(0644, fullpath)
+      self.size = File.stat(fullpath).size rescue 0
+      update
+      self
+    rescue
+      raise
+    end
+  end
+
+
+  protected
+  def uniq_filename_on_disk
+    i = 0
+    raise if filename.empty?
+    tmpfile = File.basename(filename.gsub(/\\/, '/')).gsub(/[^\w\.\-]/,'_')
+    filename = tmpfile
+    while File.exists?(fullpath(tmpfile))
+      i += 1
+      tmpfile = filename.sub(/^(.*?)(\.[^\.]+)?$/, '\1'+"#{i}"+'\2')
+    end
+    self.filename = tmpfile
+  end
+  def delete_filename_on_disk
+    File.unlink(fullpath(filename)) if File.exist?(fullpath(filename))
+  end
+end