axlsx 1.1.4 → 1.2.0

data/examples/example.rb

@@ -57,7 +57,7 @@ wb.add_worksheet(:name => "Cell Level Style Overrides") do |sheet|
 end
 #```
 
-#Using Custom Border Styles
+##Using Custom Border Styles
 
 #```ruby
 #Axlsx defines a thin border style, but you can easily create and use your own.
@@ -97,7 +97,6 @@ wb.styles do |s|
     #Set the second column outline level
     sheet.column_info[1].outlineLevel = 2
 
-    #TODO rows hidden, outline etc.
     sheet.rows[3].hidden = true
     sheet.rows[1].outlineLevel = 2
   end
@@ -211,12 +210,9 @@ end
 #```ruby
 wb.add_worksheet(:name => "Bar Chart") do |sheet|
   sheet.add_row ["A Simple Bar Chart"]
-  sheet.add_row ["First", "Second", "Third"]
-  sheet.add_row [1, 2, 3]
-  sheet.add_chart(Axlsx::Bar3DChart, :start_at => "A4", :end_at => "F17") do |chart|
-    chart.add_series :data => sheet["A3:C3"], :labels => sheet["A2:C2"], :title => sheet["A1"]
-    chart.valAxis.label_rotation = -45
-    chart.catAxis.label_rotation = 45
+  %w(first second third).each { |label| sheet.add_row [label, rand(24)+1] }
+  sheet.add_chart(Axlsx::Bar3DChart, :start_at => "A6", :end_at => "F20") do |chart|
+    chart.add_series :data => sheet["B2:B4"], :labels => sheet["A2:A4"], :title => sheet["A1"]
   end
 end
 #```
@@ -225,11 +221,10 @@ end
 
 #```ruby
 wb.add_worksheet(:name => "Chart With No Gridlines") do |sheet|
-  sheet.add_row ["A Simple Bar Chart"]
-  sheet.add_row ["First", "Second", "Third"]
-  sheet.add_row [1, 2, 3]
-  sheet.add_chart(Axlsx::Bar3DChart, :start_at => "A4", :end_at => "F17") do |chart|
-    chart.add_series :data => sheet["A3:C3"], :labels => sheet["A2:C2"], :title => sheet["A1"]
+  sheet.add_row ["Bar Chart without gridlines"]
+  %w(first second third).each { |label| sheet.add_row [label, rand(24)+1] }
+  sheet.add_chart(Axlsx::Bar3DChart, :start_at => "A6", :end_at => "F20") do |chart|
+    chart.add_series :data => sheet["B2:B4"], :labels => sheet["A2:A4"]
     chart.valAxis.gridlines = false
     chart.catAxis.gridlines = false
   end
@@ -240,28 +235,10 @@ end
 
 #```ruby
 wb.add_worksheet(:name => "Pie Chart") do |sheet|
-  sheet.add_row ["First", "Second", "Third", "Fourth"]
-  sheet.add_row [1, 2, 3, "=PRODUCT(A2:C2)"]
-  sheet.add_chart(Axlsx::Pie3DChart, :start_at => [0,2], :end_at => [5, 15], :title => "example 3: Pie Chart") do |chart|
-    chart.add_series :data => sheet["A2:D2"], :labels => sheet["A1:D1"]
-  end
-end
-#```
-
-##Data over time
-
-#```ruby
-wb.add_worksheet(:name=>'Charting Dates') do |sheet|
-   # cell level style overides when adding cells
-  sheet.add_row ['Date', 'Value'], :sz => 16
-  sheet.add_row [Time.now - (7*60*60*24), 3]
-  sheet.add_row [Time.now - (6*60*60*24), 7]
-  sheet.add_row [Time.now - (5*60*60*24), 18]
-  sheet.add_row [Time.now - (4*60*60*24), 1]
-  sheet.add_chart(Axlsx::Bar3DChart) do |chart|
-    chart.start_at "B7"
-    chart.end_at "H27"
-    chart.add_series(:data => sheet["B2:B5"], :labels => sheet["A2:A5"], :title => sheet["B1"])
+  sheet.add_row ["Simple Pie Chart"]
+  %w(first second third).each { |label| sheet.add_row [label, rand(24)+1] }
+  sheet.add_chart(Axlsx::Pie3DChart, :start_at => [0,5], :end_at => [10, 20], :title => "example 3: Pie Chart") do |chart|
+    chart.add_series :data => sheet["B2:B4"], :labels => sheet["A2:A4"],  :colors => ['FF0000', '00FF00', '0000FF']
   end
 end
 #```
@@ -270,13 +247,18 @@ end
 
 #```ruby
 wb.add_worksheet(:name => "Line Chart") do |sheet|
-  sheet.add_row ["First", 1, 5, 7, 9]
-  sheet.add_row ["Second", 5, 2, 14, 9]
-  sheet.add_chart(Axlsx::Line3DChart, :title => "example 6: Line Chart", :rotX => 30, :rotY => 20) do |chart|
-    chart.start_at 0, 2
-    chart.end_at 10, 15
-    chart.add_series :data => sheet["B1:E1"], :title => sheet["A1"]
-    chart.add_series :data => sheet["B2:E2"], :title => sheet["A2"]
+  sheet.add_row ["Simple Line Chart"]
+  sheet.add_row %w(first second)
+  4.times do
+    sheet.add_row [ rand(24)+1, rand(24)+1]
+  end
+  sheet.add_chart(Axlsx::Line3DChart, :title => "Simple Line Chart", :rotX => 30, :rotY => 20) do |chart|
+    chart.start_at 0, 5
+    chart.end_at 10, 20
+    chart.add_series :data => sheet["A3:A6"], :title => sheet["A2"]
+    chart.add_series :data => sheet["B3:B6"], :title => sheet["B2"]
+    chart.catAxis.title = 'X Axis'
+    chart.valAxis.title = 'Y Axis'
   end
 end
 #```
@@ -320,7 +302,7 @@ wb.add_worksheet(:name => "fit to page") do |sheet|
   sheet.add_row ['this all goes on one page']
   sheet.fit_to_page = true
 end
-#```
+##```
 
 
 ##Hide Gridlines in worksheet
@@ -330,18 +312,119 @@ wb.add_worksheet(:name => "No Gridlines") do |sheet|
   sheet.add_row ["This", "Sheet", "Hides", "Gridlines"]
   sheet.show_gridlines = false
 end
-#```
+##```
 
+#```ruby
+wb.add_worksheet(:name => "repeated header") do |sheet|
+  sheet.add_row %w(These Column Header Will Render On Every Printed Sheet)
+  200.times { sheet.add_row %w(1 2 3 4 5 6 7 8) }
+  wb.add_defined_name("'repeated header'!$1:$1", :local_sheet_id => sheet.index, :name => '_xlnm.Print_Titles') 
+end
 
-##Specify Page Margins for printing
+# Sheet Protection and excluding cells from locking.
+unlocked = wb.styles.add_style :locked => false
+wb.add_worksheet(:name => 'Sheet Protection') do |sheet|
+  sheet.sheet_protection.password = 'fish'
+  sheet.add_row [1, 2 ,3] # These cells will be locked
+  sheet.add_row [4, 5, 6], :style => unlocked # these cells will not!
+end
+
+
+##Specify page margins and other options for printing
 
 #```ruby
 margins = {:left => 3, :right => 3, :top => 1.2, :bottom => 1.2, :header => 0.7, :footer => 0.7}
-wb.add_worksheet(:name => "print margins", :page_margins => margins) do |sheet|
-  sheet.add_row ["this sheet uses customized page margins for printing"]
+setup = {:fit_to_width => 1, :orientation => :landscape, :paper_width => "297mm", :paper_height => "210mm"}
+options = {:grid_lines => true, :headings => true, :horizontal_centered => true}
+wb.add_worksheet(:name => "print margins", :page_margins => margins, :page_setup => setup, :print_options => options) do |sheet|
+  sheet.add_row ["this sheet uses customized print settings"]
 end
 #```
 
+## Add Comments to your spreadsheet 
+#``` ruby
+wb.add_worksheet(:name => 'comments') do |sheet|
+  sheet.add_row ['Can we build it?']
+  sheet.add_comment :ref => 'A1', :author => 'Bob', :text => 'Yes We Can!'
+end
+
+## Frozen/Split panes
+## ``` ruby
+wb.add_worksheet(:name => 'fixed headers') do |sheet|
+ sheet.add_row(['',  (0..99).map { |i| "column header #{i}" }].flatten )
+  100.times.with_index { |index| sheet << ["row header", (0..index).to_a].flatten }
+  sheet.sheet_view.pane do |pane|
+    pane.top_left_cell = "B2"
+    pane.state = :frozen_split
+    pane.y_split = 1
+    pane.x_split = 1
+    pane.active_pane = :bottom_right
+  end
+end
+
+# conditional formatting
+#
+percent = wb.styles.add_style(:format_code => "0.00%", :border => Axlsx::STYLE_THIN_BORDER)
+money = wb.styles.add_style(:format_code => '0,000', :border => Axlsx::STYLE_THIN_BORDER)
+
+# define the style for conditional formatting
+profitable = wb.styles.add_style( :fg_color=>"FF428751",
+                                    :type => :dxf)
+
+wb.add_worksheet(:name => "Conditional Cell Is") do |ws|
+
+  # Generate 20 rows of data
+  ws.add_row ["Previous Year Quarterly Profits (JPY)"]
+  ws.add_row ["Quarter", "Profit", "% of Total"]
+  offset = 3
+  rows = 20
+  offset.upto(rows + offset) do |i|
+    ws.add_row ["Q#{i}", 10000*((rows/2-i) * (rows/2-i)), "=100*B#{i}/SUM(B3:B#{rows+offset})"], :style=>[nil, money, percent]
+  end
+
+# Apply conditional formatting to range B3:B100 in the worksheet
+  ws.add_conditional_formatting("B3:B100", { :type => :cellIs, :operator => :greaterThan, :formula => "100000", :dxfId => profitable, :priority => 1 })
+end
+
+wb.add_worksheet(:name => "Conditional Color Scale") do |ws|
+  ws.add_row ["Previous Year Quarterly Profits (JPY)"]
+  ws.add_row ["Quarter", "Profit", "% of Total"]
+  offset = 3
+  rows = 20
+  offset.upto(rows + offset) do |i|
+    ws.add_row ["Q#{i}", 10000*((rows/2-i) * (rows/2-i)), "=100*B#{i}/SUM(B3:B#{rows+offset})"], :style=>[nil, money, percent]
+  end
+# Apply conditional formatting to range B3:B100 in the worksheet
+  color_scale = Axlsx::ColorScale.new
+  ws.add_conditional_formatting("B3:B100", { :type => :colorScale, :operator => :greaterThan, :formula => "100000", :dxfId => profitable, :priority => 1, :color_scale => color_scale })
+end
+
+
+wb.add_worksheet(:name => "Conditional Data Bar") do |ws|
+  ws.add_row ["Previous Year Quarterly Profits (JPY)"]
+  ws.add_row ["Quarter", "Profit", "% of Total"]
+  offset = 3
+  rows = 20
+  offset.upto(rows + offset) do |i|
+    ws.add_row ["Q#{i}", 10000*((rows/2-i) * (rows/2-i)), "=100*B#{i}/SUM(B3:B#{rows+offset})"], :style=>[nil, money, percent]
+  end
+# Apply conditional formatting to range B3:B100 in the worksheet
+  data_bar = Axlsx::DataBar.new
+  ws.add_conditional_formatting("B3:B100", { :type => :dataBar, :dxfId => profitable, :priority => 1, :data_bar => data_bar })
+end
+
+wb.add_worksheet(:name => "Conditional Format Icon Set") do |ws|
+  ws.add_row ["Previous Year Quarterly Profits (JPY)"]
+  ws.add_row ["Quarter", "Profit", "% of Total"]
+  offset = 3
+  rows = 20
+  offset.upto(rows + offset) do |i|
+    ws.add_row ["Q#{i}", 10000*((rows/2-i) * (rows/2-i)), "=100*B#{i}/SUM(B3:B#{rows+offset})"], :style=>[nil, money, percent]
+  end
+# Apply conditional formatting to range B3:B100 in the worksheet
+  icon_set = Axlsx::IconSet.new
+  ws.add_conditional_formatting("B3:B100", { :type => :iconSet, :dxfId => profitable, :priority => 1, :icon_set => icon_set })
+end
 
 ##Validate and Serialize
 

data/examples/extractive.rb

@@ -13,6 +13,7 @@ data = [ ['oil-bbl',9591.411671,8860.714604,8237.936509,7700.523067,7231.831842,
 p = Axlsx::Package.new
 wb = p.workbook
 wb.add_worksheet(:name => 'volumes') do |ws|
+
   # perspective, rotX and rotY flatten the 3D chart
   # hPercent sets the chart height to 100%
   chart = ws.add_chart(Axlsx::Line3DChart, :perspective => 0, :hPercent => 100, :rotX => 0, :rotY => 0, :start_at => "A4", :end_at => 'M44', :title => 'Monthly forcast for Type Curve Gas secondary - gross ngl')
@@ -27,12 +28,14 @@ wb.add_worksheet(:name => 'volumes') do |ws|
 
   # Knock the catAxis labels down to the forced min.
   chart.catAxis.crosses = :min
+
   # set up cat labels / markes to show every 12th item
   chart.catAxis.tickLblSkip = 12
   chart.catAxis.tickMarkSkip = 12
 
   #rgb colors for our data series
   colors = ['00FF00', 'FF0000', '0000FF']
+
   data.each_with_index do |value, index|
     ws.add_row value
     chart.add_series :data => ws.rows.last.cells[(1..value.size-1)], :labels => (0..value.size).map{ |i| i }, :title => ws.rows.last.cells.first, :color => colors[index]

data/examples/scraping_html.rb

@@ -0,0 +1,91 @@
+    require 'rubygems'
+    require 'nokogiri'
+    require 'open-uri'
+    require 'axlsx'
+
+    class Scraper
+
+       def initialize(url, selector)
+         @url = url
+         @selector = selector
+       end
+
+       def hooks
+         @hooks ||= {}
+       end
+
+       def add_hook(clue, p_roc)
+         hooks[clue] = p_roc
+       end
+
+       def export(file_name)
+         Scraper.clues.each do |clue|
+           if detail = parse_clue(clue)
+             output << [clue, detail.pop]
+             detail.each { |datum| output << ['', datum] }
+           end
+         end
+         serialize(file_name)
+       end
+
+       private
+
+       def self.clues
+         @clues ||= ['Operating system', 'Processors', 'Chipset', 'Memory type', 'Hard drive', 'Graphics',
+                     'Ports', 'Webcam', 'Pointing device', 'Keyboard', 'Network interface', 'Chipset', 'Wireless',
+                     'Power supply type', 'Energy efficiency', 'Weight', 'Minimum dimensions (W x D x H)',
+                     'Warranty', 'Software included', 'Product color']
+       end
+
+       def doc
+         @doc ||= begin 
+                    Nokogiri::HTML(open(@url))
+                  rescue
+                    raise ArgumentError, 'Invalid URL - Nothing to parse'
+                  end
+       end
+
+       def output
+         @output ||= []
+       end
+
+       def selector_for_clue(clue)
+         @selector % clue
+       end
+
+       def parse_clue(clue)
+         if element = doc.at(selector_for_clue(clue))
+           call_hook(clue, element) || element.inner_html.split('<br>').each(&:strip)
+         end
+       end
+
+       def call_hook(clue, element)
+         if hooks[clue].is_a? Proc
+            value = hooks[clue].call(element)
+            value.is_a?(Array) ? value : [value]
+         end
+       end
+
+       def package
+         @package ||= Axlsx::Package.new
+       end
+
+       def serialize(file_name)
+         package.workbook.add_worksheet do |sheet|
+           output.each { |datum| sheet.add_row datum }
+         end
+         package.serialize(file_name)
+       end
+    end
+
+    scraper = Scraper.new("http://h10010.www1.hp.com/wwpc/ie/en/ho/WF06b/321957-321957-3329742-89318-89318-5186820-5231694.html?dnr=1", "//td[text()='%s']/following-sibling::td")
+
+    # define a custom action to take against any elements found.
+    os_parse = Proc.new do |element|
+      element.inner_html.split('<br>').each(&:strip!).each(&:upcase!)
+    end
+
+    scraper.add_hook('Operating system', os_parse)
+
+    scraper.export('foo.xlsx')
+

data/examples/sheet_protection.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby -w -s
+# -*- coding: utf-8 -*-
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
+require 'axlsx'
+
+p = Axlsx::Package.new
+p.workbook.add_worksheet(:name => 'Open Office') { |ws| ws.sheet_protection.password = 'fish' }
+p.serialize 'sheet_protection.xlsx'
+
+

data/examples/sheet_view.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby -w -s
+# -*- coding: utf-8 -*-
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
+require 'axlsx'
+
+p = Axlsx::Package.new
+ws = p.workbook.add_worksheet :name => "Sheetview - Split"
+ws.sheet_view do |vs|
+  vs.pane do |p|
+    p.active_pane = :top_right
+    p.state = :split
+    p.x_split = 11080
+    p.y_split = 5000
+    p.top_left_cell = 'C44'
+  end
+  
+  vs.add_selection(:top_left, { :active_cell => 'A2', :sqref => 'A2' })
+  vs.add_selection(:top_right, { :active_cell => 'I10', :sqref => 'I10' })
+  vs.add_selection(:bottom_left, { :active_cell => 'E55', :sqref => 'E55' })
+  vs.add_selection(:bottom_right, { :active_cell => 'I57', :sqref => 'I57' })
+end
+
+
+ws = p.workbook.add_worksheet :name => "Sheetview - Frozen"
+ws.sheet_view do |vs|
+  vs.pane do |p|
+    p.state = :frozen
+    p.x_split = 3
+    p.y_split = 4
+  end
+end
+
+
+p.serialize 'sheet_view.xlsx'

data/examples/two_cell_anchor_image.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby -w -s
+# -*- coding: utf-8 -*-
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
+require 'axlsx'
+
+p = Axlsx::Package.new
+src = "#{File.dirname(__FILE__)}/image1.png"
+p.workbook.add_worksheet(:name => 'double_anchor') do |ws|
+  ws.add_image(:image_src => src, :start_at => [0,0], :end_at => [2,4])
+end
+p.serialize('two_cell_anchor_image.xlsx')

data/lib/axlsx/content_type/content_type.rb

@@ -1,5 +1,6 @@
 # encoding: UTF-8
 module Axlsx
+
   require 'axlsx/content_type/default.rb'
   require 'axlsx/content_type/override.rb'
 
@@ -21,4 +22,5 @@ module Axlsx
     end
 
   end
+
 end

data/lib/axlsx/content_type/default.rb

@@ -1,41 +1,56 @@
 # encoding: UTF-8
 module Axlsx
+
   # An default content part. These parts are automatically created by for you based on the content of your package.
   class Default
 
+    #Creates a new Default object
+    # @option options [String] extension
+    # @option options [String] content_type
+    # @raise [ArgumentError] An argument error is raised if both extension and content_type are not specified.
+    def initialize(options={})
+      raise ArgumentError, INVALID_ARGUMENTS unless validate_options(options)
+      options.each do |name, value|
+        self.send("#{name}=", value) if self.respond_to? "#{name}="
+      end
+    end
+
+    # Error string for option validation
+    INVALID_ARGUMENTS = "extension and content_type are required"
+
     # The extension of the content type.
     # @return [String]
-    attr_reader :Extension
+    attr_reader :extension
+    alias :Extension :extension
 
     # The type of content.
     # @return [String]
-    attr_reader :ContentType
+    attr_reader :content_type
+    alias :ContentType :content_type
 
-    #Creates a new Default object
-    # @option options [String] Extension
-    # @option options [String] ContentType
-    # @raise [ArgumentError] An argument error is raised if both Extension and ContentType are not specified.
-    def initialize(options={})
-      raise ArgumentError, "Extension and ContentType are required" unless options[:Extension] && options[:ContentType]
-      options.each do |o|
-        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
-      end
-    end
     # Sets the file extension for this content type.
-    def Extension=(v) Axlsx::validate_string v; @Extension = v end
+    def extension=(v) Axlsx::validate_string v; @extension = v end
+    alias :Extension= :extension=
 
     # Sets the content type
     # @see Axlsx#validate_content_type
-    def ContentType=(v) Axlsx::validate_content_type v; @ContentType = v end
+    def content_type=(v) Axlsx::validate_content_type v; @content_type = v end
+    alias :ContentType= :content_type=
 
     # Serializes the object
     # @param [String] str
     # @return [String]
     def to_xml_string(str = '')
       str << '<Default '
-      str << instance_values.map { |key, value| '' << key.to_s << '="' << value.to_s << '"' }.join(' ')
+      str << instance_values.map { |key, value| '' << Axlsx::camel(key) << '="' << value.to_s << '"' }.join(' ')
       str << '/>'
     end
 
+    private
+    def validate_options(options)
+      (options[:Extension] || options[:extension]) && (options[:content_type] || options[:ContentType])
+    end
+
   end
+
 end

data/lib/axlsx/content_type/override.rb

@@ -1,42 +1,57 @@
 # encoding: UTF-8
 module Axlsx
+
   # An override content part. These parts are automatically created by for you based on the content of your package.
   class Override
 
-    # The type of content.
-    # @return [String]
-    attr_reader :ContentType
-
-    # The name and location of the part.
-    # @return [String]
-    attr_reader :PartName
-
     #Creates a new Override object
     # @option options [String] PartName
     # @option options [String] ContentType
     # @raise [ArgumentError] An argument error is raised if both PartName and ContentType are not specified.
     def initialize(options={})
-      raise ArgumentError, "PartName and ContentType are required" unless options[:PartName] && options[:ContentType]
-      options.each do |o|
-        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
+      raise ArgumentError, INVALID_ARGUMENTS unless validate_options(options)
+      options.each do |name, value|
+        self.send("#{name}=", value) if self.respond_to? "#{name}="
       end
     end
 
+    # Error message for invalid options
+    INVALID_ARGUMENTS = 'part_name and content_type are required'
+
+    # The type of content.
+    # @return [String]
+    attr_reader :content_type
+    alias :ContentType :content_type
+
+    # The name and location of the part.
+    # @return [String]
+    attr_reader :part_name
+    alias :PartName :part_name
+
     # The name and location of the part.
-    def PartName=(v) Axlsx::validate_string v; @PartName = v end
+    def part_name=(v) Axlsx::validate_string v; @part_name = v end
+    alias :PartName= :part_name=
 
     # The content type.
     # @see Axlsx#validate_content_type
-    def ContentType=(v) Axlsx::validate_content_type v; @ContentType = v end
+    def content_type=(v) Axlsx::validate_content_type v; @content_type = v end
+    alias :ContentType= :content_type=
 
     # Serializes the object
     # @param [String] str
     # @return [String]
     def to_xml_string(str = '')
       str << '<Override '
-      str << instance_values.map { |key, value| '' << key.to_s << '="' << value.to_s << '"' }.join(' ')
+      str << instance_values.map { |key, value| '' << Axlsx::camel(key) << '="' << value.to_s << '"' }.join(' ')
       str << '/>'
     end
 
+    private 
+
+    def validate_options(options)
+      (options[:PartName] || options[:part_name]) && (options[:ContentType] || options[:content_type])
+    end
+
   end
+
 end