caramelize 0.0.1

data/.gitignore

@@ -0,0 +1,55 @@
+wiki.git
+
+# rcov generated
+coverage
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+
+# bundler
+.bundle
+Gemfile.lock
+*.gem
+
+# jeweler generated
+pkg/*
+
+# Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore: 
+#
+# * Create a file at ~/.gitignore
+# * Include files you want ignored
+# * Run: git config --global core.excludesfile ~/.gitignore
+#
+# After doing this, these files will be ignored in all your git projects,
+# saving you from having to 'pollute' every project you touch with them
+#
+# Not sure what to needs to be ignored for particular editors/OSes? Here's some ideas to get you started. (Remember, remove the leading # of the line)
+#
+# For MacOS:
+#
+.DS_Store
+
+# For TextMate
+#*.tmproj
+#tmtags
+
+# For Komodo Edit
+#*.komodoproject
+
+# For emacs:
+#*~
+#\#*
+#.\#*
+
+# For vim:
+#*.swp
+
+# For redcar:
+#.redcar
+
+# For rubinius:
+#*.rbc

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in caramelize.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,47 @@
+PATH
+  remote: .
+  specs:
+    caramelize (0.0.1)
+      gollum (>= 1.3.0)
+      mysql2
+      treetop (>= 1.4.9)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    albino (1.3.3)
+      posix-spawn (>= 0.3.6)
+    diff-lcs (1.1.2)
+    github-markup (0.5.3)
+    gollum (1.3.0)
+      albino (~> 1.3.2)
+      github-markup (>= 0.4.0, < 1.0.0)
+      grit (~> 2.4.1)
+      mustache (>= 0.11.2, < 1.0.0)
+      nokogiri (~> 1.4)
+      sanitize (~> 2.0.0)
+      sinatra (~> 1.0)
+    grit (2.4.1)
+      diff-lcs (~> 1.1)
+      mime-types (~> 1.15)
+    mime-types (1.16)
+    mustache (0.99.4)
+    mysql2 (0.3.2)
+    nokogiri (1.4.4)
+    polyglot (0.3.1)
+    posix-spawn (0.3.6)
+    rack (1.3.0)
+    sanitize (2.0.2)
+      nokogiri (~> 1.4.4)
+    sinatra (1.2.6)
+      rack (~> 1.1)
+      tilt (>= 1.2.2, < 2.0)
+    tilt (1.3.2)
+    treetop (1.4.9)
+      polyglot (>= 0.3.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  caramelize!

data/LICENSE.md

@@ -0,0 +1,7 @@
+Copyright (c) 2011 Daniel Senff
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,62 @@
+# caramelize
+
+Caramelize is a compact and flexible wiki converter. It is intended for easily creating export of otherwise rare supported legacy wikis. With caramelize you can create your own export configurations and transfer your data into a git-based gollum-wiki retaing all your history.
+
+In the future more target wiki system may be added. For the moment export is supported for WikkaWiki and Redmine-Wiki.
+
+## Usage
+
+### Building
+
+For the moment caramelize is not yet stable and not released to any gemsites.
+
+To try it you require bundler to build it.
+
+    $ gem bundler install
+
+Clone this repository and start building.
+
+    $ git clone git@github.com:Dahie/caramelize.git
+    $ gem build caramelize.gemspec
+    
+Now to build the gem do 
+
+    $ rake build
+
+or
+
+    $ rake install
+
+to install the new gem right to the system.
+
+### Use
+
+    $ caramelize create --config=config.rb 
+
+Creates a template configuration file. This includes documentation on how to use the preset Wiki-connectors and how to write addition customized connectors.
+
+
+    $ caramelize run 
+    
+Will execute a wiki migration based on a found configuration file. These are found in predefined paths.
+
+    $ caramelize help
+Returns help information.
+
+	$ caramelize version
+Returns version and release information.
+
+## Contributing to caramelize
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2011 Daniel Senff. See LICENSE.md for further details.
+

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/bin/caramelize

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+	# If we are given filenames, convert each file 
+	
+require 'caramelize/cli'
+begin
+  Caramelize::CLI::CommandParser.new.parse
+rescue
+  puts "An error has occurred:\n  " + $!.message
+  puts $!.backtrace if $DEBUG
+  exit(-1)
+end

data/caramel.rb

@@ -0,0 +1,62 @@
+require 'caramelize/wiki'
+require 'caramelize/wikkawiki'
+require 'caramelize/redmine_wiki'
+
+# Within this method you can define your own Wiki-Connectors to Wikis not supported by default in this software
+
+# Note, if you want to activate this, you need to uncomment the line below.
+def customized_wiki
+  
+  # This example is a reimplementation of the WikkaWiki-Connector. 
+  # To connect to WikkaWiki, I suggest to use the predefined Connector below.
+  wiki = Caramelize::Wiki.new(:host => "localhost", :username => "user", :database => "database_name", :password => 'admin_gnihihihi', :syntax => :wikka)
+  wiki.instance_eval do
+    def read_pages
+      sql = "SELECT id, tag, body, time, latest, user, note FROM wikka_pages ORDER BY time;"
+      @revisions, @titles = [], []
+      results = database.query(sql)
+      results.each do |row|
+        @titles << row["tag"]
+        author = @authors[row["user"]]
+        page = Page.new({:id => row["id"],
+                            :title =>   row["tag"],
+                            :body =>    row["body"],
+                            :syntax =>  'wikka',
+                            :latest =>  row["latest"] == "Y",
+                            :time =>    row["time"],
+                            :message => row["note"],
+                            :author =>  author,
+                            :author_name => row["user"]})
+        @revisions << page
+      end
+      @titles.uniq!
+      @revisions
+      
+    end
+  end
+  
+  wiki
+end
+
+
+# if you want to use one of the preset Wiki-Connectors uncomment the connector 
+# and edit the database logins accordingly.
+def predefined_wiki
+  
+  # For connection to a WikkaWiki-Database use this Connector
+  #return Caramelize::WikkaWiki.new(:host => "localhost", :username => "root", :database => "wikka")
+  
+  
+  # For connection to a Redmine-Database use this Connector
+  return Caramelize::RedmineWiki.new(:host => "localhost", :username => "root", :database => "redmine_development")
+end
+
+
+def input_wiki
+  
+  # comment and uncomment to easily switch between predefined and costumized Wiki-connectors.
+  #return customized_wiki
+  
+  return predefined_wiki
+
+end

data/caramelize.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "caramelize/version"
+
+Gem::Specification.new do |s|
+  s.name        = "caramelize"
+  s.version     = Caramelize::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.license      = "MIT"
+  s.authors     = ["Daniel Senff"]
+  s.email       = ["mail@danielsenff.de"]
+  s.homepage    = "http://github.com/Dahie/caramelize"
+  s.summary     = %q{Abstract wiki convert to migrate your data from one wiki software to another}
+  s.description = %q{By defining the access from the input to the output wiki you can migrate any wiki.}
+  
+  s.bindir = 'bin'
+  
+  s.add_dependency('mysql2')
+  s.add_dependency('cmdparse')
+  s.add_dependency('gollum', '>= 1.3.0') # grit dependency implicit through gollum
+
+  s.rubyforge_project = "caramelize"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/caramelize/author.rb

@@ -0,0 +1,8 @@
+module Caramelize
+  class Author
+  
+    attr_accessor :id, :name, :email
+  
+    
+  end
+end

data/lib/caramelize/cli/create_command.rb

@@ -0,0 +1,47 @@
+#Encoding: UTF-8
+
+require 'caramelize/cli'
+
+module Caramelize::CLI
+
+  # The CLI command for creating a caramelize config file.
+  class CreateCommand < CmdParse::Command
+
+    def initialize #:nodoc:
+      super('create', false)
+      #self.description = Utils.format("If the verbosity level is set to verbose, the created files are listed.")
+      self.short_desc = 'Create a default config file for caramelize'
+      self.options = CmdParse::OptionParserWrapper.new do |opts|
+        opts.separator "Arguments:"
+        opts.separator opts.summary_indent + "DIR: the directory in which the website should be created"
+      end
+    end
+
+    def usage # :nodoc:
+      "Usage: #{commandparser.program_name} [global options] create [options] DIR"
+    end
+
+    # Create a caramelize config file in the directory <tt>args[0]</tt>.
+    def execute(args)
+      if args.length == 0
+        raise OptionParser::MissingArgument.new('DIR')
+      else
+        begin
+          
+          # TODO create dummy config file
+          
+        rescue
+          require 'fileutils'
+          FileUtils.rm_rf(args[0])
+          raise
+        end
+        if commandparser.verbosity == :verbose
+          puts "The following files were created in the directory #{args[0]}:"
+          #puts paths.sort.join("\n")
+        end
+      end
+    end
+    
+  end
+  
+end

data/lib/caramelize/cli/run_command.rb

@@ -0,0 +1,22 @@
+#Encoding: UTF-8
+
+require 'caramelize/cli'
+
+module Caramelize::CLI
+
+  # The CLI command for rendering a webgen website.
+  class RunCommand < CmdParse::Command
+
+    def initialize # :nodoc:
+      super('run', false)
+      self.short_desc = 'Run the wiki content transfer based on the given config file'
+    end
+
+    # Transfer Wiki contents
+    def execute(args)
+      commandparser.transfer_content
+    end
+
+  end
+
+end

data/lib/caramelize/cli.rb

@@ -0,0 +1,95 @@
+require 'cmdparse'
+require 'caramelize/version'
+
+module Caramelize
+  module CLI
+    
+    # Namespace for all classes that act as CLI commands.
+    autoload :RunCommand, 'caramelize/cli/run_command'
+    autoload :CreateCommand, 'caramelize/cli/create_command'
+    autoload :ContentTransferer, 'caramelize/content_transferer'
+  
+    # This is the command parser class used for handling the webgen command line interface. After
+    # creating an instance, the inherited #parse method can be used for parsing the command line
+    # arguments and executing the requested command.
+    class CommandParser < CmdParse::CommandParser
+
+      # The website directory. Default: the current working directory.
+      attr_reader :directory
+
+      # The verbosity level. Default: <tt>:normal</tt>
+      attr_reader :verbosity
+
+      # Create a new CommandParser class. T
+      def initialize 
+        super(true)
+        @directory = nil
+        @verbosity = :normal
+
+        self.program_name = "caramelize"
+        self.program_version = Caramelize::VERSION
+        self.options = CmdParse::OptionParserWrapper.new do |opts|
+          opts.separator "Global options:"
+          opts.on("--config DIR", "-d", String, "The config file (default: caramel.conf)") {|p| @directory = p}
+          opts.on("--verbose", "-v", "Print more output") { @verbosity = :verbose }
+          opts.on("--quiet", "-q", "No output") { @verbosity = :quiet }
+        end
+        self.add_command(CmdParse::HelpCommand.new)
+        self.add_command(CmdParse::VersionCommand.new)
+      end
+
+      KNOWN_CONFIG_LOCATIONS = ['config/caramel.rb', "config/caramel.config", "caramel.rb", "src/caramel.rb"]
+
+      # Finds the configuration file, if it exists in a known location.
+      def detect_configuration_file(config_path = nil)
+        possible_files = KNOWN_CONFIG_LOCATIONS
+        possible_files.detect{|f| File.exists?(f)}
+      end
+      
+      # Utility method for sub-commands to create a default config file
+      def create_config
+        # TODO create dummy config
+        #if !defined?(@website)
+          #@config = Webgen::Website.new(@directory) do |config|
+          #  config['logger.mask'] = @log_filter
+          #end
+        #end
+        #@config
+      end
+
+      # Utility method for sub-commands to transfer wiki contents
+      def transfer_content
+        # TODO maybe move to mixin
+        
+        time_start = Time.now
+        
+        # TODO outsource to config
+        file = detect_configuration_file
+        if file && File.exists?(file)
+          instance_eval(File.read(file), file || '<eval>')
+          original_wiki = input_wiki
+          
+          ContentTransferer.execute original_wiki, {:verbosity => @verbosity}
+          
+          time_end = Time.now
+          
+          puts "Time required: #{time_end - time_start} s" if @verbosity
+        else
+          puts "No config file found."
+        end
+        
+      end
+
+      # :nodoc:
+      def parse(argv = ARGV)
+        Caramelize::CLI.constants.select {|c| c =~ /.+Command$/ }.each do |c|
+          self.add_command(Caramelize::CLI.const_get(c).new, (c.to_s == 'RunCommand' ? false : false)) # set runcommand as default
+        end
+        super
+      end
+
+    end
+
+  end
+
+end

data/lib/caramelize/content_transferer.rb

@@ -0,0 +1,64 @@
+#Encoding: UTF-8
+
+require 'gollum'
+require 'grit'
+
+module Caramelize
+  autoload :Wiki, 'caramelize/wiki'
+  autoload :WikkaWiki, 'caramelize/wikkawiki'
+  autoload :RedmineWiki, 'caramelize/redmine_wiki'
+  autoload :GollumOutput, 'caramelize/gollum_output'
+  autoload :Wikka2MarkdownConverter, 'wikka2markdown_converter'
+  autoload :Author, 'caramelize/author'
+  autoload :Page, 'caramelize/page'
+  
+  # Controller for the content migration
+  class ContentTransferer
+    
+    # Execute the content migration
+    def self.execute original_wiki, options={}
+      
+      # read page revisions from wiki
+      # store page revisions
+      
+      original_wiki.read_authors
+      @revisions = original_wiki.read_pages
+      
+      # initiate new wiki
+      
+      output_wiki = GollumOutput.new('wiki.git')
+      
+      # commit page revisions to new wiki
+      
+      output_wiki.commit_history @revisions
+      
+      # if wiki needs to convert sytax, do so
+      if original_wiki.convert_syntax?
+        puts "latest revisions:"
+        # take each latest revision
+        for rev in original_wiki.latest_revisions
+          puts "Updated syntax: #{rev.title} #{rev.time}"
+          # parse markup & convert to new syntax
+          body_new = original_wiki.convert2markdown rev.body
+          unless body_new == rev.body
+            rev.body = body_new
+            rev.author_name = "Caramelize"
+            rev.time = Time.now
+            rev.author = nil
+            
+            # commit as latest page revision
+            output_wiki.commit_revision rev  
+          end
+        end  
+      end
+      
+      
+      #lemma = wiki.revisions_by_title "dahie"
+      #for page in lemma
+      #  puts page.time
+      #end
+      
+    end
+  end
+  
+end

data/lib/caramelize/database_connector.rb

@@ -0,0 +1,20 @@
+require 'mysql2'
+
+module Caramelize
+  module DatabaseConnector
+  
+    def database
+      socket = ["/tmp/mysqld.sock", 
+      "/tmp/mysql.sock", 
+      "/var/run/mysqld/mysqld.sock",
+      "/opt/local/var/run/mysql5/mysqld.sock",
+      "/var/lib/mysql/mysql.sock"].detect{|socket| File.exist?(socket)  }
+      @options[:socket] = socket
+      @client = Mysql2::Client.new(@options) unless @client
+      @client
+      
+    end
+    
+  end
+  
+end

data/lib/caramelize/ext.rb

@@ -0,0 +1,17 @@
+require 'gollum'
+
+module Gollum
+  class Committer
+    def commit
+      @options[:parents] = parents
+      @options[:actor] = actor
+      @options[:last_tree] = nil
+      @options[:head] = @wiki.ref
+      sha1 = index.commit(@options[:message], @options)
+      @callbacks.each do |cb|
+        cb.call(self, sha1)
+      end
+      sha1
+    end
+  end
+end

data/lib/caramelize/gollum_output.rb

@@ -0,0 +1,71 @@
+#Encoding: UTF-8
+
+module Caramelize
+  class GollumOutput
+    
+    # Initialize a new gollum-wiki-repository at the given path.
+    def initialize wiki_path
+      # TODO use sanitized name as wiki-repository-title
+      repo = Grit::Repo.init(wiki_path) unless File.exists?(wiki_path)
+      @gollum = Gollum::Wiki.new(wiki_path)
+    end
+    
+    # Commit the given page into the gollum-wiki-repository.
+    def commit_revision page
+      gollum_page = @gollum.page(page.title)
+      message = page.message.empty? ? "Edit in page #{page.title}" : page.message
+      
+      if page.author
+        author = page.author   
+      else
+        author = Author.new
+        author.name = page.author_name
+        author.email = "mail@example.com"
+      end
+      
+      commit = {:message => message,
+               :name => author.name,
+               :email => author.email,
+               :authored_date => page.time,
+               :committed_date => page.time
+      }
+      if gollum_page
+        @gollum.update_page(gollum_page, gollum_page.name, gollum_page.format, page.body, commit)
+      else
+        # OPTIMIZE support not just markdown
+        @gollum.write_page(page.title, :markdown, page.body, commit)
+      end
+    end
+    
+    # Commit all revisions of the given history into this gollum-wiki-repository.
+    def commit_history revisions
+      revisions.each_with_index do |page, index|
+        puts "(#{index+1}/#{revisions.count}) #{page.time}  #{page.title}" 
+        
+        gollum_page = @gollum.page(page.title)
+        message = page.message.empty? ? "Edit in page #{page.title}" : page.message
+        
+        if page.author
+          author = page.author   
+        else
+          author = Author.new
+          author.name = page.author_name
+          author.email = "mail@example.com"
+        end
+        
+        commit = {:message => message,
+                 :name => author.name,
+                 :email => author.email,
+                 :authored_date => page.time,
+                 :committed_date => page.time
+        }
+        if gollum_page
+          @gollum.update_page(gollum_page, gollum_page.name, gollum_page.format, page.body, commit)
+        else
+          # OPTIMIZE support not just markdown
+          @gollum.write_page(page.title, :markdown, page.body, commit)
+        end
+      end
+    end
+  end
+end

data/lib/caramelize/page.rb

@@ -0,0 +1,30 @@
+module Caramelize
+  class Page
+  
+    attr_accessor :title, :body, :id, :syntax, :latest, :time, :message, :author, :author_name
+  
+    def initialize page={}
+      @id =      page[:id]
+      @title =   page[:title]
+      @body =    page[:body]
+      @syntax =  page[:syntax]
+      @latest =  page[:latest]
+      @time =    page[:time]
+      @message = page[:message]
+      @author =  page[:author]
+      @author_name =  page[:author_name]
+    end
+    
+    def latest?
+      @latest
+    end
+    
+    def set_latest
+      @latest = true
+    end
+    
+    def to_s
+      @title
+    end
+  end
+end

data/lib/caramelize/redmine_wiki.rb

@@ -0,0 +1,66 @@
+#Encoding: UTF-8
+module Caramelize
+  autoload :DatabaseConnector, 'caramelize/database_connector'
+  autoload :Wikka2MarkdownConverter, 'caramelize/wikka2markdown_converter'
+  
+  class RedmineWiki < Wiki
+    include DatabaseConnector
+    
+    
+    # after calling this action, I expect the @titles and @revisions to be filled
+    def read_pages
+      sql = "SELECT id, title FROM wiki_pages;"
+      @revisions = []
+      @titles = []
+      @latest_revisions = {}
+      results_pages = database.query(sql)
+      results_pages.each do |row_page|
+        results_contents = database.query("SELECT * FROM wiki_content_versions WHERE page_id='#{row_page["id"]}' ORDER BY updated_on;")
+        title = row_page["title"]
+        @titles << title
+        
+        results_contents.each do |row_content|
+          author = @authors[row_content["author_id"]] ? @authors[row_content["author_id"]] : nil
+          page = Page.new({:id => row_content["id"],
+                            :title => title,
+                            :body => row_content["data"],
+                            :syntax => 'textile',
+                            :latest => false,
+                            :time => row_content["updated_on"],
+                            :message => row_content["comments"],
+                            :author => author,
+                            :author_name => author.name})
+          @revisions << page
+          @latest_revisions[title] = page
+        end
+      end
+      @titles.uniq!
+      @latest_revisions.each { |rev| rev[1].set_latest }
+      @revisions.sort! { |a,b| a.time <=> b.time }
+      
+      
+      # TODO find latest revision for each limit
+      
+      @revisions
+    end
+    
+      def convert_syntax?
+      # TODO
+      false
+    end
+    
+    def read_authors
+      sql = "SELECT id, login, mail FROM users;"
+      @authors = {}
+      results = database.query(sql)
+      results.each do |row|
+        author = Author.new
+        author.id    = row["id"]
+        author.name  = row["login"]
+        author.email = row["mail"]
+        @authors[author.id] = author
+      end
+      @authors
+    end
+  end    
+end

data/lib/caramelize/version.rb

@@ -0,0 +1,3 @@
+module Caramelize
+  VERSION = "0.0.1"
+end

data/lib/caramelize/wiki.rb

@@ -0,0 +1,42 @@
+module Caramelize
+  autoload :DatabaseConnector, 'caramelize/database_connector'
+  class Wiki
+    include DatabaseConnector
+    attr_accessor :revisions, :wiki_title, :titles, :description
+    
+    #def initialize revisions
+    #  @revisions = revisions
+    #end
+    
+    def initialize options={}
+      @options = options
+    end
+    
+    def revisions_by_title title
+      if @titles.index title
+        # new array only containing pages by this name sorted by time
+        # TODO this is probably bad for renamed pages if supported
+        return @revisions.reject { |revision| revision.title != title }.sort { |x,y| x.time <=> y.time }
+      end
+    end
+    
+    # return an empty array in case this action was not overridden
+    def read_authors
+      return []
+    end
+    
+    def convert_syntax?
+      # TODO
+      true
+    end
+    
+    def latest_revisions
+      @latest_revisions = []
+      for title in @titles
+        # pick first revision by descending date
+        @latest_revisions << revisions_by_title(title).last
+      end
+      @latest_revisions
+    end
+  end
+end

data/lib/caramelize/wikka2markdown_converter.rb

@@ -0,0 +1,28 @@
+module Caramelize
+  module Wikka2MarkdownConverter
+    
+    # take an input stream and convert all wikka syntax to markdown syntax
+    def convert2markdown str
+      str.gsub!(/(======)(.*?)(======)/ ) {|s| '# ' + $2 } #h1
+      str.gsub!(/(=====)(.*?)(=====)/) {|s| '## ' + $2 }   #h2
+      str.gsub!(/(====)(.*?)(====)/) {|s| '### ' + $2 }   #h3
+      str.gsub!(/(===)(.*?)(===)/) {|s| '#### ' + $2 }   #h4
+  
+      str.gsub!(/(\*\*)(.*?)(\*\*)/) {|s| '**' + $2 + '**' }   #bold
+      str.gsub!(/(\/\/)(.*?)(\/\/)/) {|s| '_' + $2 + '_' }   #italic
+      #str.gsub!(/(===)(.*?)(===)/) {|s| '`' + $2 + '`'}   #code
+      str.gsub!(/(__)(.*?)(__)/) {|s| '<u>' + $2 + '</u>'}   #underline
+      
+      str.gsub!(/(.*?)(\n\t-)(.*?)/) {|s| $1 + '\n' + $3 }   #list
+      
+      #str.gsub!(/(\t-)(.*?)/) {|s| '*' + $2 }   #list
+      #str.gsub!(/(----)/) {|s| '~~~~'}   #seperator
+      
+      
+      
+      # TODO more syntax conversion for links and images
+      
+      str
+    end
+  end
+end

data/lib/caramelize/wikkawiki.rb

@@ -0,0 +1,50 @@
+#Encoding: UTF-8
+module Caramelize
+  autoload :DatabaseConnector, 'caramelize/database_connector'
+  autoload :Wikka2MarkdownConverter, 'caramelize/wikka2markdown_converter'
+  
+  class WikkaWiki < Wiki
+    include DatabaseConnector
+    include Wikka2MarkdownConverter
+    
+    # after calling this action, I expect the @titles and @revisions to be filled
+    def read_pages
+      sql = "SELECT id, tag, body, time, latest, user, note FROM wikka_pages ORDER BY time;"
+      @revisions = []
+      @titles = []
+      results = database.query(sql)
+      results.each do |row|
+        @titles << row["tag"]
+        author = @authors[row["user"]]
+        page = Page.new({:id => row["id"],
+                            :title =>   row["tag"],
+                            :body =>    row["body"],
+                            :syntax =>  'wikka',
+                            :latest =>  row["latest"] == "Y",
+                            :time =>    row["time"],
+                            :message => row["note"],
+                            :author =>  author,
+                            :author_name => row["user"]})
+        @revisions << page
+      end
+      @titles.uniq!
+      #@revisions.sort! { |a,b| a.time <=> b.time }
+      
+      @revisions
+    end
+    
+    def read_authors
+      sql = "SELECT name, email FROM wikka_users;"
+      @authors = {}
+      results = database.query(sql)
+      results.each do |row|
+        author = Author.new
+        #author.id    = row["id"]
+        author.name  = row["name"]
+        author.email = row["email"]
+        @authors[author.name] = author
+      end
+      @authors
+    end
+  end    
+end

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'caramelize'
+
+class Test::Unit::TestCase
+end

data/test/test_caramelize.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestCaramelize < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: caramelize
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Daniel Senff
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-15 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: &2156137340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2156137340
+- !ruby/object:Gem::Dependency
+  name: cmdparse
+  requirement: &2156133960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2156133960
+- !ruby/object:Gem::Dependency
+  name: gollum
+  requirement: &2156131900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *2156131900
+description: By defining the access from the input to the output wiki you can migrate
+  any wiki.
+email:
+- mail@danielsenff.de
+executables:
+- caramelize
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE.md
+- README.md
+- Rakefile
+- bin/caramelize
+- caramel.rb
+- caramelize.gemspec
+- lib/caramelize/author.rb
+- lib/caramelize/cli.rb
+- lib/caramelize/cli/create_command.rb
+- lib/caramelize/cli/run_command.rb
+- lib/caramelize/content_transferer.rb
+- lib/caramelize/database_connector.rb
+- lib/caramelize/ext.rb
+- lib/caramelize/gollum_output.rb
+- lib/caramelize/page.rb
+- lib/caramelize/redmine_wiki.rb
+- lib/caramelize/version.rb
+- lib/caramelize/wiki.rb
+- lib/caramelize/wikka2markdown_converter.rb
+- lib/caramelize/wikkawiki.rb
+- test/helper.rb
+- test/test_caramelize.rb
+homepage: http://github.com/Dahie/caramelize
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: caramelize
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Abstract wiki convert to migrate your data from one wiki software to another
+test_files:
+- test/helper.rb
+- test/test_caramelize.rb