ooxml_parser 0.14.1-mingw32

data/lib/ooxml_parser/common_parser/common_data/content_types.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative 'content_types/content_type_default'
+require_relative 'content_types/content_type_override'
+module OoxmlParser
+  # Class for data from `[Content_Types].xml` file
+  class ContentTypes < OOXMLDocumentObject
+    # @return [Array] list of content types
+    attr_accessor :content_types_list
+
+    def initialize(parent: nil)
+      @content_types_list = []
+      super
+    end
+
+    # @return [Array] accessor
+    def [](key)
+      @content_types_list[key]
+    end
+
+    # Parse ContentTypes object
+    # @return [ContentTypes] result of parsing
+    def parse
+      doc = Nokogiri::XML.parse(File.open("#{OOXMLDocumentObject.path_to_folder}/[Content_Types].xml"))
+      node = doc.xpath('*').first
+
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'Default'
+          @content_types_list << ContentTypeDefault.new(parent: self).parse(node_child)
+        when 'Override'
+          @content_types_list << ContentTypeOverride.new(parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+
+    # Get content definition by type
+    # @param [String] type of definition
+    # @return [Object] resulting objects
+    def by_type(type)
+      @content_types_list.select { |item| item.content_type == type }
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/coordinates.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class for working with coordinates
+  class Coordinates
+    attr_accessor :row, :column, :list
+
+    def initialize(row = nil, column = nil, list = nil)
+      @row = row.nil? ? row : row.to_i
+      @column = column
+      @list = list
+    end
+
+    class << self
+      # @param [String] string to parse
+      # @return [Coordinates]
+      def parse_coordinates_from_string(string)
+        coordinates = Coordinates.new
+        begin
+          coordinates.list = string.match(/'\w+'/)[0].delete("''")
+        rescue StandardError
+          'Raise Exception'
+        end
+        string = string.split('!').last
+        if coordinates?(string)
+          coordinates.row = string.scan(/[0-9]/).join.to_i
+          coordinates.column = string.scan(/[A-Z]/).join
+        end
+        coordinates
+      end
+
+      # Parse range of coordinates
+      # @param arguments_string [String] data to parse
+      # @return [Array] result
+      def parser_coordinates_range(arguments_string)
+        return parse_coordinates_array(arguments_string) if arguments_string.include?(',')
+        return warn "Formulas with # is unsupported: #{arguments_string}" if arguments_string.include?('#')
+        return warn 'Formulas consists from `!` only' if arguments_string == '!'
+
+        sheet_name = 'Sheet1'
+
+        if arguments_string.include?('!')
+          sheet_name = arguments_string.match(/.*!/).to_s
+          arguments_string = arguments_string.sub(sheet_name, '')
+        end
+
+        range = arguments_string.split(':')
+
+        difference = []
+        symbols_from = range.first.scan(/[a-zA-z]/).join
+        symbols_to = range.last.scan(/[a-zA-z]/).join
+        digits_from = range.first.scan(/[0-9]/).join
+        digits_to = range.last.scan(/[0-9]/).join
+
+        difference[0] = [symbols_from, symbols_to] unless symbols_from == symbols_to
+        difference[1] = [digits_from, digits_to] unless digits_from == digits_to
+        arguments_array = []
+        case difference.length
+        when 0
+          arguments_array << Coordinates.new(digits_from, symbols_from)
+        when 1
+          (difference.first.first..difference.first.last).each do |symbol|
+            arguments_array << Coordinates.new(digits_from, symbol, sheet_name)
+          end
+        when 2
+          case difference.first
+          when nil
+            (difference.last.first..difference.last.last).each do |digit|
+              arguments_array << Coordinates.new(digit, symbols_from, sheet_name)
+            end
+          else
+            (difference.first.first..difference.first.last).each do |symbol|
+              (difference.last.first..difference.last.last).each do |digit|
+                arguments_array << Coordinates.new(digit, symbol, sheet_name)
+              end
+            end
+          end
+        end
+        arguments_array
+      end
+
+      # Parse array of coordinates
+      # @param arguments_string [String] string
+      # @return [Array] result
+      def parse_coordinates_array(arguments_string)
+        result = []
+        coord_array = arguments_string.split(',')
+        coord_array.each do |current_coord|
+          result << parser_coordinates_range(current_coord)
+        end
+        result
+      end
+
+      # This method check is argument contains coordinate
+      # @param [String] string
+      def coordinates?(string)
+        !/^([A-Z]+)(\d+)$/.match(string).nil?
+      end
+
+      # @param [String or Fixnum] number to convert
+      # @return [String] column's name
+      # This method takes string like '12' or '45' etc.
+      # and converts into spreadsheet column's name
+      #    StringHelper.get_column_name('12')  #=> "L"
+      #    StringHelper.get_column_name('45')  #=> "AS"
+      #    StringHelper.get_column_name('287')  #=> "KA"
+      def get_column_name(number)
+        (number.to_i.positive? ? ('A'..'Z').to_a[(number.to_i - 1) % 26] + get_column_name((number.to_i - 1) / 26).reverse : '').reverse
+      end
+    end
+
+    # @return [Integer] number of column
+    # This method takes @column string
+    # and converts into integer
+    def column_number
+      @column.reverse.each_char.reduce(0) do |result, char|
+        result + (char.downcase.ord - 96) * (26**@column.reverse.index(char))
+      end
+    end
+
+    alias get_column_number column_number
+    extend Gem::Deprecate
+    deprecate :get_column_number, 'column_number', 2020, 1
+
+    # Compares rows of two cells
+    # @param [Coordinates] other_cell other cell coordinates
+    # @return [true, false] true, if row greater, than other row
+    def row_greater_that_other?(other_cell)
+      @row > other_cell.row
+    end
+
+    # Compares columns of two cells
+    # @param [Coordinates] other_cell other cell coordinates
+    # @return [true, false] true, if column greater, than other row
+    def column_greater_that_other?(other_cell)
+      column_number > other_cell.column_number
+    end
+
+    # @return [String] result of convert of object to string
+    def to_s
+      "#{@column}#{@row} #{@list ? "list: #{@list}" : ''}"
+    end
+
+    def nil?
+      @column.nil? && @list.nil? && @row.nil?
+    end
+
+    # Compare this object to other
+    # @param other [Object] any other object
+    # @return [True, False] result of comparision
+    def ==(other)
+      other.is_a?(Coordinates) ? (@row == other.row && @column == other.column) : false
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/font_style.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'underline'
+# @author Pavel.Lobashov
+module OoxmlParser
+  # Class for working with font styles (bold,italic,underlined,strike)
+  class FontStyle
+    # @return [false,true] is bold?
+    attr_accessor :bold
+    # @return [false,true] is bold?
+    attr_accessor :italic
+    # @return [Underline] underline type
+    attr_accessor :underlined
+    # @return [Strike] strike type
+    attr_accessor :strike
+
+    # Default constructor
+    # @param [true, false] bold is bold?
+    # @param [true, false] italic is italic?
+    # @param [true, false, String] underlined if not false or nil - default Underline, else none
+    # @param [Symbol] strike string with strike type
+    # @return [FontStyle] new font style
+    def initialize(bold = false, italic = false, underlined = Underline.new(:none), strike = :none)
+      @bold = bold
+      @italic = italic
+      @underlined = underlined == false || underlined.nil? ? Underline.new(:none) : underlined
+      @strike = strike
+    end
+
+    # Default == operator
+    # @return [true, false] true if two same, false if different
+    def ==(other)
+      (@bold == other.bold) && (@italic == other.italic) && (@underlined == other.underlined) && (@strike == other.strike)
+    end
+
+    # Default to_s operator
+    # @return [String] with text representation
+    def to_s
+      "Bold: #{@bold}, Italic: #{@italic}, Underlined: #{@underlined}, Strike: #{@strike}"
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/hyperlink.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Class for parsing `hlinkClick`, `hyperlink` tags
+  class Hyperlink < OOXMLDocumentObject
+    # @return [OOXMLDocumentObject] url of hyperlink
+    attr_accessor :url
+    # @return [String] tooltip value
+    attr_reader :tooltip
+    # @return [Coordinates] coordinates of link
+    attr_reader :coordinates
+    # @return [True, False] should click be highlighted
+    attr_reader :highlight_click
+    # @return [Symbol] type of action
+    attr_reader :action
+    # @return [String] value of action link
+    attr_reader :action_link
+    # @return [String] id of link
+    attr_reader :id
+    # @return [Array<ParagraphRun>] run of paragraph
+    attr_reader :runs
+
+    def initialize(link = nil,
+                   tooltip = nil,
+                   coordinates = nil,
+                   parent: nil)
+      @url = link
+      @tooltip = tooltip
+      @coordinates = coordinates
+      @runs = []
+      super(parent: parent)
+    end
+
+    alias link url
+    alias link_to url
+    alias link= url=
+    alias link_to= url=
+
+    # Parse Hyperlink object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [Hyperlink] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'location'
+          @url = Coordinates.parse_coordinates_from_string(value.value)
+        when 'id'
+          @id = value.value
+          @url = OOXMLDocumentObject.get_link_from_rels(@id) unless @id.empty?
+        when 'tooltip'
+          @tooltip = value.value
+        when 'ref'
+          @coordinates = Coordinates.parse_coordinates_from_string(value.value)
+        when 'action'
+          @action_link = value.value
+        when 'highlightClick'
+          @highlight_click = attribute_enabled?(value)
+        end
+      end
+
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'r'
+          @runs << ParagraphRun.new(parent: self).parse(node_child)
+        end
+      end
+
+      case @action_link
+      when 'ppaction://hlinkshowjump?jump=previousslide'
+        @action = :previous_slide
+      when 'ppaction://hlinkshowjump?jump=nextslide'
+        @action = :next_slide
+      when 'ppaction://hlinkshowjump?jump=firstslide'
+        @action = :first_slide
+      when 'ppaction://hlinkshowjump?jump=lastslide'
+        @action = :last_slide
+      when 'ppaction://hlinksldjump'
+        @action = :slide
+        @url = OOXMLDocumentObject.get_link_from_rels(@id).scan(/\d+/).join.to_i
+      else
+        if @id && !@id.empty?
+          @action = :external_link
+          @url = OOXMLDocumentObject.get_link_from_rels(@id)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/common_parser/common_data/ooxml_document_object/ooxml_document_object_helper.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module OoxmlParser
+  # Module for helper methods for OOXMLDocumentObject
+  module OoxmlDocumentObjectHelper
+    # Convert object to hash
+    # @return [Hash]
+    def to_hash
+      result_hash = {}
+      instance_variables.each do |current_attribute|
+        next if current_attribute == :@parent
+
+        attribute_value = instance_variable_get(current_attribute)
+        next unless attribute_value
+
+        if attribute_value.is_a?(Array)
+          attribute_value.each_with_index do |object_element, index|
+            result_hash["#{current_attribute}_#{index}".to_sym] = object_element.to_hash
+          end
+        else
+          result_hash[current_attribute.to_sym] = if attribute_value.respond_to?(:to_hash)
+                                                    attribute_value.to_hash
+                                                  else
+                                                    attribute_value.to_s
+                                                  end
+        end
+      end
+      result_hash
+    end
+
+    private
+
+    VALUE_TO_SYMBOL_HASH = { l: :left,
+                             ctr: :center,
+                             r: :right,
+                             just: :justify,
+                             b: :bottom,
+                             t: :top,
+                             tr: :top_right,
+                             tl: :top_left,
+                             br: :bottom_right,
+                             bl: :bottom_left,
+                             contentLocked: :content_locked,
+                             dist: :distributed,
+                             tb: :horizontal,
+                             rl: :rotate_on_90,
+                             lr: :rotate_on_270,
+                             inset: :in,
+                             lu: :left_up,
+                             ru: :right_up,
+                             ld: :left_down,
+                             rd: :right_down,
+                             d: :down,
+                             u: :up,
+                             lg: :large,
+                             med: :medium,
+                             sm: :small,
+                             beneathText: :beneath_text,
+                             greaterThan: :greater_than,
+                             pageBottom: :page_bottom,
+                             sectEnd: :section_end,
+                             docEnd: :document_end,
+                             eachSect: :each_section,
+                             eachPage: :each_page,
+                             sngStrike: :single,
+                             dblStrike: :double,
+                             noStrike: :none,
+                             lgDash: :large_dash,
+                             dashDot: :dash_dot,
+                             dashDotDot: :dash_dot_dot,
+                             mediumDashed: :medium_dashed,
+                             mediumDashDot: :medium_dash_dot,
+                             mediumDashDotDot: :medium_dash_dot_dot,
+                             lgDashDot: :large_dash_dot,
+                             lgDashDotDot: :large_dash_dot_dot,
+                             sdtLocked: :sdt_locked,
+                             sdtContentLocked: :sdt_content_locked,
+                             sysDash: :system_dash,
+                             sysDot: :system_dot,
+                             sysDashDot: :system_dash_dot,
+                             sysDashDotDot: :system_dash_dot_dot,
+                             rightMargin: :right_margin,
+                             leftMargin: :left_margin,
+                             bottomMargin: :bottom_margin,
+                             topMargin: :top_margin,
+                             undOvr: :under_over,
+                             subSup: :subscript_superscript,
+                             lrTb: :left_to_right_top_to_bottom,
+                             tbRl: :top_to_bottom_right_to_left,
+                             btLr: :bottom_to_top_left_to_right,
+                             singlelevel: :single_level,
+                             maxMin: :max_min,
+                             middleDot: :middle_dot,
+                             minMax: :min_max,
+                             multilevel: :multi_level,
+                             nextTo: :next_to,
+                             hybridMultilevel: :hybrid_multi_level,
+                             rnd: :round,
+                             sq: :square }.freeze
+
+    # Convert value to human readable symbol
+    # @param [String] value to convert
+    # @return [Symbol]
+    def value_to_symbol(value)
+      symbol = VALUE_TO_SYMBOL_HASH[value.value.to_sym]
+      return value.value.to_sym if symbol.nil?
+
+      symbol
+    end
+
+    def root_object
+      tree_object = self
+      tree_object = tree_object.parent until tree_object.parent.nil?
+      tree_object
+    end
+  end
+end