princely 1.4.1 → 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 60c51f575db0737a9fc6a0d57d14902048f6c504
+  data.tar.gz: 375ee87716da9847bae4c95dd526347196708c9c
+SHA512:
+  metadata.gz: 82a6b39938457b082524721e5bc631810917bfd4b0252b35c786699054c79604380fc8f62bc40a83fb284cf5f8c86d54a9eaa1d74fa73a573507aa61d4700105
+  data.tar.gz: 8fdd1d1d74c77590e1d23fcd4edb4acde4e720045e9cf92becf18ebff907349e552df2fcc5e72cf4bc7a2aa86f7fcdef029633e3a184775ec39e5099e4f6045c

data/README.md

@@ -0,0 +1,58 @@
+# Princely
+
+Princely is a simple wrapper for the [Prince XML PDF generation library](http://www.princexml.com).
+The plugin will also automatically register the PDF MimeType so that you can use
+pdf as a format in Rails controller `respond_to` blocks.
+
+## Example
+
+```ruby
+class Provider::EstimatesController < Provider::BaseController
+  # You can render PDF templates simply by
+  # using the :pdf option on render templates.
+  def show
+    respond_to do |format|
+      format.html
+      format.pdf do
+        render :pdf => 'file_name',
+               :template => 'controller/action',
+               :handlers => %w[erb],
+               :formats => %w[pdf],
+               :stylesheets => %w[application prince],
+               :layout => 'pdf',
+               :disposition => 'inline', # PDF will be sent inline, means you can load it inside an iFrame or Embed
+               :relative_paths => true # Modify asset paths to make them relative. See [the AssetSupport module](/lib/princely/asset_support.rb)
+      end
+    end
+  end
+
+  # Alternatively, you can use make_and_send_pdf to render out a PDF for the
+  # action without a respond_to block.
+  def pdf
+    make_and_send_pdf "file_name"
+  end
+end
+```
+
+## Render Defaults
+
+The defaults for the render options are as follows:
+
+    layout:          false
+    template:        the template for the current controller/action
+    stylesheets:     none
+    disposition:     attachment (created PDF file will be sent as download)
+    relative_paths:  true
+    server_flag:     true
+    javascript_flag: false
+    timeout:         none
+
+## Contributors
+
+* Maintainer: Jared Fraser ([modsognir](https://github.com/modsognir))
+* Gemification and more: Nic Williams
+* [Other Contributors](https://github.com/mbleigh/princely/contributors)
+
+## Resources
+
+* Copyright (c) 2007-2013 Michael Bleigh and Intridea, Inc., released under the MIT license.

data/lib/princely.rb

@@ -6,7 +6,7 @@
 #
 # USAGE
 # -----------------------------------------------------------------------------
-#   princely = Princely.new()
+#   princely = Princely.new
 #   html_string = render_to_string(:template => 'some_document')
 #   send_data(
 #     princely.pdf_from_string(html_string),
@@ -15,117 +15,31 @@
 #   )
 #
 require 'logger'
+require 'pathname'
 require 'princely/rails' if defined?(Rails)
 
-class Princely
-  attr_accessor :exe_path, :style_sheets, :log_file, :logger
+module Princely
+  autoload :StdoutLogger, 'princely/stdout_logger'
+  autoload :AssetSupport, 'princely/asset_support'
+  autoload :Pdf,          'princely/pdf'
+  autoload :Logging,      'princely/logging'
+  autoload :Executable,   'princely/executable'
 
-  # Initialize method
-  #
-  def initialize(options={})
-    # Finds where the application lives, so we can call it.
-    @exe_path = options[:path] || find_prince_executable
-    raise "Cannot find prince command-line app in $PATH" if @exe_path.length == 0
-    raise "Cannot find prince command-line app at #{@exe_path}" if @exe_path && !File.executable?(@exe_path)
-    @style_sheets = ''
-    @cmd_args = ''
-    @log_file = options[:log_file]
-    @logger = options[:logger]
-  end
-
-  def logger
-    @logger ||= defined?(Rails) ? Rails.logger : StdoutLogger
-  end
-
-  def log_file
-    @log_file ||= defined?(Rails) ?
-            Rails.root.join("log/prince.log") :
-            File.expand_path(File.dirname(__FILE__) + "/log/prince.log")
-  end
-
-  def ruby_platform
-    RUBY_PLATFORM
-  end
-
-  def find_prince_executable
-    if ruby_platform =~ /mswin32/
-      "C:/Program Files/Prince/Engine/bin/prince"
-    else
-      `which prince`.chomp
+  class << self
+    def executable
+      @custom_executable || Princely::Executable.new
     end
-  end
 
-  # Sets stylesheets...
-  # Can pass in multiple paths for css files.
-  #
-  def add_style_sheets(*sheets)
-    for sheet in sheets do
-      @style_sheets << " -s #{sheet} "
+    def executable=(custom_executable)
+      @custom_executable = custom_executable
     end
-  end
-
-  # Sets arbitrary command line arguments
-  def add_cmd_args(str)
-    @cmd_args << " #{str} "
-  end
-
-  # Returns fully formed executable path with any command line switches
-  # we've set based on our variables.
-  #
-  def exe_path
-    # Add any standard cmd line arguments we need to pass
-    @exe_path << " --input=html --server --log=#{log_file} "
-    @exe_path << @cmd_args
-    @exe_path << @style_sheets
-    return @exe_path
-  end
 
-  # Makes a pdf from a passed in string.
-  #
-  # Returns PDF as a stream, so we can use send_data to shoot
-  # it down the pipe using Rails.
-  #
-  def pdf_from_string(string, output_file = '-')
-    path = self.exe_path()
-    # Don't spew errors to the standard out...and set up to take IO
-    # as input and output
-    path << ' --silent - -o -'
-
-    # Show the command used...
-    logger.info "\n\nPRINCE XML PDF COMMAND"
-    logger.info path
-    logger.info ''
-
-    # Actually call the prince command, and pass the entire data stream back.
-    pdf = IO.popen(path, "w+")
-    pdf.puts(string)
-    pdf.close_write
-    result = pdf.gets(nil)
-    pdf.close_read
-    result.force_encoding('BINARY') if RUBY_VERSION >= "1.9"
-    return result
-  end
-
-  def pdf_from_string_to_file(string, output_file)
-    path = self.exe_path()
-    # Don't spew errors to the standard out...and set up to take IO
-    # as input and output
-    path << " --silent - -o '#{output_file}' >> '#{log_file}' 2>> '#{log_file}'"
-
-    # Show the command used...
-    logger.info "\n\nPRINCE XML PDF COMMAND"
-    logger.info path
-    logger.info ''
-
-    # Actually call the prince command, and pass the entire data stream back.
-    pdf = IO.popen(path, "w+")
-    pdf.puts(string)
-    pdf.close
-  end
+    def root
+      Pathname.new(File.expand_path('../', __FILE__))
+    end
 
-  class StdoutLogger
-    def self.info(msg)
-      puts msg
+    def ruby_platform
+      RUBY_PLATFORM
     end
   end
 end

data/lib/princely/asset_support.rb

@@ -0,0 +1,22 @@
+module Princely
+  module AssetSupport
+    def localize_html_string(html_string, asset_path = nil)
+      html_string = html_string.to_str
+      # Make all paths relative, on disk paths...
+      html_string.gsub!(".com:/",".com/") # strip out bad attachment_fu URLs
+      html_string.gsub!( /src=["']+([^:]+?)["']/i ) do |m|
+        asset_src = asset_path ? "#{asset_path}/#{$1}" : asset_file_path($1)
+        %Q{src="#{asset_src}"} # re-route absolute paths
+      end
+
+      # Remove asset ids on images with a regex
+      html_string.gsub!( /src=["'](\S+\?\d*)["']/i ) { |m| %Q{src="#{$1.split('?').first}"} }
+      html_string
+    end
+
+    def asset_file_path(asset)
+      # Remove /assets/ from generated names and try and find a matching asset
+      Rails.application.assets.find_asset(asset.gsub(%r{/assets/}, "")).try(:pathname) || asset
+    end
+  end
+end

data/lib/princely/executable.rb

@@ -0,0 +1,28 @@
+module Princely
+  class Executable
+    attr_reader :path
+
+    def initialize(path=nil)
+      @path = path || default_executable_path
+
+      check_for_executable
+    end
+
+    def check_for_executable
+      raise "Cannot find prince command-line app in $PATH" if !@path || @path.length == 0
+      raise "Cannot find prince command-line app at #{@exe_path}" unless File.executable?(@path)
+    end
+
+    def default_executable_path
+      if Princely.ruby_platform =~ /mswin32|minigw32/
+        "C:/Program Files/Prince/Engine/bin/prince"
+      else
+        `which prince`.chomp
+      end
+    end
+
+    def join(options)
+      ([path] + Array(options)).join(' ')
+    end
+  end
+end

data/lib/princely/logging.rb

@@ -0,0 +1,18 @@
+module Princely
+  module Logging
+
+    class << self
+      attr_accessor :logger, :filename
+
+      def logger
+        @logger ||= defined?(Rails) ? Rails.logger : StdoutLogger
+      end
+
+      def filename
+        pathname = defined?(Rails) ? Rails.root : Princely.root
+        @filename ||= pathname.join 'log', 'prince.log'
+      end
+    end
+
+  end
+end

data/lib/princely/pdf.rb

@@ -0,0 +1,124 @@
+require 'timeout'
+
+module Princely
+  class Pdf
+    attr_accessor :executable, :style_sheets, :logger, :log_file, :server_flag, :media, :javascript_flag, :timeout, :license_path
+
+    # Initialize method
+    #
+    def initialize(options={})
+      options = {
+        :path => nil,
+        :executable => Princely.executable,
+        :log_file => nil,
+        :logger => nil,
+        :server_flag => true,
+        :media => nil,
+        :javascript_flag => false,
+        :license_path => nil
+      }.merge(options)
+      @executable = options[:path] ? Princely::Executable.new(options[:path]) : options[:executable]
+      @style_sheets = ''
+      @log_file = options[:log_file]
+      @logger = options[:logger]
+      @license_path = options[:license_path]
+      @server_flag = options[:server_flag]
+      @media = options[:media]
+      @javascript_flag = options[:javascript_flag]
+      @timeout = options[:timeout]
+    end
+
+    # Returns the instance logger or Princely default logger
+    def logger
+      @logger || Princely::Logging.logger
+    end
+
+    # Returns the instance log file or Princely default log file
+    def log_file
+      @log_file || Princely::Logging.filename
+    end
+
+    # Sets stylesheets...
+    # Can pass in multiple paths for css files.
+    #
+    def add_style_sheets(*sheets)
+      @style_sheets << sheets.map { |sheet| " -s #{sheet} " }.join(' ')
+    end
+
+    # Returns fully formed executable path with any command line switches
+    # we've set based on our variables.
+    #
+    def exe_path
+      @executable.join(executable_options)
+    end
+
+    def executable_options
+      options = []
+      options << "--input=html"
+      options << "--server" if @server_flag
+      options << "--log=#{log_file}"
+      options << "--media=#{media}" if media
+      options << "--javascript" if @javascript_flag
+      options << @style_sheets
+      options
+    end
+
+    # Makes a pdf from a passed in string.
+    #
+    # Returns PDF as a stream, so we can use send_data to shoot
+    # it down the pipe using Rails.
+    #
+    def pdf_from_string(string, output_file = '-')
+      with_timeout do
+        pdf = initialize_pdf_from_string(string, output_file, {:output_to_log_file => false})
+        pdf.close_write
+        result = pdf.gets(nil)
+        pdf.close_read
+        result.force_encoding('BINARY') if RUBY_VERSION >= "1.9"
+
+        result
+      end
+    end
+
+    def pdf_from_string_to_file(string, output_file)
+      with_timeout do
+        pdf = initialize_pdf_from_string(string, output_file)
+        pdf.close
+      end
+    end
+
+  protected
+
+    def with_timeout(&block)
+      if timeout
+        Timeout.timeout(timeout, &block)
+      else
+        block.call
+      end
+    end
+
+    def initialize_pdf_from_string(string, output_file, options = {})
+      options = {:log_command => true, :output_to_log_file => true}.merge(options)
+      path = exe_path
+      # Don't spew errors to the standard out...and set up to take IO
+      # as input and output
+      path << " --media=#{media}" if media
+      path << " --silent - -o #{output_file}"
+      path << " --license-file=#{}" if license_path
+      path << " >> '#{log_file}' 2>> '#{log_file}'" if options[:output_to_log_file]
+
+      log_command path if options[:log_command]
+
+      # Actually call the prince command, and pass the entire data stream back.
+      pdf = IO.popen(path, "w+")
+      pdf.puts string
+      pdf
+    end
+
+    def log_command(path)
+      logger.info "\n\nPRINCE XML PDF COMMAND"
+      logger.info path
+      logger.info ''
+    end
+  end
+end

data/lib/princely/pdf_helper.rb

@@ -1,84 +1,65 @@
-module PdfHelper
-  require 'princely'
-  
-  def self.included(base)
-    base.class_eval do
-      alias_method_chain :render, :princely
-    end
-  end
-  
-  def render_with_princely(options = nil, *args, &block)
-    if options.is_a?(Hash) && options.has_key?(:pdf)
-      options[:name] ||= options.delete(:pdf)
-      make_and_send_pdf(options.delete(:name), options)      
-    else
-      render_without_princely(options, *args, &block)
+require 'princely'
+require 'princely/asset_support'
+
+module Princely
+  module PdfHelper
+
+    def self.included(base)
+      base.send :alias_method_chain, :render, :princely
     end
-  end  
-    
-  private
-  
-  def make_pdf(options = {})
-    options[:stylesheets] ||= []
-    options[:layout] ||= false
-    options[:template] ||= File.join(controller_path,action_name)
-    
-    prince = Princely.new()
-    # Sets style sheets on PDF renderer
-    prince.add_style_sheets(*options[:stylesheets].collect{|style| asset_file_path(style)})
-    
-    html_string = render_to_string(:template => options[:template], :layout => options[:layout])
-    
-    html_string = localize_html_string(html_string)
-    
-    # Send the generated PDF file from our html string.
-    if filename = options[:filename] || options[:file]
-      prince.pdf_from_string_to_file(html_string, filename)
-    else
-      prince.pdf_from_string(html_string)
+
+    def render_with_princely(options = nil, *args, &block)
+      if options.is_a?(Hash) && options.has_key?(:pdf)
+        options[:name] ||= options.delete(:pdf)
+        make_and_send_pdf(options.delete(:name), options)
+      else
+        render_without_princely(options, *args, &block)
+      end
     end
-  end
 
-  def localize_html_string(html_string) 
-    # Make all paths relative, on disk paths...
-    html_string.gsub!(".com:/",".com/") # strip out bad attachment_fu URLs
-    html_string.gsub!( /src=["']+([^:]+?)["']/i ) { |m| "src=\"#{Rails.public_path}/#{$1}\"" } # re-route absolute paths
-    
-    # Remove asset ids on images with a regex
-    html_string.gsub!( /src=["'](\S+\?\d*)["']/i ) { |m| "src=\"#{$1.split('?').first}\"" }
-    html_string
-  end
+    private
 
-  def asset_file_path(asset)
-    stylesheet = stylesheet.to_s.gsub(".css","")
-    File.join(config.stylesheets_dir, "#{stylesheet}.css")
-  end
-  alias_method :stylesheet_file_path, :asset_file_path
+    def make_pdf(options = {})
+      options = {
+        :stylesheets => [],
+        :layout => false,
+        :template => File.join(controller_path, action_name),
+        :relative_paths => true,
+        :server_flag => true,
+        :media => nil,
+        :javascript_flag => false
+      }.merge(options)
 
-  def make_and_send_pdf(pdf_name, options = {})
-    options[:disposition] ||= 'attachment'
-    send_data(
-      make_pdf(options),
-      :filename => pdf_name + ".pdf",
-      :type => 'application/pdf',
-      :disposition => options[:disposition]
-    ) 
-  end
+      prince = Princely::Pdf.new(options.slice(:server_flag, :javascript_flag, :media))
+      # Sets style sheets on PDF renderer
+      prince.add_style_sheets(*options[:stylesheets].collect{|style| asset_file_path(style)})
+
+      html_string = render_to_string(options.slice(:template, :layout, :handlers, :formats))
 
-  module AssetSupport
-    def localize_html_string(html_string)
-      # Make all paths relative, on disk paths...
-      html_string.gsub!(".com:/",".com/") # strip out bad attachment_fu URLs
-      html_string.gsub!( /src=["']+([^:]+?)["']/i ) { |m| "src=\"#{asset_file_path($1)}\"" } # re-route absolute paths
-      
-      # Remove asset ids on images with a regex
-      html_string.gsub!( /src=["'](\S+\?\d*)["']/i ) { |m| 'src="' + $1.split('?').first + '"' }
-      html_string
+      html_string = localize_html_string(html_string, Rails.public_path) if options[:relative_paths]
+
+      # Send the generated PDF file from our html string.
+      if filename = options[:filename] || options[:file]
+        prince.pdf_from_string_to_file(html_string, filename)
+      else
+        prince.pdf_from_string(html_string)
+      end
     end
 
     def asset_file_path(asset)
-      # Remove /assets/ from generated names and try and find a matching asset
-      Rails.application.assets.find_asset(asset.gsub(/\/assets\//, "")).try(:pathname) || asset
+      asset = asset.to_s.gsub('.css', '')
+      File.join(config.stylesheets_dir, "#{asset}.css")
+    end
+    alias_method :stylesheet_file_path, :asset_file_path
+
+    def make_and_send_pdf(pdf_name, options = {})
+      options = {:disposition => 'attachment'}.merge(options)
+      send_data(
+        make_pdf(options),
+        :filename => "#{pdf_name}.pdf",
+        :type => 'application/pdf',
+        :disposition => options[:disposition]
+      )
     end
   end
 end

data/lib/princely/rails.rb

@@ -1,10 +1,11 @@
 require 'princely/pdf_helper'
+require 'princely/view_helpers'
 
 if Mime::Type.lookup_by_extension(:pdf) != 'application/pdf'
   Mime::Type.register 'application/pdf', :pdf
 end
 
-ActionController::Base.send(:include, PdfHelper)
-ActionController::Base.send(:include, PdfHelper::AssetSupport) if
+ActionController::Base.send(:include, Princely::PdfHelper)
+ActionController::Base.send(:include, Princely::AssetSupport) if
  (Rails::VERSION::MAJOR == 3 && Rails::VERSION::MINOR > 0) ||
- (Rails::VERSION::MAJOR >= 4)
+ (Rails::VERSION::MAJOR >= 4)

data/lib/princely/stdout_logger.rb

@@ -0,0 +1,7 @@
+module Princely
+  class StdoutLogger
+    def self.info(msg)
+      puts msg
+    end
+  end
+end

data/lib/princely/version.rb

@@ -1,3 +1,13 @@
-class Princely
-  VERSION = "1.4.1"
+module Princely
+  class Version
+    class << self
+      def version
+        '2.0.0'
+      end
+
+      def to_s
+        version
+      end
+    end
+  end
 end

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: princely
 version: !ruby/object:Gem::Version
-  version: 1.4.1
-  prerelease: 
+  version: 2.0.0
 platform: ruby
 authors:
 - Michael Bleigh
@@ -15,33 +14,29 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: A wrapper for the PrinceXML PDF generation library.
@@ -50,44 +45,42 @@ email:
 - dev@jsf.io
 executables: []
 extensions: []
-extra_rdoc_files:
-- README.rdoc
+extra_rdoc_files: []
 files:
 - MIT-LICENSE
-- README.rdoc
+- README.md
 - Rakefile
 - lib/princely.rb
+- lib/princely/asset_support.rb
+- lib/princely/executable.rb
+- lib/princely/logging.rb
+- lib/princely/pdf.rb
 - lib/princely/pdf_helper.rb
 - lib/princely/rails.rb
+- lib/princely/stdout_logger.rb
 - lib/princely/version.rb
 homepage: http://github.com/mbleigh/princely
-licenses: []
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -2291531356337878395
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -2291531356337878395
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.4.8
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A simple Rails wrapper for the PrinceXML PDF generation library.
 test_files: []

data/README.rdoc

@@ -1,49 +0,0 @@
-= Princely
-
-Princely is a simple wrapper for the Prince XML PDF generation library 
-(http://www.princexml.com). The plugin will also automatically registers 
-the PDF MimeType so that you can use pdf as a format in controller 
-respond_to blocks.
-
-== Example
-
-    class Provider::EstimatesController < Provider::BaseController
-      # You can render PDF templates simply by
-      # using the :pdf option on render templates.
-      def show
-        respond_to do |format|
-          format.html
-          format.pdf do
-            render :pdf => "file_name", 
-                   :template => "controller/action.pdf.erb",
-                   :stylesheets => ["application","prince"],
-                   :layout => "pdf",
-                   :disposition => "inline" # PDF will be sent inline, means you can load it inside an iFrame or Embed
-          end
-        end
-      end
-      
-      # Alternatively, you can use make_and_send_pdf to
-      # render out a PDF for the action without a
-      # respond_to block.
-      def pdf
-        make_and_send_pdf("file_name")
-      end
-    end
-
-== Render Defaults
-
-The defaults for the render options are as follows:
-
-    layout:      false
-    template:    the template for the current controller/action
-    stylesheets: none
-    disposition: attachment (created PDF file will be sent as download)
-
-== Contributors
-
-* Gemification and more: Nic Williams
-
-== Resources
-
-* Copyright (c) 2007-2009 Michael Bleigh and Intridea, Inc., released under the MIT license.