rghost 0.7.4 → 0.8

data/lib/rghost/grid/base_grid.rb

@@ -0,0 +1,218 @@
+require 'enumerator'
+# RGhost::Grid::Base is a helper object to create a tabular
+# representations, composed of rows, columns and a title.  This
+# prototype used to join the common attributes for data grids. To use
+# a Grid you must first setup the columns, then load the data.
+#
+# Example:
+#  grid=Grid::Matrix.new
+#  grid.column :title => "Code", :width => 1
+#  grid.column :title => "Name", :width => 3, :align => :center
+#  grid.column :title => "Date", :width => 3, :align => :center
+#
+# Note that both the width and align of the last two columns are
+# identical. To avoid repetition, you can specify a default width upon
+# creating the DataGrid::Grid object. Any columns that do not specify
+# an explicit width and align property will inherit the defaults.
+#
+# Example:
+#
+#  grid=Grid::Matrix.new :width => 3, :align => :center
+#  grid.column :title => "Code", :width => 1    #:width => 1, :align => :center
+#  grid.column :title => "Name"                 #:width => 3, :align => :center
+#  grid.column :title => "Date"                 #:width => 3, :align => :center
+#
+# The actual content needs to be passed in as an array of arrays
+#
+#  values=[
+#    [1,"Name 1", Time.now],
+#    [2,"Name 2", Time.now],
+#    [3,"Name 3", Time.now],
+#    [4,"Name 4", Time.now],
+#    [5,"Name 5", Time.now]
+#  ]
+#
+# Bind the content to the grid:
+#  grid.data(values)
+# Add the Grid to a document
+#  d=Document.new
+#  d.set grid
+#
+class RGhost::Grid::Base < RGhost::PsObject
+  attr_reader :header
+  attr_accessor :column_padding
+  include RGhost::RubyToPs
+  include RGhost::Grid::CallbackFacade
+
+  #===Options
+  #* <tt>:headings</tt> - To disable headers set this attribute to false.
+  #* <tt>:column_padding</tt> - Padding between column content and its edge.
+  #* <tt>:width</tt> - Width for all columns.
+  #* <tt>:align</tt> - Align for all  data(:left, :center and :right).
+  #* <tt>:title_align</tt> - Align for all the header's name(:left, :center and :right).
+  def initialize(options={})
+
+    @header=RGhost::Grid::Header.new( (options[:headings] == false)?false:true  )
+    @header.default_options(options)
+    @callbacks=RGhost::PsObject.new
+    @column_padding= options[:column_padding] || 0.1
+    @record_count=1
+    @data=[]
+    @data[0]=[]
+    @data_index=0
+    @max_stack=RGhost::Config::GS[:stack_elements]
+  end
+
+
+  # Defines properties of a column. Parameters are the same as for new,
+  # plus some additional ones like :format.
+  # * <tt>:format</tt> - Format of the data. You can format data in four
+  #                      different ways with Rghost, passing in a Symbol
+  #                      a String a Class or Proc.
+  #
+  # ==== :format Parameters type
+  # * Symbol - Searches for a method defined as  Grid::FieldFormat::method_name
+  #  :format => :eurodate
+  # * Class - A class that inherits Grid::FieldFormat::Custom with a overridden format method.
+  #  :format => MyFormat
+  # * String - Formats using the same parameters used in sprintf
+  #  :format => "%0.2f"
+  # * Proc - A block. In the  example a text limited to 9 characters.
+  #  :format => lambda {|s| s.gsub(/^(.{9}).*$/,'\1...')}
+  # ====Customizing formats
+  # Replace spaces with a double dash.
+  #  class MyFormat < DataGrid::FieldFormat::Custom
+  #   def format
+  #      @value.to_s.gsub(/ /,'--')
+  #   end
+  #  end
+  #
+  # Using
+  #
+  #  grid.column :title => "Name", :format => MyFormat
+  #
+  # Below, the columns with their proper formats.
+  #
+  #  grid.column :title => "Code",:format => "(%d)", :width => 1
+  #  grid.column :title => "Name",  :format => MyFormat
+  #  grid.column :title => "Date",  :format => lambda {|date| date.strftime("%d/%m/%Y") }
+  #  values=[
+  #    [1,"Name 1", Time.now],
+  #    [2,"Name 2", Time.now],
+  #    [3,"Name 3", Time.now],
+  #    [4,"Name 4", Time.now],
+  #    [5,"Name 5", Time.now]
+  #  ]
+  #  grid.data(values)
+  # Add the Grid to a document
+  #
+  #  d=Document.new
+  #  d.set grid
+  # link:images/format01.png
+  def col(title="", options={})
+    if title.is_a? Hash
+      @header.col(title[:title],title)
+    else
+      @header.col(title[:title],options)
+    end
+  end
+  #Alias for col
+  def column(title="", options={})
+    col(title,options)
+
+  end
+
+  def format_field(value,type) #:nodoc:
+    case type
+    when Symbol: RGhost::Grid::FieldFormat.send(type,value)
+    when String: RGhost::Grid::FieldFormat.string(type % value)
+    when NilClass: RGhost::Grid::FieldFormat.string(value)
+    when Class: type.new(value).gs_format
+    when Proc: RGhost::Grid::FieldFormat.string(type.call(value))
+
+    else raise TypeError.new("type=#{type}, value type=#{value.class}")
+    end
+
+  end
+  def width
+    @header.size
+  end
+  def proc_line(line) #:nodoc:
+    h=@header.data_types
+    rec=[]
+    line.each_with_index do |v,i|
+      #puts "#{i} == #{h[i]} = #{v}, #{format_field(v,h[i])}"
+      rec << format_field(v,h[i])
+    end
+    @data[@data_index] <<  "[#{rec}]\n"
+
+
+    if @record_count == @max_stack
+      @record_count=0
+      @data_index+=1
+      @data[@data_index]=[]
+    end
+    @record_count+=1
+
+
+  end
+  #Defines data to grid processor.
+  def data(data)
+
+  end
+  public
+
+  def ps
+
+
+    grid_names=[]
+    p=RGhost::PsObject.new
+    p.set RGhost::Variable.new(:col_padding,RGhost::Units::parse(@column_padding))
+    @data.each do |ary|
+      r=(rand*99999).to_i
+      p.raw "/data#{r}[\n#{ary.join}\n] def"
+      grid_names << r
+    end
+    p.raw "#{@header.ps} #{@callbacks}"
+
+    g=RGhost::Graphic.new do
+      raw :before_table_create
+      raw grid_names.map{|m| " data#{m} table_proc \n" }.join
+      raw :after_table_create
+    end
+    p.set g
+    p.raw :nrdp
+    p
+
+
+  end
+
+  # Grid has 3 preset styles :bottom_lines, :border_lines and
+  # old_forms. To set any of them, use:
+  #
+  #   grid.style(:border_lines)
+  #
+  # :border_lines - instance of Grid::Style::BorderLines
+  #
+  # link:images/setstyle01.png
+  #
+  # :bottom_lines - instance of Grid::Style::BottomLines
+  #
+  # link:images/setstyle02.png
+  #
+  # :old_forms - instance of Grid::Style::OldForms
+  #
+  # link:images/setstyle03.png
+  def style(type=:border_lines)
+    st=case type
+    when :border_lines: RGhost::Grid::Style::BorderLines.new
+    when :old_forms: RGhost::Grid::Style::OldForms.new
+    when :bottom_lines: RGhost::Grid::Style::BottomLines.new
+    else raise NameError.new("Why? #{type} ?")
+    end
+
+    st.set_style(self)
+
+  end
+
+end

data/lib/rghost/grid/callback_facade.rb

@@ -0,0 +1,136 @@
+
+module RGhost::Grid
+  # The callbacks for the grid are defined here. Let's see them in action.
+  # ===Grid::CallbackFacade examples
+  #  grid=Grid::Matrix.new :column_padding => 1
+  #  grid.column :title => "Id", :width => 1
+  #  grid.column :title => "Name", :width => 3, :align => :center
+  #  grid.column :title => "Date", :width => 3, :align => :right, :title_align => :center,  :format => lambda{|v| v.strftime("%d/%m/%Y")}
+  #  values=('A'..'E').to_a.map{|v|  [v,"Name #{v}", Time.now]}
+  #
+  # even_row:
+  #  grid.even_row do
+  #   background_row(:size => grid.width)
+  #  end
+  # link:images/grid01.png
+  #
+  # Now before_row to create a top and bottom line:
+  #  grid.before_row do
+  #   horizontal_line(:top,    :size => grid.width )
+  #   horizontal_line(:bottom, :size => grid.width)
+  #  end
+  #
+  # link:images/grid02.png
+  #
+  # before_column:
+  #  grid.before_column do
+  #   vertical_line_row
+  #  end
+  #
+  # link:images/grid03.png
+  #
+  # after_column:
+  #  grid.after_column {  vertical_line_row  }
+  #
+  #
+  # link:images/grid04.png
+  #
+  # Moving to the header
+  #  grid.header.before_create do
+  #   horizontal_line(:top, :size => grid.width)
+  #  end
+  #
+  # link:images/grid05.png
+  #
+  # Finishing the grid lines:
+  #  grid.header.before_column do
+  #    vertical_line_row
+  #  end
+  #
+  #
+  #  grid.header.after_column do
+  #   vertical_line_row
+  #  end
+  #
+  # link:images/grid06.png
+  #
+  # Now a adding a bold font to the header
+  #  grid.header.before_create do
+  #    horizontal_line(:top, :size => grid.width)
+  #    use_tag :bold
+  #   end
+  #
+  # link:images/grid07.png
+  #
+  # Oops. Not quite what we expected, the entire grid used bold
+  # face. We need to use a header callback to reset the font.
+  #
+  #  grid.header.after_create do
+  #     use_tag :normal
+  #   end
+  #
+  # link:images/grid08.png
+  #
+  # Don't forget
+  #
+  #  doc=Document.new
+  #  doc.set grid
+  module CallbackFacade
+
+    # Executes before processing row. Responds to :only and :except
+    # options.
+    def before_row(options={},&block)
+      new_dynamic_callback(:before_row,options,&block)
+    end
+
+    # Executes on creating an odd rows. Responds to :only and :except
+    # options.
+    def odd_row(options={},&block)
+      new_dynamic_callback(:odd_row,options,&block)
+    end
+
+    # Executes upon creating even rows. Responds to :only and :except
+    # options.
+    def even_row(options={},&block)
+      new_dynamic_callback(:even_row,options,&block)
+    end
+
+    # Executes before creating a column. Responds to :only and :except
+    # options.
+    def before_column(options={},&block)
+      new_dynamic_callback(:before_column,options,&block)
+    end
+
+    # Executes after a column was created. Responds to :only and
+    # :except options.
+    def after_column(options={},&block)
+      new_dynamic_callback(:after_column,options,&block)
+    end
+
+    # Executes when creating an odd column. Responds to :only and
+    # :except options.
+    def odd_column(options={},&block)
+      new_dynamic_callback(:odd_column,options,&block)
+    end
+
+    # Executes upon creating an even column. Responds to :only and
+    # :except options.
+    def even_column(options={},&block)
+      new_dynamic_callback(:even_column,options,&block)
+    end
+
+
+    private
+
+    def new_dynamic_callback(name,options={},&block)
+      @callbacks.set RGhost::Callback.new(name,options,&block)
+    end
+    def new_static_callback(name,&block)
+
+      callback_body= RGhost::PsFacade.new(&block)
+      @callbacks.set RGhost::Function.new(name,callback_body)
+    end
+
+
+  end
+end

data/lib/rghost/grid/csv_grid.rb

@@ -0,0 +1,50 @@
+
+# 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)}
+        proc_line(l)
+        first=false
+
+        next
+      else
+
+        proc_line(l)
+      end
+    end
+
+  end
+
+
+
+end

data/lib/rghost/{data_grid → grid}/dynamic_callback.rb

@@ -1,6 +1,6 @@
 require "callback" 
-#Callbacks Din�micos a n�vel de Grid
-class DataGrid::DynamicCallback < Callback
+#Callbacks Din�micos a n�vel de Grid
+class RGhost::Grid::DynamicCallback < RGhost::Callback
   ACCEPT=[:before_row, :after_row, :even_row, 
             :odd_row, :before_column, :after_column, :even_column, :odd_column]
       

data/lib/rghost/grid/field_format.rb

@@ -0,0 +1,43 @@
+$LOAD_PATH << File.dirname(__FILE__)+File::SEPARATOR+"../"
+
+require 'ps_object'
+
+require '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 'grid/header'
+  require 'grid/callback_facade'
+  require 'grid/style/style'
+  require 'grid/base_grid'
+  require 'grid/rails_grid'
+  require 'grid/matrix'
+  require 'grid/csv_grid'
+  require 'grid/dynamic_callback'
+  require 'grid/static_callback'
+  require 'grid/field_format'
+end
+
+
+

data/lib/rghost/grid/header.rb

@@ -0,0 +1,120 @@
+$LOAD_PATH << File.dirname(__FILE__)+File::SEPARATOR+"../"
+require "ps_object"
+require "ruby_to_ps"
+require "variable"
+require "units"
+require "function"
+require "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 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,70 @@
+require '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/{data_grid → grid}/static_callback.rb

@@ -1,13 +1,13 @@
 require "ps_object"
 require "function"
-#Callbacks est�ticos a n�vel de Grid
-class DataGrid::StaticCallback < 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