axlsx 1.0.11 → 1.0.12

data/lib/axlsx/drawing/series_title.rb

@@ -1,22 +0,0 @@
-module Axlsx
-  # A series title is a Title with a slightly different serialization than chart titles.
-  class SeriesTitle < Title
-
-    # Serializes the series title
-    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
-    # @return [String]
-    def to_xml(xml)
-      xml.send('c:tx') {
-        xml.send('c:strRef') {
-          xml.send('c:f', Axlsx::cell_range([@cell]))
-          xml.send('c:strCache') {
-            xml.send('c:ptCount', :val=>1)
-            xml.send('c:pt', :idx=>0) {
-              xml.send('c:v', @text)
-            }
-          }
-        }
-      }
-    end
-  end
-end

data/lib/axlsx/drawing/title.rb

@@ -1,61 +0,0 @@
-module Axlsx
-  # A Title stores information about the title of a chart
-  class Title
-    
-    # The text to be shown. Setting this property directly with a string will remove the cell reference.
-    # @return [String]
-    attr_reader :text
-
-    # The cell that holds the text for the title. Setting this property will automatically update the text attribute.
-    # @return [Cell]
-    attr_reader :cell
-
-    # Creates a new Title object
-    # @param [String, Cell] title The cell or string to be used for the chart's title
-    def initialize(title="")
-      self.cell = title if title.is_a?(Cell)
-      self.text = title.to_s unless title.is_a?(Cell)
-    end
-    
-    # @see text
-    def text=(v) 
-      DataTypeValidator.validate 'Title.text', String, v
-      @text = v
-      @cell = nil
-      v
-    end
-
-    # @see cell
-    def cell=(v)
-      DataTypeValidator.validate 'Title.text', Cell, v
-      @cell = v
-      @text = v.value.to_s      
-      v
-    end
-
-    # Not implemented at this time.
-    #def layout=(v) DataTypeValidator.validate 'Title.layout', Layout, v; @layout = v; end
-    #def overlay=(v) Axlsx::validate_boolean v; @overlay=v; end
-    #def spPr=(v) DataTypeValidator.validate 'Title.spPr', SpPr, v; @spPr = v; end
-    
-    # Serializes the chart title
-    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
-    # @return [String]
-    def to_xml(xml)
-      xml.send('c:title') {
-        xml.send('c:tx') {
-          xml.send('c:strRef') {
-            xml.send('c:f', Axlsx::cell_range([@cell]))
-            xml.send('c:strCache') {
-              xml.send('c:ptCount', :val=>1)
-              xml.send('c:pt', :idx=>0) {
-                xml.send('c:v', @text)
-              }
-            }
-          }
-        }
-      }      
-    end
-    
-  end
-end

data/lib/axlsx/drawing/two_cell_anchor.rb

@@ -1,76 +0,0 @@
-module Axlsx
-  # This class details the anchor points for drawings.
-  # @note The recommended way to manage drawings and charts is Worksheet#add_chart. Anchors are specified by the :start_at and :end_at options to that method.
-  # @see Worksheet#add_chart
-  class TwoCellAnchor
-
-    # A marker that defines the from cell anchor. The default from column and row are 0 and 0 respectively
-    # @return [Marker]
-    attr_reader :from
-    # A marker that returns the to cell anchor. The default to column and row are 5 and 10 respectively
-    # @return [Marker]
-    attr_reader :to
-
-    # The frame for your chart
-    # @note this will be discontinued in version 2.0 please use object
-    # @return [GraphicFrame]
-    # attr_reader :graphic_frame
-
-    # The object this anchor hosts
-    # @return [Pic, GraphicFrame]
-    attr_reader :object
-
-    # The drawing that holds this anchor
-    # @return [Drawing]
-    attr_reader :drawing
-
-
-    # Creates a new TwoCellAnchor object and sets up a reference to the from and to markers in the 
-    # graphic_frame's chart. That means that you can do stuff like
-    # c = worksheet.add_chart Axlsx::Chart
-    # c.start_at 5, 9
-    # @note the chart_type parameter will be replaced with object in v. 2.0.0
-    # @param [Drawing] drawing
-    # @param [Class] chart_type This is passed to the graphic frame for instantiation. must be Chart or a subclass of Chart
-    # @param object The object this anchor holds.
-    # @option options [Array] start_at the col, row to start at
-    # @option options [Array] end_at the col, row to end at
-    def initialize(drawing, options={})
-      @drawing = drawing
-      drawing.anchors << self      
-      @from, @to =  Marker.new, Marker.new(:col => 5, :row=>10)
-    end
-
-    # Creates a graphic frame and chart object associated with this anchor
-    # @return [Chart]
-    def add_chart(chart_type, options)      
-      @object = GraphicFrame.new(self, chart_type, options)
-      @object.chart
-    end
-
-    # The index of this anchor in the drawing
-    # @return [Integer]
-    def index
-      @drawing.anchors.index(self)
-    end
-    # Serializes the two cell anchor
-    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
-    # @return [String]
-    def to_xml(xml)
-      #build it for now, break it down later!
-      xml.send('xdr:twoCellAnchor') {
-        xml.send('xdr:from') {
-          from.to_xml(xml)
-        }
-        xml.send('xdr:to') {
-          to.to_xml(xml)
-        }
-        @object.to_xml(xml)
-        xml.send('xdr:clientData')
-      }
-    end    
-
-    private
-
-  end
-end

data/lib/axlsx/drawing/val_axis.rb

@@ -1,34 +0,0 @@
-module Axlsx
-  # the ValAxis class defines a chart value axis.
-  class ValAxis < Axis
-
-    # This element specifies how the value axis crosses the category axis.
-    # must be one of [:between, :midCat]
-    # @return [Symbol]
-    attr_reader :crossBetween
-
-    # Creates a new ValAxis object
-    # @param [Integer] axId the id of this axis
-    # @param [Integer] crossAx the id of the perpendicular axis
-    # @option options [Symbol] axPos
-    # @option options [Symbol] tickLblPos
-    # @option options [Symbol] crosses
-    # @option options [Symbol] crossesBetween
-    def initialize(axId, crossAx, options={})
-      self.crossBetween = :between
-      super(axId, crossAx, options)
-    end
-    # @see crossBetween
-    def crossBetween=(v) RestrictionValidator.validate "ValAxis.crossBetween", [:between, :midCat], v; @crossBetween = v; end
-
-    # Serializes the value axis
-    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
-    # @return [String]
-    def to_xml(xml)
-      xml.send('c:valAx') {
-        super(xml)
-        xml.send('c:crossBetween', :val=>@crossBetween)
-      }
-    end
-  end
-end

data/lib/axlsx/drawing/val_axis_data.rb

@@ -1,28 +0,0 @@
-module Axlsx
-  # The ValAxisData class manages the values for a chart value series.
-  class ValAxisData < CatAxisData
-
-    # Serializes the value axis data
-    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
-    # @return [String]
-    def to_xml(xml)
-      xml.send('c:val') {
-        xml.send('c:numRef') {
-          xml.send('c:f', Axlsx::cell_range(@list))
-          xml.send('c:numCache') {
-            xml.send('c:formatCode', 'General')
-            xml.send('c:ptCount', :val=>size)
-            each_with_index do |item, index|
-              v = item.is_a?(Cell) ? item.value : item
-              xml.send('c:pt', :idx=>index) {
-                xml.send('c:v', v) 
-              }
-            end
-          }                        
-        }
-      }
-    end
-
-  end
-  
-end

data/lib/axlsx/drawing/view_3D.rb

@@ -1,85 +0,0 @@
-module Axlsx
-  # 3D attributes for a chart.
-  class View3D
-
-    # Validation for hPercent
-    H_PERCENT_REGEX = /0*(([5-9])|([1-9][0-9])|([1-4][0-9][0-9])|500)%/
-    
-    # validation for depthPercent
-    DEPTH_PERCENT_REGEX = /0*(([2-9][0-9])|([1-9][0-9][0-9])|(1[0-9][0-9][0-9])|2000)%/
-
-    # x rotation for the chart 
-    # must be between -90 and 90
-    # @return [Integer]
-    attr_reader :rotX
-    
-    # height of chart as % of chart
-    # must be between 5% and 500%
-    # @return [String]
-    attr_reader :hPercent
-    
-    # y rotation for the chart
-    # must be between 0 and 360
-    # @return [Integer]
-    attr_reader :rotY
-    
-    # depth or chart as % of chart width
-    # must be between 20% and 2000%
-    # @return [String]
-    attr_reader :depthPercent
-    
-    # Chart axis are at right angles
-    # @return [Boolean]
-    attr_reader :rAngAx
-    
-    # field of view angle
-    # @return [Integer]
-    attr_reader :perspective
-
-    # Creates a new View3D for charts
-    # @option options [Integer] rotX
-    # @option options [String] hPercent
-    # @option options [Integer] rotY
-    # @option options [String] depthPercent
-    # @option options [Boolean] rAngAx
-    # @option options [Integer] perspective
-    def initialize(options={})
-      @rotX, @hPercent, @rotY, @depthPercent, @rAngAx, @perspective  = nil, nil, nil, nil, nil, nil 
-      options.each do |o|
-        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
-      end    
-    end
-
-    # @see rotX
-    def rotX=(v) DataTypeValidator.validate "#{self.class}.rotX", [Integer, Fixnum], v, lambda {|arg| arg >= -90 && arg <= 90 }; @rotX = v; end
-
-    # @see hPercent
-    def hPercent=(v) RegexValidator.validate "#{self.class}.rotX", H_PERCENT_REGEX, v; @hPercent = v; end
-
-    # @see rotY
-    def rotY=(v) DataTypeValidator.validate "#{self.class}.rotY", [Integer, Fixnum], v, lambda {|arg| arg >= 0 && arg <= 360 }; @rotY = v; end
-
-    # @see depthPercent
-    def depthPercent=(v) RegexValidator.validate "#{self.class}.depthPercent", DEPTH_PERCENT_REGEX, v; @depthPercent = v; end
-
-    # @see rAngAx
-    def rAngAx=(v) Axlsx::validate_boolean(v); @rAngAx = v; end
-
-    # @see perspective
-    def perspective=(v) DataTypeValidator.validate "#{self.class}.perspective", [Integer, Fixnum], v, lambda {|arg| arg >= 0 && arg <= 240 }; @perspective = v; end
-
-    # Serializes the view3D properties
-    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
-    # @return [String]
-    def to_xml(xml)
-      xml.send('c:view3D') {
-        xml.send('c:rotX', :val=>@rotX) unless @rotX.nil?
-        xml.send('c:hPercent', :val=>@hPercent) unless @hPercent.nil?
-        xml.send('c:rotY', :val=>@rotY) unless @rotY.nil?
-        xml.send('c:depthPercent', :val=>@depthPercent) unless @depthPercent.nil?
-        xml.send('c:rAngAx', :val=>@rAngAx) unless @rAngAx.nil?
-        xml.send('c:perspective', :val=>@perspective) unless @perspective.nil?
-      }
-    end
-  end
-end

data/lib/axlsx/package.rb

@@ -1,214 +0,0 @@
-# -*- coding: utf-8 -*-
-module Axlsx
-  # Package is responsible for managing all the bits and peices that Open Office XML requires to make a valid
-  # xlsx document including valdation and serialization.
-  class Package
-
-    # Initializes your package
-    #
-    # @param [Hash] options A hash that you can use to specify the author and workbook for this package.
-    # @option options [String] :author The author of the document
-    # @example Package.new :author => 'you!', :workbook => Workbook.new
-    def initialize(options={})
-      @workbook = nil
-      @core, @app = Core.new, App.new
-      @core.creator = options[:author] || @core.creator
-      yield self if block_given?
-    end
-
-    # The workbook this package will serialize or validate.
-    # @return [Workbook] If no workbook instance has been assigned with this package a new Workbook instance is returned.
-    # @raise ArgumentError if workbook parameter is not a Workbook instance.
-    # @note As there are multiple ways to instantiate a workbook for the package, 
-    #   here are a few examples:
-    #     # assign directly during package instanciation
-    #     wb = Package.new(:workbook => Workbook.new).workbook
-    #
-    #     # get a fresh workbook automatically from the package
-    #     wb = Pacakge.new().workbook
-    #     #     # set the workbook after creating the package
-    #     wb = Package.new().workbook = Workbook.new
-    def workbook
-      @workbook || @workbook = Workbook.new
-      yield @workbook if block_given?
-      @workbook
-    end
-    
-    #def self.parse(input, confirm_valid = false)
-    #  p = Package.new
-    #  z = Zip::ZipFile.open(input)
-    #  p.workbook = Workbook.parse z.get_entry(WORKBOOK_PN)
-    #  p
-    #end    
-
-    # @see workbook
-    def workbook=(workbook) DataTypeValidator.validate "Package.workbook", Workbook, workbook; @workbook = workbook; end
-
-    # Serialize your workbook to disk as an xlsx document.
-    #
-    # @param [File] output The file you want to serialize your package to
-    # @param [Boolean] confirm_valid Validate the package prior to serialization.
-    # @return [Boolean] False if confirm_valid and validation errors exist. True if the package was serialized
-    # @note A tremendous amount of effort has gone into ensuring that you cannot create invalid xlsx documents.
-    #   confirm_valid should be used in the rare case that you cannot open the serialized file. 
-    # @see Package#validate
-    # @example
-    #   # This is how easy it is to create a valid xlsx file. Of course you might want to add a sheet or two, and maybe some data, styles and charts.
-    #   # Take a look at the README for an example of how to do it!
-    #   f = File.open('test.xlsx', 'w')
-    #   Package.new.serialize(f)
-    #
-    #   # You will find a file called test.xlsx
-    def serialize(output, confirm_valid=false)
-      return false unless !confirm_valid || self.validate.empty?
-      p = parts
-      Zip::ZipOutputStream.open(output) do |zip|
-        p.each do |part| 
-          unless part[:doc].nil?
-            zip.put_next_entry(part[:entry]); 
-            zip.puts(part[:doc])
-          end
-          unless part[:path].nil?
-            zip.put_next_entry(part[:entry]); 
-            # binread for 1.9.3
-            zip.write IO.respond_to?(:binread) ? IO.binread(part[:path]) : IO.read(part[:path])
-          end          
-        end
-      end
-      true
-    end
-    
-    
-    # Validate all parts of the package against xsd schema. 
-    # @return [Array] An array of all validation errors found.
-    # @note This gem includes all schema from OfficeOpenXML-XMLSchema-Transitional.zip and OpenPackagingConventions-XMLSchema.zip
-    #   as per ECMA-376, Third edition. opc schema require an internet connection to import remote schema from dublin core for dc,
-    #   dcterms and xml namespaces. Those remote schema are included in this gem, and the original files have been altered to 
-    #   refer to the local versions.
-    #
-    #   If by chance you are able to creat a package that does not validate it indicates that the internal
-    #   validation is not robust enough and needs to be improved. Please report your errors to the gem author.
-    # @see http://www.ecma-international.org/publications/standards/Ecma-376.htm
-    # @example
-    #  # The following will output any error messages found in serialization.
-    #  p = Axlsx::Package.new
-    #  # ... code to create sheets, charts, styles etc.
-    #  p.validate.each { |error| puts error.message }
-    def validate
-      errors = []
-      parts.each { |part| errors.concat validate_single_doc(part[:schema], part[:doc]) unless part[:schema].nil? }
-      errors
-    end
-
-    private 
-
-    # The parts of a package
-    # @return [Array] An array of hashes that define the entry, document and schema for each part of the package. 
-    # @private
-    def parts
-      @parts = [
-       {:entry => RELS_PN, :doc => relationships.to_xml, :schema => RELS_XSD},
-       {:entry => CORE_PN, :doc => @core.to_xml, :schema => CORE_XSD},
-       {:entry => APP_PN, :doc => @app.to_xml, :schema => APP_XSD},
-       {:entry => WORKBOOK_RELS_PN, :doc => workbook.relationships.to_xml, :schema => RELS_XSD},
-       {:entry => WORKBOOK_PN, :doc => workbook.to_xml, :schema => SML_XSD},
-       {:entry => CONTENT_TYPES_PN, :doc => content_types.to_xml, :schema => CONTENT_TYPES_XSD},
-       {:entry => "xl/#{STYLES_PN}", :doc => workbook.styles.to_xml, :schema => SML_XSD}
-      ]
-      workbook.drawings.each do |drawing|
-        @parts << {:entry => "xl/#{drawing.rels_pn}", :doc => drawing.relationships.to_xml, :schema => RELS_XSD}
-        @parts << {:entry => "xl/#{drawing.pn}", :doc => drawing.to_xml, :schema => DRAWING_XSD}
-      end
-        
-      workbook.charts.each do |chart|          
-        @parts << {:entry => "xl/#{chart.pn}", :doc => chart.to_xml, :schema => DRAWING_XSD}
-      end                  
-
-      workbook.images.each do |image|
-        @parts << {:entry => "xl/#{image.pn}", :path => image.image_src}
-      end
-
-      workbook.worksheets.each do |sheet|            
-        @parts << {:entry => "xl/#{sheet.rels_pn}", :doc => sheet.relationships.to_xml, :schema => RELS_XSD}
-        @parts << {:entry => "xl/#{sheet.pn}", :doc => sheet.to_xml, :schema => SML_XSD}        
-      end
-      @parts
-    end
-
-    # Performs xsd validation for a signle document
-    #
-    # @param [String] schema path to the xsd schema to be used in validation.
-    # @param [String] doc The xml text to be validated
-    # @return [Array] An array of all validation errors encountered.
-    # @private
-    def validate_single_doc(schema, doc)
-      schema = Nokogiri::XML::Schema(File.open(schema))
-      doc = Nokogiri::XML(doc)
-
-      errors = []
-      schema.validate(doc).each do |error|
-        errors << error
-      end
-      errors
-    end
-
-    # Appends override objects for drawings, charts, and sheets as they exist in your workbook to the default content types.
-    # @return [ContentType]
-    # @private
-    def content_types
-      c_types = base_content_types
-      workbook.drawings.each do |drawing|
-        c_types << Axlsx::Override.new(:PartName => "/xl/#{drawing.pn}", 
-                                       :ContentType => DRAWING_CT)
-      end
-      workbook.charts.each do |chart|
-        c_types << Axlsx::Override.new(:PartName => "/xl/#{chart.pn}", 
-                                       :ContentType => CHART_CT)                    
-      end
-      workbook.worksheets.each do |sheet|
-        c_types << Axlsx::Override.new(:PartName => "/xl/#{sheet.pn}", 
-                                         :ContentType => WORKSHEET_CT)
-      end
-      exts = workbook.images.map { |image| image.extname }
-      exts.uniq.each do |ext|
-        ct = if  ['jpeg', 'jpg'].include?(ext)
-               JPEG_CT
-             elsif ext == 'gif'
-               GIF_CT
-             elsif ext == 'png'
-               PNG_CT
-             end
-        c_types << Axlsx::Default.new(:ContentType => ct, :Extension => ext )
-      end
-      c_types
-    end
-
-    # Creates the minimum content types for generating a valid xlsx document.
-    # @return [ContentType]
-    # @private
-    def base_content_types
-      c_types = ContentType.new()
-      c_types <<  Default.new(:ContentType => RELS_CT, :Extension => RELS_EX)
-      c_types <<  Default.new(:Extension => XML_EX, :ContentType => XML_CT)
-      c_types << Override.new(:PartName => "/#{APP_PN}", :ContentType => APP_CT)
-      c_types << Override.new(:PartName => "/#{CORE_PN}", :ContentType => CORE_CT)
-      c_types << Override.new(:PartName => "/xl/#{STYLES_PN}", :ContentType => STYLES_CT)
-      c_types << Axlsx::Override.new(:PartName => "/#{WORKBOOK_PN}", :ContentType => WORKBOOK_CT)      
-      c_types.lock
-      c_types
-    end
-
-    # Creates the relationships required for a valid xlsx document
-    # @return [Relationships]
-    # @private
-    def relationships
-      rels = Axlsx::Relationships.new
-      rels << Relationship.new(WORKBOOK_R, WORKBOOK_PN)
-      rels << Relationship.new(CORE_R, CORE_PN)
-      rels << Relationship.new(APP_R, APP_PN)
-      rels.lock
-      rels
-    end
-  end
-end
-