typo 5.5 → 6.0.4

data/app/models/tag.rb

@@ -1,99 +0,0 @@
-class Tag < ActiveRecord::Base
-  has_and_belongs_to_many :articles, :order => 'created_at DESC'
-  validates_uniqueness_of :name
-  attr_reader :description
-  attr_reader :keywords
-
-  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.gsub('.', '-')
-    self.name = self.name.gsub(' ', '').downcase
-  end
-
-  before_save :ensure_naming_conventions
-
-  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
-      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 #{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)
-    self.find_by_name(*args) || new(:name => args.first)
-  end
-
-  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.already_published
-  end
-
-  def permalink
-    self.name
-  end
-
-  def permalink_url(anchor=nil, only_path=true)
-    blog = Blog.default # remove me...
-
-    blog.url_for(
-      :controller => 'tags',
-      :action => 'show',
-      :id => permalink
-    )
-  end
-
-  def to_atom(xml)
-    xml.category :term => display_name, :scheme => permalink_url
-  end
-
-  def to_rss(xml)
-    xml.category display_name
-  end
-
-  def to_param
-    permalink
-  end
-
-end

data/app/models/text_filter.rb

@@ -1,106 +0,0 @@
-require 'net/http'
-
-class TextFilter < ActiveRecord::Base
-  serialize :filters
-  serialize :params
-
-  @text_helper = ContentTextHelpers.new
-
-  def sanitize(*args,&blk)
-    self.class.sanitize(*args,&blk)
-  end
-
-  def self.available_filters
-    TextFilterPlugin.filter_map.values
-  end
-
-  TYPEMAP={TextFilterPlugin::Markup => "markup",
-           TextFilterPlugin::MacroPre => "macropre",
-           TextFilterPlugin::MacroPost => "macropost",
-           TextFilterPlugin::PostProcess => "postprocess",
-           TextFilterPlugin => "other"}
-
-  def self.available_filter_types
-    filters=available_filters
-    @cached_filter_types ||= {}
-
-    unless @cached_filter_types[filters]
-      types={"macropre" => [],
-             "macropost" => [],
-             "markup" => [],
-             "postprocess" => [],
-             "other" => []}
-
-      filters.each { |filter| types[TYPEMAP[filter.superclass]].push(filter) }
-
-      @cached_filter_types[filters] = types
-    end
-
-    @cached_filter_types[filters]
-  end
-
-  def self.filters_map
-    TextFilterPlugin.filter_map
-  end
-
-  def self.filter_text(blog, text, content, filters, filterparams={})
-    map=TextFilter.filters_map
-
-    filters.each do |filter|
-      next if filter == nil
-      begin
-        filter_class = map[filter.to_s]
-        next unless filter_class
-        text = filter_class.filtertext(blog, content, text, :filterparams => filterparams)
-      rescue => err
-        logger.error "Filter #{filter} failed: #{err}"
-      end
-    end
-
-    text
-  end
-
-  def self.filter_text_by_name(blog, text, filtername)
-    f = TextFilter.find_by_name(filtername)
-    f.filter_text_for_content blog, text, nil
-  end
-
-  def filter_text_for_content(blog, text, content)
-    self.class.filter_text(blog, text, content,
-      [:macropre, markup, :macropost, filters].flatten, params)
-  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
-
-    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.join("\n")
-
-    return help_text
-  end
-
-  def to_s; self.name; end
-
-  def to_text_filter; self; end
-end

data/app/models/theme.rb

@@ -1,58 +0,0 @@
-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(action=:default)
-    if action.to_s == 'view_page'
-      if File.exists? "#{RAILS_ROOT}/themes/#{name}/layouts/pages.html.erb"
-        return "#{RAILS_ROOT}/themes/#{name}/layouts/pages.html.erb"
-      end
-    end
-    "#{RAILS_ROOT}/themes/#{name}/layouts/default.html.erb"
-  end
-
-  def description
-    File.read("#{path}/about.markdown") rescue "### #{name}"
-  end
-
-  # Find a theme, given the theme name
-  def self.find(name)
-    self.new(name,theme_path(name))
-  end
-
-  def self.themes_root
-    RAILS_ROOT + "/themes"
-  end
-
-  def self.theme_path(name)
-    themes_root + "/" + name
-  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

@@ -1,67 +0,0 @@
-require_dependency 'spam_protection'
-
-class Trackback < Feedback
-  belongs_to :article
-  content_fields :excerpt
-  validates_presence_of :title, :excerpt, :url
-
-  attr_accessible :url, :blog_name, :title, :excerpt, :ip, :published, :article_id
-
-  def initialize(*args, &block)
-    super(*args, &block)
-    self.title ||= self.url
-    self.blog_name ||= ""
-  end
-
-  before_create :process_trackback
-
-  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_allows_feedback?
-    return true if article.allow_pings?
-    errors.add(:article, 'Article is not pingable')
-    false
-  end
-
-  def blog_allows_feedback?
-    return true unless blog.global_pings_disable
-    errors.add(:article, "Pings are disabled")
-    false
-  end
-
-  def originator
-    blog_name
-  end
-
-  def body
-    excerpt
-  end
-
-  def body=(newval)
-    self.excerpt = newval
-  end
-
-  def rss_author(xml)
-  end
-
-  def atom_author(xml)
-    xml.author do
-      xml.name blog_name
-      xml.uri url
-    end
-  end
-
-  def atom_title(xml)
-    xml.title "Trackback from #{blog_name}: #{title} on #{article.title}", :type => 'html'
-  end
-
-  def rss_title(xml)
-    xml.title "Trackback from #{blog_name}: #{title} on #{article.title}"
-  end
-end
-

data/app/models/trigger.rb

@@ -1,32 +0,0 @@
-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
-    returning true do
-      pending_item.send(trigger_method) if pending_item
-    end
-  end
-end

data/app/models/user.rb

@@ -1,208 +0,0 @@
-require 'digest/sha1'
-
-class User < ActiveRecord::Base
-  belongs_to :profile
-  belongs_to :text_filter
-  has_many :notifications, :foreign_key => 'notify_user_id'
-  has_many :notify_contents, :through => :notifications,
-    :source => 'notify_content',
-    :uniq => true
-
-  has_many :articles, :order => 'created_at DESC' do
-    def published
-      find_published(:all, :order => 'created_at DESC')
-    end
-  end
-  has_many :published_articles,
-    :class_name => 'Article',
-    :conditions => { :published => true },
-    :order      => "published_at DESC"
-
-  # echo "typo" | sha1sum -
-  @@salt = '20ac4d290c2293702c64b3b287ae5ea79b26a5c1'
-  cattr_accessor :salt
-  attr_accessor :last_venue
-
-  def self.authenticate(login, pass)
-    find(:first,
-         :conditions => ["login = ? AND password = ? AND state = ?", login, sha1(pass), 'active'])
-  end
-  
-  def update_connection_time
-    self.last_venue = last_connection
-    self.last_connection = Time.now
-    self.save
-  end
-
-  # These create and unset the fields required for remembering users between browser closes
-  def remember_me
-    remember_me_for 2.weeks
-  end
-
-  def remember_me_for(time)
-    remember_me_until time.from_now.utc
-  end
-
-  def remember_me_until(time)
-    self.remember_token_expires_at = time
-    self.remember_token            = Digest::SHA1.hexdigest("#{email}--#{remember_token_expires_at}")
-    save(false)
-  end
-
-  def forget_me
-    self.remember_token_expires_at = nil
-    self.remember_token            = nil
-    save(false)
-  end
-
-  def permalink_url(anchor=nil, only_path=true)
-    blog = Blog.default # remove me...
-
-    blog.url_for(
-      :controller => 'users',
-      :action => 'show',
-      :id => permalink
-    )
-  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)
-    returning(self.find_by_login(permalink)) do |user|
-      raise ActiveRecord::RecordNotFound unless user
-    end
-  end
-
-  # The current project_modules
-  def project_modules
-    profile.modules.collect { |m| AccessControl.project_module(profile.label, m) }.uniq.compact rescue []
-  end
-  
-  # Generate Methods takes from AccessControl rules
-  # Example:
-  #
-  #   def publisher?
-  #     profile.label == :publisher
-  #   end
-  AccessControl.roles.each { |r| define_method("#{r.to_s.downcase.to_sym}?") { profile.label.to_s.downcase.to_sym == r.to_s.downcase.to_sym } }
-
-  # 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
-
-  def to_param
-    permalink
-  end
-
-  def admin?
-    profile.label == Profile::ADMIN
-  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.
-  # But before the encryption, we send an email to user for he can remind his
-  # password
-  def crypt_password
-    send_create_notification
-    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)
-      write_attribute "password", user.password
-    else
-      send_create_notification
-      write_attribute "password", self.class.sha1(password(true))
-      @password = nil
-    end
-  end
-
-  before_validation :set_default_profile
-
-  def set_default_profile
-    if User.count.zero?
-      self.profile ||= Profile.find_by_label('admin')
-    else
-      self.profile ||= Profile.find_by_label('contributor')
-    end
-  end
-
-  validates_uniqueness_of :login, :on => :create
-  validates_uniqueness_of :email, :on => :create
-  validates_length_of :password, :within => 5..40, :if => Proc.new { |user|
-    user.read_attribute('password').nil? or user.password.to_s.length > 0
-  }
-
-  validates_presence_of :login
-  validates_presence_of :email
-
-  validates_confirmation_of :password
-  validates_length_of :login, :within => 3..40
-
-
-  private
-
-  # Send a mail of creation user to the user create
-  def send_create_notification
-    begin
-      email_notification = NotificationMailer.create_notif_user(self)
-      EmailNotify.send_message(self,email_notification)
-    rescue => err
-      logger.error "Unable to send notification of create user email: #{err.inspect}"
-    end
-  end
-end