typo 3.99.0

data/app/models/sidebar.rb

@@ -0,0 +1,32 @@
+class Sidebar < ActiveRecord::Base
+#  acts_as_list
+  serialize :config
+
+  def self.find_all_visible
+    find :all, :conditions => 'active_position is not null', :order => 'active_position'
+  end
+
+  def self.find_all_staged
+    find :all, :conditions => 'staged_position is not null', :order => 'staged_position'
+  end
+
+  def self.purge
+    delete_all('active_position is null and staged_position is null')
+  end
+
+  def publish
+    self.active_position=self.staged_position
+  end
+
+  def sidebar_controller
+    @sidebar_controller ||= SidebarController.available_sidebars.find { |s| s.short_name == self.controller }
+  end
+
+  def config
+    self[:config]||{}
+  end
+
+  def html_id
+    controller+'-'+id.to_s
+  end
+end

data/app/models/simple_cache.rb

@@ -0,0 +1,37 @@
+class SimpleCache < Hash
+
+  class Item
+    attr_reader :expiry, :value
+    def initialize(expiry, value)
+      @expiry, @value = expiry, value
+    end
+  end
+
+  def initialize(ttl)
+    @ttl = ttl
+    logger.info("  SimpleCache: will store items for #{ttl}s")
+  end
+
+  def [](key)
+    item = super(key)
+    if item.nil? or item.expiry <= Time.now
+      logger.info("  SimpleCache: miss on #{key}")
+      nil
+    else
+      logger.debug("  SimpleCache: hit on #{key}")
+      item.value
+    end
+  end
+
+  def []=(key, value)
+    logger.info("  SimpleCache: store on #{key}")
+    super(key, Item.new(@ttl.from_now, value))
+    value
+  end
+
+
+  def logger
+    @logger ||= RAILS_DEFAULT_LOGGER || Logger.new(STDOUT)
+  end
+
+end

data/app/models/tag.rb

@@ -0,0 +1,63 @@
+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)
+    if tag.nil?
+      tag = Tag.create(:name => tagname, :display_name => name)
+    end
+
+    tag
+  end
+
+  def self.find_by_name_or_display_name(tagname, name)
+    self.find(:first, :conditions => [%{name = ? OR display_name = ? OR display_name = ?}, tagname, tagname, name])
+  end
+
+  def self.find_by_name(name, *args)
+    self.send(:method_missing, :find_by_name, name, *args) ||
+      self.new(:name => name)
+  end
+
+  def ensure_naming_conventions
+    if self.display_name.blank?
+      self.display_name = self.name
+    end
+    self.name = self.name.tr(' ', '').downcase
+  end
+
+  before_save :ensure_naming_conventions
+
+  def self.find_all_with_article_counters(limit = 20)
+    # Only count published articles
+    self.find_by_sql([%{
+      SELECT tags.id, tags.name, tags.display_name, COUNT(articles_tags.article_id) AS article_counter
+      FROM #{Tag.table_name} tags LEFT OUTER JOIN #{Tag.table_name_prefix}articles_tags#{Tag.table_name_suffix} articles_tags
+        ON articles_tags.tag_id = tags.id
+      LEFT OUTER JOIN #{Tag.table_name_prefix + Article.table_name + Tag.table_name_prefix} articles
+        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 }
+  end
+
+  def self.find_by_permalink(*args)
+    self.find_by_name(*args)
+  end
+
+  def self.to_prefix
+    'tags'
+  end
+
+  def published_articles
+    articles.find_already_published
+  end
+
+  def permalink
+    self.name
+  end
+end

data/app/models/text_filter.rb

@@ -0,0 +1,111 @@
+require 'net/http'
+require_dependency 'textfilter_controller'
+
+class TextFilter < ActiveRecord::Base
+  serialize :filters
+  serialize :params
+
+  def self.available_filters
+    objects = []
+    ObjectSpace.each_object(Class) do |o|
+      if TextFilterPlugin > o and o.to_s =~ /Controller/
+        objects.push o
+      end
+    end
+
+    objects
+  end
+
+  def self.available_filter_types
+    filters=available_filters
+    types={"macropre" => [],
+           "macropost" => [],
+           "markup" => [],
+           "postprocess" => [],
+           "other" => []}
+
+    typemap={TextFilterPlugin::Markup => "markup",
+             TextFilterPlugin::MacroPre => "macropre",
+             TextFilterPlugin::MacroPost => "macropost",
+             TextFilterPlugin::PostProcess => "postprocess",
+             TextFilterPlugin => "other"}
+
+    filters.each { |filter| types[typemap[filter.superclass]].push(filter) }
+
+    types
+  end
+
+  def self.filters_map
+    available_filters.inject({}) { |map,filter| map[filter.short_name] = filter; map }
+  end
+
+  def self.filter_text(text, controller, content, filters, filterparams={}, filter_html=false)
+
+    map=TextFilter.filters_map
+    filters = [:htmlfilter, filters].flatten if filter_html
+
+    filters.each do |filter|
+      next if filter == nil
+      begin
+        filter_controller = map[filter.to_s]
+        next unless filter_controller
+        text = filter_controller.filtertext(controller, content, text, :filterparams => filterparams)
+      rescue => err
+        logger.error "Filter #{filter} failed: #{err}"
+      end
+    end
+
+    text
+  end
+
+  def self.filter_text_by_name(text, controller, filtername, filter_html=false)
+    f = TextFilter.find_by_name(filtername)
+    f.filter_text_for_controller text, controller, nil, filter_html
+  end
+
+  def filter_text_for_controller(text, controller, content, filter_html=false)
+    self.class.filter_text(
+      text, controller, content,
+      [:macropre, markup, :macropost, filters].flatten, params,
+      filter_html)
+  end
+
+  def filter(text,filter_html=false)
+    self.class.filter(text,self.filters,self.params,filter_html)
+  end
+
+  def help
+    filter_map = TextFilter.filters_map
+    filter_types = TextFilter.available_filter_types
+
+    help = []
+    help.push(filter_map[markup])
+    filter_types['macropre'].sort_by {|f| f.short_name}.each { |f| help.push f }
+    filter_types['macropost'].sort_by {|f| f.short_name}.each { |f| help.push f }
+    filters.each { |f| help.push(filter_map[f.to_s]) }
+
+    help_text = help.collect do |f|
+      f.help_text.blank? ? '' : "<h3>#{f.display_name}</h3>\n#{BlueCloth.new(f.help_text).to_html}\n"
+    end
+
+    help_text.join("\n")
+  end
+
+  def commenthelp
+    filter_map = TextFilter.filters_map
+    filter_types = TextFilter.available_filter_types
+
+    help = [filter_map[markup]]
+    filters.each { |f| help.push(filter_map[f.to_s]) }
+
+    help_text = help.collect do |f|
+      f.help_text.blank? ? '' : "#{BlueCloth.new(f.help_text).to_html}\n"
+    end
+
+    return help_text
+  end
+
+  def to_s; self.name; end
+
+  def to_text_filter; self; end
+end

data/app/models/theme.rb

@@ -0,0 +1,44 @@
+class Theme
+  cattr_accessor :cache_theme_lookup
+  @@cache_theme_lookup = false
+
+  attr_accessor :name, :path, :description_html
+
+  def initialize(name, path)
+    @name, @path = name, path
+  end
+
+  def layout
+    "../../themes/#{name}/layouts/default"
+  end
+
+  def description
+    File.read("#{path}/about.markdown") rescue "### #{name}"
+  end
+
+  def self.themes_root
+    RAILS_ROOT + "/themes"
+  end
+
+  def self.theme_from_path(path)
+    name = path.scan(/[-\w]+$/i).flatten.first
+    self.new(name, path)
+  end
+
+  def self.find_all
+    installed_themes.inject([]) do |array, path|
+      array << theme_from_path(path)
+    end
+  end
+
+  def self.installed_themes
+    cache_theme_lookup ? @theme_cache ||= search_theme_directory : search_theme_directory
+  end
+
+  def self.search_theme_directory
+    glob = "#{themes_root}/[a-zA-Z0-9]*"
+    Dir.glob(glob).select do |file|
+      File.readable?("#{file}/about.markdown")
+    end.compact
+  end
+end

data/app/models/trackback.rb

@@ -0,0 +1,51 @@
+require_dependency 'spam_protection'
+
+class Trackback < Content
+  include TypoGuid
+  belongs_to :article, :counter_cache => true
+
+  content_fields :excerpt
+
+  validates_age_of :article_id
+  validates_against_spamdb :title, :excerpt, :ip, :url
+  validates_presence_of :title, :excerpt, :url
+  validate_on_create :article_is_pingable
+
+  def self.default_order
+    'created_at ASC'
+  end
+
+  def initialize(*args, &block)
+    super(*args, &block)
+    self.title ||= self.url
+    self.blog_name ||= ""
+  end
+
+  def location(anchor=:ignored, only_path=true)
+    blog.url_for(article, "trackback-#{id}", only_path)
+  end
+
+  protected
+  before_create :make_nofollow, :process_trackback, :create_guid
+
+  def make_nofollow
+    self.blog_name = blog_name.strip_html
+    self.title     = title.strip_html
+    self.excerpt   = excerpt.strip_html
+  end
+
+  def process_trackback
+    if excerpt.length >= 251
+      # this limits excerpt to 250 chars, including the trailing "..."
+      self.excerpt = excerpt[0..246] << "..."
+    end
+  end
+
+  def article_is_pingable
+    return if article.nil?
+    unless article.allow_pings?
+      errors.add(:article, "Article is not pingable")
+    end
+  end
+end
+

data/app/models/trigger.rb

@@ -0,0 +1,31 @@
+class Trigger < ActiveRecord::Base
+  belongs_to :pending_item, :polymorphic => true
+
+  class << self
+    def post_action(due_at, item, method='came_due')
+      create!(:due_at => due_at, :pending_item => item,
+              :trigger_method => method)
+      fire
+    end
+
+    def fire
+      destroy_all ['due_at <= ?', Time.now]
+      true
+    end
+
+    def remove(pending_item, conditions = { })
+      return if pending_item.new_record?
+      conditions_string =
+        conditions.keys.collect{ |k| "(#{k} = :#{k})"}.join(' AND ')
+      with_scope(:find => { :conditions => [conditions_string, conditions]}) do
+        delete_all(["pending_item_id = ? AND pending_item_type = ?",
+                    pending_item.id, pending_item.class.to_s])
+      end
+    end
+  end
+
+  def before_destroy
+    pending_item.send(trigger_method)
+    true
+  end
+end

data/app/models/user.rb

@@ -0,0 +1,113 @@
+require 'digest/sha1'
+
+# this model expects a certain database layout and its based on the name/login pattern.
+class User < ActiveRecord::Base
+  has_and_belongs_to_many :notify_contents, :class_name => 'Content',
+    :join_table => 'notifications', :foreign_key => 'notify_user_id',
+    :association_foreign_key => 'notify_content_id', :uniq => true
+
+  has_many :articles, :order => 'created_at DESC' do
+    def published
+      find_published(:all, :order => 'created_at DESC')
+    end
+  end
+
+  # echo "typo" | sha1sum -
+  @@salt = '20ac4d290c2293702c64b3b287ae5ea79b26a5c1'
+  cattr_accessor :salt
+
+  # Authenticate a user.
+  #
+  # Example:
+  #   @user = User.authenticate('bob', 'bobpass')
+  #
+  def self.authenticate(login, pass)
+    find_first(["login = ? AND password = ?", login, sha1(pass)])
+  end
+
+  def self.authenticate?(login, pass)
+    user = self.authenticate(login, pass)
+    return false if user.nil?
+    return true if user.login == login
+
+    false
+  end
+
+  def self.find_by_permalink(permalink)
+    self.find_by_login(permalink)
+  end
+
+  # Let's be lazy, no need to fetch the counters, rails will handle it.
+  def self.find_all_with_article_counters(ignored_arg)
+    find(:all)
+  end
+
+  def self.to_prefix
+    'author'
+  end
+
+  def password=(newpass)
+    @password = newpass
+  end
+
+  def password(cleartext = nil)
+    if cleartext
+      @password.to_s
+    else
+      @password || read_attribute("password")
+    end
+  end
+
+  def article_counter
+    articles.size
+  end
+
+  def display_name
+    name
+  end
+
+  def permalink
+    login
+  end
+
+  protected
+
+  # Apply SHA1 encryption to the supplied password.
+  # We will additionally surround the password with a salt
+  # for additional security.
+  def self.sha1(pass)
+    Digest::SHA1.hexdigest("#{salt}--#{pass}--")
+  end
+
+  before_create :crypt_password
+
+  # Before saving the record to database we will crypt the password
+  # using SHA1.
+  # We never store the actual password in the DB.
+  def crypt_password
+    write_attribute "password", self.class.sha1(password(true))
+    @password = nil
+  end
+
+  before_update :crypt_unless_empty
+
+  # If the record is updated we will check if the password is empty.
+  # If its empty we assume that the user didn't want to change his
+  # password and just reset it to the old value.
+  def crypt_unless_empty
+    if password(true).empty?
+      user = self.class.find(self.id)
+      self.password = user.password
+    else
+      write_attribute "password", self.class.sha1(password(true))
+      @password = nil
+    end
+  end
+
+  validates_uniqueness_of :login, :on => :create
+  validates_length_of :password, :within => 5..40, :on => :create
+  validates_presence_of :login
+
+  validates_confirmation_of :password, :if=> Proc.new { |u| u.password.size > 0}
+  validates_length_of :login, :within => 3..40
+end