awhyte-rtex 2.1.2

data/lib/rtex/escaping.rb

@@ -0,0 +1,28 @@
+module RTeX
+  
+  module Escaping
+    
+    # Escape text using +replacements+
+    def escape(text)
+      replacements.inject(text.to_s) do |corpus, (pattern, replacement)|
+        corpus.gsub(pattern, replacement)
+      end
+    end
+    
+    # List of replacements
+    def replacements
+      @replacements ||= [
+        [/([{}])/,    '\\\\\1'],
+        [/\\/,        '\textbackslash{}'],
+        [/\^/,        '\textasciicircum{}'],
+        [/~/,         '\textasciitilde{}'],
+        [/\|/,        '\textbar{}'],
+        [/\</,        '\textless{}'],
+        [/\>/,        '\textgreater{}'],
+        [/([_$&%#])/, '\\\\\1']
+      ]
+    end
+    
+  end
+  
+end

data/lib/rtex/framework/merb.rb

@@ -0,0 +1,13 @@
+module RTeX
+  
+  module Framework #:nodoc:
+    
+    module Merb #:nodoc:
+      
+      # TODO
+      
+    end
+    
+  end
+  
+end

data/lib/rtex/framework/rails.rb

@@ -0,0 +1,209 @@
+require 'tempfile'
+
+module RTeX
+  module Framework #:nodoc:   
+    module Rails #:nodoc:
+      
+      def self.setup
+        RTeX::Document.options[:tempdir] = File.expand_path(File.join(RAILS_ROOT, 'tmp'))
+        if ActionView::Base.respond_to?(:register_template_handler)
+          ActionView::Base.register_template_handler(:rtex, TemplateHandler)
+        else
+          ActionView::Template.register_template_handler(:rtex, TemplateHandler)
+        end
+        ActionController::Base.send(:include, ControllerMethods)
+        ActionView::Base.send(:include, HelperMethods)
+      end
+      
+      
+      class TemplateHandler < ::ActionView::TemplateHandlers::ERB
+        # Due to significant changes in ActionView over the lifespan of Rails,
+        # tagging compiled templates to set a thread local variable flag seems
+        # to be the least brittle approach.
+        def compile(template)
+          # Insert assignment, but not before the #coding: line, if present
+          super.sub(/^(?!#)/m, "Thread.current[:_rendering_rtex] = true;\n")
+        end
+      end
+      
+      
+      module ControllerMethods
+        
+        def self.included(base) #:nodoc:
+          base.alias_method_chain :render, :rtex
+        end
+        
+        # Extends the base +ActionController#render+ method by checking whether
+        # the template is RTeX-capable and creating an RTeX::Document in that 
+        # case.
+        #
+        # If you have view templates saved, for example, as "show.html.erb" and 
+        # "show.pdf.rtex" in an ItemsController, one could write the controller
+        # action like this:
+        #
+        #   def show
+        #     # set up instance variables
+        #     # ...
+        #     respond_to do |format|
+        #       format.html
+        #       format.pdf { render :filename => "Item Information.pdf" }
+        #     end
+        #   end
+        #
+        # As well as the options available to a new RTeX::Document, the 
+        # following may be supplied here:
+        #
+        # [+:disposition+] 'inline' (default) or 'attachment'
+        # [+:filename+] +nil+ (default) results in the final part of the 
+        #               request URL being used.
+        #
+        # To see the underlying LaTeX code that generated the PDF, create 
+        # another view called "show.tex.rtex" which includes the single line
+        #
+        #   <%= include_template_from "items/show.pdf.rtex" -%>
+        #
+        # and include the following in the controller action
+        # 
+        #   format.tex { render :filename => "item_information_source.tex" }
+        #
+        # This may be helpful during debugging or for saving pre-compiled parts
+        # of LaTeX documents for later processing into PDFs.
+        #
+        def render_with_rtex(options=nil, extra_options={}, &block)
+          if conditions_for_rtex(options)
+            render_rtex(default_template, options, extra_options, &block)
+          else
+            render_without_rtex(options, extra_options, &block)
+          end
+        end
+        
+      private
+        
+        def render_rtex(template, options={}, extra_options={}, &block)
+          RTeX::Tempdir.open do |dir|
+            # Make LaTeX temporary directory accessible to view
+            @rtex_dir = dir.to_s
+            
+            # Render view into LaTeX document string
+            latex = render_without_rtex(options, extra_options, &block)
+            
+            # HTTP response options
+            send_options = { 
+              :disposition => (options.delete(:disposition) || 'inline'),
+              :url_based_filename => true,
+              :filename => (options.delete(:filename) || nil),
+              :type => template.mime_type.to_s }
+            
+            # Document options
+            rtex_options = options.merge(:tempdir => dir).reverse_merge(
+              :processed => true,
+              :tex_inputs => File.join(RAILS_ROOT,'lib','latex') )
+            
+            # Content type requested
+            content_type = template.content_type.to_sym
+            
+            # Send appropriate data to client
+            case content_type
+              when :tex
+                send_data latex, send_options.merge(:length => latex.length)
+              when :pdf
+                pdf = RTeX::Document.new(latex, rtex_options).to_pdf
+                send_data pdf, send_options.merge(:length => pdf.length)
+              else
+                raise "RTeX: unknown content type requested: #{content_type}"
+            end
+          end
+        end
+        
+        def conditions_for_rtex(options)
+          begin
+            # Do not override the +:text+ rendering, because send_data uses this
+            !options[:text] && 
+            # Check whether the default template is one managed by the 
+            # RTeX::Framework::Rails::TemplateHandler
+            :rtex == default_template.extension.to_sym 
+          rescue
+            false
+          end
+        end
+      end
+      
+      
+      module HelperMethods
+      
+        # Make the supplied text safe for the LaTeX processor, in the same way 
+        # that h() works for HTML documents.
+        #
+        def latex_escape(*args)
+          # Since Rails' I18n implementation aliases l() to localize(), LaTeX
+          # escaping should only be done if RTeX is doing the rendering.
+          # Otherwise, control should be be passed to localize().
+          if Thread.current[:_rendering_rtex]
+            RTeX::Document.escape(*args)
+          else
+            localize(*args)
+          end
+        end
+        alias :l :latex_escape
+        
+        # Obtain the temporary directory RTeX is currently using
+        attr_reader :rtex_dir
+        
+        # Copy the contents of another template into the current one, like 
+        # rendering a partial but without have to add an underscore to the 
+        # filename.
+        #
+        def include_template_from(from)
+          other_file = @template.view_paths.find_template(from).relative_path
+          render(:inline => File.read(other_file))
+        end
+        
+        # Include an image file into the current LaTeX document.
+        #
+        # For example,
+        #
+        #   \includegraphics{<%= graphics_file("some file.png") -%>}
+        #
+        # will copy "public/images/some file.png" to a the current RTeX 
+        # temporary directory (with a LaTeX-safe filename) and reference it in 
+        # the document like this:
+        #
+        #   \includegraphics{/tmp/rtex/rtex-random-number/image-file.png}
+        #
+        def graphics_file(file, reference_original_file=false)
+          source = Pathname.new file
+          source = Pathname.new(ActionView::Helpers::ASSETS_DIR) + "images" + source unless source.absolute?
+          
+          if reference_original_file
+            source.to_s
+          else
+            destination = Pathname.new(@rtex_dir) + latex_safe_filename(source.basename)
+            FileUtils.copy source, destination
+            destination.to_s
+          end
+        end
+        
+        # Save the supplied image data to the RTeX temporary directory and 
+        # return the filename for inclusion in the current document.
+        #
+        #   \includegraphics{<%= graphics_data(object.to_png) -%>}
+        #
+        def graphics_data(data)
+          destination = Pathname.new(@rtex_dir) + latex_safe_filename(filename)
+          File.open(destination, "w") { |f| f.write data }
+          dst.to_s
+        end
+        
+      private
+        
+        def latex_safe_filename(input)
+          # Replace non-ASCII characters
+          input = ActiveSupport::Inflector.transliterate(input.to_s).to_s
+          # Replace non-LaTeX-friendly characters with a dash
+          input.gsub(/[^a-z0-9\-_\+\.]+/i, '-')
+        end
+        
+      end
+    end
+  end
+end

data/lib/rtex/tempdir.rb

@@ -0,0 +1,107 @@
+require 'fileutils'
+require 'tmpdir'
+
+module RTeX
+
+  # Utility class to manage the lifetime of a temporary directory in which 
+  # LaTeX can do its processing
+  #
+  class Tempdir
+    
+    # Create a new temporary directory, yield for processing, then remove it.
+    #
+    #   RTeX::Tempdir.open do |tempdir|
+    #     # Use newly created temporary directory
+    #     # ...
+    #   end
+    #
+    # When the block completes, the directory is removed.
+    #
+    # Arguments can be either an specific directory name,
+    #
+    #   RTeX::Tempdir.open("/tmp/somewhere") do ...
+    #
+    # or options to assist the generation of a randomly named unique directory,
+    #
+    #   RTeX::Tempdir.open(:parent_path => PARENT, :basename => BASENAME) do ...
+    # 
+    # which would result in a new directory 
+    # "[PARENT]/rtex/[BASENAME]-[random hash]/" being created.
+    # 
+    # The default +:parent_path+ is +Dir.tmpdir", and +:basename+ 'rtex'.
+    #
+    def self.open(*args)
+      tempdir = new(*args)
+      tempdir.create!
+      
+      # Yield the path and wait for the block to finish
+      result = yield tempdir
+      
+      # We don't remove the temporary directory when exceptions occur,
+      # so that the source of the exception can be dubbed (logfile kept)
+      tempdir.remove!
+      result
+    end
+    
+    # Manually control tempdir creation and removal. Accepts the same arguments
+    # as +RTeX::Tempdir.open+, but the user must call +#create!+ and +#remove!+
+    # themselves:
+    #
+    #   tempdir = RTeX::Tempdir.new
+    #   tempdir.create!
+    #   # Use the temporary directory
+    #   # ...
+    #   tempdir.remove!
+    #
+    def initialize(*args)
+      options = args.last.is_a?(Hash) ? options.pop : {}
+      specific_path = args.first
+      
+      if specific_path
+        @path = specific_path
+      else
+        @parent_path = options[:parent_path] || Dir.tmpdir
+        @basename = options[:basename] || 'rtex'
+      end
+    end
+    
+    def create!
+      FileUtils.mkdir_p path
+      @removed = false
+      path
+    end
+    
+    # Is the temporary directory present on the filesystem
+    def exists?
+      File.exists?(path)
+    end
+    
+    # The filesystem location of the temporary directory
+    def path
+      @path ||= File.expand_path(File.join(@parent_path, 'rtex', "#{@basename}-#{self.class.uuid}"))
+    end
+    
+    # Return the +#path+ for use in string expansion
+    alias :to_s :path
+    
+    # Forcibly remove this temporary directory
+    def remove!
+      return false if @removed
+      FileUtils.rm_rf path
+      @removed = true
+    end
+    
+    # Try using uuidgen, but if that doesn't work drop down to
+    # a poor-man's UUID; timestamp, thread & object hashes
+    # Note: I don't want to add any dependencies (so no UUID library)
+    #
+    def self.uuid
+      if (result = `uuidgen`.strip rescue nil).empty?
+        "#{Time.now.to_i}-#{Thread.current.hash}-#{hash}"
+      else
+        result
+      end
+    end
+    
+  end
+end

data/lib/rtex/version.rb

@@ -0,0 +1,77 @@
+# (The MIT License)
+# 
+# Copyright (c) 2008 Jamis Buck <jamis@37signals.com>,
+#               with modifications by Bruce Williams <bruce@codefluency.com>
+# 
+# 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.
+module RTeX
+  
+    
+  # A class for describing the current version of a library. The version
+  # consists of three parts: the +major+ number, the +minor+ number, and the
+  # +tiny+ (or +patch+) number.
+  class Version
+  
+    # A convenience method for instantiating a new Version instance with the
+    # given +major+, +minor+, and +tiny+ components.
+    def self.[](major, minor, tiny)
+      new(major, minor, tiny)
+    end
+    
+    attr_reader :major, :minor, :tiny
+
+    # Create a new Version object with the given components.
+    def initialize(major, minor, tiny)
+      @major, @minor, @tiny = major, minor, tiny
+    end
+
+    # Compare this version to the given +version+ object.
+    def <=>(version)
+      to_i <=> version.to_i
+    end
+
+    # Converts this version object to a string, where each of the three
+    # version components are joined by the '.' character. E.g., 2.0.0.
+    def to_s
+      @to_s ||= [@major, @minor, @tiny].join(".")
+    end
+
+    # Converts this version to a canonical integer that may be compared
+    # against other version objects.
+    def to_i
+      @to_i ||= @major * 1_000_000 + @minor * 1_000 + @tiny
+    end
+    
+    def to_a
+      [@major, @minor, @tiny]
+    end
+
+    MAJOR = 2
+    MINOR = 1
+    TINY  = 1
+    
+    # The current version as a Version instance
+    CURRENT = new(MAJOR, MINOR, TINY)
+    # The current version as a String
+    STRING = CURRENT.to_s
+        
+  end
+  
+end

data/rails/init.rb

@@ -0,0 +1,2 @@
+require 'rtex'
+RTeX.framework :rails

data/rtex.gemspec

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rtex}
+  s.version = "2.1.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Bruce Williams, Wiebe Cazemier"]
+  s.date = %q{2009-09-24}
+  s.default_executable = %q{rtex}
+  s.description = %q{LaTeX preprocessor for PDF generation; Rails plugin}
+  s.email = %q{bruce@codefluency.com}
+  s.executables = ["rtex"]
+  s.extra_rdoc_files = ["bin/rtex", "CHANGELOG", "lib/rtex/document.rb", "lib/rtex/escaping.rb", "lib/rtex/framework/merb.rb", "lib/rtex/framework/rails.rb", "lib/rtex/tempdir.rb", "lib/rtex/version.rb", "lib/rtex.rb", "README.rdoc", "README_RAILS.rdoc"]
+  s.files = ["bin/rtex", "CHANGELOG", "init.rb", "lib/rtex/document.rb", "lib/rtex/escaping.rb", "lib/rtex/framework/merb.rb", "lib/rtex/framework/rails.rb", "lib/rtex/tempdir.rb", "lib/rtex/version.rb", "lib/rtex.rb", "Manifest", "rails/init.rb", "Rakefile", "README.rdoc", "README_RAILS.rdoc", "test/document_test.rb", "test/filter_test.rb", "test/fixtures/first.tex", "test/fixtures/first.tex.erb", "test/fixtures/fragment.tex.erb", "test/fixtures/text.textile", "test/tempdir_test.rb", "test/test_helper.rb", "vendor/instiki/LICENSE", "vendor/instiki/redcloth_for_tex.rb", "rtex.gemspec"]
+  s.has_rdoc = true
+  s.homepage = %q{http://rtex.rubyforge.org}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Rtex", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{rtex}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{LaTeX preprocessor for PDF generation; Rails plugin}
+  s.test_files = ["test/document_test.rb", "test/filter_test.rb", "test/tempdir_test.rb", "test/test_helper.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<Shoulda>, [">= 0"])
+      s.add_development_dependency(%q<echoe>, [">= 0"])
+    else
+      s.add_dependency(%q<Shoulda>, [">= 0"])
+      s.add_dependency(%q<echoe>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<Shoulda>, [">= 0"])
+    s.add_dependency(%q<echoe>, [">= 0"])
+  end
+end
+