dm_core 4.2.1.5

data/lib/dm_core/csv_exporter.rb

@@ -0,0 +1,210 @@
+require 'csv'
+require 'dm_core/scio_excel'
+
+# require 'ruport'
+
+# Implements CSV Export functionality
+#------------------------------------------------------------------------------
+module CsvExporter
+
+  # include Ruport
+  # include DmUtilities::RenderingHelper
+  
+  #------------------------------------------------------------------------------
+  def data_export(column_definitions, data_array, options = {})
+    case options[:format]
+    when 'xls'
+      excel_export(column_definitions, data_array, options)
+    when 'ruport'
+      # ruport_export(column_definitions, data_array, options)
+    else
+      csv_export(column_definitions, data_array, options)
+    end
+  end
+
+  # Exports data to a CSV formatted file.
+  # column_definitions: defines the name of the fields and how they are accessed.
+  #   Array of items, where each item is an array of 
+  #     name used in CSV column
+  #     name used to access the value in the data records
+  #     width of field
+  #     optional formatting instructions as a Hash
+  #     ex)
+  #        column_definitions = []
+  #        column_definitions <<     ["Receipt Code",      "'R-' + item.receipt_code", 75]
+  #        column_definitions <<     ["State",             "item.state.capitalize"]
+  #        column_definitions <<     ['Process State',     'item.aasm_state', 100]
+  #        column_definitions <<     ['Registered on',     'item.created_at.to_date', 75, {:type => 'DateTime', :numberformat => 'd mmm, yyyy'}]
+  #        column_definitions <<     ["Price",             "item.workshop_price.price.to_f", nil, {:type => 'Number', :numberformat => '#,##0.00'}]
+  #
+  # data_array: an array of objects (link from a find)
+  # :filename => 'file_name' name of file to save as.
+  # :expressions => true : the data definintion can be a complex expression, 
+  #    so simply evaluate it directly. To access the current item, the expression
+  #    should use 'item', as in 'item.name.blank? ? "n/a" : item.name'
+  #------------------------------------------------------------------------------
+  def csv_export(column_definitions, data_array, options = {})
+    options.symbolize_keys
+    outputArray = Array.new
+    csv_string  = CSV.generate do |csv|
+      column_definitions.each { |x| outputArray << x[0] }
+      csv << outputArray
+
+      data_array.each do |item|
+        outputArray.clear
+        column_definitions.each do |x|
+          data = get_data_value(item, x[1], options)
+          #data = "\"#{data}\"" if data.include?(',') #--- add quotes if comma included
+          outputArray << data
+        end            
+        csv << outputArray
+      end
+    end
+    if options[:filename]
+      send_data csv_string, :filename => to_csv_filename(options[:filename]), :disposition => 'attachment', :type => 'text/csv'
+    else
+      return csv_string
+    end
+  end
+
+  # Exports data to a CSV formatted file, using columns directly from a table
+  # table_name: name of the table exporting. Column names are pulled from it.
+  # data_array: an array of hashes (link from a find)
+  #------------------------------------------------------------------------------
+  def csv_export_rawtable(table_name, data_array, options = {})
+    column_definitions = Array.new
+    for column in eval("#{table_name}.content_columns")
+        column_definitions << [column.name, column.name]
+    end
+    csv_export(column_definitions, data_array, options)
+  end
+
+  # Exports data to an Excel formatted file.
+  # column_definitions: defines the name of the fields and how they are accessed.
+  #   Array of items, where each item is an array of 
+  #     name used in CSV column
+  #     name used to access the value in the data records
+  #     width of field
+  #     optional formatting instructions as a Hash
+  #     ex)
+  #        column_definitions = []
+  #        column_definitions <<     ["Receipt Code",      "'R-' + item.receipt_code", 75]
+  #        column_definitions <<     ["State",             "item.state.capitalize"]
+  #        column_definitions <<     ['Process State',     'item.aasm_state', 100]
+  #        column_definitions <<     ['Registered on',     'item.created_at.to_date', 75, {:type => 'DateTime', :numberformat => 'd mmm, yyyy'}]
+  #        column_definitions <<     ["Price",             "item.workshop_price.price.to_f", nil, {:type => 'Number', :numberformat => '#,##0.00'}]
+  #
+  # data_array: an array of objects (link from a find)
+  # :filename => 'file_name' name of file to save as.
+  # :expressions => true : the data definintion can be a complex expression, 
+  #    so simply evaluate it directly. To access the current item, the expression
+  #    should use 'item', as in 'item.name.blank? ? "n/a" : item.name'
+  #------------------------------------------------------------------------------
+  def excel_export(column_definitions, data_array, options = {})
+    options.symbolize_keys
+    rows      = Array.new
+    columns   = Array.new
+  
+    #--- create the workbook
+    wb          = Scio::Excel::SimpleWorkbook.new(to_excel_filename(options[:filename] ? options[:filename] : 'Workbook'))
+    stc         = wb.default_cell_style
+    stc.borders = stc.borders & 0
+  
+    column_definitions.each do |x|
+      style = x[3].nil? ? nil : Scio::Excel::SimpleStyle.new(x[3])
+      c = Scio::Excel::Column.new(x[0], x[3].nil? ? {} : x[3])
+      c.width = x[2] unless x[2].nil?
+      c.cell_style = style
+      columns << c
+    end
+
+    data_array.each do |item|
+      data = {}
+      column_definitions.each do |x|
+        data[x[0]] = get_data_value(item, x[1], options)
+      end
+      rows << data
+    end
+  
+    wb.columns  = columns
+    wb.rows     = rows
+  
+    if options[:filename]
+      send_data wb.create, :filename => to_excel_filename(options[:filename]), :disposition => 'attachment', :type => 'application/excel'
+    else
+      return wb.create
+    end
+  end
+
+=begin
+  #------------------------------------------------------------------------------
+  def ruport_export(column_definitions, data_array, options = {})
+    options.symbolize_keys
+    output_array = Array.new
+    column_array = Array.new
+
+    column_definitions.each { |x| column_array << x[0] }
+
+    table = Table(column_array) do |t| 
+      data_array.each do |item|
+        output_array.clear
+        column_definitions.each do |x|
+          value = get_data_value(item, x[1], options)
+          output_array << convert_value(value, x[3])
+        end      
+        t << output_array
+      end
+    end
+    return table
+  end
+=end
+  
+private
+  #------------------------------------------------------------------------------
+  def get_data_value(item, data_def, options)
+    begin
+      if item.is_a? Hash
+        value = options[:expressions] ? eval('(' + data_def + ').to_s') : eval('item[' + data_def + '].to_s')
+      else
+        value = options[:expressions] ? eval('(' + data_def + ').to_s') : eval('item.' + data_def + '.to_s')
+      end
+    rescue
+      #--- catch any nil references
+      value = nil
+    end
+    return value.nil? ? '' : value.gsub(/[\r\n]/, '')  # strip off \r and \n
+  end
+
+  # Use the column_options to change data to a specific type
+  #------------------------------------------------------------------------------
+  def convert_value(value, column_options)
+    if column_options
+      case column_options[:type]
+      when 'Number'
+        return value.to_i
+      when 'link'
+      end
+    end
+  
+    return value
+  end
+
+  #------------------------------------------------------------------------------
+  def to_csv_filename(title)
+    the_time    = Time.now
+    file_prefix = "#{the_time.year}_#{the_time.mon}_#{the_time.day}_"
+    filename    = (file_prefix + title.gsub(/[^\w\.\-]/,'_')).squeeze('_')
+    filename + '.csv'
+  end
+
+  # Older Excel limited to 32 char filenames
+  # -- removed filename length limit - put back if problems occur
+  #------------------------------------------------------------------------------
+  def to_excel_filename(title)
+    the_time    = Time.now
+    file_prefix = "#{the_time.year}_#{the_time.mon}_#{the_time.day}_"
+    filename    = (file_prefix + title.gsub(/[^\w\.\-]/,'_')).squeeze('_')
+    # --- removed filename length limit - put back if problems occur : (filename.length > 27 ? filename[0...27] : filename) + '.xls'
+    filename + '.xls'
+  end
+end

data/lib/dm_core/csv_importer.rb

@@ -0,0 +1,16 @@
+# Implements CSV Import functionality
+#------------------------------------------------------------------------------
+module CsvImporter
+
+  require 'csv'
+  
+  # import data from CSV file and return an Array of Hashes
+  #------------------------------------------------------------------------------
+  def csv_import(the_file)
+    import_list = Array.new
+    CSV.foreach(the_file, headers: true) do |row|
+      import_list << row.to_hash
+    end
+    return import_list
+  end
+end

data/lib/dm_core/engine.rb

@@ -0,0 +1,51 @@
+require 'csv'
+
+require 'devise'
+require 'rolify'
+require 'cancan'
+require 'globalize'
+require 'country_select'
+require 'simple_form'
+require 'will_paginate'
+require 'paper_trail'
+require 'RedCloth'
+require 'kramdown'
+require 'liquid'
+require 'sanitize'
+require 'acts_as_commentable'
+require 'acts_as_votable'
+require 'acts_as_follower'
+require 'acts-as-taggable-on'
+require 'ancestry'
+require 'ranked-model'
+require 'amoeba'
+require 'babosa'
+require 'friendly_id'
+require 'aasm'
+require 'monetize/core_extensions'
+require 'money-rails'
+require 'exception_notification'
+require 'aws-sdk'
+require 'biggs'
+require 'codemirror-rails'
+require 'mini_magick'
+require 'carrierwave'
+
+module DmCore
+  class Engine < ::Rails::Engine
+    isolate_namespace DmCore
+    
+    initializer 'engine.helper' do |app|
+      ActionView::Base.send :include, RenderHelper
+      ActiveSupport.on_load(:action_controller) do
+        include DmCore::ApplicationHelper
+      end
+    end
+    
+    config.before_initialize do
+      DmCore.initialize_configuration
+    end
+  end
+  
+  
+end

data/lib/dm_core/liquid_extensions.rb

@@ -0,0 +1,125 @@
+# Allow Liquid tags to be namespaced, based on the account_prefix.  This allows
+# multiple sites to have tags named the same, but the correct one will get used
+# during rendering 
+#------------------------------------------------------------------------------
+module Liquid
+  class Template
+    class << self
+      
+      #------------------------------------------------------------------------------
+      def register_tag(name, klass)
+        register_tag_namespace(name, klass)
+      end
+      
+      # Store tags in a namespace, usually a theme name.  This is so we can register
+      # many different tags for each theme and keep them seperate.
+      #------------------------------------------------------------------------------
+      def register_tag_namespace(name, klass, namespace = 'system_tags')
+        tags_namespaced(namespace)[name.to_s] = klass
+      end
+      
+      # return the list of tags that are available.  Tags available at any instance is
+      # the global tags, the current theme's tags, and the parent theme's tags.
+      #------------------------------------------------------------------------------
+      def tags
+        if Account.current.nil?
+          tags_namespaced('system_tags').merge(@tags)
+        else
+          t = tags_namespaced('system_tags').merge(@tags).merge(tags_namespaced(Account.current.current_theme))
+          
+          #--- if parent theme, reverse_merge tags - they should not override current theme tags
+          t.reverse_merge!(tags_namespaced(Account.current.parent_theme)) if Account.current.parent_theme
+          return t
+        end
+      end
+      
+      #------------------------------------------------------------------------------
+      def tags_namespaced(namespace)
+        @tags_namespaced            ||= {}
+        @tags_namespaced[namespace] ||= {}
+      end
+    end
+  end
+end
+
+#------------------------------------------------------------------------------
+module LiquidExtensions
+  module Helpers
+    # So that tags can render Erb and have access to normal Rails helpers
+    # http://robots.thoughtbot.com/post/159806314/custom-tags-in-liquid
+    #------------------------------------------------------------------------------
+    def render_erb(context, file_name, locals = {})
+      context.registers[:controller].send(:render_to_string, :partial => file_name, :locals => locals)
+    end
+
+    #------------------------------------------------------------------------------
+    def context_account_site_assets(context)
+      context.registers[:account_site_assets]
+    end
+  end
+end
+
+# Pull common setup functions of Tag and Block
+#------------------------------------------------------------------------------
+module DmCore
+  class LiquidTag < Liquid::Tag
+    include LiquidExtensions::Helpers
+
+    SimpleSyntax = /#{Liquid::QuotedFragment}/        
+    NamedSyntax = /(#{Liquid::QuotedFragment})\s*\:\s*(#{Liquid::QuotedFragment})/
+
+    #------------------------------------------------------------------------------
+    def initialize(tag_name, markup, tokens)      
+      @attributes    = {}
+      markup.scan(Liquid::TagAttributes) do |key, value|
+        @attributes[key] = ((value.delete "\"").delete "\'")
+      end
+      super
+    end
+
+    class << self
+      #------------------------------------------------------------------------------
+      def tag_name
+        self.name.split('::').last.underscore
+      end
+      def details
+        { name: self.tag_name, summary: '', description: '', example: '', category: '' }
+      end
+    end
+  end
+end
+
+module DmCore
+  class LiquidBlock < Liquid::Block
+    include LiquidExtensions::Helpers
+
+    SimpleSyntax = /#{Liquid::QuotedFragment}/        
+    NamedSyntax = /(#{Liquid::QuotedFragment})\s*\:\s*(#{Liquid::QuotedFragment})/
+
+    #------------------------------------------------------------------------------
+    def initialize(tag_name, markup, tokens)      
+      @attributes    = {}
+      markup.scan(Liquid::TagAttributes) do |key, value|
+        @attributes[key] = ((value.delete "\"").delete "\'")
+      end
+      super    
+    end
+    
+    # Liquid will automatically throw away a block with empty/blank content.
+    # Call this in the tag's render method to allow the tag to be rendered anyway
+    #------------------------------------------------------------------------------
+    def allow_empty_block
+      @blank = false
+    end
+    
+    class << self
+      #------------------------------------------------------------------------------
+      def tag_name
+        self.name.split('::').last.underscore
+      end
+      def details
+        { name: self.tag_name, summary: '', description: '', example: '', category: '' }
+      end
+    end
+  end
+end

data/lib/dm_core/nls.rb

@@ -0,0 +1,31 @@
+
+#------------------------------------------------------------------------------
+module Nls
+  
+  CONTINENTS = ['Europe', 'North America', 'South America', 'Oceania', 'Asia', 'Africa', 'Antartica']
+  
+  # default scope the msg lookup to the current theme
+  #------------------------------------------------------------------------------
+  def nls(message_key, options = {})
+    #--- look up message in the scope of current theme, fallback to parent theme
+    key       = "#{Account.current.current_theme}.#{message_key.to_s}"
+    fallback  = Account.current.parent_theme ? "#{Account.current.parent_theme}.#{message_key.to_s}" : "translation missing: #{key}"
+    I18n.t(key, options.merge(default: fallback.to_sym))     
+  end
+
+  # Check if the message exists
+  #------------------------------------------------------------------------------
+  def nls?(message_key)
+    key       = "#{Account.current.current_theme}.#{message_key.to_s}"
+    I18n.t key, :raise => true rescue false
+  end
+  
+  # Helper to generate the image_tag for a language flag.  
+  #  nls_flag_image(:en)
+  #------------------------------------------------------------------------------
+  def nls_flag_image(lang = nil)
+    image_tag(DmCore::Language.flag_image(lang))
+  end
+
+end
+

data/lib/dm_core/scio_excel.rb

@@ -0,0 +1,501 @@
+require 'builder'
+
+#    Scio Excel Library
+#
+#    v.0.2.1
+#
+#    Copyright (c) Rolando Abarca Millán 2005-2006
+#
+#    rabarca@scio.cl
+#
+#    This library is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program; if not, write to the Free Software
+#    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+#    == Installation
+#
+#    Put this file in $Rails.root/lib, restart your server.
+#
+#    <b>NOTE</b>: this library will become a rails plugin in the near future
+
+module Scio
+  module Excel
+
+    BORDER_ALL    = 0b1111
+    BORDER_LEFT   = 0b0001
+    BORDER_TOP    = 0b0010
+    BORDER_RIGHT  = 0b0100
+    BORDER_BOTTOM = 0b1000
+
+    # = SimpleWorkbook
+    # This is a one-sheet workbook. Really simple.
+    # It allows you to create an excel workbook from an array of hashes
+    #
+    # == Example 1
+    #
+    #   # first, create the styles (You should check the default styles)
+    #   st1 = Scio::Excel::SimpleStyle.new(:text => {:valign => "Top"},
+    #                                      :borders => Scio::Excel::BORDER_ALL)
+    #   st2 = Scio::Excel::SimpleStyle.new(:text => {:valign => "Top", :wrap => true},
+    #                                      :borders => Scio::Excel::BORDER_ALL)
+    #   st3 = Scio::Excel::SimpleStyle.new(:borders => Scio::Excel::BORDER_ALL,
+    #                                      :bgcolor => "#666699",
+    #                                      :font => {:bold => true, :color => "#ffffff"})
+    #
+    #   # now, create the columns. The order of appearance is the order in which you push them
+    #   # to the array.
+    #   columns = []
+    #   columns << Scio::Excel::Column.new("Birthday", :width => 76.5, :cell_style => st1, :header_style => st3)
+    #   columns << Scio::Excel::Column.new("Name", :width => 276.75, :cell_style => st1, :header_style => st3)
+    #
+    #   # next, create the data array
+    #   rows = User.all.collect {|u| {"Birthday" => u.bday.strftime("%d/%m/%Y"), "Name" => u.name}}
+    #
+    #   # create the workbook
+    #   wb = Scio::Excel::SimpleWorkbook.new("User's birthday List")
+    #   wb.columns = columns
+    #   wb.rows = rows
+    #
+    #   # finally, send the workbook to the browser
+    #   headers['Content-type'] = "application/vnd.ms-excel"
+    #   render_text(e.create)
+    #
+    # == Example 2 (Default Styles & PDF Output)
+    #
+    # (needs fpdf for the PDF output)
+    #
+    #   wb = Scio::Excel::SimpleWorkbook.new("test de excel")
+    #   
+    #   # create styles
+    #   sth = Scio::Excel::SimpleStyle.new
+    #   sth.text[:halign] = "Center"
+    #   sth.font[:bold] = true
+    #   sth.bgcolor = "#CCFFCC"
+    #   sth.borders = Scio::Excel::BORDER_TOP | Scio::Excel::BORDER_BOTTOM
+    #   stc = wb.default_cell_style
+    #   stc.font[:italic] = true
+    #   stc.text[:halign] = "Left"
+    #
+    #   # create the columns
+    #   columns = Array.new
+    #   columns << Scio::Excel::Column.new("Nombre Cliente", :width => 150, :header_style => sth)
+    #   columns << Scio::Excel::Column.new("R.U.T", :width => 40, :header_style => sth)
+    #
+    #   # crear the data
+    #   rows = Cliente.order('razon_social').collect {|c|
+    #     {"Nombre Cliente" => c.razon_social, "R.U.T" => c.rut}
+    #   }
+    #
+    #   # set columns and rows
+    #   wb.columns = columns
+    #   wb.rows = rows
+    #   send_data wb.create_pdf, :filename => "something.pdf", :type => "application/pdf"
+    #
+    # == Attributes
+    #
+    # +columns+:: array of Column
+    # +rows+:: array of Hashes, each one representing a row. The key for the Hash must be
+    #          the name of the corresponding column.
+    # +name+:: name of the workbook. This will be the name of the single worksheet.
+    # +row_height+:: set this to the height of the data rows.
+    #
+    # == Inspiration
+    #
+    # This library was inspired by the Excel Export Plugin:
+    #
+    # http://www.napcsweb.com/blog/2006/02/10/excel-plugin-10
+    class SimpleWorkbook
+      attr_accessor :columns,
+                    :rows,
+                    :name,
+                    :row_height
+
+      def initialize(name)
+        @name       = name
+        @columns    = []
+        @rows       = []
+        @row_height = nil
+        @style_id   = 0
+      end
+
+      # Creates the xml text of the Workbook. You can send it to the browser
+      # using <tt>render_text</tt>. You might need to set the HTTP headers
+      # before.
+      #
+      # == Example
+      #
+      #   wb = Scio::Excel::Workbook.new("list")
+      #   ...
+      #   render_text(wb.create)
+      def create
+        buffer = ""
+        xml = Builder::XmlMarkup.new(:target => buffer, :indent => 2)
+        xml.instruct! :xml, :version => "1.0", :encoding => "UTF-8"
+        xml.Workbook({
+          'xmlns'      => "urn:schemas-microsoft-com:office:spreadsheet", 
+          'xmlns:o'    => "urn:schemas-microsoft-com:office:office",
+          'xmlns:x'    => "urn:schemas-microsoft-com:office:excel",    
+          'xmlns:html' => "http://www.w3.org/TR/REC-html40",
+          'xmlns:ss'   => "urn:schemas-microsoft-com:office:spreadsheet" 
+        }) do
+          # add styles to the workbook
+          styles = []
+          @columns.each do |c|
+            # use the default style if none set
+            hstyle = (c.header_style.nil?) ? default_header_style : c.header_style
+            cstyle = (c.cell_style.nil?) ? default_cell_style : c.cell_style
+            # set the style, in case it's the default one
+            c.header_style = hstyle
+            c.cell_style = cstyle
+            styles << hstyle unless styles.include?(hstyle)
+            styles << cstyle unless styles.include?(cstyle)
+          end
+          xml.Styles do
+            xml.Style 'ss:ID' => 'Default', 'ss:Name' => 'Normal' do
+              xml.Alignment 'ss:Vertical' => 'Bottom'
+              xml.Borders
+              xml.Font 'ss:FontName' => 'Arial'
+              xml.Interior
+              xml.NumberFormat
+              xml.Protection
+            end
+            styles.each do |s|
+              xml << s.create(self)
+            end
+          end
+          xml << createWorksheet(@name)
+          # reset the styles-id
+          @style_id = 0
+        end # Workbook
+      end
+
+      # attempt to create a pdf for the table.
+      #
+      # == Example
+      #
+      #   wb = Scio::Excel::Workbook.new("customers")
+      #   ...
+      #   send_data wb.create_pdf, :filename => "something.pdf", :type => "application/pdf"
+      # 
+      # One thing to note is that you <b>must</b> specify a width for each
+      # column, and that the units for the columns are different than those
+      # for excel (i.e: specify smaller numbers).
+      #
+      # This requires fpdf (http://zeropluszero.com/software/fpdf/)
+      def create_pdf(orientation = "L")
+        require 'fpdf'
+        raise "Invalid orientation" if !["L","P"].include?(orientation)
+        pdf = FPDF.new
+        # default font
+        pdf.SetFont('Arial', '', 14)
+        pdf.AddPage(orientation)
+        # first, create the headers
+        @columns.each do |c|
+          # set the style
+          hstyle = (c.header_style.nil?) ? default_header_style : c.header_style
+          rgb = hstyle.bgcolor.to_rgb rescue nil
+          fill = 0
+          unless rgb.nil?
+            pdf.SetFillColor(rgb[:red], rgb[:green], rgb[:blue])
+            fill = 1
+          end
+          rgb = hstyle.font[:color].to_rgb rescue nil
+          pdf.SetTextColor(rgb[:red], rgb[:green], rgb[:blue]) unless rgb.nil?
+          fstyle = String.new
+          fstyle << "B" if hstyle.font[:bold]
+          fstyle << "I" if hstyle.font[:italic]
+          pdf.SetFont('',fstyle)
+          border = 0
+          if hstyle.borders > 0
+            if hstyle.borders == BORDER_ALL
+              border = 1
+            else
+              border = String.new
+              border << "T" if hstyle.borders & BORDER_TOP > 0
+              border << "B" if hstyle.borders & BORDER_BOTTOM > 0
+              border << "L" if hstyle.borders & BORDER_LEFT > 0
+              border << "R" if hstyle.borders & BORDER_RIGHT > 0
+            end
+          end
+          align = "C"
+          unless hstyle.text[:align].nil?
+            align = "L" if hstyle.text[:halign] == "Left"
+            align = "R" if hstyle.text[:halign] == "Right"
+          end
+          # draw the cells
+          pdf.Cell(c.width, 7, c.name, border, 0, align, fill)
+        end # headers
+        pdf.Ln
+
+        # reset the styles
+        pdf.SetTextColor(0,0,0)
+        pdf.SetFont('','')
+
+        # draw the rows
+        @rows.each do |r|
+          # set the style
+          @columns.each do |c|
+            cstyle = (c.cell_style.nil?) ? default_cell_style : c.cell_style
+            rgb = cstyle.bgcolor.to_rgb rescue nil
+            fill = 0
+            unless rgb.nil?
+              pdf.SetFillColor(rgb[:red], rgb[:green], rgb[:blue])
+              fill = 1
+            end
+            rgb = cstyle.font[:color].to_rgb rescue nil
+            pdf.SetTextColor(rgb[:red], rgb[:green], rgb[:blue]) unless rgb.nil?
+            fstyle = String.new
+            fstyle << "B" if cstyle.font[:bold]
+            fstyle << "I" if cstyle.font[:italic]
+            pdf.SetFont('',fstyle)
+            border = 0
+            if cstyle.borders > 0
+              if cstyle.borders == BORDER_ALL
+                border = 1
+              else
+                border = String.new
+                border << "T" if cstyle.borders & BORDER_TOP > 0
+                border << "B" if cstyle.borders & BORDER_BOTTOM > 0
+                border << "L" if cstyle.borders & BORDER_LEFT > 0
+                border << "R" if cstyle.borders & BORDER_RIGHT > 0
+              end
+            end
+            align = "C"
+            unless cstyle.text[:align].nil?
+              align = "L" if cstyle.text[:halign] == "Left"
+              align = "R" if cstyle.text[:halign] == "Right"
+            end
+            pdf.Cell(c.width, 7, r[c.name], border, 0, align, fill)
+          end # columns
+          pdf.Ln
+        end # rows
+
+        # salida
+        pdf.Output
+      end
+
+      # creates a default style for the header. This is used in case you don't
+      # set a style for the column. If you really want a "plain" style, create
+      # a column with an empty one:
+      #
+      #   nst = Scio::Excel::SimpleStyle.new
+      #   col = Scio::Excel::Column.new("name", :header_style => nst)
+      #
+      # Since the default style is an instance variable, you don't need to set the
+      # style for a column if you modify it.
+      # 
+      # == Example
+      # 
+      #   wb = Scio::Excel::SimpleWorkbook.new("user list")
+      #   sth = wb.default_header_style
+      #   sth.bgcolor = "#CCFFCC"
+      #   columns = Array.new
+      #   # when rendering, the columns will use the default header style, but with a 
+      #   # bgcolor = #CCFFCC.
+      #   columns << Scio::Excel::Column.new("User Name", :width => 276.75)
+      #   columns << Scio::Excel::Column.new("Birthday", :width => 76.5)
+      # 
+      # The same applies for the default_cell_style.
+      def default_header_style
+        if @default_header_style.nil?
+          st = SimpleStyle.new
+          st.font[:bold] = true
+          st.font[:color] = "#FFFFFF"
+          st.borders = BORDER_ALL
+          st.text[:halign] = "Center"
+          st.bgcolor = "#666699"
+          @default_header_style = st
+        end
+        @default_header_style
+      end
+
+      # creates a default style for the cell. See default_header_style for documentation.
+      def default_cell_style
+        if @default_cell_style.nil?
+          st = SimpleStyle.new
+          st.borders = BORDER_ALL
+          st.text[:valign] = "Center"
+          @default_cell_style = st
+        end
+        @default_cell_style
+      end
+
+      def next_style_id #:nodoc:
+        @style_id += 1
+        "s#{@style_id}"
+      end
+
+      protected
+      def createWorksheet(name) #:nodoc:
+        buffer = ""
+        xml = Builder::XmlMarkup.new(:target => buffer, :indent => 2)
+        xml.Worksheet 'ss:Name' => name do
+          xml.Table do
+            # create header
+            @columns.each do |c| 
+              col_opts = {}
+              if !c.width.nil? && c.width > 0
+                col_opts['ss:AutoFitWidth'] = "0"
+                col_opts['ss:Width'] = c.width
+              end
+              xml.Column col_opts
+            end
+            xml.Row do
+              @columns.each do |c|
+                col_opts = {}
+                col_opts['ss:StyleID'] = c.header_style.excel_id unless c.header_style.nil?
+                xml.Cell col_opts do
+                  xml.Data c.name, 'ss:Type' => 'String'
+                end
+              end
+            end
+            # now, add data :-)
+            @rows.each do |r|
+              row_opts = {}
+              row_opts["ss:AutoFitHeight"] = "0"
+              row_opts["ss:Height"] = @row_height unless @row_height.nil?
+              xml.Row row_opts do
+                @columns.each do |c|
+                  cell_opts = {}
+                  cell_opts["ss:StyleID"] = c.cell_style.excel_id unless c.cell_style.nil?
+                  xml.Cell cell_opts do
+                    unless r[c.name].blank?
+                      xml.Data r[c.name], 'ss:Type' => c.type
+                    end
+                  end
+                end
+              end
+            end # rows
+          end # Table
+        end # Worksheet
+        xml.target!
+      end
+
+    end # SimpleWorkbook
+
+    # Defines a Column for the data. You can set different styles for the
+    # header and the cells.
+    #
+    # You can also set the width of the column.
+    class Column
+      attr_accessor :name,
+                    :header_style,
+                    :cell_style,
+                    :width,
+                    :type
+      def initialize(name, opts = {})
+        @name = name
+        @header_style = opts[:header_style]
+        @cell_style = opts[:cell_style]
+        @width = opts[:width]
+        @type = opts[:type].nil? ? 'String' : opts[:type]
+      end
+    end
+
+    # SimpleStyle tries to simplify the styles for an individual cell.
+    #
+    # Current options are:
+    #
+    # * text alignment (vertical, horizontal)
+    # * text wrapping
+    # * font style (bold, italics, color)
+    # * background color for the cell
+    # * borders
+    #
+    # == Example
+    #
+    #   # simple center-align
+    #   st1 = Scio::Excel::SimpleStyle.new(:text => {:halign => "Center"})
+    #   # wrap text to the cell
+    #   st2 = Scio::Excel::SimpleStyle.new(:text => {:wrap => true})
+    #   # set background color
+    #   st2.bgcolor = "#666699"
+    #   # set the borders
+    #   st2.borders = Scio::Excel::BORDER_ALL
+    #   # set only the left & right border
+    #   st1.borders = Scio::Excel::BORDER_LEFT | Scio::Excel::BORDER_RIGHT
+    #   # italics
+    #   st1.font[:italic] = true
+    class SimpleStyle
+      attr_accessor :text,
+                    :font,
+                    :borders,
+                    :excel_id,
+                    :bgcolor,
+                    :numberformat
+
+      def initialize(opts = {})
+        @text         = opts[:text] || {}
+        @font         = opts[:font] || {}
+        @borders      = opts[:borders].nil? ? 0 : opts[:borders]
+        @bgcolor      = opts[:bgcolor]
+        @numberformat = opts[:numberformat]
+      end
+
+      # Creates the xml for the style. You should not call this directly.
+      def create(workbook)
+        buffer = ""
+        xml = Builder::XmlMarkup.new(:target => buffer, :indent => 2)
+        @excel_id = workbook.next_style_id
+        xml.Style 'ss:ID' => @excel_id do
+          unless @text.empty?
+            alignment_opts = {}
+            alignment_opts["ss:Vertical"] = @text[:valign] if !@text[:valign].nil?
+            alignment_opts["ss:Horizontal"] = @text[:halign] if !@text[:halign].nil?
+            alignment_opts["ss:WrapText"] = "1" if @text[:wrap]
+            xml.Alignment alignment_opts unless alignment_opts.empty?
+          end
+          unless @font.empty?
+            font_opts = {}
+            font_opts["ss:Bold"] = "1" if @font[:bold]
+            font_opts["ss:Italic"] = "1" if @font[:italic]
+            font_opts["ss:Color"] = @font[:color] unless @font[:color].nil?
+            xml.Font font_opts unless font_opts.empty?
+          end
+          if @borders > 0
+            xml.Borders do
+              xml.Border "ss:Position" => "Bottom",
+                         "ss:LineStyle" => "Continuous",
+                         "ss:Weight" => "1" if @borders & BORDER_BOTTOM > 0
+              xml.Border "ss:Position" => "Left",
+                         "ss:LineStyle" => "Continuous",
+                         "ss:Weight" => "1" if @borders & BORDER_LEFT > 0
+              xml.Border "ss:Position" => "Right",
+                         "ss:LineStyle" => "Continuous",
+                         "ss:Weight" => "1" if @borders & BORDER_RIGHT > 0
+              xml.Border "ss:Position" => "Top",
+                         "ss:LineStyle" => "Continuous",
+                         "ss:Weight" => "1" if @borders & BORDER_TOP > 0
+            end
+          end
+          xml.Interior "ss:Color" => @bgcolor, "ss:Pattern" => "Solid" unless @bgcolor.nil?
+          xml.NumberFormat "ss:Format" => @numberformat unless @numberformat.nil?
+        end
+        xml.target!
+      end
+    end # SimpleStyle
+
+  end
+end
+
+class String
+  # simple (and naive) way to convert html-hex color to array of colors
+  def to_rgb
+    raise "Invalid Hex Color" if self.size != 7 || self[0] != 35
+    rgb = Hash.new
+    rgb[:red]   = self[1,2].to_i(16)
+    rgb[:green] = self[3,2].to_i(16)
+    rgb[:blue]  = self[5,2].to_i(16)
+    rgb
+  end
+end