gimli 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Fredrik Wallgren
+
+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.textile

@@ -0,0 +1,60 @@
+h1. gimli - utility for converting markup to pdf
+
+h2. Description
+
+Gimli is a utility for converting markup to pdf files. Useful for reports and such things.
+It's inspired by the markup convertion in "gollum":https://github.com/github/gollum
+It works by converting the markup to html using "PDFKit":https://github.com/jdpace/PDFKit
+The markup is converted to html using "github/markup":https://github.com/github/markup
+
+h3. Markup
+
+Markup files may be written in any format supported by GitHub-Markup (except roff).
+
+h2. Installation
+
+The best way to install Gimli is with RubyGems:
+
+bc. $ [sudo] gem install gimli
+
+You can install from source:
+
+bc. $ cd gimli/
+$ bundle
+$ rake install
+
+h2. Running
+
+The standard way to run gimli is to go to a folder with markup files and running
+
+bc. $ gimli
+
+To apply some style to the pdf or override the standard style add a css file in the directory named @gimli.css@ or use the @-s@ flag to point out another css file.
+
+Standard behavior is for gimli to output the files in the current directory. To override this use the @-o@ flag to point out another output directory. Gimli tries to create it if it doesn't exist.
+
+Run @gimli -h@ for a full list of options available
+
+h2. Syntax highlighting
+
+In page files you can get automatic syntax highlighting for a wide range of languages by using the following syntax:
+
+If you want to be able to use the syntax highlightning you have to install "pygments":http://pygments.org
+
+Example installation on Ubuntu
+
+bc. $ sudo aptitude install python-setuptools
+$ sudo easy_install pygments
+
+bc. ```ruby
+  def foo
+    puts 'bar'
+  end
+```
+
+The block must start with three backticks (as the first characters on the line). After that comes the name of the language that is contained by the block. The language must be one of the short name lexer strings supported by Pygments. See the list of lexers for valid options.
+
+If the block contents are indented two spaces or one tab, then that whitespace will be ignored (this makes the blocks easier to read in plaintext).
+
+The block must end with three backticks as the first characters on a line.
+

data/bin/gimli

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__)) + '/../lib/')
+
+require 'gimli'
+
+Gimli.process!
+

data/config/style.css

@@ -0,0 +1,109 @@
+body
+{
+  font-family: "Trebuchet MS", "Lucida Sans Unicode", "Lucida Sans", Arial, sans-serif;
+  font-size: 12px;
+}
+
+/* Code */
+code, tt
+{
+  background-color: #f8f8f8;
+  border: 1px solid #dedede;
+  font-size: 13px;
+  padding: 1px 5px;
+
+  -moz-border-radius: 3px;
+  -webkit-border-radius: 3px;
+  border-radius: 3px;
+}
+
+.highlight pre, pre
+{
+  background-color: #f8f8f8;
+  border: 1px solid #ccc;
+  font-size: 13px;
+  line-height: 19px;
+  overflow: auto;
+  padding: 6px;
+
+  -moz-border-radius: 3px;
+  -webkit-border-radius: 3px;
+  border-radius: 3px;
+}
+
+pre code, pre tt
+{
+  background-color: transparent;
+  border: none;
+}
+
+.highlight .hll { background-color: #ffffcc }
+.highlight .c { color: #8f5902; font-style: italic } /* Comment */
+.highlight .err { color: #a40000; border: 1px solid #ef2929 } /* Error */
+.highlight .g { color: #000000 } /* Generic */
+.highlight .k { color: #204a87; font-weight: bold } /* Keyword */
+.highlight .l { color: #000000 } /* Literal */
+.highlight .n { color: #000000 } /* Name */
+.highlight .o { color: #ce5c00; font-weight: bold } /* Operator */
+.highlight .x { color: #000000 } /* Other */
+.highlight .p { color: #000000; font-weight: bold } /* Punctuation */
+.highlight .cm { color: #8f5902; font-style: italic } /* Comment.Multiline */
+.highlight .cp { color: #8f5902; font-style: italic } /* Comment.Preproc */
+.highlight .c1 { color: #8f5902; font-style: italic } /* Comment.Single */
+.highlight .cs { color: #8f5902; font-style: italic } /* Comment.Special */
+.highlight .gd { color: #a40000 } /* Generic.Deleted */
+.highlight .ge { color: #000000; font-style: italic } /* Generic.Emph */
+.highlight .gr { color: #ef2929 } /* Generic.Error */
+.highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */
+.highlight .gi { color: #00A000 } /* Generic.Inserted */
+.highlight .go { color: #000000; font-style: italic } /* Generic.Output */
+.highlight .gp { color: #8f5902 } /* Generic.Prompt */
+.highlight .gs { color: #000000; font-weight: bold } /* Generic.Strong */
+.highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
+.highlight .gt { color: #a40000; font-weight: bold } /* Generic.Traceback */
+.highlight .kc { color: #204a87; font-weight: bold } /* Keyword.Constant */
+.highlight .kd { color: #204a87; font-weight: bold } /* Keyword.Declaration */
+.highlight .kn { color: #204a87; font-weight: bold } /* Keyword.Namespace */
+.highlight .kp { color: #204a87; font-weight: bold } /* Keyword.Pseudo */
+.highlight .kr { color: #204a87; font-weight: bold } /* Keyword.Reserved */
+.highlight .kt { color: #204a87; font-weight: bold } /* Keyword.Type */
+.highlight .ld { color: #000000 } /* Literal.Date */
+.highlight .m { color: #0000cf; font-weight: bold } /* Literal.Number */
+.highlight .s { color: #4e9a06 } /* Literal.String */
+.highlight .na { color: #c4a000 } /* Name.Attribute */
+.highlight .nb { color: #204a87 } /* Name.Builtin */
+.highlight .nc { color: #000000 } /* Name.Class */
+.highlight .no { color: #000000 } /* Name.Constant */
+.highlight .nd { color: #5c35cc; font-weight: bold } /* Name.Decorator */
+.highlight .ni { color: #ce5c00 } /* Name.Entity */
+.highlight .ne { color: #cc0000; font-weight: bold } /* Name.Exception */
+.highlight .nf { color: #000000 } /* Name.Function */
+.highlight .nl { color: #f57900 } /* Name.Label */
+.highlight .nn { color: #000000 } /* Name.Namespace */
+.highlight .nx { color: #000000 } /* Name.Other */
+.highlight .py { color: #000000 } /* Name.Property */
+.highlight .nt { color: #204a87; font-weight: bold } /* Name.Tag */
+.highlight .nv { color: #000000 } /* Name.Variable */
+.highlight .ow { color: #204a87; font-weight: bold } /* Operator.Word */
+.highlight .w { color: #f8f8f8; text-decoration: underline } /* Text.Whitespace */
+.highlight .mf { color: #0000cf; font-weight: bold } /* Literal.Number.Float */
+.highlight .mh { color: #0000cf; font-weight: bold } /* Literal.Number.Hex */
+.highlight .mi { color: #0000cf; font-weight: bold } /* Literal.Number.Integer */
+.highlight .mo { color: #0000cf; font-weight: bold } /* Literal.Number.Oct */
+.highlight .sb { color: #4e9a06 } /* Literal.String.Backtick */
+.highlight .sc { color: #4e9a06 } /* Literal.String.Char */
+.highlight .sd { color: #8f5902; font-style: italic } /* Literal.String.Doc */
+.highlight .s2 { color: #4e9a06 } /* Literal.String.Double */
+.highlight .se { color: #4e9a06 } /* Literal.String.Escape */
+.highlight .sh { color: #4e9a06 } /* Literal.String.Heredoc */
+.highlight .si { color: #4e9a06 } /* Literal.String.Interpol */
+.highlight .sx { color: #4e9a06 } /* Literal.String.Other */
+.highlight .sr { color: #4e9a06 } /* Literal.String.Regex */
+.highlight .s1 { color: #4e9a06 } /* Literal.String.Single */
+.highlight .ss { color: #4e9a06 } /* Literal.String.Symbol */
+.highlight .bp { color: #3465a4 } /* Name.Builtin.Pseudo */
+.highlight .vc { color: #000000 } /* Name.Variable.Class */
+.highlight .vg { color: #000000 } /* Name.Variable.Global */
+.highlight .vi { color: #000000 } /* Name.Variable.Instance */
+.highlight .il { color: #0000cf; font-weight: bold } /* Literal.Number.Integer.Long */
+

data/lib/gimli.rb

@@ -0,0 +1,33 @@
+require 'gimli/version'
+require 'gimli/setup'
+require 'gimli/file'
+require 'gimli/converter'
+require 'gimli/albino'
+
+module Gimli
+
+  # Starts the processing of selected files
+  def self.process!
+    @files = []
+    if ARGV.flags.file?
+      Gimli.load_file(ARGV.flags.file)
+    else
+      Dir.glob("*").each do |file|
+        Gimli.load_file(file)
+      end
+    end
+
+    @files.each do |file|
+      converter = Converter.new file
+      converter.convert!
+    end
+  end
+
+  # Add file to the files to be converted if it's valid
+  # @param [String] file
+  def self.load_file(file)
+    file = File.new file
+    @files << file if file.valid?
+  end
+end
+

data/lib/gimli/albino.rb

@@ -0,0 +1,7 @@
+require 'albino/multi'
+
+# Use Albino Multi
+class Gimli::Albino < Albino::Multi
+  self.bin = ::Albino::Multi.bin
+end
+

data/lib/gimli/converter.rb

@@ -0,0 +1,75 @@
+require 'fileutils'
+
+require 'pdfkit'
+
+require 'gimli/markup'
+
+module Gimli
+
+  # The class that communicates with PDFKit
+  class Converter
+
+    # Initialize the converter with a File
+    # @param [Gimli::File] file The file to convert
+    def initialize(file)
+      @file = file
+    end
+
+    # Convert the file and save it as a PDF file
+    def convert!
+      markup = Markup.new @file
+      html = markup.render
+
+      kit = pdf_kit(html)
+
+      kit.to_file(output_file)
+    end
+
+    # Load the pdfkit with html
+    # @param [String] html
+    # @return [PDFKit]
+    def pdf_kit(html)
+      kit = PDFKit.new(html)
+
+      load_stylesheets kit
+
+      kit
+    end
+
+    # Load the stylesheets to pdfkit loads the default and the user selected if any
+    # @param [PDFKit] kit
+    def load_stylesheets(kit)
+      # Load standard stylesheet
+      style = ::File.expand_path("../../../config/style.css", __FILE__)
+      kit.stylesheets << style
+
+      stylesheet
+
+      kit.stylesheets << stylesheet if ::File.exists?(stylesheet)
+    end
+
+    # Returns the selected stylesheet. Defaults to ./gimli.css
+    # @return [String]
+    def stylesheet
+      stylesheet = 'gimli.css'
+      stylesheet = ARGV.flags.stylesheet if ARGV.flags.stylesheet?
+      stylesheet
+    end
+
+    # Returns the directory where to save the output. Defaults to ./
+    # @return [String]
+    def output_dir
+      output_dir = Dir.getwd
+      output_dir = ARGV.flags.outputdir if ARGV.flags.outputdir?
+      FileUtils.mkdir_p(output_dir) unless ::File.directory?(output_dir)
+      output_dir
+    end
+
+    # Generate the name of the output file
+    # @return [String]
+    def output_file
+      ::File.join(output_dir, "#{@file.name}.pdf")
+    end
+  end
+end
+

data/lib/gimli/file.rb

@@ -0,0 +1,65 @@
+module Gimli
+
+  # Class used to load files and determine if they are valid
+  class File
+    attr_reader :filename, :name, :data, :format
+
+    # Accepted formats
+    FORMATS = [:markdown, :textile, :rdoc, :org, :creole, :rest, :asciidoc, :pod, :roff, :mediawiki]
+
+    # Initializes the file object. Only reads contents if it's a valid file
+    def initialize(filename)
+      @filename = filename
+      extension = ::File.extname(@filename)
+      @format = load_format(extension)
+      @name = ::File.basename(@filename, extension)
+      @data = ::File.open(@filename, 'rb') { |f| f.read } if valid? && ::File.exists?(@filename)
+    end
+
+    # Is the file valid
+    # @return [Boolean]
+    def valid?
+      valid_format? @format
+    end
+
+    # Converts the format to a symbol if it's a valid format nil otherwise
+    # @param [String] format
+    # @return [Symbol|nil]
+    def load_format(format)
+      case format
+        when /(md|mkdn?|mdown|markdown)$/i
+          :markdown
+        when /(textile)$/i
+          :textile
+        when /(rdoc)$/i
+          :rdoc
+        when /(org)$/i
+          :org
+        when /(creole)$/i
+          :creole
+        when /(re?st(\.txt)?)$/i
+          :rest
+        when /(asciidoc)$/i
+          :asciidoc
+        when /(pod)$/i
+          :pod
+        when /(\d)$/i
+          :roff
+        when /(media)?wiki$/i
+          :mediawiki
+        else
+          nil
+      end
+    end
+
+    # Checks if the format is a valid one
+    # @param [String] format
+    # @return [Boolean]
+    def valid_format?(format)
+      return false if format.nil?
+
+      FORMATS.include? format.to_sym
+    end
+  end
+end
+

data/lib/gimli/markup.rb

@@ -0,0 +1,268 @@
+require 'digest/sha1'
+require 'cgi'
+
+require 'github/markup'
+require 'nokogiri'
+
+module Gimli
+
+  # Contains functionality to render html from a markup file
+  class Markup
+    # Initialize a new Markup object.
+    #
+    # @param [Gimli::File] file  The Gimli::File to process
+    # @return [Gimli::Markup]
+    def initialize(file)
+      @filename = file.filename
+      @name = file.name
+      @data = file.data
+      @format = file.format
+      @tagmap = {}
+      @codemap = {}
+      @premap = {}
+    end
+
+    # Render the content with Gollum wiki syntax on top of the file's own
+    # markup language.
+    #
+    # @return [String] The formatted data
+    def render
+      data = extract_code(@data.dup)
+      data = extract_tags(data)
+      begin
+        data = GitHub::Markup.render(@filename, data)
+        if data.nil?
+          raise "There was an error converting #{@name} to HTML."
+        end
+      rescue Object => e
+        data = %{<p class="gimli-error">#{e.message}</p>}
+      end
+      data = process_tags(data)
+      data = process_code(data)
+
+      doc  = Nokogiri::HTML::DocumentFragment.parse(data)
+      yield doc if block_given?
+      data = doc_to_html(doc)
+
+      data.gsub!(/<p><\/p>/, '')
+      data
+    end
+
+    def doc_to_html(doc)
+      doc.to_xhtml(:save_with => Nokogiri::XML::Node::SaveOptions::AS_XHTML)
+    end
+
+    # Extract all tags into the tagmap and replace with placeholders.
+    #
+    # @param [String] data - The raw string data.
+    # @return [String] Returns the placeholder's string data.
+    def extract_tags(data)
+      data.gsub!(/(.?)\[\[(.+?)\]\]([^\[]?)/m) do
+        if $1 == "'" && $3 != "'"
+          "[[#{$2}]]#{$3}"
+        elsif $2.include?('][')
+          if $2[0..4] == 'file:'
+            pre = $1
+            post = $3
+            parts = $2.split('][')
+            parts[0][0..4] = ""
+            link = "#{parts[1]}|#{parts[0].sub(/\.org/,'')}"
+            id = Digest::SHA1.hexdigest(link)
+            @tagmap[id] = link
+            "#{pre}#{id}#{post}"
+          else
+            $&
+          end
+        else
+          id = Digest::SHA1.hexdigest($2)
+          @tagmap[id] = $2
+          "#{$1}#{id}#{$3}"
+        end
+      end
+      data
+    end
+
+    # Process all tags from the tagmap and replace the placeholders with the
+    # final markup.
+    #
+    # @param [String] data - The data (with placeholders)
+    # @return [String] Returns the marked up String data.
+    def process_tags(data)
+      @tagmap.each do |id, tag|
+        data.gsub!(id, process_tag(tag))
+      end
+      data
+    end
+
+    # Process a single tag into its final HTML form.
+    #
+    # @param [String] tag The String tag contents (the stuff inside the double brackets).
+    # @return [String] Returns the String HTML version of the tag.
+    def process_tag(tag)
+      if html = process_image_tag(tag)
+        html
+      elsif html = process_file_link_tag(tag)
+        html
+      end
+    end
+
+    # Attempt to process the tag as an image tag.
+    #
+    # @param [String] tag The String tag contents (the stuff inside the double brackets).
+    # @return [String|nil] Returns the String HTML if the tag is a valid image tag or nil if it is not.
+    def process_image_tag(tag)
+      parts = tag.split('|')
+      return if parts.size.zero?
+
+      name  = parts[0].strip
+      path  = name
+
+      if path
+        opts = parse_image_tag_options(tag)
+
+        containered = false
+
+        classes = [] # applied to whatever the outermost container is
+        attrs   = [] # applied to the image
+
+        align = opts['align']
+        if opts['float']
+          containered = true
+          align ||= 'left'
+          if %w{left right}.include?(align)
+            classes << "float-#{align}"
+          end
+        elsif %w{top texttop middle absmiddle bottom absbottom baseline}.include?(align)
+          attrs << %{align="#{align}"}
+        elsif align
+          if %w{left center right}.include?(align)
+            containered = true
+            classes << "align-#{align}"
+          end
+        end
+
+        if width = opts['width']
+          if width =~ /^\d+(\.\d+)?(em|px)$/
+            attrs << %{width="#{width}"}
+          end
+        end
+
+        if height = opts['height']
+          if height =~ /^\d+(\.\d+)?(em|px)$/
+            attrs << %{height="#{height}"}
+          end
+        end
+
+        if alt = opts['alt']
+          attrs << %{alt="#{alt}"}
+        end
+
+        attr_string = attrs.size > 0 ? attrs.join(' ') + ' ' : ''
+
+        if opts['frame'] || containered
+          classes << 'frame' if opts['frame']
+          %{<span class="#{classes.join(' ')}">} +
+          %{<span>} +
+          %{<img src="#{path}" #{attr_string}/>} +
+          (alt ? %{<span>#{alt}</span>} : '') +
+          %{</span>} +
+          %{</span>}
+        else
+          %{<img src="#{path}" #{attr_string}/>}
+        end
+      end
+    end
+
+    # Parse any options present on the image tag and extract them into a
+    # Hash of option names and values.
+    #
+    # @param [String] tag The String tag contents (the stuff inside the double brackets).
+    # @return [Hash]
+    # Returns the options Hash:
+    #   key - The String option name.
+    #   val - The String option value or true if it is a binary option.
+    def parse_image_tag_options(tag)
+      tag.split('|')[1..-1].inject({}) do |memo, attr|
+        parts = attr.split('=').map { |x| x.strip }
+        memo[parts[0]] = (parts.size == 1 ? true : parts[1])
+        memo
+      end
+    end
+
+    # Extract all code blocks into the codemap and replace with placeholders.
+    #
+    # @param [String] data The raw String data.
+    # @return [String] Returns the placeholder'd String data.
+    def extract_code(data)
+      data.gsub!(/^``` ?([^\r\n]+)?\r?\n(.+?)\r?\n```\r?$/m) do
+        id     = Digest::SHA1.hexdigest($2)
+        cached = check_cache(:code, id)
+        @codemap[id] = cached   ?
+          { :output => cached } :
+          { :lang => $1, :code => $2 }
+        id
+      end
+      data
+    end
+
+    # Process all code from the codemap and replace the placeholders with the
+    # final HTML.
+    #
+    # @param [String] data The String data (with placeholders).
+    # @return [String] Returns the marked up String data.
+    def process_code(data)
+      return data if data.nil? || data.size.zero? || @codemap.size.zero?
+
+      blocks    = []
+      @codemap.each do |id, spec|
+        next if spec[:output] # cached
+
+        code = spec[:code]
+        if code.lines.all? { |line| line =~ /\A\r?\n\Z/ || line =~ /^(  |\t)/ }
+          code.gsub!(/^(  |\t)/m, '')
+        end
+
+        blocks << [spec[:lang], code]
+      end
+
+      highlighted = begin
+        blocks.size.zero? ? [] : Gimli::Albino.colorize(blocks)
+      rescue ::Albino::ShellArgumentError, ::Albino::TimeoutExceeded,
+               ::Albino::MaximumOutputExceeded
+        []
+      end
+
+      @codemap.each do |id, spec|
+        body = spec[:output] || begin
+          if (body = highlighted.shift.to_s).size > 0
+            update_cache(:code, id, body)
+            body
+          else
+            "<pre><code>#{CGI.escapeHTML(spec[:code])}</code></pre>"
+          end
+        end
+        data.gsub!(id, body)
+      end
+
+      data
+    end
+
+    # Hook for getting the formatted value of extracted tag data.
+    #
+    # @param [Symbol] type Symbol value identifying what type of data is being extracted.
+    # @param [String] id String SHA1 hash of original extracted tag data.
+    # @return [String] Returns the String cached formatted data, or nil.
+    def check_cache(type, id)
+    end
+
+    # Hook for caching the formatted value of extracted tag data.
+    #
+    # @param [Symbol] type Symbol value identifying what type of data is being extracted.
+    # @param [String] id String SHA1 hash of original extracted tag data.
+    # @param [String] data The String formatted value to be cached.
+    # @return [nil]
+    def update_cache(type, id, data)
+    end
+  end
+end
+

data/lib/gimli/setup.rb

@@ -0,0 +1,21 @@
+require 'optiflag'
+
+# Set up the flags available
+module Gimli extend OptiFlagSet
+  optional_flag 'file' do
+    description 'The file to convert if you do not want to convert all in the current folder'
+    alternate_forms 'f'
+  end
+  optional_flag 'outputdir' do
+    description 'The directory to save parsed files if you do not want to use the current folder. The directory is created if it does not exist'
+    alternate_forms 'o'
+  end
+  optional_flag 'stylesheet' do
+    description 'The stylesheet to use to override the standard'
+    alternate_forms 's'
+  end
+  usage_flag 'h', 'help', '?'
+
+  and_process!
+end
+

data/lib/gimli/version.rb

@@ -0,0 +1,6 @@
+module Gimli
+
+  Version = "0.1.0"
+
+end
+

data/spec/fixtures/code_block.textile

@@ -0,0 +1,8 @@
+a
+
+```ruby
+x = 1
+```
+
+b
+

data/spec/gimli/converter_spec.rb

@@ -0,0 +1,71 @@
+require './spec/spec_helper'
+
+require './lib/gimli'
+
+describe Gimli::Converter do
+  it 'should give the correct output_file with none given' do
+    file = Gimli::File.new 'fake'
+    name = 'my_file'
+    mock(file).name { name }
+
+    converter = Gimli::Converter.new file
+    mock(converter).output_dir { Dir.getwd }
+
+    converter.output_file.should == File.join(Dir.getwd, "#{name}.pdf")
+  end
+
+  it 'should give the correct output_file with one given' do
+    file = Gimli::File.new 'fake'
+    name = 'my_file'
+    mock(file).name { name }
+
+    converter = Gimli::Converter.new file
+    mock(converter).output_dir { '/tmp/out' }
+
+    converter.output_file.should == "/tmp/out/#{name}.pdf"
+  end
+
+  it 'should give the correct output_dir when none given' do
+    dir = Dir.getwd
+
+    file = Gimli::File.new 'fake'
+    converter = Gimli::Converter.new file
+
+    converter.output_dir.should == dir
+  end
+
+  it 'should give the correct output_dir when given' do
+    dir = '/tmp/out'
+
+    file = Gimli::File.new 'fake'
+    converter = Gimli::Converter.new file
+
+    mock(ARGV).flags.mock!.outputdir? { true }
+    mock(ARGV).flags.mock!.outputdir { dir }
+    mock(File).directory?(dir) { true }
+
+    converter.output_dir.should == dir
+  end
+
+  it 'should use stylesheet if exists in folder' do
+    file = Gimli::File.new 'fake'
+    converter = Gimli::Converter.new file
+
+    mock(ARGV).flags.mock!.stylesheet? { false }
+
+    converter.stylesheet.should == 'gimli.css'
+  end
+
+  it 'should use stylesheet if given' do
+    file = Gimli::File.new 'fake'
+    converter = Gimli::Converter.new file
+
+    style = '/home/me/gimli/my-style.css'
+
+    mock(ARGV).flags.mock!.stylesheet? { true }
+    mock(ARGV).flags.mock!.stylesheet { style }
+
+    converter.stylesheet.should == style
+  end
+end
+

data/spec/gimli/file_spec.rb

@@ -0,0 +1,26 @@
+require './spec/spec_helper'
+
+require './lib/gimli'
+
+describe Gimli::File do
+  it 'should recognize valid format' do
+    file = Gimli::File.new 'fake'
+    file.valid_format?('textile').should be_true
+  end
+
+  it 'should recognize invalid format' do
+    file = Gimli::File.new 'fake'
+    file.valid_format?('abc123').should be_false
+  end
+
+  it 'should recognize nil as invalid format' do
+    file = Gimli::File.new 'fake'
+    file.valid_format?(nil).should be_false
+  end
+
+  it 'should give the name as the filename without the extension' do
+    file = Gimli::File.new 'test.txt'
+    file.name.should == File.basename(file.filename, File.extname(file.filename))
+  end
+end
+

data/spec/gimli/markup_spec.rb

@@ -0,0 +1,21 @@
+require './spec/spec_helper'
+
+require './lib/gimli'
+
+describe Gimli::Markup do
+
+  it 'should give correct code block' do
+
+    output = "<p>a</p>\n<div class=\"highlight\"><pre>" +
+             "<span class=\"n\">x</span> <span class=\"o\">=</span> " +
+             "<span class=\"mi\">1</span>\n</pre>\n</div>\n\n<p>b</p>"
+
+    file = Gimli::File.new File.expand_path('../../fixtures/code_block.textile', __FILE__)
+    markup = Gimli::Markup.new file
+
+    markup.render.should == output
+  end
+
+
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+RSpec.configure do |config|
+  config.mock_with :rr
+end
+

metadata

@@ -0,0 +1,221 @@
+--- !ruby/object:Gem::Specification
+name: gimli
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Fredrik Wallgren
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-04-29 00:00:00.000000000 +02:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: github-markup
+  requirement: &16957440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *16957440
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: &16957020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *16957020
+- !ruby/object:Gem::Dependency
+  name: RedCloth
+  requirement: &16956600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *16956600
+- !ruby/object:Gem::Dependency
+  name: org-ruby
+  requirement: &16956180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *16956180
+- !ruby/object:Gem::Dependency
+  name: creole
+  requirement: &16955760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *16955760
+- !ruby/object:Gem::Dependency
+  name: wikicloth
+  requirement: &16955340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *16955340
+- !ruby/object:Gem::Dependency
+  name: albino
+  requirement: &16954920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *16954920
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: &16954500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *16954500
+- !ruby/object:Gem::Dependency
+  name: wkhtmltopdf-binary
+  requirement: &16985560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *16985560
+- !ruby/object:Gem::Dependency
+  name: pdfkit
+  requirement: &16985140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *16985140
+- !ruby/object:Gem::Dependency
+  name: optiflag
+  requirement: &16984720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *16984720
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &16984300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *16984300
+- !ruby/object:Gem::Dependency
+  name: rr
+  requirement: &16983880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *16983880
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &16983460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *16983460
+description: Utility for converting markup files to pdf files. Useful for reports
+  etc.
+email: fredrik.wallgren@gmail.com
+executables:
+- gimli
+extensions: []
+extra_rdoc_files:
+- README.textile
+- LICENSE
+files:
+- bin/gimli
+- lib/gimli/version.rb
+- lib/gimli/albino.rb
+- lib/gimli/file.rb
+- lib/gimli/markup.rb
+- lib/gimli/setup.rb
+- lib/gimli/converter.rb
+- lib/gimli.rb
+- spec/spec_helper.rb
+- spec/fixtures/code_block.textile
+- spec/gimli/converter_spec.rb
+- spec/gimli/markup_spec.rb
+- spec/gimli/file_spec.rb
+- config/style.css
+- LICENSE
+- README.textile
+has_rdoc: true
+homepage: https://github.com/walle/gimli
+licenses: []
+post_install_message: 
+rdoc_options:
+- --charset=UTF-8
+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: gimli
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Utility for converting markup files to pdf files.
+test_files: []