caramelize 0.4.0 → 1.0.0

data/lib/caramelize/input_wiki/redmine_wiki.rb

@@ -7,56 +7,20 @@ module Caramelize
     class RedmineWiki < Wiki
       include DatabaseConnector
 
-      def initialize options={}
+      def initialize(options = {})
         super(options)
         @options[:markup] = :textile
-        @options[:filters] << Caramelize::SwapWikiLinks.new
-        @options[:filters] << Caramelize::RemoveTableTabLineEndings.new
+        @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
-        # 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
+        add_projects_as_namespaces
 
-        # 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
+        pages.each do |row_page|
+          build_page(row_page)
         end
         titles.uniq!
         @latest_revisions.each { |rev| rev[1].set_latest }
@@ -68,7 +32,7 @@ module Caramelize
       end
 
       def read_authors
-        results = database.query("SELECT id, login, mail FROM users;")
+        results = database.query('SELECT id, login, mail FROM users;')
         results.each do |row|
           authors[row["id"]] = OpenStruct.new(id: row["id"],
                                               name: row["login"],
@@ -79,15 +43,59 @@ module Caramelize
 
       private
 
+      def build_page(row_page)
+        results_contents = database.query("SELECT * FROM wiki_content_versions WHERE page_id='#{row_page["id"]}' ORDER BY updated_on;")
+
+        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
+
+        @latest_revisions = {}
+        results_contents.each do |row_content|
+          page = Page.new(build_properties(title, row_content))
+          revisions << page
+          @latest_revisions[title] = 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 pages
+        @pages ||= database.query('SELECT id, title, wiki_id FROM wiki_pages;')
+      end
+
+      def projects
+        @projects ||= database.query('SELECT id, identifier, name FROM projects;')
+      end
+
+      def wikis
+        @wikis ||= database.query('SELECT id, project_id FROM wikis;')
+      end
+
       def build_properties(title, row_content)
         author = authors[row_content["author_id"]] ? authors[row_content["author_id"]] : nil
-        { id: row_content["id"],
+        {
+          id: row_content['id'],
           title: title,
-          body: row_content["data"],
+          body: row_content['data'],
           markup: :textile,
           latest: false,
-          time: row_content["updated_on"],
-          message: row_content["comments"],
+          time: row_content['updated_on'],
+          message: row_content['comments'],
           author: author,
           author_name: author.name
         }

data/lib/caramelize/input_wiki/wikkawiki.rb

@@ -7,18 +7,16 @@ module Caramelize
     class WikkaWiki < Wiki
       include DatabaseConnector
 
-      def initialize options={}
+      def initialize(options = {})
         super(options)
         @options[:markup] = :wikka
-        @options[:filters] << Caramelize::Wikka2Markdown.new
+        @options[:filters] << Caramelize::Wikka2Markdown
       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"]
+        pages.each do |row|
+          titles << row['tag']
           page = Page.new(build_properties(row))
           revisions << page
         end
@@ -29,19 +27,25 @@ module Caramelize
       end
 
       def read_authors
-        sql = "SELECT name, email FROM wikka_users;"
+        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"] )
+          authors[row['name']] = OpenStruct.new(name:  row['name'],
+                                                email: row['email'] )
         end
       end
 
       private
 
+      def pages
+        sql = 'SELECT id, tag, body, time, latest, user, note FROM wikka_pages ORDER BY time;'
+        @pages ||= database.query(sql)
+      end
+
       def build_properties(row)
-        author = authors[row["user"]]
-        { id: row["id"],
+        author = authors[row['user']]
+        {
+          id: row["id"],
           title: row["tag"],
           body: row["body"],
           markup: :wikka,

data/lib/caramelize/output_wiki/gollum.rb

@@ -1,4 +1,3 @@
-require 'caramelize/ext'
 module Caramelize
   module OutputWiki
     class Gollum
@@ -27,6 +26,11 @@ module Caramelize
         end
       end
 
+      def rename_page(page_title, rename)
+        gollum_page = gollum.page(page_title)
+        gollum.rename_page(gollum_page, rename, { message: 'Rename home page' })
+      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|
@@ -47,10 +51,9 @@ module Caramelize
       def build_commit(page)
         {
           message: page.commit_message,
-          name: page.author_name,
-          email: page.author_email,
-          authored_date: page.time,
-          committed_date: page.time
+          name: page.author.name,
+          email: page.author.email,
+          time: page.time
         }
       end
 
@@ -61,12 +64,14 @@ module Caramelize
       end
 
       def gollum
-        @gollum ||= ::Gollum::Wiki.new(wiki_path)
+        @gollum ||= ::Gollum::Wiki.new(wiki_path, {repo_is_bare: true})
       end
 
       def initialize_repository
         return if File.exists?(wiki_path)
-        Grit::Repo.init(wiki_path)
+        Dir.mkdir(wiki_path)
+        #::Gollum::Git::Repo.new(wiki_path, { is_bare: true })
+        ::Gollum::Git::Repo.init(wiki_path)
       end
     end
   end

data/lib/caramelize/version.rb

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

data/spec/lib/caramelize/filter_processor_spec.rb

@@ -7,8 +7,12 @@ describe Caramelize::FilterProcessor do
   subject(:processor) { described_class.new(input_wiki) }
 
   class ReverseFilter
-    def run(body)
-      body.reverse
+    def initialize(body)
+      @body = body
+    end
+
+    def run
+      @body.reverse
     end
   end
 
@@ -20,9 +24,7 @@ describe Caramelize::FilterProcessor do
     end
 
     context 'with reverse filter' do
-      let(:filters) do
-        [ReverseFilter.new]
-      end
+      let(:filters) { [ReverseFilter] }
 
       it 'returns reversed body' do
         expect(processor.run(body)).to eql body.reverse

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

@@ -1,34 +1,48 @@
 require 'spec_helper'
 
 describe Caramelize::RemoveTableTabLineEndings do
+  let(:filter) { described_class.new(body) }
+  subject { filter.run}
 
-  describe :run do
-    let(:filter) { Caramelize::RemoveTableTabLineEndings.new }
+  describe '#run' do
     context 'table with tabs at unix line-endings' do
-      it 'should remove tabs at end of line' do
-        body = "cell1\t|cell2\t|\t\t\n"
-        expect(filter.run(body)).to eq "cell1\t|cell2\t|\n"
+      let(:body) { "cell1\t|cell2\t|\t\t\n" }
+
+      it 'removes tabs at end of line' do
+        is_expected.to eq "cell1\t|cell2\t|\n"
       end
-      it 'should remove spaces at end of line' do
-        body = "cell1\t|cell2\t|\t    \n"
-        expect(filter.run(body)).to eq "cell1\t|cell2\t|\n"
+    end
+
+    context 'with spaces on line ending' do
+      let(:body) { "cell1\t|cell2\t|\t    \n" }
+
+      it 'removes spaces at end of line' do
+        is_expected.to eq "cell1\t|cell2\t|\n"
       end
+
       context 'replace in full file' do
+        let(:body) { File.open(File.join(['spec', 'fixtures', 'markup', 'table-tab-line-endings-input.textile']), 'r').read }
+
         it 'returns as expected' do
-          input_text = File.open(File.join(['spec', 'fixtures', 'markup', 'table-tab-line-endings-input.textile']), 'r').read
           output_text = File.open(File.join(['spec', 'fixtures', 'markup', 'table-tab-line-endings-output.textile']), 'r').read
-          expect(filter.run(input_text)).to eq output_text
+          is_expected.to eq output_text
         end
       end
     end
+
     context 'table with tabs at windows line-endings' do
-      it 'should remove tabs at end of line' do
-        body = "cell1\t|cell2\t|\t\t\r\n"
-        expect(filter.run(body)).to eq "cell1\t|cell2\t|\n"
+      let(:body) { "cell1\t|cell2\t|\t\t\r\n" }
+
+      it 'removes tabs at end of line' do
+        is_expected.to eq "cell1\t|cell2\t|\n"
       end
-      it 'should remove spaces at end of line' do
-        body = "cell1\t|cell2\t|\t    \r\n"
-        expect(filter.run(body)).to eq "cell1\t|cell2\t|\n"
+    end
+
+    context 'with spaces and windows line-endings' do
+      let(:body) { "cell1\t|cell2\t|\t    \r\n" }
+
+      it 'removes spaces at end of line' do
+        is_expected.to eq "cell1\t|cell2\t|\n"
       end
     end
   end

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

@@ -1,31 +1,47 @@
 require 'spec_helper'
 
 describe Caramelize::SwapWikiLinks do
+  describe '#run' do
+    let(:filter) { described_class.new(body) }
+    subject { filter.run }
 
-  describe :run do
-    let(:filter) { Caramelize::SwapWikiLinks.new }
-    context 'wiki link' do
-      it 'should switch title and target' do
-        body = '[[statistics|Driver & Team Statistics]]'
-        expect(filter.run(body)).to eq '[[Driver & Team Statistics|statistics]]'
+    context 'wiki link with title' do
+      let(:body) { '[[statistics|Driver & Team Statistics]]' }
+
+      it 'swaps title and target' do
+        is_expected.to eq '[[Driver & Team Statistics|statistics]]'
       end
-      it 'should replace space with dashes' do
-        body = '[[Release 1 0]]'
-        expect(filter.run(body)).to eq '[[Release 1 0|Release_1_0]]'
+    end
+
+    context 'wiki title with spaces' do
+      let(:body) { '[[Release 1 0]]' }
+
+      it 'replaces space with dashes' do
+        is_expected.to eq '[[Release 1 0|Release_1_0]]'
       end
-      it 'should remove dots' do
-        body = '[[Release 1.0]]'
-        expect(filter.run(body)).to eq '[[Release 1.0|Release_10]]'
+    end
+
+    context 'wiki title with dashes' do
+      let(:body) { '[[Release 1.0]]' }
+
+      it 'removes dots' do
+        is_expected.to eq '[[Release 1.0|Release_10]]'
       end
-      it 'should simple link to hyperlink' do
-        body = '[[Intra wiki link]]'
-        expect(filter.run(body)).to eq '[[Intra wiki link|Intra_wiki_link]]'
+    end
+
+    context 'wiki link with spaces and without title' do
+      let(:body) { '[[Intra wiki link]]' }
+
+      it 'simples link to hyperlink' do
+        is_expected.to eq '[[Intra wiki link|Intra_wiki_link]]'
       end
+
       context 'replace in full file' do
+        let(:body) { File.open(File.join(['spec', 'fixtures', 'markup', 'swap-links-input.textile']), 'r').read }
+
         it 'returns as expected' do
-          input_text = File.open(File.join(['spec', 'fixtures', 'markup', 'swap-links-input.textile']), 'r').read
           output_text = File.open(File.join(['spec', 'fixtures', 'markup', 'swap-links-output.textile']), 'r').read
-          expect(filter.run(input_text)).to eq output_text
+          is_expected.to eq output_text
         end
       end
     end

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

@@ -1,100 +1,198 @@
 require 'spec_helper'
 
 describe Caramelize::Wikka2Markdown do
+  let(:filter) { described_class.new(body) }
+
+  describe '#run' do
+    subject { filter.run }
+
+    xcontext 'keep line breaks' do
+      let(:body) { "line1\nline2" }
+
+      it { is_expected.to eq "line1  \nline2" }
+    end
 
-  describe :run do
-    let(:filter) { Caramelize::Wikka2Markdown.new }
     context 'headline h1' do
-      it 'converts to markdown' do
-        body = '======Headline======'
-        expect(filter.run(body)).to eq '# Headline'
-      end
+      let(:body) { '======Headline======' }
+
+      it { is_expected.to eq '# Headline' }
     end
 
     context 'headline h2' do
-      it 'converts to markdown' do
-        body = '=====Headline====='
-        expect(filter.run(body)).to eq '## Headline'
-      end
+      let(:body) { '=====Headline=====' }
+
+      it { is_expected.to eq '## Headline' }
     end
 
     context 'headline h3' do
-      it 'converts to markdown' do
-        body = '====Headline===='
-        expect(filter.run(body)).to eq '### Headline'
-      end
+      let(:body) { '====Headline===='}
+
+      it { is_expected.to eq '### Headline' }
     end
 
     context 'headline h4' do
-      it 'converts to markdown' do
-        body = '===Headline==='
-        expect(filter.run(body)).to eq '#### Headline'
-      end
+      let(:body) { '===Headline===' }
+
+      it { is_expected.to eq '#### Headline' }
     end
 
-    context 'headline h1' do
-      it 'converts to markdown' do
-        body = '======Headline======'
-        expect(filter.run(body)).to eq '# Headline'
-      end
+    context 'headline h5' do
+      let(:body) { '==Headline==' }
+
+      it { is_expected.to eq '##### Headline' }
     end
 
     context 'bold' do
-      it 'converts to markdown' do
-        body = '**Text is bold**'
-        expect(filter.run(body)).to eq '**Text is bold**'
-      end
+      let(:body) { '**Text is bold**' }
+
+      it { is_expected.to eq '**Text is bold**' }
     end
 
     context 'italic' do
-      it 'converts to markdown' do
-        body = '//Text is italic//'
-        expect(filter.run(body)).to eq '_Text is italic_'
-      end
+      let(:body) { '//Text is italic//' }
+
+      it { is_expected.to eq '*Text is italic*' }
     end
 
     context 'underline' do
-      it 'converts to markdown' do
-        body = '__Text is underlined__'
-        expect(filter.run(body)).to eq '<u>Text is underlined</u>'
-      end
+      let(:body) { '__Text is underlined__' }
+
+      it { is_expected.to eq '<u>Text is underlined</u>' }
     end
 
     context 'line break' 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
+      let(:body) { 'Text is---\nbroken to two lines.' }
+
+      it { is_expected.to eq 'Text is  \nbroken to two lines.' }
     end
 
     context 'unordered list entry' do
       context 'tab based' do
-        it 'converts to markdown' do
-          body = "\t-unordered list entry"
-          expect(filter.run(body)).to eq '*unordered list entry'
-        end
+        let(:body) { "\t-unordered list entry" }
+
+        it { is_expected.to eq '* unordered list entry' }
       end
 
       context 'also tab based' do
-        it 'converts to markdown' do
-          body = "~-unordered list entry"
-          expect(filter.run(body)).to eq '*unordered list entry'
-        end
+        let(:body) { "~-unordered list entry" }
+
+        it { is_expected.to eq '* unordered list entry' }
       end
 
       context 'space based' do
-        it 'converts to markdown' do
-          body = "    -unordered list entry"
-          expect(filter.run(body)).to eq '*unordered list entry'
-        end
+        let(:body) { "    -unordered list entry" }
+
+        it { is_expected.to eq '* unordered list entry' }
+      end
+
+      context 'tab based with space' do
+        let(:body) { "\t- unordered list entry" }
+
+        it { is_expected.to eq '* unordered list entry' }
+      end
+
+      context 'also tab based with space' do
+        let(:body) { "~- unordered list entry" }
+
+        it { is_expected.to eq '* unordered list entry' }
+      end
+
+      context 'space based with space' do
+        let(:body) { "    - unordered list entry" }
+
+        it { is_expected.to eq '* unordered list entry' }
+      end
+    end
+
+    context 'ordered list entry' do
+      context 'without space' do
+        let(:body) { "~1)ordered list entry" }
+
+        it { is_expected.to eq '1. ordered list entry' }
+      end
+
+      context 'with space' do
+        let(:body) { "~1) ordered list entry" }
+
+        it { is_expected.to eq '1. ordered list entry' }
+      end
+    end
+
+    context 'wikilink' do
+      context 'only url' do
+        let(:body) { '[[LemmaLemma]]' }
+
+        it { is_expected.to eq '[[LemmaLemma]]' }
+      end
+
+      context 'url and pipe title' do
+        let(:body) { '[[SandBox|Test your formatting skills]]' }
+
+        it { is_expected.to eq '[[Test your formatting skills|SandBox]]' }
+      end
+
+      context 'url and title' do
+        let(:body) { '[[SandBox Test your formatting skills]]' }
+
+        it { is_expected.to eq '[[Test your formatting skills|SandBox]]' }
       end
     end
 
     context 'hyperlink' do
-      it 'converts to markdown' do
-        body = '[[Title http://target]]'
-        expect(filter.run(body)).to eq '[[http://target|Title]]'
+      context 'only url' do
+        let(:body) { '[[http://target]]' }
+
+        it { is_expected.to eq '<http://target>' }
+      end
+
+      context 'url with title' do
+        let(:body) { '[[http://target Title]]' }
+
+        it { is_expected.to eq '[Title](http://target)' }
+      end
+
+      context 'url with pipe' do
+        let(:body) { '[[http://target|Title]]' }
+
+        it { is_expected.to eq '[Title](http://target)' }
+      end
+    end
+
+    context 'code block' do
+      let(:body) do
+        <<-EOS
+Text before
+
+%%
+std::cin >> input;
+++stat[input];
+%%
+
+Text after
+
+%%
+std::cin >> input;
+++stat[input];
+%%
+
+        EOS
       end
+      let(:expected_result) do
+        <<-EOS
+Text before
+
+    std::cin >> input;
+    ++stat[input];
+
+Text after
+
+    std::cin >> input;
+    ++stat[input];
+
+        EOS
+      end
+
+      it { is_expected.to eq expected_result }
     end
   end
 end