typo 5.5 → 6.0.4

data/app/models/page.rb

@@ -1,41 +0,0 @@
-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 self.search_paginate(search_hash, paginate_hash)
-    list_function = ["Page"] + function_search_no_draft(search_hash)
-    paginate_hash[:order] = 'title ASC'
-    list_function << "paginate(paginate_hash)"
-    eval(list_function.join('.'))
-  end
-
-  def permalink_url(anchor=nil, only_path=false)
-    blog.url_for(
-      :controller => '/articles',
-      :action => 'view_page',
-      :name => name, 
-      :anchor => anchor,
-      :only_path => only_path
-    )
-  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
-  
-  def delete_url
-    blog.url_for(:controller => "/admin/pages", :action =>"destroy", :id => id)
-  end
-end

data/app/models/page_cache.rb

@@ -1,62 +0,0 @@
-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
-
-  # Delete all file save in path_cache by page_cache system
-  def self.sweep_all
-    self.zap_pages(%w{*})
-  end
-
-  def self.sweep_theme_cache
-    self.zap_pages(%w{images/theme/* stylesheets/theme/* javascripts/theme/*})
-  end
-
-  def self.zap_pages(paths)
-    # Ensure no one is going to wipe his own blog public directory
-    # It happened once on a release and was no fun at all
-    return if public_path == "#{RAILS_ROOT}/public"
-    srcs = paths.inject([]) { |o,v|
-      o + Dir.glob(public_path + "/#{v}")
-    }
-    return true if srcs.empty?
-    trash = RAILS_ROOT + "/tmp/typodel.#{UUID.random_create}"
-    FileUtils.makedirs(trash)
-    FileUtils.mv(srcs, trash, :force => true)
-    FileUtils.rm_rf(trash)
-  end
-  
-
-  # DEPRECATED
-  #
-  # It's now deprecated. It's use only in migration
-  # (20090311160502_create_cache_informations.rb)
-  # Doesn't use anyway. The cache is now manage by CacheInformation
-  # Method to swepp_all cache is allways self.sweep_all
-  #
-  # DEPRECATED
-  def self.old_sweep_all
-    logger.debug "PageCache - sweep_all called by #{caller[1].inspect}"
-    unless Blog.default.nil?
-      self.zap_pages(%w{index.* articles.* pages page
-                     pages.* feedback feedback.*
-                     comments comments.*
-                     category categories.* xml
-                     sitemap.xml
-                     *.rss *.atom
-                     tag tags.* category archives.*})
-
-      self.zap_pages((1990..2020))
-      self.zap_pages([*1990..2020].collect { |y| "#{y}.*" })
-    end
-  end
-  
-end

data/app/models/ping.rb

@@ -1,124 +0,0 @@
-require 'rexml/document'
-
-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))
-        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
-      end
-    end
-
-    def origin_url
-      @origin_url
-    end
-
-    def response
-      @response
-    end
-
-    def ping
-      @ping
-    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
-      # 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)
-    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=#{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)}"
-
-    path = trackback_uri.path
-    path += "?#{trackback_uri.query}" if trackback_uri.query
-
-    net_request = Net::HTTP.start(trackback_uri.host, trackback_uri.port) do |http|
-      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/profile.rb

@@ -1,15 +0,0 @@
-class Profile < ActiveRecord::Base
-  serialize :modules
-  validates_uniqueness_of :label
-
-  ADMIN = 'admin'
-  
-  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/redirect.rb

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

data/app/models/resource.rb

@@ -1,66 +0,0 @@
-require 'tempfile'
-require 'mini_magick'
-
-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
-  
-  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
-
-  def create_thumbnail
-    return unless self.mime =~ /image/ or File.exists?(fullpath("thumb_#{self.filename}"))
-    return unless File.exists?(fullpath("#{self.filename}"))
-    begin
-      img_orig = MiniMagick::Image.from_file(fullpath(self.filename))
-      img_orig = img_orig.resize('125x125')
-      img_orig.write(fullpath("thumb_#{self.filename}"))
-    rescue
-      nil
-    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.exist?(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

data/app/models/right.rb

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

data/app/models/sidebar.rb

@@ -1,269 +0,0 @@
-class Sidebar < ActiveRecord::Base
-  serialize :config
-
-  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], { :class => 'small large'})
-    end
-
-    def line_html(sidebar)
-      content_tag(:p, label_html(sidebar) +  "<br />" + input_html(sidebar), :class => 'input_text_title')
-    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", "class" => "large small" }.update(options.stringify_keys)
-        text_area_tag(input_name(sidebar), 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)
-        hidden_field_tag(input_name(sidebar),0)+
-        check_box_tag(input_name(sidebar), 1, sidebar.config[key], options)
-      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
-
-  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 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
-      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 html_id
-    short_name + '-' + id.to_s
-  end
-
-  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
-