markdown_prawn 0.0.1.pre

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rake'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.pattern = './test/*.rb'
+  t.verbose = true
+end
+Rake::Task['test'].comment = "Test Markdown Prawn"
+
+task :default => [:test]

data/bin/md2pdf

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+#
+# Markdown to PDF by Ryan Stenhouse <ryan@ryanstenhouse.eu>
+# November 1st 2010
+#
+# Takes input from standard in, expected to be a markdown document
+# and renders a PDF to standard out.
+#
+root =  File.expand_path(File.dirname(__FILE__)+ '/../')
+load root + '/markdown_prawn.rb'
+content = $stdin.read
+puts MarkdownPrawn::StringParser.new(content).to_pdf.render

data/lib/markdown_fragments/heading_fragment.rb

@@ -0,0 +1,20 @@
+class HeadingFragment < MarkdownFragment
+  attr_accessor :level
+  
+    def render_on(pdf_object, options = {})
+      arguments = _default_render_options.merge(options)
+      pdf_object.move_down(@level * 2)
+      pdf_object.text @content.join(' '), arguments
+      pdf_object.move_down(@level * 2)
+    end
+
+  private
+
+    def _default_render_options
+      options = { :size => (40 - (8*@level)), :align => :left, :leading => 2, :weight => :bold }
+      if Prawn::VERSION =~ /^0.1/ || Prawn::VERSION =~ /^1/
+        options.merge({:inline_format => true})
+      end
+      options
+    end
+end

data/lib/markdown_fragments/horizontal_rule_fragment.rb

@@ -0,0 +1,25 @@
+class HorizontalRuleFragment < MarkdownFragment
+
+  def render_on(pdf_object, options = {})
+    pdf_object.move_down(3)
+    old_width = pdf_object.line_width
+    pdf_object.line_width = 3
+    pdf_object.horizontal_rule
+    pdf_object.stroke
+    pdf_object.line_width = old_width
+    pdf_object.move_down(3)
+  end
+
+private
+
+  def _default_render_options
+    options = { :size => 12, :align => :left, :leading => 2 }
+    if Prawn::VERSION =~ /^0.1/ || Prawn::VERSION =~ /^1/
+      options = options.merge({:inline_format => true})
+    else
+      options = options.merge({:inline_format => false})
+    end
+    options
+  end
+
+end

data/lib/markdown_fragments/image_fragment.rb

@@ -0,0 +1,25 @@
+require 'net/http'
+require 'tmpdir'
+
+class ImageFragment < MarkdownFragment
+  def render_on(pdf_object)
+    if is_remote_uri?
+      filename = @content.first.split('/').last
+      file_path = "#{Dir.tmpdir}/#{filename}"
+      content = Net::HTTP.get(URI.parse(@content.first))
+      File.open(file_path, 'w') do |f|
+        f.puts content
+      end
+    else
+      file_path = File.expand_path(@content.first)
+    end
+    pdf_object.image file_path
+  end
+
+  private
+
+  def is_remote_uri?
+    !/^(http:|https:)/.match(@content.first).nil?
+  end
+
+end

data/lib/markdown_fragments/links_reference_fragment.rb

@@ -0,0 +1,17 @@
+class LinksReferenceFragment < MarkdownFragment
+
+  def render_on(pdf_object)
+
+    pdf_object.move_down(10)
+    pdf_object.horizontal_rule
+    pdf_object.stroke
+    pdf_object.move_down(4)
+    pdf_object.text "Hyperlink References:"
+    pdf_object.move_down(4)
+    pdf_object.table @content do
+      cells.borders = []
+    end
+    pdf_object.move_down(4)
+  end
+
+end

data/lib/markdown_fragments/list_fragment.rb

@@ -0,0 +1,40 @@
+class ListFragment < MarkdownFragment
+  attr_accessor :ordered
+  
+  def render_on(pdf_object, options = {})
+    bullet = '• '
+    arguments = _default_render_options.merge(options)
+    width = ((pdf_object.bounds.width / 100) * 90)
+    data = []
+
+    @content.each_with_index do |item, i|
+      # Strip any un-needed white space
+      #
+      item = item.gsub(/\s\s+/,' ')
+      if ordered?
+        bullet = "#{i+1}."
+      end
+      data << [bullet,item]
+    end
+ 
+    pdf_object.table data, arguments.merge({:width => width}) do
+       cells.borders = []
+    end
+    pdf_object.move_down(5) 
+  end
+  
+  def ordered?
+    @ordered == true
+  end
+
+  private
+
+  def _default_render_options
+    options = {}
+    if Prawn::VERSION =~ /^0.1/ || Prawn::VERSION =~ /^1/
+      options = options.merge({:cell_style =>  { :inline_format => true}})
+    end
+    options
+  end  
+  
+end

data/lib/markdown_fragments/markdown_fragment.rb

@@ -0,0 +1,13 @@
+class MarkdownFragment
+  attr_accessor :content
+  
+  def initialize(content = [])
+    @content = content
+  end
+  
+  # Renders the current fragment on the supplied prawn PDF Object. By Default,
+  # it will just join content and add it as text - not too useful.
+  def render_on(pdf_object)
+    pdf_object.text @content.join(' ')
+  end
+end

data/lib/markdown_fragments/paragraph_fragment.rb

@@ -0,0 +1,21 @@
+class ParagraphFragment < MarkdownFragment
+
+  def render_on(pdf_object, options = {})
+    arguments = _default_render_options.merge(options)
+    pdf_object.move_down(3)
+    pdf_object.text @content.join(' '), arguments
+  end
+
+private
+
+  def _default_render_options
+    options = { :size => 12, :align => :left, :leading => 2 }
+    if Prawn::VERSION =~ /^0.1/ || Prawn::VERSION =~ /^1/
+      options = options.merge({:inline_format => true})
+    else
+      options = options.merge({:inline_format => false})
+    end
+    options
+  end
+
+end

data/lib/markdown_fragments.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/markdown_fragments/markdown_fragment.rb'
+require File.dirname(__FILE__) + '/markdown_fragments/paragraph_fragment.rb'
+require File.dirname(__FILE__) + '/markdown_fragments/heading_fragment.rb'
+require File.dirname(__FILE__) + '/markdown_fragments/list_fragment.rb'
+require File.dirname(__FILE__) + '/markdown_fragments/image_fragment.rb'
+require File.dirname(__FILE__) + '/markdown_fragments/horizontal_rule_fragment.rb'
+require File.dirname(__FILE__) + '/markdown_fragments/links_reference_fragment.rb'

data/lib/markdown_parser/file_parser.rb

@@ -0,0 +1,18 @@
+module MarkdownPrawn
+  class FileParser < Parser
+
+    # Give this the path to a file and (if it exists), it'll generate 
+    # a PDF version of the markdown there.
+    #
+    def initialize(file_path)
+      file_path = File.expand_path(file_path)
+      if !File.exist?(file_path)
+        raise Errno::ENOENT.new("#{file_path} could not be found") and return
+      else
+        @content = detab(IO.read(file_path).gsub(/\r\n?/, "\n")).split("\n")
+      end
+      super
+    end
+
+  end
+end

data/lib/markdown_parser/parser.rb

@@ -0,0 +1,213 @@
+require File.dirname(__FILE__) + '/../markdown_fragments.rb'
+
+module MarkdownPrawn
+
+# Horribly bodgy and wrong markdown parser which should just about do
+# for a proof of concept. Some of the code comes from mislav's original
+# BlueCloth since I cant find the source of a newer versoin.
+#
+class Parser
+  attr_accessor :links_list, :images_list, :document_structure
+
+  def initialize(document_structure = [])
+    @links_list = { :urls_seen => [], :object => LinksReferenceFragment.new }
+    @document_structure = []
+    @images_list = []
+  end
+
+  # Returns a Prawn::Document, accepts the same options as Prawn does when creating
+  # a new document, but defaults to creating pages in Portrait and at A4 size.
+  #
+  # Uses parse! rather than parse to ensure that the slate is always clean when
+  # generating the PDF.
+  #
+  def to_pdf(options = {})
+    parse!
+    options = options.merge({ :page_layout =>  :portrait, :page_size => 'A4' })
+    pdf = Prawn::Document.new(options)
+    @document_structure.each { |markdown_fragment| markdown_fragment.render_on(pdf) }
+    pdf
+  end
+
+  # Clears out the current sate of +@document_structure+ and then parses +@content+ content
+  #
+  def parse!
+    @document_structure = []
+    parse
+  end
+
+  def parse
+    paragraph = ParagraphFragment.new
+    list = ListFragment.new
+    in_list = false
+    @content.each_with_index do |line, index|
+      line = process_inline_formatting(line)
+ 
+      # Assume everything is part of a paragraph by default and
+      # add its content to the current in-scope paragraph object.
+      #
+      paragraph.content << line
+      if line == ""
+        unless paragraph.content.empty?
+          @document_structure << paragraph
+          paragraph = ParagraphFragment.new
+        end
+      end
+      
+      # Deal with inline headings
+      #
+      unless /^(#+)(\s?)\S/.match(line).nil?
+        paragraph.content = paragraph.content.delete_if { |i| i == line }
+        hashes = $1.dup
+        heading = HeadingFragment.new([line.gsub(hashes,'')])
+        heading.level = hashes.length
+        @document_structure << heading
+      end
+      
+      # Deal with Level 1 Headings
+      #
+      if !/^(=)+$/.match(line).nil?
+        paragraph.content = paragraph.content.delete_if do |item|
+          item == line || item == @content[index - 1]
+        end
+        heading = HeadingFragment.new([@content[index - 1]])
+        heading.level = 1
+        @document_structure << heading
+      end
+
+      # Deal with Level 2 Headings or horizontal rules.
+      #
+      if !/^(-)+$/.match(line).nil?
+        if @content[index - 1].strip == ''
+          # Assume it's a horizontal rule
+          #
+          paragraph.content = paragraph.content.delete_if { |i| i == line }
+          @document_structure << HorizontalRuleFragment.new
+        else
+          paragraph.content = paragraph.content.delete_if do |item|
+            item == line || item == @content[index - 1]
+          end
+          heading = HeadingFragment.new([@content[index - 1]])
+          heading.level = 2
+          @document_structure << heading
+        end
+      end
+
+      # Deal with all other kinds of horizontal rules
+      #
+      if !/^(\*+)(\s)?(\*+)(\s)?(\*+)/.match(line).nil? || !/^(-+)(\s)(-+)(\s)(-+)/.match(line).nil?
+        if @content[index - 1].strip == ''
+          paragraph.content = paragraph.content.delete_if { |i| i == line }
+          @document_structure << HorizontalRuleFragment.new
+        end
+      end
+
+      # Try to deal with lists.
+      #
+      if in_list
+        # We're in a list just now.
+        #
+
+        # Remove the content from the paragraph where it will have
+        # automatically been appended
+        #
+        paragraph.content = paragraph.content.delete_if { |i| i == line }
+
+        # Check to see if we've got a new list item.
+        #
+        if (!/^\s+\*\s/.match(line).nil? || !/^\s+\d+\.\s/.match(line).nil?)
+
+          # Find out if this new list item is for a different type of list 
+          # and deal with that before adding the new list item.
+          #
+          if list.ordered? && !/^\s+\*\s/.match(line).nil?
+            @document_structure << list
+            list = ListFragment.new
+         elsif !list.ordered? && !/^\s+\d+\.\s/.match(line).nil?
+            @document_structure << list
+            list = ListFragment.new
+            list.ordered = true
+         end
+
+          # Remove the list style and add the new list item.
+          #
+          list.content << line.sub(/^\s+\*\s/,'').sub(/^\s+\d+\.\s/,'')
+
+        else
+          # If this line isn't a new list item, then it's a continuation for the current
+          # list item.
+          #
+          list.content[-1] += line
+        end
+
+        # If the current line is empty, then we're done with the list.
+        #
+        if line == '' 
+          @document_structure << list
+          list = ListFragment.new
+          in_list = false
+        end
+      else
+        # Not currently in a list, but we've detected a list item
+        #
+        if (!/^\s+\*\s/.match(line).nil? || !/^\s+\d+\.\s/.match(line).nil?)
+          ordered = false
+          ordered = true if !/^\s+\d+\.\s/.match(line).nil?
+          list = ListFragment.new
+          list.ordered = ordered
+          list.content << line.sub(/^\s+\*\s/,'').sub(/^\s+\d+\.\s/,'')
+          paragraph.content = paragraph.content.delete_if { |i| i == line }
+          in_list = true
+        end
+      end
+
+
+      # Deal with a link reference by adding it ot the list of references
+      #
+      if !/^(\[\S+\]){1}:\s(\S+)\s?(.+)?/.match(line).nil?
+        reference, url, title = $1, $2, $3
+        paragraph.content = paragraph.content.delete_if { |i| i == line }
+        @links_list[:urls_seen] << url 
+        @links_list[:object].content <<  [ reference, url, "#{title}" ]
+      end
+
+      # Deal with inline images
+      #
+      line.scan(/(?:^|\s)?(\!\[(?:.+?)\]\((.+?)\))/) do |val|
+        line.gsub(val[0],'')
+        @document_structure << ImageFragment.new([val[1]])
+      end
+    end
+    if !list.content.empty? && ! @document_structure.include?(list)
+      @document_structure << list
+      list = ListFragment.new
+    end
+    @document_structure << paragraph unless paragraph.content == ''
+    @document_structure << @links_list[:object] if !@links_list[:urls_seen].empty?
+  end
+
+  private
+
+  def detab(string, tabwidth = 2)
+    string.split("\n").collect { |line|
+      line.gsub(/(.*?)\t/) do
+        $1 + ' ' * (tabwidth - $1.length % tabwidth)
+      end
+    }.join("\n")
+  end
+
+  # Only do Inline formatting for versions of Prawn which support it.
+  #
+  def process_inline_formatting(str)
+    breg = [ %r{ \b(\_\_) (\S|\S.*?\S) \1\b }x, %r{ (\*\*) (\S|\S.*?\S) \1 }x ]
+    ireg = [ %r{ (\*) (\S|\S.*?\S) \1 }x, %r{ \b(_) (\S|\S.*?\S) \1\b }x ]
+    if Prawn::VERSION =~ /^0.1/ || Prawn::VERSION =~ /^1/
+      str.gsub(breg[0], %{<b>\\2</b>} ).gsub(breg[1], %{<b>\\2</b>} ).gsub(ireg[0], %{<i>\\2</i>} ).gsub(ireg[1], %{<i>\\2</i>} )
+    else
+      str.gsub(breg[0], %{\\2} ).gsub(breg[1], %{\\2} ).gsub(ireg[0], %{\\2} ).gsub(ireg[1], %{\\2} )
+    end
+  end
+
+end
+
+end

data/lib/markdown_parser/string_parser.rb

@@ -0,0 +1,11 @@
+module MarkdownPrawn
+  class StringParser < Parser
+    # Take a string or an object which responds to to_s and attemps to
+    # parse markdown in it.
+    def initialize(string_to_convert)
+      string_to_convert = string_to_convert.to_s
+      @content = detab(string_to_convert.gsub(/\r\n?/, "\n")).split("\n")
+      super
+    end 
+  end
+end

data/lib/markdown_parser.rb

@@ -0,0 +1,5 @@
+require File.dirname(__FILE__) + '/markdown_fragments.rb'
+require File.dirname(__FILE__) + '/markdown_parser/parser.rb'
+require File.dirname(__FILE__) + '/markdown_parser/file_parser.rb'
+require File.dirname(__FILE__) + '/markdown_parser/string_parser.rb'
+

data/lib/markdown_prawn_exceptions.rb

@@ -0,0 +1,6 @@
+module MarkdownPrawn
+  module Exceptions
+    class InvalidMarkdownFile < Exception; end
+    class InvalidDestinationPath < Exception; end
+  end
+end

data/markdown_prawn.gemspec

@@ -0,0 +1,21 @@
+description = "Markdown Parawn is a library and an executable strip which allow you to generate a PDF from any valid Markdown." 
+Gem::Specification.new do |spec|
+  spec.name = "markdown_prawn"
+  spec.version = '0.0.1.pre'
+  spec.platform = Gem::Platform::RUBY
+  spec.files =  Dir.glob("{bin,lib,test}/**/**/*") +
+                      ["Rakefile", "markdown_prawn.gemspec"]
+  spec.require_path = "lib"
+  spec.required_ruby_version = '>= 1.8.7'
+  spec.required_rubygems_version = ">= 1.3.6"
+
+  spec.test_files = Dir[ "test/*_test.rb" ]
+  spec.has_rdoc = false
+  spec.author = "Ryan Stenhouse"
+  spec.email = "ryan@ryanstenhouse.eu"
+  spec.rubyforge_project = "markdown_prawn"
+  spec.add_dependency('prawn', '~>0.10')
+  spec.homepage = "http://ryanstenhouse.eu"
+  spec.summary = description
+  spec.description = description
+end

data/test/fixtures/ordered_lists.mdown

@@ -0,0 +1,3 @@
+  1. One Item
+  2. Two Item
+  3. Three Item

data/test/fixtures/paragraphs.mdown

@@ -0,0 +1,8 @@
+Paragaphs are a fundamental part of Markdown and 
+this makes sure that I can process them properly
+even with
+strange wrapping and
+other
+annoyances
+
+This should be seen as the second paragraph.

data/test/fixtures/unordered_lists.mdown

@@ -0,0 +1,3 @@
+  * Bulleted
+  * List
+  * Support

data/test/helper.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'prawn'
+require 'test/unit'
+require File.dirname(__FILE__) + '/../markdown_prawn.rb'

data/test/test_lists_handling.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/helper.rb'
+
+class TestListsHandling < Test::Unit::TestCase
+
+  def setup
+    @unordered = MarkdownPrawn::FileParser.new(File.expand_path(File.dirname(__FILE__) + '/fixtures/unordered_lists.mdown'))
+    @ordered = MarkdownPrawn::FileParser.new(File.expand_path(File.dirname(__FILE__) + '/fixtures/ordered_lists.mdown'))
+  end
+
+  def test_document_structure_is_correct_for_unordered_lists
+    @unordered.parse
+    assert !@unordered.document_structure.empty?
+    assert_equal ListFragment, @unordered.document_structure[0].class
+    assert_equal false, @unordered.document_structure[0].ordered?
+  end
+
+  def test_document_structure_is_correct_for_ordered_lists
+    @ordered.parse
+    assert !@ordered.document_structure.empty?
+    assert_equal ListFragment, @ordered.document_structure[0].class
+    assert_equal true, @ordered.document_structure[0].ordered?
+  end
+
+end

data/test/test_paragraph_handling.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/helper.rb'
+
+class TestParagraphHandling < Test::Unit::TestCase
+  
+  def setup
+    @paragraphs = MarkdownPrawn::FileParser.new(File.expand_path(File.dirname(__FILE__) + '/fixtures/paragraphs.mdown'))
+  end
+
+  def test_document_structure_is_correct_for_paragraphs
+    @paragraphs.parse
+    assert !@paragraphs.document_structure.empty?
+    assert_equal 2, @paragraphs.document_structure.nitems
+    @paragraphs.document_structure.each do |fragment|
+      assert_equal ParagraphFragment, fragment.class
+    end
+  end
+
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification 
+name: markdown_prawn
+version: !ruby/object:Gem::Version 
+  hash: 961915968
+  prerelease: true
+  segments: 
+  - 0
+  - 0
+  - 1
+  - pre
+  version: 0.0.1.pre
+platform: ruby
+authors: 
+- Ryan Stenhouse
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-01 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: prawn
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 0
+        - 10
+        version: "0.10"
+  type: :runtime
+  version_requirements: *id001
+description: Markdown Parawn is a library and an executable strip which allow you to generate a PDF from any valid Markdown.
+email: ryan@ryanstenhouse.eu
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/md2pdf
+- lib/markdown_fragments.rb
+- lib/markdown_parser/parser.rb
+- lib/markdown_parser/file_parser.rb
+- lib/markdown_parser/string_parser.rb
+- lib/markdown_parser.rb
+- lib/markdown_fragments/paragraph_fragment.rb
+- lib/markdown_fragments/markdown_fragment.rb
+- lib/markdown_fragments/image_fragment.rb
+- lib/markdown_fragments/heading_fragment.rb
+- lib/markdown_fragments/links_reference_fragment.rb
+- lib/markdown_fragments/list_fragment.rb
+- lib/markdown_fragments/horizontal_rule_fragment.rb
+- lib/markdown_prawn_exceptions.rb
+- test/test_lists_handling.rb
+- test/test_paragraph_handling.rb
+- test/fixtures/ordered_lists.mdown
+- test/fixtures/paragraphs.mdown
+- test/fixtures/unordered_lists.mdown
+- test/helper.rb
+- Rakefile
+- markdown_prawn.gemspec
+has_rdoc: true
+homepage: http://ryanstenhouse.eu
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 57
+      segments: 
+      - 1
+      - 8
+      - 7
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: markdown_prawn
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Markdown Parawn is a library and an executable strip which allow you to generate a PDF from any valid Markdown.
+test_files: []
+