ooxml_parser 0.14.1-mingw32

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Single Chart Point
+  class ChartPoint
+    attr_accessor :coordinates, :value
+
+    def initialize(coordinates = nil, value = nil)
+      @coordinates = coordinates
+      @value = value
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Chart Label Properties, parse tag `dLbls`
+  class DisplayLabelsProperties < OOXMLDocumentObject
+    attr_accessor :position, :show_legend_key, :show_values, :show_x_axis_name, :show_y_axis_name
+    # @return [True, False] is category name shown
+    attr_accessor :show_category_name
+    # @return [True, False] is series name shown
+    attr_accessor :show_series_name
+    # @return [True, False] is label is deleted
+    attr_reader :delete
+
+    def initialize(params = {})
+      @show_legend_key = params.fetch(:show_legend_key, false)
+      @show_values = params.fetch(:show_values, false)
+      super(parent: params[:parent])
+    end
+
+    # Parse DisplayLabelsProperties object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [DisplayLabelsProperties] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'dLblPos'
+          @position = value_to_symbol(node_child.attribute('val'))
+        when 'showLegendKey'
+          @show_legend_key = true if node_child.attribute('val').value == '1'
+        when 'showVal'
+          @show_values = true if node_child.attribute('val').value == '1'
+        when 'showCatName'
+          @show_category_name = option_enabled?(node_child)
+        when 'showSerName'
+          @show_series_name = option_enabled?(node_child)
+        when 'delete'
+          @delete = option_enabled?(node_child)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/alternate_content/drawing/docx_drawing/doc_properties.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class for parsing `wp:docP` tags
+  class DocProperties < OOXMLDocumentObject
+    # @return [String] title property
+    attr_accessor :title
+    # @return [String] description property
+    attr_accessor :description
+
+    # Parse DocProperties object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [DocProperties] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'title'
+          @title = value.value
+        when 'descr'
+          @description = value.value
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/alternate_content/drawing/docx_drawing.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'docx_drawing/doc_properties'
+require_relative 'drawing_properties/docx_drawing_properties'
+require_relative 'drawing_properties/size_relative_horizontal'
+require_relative 'drawing_properties/size_relative_vertical'
+require_relative 'graphic/docx_graphic'
+module OoxmlParser
+  # Class for parsing `graphic` tags
+  class DocxDrawing < OOXMLDocumentObject
+    attr_accessor :type, :properties, :graphic
+    # @return [DocProperties] doc properties
+    attr_accessor :doc_properties
+
+    alias picture graphic
+
+    def initialize(properties = DocxDrawingProperties.new, parent: nil)
+      @properties = properties
+      super(parent: parent)
+    end
+
+    # Parse DocxDrawing
+    # @param [Nokogiri::XML:Node] node with NumberingProperties
+    # @return [DocxDrawing] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'anchor'
+          @type = :flow
+        when 'inline'
+          @type = :inline
+        end
+        node_child.xpath('*').each do |content_node_child|
+          case content_node_child.name
+          when 'graphic'
+            @graphic = DocxGraphic.new(parent: self).parse(content_node_child)
+          when 'docPr'
+            @doc_properties = DocProperties.new(parent: self).parse(content_node_child)
+          end
+        end
+        @properties.parse(node_child)
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/alternate_content/drawing/drawing_properties/docx_drawing_distance_from_text.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Docx Drawing Distance From Text
+  class DocxDrawingDistanceFromText < OOXMLDocumentObject
+    attr_accessor :top, :bottom, :left, :right
+
+    # Parse DocxDrawingDistanceFromText object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [DocxDrawingDistanceFromText] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'distT'
+          @top = OoxmlSize.new(value.value.to_f, :emu)
+        when 'distB'
+          @bottom = OoxmlSize.new(value.value.to_f, :emu)
+        when 'distL'
+          @left = OoxmlSize.new(value.value.to_f, :emu)
+        when 'distR'
+          @right = OoxmlSize.new(value.value.to_f, :emu)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/alternate_content/drawing/drawing_properties/docx_drawing_position.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Docx Drawing Position
+  class DocxDrawingPosition < OOXMLDocumentObject
+    attr_accessor :relative_from, :offset, :align
+
+    # Parse DocxDrawingPosition object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [DocxDrawingPosition] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'relativeFrom'
+          @relative_from = value_to_symbol(value)
+        end
+      end
+
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'posOffset', 'pctPosHOffset', 'pctPosVOffset'
+          @offset = OoxmlSize.new(node_child.text.to_f, :emu)
+        when 'align'
+          @align = node_child.text.to_sym
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/alternate_content/drawing/drawing_properties/docx_drawing_properties.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative 'ooxml_coordinates'
+require_relative 'ooxml_size'
+require_relative 'docx_drawing_distance_from_text'
+require_relative 'docx_drawing_position'
+require_relative 'docx_wrap_drawing'
+module OoxmlParser
+  # Docx Drawing Properties
+  class DocxDrawingProperties < OOXMLDocumentObject
+    # @return [DocxDrawingDistanceFromText] distance from text
+    attr_reader :distance_from_text
+    # @return [DocxWrapDrawing] wrap of drawing
+    attr_reader :wrap
+    # @return [Integer] relative height of object
+    attr_reader :relative_height
+    # @return [OOXMLCoordinates] simple position of object
+    attr_reader :simple_position
+    # @return [OOXMLCoordinates] size of object
+    attr_reader :object_size
+    # @return [DocxDrawingPosition] vertical position
+    attr_reader :vertical_position
+    # @return [DocxDrawingPosition] horizontal position
+    attr_reader :horizontal_position
+    # @return [SizeRelativeHorizontal] size of drawing relative to horizontal
+    attr_reader :size_relative_horizontal
+    # @return [SizeRelativeVertical] size of drawing relative to vertical
+    attr_reader :size_relative_vertical
+
+    # Parse DocxDrawingProperties
+    # @param [Nokogiri::XML:Node] node with DocxDrawingProperties
+    # @return [DocxDrawingProperties] result of parsing
+    def parse(node)
+      @distance_from_text = DocxDrawingDistanceFromText.new(parent: self).parse(node)
+      @wrap = DocxWrapDrawing.new(parent: self).parse(node)
+
+      node.attributes.each do |key, value|
+        case key
+        when 'relativeHeight'
+          @relative_height = value.value.to_i
+        end
+      end
+
+      node.xpath('*').each do |content_node_child|
+        case content_node_child.name
+        when 'simplePos'
+          @simple_position = OOXMLCoordinates.parse(content_node_child)
+        when 'extent'
+          @object_size = OOXMLCoordinates.parse(content_node_child, x_attr: 'cx', y_attr: 'cy', unit: :emu)
+        when 'positionV'
+          @vertical_position = DocxDrawingPosition.new(parent: self).parse(content_node_child)
+        when 'positionH'
+          @horizontal_position = DocxDrawingPosition.new(parent: self).parse(content_node_child)
+        when 'sizeRelH'
+          @size_relative_horizontal = SizeRelativeHorizontal.new(parent: self).parse(content_node_child)
+        when 'sizeRelV'
+          @size_relative_vertical = SizeRelativeVertical.new(parent: self).parse(content_node_child)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/alternate_content/drawing/drawing_properties/docx_wrap_drawing.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Docx Wrap Drawing
+  class DocxWrapDrawing < OOXMLDocumentObject
+    attr_accessor :wrap_text, :distance_from_text
+
+    def initialize(parent: nil)
+      @wrap_text = :none
+      super
+    end
+
+    # Parse DocxWrapDrawing object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [DocxWrapDrawing] result of parsing
+    def parse(node)
+      unless node.attribute('behindDoc').nil?
+        @wrap_text = :behind if node.attribute('behindDoc').value == '1'
+        @wrap_text = :infront if node.attribute('behindDoc').value == '0'
+      end
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'wrapSquare'
+          @wrap_text = :square
+          @distance_from_text = DocxDrawingDistanceFromText.new(parent: self).parse(node_child)
+          break
+        when 'wrapTight'
+          @wrap_text = :tight
+          @distance_from_text = DocxDrawingDistanceFromText.new(parent: self).parse(node_child)
+          break
+        when 'wrapThrough'
+          @wrap_text = :through
+          @distance_from_text = DocxDrawingDistanceFromText.new(parent: self).parse(node_child)
+          break
+        when 'wrapTopAndBottom'
+          @wrap_text = :topbottom
+          @distance_from_text = DocxDrawingDistanceFromText.new(parent: self).parse(node_child)
+          break
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/alternate_content/drawing/drawing_properties/ooxml_coordinates.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Docx Coordinates
+  class OOXMLCoordinates
+    attr_accessor :x, :y
+
+    def initialize(x_value, y_value)
+      @x = if x_value.is_a?(OoxmlSize)
+             x_value
+           else
+             OoxmlSize.new(x_value)
+           end
+      @y = if y_value.is_a?(OoxmlSize)
+             y_value
+           else
+             OoxmlSize.new(y_value)
+           end
+    end
+
+    # @return [String] result of convert of object to string
+    def to_s
+      "(#{@x}; #{@y})"
+    end
+
+    # Compare two OOXMLCoordinates objects
+    # @param other [OOXMLCoordinates] other object
+    # @return [True, False] result of comparasion
+    def ==(other)
+      x == other.x && y == other.y
+    end
+
+    # Parse OOXMLCoordinates object
+    # @param position_node [Nokogiri::XML:Element] node to parse
+    # @param x_attr [String] name of x attribute
+    # @param y_attr [String] name of y attribute
+    # @param unit [Symbol] unit in which data is stored
+    # @return [OOXMLCoordinates] result of parsing
+    def self.parse(position_node, x_attr: 'x', y_attr: 'y', unit: :dxa)
+      return if position_node.attribute(x_attr).nil? || position_node.attribute(y_attr).nil?
+
+      OOXMLCoordinates.new(OoxmlSize.new(position_node.attribute(x_attr).value.to_f, unit),
+                           OoxmlSize.new(position_node.attribute(y_attr).value.to_f, unit))
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/alternate_content/drawing/drawing_properties/ooxml_size.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Size of some object
+  class OoxmlSize
+    # @return [Float] value of size
+    attr_accessor :value
+    # @return [Symbol] units of measurement
+    attr_accessor :unit
+
+    def initialize(value = 0, unit = :dxa)
+      @unit = unit
+      @value = value
+    end
+
+    # Parse OoxmlSize
+    # @param [Nokogiri::XML:Node] node with OoxmlSize
+    # @return [OoxmlSize] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'type'
+          @unit = value.value.to_sym
+        when 'w', 'val'
+          @value = value.value.to_f
+        end
+      end
+      self
+    end
+
+    # Compare this object to other
+    # @param other [Object] any other object
+    # @return [True, False] result of comparision
+    def ==(other)
+      (to_base_unit.value - other.to_base_unit.value).abs < 10**(OoxmlParser.configuration.accuracy + 2)
+    end
+
+    def zero?
+      @value.zero?
+    end
+
+    # @param unit [Symbol] unit in which output should be
+    # @return [String] string representation of size
+    def to_s(unit = :centimeter)
+      converted = to_unit(unit)
+      "#{converted.value.to_f} #{converted.unit}"
+    end
+
+    # Convert all values to one same base unit
+    # @return [OoxmlSize] base unit
+    def to_base_unit
+      case @unit
+      when :centimeter
+        OoxmlSize.new(@value * 360_000)
+      when :point
+        OoxmlSize.new(@value * 12_700)
+      when :half_point
+        OoxmlSize.new(@value * (12_700 / 2))
+      when :one_eighth_point
+        OoxmlSize.new(@value * (12_700 / 8))
+      when :one_100th_point
+        OoxmlSize.new(@value * (12_700 / 100))
+      when :one_240th_cm
+        OoxmlSize.new(@value * 1500)
+      when :dxa, :twip
+        OoxmlSize.new(@value * 635, :emu)
+      when :inch
+        OoxmlSize.new(@value * 914_400, :emu)
+      when :spacing_point
+        OoxmlSize.new(@value * (12_700 / 100), :emu)
+      when :percent
+        OoxmlSize.new(@value * 100_000, :one_100000th_percent)
+      when :pct
+        OoxmlSize.new(@value * 100_000 / 50, :one_100000th_percent)
+      when :one_1000th_percent
+        OoxmlSize.new(@value * 100, :one_100000th_percent)
+      when :one_60000th_degree
+        OoxmlSize.new(@value, :one_60000th_degree)
+      when :degree
+        OoxmlSize.new(@value * 60_000, :one_60000th_degree)
+      else
+        self
+      end
+    end
+
+    # @param output_unit [Symbol] output unit of convertion
+    # @return [OoxmlSize] converted unit
+    def to_unit(output_unit)
+      base_unit = to_base_unit
+      case output_unit
+      when :centimeter
+        OoxmlSize.new((base_unit.value / 360_000).round(OoxmlParser.configuration.accuracy), output_unit)
+      when :point
+        OoxmlSize.new((base_unit.value / 12_700).round(OoxmlParser.configuration.accuracy), output_unit)
+      when :half_point
+        OoxmlSize.new((base_unit.value / (12_700 * 2)).round(OoxmlParser.configuration.accuracy), output_unit)
+      when :one_eighth_point
+        OoxmlSize.new((base_unit.value / (12_700 * 8)).round(OoxmlParser.configuration.accuracy), output_unit)
+      when :one_100th_point
+        OoxmlSize.new((base_unit.value / (12_700 / 100)).round(OoxmlParser.configuration.accuracy), output_unit)
+      when :one_240th_cm
+        OoxmlSize.new((base_unit.value / 1500).round(OoxmlParser.configuration.accuracy), output_unit)
+      when :dxa, :twip
+        OoxmlSize.new((base_unit.value / 635).round(OoxmlParser.configuration.accuracy), output_unit)
+      when :inch
+        OoxmlSize.new((base_unit.value / 914_400).round(OoxmlParser.configuration.accuracy), output_unit)
+      when :percent
+        OoxmlSize.new((base_unit.value / 50).round(OoxmlParser.configuration.accuracy), output_unit)
+      when :spacing_point
+        OoxmlSize.new((base_unit.value / (12_700 * 100)).round(OoxmlParser.configuration.accuracy), output_unit)
+      else
+        base_unit
+      end
+    end
+  end
+end