caramelize 0.1.2 → 1.1.0

data/lib/caramelize/filters/remove_table_tab_line_endings.rb

@@ -0,0 +1,15 @@
+module Caramelize
+  class RemoveTableTabLineEndings
+
+    def initialize(body)
+      @body = body
+    end
+
+    # take an input stream and convert all wikka syntax to markdown syntax
+    def run
+      migrated_body = @body.dup
+      migrated_body.gsub!(/\|[\t ]*\r?[\n]/, "|\n")
+      migrated_body
+    end
+  end
+end

data/lib/caramelize/filters/swap_wiki_links.rb

@@ -0,0 +1,26 @@
+module Caramelize
+  class SwapWikiLinks
+    def initialize(body)
+      @body = body
+    end
+
+    # take an input stream and convert all wikka syntax to markdown syntax
+    def run
+      migrated_body = @body.dup
+
+      migrated_body.gsub!(/\[\[(\S+)\|(.+?)\]\]/) { format_link($2, $1) }
+      migrated_body.gsub!(/\[\[([\w\s\-\.]*)\]\]/) { format_link($1, $1.dup) }
+
+      migrated_body
+    end
+
+    private
+
+    def format_link(label, link)
+      link.downcase!
+      link.gsub!(' ', '_')
+      link.gsub!(/\./, '')
+      "[[#{label}|#{link}]]"
+    end
+  end
+end

data/lib/caramelize/filters/wikka_to_markdown.rb

@@ -0,0 +1,67 @@
+module Caramelize
+  class Wikka2Markdown
+    attr_reader :source_body
+
+    def initialize(source_body)
+      @source_body = source_body
+    end
+
+    def run
+      # TODO images: ({{image)(url\=?)?(.*)(}})
+      # markdown: ![Tux, the Linux mascot](/assets/images/tux.png)
+
+      replace_headlines
+      replace_formatting
+      replace_lists
+      replace_wiki_links
+      replace_links
+      replace_code_block
+
+      target_body
+    end
+
+    def replace_headlines
+      target_body.gsub!(/(======)(.*?)(======)/ ) {|s| '# ' + $2 } #h1
+      target_body.gsub!(/(=====)(.*?)(=====)/) {|s| '## ' + $2 }   #h2
+      target_body.gsub!(/(====)(.*?)(====)/) {|s| '### ' + $2 }   #h3
+      target_body.gsub!(/(===)(.*?)(===)/) {|s| '#### ' + $2 }   #h4
+      target_body.gsub!(/(==)(.*?)(==)/) {|s| '##### ' + $2 }   #h5
+    end
+
+    def replace_formatting
+      target_body.gsub!(/(\*\*)(.*?)(\*\*)/) {|s| '**' + $2 + '**' }   #bold
+      target_body.gsub!(/(\/\/)(.*?)(\/\/)/, '*\2*') #italic
+      target_body.gsub!(/(__)(.*?)(__)/) {|s| '<u>' + $2 + '</u>'}   #underline
+      target_body.gsub!(/(---)/, '  ')   #forced linebreak
+    end
+
+    def replace_lists
+      target_body.gsub!(/(\t-\s?)(.*)/, '* \2')    # unordered list
+      target_body.gsub!(/(~-\s?)(.*)/, '* \2')     # unordered list
+      target_body.gsub!(/(    -\s?)(.*)/, '* \2')     # unordered list
+
+      target_body.gsub!(/(~1\)\s?)(.*)/, '1. \2')     # unordered list
+      # TODO ordered lists
+    end
+
+    def replace_wiki_links
+      target_body.gsub!(/[\[]{2}(\w+)[\s|](.+?)[\]]{2}/, '[[\2|\1]]')
+    end
+
+    def replace_links
+      target_body.gsub!(/[\[]{2}((\w+):[\S][^\| ]*)[\| ](.*)[\]]{2}/,
+                 '[\3](\1)')
+      target_body.gsub!(/[\[]{2}((\w+):.*)[\]]{2}/, '<\1>')
+    end
+
+    def replace_code_block
+      target_body.gsub!(/^%%\s(.*?)%%\s?/m) do
+        $1.gsub(/^/, '    ')
+      end
+    end
+
+    def target_body
+      @target_body ||= source_body.dup
+    end
+  end
+end

data/lib/caramelize/health_check.rb

@@ -0,0 +1,85 @@
+module Caramelize
+  class HealthCheck
+    attr_reader :wiki_path, :options
+
+    DEFAULT_GOLLUM_HOME_TITLE = 'Home'.freeze
+
+    def initialize(wiki_path, options={})
+      @wiki_path = wiki_path
+      @options = options
+    end
+
+    def execute
+      #puts page_paths.sort.inspect
+
+      check_pages
+
+      #puts intra_wiki_paths.sort.inspect
+
+      puts "\n # Pages not linked within Wiki:"
+      puts page_paths_without_intra_wiki_path.sort.inspect
+    end
+
+    private
+
+    def files
+      @files ||= Dir.glob([wiki_path, '**/*.md'].join('/'))
+    end
+
+    def file_names
+      files.map do |file|
+        file.gsub("#{wiki_path}/", '').split('.').first
+      end
+    end
+
+    def check_pages
+      pages.each do |page|
+        puts "\n## #{page.path}"
+        check_page(page)
+      end
+    end
+
+    def check_page(page)
+      intra_wiki_links = intra_wiki_links(page.text_data)
+      available = 0
+      intra_wiki_links.each do |link|
+        intra_wiki_link = page.path.split('/').first == page.path ? link : [page.path.split('/').first, link].join('/')
+        if !page_paths.include?(intra_wiki_link)
+          puts "#{intra_wiki_link} expected, but missing"
+        else
+          available += 1
+          intra_wiki_paths << intra_wiki_link
+        end
+      end
+      puts "#{available}/#{intra_wiki_links.count} available"
+    end
+
+    def intra_wiki_links(body)
+      body.scan(/\[\[(.+\|)?(\S+)\]\]/).map { |match| match[1] }.uniq
+    end
+
+    def pages
+      gollum.pages
+    end
+
+    def page_paths
+      pages.map(&:path).map { |path| path.split('.').first }
+    end
+
+    def intra_wiki_paths
+      @intra_wiki_paths ||= []
+    end
+
+    def page_paths_without_intra_wiki_path
+      page_paths - intra_wiki_paths
+    end
+
+    def check_home_page
+      puts "Home.md missing" if File.exist?('wiki-export/Home.md')
+    end
+
+    def gollum
+      @gollum ||= ::Gollum::Wiki.new(wiki_path)
+    end
+  end
+end

data/lib/caramelize/input_wiki/redmine_wiki.rb

@@ -0,0 +1,120 @@
+require 'caramelize/input_wiki/wiki'
+require 'caramelize/filters/swap_wiki_links'
+require 'caramelize/filters/remove_table_tab_line_endings'
+
+module Caramelize
+  module InputWiki
+    class RedmineWiki < Wiki
+      include DatabaseConnector
+
+      def initialize(options = {})
+        super(options)
+        @options[:markup] = :textile
+        @options[:filters] << Caramelize::SwapWikiLinks
+        @options[:filters] << Caramelize::RemoveTableTabLineEndings
+        @options[:create_namespace_overview] = true
+      end
+
+      # after calling this action, I expect the titles and revisions to be filled
+      def read_pages
+        add_projects_as_namespaces
+
+        pages.each do |row_page|
+          build_page(row_page)
+        end
+        titles.uniq!
+        revisions.sort! { |a,b| a.time <=> b.time }
+
+        revisions
+      end
+
+      def read_authors
+        results = database.query(authors_query)
+        results.each do |row|
+          authors[row["id"]] = OpenStruct.new(id: row["id"],
+                                              name: row["login"],
+                                              email: row["mail"])
+        end
+        authors
+      end
+
+      private
+
+      def build_page(row_page)
+        results_contents = database.query(single_page_query(row_page['id']))
+
+        wiki = wikis.select{ |row| row['id'] == row_page['wiki_id'] }.first
+
+        project_identifier = ''
+
+        if wiki
+          project = projects.select{ |row| row['id'] == wiki['project_id'] }.first
+          project_identifier = project['identifier'] + '/'
+        end
+
+        title = project_identifier + row_page['title']
+        titles << title
+
+        results_contents.each do |row_content|
+          page = Page.new(build_properties(title, row_content))
+          revisions << page
+        end
+      end
+
+      def add_projects_as_namespaces
+        projects.each do |row_project|
+          namespace = OpenStruct.new(identifier: row_project['identifier'],
+                                     name: row_project['name'])
+          namespaces << namespace
+        end
+      end
+
+      def authors_query
+        'SELECT id, login, mail FROM users;'
+      end
+
+      def single_page_query(page_id)
+        "SELECT * FROM wiki_content_versions WHERE page_id='#{page_id}' ORDER BY updated_on;"
+      end
+
+      def projects_query
+        'SELECT id, identifier, name FROM projects;'
+      end
+
+      def pages_query
+        'SELECT id, title, wiki_id FROM wiki_pages;'
+      end
+
+      def wikis_query
+        'SELECT id, project_id FROM wikis;'
+      end
+
+      def pages
+        @pages ||= database.query(pages_query)
+      end
+
+      def projects
+        @projects ||= database.query(projects_query)
+      end
+
+      def wikis
+        @wikis ||= database.query(wikis_query)
+      end
+
+      def build_properties(title, row_content)
+        author = authors.fetch(row_content["author_id"], nil)
+        {
+          id: row_content['id'],
+          title: title,
+          body: row_content['data'],
+          markup: :textile,
+          latest: false,
+          time: row_content['updated_on'],
+          message: row_content['comments'],
+          author: author,
+          author_name: author.name
+        }
+      end
+    end
+  end
+end

data/lib/caramelize/input_wiki/wiki.rb

@@ -0,0 +1,59 @@
+module Caramelize
+  module InputWiki
+    class Wiki
+      include DatabaseConnector
+
+      attr_accessor :revisions, :wiki_title, :titles, :description, :namespaces, :options
+
+      def initialize(options={})
+        @options = options
+        @options[:filters] = []
+        @namespaces = []
+      end
+
+      def revisions_by_title(title)
+        # new array only containing pages by this name sorted by time asc
+        # this does not support renamed pages
+        revisions.select { |revision| revision.title == title }
+                 .sort { |x,y| x.time <=> y.time }
+      end
+
+      # return an empty array in case this action was not overridden
+      def read_authors
+        []
+      end
+
+      def namespaces
+        @namespaces ||= {}
+      end
+
+      def authors
+        @authors ||= {}
+      end
+
+      def revisions
+        @revisions ||= []
+      end
+
+      def titles
+        @titles ||= []
+      end
+
+      def convert_markup?(to_markup)
+        markup != to_markup
+      end
+
+      def filters
+        @options[:filters]
+      end
+
+      def latest_revisions
+        @latest_revisions ||= titles.map { |title| revisions_by_title(title).last }.compact
+      end
+
+      def markup
+        @options[:markup]
+      end
+    end
+  end
+end

data/lib/caramelize/input_wiki/wikkawiki.rb

@@ -0,0 +1,69 @@
+require 'caramelize/database_connector'
+require 'caramelize/filters/wikka_to_markdown'
+
+module Caramelize
+  module InputWiki
+    class WikkaWiki < Wiki
+      include DatabaseConnector
+
+      SQL_PAGES = 'SELECT id, tag, body, time, latest, user, note FROM wikka_pages ORDER BY time;'.freeze
+      SQL_AUTHORS = 'SELECT name, email FROM wikka_users;'.freeze
+
+      def initialize(options = {})
+        super(options)
+        @options[:markup] = :wikka
+        @options[:filters] << Caramelize::Wikka2Markdown
+      end
+
+      # after calling this action, titles and @revisions are expected to be filled
+      def read_pages
+        pages.each do |row|
+          titles << row['tag']
+          page = Page.new(build_properties(row))
+          revisions << page
+        end
+        titles.uniq!
+        #revisions.sort! { |a,b| a.time <=> b.time }
+
+        revisions
+      end
+
+      def read_authors
+        results = database.query(authors_query)
+        results.each do |row|
+          authors[row['name']] = OpenStruct.new(name:  row['name'],
+                                                email: row['email'] )
+        end
+      end
+
+      private
+
+      def pages_query
+        SQL_PAGES
+      end
+
+      def authors_query
+        SQL_AUTHORS
+      end
+
+      def pages
+        @pages ||= database.query(pages_query)
+      end
+
+      def build_properties(row)
+        author = authors[row['user']]
+        {
+          id: row["id"],
+          title: row["tag"],
+          body: row["body"],
+          markup: :wikka,
+          latest: row["latest"] == "Y",
+          time: row["time"],
+          message: row["note"],
+          author: author,
+          author_name: row["user"]
+        }
+      end
+    end
+  end
+end