caramelize 0.3.0 → 0.4.0

data/lib/caramelize/filter_processor.rb

@@ -0,0 +1,31 @@
+require 'gollum-lib'
+require 'grit'
+require 'ruby-progressbar'
+
+module Caramelize
+  class FilterProcessor
+    attr_reader :filters, :input_wiki
+
+    def initialize(input_wiki)
+      @filters = []
+      @input_wiki = input_wiki
+
+      initialize_wiki_filters
+    end
+
+    def run(body)
+      body_new = body
+      filters.each do |filter|
+        body_new = filter.run(body_new)
+      end
+      body_new
+    end
+
+    private
+
+    def initialize_wiki_filters
+      filters << input_wiki.filters
+      filters.flatten!
+    end
+  end
+end

data/lib/caramelize/input_wiki/redmine_wiki.rb

@@ -0,0 +1,97 @@
+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.new
+        @options[:filters] << Caramelize::RemoveTableTabLineEndings.new
+        @options[:create_namespace_overview] = true
+      end
+
+      # after calling this action, I expect the titles and revisions to be filled
+      def read_pages
+        # get all projects
+        results_projects = database.query("SELECT id, identifier, name FROM projects;")
+        results_projects.each do |row_project|
+          #collect all namespaces
+          namespaces << OpenStruct.new(identifier: row_project["identifier"], name: row_project["name"])
+        end
+
+        # get all wikis
+        results_wikis = database.query("SELECT id, project_id FROM wikis;")
+
+        # get all lemmas
+        results_pages = database.query("SELECT id, title, wiki_id FROM wiki_pages;")
+        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;")
+
+          # get wiki for page
+          wiki_row = nil
+          project_row = nil
+          results_wikis.each do |wiki|
+            wiki_row = wiki if wiki["id"] == row_page["wiki_id"]
+          end
+
+          if wiki_row
+            # get project from wiki-id
+            results_projects.each do |project|
+              project_row = project if project["id"] == wiki_row["project_id"]
+            end
+          end
+
+          project_identifier = project_row ? project_row["identifier"] + '/' : ""
+
+          title = project_identifier + row_page["title"]
+          titles << title
+
+          @latest_revisions = {}
+          results_contents.each do |row_content|
+            page = Page.new(build_properties(title, row_content))
+            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 read_authors
+        results = database.query("SELECT id, login, mail FROM users;")
+        results.each do |row|
+          authors[row["id"]] = OpenStruct.new(id: row["id"],
+                                              name: row["login"],
+                                              email: row["mail"])
+        end
+        authors
+      end
+
+      private
+
+      def build_properties(title, row_content)
+        author = authors[row_content["author_id"]] ? authors[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,61 @@
+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
+        return 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
+        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,57 @@
+require 'caramelize/input_wiki/wiki'
+require 'caramelize/database_connector'
+require 'caramelize/filters/wikka_to_markdown'
+
+module Caramelize
+  module InputWiki
+    class WikkaWiki < Wiki
+      include DatabaseConnector
+
+      def initialize options={}
+        super(options)
+        @options[:markup] = :wikka
+        @options[:filters] << Caramelize::Wikka2Markdown.new
+      end
+
+      # after calling this action, titles and @revisions are expected to be filled
+      def read_pages
+        sql = "SELECT id, tag, body, time, latest, user, note FROM wikka_pages ORDER BY time;"
+        results = database.query(sql)
+        results.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
+        sql = "SELECT name, email FROM wikka_users;"
+        results = database.query(sql)
+        results.each do |row|
+          authors[row["name"]] = OpenStruct.new(name:  row["name"],
+                                                email: row["email"] )
+        end
+      end
+
+      private
+
+      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

data/lib/caramelize/output_wiki/gollum.rb

@@ -0,0 +1,73 @@
+require 'caramelize/ext'
+module Caramelize
+  module OutputWiki
+    class Gollum
+
+      attr_reader :wiki_path
+
+      SUPPORTED_TARGET_MARKUP =
+        %i[markdown textile rdoc creole media_wiki org pod re_structured_text ascii_doc].freeze
+
+      # Initialize a new gollum-wiki-repository at the given path.
+      def initialize(new_wiki_path)
+        # TODO use sanitized name as wiki-repository-title
+        @wiki_path = new_wiki_path
+        initialize_repository
+      end
+
+      # Commit the given page into the gollum-wiki-repository.
+      # Make sure the target markup is correct before calling this method.
+      def commit_revision(page, markup)
+        gollum_page = gollum.page(page.title)
+
+        if gollum_page
+          gollum.update_page(gollum_page, gollum_page.name, gollum_page.format, page.body, build_commit(page))
+        else
+          gollum.write_page(page.title, markup, page.body, build_commit(page))
+        end
+      end
+
+      # Commit all revisions of the given history into this gollum-wiki-repository.
+      def commit_history(revisions, options = {}, &block)
+        revisions.each_with_index do |page, index|
+          # call debug output from outside
+          block.call(page, index) if block_given?
+          commit_revision(page, options.fetch(:markup, :markdown))
+        end
+      end
+
+      def commit_namespace_overview(namespaces)
+        commit_revision(build_namespace_overview(namespaces), :markdown)
+      end
+
+      def supported_markup
+        SUPPORTED_TARGET_MARKUP
+      end
+
+      def build_commit(page)
+        {
+          message: page.commit_message,
+          name: page.author_name,
+          email: page.author_email,
+          authored_date: page.time,
+          committed_date: page.time
+        }
+      end
+
+      private
+
+      def build_namespace_overview(namespaces)
+        ::Caramelize::Services::PageBuilder.build_namespace_overview(namespaces)
+      end
+
+      def gollum
+        @gollum ||= ::Gollum::Wiki.new(wiki_path)
+      end
+
+      def initialize_repository
+        return if File.exists?(wiki_path)
+        Grit::Repo.init(wiki_path)
+      end
+    end
+  end
+end

data/lib/caramelize/page.rb

@@ -1,9 +1,10 @@
 module Caramelize
   class Page
 
-    attr_accessor :title, :body, :id, :markup, :latest, :time, :message, :author, :author_name
+    attr_accessor :title, :body, :id, :markup, :latest, :time, :message,
+                  :author, :author_name
 
-    def initialize page={}
+    def initialize(page={})
       @id =      page[:id]
       @title =   page[:title] || ""
       @body =    page[:body] || ""
@@ -12,7 +13,7 @@ module Caramelize
       @time =    page[:time] || Time.now
       @message = page[:message] || ""
       @author =  page[:author]
-      @author_name =  page[:author_name]
+      @author_name = page[:author_name]
     end
 
     def author_email
@@ -39,5 +40,10 @@ module Caramelize
     def to_s
       @title
     end
+
+    def commit_message
+      return "Edit in page #{title}" if message.empty?
+      message
+    end
   end
-end
+end

data/lib/caramelize/services/page_builder.rb

@@ -0,0 +1,20 @@
+module Caramelize
+  module Services
+    class PageBuilder
+      def self.build_namespace_overview(namespaces)
+        body = "## Overview of namespaces\n\n"
+
+        namespaces.each do |namespace|
+          # TODO change wiki as configurable default home
+          # TODO support other markup syntaxes
+          body << "* [[#{namespace[:name]}|#{namespace[:identifier]}/Wiki]]  \n"
+        end
+
+        Page.new(title: "Home",
+                 body: body,
+                 message: 'Create Namespace Overview',
+                 latest: true)
+      end
+    end
+  end
+end

data/lib/caramelize/version.rb

@@ -1,3 +1,3 @@
 module Caramelize
-  VERSION = "0.3.0"
+  VERSION = '0.4.0'
 end

data/spec/lib/caramelize/content_transferer_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Caramelize::ContentTransferer do
+  describe '#execute' do
+    context 'with original_wiki' do
+      pending
+    end
+  end
+end

data/spec/lib/caramelize/filter_processor_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Caramelize::FilterProcessor do
+  let(:filters) { [] }
+  let(:input_wiki) { double(filters: filters) }
+  let(:body) { 'body' }
+  subject(:processor) { described_class.new(input_wiki) }
+
+  class ReverseFilter
+    def run(body)
+      body.reverse
+    end
+  end
+
+  describe '#run' do
+    context 'without any filters' do
+      it 'returns same revision body' do
+        expect(processor.run(body)).to eql body
+      end
+    end
+
+    context 'with reverse filter' do
+      let(:filters) do
+        [ReverseFilter.new]
+      end
+
+      it 'returns reversed body' do
+        expect(processor.run(body)).to eql body.reverse
+      end
+    end
+  end
+end

data/spec/lib/caramelize/filters/wikka_to_markdown_spec.rb

@@ -5,81 +5,93 @@ describe Caramelize::Wikka2Markdown do
   describe :run do
     let(:filter) { Caramelize::Wikka2Markdown.new }
     context 'headline h1' do
-      it 'should convert to markdown' do
+      it 'converts to markdown' do
         body = '======Headline======'
         expect(filter.run(body)).to eq '# Headline'
       end
     end
+
     context 'headline h2' do
-      it 'should convert to markdown' do
+      it 'converts to markdown' do
         body = '=====Headline====='
         expect(filter.run(body)).to eq '## Headline'
       end
     end
+
     context 'headline h3' do
-      it 'should convert to markdown' do
+      it 'converts to markdown' do
         body = '====Headline===='
         expect(filter.run(body)).to eq '### Headline'
       end
     end
+
     context 'headline h4' do
-      it 'should convert to markdown' do
+      it 'converts to markdown' do
         body = '===Headline==='
         expect(filter.run(body)).to eq '#### Headline'
       end
     end
+
     context 'headline h1' do
-      it 'should convert to markdown' do
+      it 'converts to markdown' do
         body = '======Headline======'
         expect(filter.run(body)).to eq '# Headline'
       end
     end
+
     context 'bold' do
-      it 'should convert to markdown' do
+      it 'converts to markdown' do
         body = '**Text is bold**'
         expect(filter.run(body)).to eq '**Text is bold**'
       end
     end
+
     context 'italic' do
-      it 'should convert to markdown' do
+      it 'converts to markdown' do
         body = '//Text is italic//'
         expect(filter.run(body)).to eq '_Text is italic_'
       end
     end
+
     context 'underline' do
-      it 'should convert to markdown' do
+      it 'converts to markdown' do
         body = '__Text is underlined__'
         expect(filter.run(body)).to eq '<u>Text is underlined</u>'
       end
     end
+
     context 'line break' do
-      it 'should convert to markdown' do
+      it 'converts to markdown' do
         body = 'Text is---\nbroken to two lines.'
         expect(filter.run(body)).to eq 'Text is  \nbroken to two lines.'
       end
     end
+
     context 'unordered list entry' do
       context 'tab based' do
-        it 'should convert to markdown' do
+        it 'converts to markdown' do
           body = "\t-unordered list entry"
           expect(filter.run(body)).to eq '*unordered list entry'
         end
       end
+
       context 'also tab based' do
-        it 'should convert to markdown' do
+        it 'converts to markdown' do
           body = "~-unordered list entry"
           expect(filter.run(body)).to eq '*unordered list entry'
         end
       end
+
       context 'space based' do
-        it 'should convert to markdown' do
+        it 'converts to markdown' do
           body = "    -unordered list entry"
           expect(filter.run(body)).to eq '*unordered list entry'
         end
       end
     end
+
     context 'hyperlink' do
-      it 'should convert to markdown' do
+      it 'converts to markdown' do
         body = '[[Title http://target]]'
         expect(filter.run(body)).to eq '[[http://target|Title]]'
       end