ooxml_parser 0.14.1-mingw32

data/lib/ooxml_parser/common_parser/common_data/alternate_content/chart/chart/series/x_y_values.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class for parsing `c:xVal`, `c:yVal` object
+  class XYValues < OOXMLDocumentObject
+    # @return [NumberReference] number reference
+    attr_reader :number_reference
+
+    # Parse XYValues
+    # @param [Nokogiri::XML:Node] node with XYValues
+    # @return [XYValues] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'numRef'
+          @number_reference = NumberStringReference.new(parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/alternate_content/chart/chart/series.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative 'series/series_text'
+require_relative 'series/x_y_values'
+module OoxmlParser
+  # Class for parsing `c:ser` object
+  class Series < OOXMLDocumentObject
+    # @return [Index] index of chart
+    attr_reader :index
+    # @return [ValuedChild] order of chart
+    attr_reader :order
+    # @return [SeriesText] text of series
+    attr_accessor :text
+    # @return [SeriesText] categories of chart
+    attr_accessor :categories
+    # @return [DisplayLabelsProperties]
+    attr_accessor :display_labels
+    # @return [XYValues] values of series
+    attr_reader :values
+    # @return [XYValues] values of x
+    attr_reader :x_values
+    # @return [XYValues] values of y
+    attr_reader :y_values
+
+    # Parse Series
+    # @param [Nokogiri::XML:Node] node with Series
+    # @return [Series] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'idx'
+          @index = ValuedChild.new(:integer, parent: self).parse(node_child)
+        when 'order'
+          @order = ValuedChild.new(:integer, parent: self).parse(node_child)
+        when 'tx'
+          @text = SeriesText.new(parent: self).parse(node_child)
+        when 'cat'
+          @categories = SeriesText.new(parent: self).parse(node_child)
+        when 'dLbls'
+          @display_labels = DisplayLabelsProperties.new(parent: self).parse(node_child)
+        when 'val'
+          @values = XYValues.new(parent: self).parse(node_child)
+        when 'xVal'
+          @x_values = XYValues.new(parent: self).parse(node_child)
+        when 'yVal'
+          @y_values = XYValues.new(parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/alternate_content/chart/chart/view_3d.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Parsing Chart 3D view tag 'view3D'
+  class View3D < OOXMLDocumentObject
+    # @return [ValuedChild] This element specifies the amount
+    # a 3-D chart shall be rotated in the X direction
+    attr_accessor :rotation_x
+    # @return [ValuedChild] This element specifies the amount
+    # a 3-D chart shall be rotated in the Y direction
+    attr_accessor :rotation_y
+    # @return [True, False] This element specifies that the
+    # chart axes are at right angles, rather than drawn
+    # in perspective. Applies only to 3-D charts.
+    attr_accessor :right_angle_axis
+
+    # Parse View3D object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [View3D] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'rotX'
+          @rotation_x = ValuedChild.new(:integer, parent: self).parse(node_child)
+        when 'rotY'
+          @rotation_y = ValuedChild.new(:integer, parent: self).parse(node_child)
+        when 'rAngAx'
+          @right_angle_axis = option_enabled?(node_child)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/alternate_content/chart/chart.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require_relative 'chart_axis'
+require_relative 'chart_cells_range'
+require_relative 'chart_legend'
+require_relative 'chart_point'
+require_relative 'display_labels_properties'
+require_relative 'chart/pivot_formats'
+require_relative 'chart/plot_area'
+require_relative 'chart/series'
+require_relative 'chart/view_3d'
+
+module OoxmlParser
+  # Class for working with Chart data
+  class Chart < OOXMLDocumentObject
+    attr_accessor :type, :data, :grouping, :title, :legend, :display_labels, :axises, :alternate_content, :shape_properties
+    # @return [Array, ValuedChild] array axis id
+    attr_reader :axis_ids
+    # @return [Array, Series] series of chart
+    attr_accessor :series
+    # @return [PivotFormats] list of pivot formats
+    attr_accessor :pivot_formats
+    # @return [PlotArea] plot area data
+    attr_accessor :plot_area
+    # @return [True, False] This element specifies that
+    # each data marker in the series has a different color.
+    # ECMA-376 (5th Edition). 21.2.2.227
+    attr_reader :vary_colors
+    # @return [View3D] properties of 3D view
+    attr_accessor :view_3d
+
+    def initialize(parent: nil)
+      @axis_ids = []
+      @type = ''
+      @data = []
+      @grouping = nil
+      @title = nil
+      @legend = nil
+      @axises = []
+      @series = []
+      super
+    end
+
+    # Parse properties of Chart
+    # @param chart_prop_node [Nokogiri::XML:Element] node to parse
+    # @return [void]
+    def parse_properties(chart_prop_node)
+      chart_prop_node.xpath('*').each do |chart_props_node_child|
+        case chart_props_node_child.name
+        when 'axId'
+          @axis_ids << ValuedChild.new(:integer, parent: self).parse(chart_props_node_child)
+        when 'grouping'
+          @grouping = chart_props_node_child.attribute('val').value.to_sym
+        when 'ser'
+          @series << Series.new(parent: self).parse(chart_props_node_child)
+          val = case @type
+                when :point, :bubble
+                  chart_props_node_child.xpath('c:yVal')[0]
+                else
+                  chart_props_node_child.xpath('c:val')[0]
+                end
+          next unless val
+          next if val.xpath('c:numRef').empty?
+
+          @data << ChartCellsRange.new(parent: self).parse(val.xpath('c:numRef').first).dup
+        when 'dLbls'
+          @display_labels = DisplayLabelsProperties.new(parent: self).parse(chart_props_node_child)
+        when 'varyColors'
+          @vary_colors = option_enabled?(chart_props_node_child)
+        end
+      end
+    end
+
+    extend Gem::Deprecate
+    deprecate :data, 'series points interface', 2020, 1
+
+    # Parse Chart data
+    # @return [Chart] result of parsing
+    def parse
+      chart_xml = parse_xml(OOXMLDocumentObject.current_xml)
+      chart_xml.xpath('*').each do |chart_node|
+        case chart_node.name
+        when 'chartSpace'
+          chart_node.xpath('*').each do |chart_space_node_child|
+            case chart_space_node_child.name
+            when 'AlternateContent'
+              @alternate_content = AlternateContent.new(parent: self).parse(chart_space_node_child)
+            when 'spPr'
+              @shape_properties = DocxShapeProperties.new(parent: self).parse(chart_space_node_child)
+            when 'chart'
+              chart_space_node_child.xpath('*').each do |chart_node_child|
+                case chart_node_child.name
+                when 'plotArea'
+                  chart_node_child.xpath('*').each do |plot_area_node_child|
+                    next unless type.empty?
+
+                    case plot_area_node_child.name
+                    when 'barChart'
+                      @type = :bar
+                      bar_dir_node = plot_area_node_child.xpath('c:barDir')
+                      @type = :column if bar_dir_node.first.attribute('val').value == 'col'
+                      parse_properties(plot_area_node_child)
+                    when 'lineChart'
+                      @type = :line
+                      parse_properties(plot_area_node_child)
+                    when 'areaChart'
+                      @type = :area
+                      parse_properties(plot_area_node_child)
+                    when 'bubbleChart'
+                      @type = :bubble
+                      parse_properties(plot_area_node_child)
+                    when 'doughnutChart'
+                      @type = :doughnut
+                      parse_properties(plot_area_node_child)
+                    when 'pieChart'
+                      @type = :pie
+                      parse_properties(plot_area_node_child)
+                    when 'scatterChart'
+                      @type = :point
+                      parse_properties(plot_area_node_child)
+                    when 'radarChart'
+                      @type = :radar
+                      parse_properties(plot_area_node_child)
+                    when 'stockChart'
+                      @type = :stock
+                      parse_properties(plot_area_node_child)
+                    when 'surface3DChart'
+                      @type = :surface_3d
+                      parse_properties(plot_area_node_child)
+                    when 'line3DChart'
+                      @type = :line_3d
+                      parse_properties(plot_area_node_child)
+                    when 'bar3DChart'
+                      @type = :bar_3d
+                      parse_properties(plot_area_node_child)
+                    when 'pie3DChart'
+                      @type = :pie_3d
+                      parse_properties(plot_area_node_child)
+                    end
+                  end
+                  parse_axis(chart_node_child)
+                  @plot_area = PlotArea.new(parent: self).parse(chart_node_child)
+                when 'title'
+                  @title = ChartAxisTitle.new(parent: self).parse(chart_node_child)
+                when 'legend'
+                  @legend = ChartLegend.new(parent: self).parse(chart_node_child)
+                when 'view3D'
+                  @view_3d = View3D.new(parent: self).parse(chart_node_child)
+                when 'pivotFmts'
+                  @pivot_formats = PivotFormats.new(parent: self).parse(chart_node_child)
+                end
+              end
+            end
+          end
+        end
+      end
+      self
+    end
+
+    private
+
+    # Perform parsing of axis info
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [void]
+    def parse_axis(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'catAx', 'valAx'
+          @axises << ChartAxis.new(parent: self).parse(node_child)
+        end
+      end
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/alternate_content/chart/chart_axis/scaling.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Parsing Scaling tag 'scaling'
+  class Scaling < OOXMLDocumentObject
+    # @return [ValuedChild] orientation value
+    attr_reader :orientation
+
+    # Parse Scaling object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [Scaling] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'orientation'
+          @orientation = ValuedChild.new(:symbol, parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/alternate_content/chart/chart_axis.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative 'chart_axis/scaling'
+require_relative 'chart_axis_title'
+module OoxmlParser
+  # Parsing Chart axis tags 'catAx', 'valAx'
+  class ChartAxis < OOXMLDocumentObject
+    attr_accessor :title, :display, :position, :major_grid_lines, :minor_grid_lines
+    # @return [Scaling] scaling attribute
+    attr_reader :scaling
+    # @return [ValuedChild] the position of the tick labels
+    attr_reader :tick_label_position
+
+    def initialize(params = {})
+      @title = params.fetch(:title, ChartAxisTitle.new)
+      @display = params.fetch(:display, true)
+      @minor_grid_lines = params.fetch(:minor_grid_lines, false)
+      @major_grid_lines = params.fetch(:major_grid_lines, false)
+      super(parent: params[:parent])
+    end
+
+    # Parse ChartAxis object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [ChartAxis] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'delete'
+          @display = false if node_child.attribute('val').value == '1'
+        when 'title'
+          @title = ChartAxisTitle.new(parent: self).parse(node_child)
+        when 'majorGridlines'
+          @major_grid_lines = true
+        when 'minorGridlines'
+          @minor_grid_lines = true
+        when 'scaling'
+          @scaling = Scaling.new(parent: self).parse(node_child)
+        when 'tickLblPos'
+          @tick_label_position = ValuedChild.new(:symbol, parent: self).parse(node_child)
+        when 'axPos'
+          @position = value_to_symbol(node_child.attribute('val'))
+        end
+      end
+      @display = false unless @title.visible?
+      self
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/alternate_content/chart/chart_axis_title.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Chart Axis Title `title` node
+  class ChartAxisTitle < OOXMLDocumentObject
+    attr_accessor :layout, :overlay, :elements
+
+    def initialize(parent: nil)
+      @elements = []
+      super
+    end
+
+    # @return [Boolean] if chart title is visible
+    def visible?
+      @layout || @overlay || !@elements.empty?
+    end
+
+    # Parse ChartAxisTitle object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [ChartAxisTitle] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'tx'
+          node_child.xpath('c:rich/*').each do |rich_node_child|
+            case rich_node_child.name
+            when 'p'
+              root_object.default_font_style = FontStyle.new(true) # Default font style for chart title always bold
+              @elements << Paragraph.new(parent: self).parse(rich_node_child)
+              root_object.default_font_style = FontStyle.new
+            end
+          end
+        when 'layout'
+          @layout = option_enabled?(node_child)
+        when 'overlay'
+          @overlay = option_enabled?(node_child)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/alternate_content/chart/chart_cells_range.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Cell Range of Chart
+  class ChartCellsRange < OOXMLDocumentObject
+    attr_accessor :list, :points
+
+    def initialize(parent: nil)
+      @list = ''
+      @points = []
+      super
+    end
+
+    # Parse ChartCellsRange object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [ChartCellsRange] result of parsing
+    def parse(node)
+      @list = node.xpath('c:f')[0].text.split('!').first
+      coordinates = Coordinates.parser_coordinates_range(node.xpath('c:f')[0].text) # .split('!')[1].gsub('$', ''))
+      return self unless coordinates
+
+      node.xpath('c:numCache/c:pt').each_with_index do |point_node, index|
+        point = ChartPoint.new(coordinates[index])
+        point.value = point_node.xpath('c:v').first.text.to_f unless point_node.xpath('c:v').first.nil?
+        @points << point
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/alternate_content/chart/chart_legend.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Legend of Chart `legend` tag
+  class ChartLegend < OOXMLDocumentObject
+    attr_accessor :position, :overlay
+
+    def initialize(params = {})
+      @position = params.fetch(:position, :right)
+      @overlay = params.fetch(:overlay, false)
+      super(parent: params[:parent])
+    end
+
+    # Return combined data from @position and @overlay
+    # If there is no overlay - return :right f.e.
+    # If there is overlay - return :right_overlay
+    # @return [Symbol] overlay and position type
+    def position_with_overlay
+      return "#{@position}_overlay".to_sym if overlay
+
+      @position
+    end
+
+    # Parse ChartLegend object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [ChartLegend] result of parsing
+    def parse(node)
+      node.xpath('*').each do |child_node|
+        case child_node.name
+        when 'legendPos'
+          @position = value_to_symbol(child_node.attribute('val'))
+        when 'overlay'
+          @overlay = true if child_node.attribute('val').value.to_s == '1'
+        end
+      end
+      self
+    end
+  end
+end