srdperu-prawn-format 0.1.1.2 → 0.1.2

data/manual/pdf.rb

@@ -1,204 +0,0 @@
-$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
-require 'prawn'
-require 'prawn/format'
-require 'prawn/format/version'
-require 'coderay'
-
-def process_style(document, style, content, line_number)
-  content = process_substitutions(content)
-
-  case style
-  when "h1"        then h1(document, content)
-  when "h2"        then h2(document, content)
-  when "p"         then paragraph(document, content)
-  when "fp"        then paragraph(document, content, false)
-  when "ul"        then start_list(document)
-  when "li"        then list_item(document, content)
-  when "/ul"       then end_list(document)
-  when "page"      then new_page(document)
-  when "highlight" then highlight(document, content)
-  when "hr"        then horiz_rule(document)
-  when "center"    then center(document, content)
-  else warn "unknown style #{style.inspect}"
-  end
-
-rescue Exception => err
-  puts "[error occurred while processing line ##{line_number}]"
-  raise
-end
-
-def process_substitutions(content)
-  content.
-    gsub(/%FORMAT:VERSION%/, Prawn::Format::Version::STRING).
-    gsub(/%NOW%/, Time.now.utc.strftime("%e %B %Y at %H:%M UTC")).
-    gsub(/%PDF\{(.*?)\}HTML\{(.*?)\}END%/, '\\1')
-end
-
-def center(document, content)
-  padding(document, :clear => true)
-  document.text(content, :plain => false, :align => :center)
-  padding(document)
-end
-
-def horiz_rule(document)
-  padding(document, :clear => true)
-  document.stroke_color "000000"
-  document.stroke_horizontal_rule
-  padding(document)
-end
-
-def h1(document, content)
-  clear_padding!
-  document.text "<h1>#{content}</h1>"
-  document.stroke_color "000080"
-  document.stroke_horizontal_rule
-  padding(document, :size => document.font_size * 2)
-end
-
-def h2(document, content)
-  clear_padding!
-  document.text "<h2>#{content}</h2>"
-  document.stroke_color "000080"
-  document.stroke_horizontal_rule
-  padding(document, :size => document.font_size * 2)
-end
-
-def paragraph(document, content, indent=true)
-  return unless content.strip.length > 0
-  clear_padding!
-  document.text "#{content}", :align => :justify
-  padding(document, :size => document.font_size / 2)
-end
-
-def start_list(document)
-  padding(document)
-end
-
-def list_item(document, content)
-  clear_padding!
-
-  indent_b = document.font_size * 3
-  indent   = document.font_size * 4
-
-  document.start_new_page if document.y < document.font_size
-  y = document.y - document.bounds.absolute_bottom
-  document.text "&bull;", :at => [indent_b, y - document.font.ascender]
-  document.layout(content, :align => :justify) do |helper|
-    while !helper.done?
-      y = helper.fill(indent, y, document.bounds.width-indent, :height => document.y)
-      if helper.done?
-        document.y = y + document.bounds.absolute_bottom
-      else
-        document.start_new_page
-        y = document.y - document.bounds.absolute_bottom
-      end
-    end
-  end
-
-  padding(document, :size => document.font_size / 4)
-end
-
-def end_list(document)
-  padding(document)
-end
-
-def new_page(document)
-  document.start_new_page
-  clear_padding!
-end
-
-def highlight(document, content)
-  file, syntax = content.split(/,/)
-  analyzed = CodeRay.scan(File.read(File.join(File.dirname(__FILE__), file)), syntax.to_sym)
-  html = "<pre>" + analyzed.html + "</pre>"
-
-  padding(document, :size => document.font_size * 2, :clear => true)
-  y = document.y - document.bounds.absolute_bottom
-  start_y = y + document.font_size
-
-  indent = document.font_size * 2
-
-  document.layout(html) do |helper|
-    while !helper.done?
-      y = helper.fill(indent, y, document.bounds.width-indent*2, :height => document.y)
-      if helper.done?
-        document.y = y + document.bounds.absolute_bottom
-      else
-        document.start_new_page
-        y = document.y - document.bounds.absolute_bottom
-      end
-    end
-  end
-
-  document.stroke_color "a0a0a0"
-  document.rectangle [document.font_size, start_y], bounds.width - document.font_size*2, (start_y - y)
-  document.stroke
-
-  padding(document, :size => document.font_size)
-end
-
-def clear_padding!
-  @last_padding = nil
-end
-
-# This padding stuff is mostly here just so that adjacent vertical spaces
-# will collapse.
-def padding(document, options={})
-  size = options[:size] || document.font_size
-
-  if @last_padding
-    full_size = [@last_padding, size].max
-    size = full_size - @last_padding
-    @last_padding = full_size
-  else
-    @last_padding = size
-  end
-
-  document.y -= size
-  clear_padding! if options[:clear]
-end
-
-SERIF_FONT  = "/Library/Fonts/Baskerville.dfont"
-
-Prawn::Document.generate("prawn-format.pdf", :compress => true) do
-  if File.exists?(SERIF_FONT)
-    font_families["Baskerville"] = {
-      :normal      => { :file => SERIF_FONT, :font => 1 },
-      :italic      => { :file => SERIF_FONT, :font => 2 },
-      :bold        => { :file => SERIF_FONT, :font => 4 }, # semi-bold, not bold
-      :bold_italic => { :file => SERIF_FONT, :font => 3 }
-    }
-    font "Baskerville", :size => 14
-  else
-    warn "Baskerville font is preferred for the manual, but could not be found. Using Times-Roman."
-    font "Times-Roman", :size => 14
-  end
-
-  tags :h1 => { :font_size => "2em", :font_weight => :bold, :color => "navy" },
-       :h2 => { :font_size => "1.5em", :font_weight => :bold, :color => "navy" },
-       :about => { :font_size => "80%", :color => "808080", :font_style => :italic }
-
-  styles :no  => { :color => "gray" },
-         :c   => { :color => "#666" },
-         :s   => { :color => "#d20" },
-         :dl  => { :color => "black" },
-         :co  => { :color => "#036", :font_weight => :bold },
-         :pc  => { :color => "#038", :font_weight => :bold },
-         :sy  => { :color => "#A60" },
-         :r   => { :color => "#080" },
-         :i   => { :color => "#00D", :font_weight => :bold },
-         :idl => { :color => "#888", :font_weight => :bold },
-         :dl  => { :color => "#840", :font_weight => :bold }
-
-  File.open("#{File.dirname(__FILE__)}/manual.txt") do |source|
-    number = 0
-    source.each_line do |line|
-      number += 1
-      line.chomp!
-      next if line.length == 0
-
-      style, content = line.match(/^(\S+)\.\s*(.*)/)[1,2]
-      process_style(self, style, content, number)
-    end
-  end
-end

data/spec/layout_builder_spec.rb

@@ -1,27 +0,0 @@
-# encoding: utf-8
-
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")      
-
-describe "when building a text layout" do     
-
-  before(:each) { create_pdf }
-
-  it "should understand common tags by default" do
-    layout = new_layout("<b>hi</b> <i>there</i>")
-    assert_nothing_raised { lines(layout) }
-  end
-
-  private
-
-    def new_layout(text, opts={})
-      Prawn::Format::LayoutBuilder.new(@pdf, text, opts)
-    end
-
-    def lines(layout)
-      lines = []
-      while (line = layout.next)
-        lines << line
-      end
-      return lines
-    end
-end

data/spec/lexer_spec.rb

@@ -1,91 +0,0 @@
-# encoding: utf-8
-
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")      
-
-def lexer_for(text)
-  Prawn::Format::Lexer.new(text)
-end
-
-describe "when scanning text" do     
-
-  it "should scan a single text word as a chunk" do
-    lexer = lexer_for("christmas")
-    assert_equal({ :type => :text, :text => ["christmas"] }, lexer.next)
-  end
-
-  it "should delimit multiple words by spaces" do
-    lexer = lexer_for("a christmas carol by charles dickens")
-    assert_equal({ :type => :text, :text => ["a", " ", "christmas", " ", "carol", " ", "by", " ", "charles", " ", "dickens"] }, lexer.next)
-  end
-
-  it "should delimit multiple words by hyphens" do
-    lexer = lexer_for("christmas-carol-thingy")
-    assert_equal({ :type => :text, :text => ["christmas", "-", "carol", "-", "thingy"] }, lexer.next)
-  end
-
-  it "should delimit multiple words by em-dashes" do
-    lexer = lexer_for("christmas—carol—thingy")
-    assert_equal({ :type => :text, :text => ["christmas", "—", "carol", "—", "thingy"] }, lexer.next)
-  end
-
-  it "should report nil as end-of-stream after scanning" do
-    lexer = lexer_for("a christmas carol by charles dickens")
-    assert_not_nil lexer.next
-    assert_nil lexer.next
-    assert_nil lexer.next
-  end
-
-end
-
-describe "when scanning XML entities" do
-
-  Prawn::Format::Lexer::ENTITY_MAP.each do |key, value|
-    it "should map #{key} to #{value}" do
-      lexer = lexer_for("&#{key};")
-      assert_equal({ :type => :text, :text => [value] }, lexer.next)
-    end
-  end
-
-  it "should convert decimal entities to utf-8" do
-    lexer = lexer_for('—')
-    assert_equal({ :type => :text, :text => ["\xe2\x80\x94"] }, lexer.next)
-  end
-
-  it "should convert hexadecimal entities to utf-8" do
-    lexer = lexer_for('—')
-    assert_equal({ :type => :text, :text => ["\xe2\x80\x94"] }, lexer.next)
-  end
-
-  it "should raise InvalidFormat on unrecognized entities" do
-    lexer = lexer_for('&bogus;')
-    assert_raises(Prawn::Format::Lexer::InvalidFormat) do
-      lexer.next
-    end
-  end
-
-end
-
-describe "when scanning tags" do
-
-  it "should return tag with empty options for a tag with no options" do
-    lexer = lexer_for("<test>")
-    assert_equal({ :type => :open, :tag => :test, :options => {} }, lexer.next)
-  end
-
-  it "should scan tags with different delimiters consistently" do
-    lexer = lexer_for("<test first=january second=\"february\" third='march'>")
-    assert_equal({ :type => :open, :tag => :test, :options => { :first => "january", :second => "february", :third => "march" } }, lexer.next)
-  end
-
-  it "should scan closing tag" do
-    lexer = lexer_for("</test>")
-    assert_equal({ :type => :close, :tag => :test }, lexer.next)
-  end
-
-  it "should scan self-closing tag as two tokens" do
-    lexer = lexer_for("<test/>")
-    assert_equal({ :type => :open, :tag => :test, :options => {} }, lexer.next)
-    assert_equal({ :type => :close, :tag => :test }, lexer.next)
-  end
-
-end

data/spec/parser_spec.rb

@@ -1,103 +0,0 @@
-# encoding: utf-8
-
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")      
-
-describe "when parsing formatted text" do     
-
-  before(:each) { create_pdf }
-
-  it "should raise TagError when it does not recognize a tag" do
-    parser = parser_for("<hello>")
-    assert_raises(Prawn::Format::Parser::TagError) { parser.next }
-  end
-
-  it "should raise TagError when it encounters an unmatched closing tag" do
-    parser = parser_for("</b>")
-    assert_raises(Prawn::Format::Parser::TagError) { parser.next }
-  end
-
-  it "should raise TagError when it a tag is closed with the wrong type" do
-    parser = parser_for("<b></i>")
-    assert_raises(Prawn::Format::Parser::TagError) { parse(parser) }
-  end
-
-  it "should apply styles defined for tag" do
-    parser = parser_for("a<b>c</b>d")
-    weights = [:normal, :bold, :bold, :bold, :normal]
-    assert_equal weights, parse(parser).map { |i| i.state.font_weight }
-  end
-
-  it "should honor custom tag styles" do
-    parser = parser_for("a<k>c</k>d", :tags => { :k => { :text_decoration => :underline } })
-    decorations = [:none, :underline, :underline, :underline, :none]
-    assert_equal decorations, parse(parser).map { |i| i.state.text_decoration }
-  end
-
-  it "should honor custom style classes" do
-    parser = parser_for("a<j class='test'>c</j>d", :tags => { :j => {} }, :styles => { :test => { :text_decoration => :underline } })
-    decorations = [:none, :underline, :underline, :underline, :none]
-    assert_equal decorations, parse(parser).map { |i| i.state.text_decoration }
-  end
-
-  it "should parse delimited text as separate instructions" do
-    parser = parser_for("a b-cd")
-    bits = ["a", " ", "b", "-", "cd"]
-    assert_equal bits, parse(parser).map { |i| i.text }
-  end
-
-  it "should return nil after last token is parsed" do
-    parser = parser_for("a")
-    assert_not_nil parser.next
-    assert_nil parser.next
-    assert_nil parser.next
-  end
-
-  it "should report eos? at end of stream" do
-    parser = parser_for("a")
-    assert !parser.eos?
-    parser.next
-    assert parser.eos?
-  end
-
-  it "should return next instruction without consuming it when peek is called" do
-    parser = parser_for("a")
-    assert_equal "a", parser.peek.text
-    assert !parser.eos?
-    assert_equal "a", parser.next.text
-    assert parser.eos?
-  end
-
-  it "should save instruction for next call when push is called" do
-    parser = parser_for("a")
-    k = parser.next
-    assert parser.eos?
-    parser.push(k)
-    assert !parser.eos?
-    assert_equal k, parser.next
-    assert parser.eos?
-  end
-
-  it "should map meta styles to styles on the tag" do
-    parser = parser_for("<k name='bob'>a</k>", :tags => { :k => { :meta => { :name => :__name__ } } })
-    i = parser.next
-    assert_equal "bob", i.tag[:style][:__name__]
-  end
-
-  private
-
-    def parser_for(text, opts={})
-      tags = @pdf.tags.merge(opts[:tags] || {})
-      styles = @pdf.styles.merge(opts[:styles] || {})
-      @parser = Prawn::Format::Parser.new(@pdf, text, opts.merge(:styles => styles, :tags => tags))
-    end
-
-    def parse(parser)
-      instructions = []
-
-      while instr = parser.next
-        instructions << instr
-      end
-
-      return instructions
-    end
-end

data/spec/spec_helper.rb

@@ -1,24 +0,0 @@
-# encoding: utf-8
-
-puts "Prawn-Format specs: Running on Ruby Version: #{RUBY_VERSION}"
-
-require "rubygems"
-require "test/spec"                                                
-require "mocha"
-require "prawn"
-$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib') 
-$LOAD_PATH << File.join(Prawn::BASEDIR, 'vendor','pdf-inspector','lib')
-require "prawn/format"
-
-Prawn.debug = true
-
-gem 'pdf-reader', ">=0.7.3"
-require "pdf/reader"          
-require "pdf/inspector"
-
-def create_pdf(klass=Prawn::Document)
-  @pdf = klass.new(:left_margin   => 0,
-                   :right_margin  => 0,
-                   :top_margin    => 0,
-                   :bottom_margin => 0)
-end