lunks_rghost 0.8.7.6

data/lib/rghost/grid/csv_grid.rb

@@ -0,0 +1,51 @@
+
+# Grid::CSV allows you to import data from a csv file.
+
+# ===Example
+#
+#  grid=Grid::CSV.new :width => 2
+#  grid.column :title => "User", :align => :right
+#  grid.column :title => "Password", :format => lambda{|v| (v.to_s == "x") ? "Yes" : "No"}
+#  grid.column :title => "UID", :width => 1
+#  grid.column :title => "GID"
+#  grid.column :title => "Gecos", :width => 2.5
+#  grid.column :title => "Home Dir", :width => 4
+#  grid.column :title => "Shell"
+#  grid.style  :bottom_lines
+#  grid.data("/etc/passwd",/:/)
+#
+# link:images/csvgrid01.png
+#
+class RGhost::Grid::CSV < RGhost::Grid::Base
+  # Pass in path to file and the record separator:
+  #  grid.data("/mydir/myfile.csv", ';')
+  # You can use a regular expression for record separator:
+  #  grid.data("/mydir/myfile.csv", /[^\w]/)
+
+  def data(filepath,col_sep=';')
+    _data=filepath
+    first=true
+    _data=File.open(_data) if _data.is_a? String
+    _data.each do |line|
+      l=line.split(Regexp.new(col_sep)) if col_sep.is_a?(String)
+      l=line.split(col_sep) if col_sep.is_a?(Regexp)
+      if first
+        v=l.size-@header.titles.size
+        #v.times{@header.titles << "tt"}
+        #l.each {|h| col(h)} if @header.titles.size == 0
+        l.each {|h| col("")} if @header.titles.size == 0
+        proc_line(l)
+        first=false
+
+        next
+      else
+
+        proc_line(l)
+      end
+    end
+
+  end
+
+
+
+end

data/lib/rghost/grid/dynamic_callback.rb

@@ -0,0 +1,12 @@
+require "rghost/callback" 
+#Dynamic Callbacks
+class RGhost::Grid::DynamicCallback < RGhost::Callback
+  ACCEPT=[:before_row, :after_row, :even_row, 
+            :odd_row, :before_column, :after_column, :even_column, :odd_column]
+      
+  def initialize(name,options={},&block)
+    raise NameError.new("#{name} no accept in #{self.class}") unless ACCEPT.include? name
+    super(name,options,&block)
+  end
+  
+end

data/lib/rghost/grid/field_format.rb

@@ -0,0 +1,43 @@
+$LOAD_PATH << File.dirname(__FILE__)+File::SEPARATOR+"../"
+
+require 'rghost/ps_object'
+
+require 'rghost/ruby_to_ps'
+
+module RGhost::Grid 
+  module FieldFormat 
+    extend RGhost::RubyToPs
+    #Format Time/Date to %d/%m/%Y
+    def self.eurodate(value)
+   
+      string(value.strftime("%d/%m/%Y"))
+    end
+    #Cut all blank spaces
+    def self.no_space(value)
+      string(value.to_s.gsub(/\s/,''))
+    end
+    
+    def self.string(value)
+      to_string(value)
+    end  
+   
+  end
+end
+#Prototype to override format method.
+class RGhost::Grid::FieldFormat::Custom 
+   
+  def initialize(value)
+    @value=value
+  end
+   
+  def gs_format
+    RGhost::Grid::FieldFormat.string(self.format)
+  end 
+
+  def format
+    @value.to_s
+  end
+   
+end
+
+

data/lib/rghost/grid/grid.rb

@@ -0,0 +1,15 @@
+module RGhost::Grid
+  require 'rghost/grid/header'
+  require 'rghost/grid/callback_facade'
+  require 'rghost/grid/style/style'
+  require 'rghost/grid/base_grid'
+  require 'rghost/grid/rails_grid'
+  require 'rghost/grid/matrix'
+  require 'rghost/grid/csv_grid'
+  require 'rghost/grid/dynamic_callback'
+  require 'rghost/grid/static_callback'
+  require 'rghost/grid/field_format'
+end
+
+
+

data/lib/rghost/grid/header.rb

@@ -0,0 +1,120 @@
+$LOAD_PATH << File.dirname(__FILE__)+File::SEPARATOR+"../"
+require "rghost/ps_object"
+require "rghost/ruby_to_ps"
+require "rghost/variable"
+require "rghost/units"
+require "rghost/function"
+require "rghost/callback"
+
+# Grid's Header.
+# You can get a header instance using:
+#  grid=Grid::Rails.new
+#  grid.header
+#
+# You can also define callbacks:
+#
+#  grid.header.before_column :only => [1,2] do
+#   use_tag :span
+#  end
+#
+class RGhost::Grid::Header < RGhost::PsObject
+  include RGhost::RubyToPs
+
+  DEFAULT_OPTIONS={:width => 4, :align => :center, :title_align => nil, :header_width => nil, :format => :string}
+  attr_reader :data_types, :titles, :size
+
+  def initialize(headings=true,options={},&block) #:nodoc:
+    @header=RGhost::PsObject.new
+    @data_types=[]
+    @options=[]
+    @titles=[]
+    @header.set RGhost::Variable.new(:new_page?,true)  
+    @default_options=DEFAULT_OPTIONS.merge(options)
+    @header.set RGhost::Variable.new(:headings?,headings)
+    @size=0
+    instance_eval(&block) if block
+
+  end
+
+  def ps
+    
+    p,h=format_header
+    @header.set RGhost::Variable.new(:header_titles,to_array(@titles))
+    @header.set RGhost::Variable.new(:table_params," [\n #{p}] \n")
+    @header.set RGhost::Variable.new(:table_header," [\n #{h}] \n")
+
+
+    @header
+  end
+
+  def col(name="", options={}) #:nodoc:
+    
+    opts=@default_options.merge(options)
+    @size+=opts[:width]
+    @data_types << opts[:format]
+    @options << opts
+    @titles <<  ps_escape(name.to_s)
+
+  end
+
+  def default_options(opts) #:nodoc:
+    @default_options.merge!(opts)
+
+  end
+
+  def column(name,options={}) #:nodoc:
+    col(name,options)
+  end
+
+  def next_column(name,options={}) #:nodoc:
+    col(name,options)
+  end
+
+  def before_create(&block)
+    #@header.set RGhost::Function.new(:before_header_create, &block )
+    new_static_callback(:before_header_create,&block)
+  end
+
+
+  def after_create(&block)
+    #@header.set RGhost::Function.new(:after_header_create, &block )
+    new_static_callback(:after_header_create,&block)
+  end
+
+  def before_column(options={},&block)
+    @header.set RGhost::Callback.new(:before_column_header, options,&block)
+
+  end
+
+  def after_column(options={},&block)
+    @header.set RGhost::Callback.new(:after_column_header,options,&block)
+
+  end
+
+  private
+  def new_static_callback(name,&block)
+
+    callback_body= RGhost::PsFacade.new(&block)
+    @header.set RGhost::Function.new(name,callback_body)
+  end
+  def format_header
+    p='' #params
+    h='' #params_head
+    o=@options.dup
+    o.each do |v|
+      v[:title_align]||=v[:align]
+      v[:header_width]||=v[:width]
+      p << "[ #{RGhost::Units::parse(v[:width])} /st_#{v[:align]}]\n "
+      h << "[ #{RGhost::Units::parse(v[:header_width])} /st_#{v[:title_align]}]\n "
+    end
+
+    return p,h
+
+  end
+
+
+end
+
+
+
+

data/lib/rghost/grid/matrix.rb

@@ -0,0 +1,10 @@
+# Implements data method for Grid::Base. You can consult the examples at Grid::Base.
+class RGhost::Grid::Matrix < RGhost::Grid::Base
+
+  def data(_data)
+    _data.each{|d| proc_line(d) }
+
+  end
+
+end
+

data/lib/rghost/grid/rails_grid.rb

@@ -0,0 +1,74 @@
+require 'rghost/ps_object'
+#
+# Grid::Rails mapps grid columns to ActiveRecord attributes. For
+# example, let's take a Calls class to represent telephone calls.
+#
+# ===Example
+#   rails_grid=Grid::Rails.new(:align => :center, :width => 3)
+#
+# Mapping, first the attribute name then the already known optionsName
+#  rails_grid.column :mobile,   :title => "Mobile", :align => :right
+#  rails_grid.column :duration, :title => "Duration",:width => 3
+#  rails_grid.column :start,    :title => "Start", :format => :eurodate
+#  rails_grid.column :called,   :title => "Number", :align => :right, :title_align => :center
+# Load data
+#   calls = Call.find(:all, :limit => 5000)
+#   rails_grid.data(calls)
+# ====Relationships
+# You can also use attributes of associated objects, via a block or
+# string. For example consider Accounts and Customers
+# relationship. Let's produce a grid od all Customers plus some data
+# reffering to the first account the customer had created.
+#
+#   class Accounts < ActiveRecord::Base
+#     belongs_to :customer
+#   end
+#   class Customers < ActiveRecord::Base
+#     has_many :accounts
+#   end
+#
+#   c = Customers.find(:all, :include => :accounts )
+#
+# Using a block
+#   g=Grid::Rails.new  :width => 4
+#   g.column :id,         :title => "Customer id"
+#   g.column :name,       :title => "Name",   :width => 6
+#   g.column :created_on, :title => "Date ",  :format => lambda{|d| d.strftime("%m/%d/%Y") }
+#   g.column lambda { accounts.first.login }, :title => "Login"
+#   g.column lambda { accounts.first.type },  :title => "Account Type"
+#   g.data(c)
+# Or a String
+#   g.column 'accounts.first.login', :title => Login"
+class RGhost::Grid::Rails < RGhost::Grid::Base
+  #The parameter +_data+ is an Array of ActiveRecord::Base objects.
+  def data(_data)
+    _data.collect do |d|
+      line=@rails_cols.collect do |c|
+        case c[:field_name]
+          when Symbol
+            d[c[:field_name]]
+          when String
+            d.instance_eval c[:field_name]
+          when Proc
+            d.instance_eval(&c[:field_name])
+        end
+      end
+      proc_line(line)
+    end
+  end
+
+  def col(field_name, options={}) #:nodoc:
+    super(options[:title],options)
+     
+    @rails_cols||=[]
+    owf=options.dup #from options with field
+    owf[:field_name]||=field_name
+    @rails_cols << owf
+
+  end
+
+  def column(field_name, options={}) #:nodoc:
+    col(field_name,options)
+  end
+
+end

data/lib/rghost/grid/static_callback.rb

@@ -0,0 +1,13 @@
+require "rghost/ps_object"
+require "rghost/function"
+
+class RGhost::Grid::StaticCallback < RGhost::Function
+  ACCEPT=[:before_table_create, :after_table_create]
+
+  def initialize(name,&block)
+    raise NameError.new("#{name} no accept in #{self.class}") unless ACCEPT.include? name
+    super(name,&block)
+  end
+
+end
+

data/lib/rghost/grid/style/border_lines.rb

@@ -0,0 +1,44 @@
+class RGhost::Grid::Style::BorderLines
+  
+  def set_style(grid)
+
+    grid.before_row do |b|
+      
+      b.horizontal_line(:top,    :size => grid.width)
+      b.horizontal_line(:bottom,    :size => grid.width)
+    end
+
+    grid.before_column :only => 0 do |b|
+      b.vertical_line_row
+    end
+    
+    grid.after_column do |c|
+      c.vertical_line_row
+    end
+    
+    
+    grid.header.before_create do |c|
+      c.line_width(0)
+      c.use_tag :bold
+      c.horizontal_line(:top, :size => grid.width)
+      c.horizontal_line(:bottom,:size => grid.width)
+    end
+    
+    grid.header.after_create {|a| a.use_tag :normal }
+  
+
+    grid.header.before_column :only => 0 do |h|
+      h.vertical_line_row
+    end
+    
+    grid.header.after_column do |h|
+      h.vertical_line_row
+    end
+    
+    
+    
+    
+  end
+
+
+end

data/lib/rghost/grid/style/bottom_lines.rb

@@ -0,0 +1,28 @@
+class RGhost::Grid::Style::BottomLines
+  
+  def set_style(grid)
+
+    size=grid.header.size
+    grid.before_row do |b|
+       b.horizontal_line(:bottom,:size => grid.width)
+
+    end
+    
+    grid.header.before_create do |h|
+      h.line_width(0)
+      h.horizontal_line(:bottom,:size => grid.width)
+      h.use_tag :bold
+    end
+    
+    grid.header.after_create {|h| h.use_tag :normal }
+      
+  
+
+    
+    
+    
+    
+  end
+
+
+end

data/lib/rghost/grid/style/old_forms.rb

@@ -0,0 +1,28 @@
+class RGhost::Grid::Style::OldForms
+  
+  def set_style(grid)
+
+    size=grid.header.size
+    grid.odd_row do |o|
+      o.background_row(:size => size)
+
+    end
+    
+    grid.header.before_create do |h|
+      h.line_width(0)
+      h.background_row(:size => size, :color => RGhost::ShapeContent::DEFAULT_OPTIONS[:color] )
+      h.use_tag :bold
+    end
+    
+    grid.header.after_create {|h| h.use_tag :normal }
+      
+  
+
+    
+    
+    
+    
+  end
+
+
+end

data/lib/rghost/grid/style/style.rb

@@ -0,0 +1,8 @@
+
+module RGhost::Grid 
+  module Style
+    require 'rghost/grid/style/border_lines'
+    require 'rghost/grid/style/old_forms'
+    require 'rghost/grid/style/bottom_lines'
+  end
+end

data/lib/rghost/gs_alone.rb

@@ -0,0 +1,25 @@
+class RGhost::GSAlone #:nodoc:
+  
+  def initialize(params,debug=false)
+    @params=params.dup
+    @params[0]=" "
+    @debug=debug
+  end
+  
+  def run
+    cmd=@params.join(" ")
+    #puts File.exists?(RGhost::Config::GS[:path].to_s)
+    unless File.exists?(RGhost::Config::GS[:path].to_s)
+      RGhost::Config.config_platform
+    end
+    r=system(RGhost::Config::GS[:path]+cmd)
+    
+    puts RGhost::Config::GS[:path]+cmd if @debug
+    #puts r
+    r
+  end
+  
+
+  
+end
+

data/lib/rghost/helpers.rb

@@ -0,0 +1,13 @@
+module RGhost::UnlessHelpers #:nodoc:
+  module HashKeyMethod #:nodoc:
+    def method_missing(method, *args)
+      self[method.to_sym]   
+    end
+  end
+  
+  class HashKeyMethodClass < Hash #:nodoc:
+    include HashKeyMethod
+  end
+
+
+end

data/lib/rghost/horizontal_line.rb

@@ -0,0 +1,45 @@
+require "rghost/ps_object"
+require "rghost/units"
+#Creates horizontal line on the current row.
+class RGhost::HorizontalLine < RGhost::PsObject
+  
+  DEFAULT_OPTIONS={:start_in => :limit_left, :size => :area_x,
+    :border => RGhost::Border::DEFAULT_OPTIONS
+    
+  }
+ 
+#Examples
+#
+#Drawing line on middle
+#
+# doc.show "Foo Bar"
+# doc.horizontal_line :middle
+# 
+#link:images/horizontal_line01.png
+#
+#Drawing line on bottom and customizing border attributes
+#
+# doc.show "Foo Bar"
+# doc.horizontal_line :bottom, :border => {:dash => [1,2,2,2], :color => :red}
+#
+#link:images/horizontal_line02.png
+#
+#Specifies size and where will start of line
+#
+# doc.show "Foo Bar"
+# doc.horizontal_line :top, :start_in => 2, :size => 5, :border => {:dash => [1,2,2,2], :color => :red}
+#
+#link:images/horizontal_line03.png
+
+  
+  def initialize(valign=:middle,options={})
+    @options=DEFAULT_OPTIONS.dup.merge(options)
+    start_in= RGhost::Units::parse(@options[:start_in])
+    size= RGhost::Units::parse(@options[:size])
+    border=RGhost::Border.new(@options[:border])
+    super("gsave #{border.ps }  #{start_in} #{size} horizontal_line_#{valign} grestore")
+    #super("#{start_in} #{size} horizontal_line_#{valign}")
+  
+  end
+  
+end

data/lib/rghost/how_to.rb

@@ -0,0 +1,75 @@
+#=Ruby Ghostscript engine - Document Builder
+#==About
+#RubyGhost (RGhost) is a library for document developers wanting a quick and easy 
+#way to generate pdf files. Notable features include: inserting images, 
+#vector drawing , font suppoort , EPS template support and multiple output formats. 
+#RGhost acts as Ruby a wrapper over the Ghostscript engine enriched by predefined 
+#set Postscript(ps) functions. For example:
+#
+#Ruby code you'll write: 
+#
+#  h=HorizontalLine.new :middle, :start_in => 3, :size => 2
+#
+#gets translated to the following Postscript function. Note how this is not actually 
+#raw Postscript, instead it makes use of a set of predefined functions shipped with Rghost. 
+#
+#  3 unit 2 unit exch gsave current_row row_height sqrt add moveto 0 rlineto stroke grestore
+#
+#Unless embarking into deep Postscript wizardry you don't need to be aware of this fact. 
+#Basically RGhost is a helper for creating of Postscript documents. 
+#The resulting Postscript document is rendered to the target format (usually pdf but not just) 
+#by invoking  Ghostscript the free Postscript interpreter. Ghostscript settings very 
+#a lot depending on your platform. Initially RGhost was developed for *nix environments 
+#where Ghostscript is (almost always) native and used as a printing filter (CUPS, LPRng etc) 
+#and also as a document format converter. So it became necessary to make an interface 
+#between Ruby and Ghostscript in two ways:
+#
+#* gsapi     - based on the exchange of data between Ruby and Ghostscript via rgengine.so using gslib.so.8 or gslib-esp.so.8 
+#* gsparams  - In this mode RGhost just pass parameters to the Ghostscript framework.1.1 Files
+#	
+#During the conversion of the postscript code to the desired format 4 files are created, 3 of them being temporary.
+#
+#====Input
+#The input file is a pure postscript file with a .rgin extension that will be automatically removed after the conversion process, even if errors show up.
+#
+#====Errors
+#Using a .rgerr extension, its content are the errors generated by ghostscript. It'll be deleted after the conversion. The content of the file is available on the errors variable of the RubyGhostEngine class.
+#
+#====Log
+#The log file is set using the option :logfile of the RubyGhostEngine class, appending all logs to it. Disabled by default.
+#
+#====Output
+#The output files will have the extension passed to the RGhost::Document#render method. For multi page formats it will return an array of files. These files aren't deleted automatically, meaning that the developer will have to deal with them.
+#====Author
+#Shairon Toledo  shairon.toledo(at)gmail.com http://www.hashcode.eti.br Brazil Jun/2008
+#====Thanks
+#Dee Zsombor[http://deezsombor.com] and Mereghost
+#   
+#==Installation and Setup
+#====Ghostscript
+#You need to have ESP Ghostscript 8.xx or GNU Ghostscript 8.xx installed
+#
+#=====Non-coupled installation: *gsparams* (recommended)
+#This is the simplest setup, you'll have to dowload and install the Ghostscript framework(http://www.cs.wisc.edu/~ghost/). 
+#Rhgost will invoke the ghostscript interpreter in the background to generate the desired output.
+#
+#===== Coupled installation: *gslib* (Linux only) 
+#You can use the native ghostrcipt interface via the  gs-esp and libgs-esp8 (libgs-esp.so) packages. This may be already set up for you on Linux or you'll have to compile ghostscript
+#=====Installation via remote gem
+#  gem install rghost
+#  
+#=====Rails plugin installation 
+#Gets last version in RubyForge[http://rubyforge.org/frs/?group_id=3796&release_id=18301] unpack on RAILS_ROOT/lib
+#====Setup
+#Look at RGhost::Config
+#==Namespace 
+#You can work either full namespace of including RGhost module. 
+#=====Full namespace
+# doc=RGhost::Document.new
+#=====Including module RGhost
+# include RGhost
+# doc=Document.new
+
+class RGhost::HowTo
+  
+end

data/lib/rghost/image.rb

@@ -0,0 +1,29 @@
+require "rghost/ps_object"
+#Super class of GIF and JPEG.
+class RGhost::Image < RGhost::PsObject
+  DEFAULT_OPTIONS={:x=> :limit_left, :y=> 1, :zoom => 100, :rotate => 0}
+  
+  def initialize(image_path,options={})
+    super("")
+    @options=DEFAULT_OPTIONS.dup.merge(options)
+    @file=image_path
+  end
+  
+  #Facade method for load image by file extension. Uses Eps, Gif and Jpeg class. Accepts gif, jpeg, jpg and eps
+  def self.for(path,options={})
+    
+    clazz=case path
+      when /gif$/i
+        RGhost::Gif
+      when /jpe?g$/i
+        RGhost::Jpeg
+      when /(eps|template)$/i
+          RGhost::Eps
+      else raise NameError.new("Unsupported format")
+    end
+    
+    clazz.new(path,options)
+  end
+  
+  
+end  

data/lib/rghost/jpeg.rb

@@ -0,0 +1,39 @@
+require "rghost/ps_object"
+require "rghost/graphic"
+require "rghost/cursor"
+require "rghost/variable"
+require "rghost/image"
+  #Loads JPEG image from file
+  #===Examples
+  # doc=Document.new
+  # doc.set Jpeg.new "../public/images/button.jpg", :x => 10, :y => 3
+  #Using Image.for facade 
+  # doc.set Image.for "../public/images/button.jpg", :x => 10, :y => 3
+  #Using PsFacade or Document 
+  # doc.image "images/button.jpg", :x => 10, :y => 3
+  #Using Zoom of the 200 percent
+  # doc.image "images/button.jpg", :zoom => 200
+  #===Options
+  #
+  #* <tt>:x and :y</tt> - Coordinates to position.
+  #* <tt>:rotate</tt> - Angle to image rotation if there is one.
+  #* <tt>:zoom</tt> - Resize proportionally the image
+class RGhost::Jpeg < RGhost::Image
+
+
+
+  def ps
+    #x=Units::parse( @options[:x] )
+    #y=Units::parse( @options[:y] )
+    
+    g=RGhost::Graphic.new 
+    g.set RGhost::Cursor.translate(@options)
+      #set Cursor.translate()
+    g.set RGhost::Cursor.rotate(@options[:rotate])
+    g.set RGhost::Variable.new(:zoom,@options[:zoom]/100.0)
+    g.set RGhost::PsObject.new("(#{@file}) viewJPEG")
+    g.ps
+
+  end
+
+end