typo 5.0.2 → 5.0.3.98

data/vendor/plugins/typo_converter/Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the Typo_converters plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the Typo_converters plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'TypoConverters'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/vendor/plugins/typo_converter/init.rb

@@ -0,0 +1,8 @@
+TypoPlugins.module_eval do
+  def self.convert_from(engine, options = {})
+    require "converters/base"
+    require "converters/#{engine}"
+    puts "converting #{engine.to_s.humanize}..."
+    "#{engine.to_s.camelize}Converter".constantize.convert(options)
+  end
+end

data/vendor/plugins/typo_converter/lib/converters/base.rb

@@ -0,0 +1,249 @@
+class EmailNotifier < ActiveRecord::Observer
+  observe Article, Comment
+  
+  def after_save(content)
+    true
+  end
+end
+
+class WebNotifier < ActiveRecord::Observer
+  observe Article
+
+  def after_save(article)
+  end
+end
+
+class BaseConverter
+  @@new_user_password = 'typomigrator'
+  cattr_accessor :new_user_password
+
+  def initialize(options = {})
+    @count   = {:users => 0, :articles => 0, :comments => 0}
+    @options = options
+  end
+
+  # Converts the source blog to typo.  Should resemble something like this:
+  #
+  #   converter = new(options)
+  #   converter.import_users do |other_user|
+  #     # build Typo User object from other user
+  #     ::User.new ...
+  #   end
+  #   
+  #   convert.import_articles do |other_article|
+  #     # build Typo Article object from other article
+  #     ::Article.new ...
+  #   end
+  #   
+  #   convert.import_comments do |other_comment|
+  #     # build Typo Comment object from other comment
+  #     ::Comment.new ...
+  #   end
+  def self.convert(options = {})
+    raise NotImplementedError
+  end
+
+  # override this to provide array of all posts to migrate.
+  #
+  #   @old_articles ||= Article.find(:all)
+  def old_articles
+    raise NotImplementedError
+  end
+
+  # override this to find all users from the source database
+  # save them to @old_users, indexed by :login
+  # 
+  #   @old_users ||= User.find(:all).index_by(&:login)
+  def old_users
+    raise NotImplementedError
+  end
+  
+  # override this to retrieve the login name from the source user model
+  def get_login(other_user)
+    other_user.login
+  end
+
+  # override this to retrieve all comments from the source article model
+  def comments_for(other_article)
+    other_article.comments
+  end
+
+  # Resets an invalid email for a new user
+  def handle_bad_user_email(other_user, email)
+    other_user.email = email
+  end
+
+  # Resets the author email for a bad comment from the source site.
+  def handle_bad_comment_author_email(other_comment, email)
+    other_comment.author_email = email
+  end
+
+  # Resets the author url for a bad comment from the source site.
+  def handle_bad_comment_author_url(other_comment, url)
+    other_comment.author_url = url
+  end
+  
+  # Resets the author name for a bad comment from the source site.
+  def handle_bad_comment_author(other_comment, author)
+    other_comment.author = author
+  end
+  
+  # Resets the content for a bad comment from the source site.
+  def handle_bad_comment_content(other_comment, content)
+    other_comment.content = content
+  end
+
+  # Returns the destination site for the migrated content.  Uses the :site => 5 option to specify a site by id.
+  def blog
+    @blog ||= ::Blog.find(@options[:blog] || 1)
+  end
+
+  # Return the Typo filter None
+  def filter
+    @filter ||= ::TextFilter.find 1
+  end
+
+  # Returns all the users from the current Typo site, in a hash indexed by login name.
+  def users
+    @users        = ::User.find(:all)
+    @default_user = @users.first
+    @users.index_by(&:login)
+  end
+
+  # Returns the default user for new articles if one is not set in the source site.
+  def default_user
+    users if @users.nil?
+    @default_user
+  end
+
+  # Returns all Category, in a hash indexed by the category name.
+  def categories
+    @categories ||= ::Category.find(:all).index_by(&:name)
+  end
+
+  # Returns all Tag in a hash indexed by the tag name
+  def tags
+    @tags ||= ::Tag.find(:all).index_by(&:name)
+  end
+
+  def import_users(&block)
+    puts "start migrating of user..."
+    old_users.each do |login, other_user|
+      import_user(other_user, &block)
+    end
+    print "\n"
+    puts "migrated #{@count[:users]} user(s)..."
+  end
+  
+  def import_user(other_user, &block)
+    unless other_user && users[get_login(other_user)]
+      ActiveRecord::Base.logger.info "Creating new user for #{get_login(other_user)}"
+      new_user = block.call(other_user)
+      new_user.save!
+      print '.'
+      @count[:users] += 1
+      new_user
+    end
+  rescue ActiveRecord::RecordInvalid
+    if $!.record.errors.on :email
+      puts "  Retrying with new email"
+      handle_bad_user_email other_user, "#{$!.record.login}@nodomain.com"
+      retry
+    else
+      raise
+    end
+  end
+
+  def create_article(other_article, &block)
+    (article, *categories) = block.call(other_article)
+    if article
+      tags = Array.new(article.tags)
+      article.allow_comments = true
+      article.allow_pings    = false
+      article.published      = true
+      article.user           ||= default_user
+      article.text_filter    ||= filter
+      article.save!
+      print '.'
+      categories.each_with_index do |c, i|
+        article.categories << c
+      end
+      tags.each { |tag|
+        tag.articles << article
+        tag.save!
+      }
+      @article_index[other_article] = article
+      @count[:articles] += 1
+    end
+  rescue ActiveRecord::RecordInvalid
+    puts "Invalid Article: %s " % $!.record.errors.full_messages.join(' ')
+    puts $!.record.inspect
+    raise
+  end
+
+  def create_comment(article, other_comment, &block)
+    ActiveRecord::Base.logger.info "adding comment"
+    returning block.call(other_comment) do |comment|
+      comment.article  = article
+      comment.text_filter ||= filter
+      comment.ip ||= '127.0.0.1'
+      comment.save!
+      print '.'
+      @count[:comments] += 1
+    end
+  rescue ActiveRecord::RecordInvalid
+    if $!.record.errors.on :author_email
+      puts "  Retrying with new email"
+      handle_bad_comment_author_email other_comment, "invalid@nodomain.com"
+      retry
+    elsif $!.record.errors.on :author_url
+      puts "  Retrying with new URL"
+      handle_bad_comment_author_url other_comment, "http://nowhere.com/"
+      retry
+    elsif $!.record.errors.on :author
+      puts "  Retrying with new author name"
+      handle_bad_comment_author other_comment, "unknown"
+      retry
+    elsif $!.record.errors.on :body
+      puts "  Retrying with blank body"
+      handle_bad_comment_content other_comment, "empty"
+      retry
+    end
+    puts "Invalid Comment: %s " % $!.record.errors.full_messages.join(' ')
+    puts $!.record.inspect
+    raise
+  end
+
+  def create_categories(libelle)
+    @categories[libelle] = Category.find_or_create_by_name libelle 
+  end
+
+  # Create a tag with a libelle
+  # Add the tag in Hash value in attribute of tags
+  def create_tag(libelle)
+    @tags[libelle] = Tag.get libelle 
+  end
+  
+  def import_articles(&block)
+    puts "started articles migration..."
+    @article_index = {}
+    old_articles.each do |other_article|
+      create_article other_article, &block
+    end
+    print "\n"
+    puts "migrated #{@count[:articles]} article(s)..."
+  end
+  
+  def import_comments(&block)
+    puts "started comment migration..."
+    old_articles.each do |other_article|
+      ActiveRecord::Base.logger.info "Creating article comments"
+      comments_for(other_article).each do |other_comment|
+        create_comment(@article_index[other_article], other_comment, &block)
+      end
+    end
+    print "\n"
+    puts "migrated #{@count[:comments]} comment(s)..."
+  end
+end
+

data/vendor/plugins/typo_converter/lib/converters/dotclear.rb

@@ -0,0 +1,98 @@
+require 'converters/dotclear/post'
+require 'converters/dotclear/comment'
+require 'converters/dotclear/category'
+require 'converters/dotclear/user'
+
+class DotclearConverter < BaseConverter
+  def self.convert(options = {})
+    converter = new(options)
+    converter.import_users do |dc_user|
+      ::User.new \
+        :email => dc_user.user_email || "#{dc_user.user_id}@notfound.com",
+        :login => dc_user.user_id,
+        :password => new_user_password,
+        :password_confirmation => new_user_password
+    end
+
+    converter.import_articles do |dc_article|
+      unless dc_article.post_content.blank? && dc_article.post_chapo.blank? || dc_article.post_titre.blank?
+        user = dc_article.user_id.nil? ? nil : converter.users[Dotclear::User.find(dc_article.user_id.to_i).user_id]
+        
+        body = !dc_article.post_chapo.blank? ?
+          dc_article.post_chapo + '<br /> ' + dc_article.post_content :
+          dc_article.post_content
+
+        
+        a = ::Article.new \
+          :title        => CGI::unescapeHTML(dc_article.post_titre),
+          :body         => body,
+          :created_at   => dc_article.post_creadt,
+          :published_at => dc_article.post_creadt,
+          :updated_at   => dc_article.post_upddt,
+          :author       => user
+        [a, converter.find_or_create_categories(dc_article)]
+      end
+    end
+    
+    converter.import_comments do |dc_comment|
+      ::Comment.new \
+        :body         => dc_comment.comment_content,
+        :created_at   => dc_comment.comment_dt,
+        :updated_at   => dc_comment.comment_upddt,
+        :published_at => dc_comment.comment_dt,
+        :author       => dc_comment.comment_auteur,
+        :url          => dc_comment.comment_site,
+        :email        => dc_comment.comment_email,
+        :ip           => dc_comment.comment_ip
+    end
+  end
+
+  def old_articles
+    if @options.has_key?(:categories)
+      @old_article ||= Dotclear::Post.find(:all, 
+                                           :include => :categorie, 
+                                           :conditions => ["post_pub = 1 AND cat_libelle IN (?)", @options[:categories]])
+    else
+      @old_article ||= Dotclear::Post.find_all_by_post_pub true
+    end
+    @old_article
+  end
+
+  def old_users
+    @old_users ||= Dotclear::User.find(:all).index_by &:user_id
+  end
+
+  def get_login(dc_user)
+    dc_user.user_id
+  end
+
+  def handle_bad_user_email(dc_user, email)
+    dc_user.user_email = email
+  end
+
+  def handle_bad_comment_author_email(dc_comment, email)
+    dc_comment.comment_email = email
+  end
+  
+  def handle_bad_comment_author_url(dc_comment, url)
+    dc_comment.comment_site = url
+  end
+  
+  def handle_bad_comment_author(dc_comment, author)
+    dc_comment.comment_auteur = author
+  end
+  
+  def handle_bad_comment_content(dc_comment, content)
+    dc_comment.comment_content = content
+  end
+ 
+  def create_sections(libelle)
+    @sections[libelle] = site.sections.create!(:name => libelle, :path => libelle)
+    @sections[libelle]
+  end
+  def find_or_create_categories(dc_article)
+    cat = dc_article.categorie
+    create_categories(cat.cat_libelle) if categories[cat.cat_libelle].nil?
+    categories[cat.cat_libelle]
+  end
+end

data/vendor/plugins/typo_converter/lib/converters/dotclear/category.rb

@@ -0,0 +1,7 @@
+module Dotclear
+  class Category < ActiveRecord::Base
+    set_table_name 'dc_categorie'
+    set_primary_key 'cat_id'
+    establish_connection configurations['dc']
+  end
+end

data/vendor/plugins/typo_converter/lib/converters/dotclear/comment.rb

@@ -0,0 +1,8 @@
+module Dotclear
+  class Comment < ActiveRecord::Base
+    establish_connection configurations['dc']
+    set_primary_key 'comment_id'
+    set_table_name 'dc_comment'
+    belongs_to :post, :foreign_key => 'post_id', :class_name => 'Dotclear::Post'
+  end
+end

data/vendor/plugins/typo_converter/lib/converters/dotclear/post.rb

@@ -0,0 +1,9 @@
+module Dotclear
+  class Post < ActiveRecord::Base
+    set_table_name 'dc_post'
+    set_primary_key 'post_id'
+    establish_connection configurations['dc']
+    has_many :comments, :foreign_key => 'post_id', :class_name => 'Dotclear::Comment'
+    belongs_to :categorie, :foreign_key => 'cat_id', :class_name => 'Dotclear::Category'
+  end
+end

data/vendor/plugins/typo_converter/lib/converters/dotclear/user.rb

@@ -0,0 +1,8 @@
+module Dotclear
+  class User < ActiveRecord::Base
+    set_table_name 'dc_user'
+    set_primary_key 'user_id'
+    establish_connection configurations['dc']
+    has_many :posts, :foreign_key => 'user_id', :class_name => 'Dotclear::Post'
+  end
+end

data/vendor/plugins/typo_converter/lib/converters/dotclear_2.rb

@@ -0,0 +1,122 @@
+require 'converters/dotclear_2/post'
+require 'converters/dotclear_2/comment'
+require 'converters/dotclear_2/category'
+require 'converters/dotclear_2/user'
+require 'converters/dotclear_2/tag'
+
+class Dotclear2Converter < BaseConverter
+  def self.convert(options = {})
+    converter = new(options)
+    
+    unless (options[:prefix].nil?)
+      Dotclear2::Post.prefix = options[:prefix]
+      Dotclear2::Comment.prefix = options[:prefix]
+      Dotclear2::User.prefix = options[:prefix]
+      Dotclear2::Tag.prefix = options[:prefix]
+      Dotclear2::Category.prefix = options[:prefix]
+    end
+    
+    converter.import_users do |dc_user|
+      ::User.new \
+        :name => dc_user.user_displayname,
+        :email => dc_user.user_email || "#{dc_user.user_id}@notfound.com",
+        :login => dc_user.user_id,
+        :password => new_user_password,
+        :password_confirmation => new_user_password
+    end
+
+    converter.import_articles do |dc_article|
+      unless dc_article.post_content.blank? || dc_article.post_title.blank?
+        user = dc_article.user_id.nil? ? nil : converter.users[Dotclear2::User.find(dc_article.user_id.to_i).user_id]
+        
+        excerpt, body = !dc_article.post_excerpt.blank? ?
+          [dc_article.post_excerpt, dc_article.post_content]:
+          [nil, dc_article.post_content]
+
+        
+        a = ::Article.new \
+          :title        => CGI::unescapeHTML(dc_article.post_title),
+          :body         => body,
+          :created_at   => dc_article.post_creadt,
+          :published_at => dc_article.post_creadt,
+          :updated_at   => dc_article.post_upddt,
+          :author       => user,
+          :tags         => converter.find_or_create_tags(dc_article.tags)
+        [a, converter.find_or_create_categories(dc_article)]
+      end
+    end
+    
+    converter.import_comments do |dc_comment|
+      ::Comment.new \
+        :body         => dc_comment.comment_content,
+        :created_at   => dc_comment.comment_dt,
+        :updated_at   => dc_comment.comment_upddt,
+        :published_at => dc_comment.comment_dt,
+        :author       => dc_comment.comment_author,
+        :url          => dc_comment.comment_site,
+        :email        => dc_comment.comment_email,
+        :ip           => dc_comment.comment_ip
+    end
+  end
+
+  def old_articles
+    if @options.has_key?(:categories)
+      @old_article ||= Dotclear2::Post.find(:all, 
+                                           :include => :categorie, 
+                                           :conditions => ["post_status = ? AND cat_title IN (?)", true, @options[:categories]])
+    else
+      @old_article ||= Dotclear2::Post.find_all_by_post_status true
+    end
+    @old_article
+  end
+
+  def old_users
+    @old_users ||= Dotclear2::User.find(:all).index_by &:user_id
+  end
+
+  def get_login(dc_user)
+    dc_user.user_id
+  end
+
+  def handle_bad_user_email(dc_user, email)
+    dc_user.user_email = email
+  end
+
+  def handle_bad_comment_author_email(dc_comment, email)
+    dc_comment.comment_email = email
+  end
+  
+  def handle_bad_comment_author_url(dc_comment, url)
+    dc_comment.comment_site = url
+  end
+  
+  def handle_bad_comment_author(dc_comment, author)
+    dc_comment.comment_author = author
+  end
+  
+  def handle_bad_comment_content(dc_comment, content)
+    dc_comment.comment_content = content
+  end
+ 
+  def create_sections(libelle)
+    @sections[libelle] = site.sections.create!(:name => libelle, :path => libelle)
+    @sections[libelle]
+  end
+
+  def find_or_create_categories(dc_article)
+    cat = dc_article.categorie
+    create_categories(cat.cat_title) if categories[cat.cat_title].nil?
+    categories[cat.cat_title]
+  end
+  
+  # with the tags'libelle in params search or
+  # create the Tag objet in Typo
+  def find_or_create_tags(dc_tags)
+    tags_post = []
+    dc_tags.each { |tag|
+      create_tag(tag.meta_id) if tags[tag.meta_id].nil?
+      tags_post << tags[tag.meta_id]
+    }
+    tags_post
+  end
+end