prawn 0.13.0 → 2.4.0

data/manual/example_file.rb

@@ -1,116 +0,0 @@
-# encoding: utf-8
-
-module Prawn
-  
-  # The Prawn::ExampleFile class is a utility class to ease the manipulation
-  # and extraction of source code and comments from the actual example files
-  #
-  class ExampleFile
-    attr_reader :package, :filename
-    
-    # Stores the file data, filename and parent, which will be either an
-    # ExampleSection or an ExamplePackage.
-    #
-    # Available boolean options are:
-    # 
-    # <tt>:eval_source</tt>:: Evals the example source code (default: true)
-    # <tt>:full_source</tt>:: Extract the full source code when true. Extract
-    # only the code between the generate block when false (default: false)
-    #
-    def initialize(parent, filename, options={})
-      @parent   = parent.is_a?(String) ? ExamplePackage.new(parent) : parent
-      
-      @filename = filename
-      @data     = read_file(@parent.folder_name, filename)
-      
-      @options  = {:eval_source => true, :full_source => false}.merge(options)
-    end
-    
-    # Return the example source code excluding the initial comments and
-    # require calls
-    #
-    def full_source
-      @data.gsub(/# encoding.*?\n.*require.*?\n\n/m, "\n").strip
-    end
-    
-    # Return the example source contained inside the first generate block or
-    # the full source if no generate block is found
-    #
-    def generate_block_source
-      block = @data.slice(/\w+\.generate.*? do\n(.*)end/m, 1)
-        
-      return full_source unless block
-      
-      block.gsub(/^( ){2}/, "")
-    end
-    
-    # Return either the full_source or the generate_block_source according
-    # to the options
-    #
-    def source
-      @options[:full_source] ? full_source : generate_block_source
-    end
-    
-    # Return true if the example source should be evaluated inline within
-    # the manual according to the options
-    #
-    def eval?
-      @options[:eval_source]
-    end
-    
-    # Retrieve the comments between the encoding declaration and the require
-    # call for example_helper.rb
-    #
-    # Then removes the '#' signs, reflows the line breaks and return the result
-    #
-    def introduction_text
-      intro = @data.slice(/# encoding.*?\n(.*)require File\.expand_path/m, 1)
-      intro.gsub!(/\n# (?=\S)/m, ' ')
-      intro.gsub!(/^#/, '')
-      intro.gsub!("\n", "\n\n")
-      intro.rstrip!
-      intro
-    end
-    
-    # Returns a human friendly version of the example file name
-    #
-    def name
-      @name ||= @filename[/(.*)\.rb/, 1].gsub("_", " ").capitalize
-    end
-    
-    # Returns this example's parent original folder name
-    #
-    def parent_folder_name
-      @parent.folder_name
-    end
-    
-    # Returns the human friendly version of this example parent name
-    #
-    def parent_name
-      @parent.name
-    end
-    
-    # Renders this example to a pdf
-    #
-    def render(pdf)
-      pdf.render_example(self)
-    end
-    
-  private
-  
-    # Read the data from a file in a given package
-    #
-    def read_file(folder_name, filename)
-      data = File.read(File.expand_path(File.join(
-        File.dirname(__FILE__), folder_name, filename)))
-      
-      # XXX If we ever have manual files with source encodings other than
-      # UTF-8, we will need to fix this to work on Ruby 1.9.
-      if data.respond_to?(:encode!)
-        data.encode!("UTF-8")
-      end
-      data
-    end
-    
-  end
-end

data/manual/example_package.rb

@@ -1,53 +0,0 @@
-# encoding: utf-8
-
-module Prawn
-  
-  # The Prawn::ExamplePackage class is a utility class to handle the packaging
-  # of individual examples within a hierarchy when building the manual
-  #
-  class ExamplePackage
-    attr_reader :intro_block, :folder_name
-    
-    def initialize(folder_name)
-      @folder_name = folder_name
-      @hierarchy = []
-    end
-    
-    # Stores a new ExampleSection in the hierarchy and yields it to a block
-    #
-    def section(name)
-      s = ExampleSection.new(self, name)
-      yield s
-      @hierarchy << s
-    end
-    
-    # Stores a new ExampleFile in the hierarchy
-    #
-    def example(filename, options={})
-      @hierarchy << ExampleFile.new(self, "#{filename}.rb", options)
-    end
-    
-    # Stores a block with code to be evaluated when rendering the package cover
-    #
-    def intro(&block)
-      @intro_block = block
-    end
-    
-    # Returns a human friendly version of the package name
-    #
-    def name
-      @name ||= @folder_name.gsub("_", " ").capitalize
-    end
-    
-    # Renders a cover page for the package to a pdf and iterates the examples
-    # hierarchy delegating the examples and sections to be rendered as well
-    #
-    def render(pdf)
-      pdf.render_package_cover(self)
-      
-      @hierarchy.each do |node|
-        node.render(pdf)
-      end
-    end
-  end
-end

data/manual/example_section.rb

@@ -1,46 +0,0 @@
-# encoding: utf-8
-
-module Prawn
-  
-  # The Prawn::ExampleSection class is a utility class to handle sections
-  # of related examples within an ExamplePackage
-  #
-  class ExampleSection
-    attr_reader :name
-    
-    def initialize(package, name)
-      @package  = package
-      @name     = name
-      @examples = []
-    end
-    
-    # Stores a new ExampleFile in the examples list
-    #
-    def example(filename, options={})
-      @examples << ExampleFile.new(self, "#{filename}.rb", options)
-    end
-
-    # Returns this example's package original folder name
-    #
-    def folder_name
-      @package.folder_name
-    end
-    
-    # Returns the human friendly version of this section's package name
-    #
-    def package_name
-      @package.name
-    end
-    
-    # Renders the section to a pdf and iterates the examples list delegating the
-    # examples to be rendered as well
-    #
-    def render(pdf)
-      pdf.render_section(self)
-      
-      @examples.each do |example|
-        example.render(pdf)
-      end
-    end
-  end
-end

data/manual/manual/cover.rb

@@ -1,35 +0,0 @@
-# encoding: utf-8
-#
-# Prawn manual how to read this manual page. 
-#
-require File.expand_path(File.join(File.dirname(__FILE__),
-                                   %w[.. example_helper]))
-
-filename = File.basename(__FILE__).gsub('.rb', '.pdf')
-Prawn::Example.generate(filename) do
-  move_down 200
-
-  image "#{Prawn::DATADIR}/images/prawn.png",
-        :scale => 0.9,
-        :at => [10, cursor]
-        
-  formatted_text_box([ {:text => "Prawn\n",
-                        :styles => [:bold],
-                        :size => 100}
-                     ], :at => [170, cursor - 50])
-
-  formatted_text_box([ {:text => "by example",
-                        :font => 'Courier',
-                        :size => 60}
-                     ], :at => [170, cursor - 160])
-
-  #long git commit hash
-  #commit = `git show --pretty=%H`
-  #short git commit hash
-  commit = `git show --pretty=%h`
-  formatted_text_box([  {:text => "Last Update: #{Time.now.strftime("%Y-%m-%d")}\n
-                                   git commit: #{commit}",
-                         :size => 12}
-                    ],   :at => [390, cursor - 620])
-  
-end

data/manual/manual/foreword.rb

@@ -1,85 +0,0 @@
-# encoding: utf-8
-#
-# Prawn manual foreword page.
-#
-require File.expand_path(File.join(File.dirname(__FILE__),
-                                   %w[.. example_helper]))
-
-filename = File.basename(__FILE__).gsub('.rb', '.pdf')
-Prawn::Example.generate(filename) do
-  header("Foreword, by Gregory Brown")
-  prose %{
-    Back in 2008, the state of PDF generation in
-    Ruby was grim. The best general purpose tool that existed was
-    Austin Ziegler's PDF::Writer, which was an ambitious but
-    painfully unsustainable project. Despite years of hard work
-    from Austin, the code was slow, buggy, and hard to
-    understand. All of those things made it very difficult
-    to extend with the many features that its users needed,
-    and so it gradually turned into abandonware.
-
-    Because I had a lot of work that depended on PDF generation
-    I eventually volunteered to become the new maintainer of
-    PDF::Writer. In the first couple months after I got commit bit, I
-    managed to get out a couple minor releases that fixed
-    known issues that had been left unresolved for years,
-    and that made some people happy. However, the cliff
-    ahead of me was far too steep to climb: without a
-    major redesign, PDF::Writer would never support proper
-    internationalization, would not easily be ported to
-    Ruby 1.9, and would remain painfully slow for many
-    ordinary tasks.
-
-    Against my better judgement, but out of desperation, I
-    was convinced that the only way forward was to attempt the
-    big rewrite. It is good that I didn't realize
-    how impossible that task would be, because otherwise,
-    I would have never started working
-    on Prawn. But with the support of dozens of Ruby community
-    members who had graciously crowd-funded this project
-    so that I could take a few months off of work to
-    kick start it (long before Kickstarter existed!), Prawn
-    was born.
-
-    The PDF specification is over 1300 pages long, and despite
-    being the original author and lead maintainer of this
-    project from 2008-2011, I still know relatively little
-    about the intricacies of the format. I relied heavily
-    on the insights of our core team and casual contributors
-    to educate me on various issues, and to help develop
-    nearly every feature of this project. From day one,
-    Prawn was a stone soup in which virtually all of the
-    tasty bits were provided by the community at large --
-    my most significant contribution was to simply
-    keep stirring the pot. Now, the pot mostly stirs itself,
-    with the occasional nudge from one of the core
-    team members (usually Brad or James, but everyone
-    has pitched in at one time or the other.)
-
-    Although Prawn bears no resemblance to PDF::Writer, this library
-    is most certainly its spiritual successor. That means that between
-    Austin's efforts and that of the Prawn team, we've been
-    trying to solve the PDF problem comfortably in Ruby for
-    nearly a decade now. This manual will help you decide for
-    yourself whether we've managed to finally overcome that
-    challenge or not.
-
-    I sincerely hope that a few years down the line, someone else
-    comes along and makes something brand new and exciting that
-    blows Prawn out of the water and onto the barbeque. But until
-    that happens, what you'll find here is a very powerful
-    PDF generation library that has a great team supporting it,
-    and I suspect it will stay that way for the forseeable future.
-
-    Happy Hacking!
-
-    -greg
-
-    PS: I cannot be possibly be more grateful for the time, money,
-    code, and knowledge that the Ruby community has invested in
-    this project. Whether you're a core team member or someone
-    who filed a single thoughtful bug report, your efforts are
-    what kept me motivated throughout the years that I spent working
-    on this project.
-  }
-end

data/manual/manual/manual.rb

@@ -1,35 +0,0 @@
-# encoding: utf-8
-#
-# Generates the Prawn by example manual.
-#
-
-Encoding.default_external = "UTF-8" if defined? Encoding
-
-require File.expand_path(File.join(File.dirname(__FILE__),
-                                   %w[.. example_helper]))
-
-Prawn::Example.generate("manual.pdf",
-                        :optimize_objects => true,
-                        :skip_page_creation => true,
-                        :page_size => "FOLIO") do
-
-  load_page "cover"
-  load_page "foreword"
-  load_page "how_to_read_this_manual"
-
-  # Core chapters
-  load_package "basic_concepts"
-  load_package "graphics"
-  load_package "text"
-  load_package "bounding_box"
-
-  # Remaining chapters
-  load_package "layout"
-  load_package "images"
-  load_package "table"
-  load_package "document_and_page_options"
-  load_package "outline"
-  load_package "repeatable_content"
-  load_package "templates"
-  load_package "security"
-end

data/manual/syntax_highlight.rb

@@ -1,52 +0,0 @@
-# encoding: utf-8
-
-require "coderay"
-
-# Registers a to_prawn method on CodeRay. It returns an array of hashes to be
-# used with formatted_text.
-#
-# Usage:
-#
-# CodeRay.scan(string, :ruby).to_prawn
-#
-class PrawnEncoder < CodeRay::Encoders::Encoder
-  register_for :to_prawn
-
-  COLORS = { :default           => "FFFFFF",
-             
-             :comment           => "AEAEAE",
-             :constant          => "88A5D2",
-             :instance_variable => "E8ED97",
-             :integer           => "C8FF0E",
-             :float             => "C8FF0E",
-             :inline_delimiter  => "EF804F",  # #{} within a string
-             :keyword           => "FEE100",
-             
-             # BUG: There appear to be some problem with this token. Method
-             #      definitions are considered as ident tokens
-             #
-             :method            => "FF5C00",
-             :string            => "56D65E",
-             :symbol            => "C8FF0E" 
-           }
-
-  def setup(options)
-    super
-    @out  = []
-    @open = []
-  end
-
-  def text_token(text, kind)
-    color = COLORS[kind] || COLORS[@open.last] || COLORS[:default]
-    
-    @out << {:text => text, :color => color}
-  end
-
-  def begin_group(kind)
-    @open << kind
-  end
-
-  def end_group(kind)
-    @open.pop
-  end
-end

data/manual/table/basic_block.rb

@@ -1,53 +0,0 @@
-# encoding: utf-8
-#
-# All of the previous styling options we've seen deal with all the table cells
-# at once.
-#
-# With initializer blocks we may deal with specific cells.
-# A block passed to one of the table methods (<code>Prawn::Table.new</code>,
-# <code>Prawn::Document#table</code>, <code>Prawn::Document#make_table</code>)
-# will be called after cell setup but before layout. This is a very flexible way
-# to specify styling and layout constraints.
-#
-# Just like the <code>Prawn::Document.generate</code> method, the table
-# initializer blocks may be used with and without a block argument.
-#
-# The table class has three methods that are handy within an initializer block:
-# <code>cells</code>, <code>rows</code> and <code>columns</code>. All three
-# return an instance of <code>Prawn::Table::Cells</code> which represents
-# a selection of cells.
-#
-# <code>cells</code> return all the table cells, while <code>rows</code> and
-# <code>columns</code> accept a number or a range as argument which returns a
-# single row/column or a range of rows/columns respectively. (<code>rows</code>
-# and <code>columns</code> are also aliased as <code>row</code> and
-# <code>column</code>)
-#
-# The <code>Prawn::Table::Cells</code> class also defines <code>rows</code> and
-# <code>columns</code> so they may be chained to narrow the selection of cells.
-#
-# All of the cell styling options we've seen on previous examples may be set as
-# properties of the selection of cells.
-#
-require File.expand_path(File.join(File.dirname(__FILE__),
-                                   %w[.. example_helper]))
-
-filename = File.basename(__FILE__).gsub('.rb', '.pdf')
-Prawn::Example.generate(filename) do
-  data = [ ["Header",           "A " * 5, "B"],
-           ["Data row",         "C",      "D " * 5],
-           ["Another data row", "E",      "F"]]
-  
-  table(data) do
-    cells.padding = 12
-    cells.borders = []
-    
-    row(0).borders      = [:bottom]
-    row(0).border_width = 2
-    row(0).font_style   = :bold
-    
-    columns(0..1).borders = [:right]
-    
-    row(0).columns(0..1).borders = [:bottom, :right]
-  end
-end

data/manual/table/before_rendering_page.rb

@@ -1,26 +0,0 @@
-# encoding: utf-8
-#
-# <code>Prawn::Table#initialize</code> takes a
-# <code>:before_rendering_page</code> argument, to adjust the way an entire page
-# of table cells is styled. This allows you to do things like draw a border
-# around the entire table as displayed on a page.
-#
-# The callback is passed a Cells object that is numbered based on the order of
-# the cells on the page (e.g., the first row on the page is
-# <code>cells.row(0)</code>).
-#
-require File.expand_path(File.join(File.dirname(__FILE__),
-                                   %w[.. example_helper]))
-
-filename = File.basename(__FILE__).gsub('.rb', '.pdf')
-Prawn::Example.generate(filename) do
-  table([["foo", "bar", "baz"]] * 40) do |t|
-    t.cells.border_width = 1
-    t.before_rendering_page do |page|
-      page.row(0).border_top_width       = 3
-      page.row(-1).border_bottom_width   = 3
-      page.column(0).border_left_width   = 3
-      page.column(-1).border_right_width = 3
-    end
-  end
-end

data/manual/table/cell_border_lines.rb

@@ -1,24 +0,0 @@
-# encoding: utf-8
-#
-# The <code>border_lines</code> option accepts an array with the styles of the
-# border sides. The default is <code>[:solid, :solid, :solid, :solid]</code>.
-#
-# <code>border_lines</code> must be set to an array.
-#
-require File.expand_path(File.join(File.dirname(__FILE__),
-                                   %w[.. example_helper]))
-
-filename = File.basename(__FILE__).gsub('.rb', '.pdf')
-Prawn::Example.generate(filename) do
-  data =  [ ["Look at how the cell border lines can be mixed", "", ""],
-            ["dotted top border", "", ""],
-            ["solid right border", "", ""],
-            ["dotted bottom border", "", ""],
-            ["dashed left border", "", ""]
-          ]
-  
-  text "Cell :border_lines => [:dotted, :solid, :dotted, :dashed]"
-  
-  table(data, :cell_style => 
-    { :border_lines => [:dotted, :solid, :dotted, :dashed] })
-end

data/manual/table/cell_borders_and_bg.rb

@@ -1,31 +0,0 @@
-# encoding: utf-8
-#
-# The <code>borders</code> option accepts an array with the border sides that
-# will be drawn. The default is <code>[:top, :bottom, :left, :right]</code>.
-#
-# <code>border_width</code> may be set with a numeric value.
-#
-# Both <code>border_color</code> and <code>background_color</code> accept an
-# HTML like RGB color string ("FF0000")
-#
-require File.expand_path(File.join(File.dirname(__FILE__),
-                                   %w[.. example_helper]))
-
-filename = File.basename(__FILE__).gsub('.rb', '.pdf')
-Prawn::Example.generate(filename) do
-  data = [ ["Look at how the cells will look when styled", "", ""],
-           ["They probably won't look the same", "", ""]
-         ]
-  
-  { :borders => [:top, :left],
-    :border_width => 3,
-    :border_color => "FF0000"}.each do |property, value|
-      
-      text "Cell #{property}: #{value.inspect}"
-      table(data, :cell_style => {property => value})
-      move_down 20
-  end
-  
-  text "Cell background_color: FFFFCC"
-  table(data, :cell_style => {:background_color => "FFFFCC"})
-end

data/manual/table/cell_dimensions.rb

@@ -1,30 +0,0 @@
-# encoding: utf-8
-#
-# To style all the table cells you can use the <code>:cell_style</code> option
-# with the table methods. It accepts a hash with the cell style options.
-#
-# Some straightforward options are <code>width</code>, <code>height</code>,
-# and <code>padding</code>. All three accept numeric values to set the property.
-#
-# <code>padding</code> also accepts a four number array that defines the padding
-# in a CSS like syntax setting the top, right, bottom, left sequentially. The
-# default is 5pt for all sides.
-#
-require File.expand_path(File.join(File.dirname(__FILE__),
-                                   %w[.. example_helper]))
-
-filename = File.basename(__FILE__).gsub('.rb', '.pdf')
-Prawn::Example.generate(filename) do
-  data = [ ["Look at how the cells will look when styled", "", ""],
-           ["They probably won't look the same", "", ""]
-         ]
-  
-  {:width => 160, :height => 50, :padding => 12}.each do |property, value|
-    text "Cell's #{property}: #{value}"
-    table(data, :cell_style => {property => value})
-    move_down 20
-  end
-  
-  text "Padding can also be set with an array: [0, 0, 0, 30]"
-  table(data, :cell_style => {:padding => [0, 0, 0, 30]})
-end

data/manual/table/cell_text.rb

@@ -1,38 +0,0 @@
-# encoding: utf-8
-#
-# Text cells accept the following options: <code>align</code>,
-# <code>font</code>, <code>font_style</code>, <code>inline_format</code>,
-# <code>kerning</code>, <code>leading</code>, <code>min_font_size</code>,
-# <code>overflow</code>, <code>rotate</code>, <code>rotate_around</code>,
-# <code>single_line</code>, <code>size</code>, <code>text_color</code>,
-# and <code>valign</code>.
-#
-# Most of these style options are direct translations from the text methods
-# styling options.
-#
-require File.expand_path(File.join(File.dirname(__FILE__),
-                                   %w[.. example_helper]))
-
-filename = File.basename(__FILE__).gsub('.rb', '.pdf')
-Prawn::Example.generate(filename) do
-  data = [ ["Look at how the cells will look when styled", "", ""],
-           ["They probably won't look the same", "", ""]
-         ]
-  
-  table data, :cell_style => { :font => "Times-Roman", :font_style => :italic }
-  move_down 20
-  
-  table data, :cell_style => { :size => 18, :text_color => "346842" }
-  move_down 20
-  
-  table [["Just <font size='18'>some</font> <b><i>inline</i></b>", "", ""],
-         ["<color rgb='FF00FF'>styles</color> being applied here", "", ""]],
-         :cell_style => { :inline_format => true }
-  move_down 20
-  
-  table [["1", "2", "3", "rotate"]], :cell_style => { :rotate => 30 }
-  move_down 20
-  
-  table data, :cell_style => { :overflow => :shrink_to_fit, :min_font_size => 8,
-                               :width => 60, :height => 30 }
-end

data/manual/table/column_widths.rb

@@ -1,30 +0,0 @@
-# encoding: utf-8
-#
-# Prawn will make its best attempt to identify the best width for the columns.
-# If the end result isn't good, we can override it with some styling.
-#
-# Individual column widths can be set with the <code>:column_widths</code>
-# option. Just provide an array with the sequential width values for the columns
-# or a hash were each key-value pair represents the column 0-based index and its
-# width.
-#
-require File.expand_path(File.join(File.dirname(__FILE__),
-                                   %w[.. example_helper]))
-
-filename = File.basename(__FILE__).gsub('.rb', '.pdf')
-Prawn::Example.generate(filename) do
-  data = [ ["this is not quite as long as the others",
-            "here we have a line that is long but with smaller words",
-            "this is so very looooooooooooooooooooooooooooooong"] ]
-  
-  text "Prawn trying to guess the column widths"
-  table(data)
-  move_down 20
-  
-  text "Manually setting all the column widths"
-  table(data, :column_widths => [100, 200, 240])
-  move_down 20
-  
-  text "Setting only the last column width"
-  table(data, :column_widths => {2 => 240})
-end