rghost-ruby1.9-beta 0.8.7.2

data/lib/rghost/grid/base_grid.rb

@@ -0,0 +1,228 @@
+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,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 |e|
+  #   e.background_row(:size => grid.width)
+  #  end
+  # link:images/grid01.png
+  #
+  # Now before_row to create a top and bottom line:
+  #  grid.before_row do |b|
+  #   b.horizontal_line(:top,    :size => grid.width )
+  #   b.horizontal_line(:bottom, :size => grid.width)
+  #  end
+  #
+  # link:images/grid02.png
+  #
+  # before_column:
+  #  grid.before_column do |v|
+  #   v.vertical_line_row
+  #  end
+  #
+  # link:images/grid03.png
+  #
+  # after_column:
+  #  grid.after_column {|c|  c.vertical_line_row  }
+  #
+  #
+  # link:images/grid04.png
+  #
+  # Moving to the header
+  #  grid.header.before_create do |b|
+  #   b.horizontal_line(:top, :size => grid.width)
+  #  end
+  #
+  # link:images/grid05.png
+  #
+  # Finishing the grid lines:
+  #  grid.header.before_column do |b|
+  #    b.vertical_line_row
+  #  end
+  #
+  #
+  #  grid.header.after_column do |b|
+  #   b.vertical_line_row
+  #  end
+  #
+  # link:images/grid06.png
+  #
+  # Now a adding a bold font to the header
+  #  grid.header.before_create do |b|
+  #    b.horizontal_line(:top, :size => grid.width)
+  #    b.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
+  #     b.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,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
+
+