acts_as_flying_saucer 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+pkg/*
+*.gem
+.bundle
+.idea/
+.idea/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in acts_as_flying_saucer.gemspec
+gemspec

data/README.markdown

@@ -0,0 +1,153 @@
+acts\_as\_flying\_saucer
+=====================
+
+acts\_as\_flying\_saucer is a library that allows to save rendered views as pdf documents using the [Flying Saucer][1] java library.
+
+[1]: https://xhtmlrenderer.dev.java.net/
+
+Install
+-------
+
+Grab the last version from Github:
+
+    sudo gem install acts_as_flying_saucer
+
+
+Requirements
+------------
+
+JDK 1.5.x or 1.6.x
+
+Usage
+-----
+### Rails
+Just call the acts\_as\_flying\_saucer method inside the controller you want to enable to generate pdf documents.
+Then you can call the render\_pdf method. 
+It accepts the same options as ActionController::Base#render plus the following ones:
+  
+
+:pdf\_file - absolute path for the generated pdf file.
+  
+:send\_file - sends the generated pdf file to the browser. It's the hash the ActionController::Streaming#send\_file method will receive.  
+             
+:password  attach password for generated pdf            
+
+:debug_html - (boolean expected) generates html output to the browser for debugging purposes
+          
+    class FooController < ActionController::Base
+      acts_as_flying_saucer
+    
+      def create
+        render_pdf :template => 'foo/pdf_template'
+      end
+    end
+   
+
+  
+  
+Examples
+--------
+  
+    # Renders the template located at '/foo/bar/pdf.html.erb' and stores the pdf 
+    # in the temp path with a filename based on its md5 digest
+    render_pdf :file => '/foo/bar/pdf.html.erb'
+  
+    # renders the template located at 'app/views/foo.html.erb' and saves the pdf
+    # in '/www/docs/foo.pdf'
+    render_pdf :template => 'foo', :pdf_file => '/www/docs/foo.pdf'
+  
+    # renders the 'app/views/foo.html.erb' template, saves the pdf in the temp path
+    # and sends it to the browser with the name 'bar.pdf'
+    render_pdf :template => 'foo', :send_file => { :filename => 'bar.pdf' }
+    
+    # To send file with password protection
+       render_pdf :template => 'foo', :send_file => { :filename => 'bar.pdf' },:password=>"xxx"
+  Now pdf is password protected
+  
+Easy as pie
+
+While converting the xhtml document into a pdf, the css stylesheets and images should be referenced with absolute URLs(either local or remote) or Flying Saucer will not be able to access them. 
+If there is no asset host defined, it will set automatically during the pdf generation so the parser can access the requested resources:
+
+View rendered in the browser:
+
+    <%= stylesheet_link_tag("styles.css") %>
+    #<link href="/stylesheets/styles.css?1228586784" media="screen" rel="stylesheet" type="text/css" />
+
+
+    <%= image_tag("rails.png") %>
+    # <img alt="Rails" src="/images/rails.png?1228433051" />
+  
+View rendered as pdf:
+
+    <%= stylesheet_link_tag("styles.css") %>
+    #<link href="http://localhost:3000/stylesheets/styles.css" media="print" rel="stylesheet" type="text/css" />
+
+
+    <%= image_tag("rails.png") %>
+    # <img alt="Rails" src="http://localhost:3000/images/rails.png" />
+  
+The stylesheet media type will be set to 'print' if none was given(otherwise it would not be parsed)
+
+If you need to distinguish if the view is being rendered in the browser or as a pdf, you can use the @pdf\_mode variable, whose value will be set to :create
+when generating the pdf version
+
+Sinatra
+-------
+	 get '/' do
+  	   content_type 'application/pdf'
+  	   html_content = erb :index
+       render_pdf(:template=>html_content,:pdf_file=>"test.pdf",
+                :send_file=> {:file_name=>"test.pdf",:stream=>false},:password=>"xxx")
+   end
+Ruby
+----
+	class Pdf
+  		def generate_pdf(input_file_html,output_pdf)
+  	  		options = ActsAsFlyingSaucer::Config.options.merge({:input_file=>input_file_html,:output_file=>output_pdf})
+  		    ActsAsFlyingSaucer::Xhtml2Pdf.write_pdf(options)
+  		end
+	end
+
+Configuration
+-------------
+
+These are the default settings which can be overwritten in your enviroment configuration file:
+
+    ActsAsFlyingSaucer::Config.options = {
+      :java_bin => "java",          # java binary
+      :classpath_separator => ':',  # classpath separator. unixes system use ':' and windows ';'
+      :tmp_path => "/tmp",          # path where temporary files will be stored
+      :max_memory_mb=>512,
+      :nailgun =>false
+    }
+    
+    
+Advance Configuration (TODO: Manually)
+-------------------
+Now acts_as_flying_saucer call java each time on creating pdf this will speed down speed of generaion of pdf.To overcome this start nailgun server that reads data from specific port and rendered pdf.so there is no need to launch the jvm everytime a new pdf is generated.
+
+So to start nailgun with acts_as_flying_saucer plugin:
+
+<code>
+ ./script/plugin install git://github.com/amardaxini/nailgun.git
+</code>
+
+Start nailgun server.Before starting nailgun server make sure that your **classpath environment variable** set and point to jre/lib
+
+<code>
+ script/nailgun start
+</code> 
+<code>
+  rake nailgun
+</code>
+Generate pdf with nailgun you have to overwrite Configuration make **nailgun option to true**
+Now after making nailgun option true run
+
+<code>rake acts_as_flying_saucer</code>
+
+<code>
+ script/flying_saucer_nailgun
+</code>
+
+Now you are ready with nailgun. 

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/acts_as_flying_saucer.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "acts_as_flying_saucer/version"
+
+Gem::Specification.new do |s|
+  s.name        = "acts_as_flying_saucer"
+  s.version     = ActsAsFlyingSaucer::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Amar Daxini"]
+  s.email       = ["amardaxini@gmail.com"]
+  s.homepage    = "http://rubygems.org/gems/acts_as_flying_saucer"
+  s.summary     = %q{XHTML to PDF using Flying Saucer java library}
+  s.description = %q{XHTML to PDF using Flying Saucer java library}
+
+  s.rubyforge_project = "acts_as_flying_saucer"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/acts_as_flying_saucer.rb

@@ -0,0 +1,15 @@
+require 'acts_as_flying_saucer/config'
+require 'acts_as_flying_saucer/xhtml2pdf'
+require 'acts_as_flying_saucer/acts_as_flying_saucer_controller'
+if defined?(Rails)
+	ActionController::Base.send(:include, ActsAsFlyingSaucer::Controller)
+elsif defined?(Sinatra)
+	Sinatra::Base.send(:include, ActsAsFlyingSaucer::Controller)
+	class Sinatra::Base
+		acts_as_flying_saucer
+	end
+end
+
+module ActsAsFlyingSaucer
+
+end

data/lib/acts_as_flying_saucer/acts_as_flying_saucer_controller.rb

@@ -0,0 +1,98 @@
+# ActsAsFlyingSaucer
+module ActsAsFlyingSaucer
+
+	module Controller
+		def self.included(base)
+			base.extend(ClassMethods)
+		end
+
+		private
+
+		# ClassMethods
+		#
+		module ClassMethods
+
+			# acts_as_flying_saucer
+			#
+			def acts_as_flying_saucer
+				self.send(:include, ActsAsFlyingSaucer::Controller::InstanceMethods)
+				class_eval do
+					attr_accessor :pdf_mode
+				end
+			end
+		end
+
+		# InstanceMethods
+		#
+		module InstanceMethods
+
+			# render_pdf
+			#
+			def render_pdf(options = {})
+
+#        host = ActionController::Base.asset_host
+#        ActionController::Base.asset_host = request.protocol + request.host_with_port if host.blank?
+#
+#        logger.debug("#{host} - #{host.nil?} - #{ActionController::Base.asset_host}")
+
+				self.pdf_mode = :create
+				if defined?(Rails)
+					html = render_to_string options
+					if options[:debug_html]
+						#    ActionController::Base.asset_host = host
+						response.header["Content-Type"] = "text/html; charset=utf-8"
+						render :text => html and return
+					end
+					#sinatra
+				elsif defined?(Sinatra)
+					html = options[:template]
+					if options[:debug_html]
+						response.header["Content-Type"] = "text/html; charset=utf-8"
+						response.body << html and return
+					end
+				end
+				# saving the file
+				tmp_dir = ActsAsFlyingSaucer::Config.options[:tmp_path]
+				html_digest = Digest::MD5.hexdigest(html)
+				input_file =File.join(File.expand_path("#{tmp_dir}"),"#{html_digest}.html")
+
+				#logger.debug("html file: #{input_file}")
+
+				output_file = (options.has_key?(:pdf_file)) ? options[:pdf_file] : File.join(File.expand_path("#{tmp_dir}"),"#{html_digest}.pdf")
+				password = (options.has_key?(:password)) ? options[:password] : ""
+
+
+				generate_options = ActsAsFlyingSaucer::Config.options.merge({
+								                                                            :input_file => input_file,
+								                                                            :output_file => output_file,
+								                                                            :html => html,
+				                                                            })
+
+				ActsAsFlyingSaucer::Xhtml2Pdf.write_pdf(generate_options)
+				if  password != ""
+					op=output_file.split(".")
+					op.pop
+					op  << "a"
+					op=op.to_s+".pdf"
+					output_file_name =  op
+					ActsAsFlyingSaucer::Xhtml2Pdf.encrypt_pdf(generate_options,output_file_name,password)
+					output_file = op
+				end
+				# restoring the host
+				# ActionController::Base.asset_host = host
+
+				# sending the file to the client
+				if options[:send_file]
+
+					send_file_options = {
+									:filename => File.basename(output_file)
+									#:x_sendfile => true,
+					}
+					send_file_options.merge!(options[:send_file]) if options.respond_to?(:merge)
+					send_file(output_file, send_file_options)
+				end
+			end
+		end
+	end
+
+end

data/lib/acts_as_flying_saucer/config.rb

@@ -0,0 +1,22 @@
+module ActsAsFlyingSaucer
+
+	class Config
+		# default options
+		class << self
+			attr_accessor :options
+		end
+		ActsAsFlyingSaucer::Config.options = {
+						:java_bin => "java",
+						:classpath_separator => ':',
+						:tmp_path => "/tmp",
+						:run_mode => :once,
+						:max_memory_mb => 512,
+						:nailgun=> false
+		}
+		class << self
+			attr_accessor :options
+		end
+		# cattr_accessor :options
+	end
+
+end

data/lib/acts_as_flying_saucer/java/src/Xhtml2Pdf.java

@@ -0,0 +1,20 @@
+import java.io.*;
+import org.xhtmlrenderer.pdf.ITextRenderer;
+
+public class Xhtml2Pdf
+{
+    public static void main(String[] args) throws Exception {
+       
+        String input = args[0];
+        String url = new File(input).toURI().toURL().toString();
+        String output = args[1];
+        
+        OutputStream os = new FileOutputStream(output);
+        ITextRenderer renderer = new ITextRenderer();
+        renderer.setDocument(url);
+        renderer.layout();
+        renderer.createPDF(os);
+        os.close();
+
+    }
+}

data/lib/acts_as_flying_saucer/java/src/encryptPdf.java

@@ -0,0 +1,20 @@
+import java.io.*;
+import org.xhtmlrenderer.pdf.ITextRenderer;
+import com.lowagie.text.pdf.PdfReader;
+import com.lowagie.text.pdf.PdfWriter;
+import com.lowagie.text.pdf.PdfEncryptor;
+public class encryptPdf
+{
+    public static void main(String[] args) throws Exception {
+       
+        String input = args[0];
+        String output = args[1];
+        String password = args[2];
+
+        PdfReader pr = new PdfReader(input);
+        OutputStream os = new FileOutputStream(output);
+        PdfEncryptor.encrypt(pr,os, false,password,password, PdfWriter.AllowAssembly |
+ PdfWriter.AllowCopy | PdfWriter.AllowDegradedPrinting | PdfWriter.AllowFillIn | PdfWriter.AllowModifyAnnotations | PdfWriter.AllowModifyContents  | PdfWriter.AllowPrinting | PdfWriter.AllowScreenReaders);
+        os.close();
+    }
+}

data/lib/acts_as_flying_saucer/version.rb

@@ -0,0 +1,3 @@
+module ActsAsFlyingSaucer
+  VERSION = "0.0.1"
+end

data/lib/acts_as_flying_saucer/xhtml2pdf.rb

@@ -0,0 +1,36 @@
+module ActsAsFlyingSaucer
+
+	# Xhtml2Pdf
+	#
+	class Xhtml2Pdf
+		def self.write_pdf(options)
+			if 	!File.exists?(options[:input_file])
+				File.open(options[:input_file], 'w') do |file|
+					file << options[:html]
+				end
+			end
+
+			java_dir = File.join(File.expand_path(File.dirname(__FILE__)), "java")
+			class_path = "'.#{options[:classpath_separator]}#{java_dir}/jar/acts_as_flying_saucer.jar'"
+
+			if options[:nailgun]
+				command = "#{Nailgun::NgCommand::NGPATH} Xhtml2Pdf #{options[:input_file]} #{options[:output_file]}"
+			else
+				command = "#{options[:java_bin]} -Xmx512m -Djava.awt.headless=true -cp #{class_path} acts_as_flying_saucer.Xhtml2Pdf #{options[:input_file]} #{options[:output_file]}"
+			end
+			system(command)
+		end
+
+		def self.encrypt_pdf(options,output_file_name,password)
+			java_dir = File.join(File.expand_path(File.dirname(__FILE__)), "java")
+			class_path = "'.#{options[:classpath_separator]}#{java_dir}/jar/acts_as_flying_saucer.jar'"
+			if options[:nailgun]
+				command = "#{Nailgun::NgCommand::NGPATH} encryptPdf #{options[:input_file]} #{options[:output_file]}"
+			else
+				command = "#{options[:java_bin]} -Xmx#{options[:max_memory_mb]}m -Djava.awt.headless=true -cp #{class_path} acts_as_flying_saucer.encryptPdf #{options[:output_file]} #{output_file_name} #{password}"
+			end
+			system(command)
+		end
+
+	end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: acts_as_flying_saucer
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Amar Daxini
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-24 00:00:00 +05:30
+default_executable: 
+dependencies: []
+
+description: XHTML to PDF using Flying Saucer java library
+email: 
+- amardaxini@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.markdown
+- Rakefile
+- acts_as_flying_saucer.gemspec
+- lib/acts_as_flying_saucer.rb
+- lib/acts_as_flying_saucer/acts_as_flying_saucer_controller.rb
+- lib/acts_as_flying_saucer/config.rb
+- lib/acts_as_flying_saucer/java/jar/acts_as_flying_saucer.jar
+- lib/acts_as_flying_saucer/java/src/Xhtml2Pdf.java
+- lib/acts_as_flying_saucer/java/src/encryptPdf.java
+- lib/acts_as_flying_saucer/version.rb
+- lib/acts_as_flying_saucer/xhtml2pdf.rb
+has_rdoc: true
+homepage: http://rubygems.org/gems/acts_as_flying_saucer
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: acts_as_flying_saucer
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: XHTML to PDF using Flying Saucer java library
+test_files: []
+