pdf_renderer 0.0.2

data/lib/pdf_renderer.rb

@@ -0,0 +1,5 @@
+require 'pdf_renderer/helpers'
+require 'pdf_renderer/base'
+require 'pdf_renderer/latex'
+require 'pdf_renderer/pdf'
+require 'pdf_renderer/helpers/latex_helper'

data/lib/pdf_renderer/base.rb

@@ -0,0 +1,137 @@
+module PdfRenderer
+  # Base class for rendering PDFs. PDFs are rendered in two passes. The first
+  # pass evaluates an LaTeX ERB template. In the second pass the evaluated
+  # output is piped through pdflatex. The resulting PDF is returned as a string.
+  #
+  # === Usage
+  #
+  # The usage is very similar to ActionMailer. Example:
+  #
+  #   class BillPdfRenderer < PdfRenderer::Base
+  #     def bill(model)
+  #       body :variable => model
+  #     end
+  #   end
+  #
+  # Render the PDF using
+  #
+  #   pdf_as_string = BillPdfRenderer.render_bill(model)
+  #
+  # The default template path is
+  # <code>underscored_class_name/action_name.pdf.erb</code> and is looked for in
+  # all specified view_paths.
+  #
+  # === Saving PDFs
+  #
+  # You can also use PdfRenderer::Base to generate and save PDFs to the file
+  # system. Instead of calling <code>render_</code>
+  #
+  # === Helpers
+  #
+  # To use view helpers, declare them in class scope. You can declare them as
+  # symbols, strings or constants, camelized or underscored. Omit the "Helper"
+  # suffix when using strings or symbols.
+  #
+  # The LatexHelper included in the PdfRenderer gem is automatically added to
+  # the ActionView instance. This helper contains methods for escaping strings
+  # to LaTeX.
+  #
+  # === Options
+  #
+  # Inside of render actions, there are a couple of options you can use:
+  #
+  # preprocess:: Run pdflatex twice for assigning page numbers etc.
+  # debug::      Save the rendered tex source to the file system for debugging.
+  class Base
+    include ActionMailer::AdvAttrAccessor
+    include PdfRenderer::Helpers
+    
+    adv_attr_accessor :body, :template_name, :preprocess, :debug
+    
+    # Contains the input for LaTeX
+    attr_reader :tex_out
+    
+    # Paths where views are looked for in.
+    class_inheritable_array :view_paths
+    
+    # Sets default options
+    #
+    # preprocess:: <code>false</code>
+    # debug::      <code>false</code>
+    def initialize
+      preprocess false
+      debug false
+    end
+    
+    # Depending on the method pattern, does one of three things:
+    #
+    # * If the method name starts with <code>render_</code>, the action is
+    #   called on a new instance of the renderer and the rendered PDF is
+    #   returned as a string.
+    # * If the method starts with <code>save_</code>, the action is called,
+    #   the PDF is generated and saved to the path given in the first method
+    #   argument.
+    # * Otherwise, the action is called on a new instance of the renderer and a
+    #   Pdf object is returned.
+    def self.method_missing(method, *params)
+      if method.to_s =~ /^render_(.*)$/
+        pdf = send($1, *params)
+        pdf.render!
+      elsif method.to_s =~ /^save_(.*)$/
+        file_name = params.shift
+        pdf = send($1, *params)
+        pdf.save(file_name)
+      elsif instance_methods.include?(method.to_s)
+        renderer_instance = new
+        renderer_instance.template_name = method
+        renderer_instance.send(renderer_instance.template_name, *params)
+        Pdf.new(renderer_instance)
+      else
+        super
+      end
+    end
+    
+    # The root for view files.
+    def self.template_root
+      "#{RAILS_ROOT}/app/views"
+    end
+    
+    # The directory in which templates are stored by default for this renderer.
+    def template_dir
+      self.class.name.underscore
+    end
+    
+    # The complete path to the LaTeX ERB template.
+    def template_path
+      "#{template_dir}/#{template_name}"
+    end
+    
+    # Delegates the render call to ActionView and runs the resulting LaTeX code
+    # through pdflatex.
+    def render(options)
+      @tex_out = template_instance.render options
+      Latex.new(:preprocess => preprocess, :debug => debug).generate_pdf(tex_out)
+    end
+    
+    # Renders the default template.
+    def render!
+      render :file => template_path
+    end
+    
+  protected
+    def self.template_class
+      @template_class ||= returning Class.new(ActionView::Base) do |view_class|
+        view_class.send(:include, ApplicationController.master_helper_module) if Object.const_defined?(:ApplicationController)
+        view_class.send(:include, PdfRenderer::Helpers::LatexHelper)
+        view_class.send(:include, self.master_helper_module)
+      end
+    end
+    
+    def template_instance
+      returning self.class.template_class.new(self.class.template_root, body || {}, self) do |view|
+        view.template_format = :pdf
+        view.view_paths = ActionView::Base.process_view_paths(self.view_paths)
+      end
+    end
+  end
+end

data/lib/pdf_renderer/helpers.rb

@@ -0,0 +1,33 @@
+module PdfRenderer
+  # Contains functionality for using helper modules in the views when rendering
+  # LaTeX ERB files.
+  module Helpers
+    def self.included(base)
+      base.class_inheritable_array :helpers
+      base.extend ClassMethods
+    end
+    
+    module ClassMethods
+      # Class-level method that declares <code>helpers</code> as helpers for
+      # inclusion in the view. Specify the helpers as <code>:symbol</code>,
+      # <code>'string'</code>, or <code>ConstantName</code>.
+      def helper(*helpers)
+        write_inheritable_array :helpers, helpers
+      end
+
+    protected
+      def master_helper_module
+        @master_helper_module ||= returning(Module.new) do |mod|
+          (helpers || []).each do |helper|
+            case helper
+            when Module
+              mod.send(:include, helper)
+            when String, Symbol
+              mod.send(:include, "#{helper.to_s}_helper".camelize.constantize)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pdf_renderer/helpers/latex_helper.rb

@@ -0,0 +1,28 @@
+module PdfRenderer
+  module Helpers
+    # Contains methods for escaping strings for LaTeX.
+    module LatexHelper
+      BS        = "\\\\"
+      BACKSLASH = "#{BS}textbackslash{}"
+      HAT       = "#{BS}textasciicircum{}"
+      TILDE     = "#{BS}textasciitilde{}"
+
+      # Escapes the string, so it is suitable for LaTeX input. This method is
+      # aliased as <code>l</code>.
+      def latex_escape(s)
+        quote_count = 0
+        s.to_s.
+          gsub(/([{}_$&%#])/, "__LATEX_HELPER_TEMPORARY_BACKSLASH_PLACEHOLDER__\\1").
+          gsub(/\\/, BACKSLASH).
+          gsub(/__LATEX_HELPER_TEMPORARY_BACKSLASH_PLACEHOLDER__/, BS).
+          gsub(/\^/, HAT).
+          gsub(/~/, TILDE).
+          gsub(/"/) do
+            quote_count += 1
+            quote_count.odd? ? %{"`} : %{"'}
+          end
+      end
+      alias :l :latex_escape
+    end
+  end
+end

data/lib/pdf_renderer/latex.rb

@@ -0,0 +1,110 @@
+module PdfRenderer
+  # This error is raised when no suitable LaTeX executable is found.
+  class LatexProcessorNotFound < StandardError; end
+  # This error is raised when there is a syntax error in the LaTeX input.
+  class LatexError < StandardError; end
+  # This error is raised when there is an illegal character in the LaTeX input.
+  class InvalidCharacter < StandardError; end
+
+  # This class wraps the LaTeX command invocation.
+  class Latex
+    attr_reader :options
+    
+    # Option redirection for shell output (default is '> /dev/null 2>&1' )
+    cattr_accessor :shell_redirect
+    self.shell_redirect = '> /dev/null 2>&1'
+    # Temporary Directory
+    cattr_accessor :tempdir
+    self.tempdir = "#{File.expand_path(RAILS_ROOT)}/tmp"
+    # tex command to run
+    cattr_accessor :tex_command
+    self.tex_command = "pdflatex"
+    
+    def initialize(options = {})
+      @options = options
+    end
+    
+    # Returns the rendered PDF as string for the given input string (LaTeX
+    # source).
+    def generate_pdf(input)
+      create_debug_output(input) if options[:debug]
+      check_for_tex_presence!
+      create_pdf(input)
+    end
+
+  protected
+    def processor
+      self.class.tex_command
+    end
+    
+    def run(command)
+      %x{#{command}}
+    end
+    
+    def create_debug_output(output)
+      File.open("pdf_renderer_out.tex", "wb") {|f| f.puts output}
+    rescue
+    end
+    
+    def check_for_tex_presence!
+      system_path = ENV["PATH"]
+
+      # This is one big ugly platform dependent kludge, but it's necessary. 
+      # See: http://lists.radiantcms.org/pipermail/radiant/2007-April/004473.html
+      # In short, apache doesn't see environment variables like PATH.
+      system_path = "/bin:/usr/bin:/usr/local/bin" if system_path.nil?
+
+      # Check for the presence of the tex processor in the path.
+      unless File.executable?(processor) or system_path.split(":").any?{|path| File.executable?(File.join(path, processor))}
+        raise LatexProcessorNotFound
+      end
+    end
+    
+    def create_pdf(input)
+      create_temp_dir("pdf_renderer", self.class.tempdir) do
+        basename = "processed_pdf_renderer_file"
+        texfile = File.open("#{basename}.tex", "wb")
+        texfile.write(input)
+        texfile.close
+
+        tex_command = "#{processor} -interaction=nonstopmode #{texfile.path} #{self.class.shell_redirect}"
+        tex_return = ''
+        tex_return = run(tex_command)
+        tex_return = run(tex_command) if options[:preprocess] # One can wonder if it matters if it's always run twice...
+
+        if File.exists?("#{basename}.pdf")
+          # For some reason, File.read doesn't work, hence the call using the block
+          File.open("#{basename}.pdf",'rb') { |f| f.read }
+        else
+          if tex_return[/(Package inputenc Error: Unicode char .+)/,1]
+            raise InvalidCharacter.new($1)
+          end
+          raise LatexError.new("Could not generate PDF:\n>>#{tex_return}<<\n\nPath:#{texfile.path}\n\n\nInput:#{input}")
+        end
+      end
+    end
+
+    @@temporary_dir_number = 0;
+
+    # Creates a temp dir in location and performs the supplied code block
+    def create_temp_dir(name, location)
+      @@temporary_dir_number += 1
+      pid = Process.pid # This doesn't work on some platforms, according to the docs. A better way to get it would be nice.
+      random_number = Kernel.rand(1000000000).to_s # This is to avoid a possible symlink attack vulnerability in the creation of temporary files.
+      complete_dir_name = "#{location}/#{name}.#{pid}.#{random_number}.#{@@temporary_dir_number}"
+
+      yield_result = Object.new
+
+      FileUtils.mkdir_p(complete_dir_name)
+      Dir.chdir(complete_dir_name) do
+        begin
+          yield_result = yield
+        ensure
+          FileUtils.rmtree([complete_dir_name])
+        end
+      end
+
+      yield_result
+    end
+  end
+end

data/lib/pdf_renderer/pdf.rb

@@ -0,0 +1,30 @@
+module PdfRenderer
+  # Wrapper class that represents the PDF to be rendered. An instance of this
+  # class is returned by a PdfRenderer, when an action is called without a
+  # prefix (i.e. without <code>render_</code> or <code>save_</code>).
+  class Pdf
+    # Contains the instance variable assigns
+    attr_accessor :body
+    # Contains the LaTeX source for this PDF.
+    attr_accessor :source
+    # Contains the rendered PDF as string.
+    attr_accessor :rendered
+    
+    def initialize(renderer)
+      @renderer = renderer
+      @body = renderer.body
+    end
+    
+    # Renders the PDF.
+    def render!
+      @rendered = @renderer.render!
+      @source = @renderer.tex_out
+      @rendered
+    end
+    
+    # Renders the PDF and saves it to the file system.
+    def save(filename)
+      File.open(filename, 'wb') { |file| file.print render! }
+    end
+  end
+end

data/rails_generators/pdf_renderer/USAGE

@@ -0,0 +1,15 @@
+Description:
+    Stubs out a new PDF renderer and its views. Pass the renderer name, either
+    CamelCased or under_scored, without PdfRenderer or _pdf_renderer as the suffix,
+    and an optional list of actions as arguments.
+
+    This generates a renderer class in app/pdf_renderers, view templates in
+    app/views/renderer_name, and a functional test in test/functional.
+
+Example:
+    `./script/generate pdf_renderer Bill bill invoice reminder`
+
+    creates a bill renderer class, views, and test:
+        Renderer:  app/pdf_renderers/bill_pdf_renderer.rb
+        Views:     app/views/bill_pdf_renderer/bill.pdf.erb [...]
+        Test:      test/functional/bill_pdf_renderer_test.rb

data/rails_generators/pdf_renderer/pdf_renderer_generator.rb

@@ -0,0 +1,26 @@
+class PdfRendererGenerator < Rails::Generator::NamedBase
+  def manifest
+    record do |m|
+      # Check for class naming collisions.
+      m.class_collisions "#{class_name}PdfRenderer", "#{class_name}PdfRendererTest"
+
+      # Renderer, view, and test directories.
+      m.directory File.join('app/pdf_renderers', class_path)
+      m.directory File.join('app/views', "#{file_path}_pdf_renderer")
+      m.directory File.join('test/functional', class_path)
+
+      # Renderer class and functional test.
+      m.template "pdf_renderer.rb",    File.join('app/pdf_renderers', class_path, "#{file_name}_pdf_renderer.rb")
+      m.template "functional_test.rb", File.join('test/functional', class_path, "#{file_name}_pdf_renderer_test.rb")
+
+      # View template for each action.
+      actions.each do |action|
+        relative_path = File.join("#{file_path}_pdf_renderer", action)
+        view_path     = File.join('app/views', "#{relative_path}.pdf.erb")
+
+        m.template "view.erb", view_path,
+                   :assigns => { :action => action, :path => view_path }
+      end
+    end
+  end
+end

data/rails_generators/pdf_renderer/templates/functional_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+ 
+class <%= class_name %>PdfRendererTest < ActiveSupport::TestCase
+<% for action in actions -%>
+  test "<%= action %>" do
+    pdf = <%= class_name %>PdfRenderer.render_<%= action %>
+    assert pdf.source =~ /content/
+  end
+
+<% end -%>
+<% if actions.blank? -%>
+  # replace this with your real tests
+  test "the truth" do
+    assert true
+  end
+<% end -%>
+end

data/rails_generators/pdf_renderer/templates/pdf_renderer.rb

@@ -0,0 +1,8 @@
+class <%= class_name %>PdfRenderer < ActionFaxer::Base
+<% for action in actions -%>
+  def <%= action %>
+    body :greeting => 'Hi,'
+  end
+
+<% end -%>
+end

data/rails_generators/pdf_renderer/templates/view.erb

@@ -0,0 +1,11 @@
+\documentclass[a4paper]{report}
+
+\title{Test PDF}
+
+\begin{document}
+
+<%= class_name %>PdfRenderer#<%= action %>
+
+Find me in <%= path %>
+
+\end{document}

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: pdf_renderer
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Thomas Kadauke
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-17 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: 
+email: entwicker@imedo.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/pdf_renderer/base.rb
+- lib/pdf_renderer/helpers/latex_helper.rb
+- lib/pdf_renderer/helpers.rb
+- lib/pdf_renderer/latex.rb
+- lib/pdf_renderer/pdf.rb
+- lib/pdf_renderer.rb
+- rails_generators/pdf_renderer/pdf_renderer_generator.rb
+- rails_generators/pdf_renderer/templates/functional_test.rb
+- rails_generators/pdf_renderer/templates/pdf_renderer.rb
+- rails_generators/pdf_renderer/templates/view.erb
+- rails_generators/pdf_renderer/USAGE
+has_rdoc: true
+homepage: http://www.imedo.de/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Framework for rendering PDFs using LaTeX
+test_files: []
+