caxlsx 2.0.2 → 3.0.0

data/examples/merge_cells.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby -w -s
+# -*- coding: utf-8 -*-
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
+
+#```ruby
+require 'axlsx'
+package = Axlsx::Package.new
+package.workbook do |workbook|
+  workbook.add_worksheet name: 'merged_cells' do |sheet|
+    4.times do
+      sheet.add_row %w(a b c d e f g)
+    end
+    sheet.merge_cells "A1:A2"
+    sheet.merge_cells "B1:B2"
+  end
+end
+package.serialize 'merged_cells.xlsx'

data/examples/no_grid_with_borders.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby -w -s
+# -*- coding: utf-8 -*-
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
+
+#```ruby
+require 'axlsx'
+package = Axlsx::Package.new
+package.workbook do |workbook|
+  workbook.styles do |s|
+    gridstyle_border =  s.add_style :border => { :style => :thin, :color =>"FFCDCDCD" }
+    workbook.add_worksheet :name => "Custom Borders"  do |sheet|
+      sheet.sheet_view.show_grid_lines = false
+      sheet.add_row ["with", "grid", "style"], :style => gridstyle_border
+      sheet.add_row ["no", "border"]
+    end
+  end
+end
+package.serialize 'no_grid_with_borders.xlsx'

data/examples/pivot_test.rb

@@ -0,0 +1,63 @@
+class RandomReportGenerator
+  def date
+    Date.today.strftime("%m/%d/%Y")
+  end
+  def member_id
+    @i ||= 0
+    @i += 1
+  end
+  def name
+    "John S."
+  end
+  def gender
+    ["Male", "Female"].sample
+  end
+  def age
+    rand(100)
+  end
+  def city
+    ["New York", "Mountain View", "Newark", "Phoenix"].sample
+  end
+  def state
+    ["NY", "CA", "NJ", "AZ"].sample
+  end
+  def parenting
+    "Foo"
+  end
+  def student
+    "Bar"
+  end
+  def income
+    "Bar"
+  end
+  def education
+    "Bar"
+  end
+  def answer
+    ["Yes", "No", "Maybe", "I dont know"].sample
+  end
+  def run
+    package  = Axlsx::Package.new
+    workbook = package.workbook
+ 
+    workbook.add_worksheet(:name => "Data Sheet") do |sheet|
+      sheet.add_row [
+        "Date", "Member ID", "Name", "Gender", "Age", "City", "State",
+        "Parenting Status", "Student Status", "Income", "Education", "Answer"
+      ]
+      30.times do
+        sheet.add_row [date, member_id, name, gender, age, city, state,
+                       parenting, student, income, education, answer]
+      end
+    end
+ 
+    workbook.add_worksheet(:name => "Summary") do |sheet|
+      pivot_table = Axlsx::PivotTable.new 'A1:B15', "A1:L31", workbook.worksheets[0]
+      pivot_table.rows = ['Answer']
+      pivot_table.data = [{:ref => "Member ID", :subtotal => "count"}]
+      sheet.pivot_tables << pivot_table
+    end
+ 
+    package.serialize("pivot_table.xlsx")
+  end
+end

data/examples/split.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby -w -s
+# -*- coding: utf-8 -*-
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
+require 'axlsx'
+p = Axlsx::Package.new
+wb = p.workbook
+wb.add_worksheet name: 'pane' do |sheet|
+  sheet.sheet_view.pane do |pane|
+    pane.top_left_cell = "B2"
+    pane.state = :frozen_split
+    pane.y_split = 2
+    pane.x_split = 1
+    pane.active_pane = :bottom_right
+  end
+end
+p.serialize 'pane.xlsx'

data/lib/axlsx.rb

@@ -1,6 +1,7 @@
 # encoding: UTF-8
 require 'htmlentities'
 require 'axlsx/version.rb'
+require 'mimemagic'
 
 require 'axlsx/util/simple_typed_list.rb'
 require 'axlsx/util/constants.rb'
@@ -10,6 +11,7 @@ require 'axlsx/util/serialized_attributes'
 require 'axlsx/util/options_parser'
 # to be included with parsable intitites.
 #require 'axlsx/util/parser.rb'
+require 'axlsx/util/mime_type_utils'
 
 require 'axlsx/stylesheet/styles.rb'
 
@@ -53,7 +55,7 @@ module Axlsx
     cells = sort_cells(cells)
     reference = "#{cells.first.reference(absolute)}:#{cells.last.reference(absolute)}"
     if absolute
-      escaped_name = cells.first.row.worksheet.name.gsub "'", "''"
+      escaped_name = cells.first.row.worksheet.name.gsub ''', "''"
       "'#{escaped_name}'!#{reference}"
     else
       reference
@@ -65,7 +67,7 @@ module Axlsx
   # @param [Array] cells
   # @return [Array]
   def self.sort_cells(cells)
-    cells.sort { |x, y| [x.index, x.row.index] <=> [y.index, y.row.index] }
+    cells.sort { |x, y| [x.index, x.row.row_index] <=> [y.index, y.row.row_index] }
   end
 
   #global reference html entity encoding
@@ -88,20 +90,21 @@ module Axlsx
   # @note This follows the standard spreadsheet convention of naming columns A to Z, followed by AA to AZ etc.
   # @return [String]
   def self.col_ref(index)
-    chars = []
+    chars = ''
     while index >= 26 do
-      chars << ((index % 26) + 65).chr
-      index = (index / 26).to_i - 1
+      index, char = index.divmod(26)
+      chars.prepend((char + 65).chr)
+      index -= 1
     end
-    chars << (index + 65).chr
-    chars.reverse.join
+    chars.prepend((index + 65).chr)
+    chars
   end
 
   # @return [String] The alpha(column)numeric(row) reference for this sell.
   # @example Relative Cell Reference
   #   ws.rows.first.cells.first.r #=> "A1"
   def self.cell_r(c_index, r_index)
-    Axlsx::col_ref(c_index).to_s << (r_index+1).to_s
+    col_ref(c_index) << (r_index+1).to_s
   end
 
   # Creates an array of individual cell references based on an excel reference range.
@@ -113,7 +116,7 @@ module Axlsx
     end_col,   end_row   = name_to_indices($2)
     (start_row..end_row).to_a.map do |row_num|
       (start_col..end_col).to_a.map do |col_num|
-        "#{col_ref(col_num)}#{row_num+1}"
+        cell_r(col_num, row_num)
       end
     end
   end
@@ -127,14 +130,30 @@ module Axlsx
     s.gsub(/_(.)/){ $1.upcase }
   end
 
-    # returns the provided string with all invalid control charaters
-    # removed.
-    # @param [String] str The sting to process
-    # @return [String]
-    def self.sanitize(str)
-      str.gsub(CONTROL_CHAR_REGEX, '')
+  # returns the provided string with all invalid control charaters
+  # removed.
+  # @param [String] str The string to process
+  # @return [String]
+  def self.sanitize(str)
+    if str.frozen?
+      str.delete(CONTROL_CHARS)
+    else
+      str.delete!(CONTROL_CHARS)
+      str
     end
+  end
 
+  # If value is boolean return 1 or 0
+  # else return the value
+  # @param [Object] value The value to process
+  # @return [Object]
+  def self.booleanize(value)
+    if value == true || value == false
+      value ? 1 : 0
+    else
+      value
+    end
+  end
 
   # Instructs the serializer to not try to escape cell value input.
   # This will give you a huge speed bonus, but if you content has <, > or other xml character data

data/lib/axlsx/content_type/abstract_content_type.rb

@@ -24,7 +24,7 @@ module Axlsx
     # Serialize the contenty type to xml
     def to_xml_string(node_name = '', str = '')
       str << "<#{node_name} "
-      str << instance_values.map { |key, value| '' << Axlsx::camel(key) << '="' << value.to_s << '"' }.join(' ')
+      str << instance_values.map { |key, value| Axlsx::camel(key) << '="' << value.to_s << '"' }.join(' ')
       str << '/>'
     end
 

data/lib/axlsx/content_type/content_type.rb

@@ -16,7 +16,7 @@ module Axlsx
     # @return [String]
     def to_xml_string(str = '')
       str << '<?xml version="1.0" encoding="UTF-8"?>'
-      str << '<Types xmlns="' << XML_NS_T << '">'
+      str << ('<Types xmlns="' << XML_NS_T << '">')
       each { |type| type.to_xml_string(str) }
       str << '</Types>'
     end

data/lib/axlsx/doc_props/app.rb

@@ -222,7 +222,7 @@ module Axlsx
     # @return [String]
     def to_xml_string(str = '')
       str << '<?xml version="1.0" encoding="UTF-8"?>'
-      str << '<Properties xmlns="' << APP_NS << '" xmlns:vt="' << APP_NS_VT << '">'
+      str << ('<Properties xmlns="' << APP_NS << '" xmlns:vt="' << APP_NS_VT << '">')
       instance_values.each do |key, value|
         node_name = Axlsx.camel(key)
         str << "<#{node_name}>#{value}</#{node_name}>"

data/lib/axlsx/doc_props/core.rb

@@ -25,11 +25,11 @@ module Axlsx
     # @return [String]
     def to_xml_string(str = '')
       str << '<?xml version="1.0" encoding="UTF-8"?>'
-      str << '<cp:coreProperties xmlns:cp="' << CORE_NS << '" xmlns:dc="' << CORE_NS_DC << '" '
-      str << 'xmlns:dcmitype="' << CORE_NS_DCMIT << '" xmlns:dcterms="' << CORE_NS_DCT << '" '
-      str << 'xmlns:xsi="' << CORE_NS_XSI << '">'
-      str << '<dc:creator>' << self.creator << '</dc:creator>'
-      str << '<dcterms:created xsi:type="dcterms:W3CDTF">' << (created || Time.now).strftime('%Y-%m-%dT%H:%M:%S') << 'Z</dcterms:created>'
+      str << ('<cp:coreProperties xmlns:cp="' << CORE_NS << '" xmlns:dc="' << CORE_NS_DC << '" ')
+      str << ('xmlns:dcmitype="' << CORE_NS_DCMIT << '" xmlns:dcterms="' << CORE_NS_DCT << '" ')
+      str << ('xmlns:xsi="' << CORE_NS_XSI << '">')
+      str << ('<dc:creator>' << self.creator << '</dc:creator>')
+      str << ('<dcterms:created xsi:type="dcterms:W3CDTF">' << (created || Time.now).strftime('%Y-%m-%dT%H:%M:%S') << 'Z</dcterms:created>')
       str << '<cp:revision>0</cp:revision>'
       str << '</cp:coreProperties>'
     end

data/lib/axlsx/drawing/area_chart.rb

@@ -0,0 +1,99 @@
+# encoding: UTF-8
+module Axlsx
+
+  # The AreaChart is a two dimentional line chart (who would have guessed?) that you can add to your worksheet.
+  # @example Creating a chart
+  #   # This example creates a line in a single sheet.
+  #   require "rubygems" # if that is your preferred way to manage gems!
+  #   require "axlsx"
+  #
+  #   p = Axlsx::Package.new
+  #   ws = p.workbook.add_worksheet
+  #   ws.add_row ["This is a chart with no data in the sheet"]
+  #
+  #   chart = ws.add_chart(Axlsx::AreaChart, :start_at=> [0,1], :end_at=>[0,6], :title=>"Most Popular Pets")
+  #   chart.add_series :data => [1, 9, 10], :labels => ["Slimy Reptiles", "Fuzzy Bunnies", "Rottweiler"]
+  #
+  # @see Worksheet#add_chart
+  # @see Worksheet#add_row
+  # @see Chart#add_series
+  # @see Series
+  # @see Package#serialize
+  class AreaChart < Chart
+
+    # the category axis
+    # @return [CatAxis]
+    def cat_axis
+      axes[:cat_axis]
+    end
+    alias :catAxis :cat_axis
+
+    # the category axis
+    # @return [ValAxis]
+    def val_axis
+      axes[:val_axis]
+    end
+    alias :valAxis :val_axis
+
+     # must be one of  [:percentStacked, :clustered, :standard, :stacked]
+    # @return [Symbol]
+    attr_reader :grouping
+
+    # Creates a new line chart object
+    # @param [GraphicFrame] frame The workbook that owns this chart.
+    # @option options [Cell, String] title
+    # @option options [Boolean] show_legend
+    # @option options [Symbol] grouping
+    # @see Chart
+    def initialize(frame, options={})
+      @vary_colors = false
+      @grouping = :standard
+      super(frame, options)
+      @series_type = AreaSeries
+      @d_lbls = nil
+    end
+
+    # @see grouping
+    def grouping=(v)
+      RestrictionValidator.validate "AreaChart.grouping", [:percentStacked, :standard, :stacked], v
+      @grouping = v
+    end
+
+    # The node name to use in serialization. As AreaChart is used as the
+    # base class for Liine3DChart we need to be sure to serialize the
+    # chart based on the actual class type and not a fixed node name.
+    # @return [String]
+    def node_name
+      path = self.class.to_s
+      if i = path.rindex('::')
+        path = path[(i+2)..-1]
+      end
+      path[0] = path[0].chr.downcase
+      path
+    end
+
+    # Serializes the object
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str = '')
+      super(str) do
+        str << ("<c:" << node_name << ">")
+        str << ('<c:grouping val="' << grouping.to_s << '"/>')
+        str << ('<c:varyColors val="' << vary_colors.to_s << '"/>')
+        @series.each { |ser| ser.to_xml_string(str) }
+        @d_lbls.to_xml_string(str) if @d_lbls
+        yield if block_given?
+        axes.to_xml_string(str, :ids => true)
+        str << ("</c:" << node_name << ">")
+        axes.to_xml_string(str)
+      end
+    end
+
+    # The axes for this chart. AreaCharts have a category and value
+    # axis.
+    # @return [Axes]
+    def axes
+      @axes ||= Axes.new(:cat_axis => CatAxis, :val_axis => ValAxis)
+    end
+  end
+end

data/lib/axlsx/drawing/area_series.rb

@@ -0,0 +1,110 @@
+# encoding: UTF-8
+module Axlsx
+  # A AreaSeries defines the title, data and labels for line charts
+  # @note The recommended way to manage series is to use Chart#add_series
+  # @see Worksheet#add_chart
+  # @see Chart#add_series
+  class AreaSeries < Series
+
+    # The data for this series.
+    # @return [ValAxisData]
+    attr_reader :data
+
+    # The labels for this series.
+    # @return [CatAxisData]
+    attr_reader :labels
+
+    # The fill color for this series.
+    # Red, green, and blue is expressed as sequence of hex digits, RRGGBB. A perceptual gamma of 2.2 is used.
+    # @return [String]
+    attr_reader :color
+
+    # show markers on values
+    # @return [Boolean]
+    attr_reader :show_marker
+
+    # custom marker symbol
+    # @return [String]
+    attr_reader :marker_symbol
+
+    # line smoothing on values
+    # @return [Boolean]
+    attr_reader :smooth
+
+    # Creates a new series
+    # @option options [Array, SimpleTypedList] data
+    # @option options [Array, SimpleTypedList] labels
+    # @param [Chart] chart
+    def initialize(chart, options={})
+      @show_marker = false
+      @marker_symbol = options[:marker_symbol] ? options[:marker_symbol] : :default
+      @smooth = false
+      @labels, @data = nil, nil
+      super(chart, options)
+      @labels = AxDataSource.new(:data => options[:labels]) unless options[:labels].nil?
+      @data = NumDataSource.new(options) unless options[:data].nil?
+    end
+
+    # @see color
+    def color=(v)
+      @color = v
+    end
+
+    # @see show_marker
+    def show_marker=(v)
+      Axlsx::validate_boolean(v)
+      @show_marker = v
+    end
+
+    # @see marker_symbol
+    def marker_symbol=(v)
+      Axlsx::validate_marker_symbol(v)
+      @marker_symbol = v
+    end
+
+    # @see smooth
+    def smooth=(v)
+      Axlsx::validate_boolean(v)
+      @smooth = v
+    end
+
+    # Serializes the object
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str = '')
+      super(str) do
+        if color
+          str << '<c:spPr><a:solidFill>'
+          str << ('<a:srgbClr val="' << color << '"/>')
+          str << '</a:solidFill>'
+          str << '<a:ln w="28800">'
+          str << '<a:solidFill>'
+          str << ('<a:srgbClr val="' << color << '"/>')
+          str << '</a:solidFill>'
+          str << '</a:ln>'
+          str << '<a:round/>'
+          str << '</c:spPr>'
+        end
+
+        if !@show_marker
+          str << '<c:marker><c:symbol val="none"/></c:marker>'
+        elsif @marker_symbol != :default
+          str << '<c:marker><c:symbol val="' + @marker_symbol.to_s + '"/></c:marker>'
+        end
+
+        @labels.to_xml_string(str) unless @labels.nil?
+        @data.to_xml_string(str) unless @data.nil?
+        str << ('<c:smooth val="' << ((smooth) ? '1' : '0') << '"/>')
+      end
+    end
+
+    private
+
+    # assigns the data for this series
+    def data=(v) DataTypeValidator.validate "Series.data", [NumDataSource], v; @data = v; end
+
+    # assigns the labels for this series
+    def labels=(v) DataTypeValidator.validate "Series.labels", [AxDataSource], v; @labels = v; end
+
+  end
+end