caramelize 0.3.0 → 0.4.0

data/lib/caramelize/cli/create_command.rb

@@ -1,36 +0,0 @@
-require 'caramelize/cli'
-require 'fileutils'
-
-module Caramelize::CLI
-
-  # The CLI command for creating a caramelize config file.
-  class CreateCommand < CmdParse::Command
-
-    # The website config-file. Default: the current working directory.
-    attr_reader :config_file
-
-    def initialize #:nodoc:
-      super('create', false)
-      self.description = "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.on("--config <file>", "-f", String, "The config file (default: caramel.rb)") {|p| @config_file = p}
-      end
-    end
-
-    def usage # :nodoc:
-      "Usage: #{commandparser.program_name} [global options] create [options]"
-    end
-
-    # Create a caramelize config file.
-    def execute(args)
-      # create dummy config file
-      target_file = @config_file.nil? ? "caramel.rb" : @config_file
-      FileUtils.cp(File.dirname(__FILE__) +"/../caramel.rb", target_file)
-      if commandparser.verbosity == :normal
-        puts "Created new configuration file: #{target_file}"
-      end
-    end
-  end
-end

data/lib/caramelize/cli/run_command.rb

@@ -1,33 +0,0 @@
-#Encoding: UTF-8
-require 'caramelize/cli'
-
-module Caramelize::CLI
-
-  # The CLI command for rendering a webgen website.
-  class RunCommand < CmdParse::Command
-
-    # The website config-file. Default: the current working directory.
-    attr_reader :config_file
-
-    def initialize # :nodoc:
-      super('run', false)
-      self.short_desc = 'Run the wiki content transfer based on the given config file'
-      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"
-        opts.on("--config <file>", "-f", String, "The config file (default: caramel.rb)") {|p| @config_file = p}
-      end
-    end
-
-    def usage # :nodoc:
-      "Usage: #{commandparser.program_name} [global options] run [options]"
-    end
-
-    # Transfer Wiki contents
-    def execute(args)
-      commandparser.transfer_content @config_file
-    end
-
-  end
-
-end

data/lib/caramelize/gollum_output.rb

@@ -1,79 +0,0 @@
-require 'caramelize/ext'
-module Caramelize
-  class GollumOutput
-
-    def supported_markup
-      [:markdown, :textile]
-    end
-
-    # 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
-
-    def wiki_path
-      @wiki_path
-    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)
-      options[:markup] = :markdown if !options[:markup] # target markup
-      revisions.each_with_index do |page, index|
-        # call debug output from outside
-        block.call(page, index) if block_given?
-        commit_revision(page, options[:markup])
-      end
-    end
-
-    def create_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 = Page.new(title: "Home",
-                      body: body,
-                      message: 'Create Namespace Overview',
-                      latest: true)
-      commit_revision(page, :markdown)
-      page
-    end
-
-
-    private
-
-    def gollum
-      @gollum ||= Gollum::Wiki.new(wiki_path)
-    end
-
-    def initialize_repository
-      # TODO ask if we should replace existing paths
-      Grit::Repo.init(wiki_path) unless File.exists?(wiki_path)
-    end
-
-    def build_commit(page)
-      message = page.message.empty? ? "Edit in page #{page.title}" : page.message
-
-      { message: message,
-        name: page.author_name,
-        email: page.author_email,
-        authored_date: page.time,
-        committed_date: page.time }
-    end
-
-  end
-end

data/lib/caramelize/wiki/redmine_wiki.rb

@@ -1,88 +0,0 @@
-require 'caramelize/wiki/wiki'
-require 'caramelize/filters/swap_wiki_links'
-require 'caramelize/filters/remove_table_tab_line_endings'
-module Caramelize
-
-  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|
-          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"],
-                            :markup => :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 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
-  end
-end

data/lib/caramelize/wiki/wiki.rb

@@ -1,63 +0,0 @@
-module Caramelize
-  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
-      # TODO this is probably bad for renamed pages if supported
-      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
-      return []
-    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.each do |title|
-        # pick first revision by descending date
-        @latest_revisions << revisions_by_title(title).last
-      end
-      @latest_revisions
-    end
-
-    def markup
-      @options[:markup]
-    end
-
-  end
-end

data/lib/caramelize/wiki/wikkawiki.rb

@@ -1,48 +0,0 @@
-module Caramelize
-  require 'caramelize/wiki/wiki'
-  require 'caramelize/database_connector'
-  require 'caramelize/filters/wikka_to_markdown'
-
-  class WikkaWiki < Wiki
-    include DatabaseConnector
-
-    def initialize options={}
-      super(options)
-      @options[:markup] = :wikka
-      @options[:filters] << Caramelize::Wikka2Markdown.new
-    end
-
-    # 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;"
-      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"],
-                            :markup =>  :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;"
-      results = database.query(sql)
-      results.each do |row|
-        authors[row["name"]] = OpenStruct.new(name:  row["name"],
-                                              email: row["email"] )
-      end
-    end
-  end
-end

data/spec/lib/caramelize/gollum_output_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-
-describe Caramelize::GollumOutput do
-
-  let(:gollum_output) { Caramelize::GollumOutput.new('wiki.git') }
-  before do
-    allow(gollum_output).to receive(:initialize_repository).and_return true
-  end
-
-  describe :commit_history do
-  end
-
-  describe :create_namespace_overview do
-
-    context '3 pages in namespaces' do
-      it 'commits page' do
-        namespaces= [
-          OpenStruct.new(identifier: 'velociraptors', name: 'Velociraptor'),
-          OpenStruct.new(identifier: 'allosaurus', name: 'Allosaurus')
-        ]
-        body = "## Overview of namespaces\n\n* [[Velociraptor|velociraptors/Wiki]]  \n* [[Allosaurus|allosaurus/Wiki]]  \n"
-        expected_page = Caramelize::Page.new(title: 'Home',
-          body: body,
-          message: 'Create Namespace Overview',
-          latest: true
-          )
-        allow(gollum_output).to receive(:commit_revision).with(expected_page, :markdown)
-        gollum_output.create_namespace_overview(namespaces)
-        expect(gollum_output).to have_receive(:commit_revision).with(expected_body, :markdown)
-      end
-    end
-  end
-
-  describe :build_commit do
-    let(:page) do
-      Caramelize::Page.new( title: 'Feathered Dinosaurs',
-                message: 'Dinosaurs really had feathers, do not forget!',
-                time: Time.parse('2015-02-12'),
-                body: 'Dinosaurs are awesome and have feathers!',
-                author: OpenStruct.new(name: 'Jeff Goldblum', email: 'jeff.g@example.com') )
-    end
-
-    it 'builds commit hash' do
-      expected_hash = { message: 'Dinosaurs really had feathers, do not forget!',
-                         authored_date: Time.parse('2015-02-12'),
-                         committed_date: Time.parse('2015-02-12'),
-                         name: 'Jeff Goldblum',
-                         email: 'jeff.g@example.com' }
-      expect(gollum_output.send(:build_commit, page)).to eq expected_hash
-    end
-    context 'page has message' do
-      it 'uses page.title' do
-        expect(gollum_output.send(:build_commit, page)[:message]).to eq 'Dinosaurs really had feathers, do not forget!'
-      end
-    end
-    context 'page has no message' do
-      it 'should create message "Edit in page Feathered Dinosaurs"' do
-        page.message = ''
-        expect(gollum_output.send(:build_commit, page)[:message]).to eq 'Edit in page Feathered Dinosaurs'
-      end
-    end
-  end
-
-end