ooxml_parser 0.1.2 → 0.2.0

data/lib/ooxml_parser/pptx_parser/pptx_data/presentation/slide/transition/transition_properties/transition_properties.rb

@@ -1,29 +1,24 @@
 module OoxmlParser
-  class TransitionProperties
+  class TransitionProperties < OOXMLDocumentObject
     attr_accessor :type, :through_black, :direction, :orientation, :spokes
 
-    def initialize(type = nil)
-      @type = type
-    end
-
     # Parse TransitionProperties object
     # @param node [Nokogiri::XML:Element] node to parse
     # @return [TransitionProperties] result of parsing
-    def self.parse(node)
-      transition_properties = TransitionProperties.new
-      transition_properties.type = node.name.to_sym
+    def parse(node)
+      @type = node.name.to_sym
       case node.name
       when 'blinds', 'checker', 'comb', 'cover', 'pull', 'push', 'randomBar', 'strips', 'wipe', 'zoom', 'warp'
-        transition_properties.direction = Alignment.parse(node.attribute('dir')) if node.attribute('dir')
+        @direction = value_to_symbol(node.attribute('dir')) if node.attribute('dir')
       when 'cut', 'fade'
-        transition_properties.through_black = OOXMLDocumentObject.option_enabled?(node, 'thruBlk')
+        @through_black = option_enabled?(node, 'thruBlk')
       when 'split'
-        transition_properties.direction = Alignment.parse(node.attribute('dir')) if node.attribute('dir')
-        transition_properties.orientation = node.attribute('orient').value.to_sym if node.attribute('orient')
+        @direction = value_to_symbol(node.attribute('dir')) if node.attribute('dir')
+        @orientation = node.attribute('orient').value.to_sym if node.attribute('orient')
       when 'wheel', 'wheelReverse'
-        transition_properties.spokes = OOXMLDocumentObject.option_enabled?(node, 'spokes')
+        @spokes = option_enabled?(node, 'spokes')
       end
-      transition_properties
+      self
     end
   end
 end

data/lib/ooxml_parser/pptx_parser/pptx_data/presentation/slide.rb

@@ -3,102 +3,65 @@ require_relative 'slide/background'
 require_relative 'slide/graphic_frame/graphic_frame'
 require_relative 'slide/slide/shapes_grouping'
 require_relative 'slide/slide/timing'
+require_relative 'slide/slide_helper'
 module OoxmlParser
+  # Class for parsing `slide.xml`
   class Slide < OOXMLDocumentObject
+    include SlideHelper
     attr_accessor :elements, :background, :transition, :timing, :alternate_content
 
-    def initialize(elements = [], background = nil)
-      @elements = elements
-      @background = background
+    def initialize(parent: nil, xml_path: nil)
+      @elements = []
+      @background = nil
+      @parent = parent
+      @xml_path = xml_path
     end
 
-    def nonempty_elements
-      @elements.select { |cur_shape| !cur_shape.text_body.paragraphs.first.characters.empty? }
-    end
-
-    def graphic_frames
-      @elements.select { |cur_element| cur_element.is_a?(GraphicFrame) }
-    end
-
-    # Get transform property of object, by object type
-    # @param object [Symbol] type of object: :image, :chart, :table, :shape
-    # @return [OOXMLDocumentObject] needed object
-    def transform_of_object(object)
-      case object
-      when :image
-        return elements.find { |e| e.is_a? Picture }.properties.transform
-      when :chart
-        return elements.find { |e| e.is_a? GraphicFrame }.transform
-      when :table
-        return elements.find { |e| e.is_a? GraphicFrame }.transform
-      when :shape
-        return elements.find { |e| !e.shape_properties.preset.nil? }.shape_properties.transform
-      else
-        raise "Dont know this type object - #{object}"
+    def with_data?
+      return true unless @background.nil?
+      @elements.each do |current_element|
+        return true if current_element.with_data?
       end
+      false
     end
 
-    def content_horizontal_align(object, slide_size)
-      transform = transform_of_object(object)
-      return :left if transform.offset.x == 0
-      return :center if ((slide_size.width / 2) - (transform.extents.x / 2)).round(1) == transform.offset.x.round(1)
-      return :right if (slide_size.width - transform.extents.x).round(1) == transform.offset.x.round(1)
-      :unknown
-    end
-
-    def content_vertical_align(object, slide_size)
-      transform = transform_of_object(object)
-      return :top if transform.offset.y == 0
-      return :middle if ((slide_size.height / 2) - (transform.extents.y / 2)).round(1) == transform.offset.y.round(1)
-      return :bottom if (slide_size.height - transform.extents.y).round(1) == transform.offset.y.round(1)
-      :unknown
-    end
-
-    def content_distribute(object, slide_size)
-      return [:horizontally, :vertically] if content_horizontal_align(object, slide_size) == :center && content_vertical_align(object, slide_size) == :middle
-      return [:horizontally] if content_horizontal_align(object, slide_size) == :center
-      return [:vertically] if content_vertical_align(object, slide_size) == :middle
-    end
-
-    def self.parse(path_to_slide_xml)
-      slide = Slide.new
-      OOXMLDocumentObject.add_to_xmls_stack(path_to_slide_xml)
-      doc = Nokogiri::XML(File.open(OOXMLDocumentObject.current_xml))
-      doc.xpath('//p:sld/*').each do |slide_node_child|
-        case slide_node_child.name
+    # Parse Slide object
+    # @return [Slide] result of parsing
+    def parse
+      OOXMLDocumentObject.add_to_xmls_stack(@xml_path)
+      node = Nokogiri::XML(File.open(OOXMLDocumentObject.current_xml))
+      node.xpath('//p:sld/*').each do |node_child|
+        case node_child.name
         when 'cSld'
-          slide_node_child.xpath('*').each do |common_slide_node_child|
+          node_child.xpath('*').each do |common_slide_node_child|
             case common_slide_node_child.name
             when 'spTree'
               common_slide_node_child.xpath('*').each do |slide_element_node|
                 case slide_element_node.name
-                when 'nvGrpSpPr'
-                when 'grpSpPr'
                 when 'sp'
-                  slide.elements << PresentationShape.parse(slide_element_node).dup
+                  @elements << DocxShape.new(parent: self).parse(slide_element_node).dup
                 when 'pic'
-                  slide.elements << DocxPicture.parse(slide_element_node)
+                  @elements << DocxPicture.new(parent: self).parse(slide_element_node)
                 when 'graphicFrame'
-                  slide.elements << GraphicFrame.parse(slide_element_node)
+                  @elements << GraphicFrame.new(parent: self).parse(slide_element_node)
                 when 'grpSp'
-                  slide.elements << ShapesGrouping.parse(slide_element_node)
+                  @elements << ShapesGrouping.new(parent: self).parse(slide_element_node)
                 end
               end
             when 'bg'
-              slide.background = Background.parse(common_slide_node_child)
+              @background = Background.new(parent: self).parse(common_slide_node_child)
             end
           end
-        when 'clrMapOvr'
         when 'timing'
-          slide.timing = Timing.parse(slide_node_child)
+          @timing = Timing.new(parent: self).parse(node_child)
         when 'transition'
-          slide.transition = Transition.parse(slide_node_child)
+          @transition = Transition.new(parent: self).parse(node_child)
         when 'AlternateContent'
-          slide.alternate_content = PresentationAlternateContent.parse(slide_node_child)
+          @alternate_content = PresentationAlternateContent.new(parent: self).parse(node_child)
         end
       end
       OOXMLDocumentObject.xmls_stack.pop
-      slide
+      self
     end
   end
 end

data/lib/ooxml_parser/pptx_parser/pptx_data/presentation/slide_size.rb

@@ -1,20 +1,23 @@
 module OoxmlParser
-  class SlideSize
+  # Class for parsing `sldSz` tag
+  class SlideSize < OOXMLDocumentObject
     attr_accessor :width, :height, :type
 
-    def self.parse(slide_size_node)
-      slide_size = SlideSize.new
-      slide_size_node.attributes.each do |key, value|
+    # Parse SlideSize object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [Bookmark] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
         case key
         when 'cx'
-          slide_size.width = (value.value.to_f / OoxmlParser.configuration.units_delimiter).round(2)
+          @width = OoxmlSize.new(value.value.to_f, :emu)
         when 'cy'
-          slide_size.height = (value.value.to_f / OoxmlParser.configuration.units_delimiter).round(2)
+          @height = OoxmlSize.new(value.value.to_f, :emu)
         when 'type'
-          slide_size.type = value.value.to_sym
+          @type = value.value.to_sym
         end
       end
-      slide_size
+      self
     end
   end
 end

data/lib/ooxml_parser/pptx_parser/pptx_data/presentation.rb

@@ -1,9 +1,11 @@
 require_relative 'presentation/presentation_comment'
+require_relative 'presentation/presentation_helpers'
 require_relative 'presentation/presentation_theme'
 require_relative 'presentation/slide'
 require_relative 'presentation/slide_size'
 module OoxmlParser
   class Presentation < CommonDocumentStructure
+    include PresentationHelpers
     attr_accessor :slides, :theme, :slide_size, :comments
 
     def initialize(slides = [], theme = nil, comments = [])
@@ -15,7 +17,6 @@ module OoxmlParser
     def self.parse
       OOXMLDocumentObject.root_subfolder = 'ppt/'
       OOXMLDocumentObject.xmls_stack = []
-      OOXMLDocumentObject.namespace_prefix = 'a'
       OOXMLDocumentObject.add_to_xmls_stack('ppt/presentation.xml')
       doc = Nokogiri::XML(File.open(OOXMLDocumentObject.current_xml))
       presentation = Presentation.new
@@ -24,12 +25,14 @@ module OoxmlParser
       presentation_node.xpath('*').each do |presentation_node_child|
         case presentation_node_child.name
         when 'sldSz'
-          presentation.slide_size = SlideSize.parse(presentation_node_child)
+          presentation.slide_size = SlideSize.new(parent: presentation).parse(presentation_node_child)
         when 'sldIdLst'
           presentation_node_child.xpath('p:sldId').each do |silde_id_node|
             id = nil
             silde_id_node.attribute_nodes.select { |node| id = node.to_s if node.namespace && node.namespace.prefix == 'r' }
-            presentation.slides << Slide.parse("#{OOXMLDocumentObject.root_subfolder}/#{OOXMLDocumentObject.get_link_from_rels(id)}")
+            presentation.slides << Slide.new(parent: presentation,
+                                             xml_path: "#{OOXMLDocumentObject.root_subfolder}/#{OOXMLDocumentObject.get_link_from_rels(id)}")
+                                   .parse
           end
         end
       end

data/lib/ooxml_parser/pptx_parser/pptx_parser.rb

@@ -3,7 +3,7 @@ require_relative 'pptx_data/presentation.rb'
 module OoxmlParser
   class PptxParser
     def self.parse_pptx(path_to_file)
-      Parser.parse(path_to_file) do
+      Parser.parse_format(path_to_file) do
         Presentation.parse
       end
     end

data/lib/ooxml_parser/version.rb

@@ -1,6 +1,6 @@
 module OoxmlParser
   # This module holds the RuboCop version information.
   module Version
-    STRING = '0.1.2'.freeze
+    STRING = '0.2.0'.freeze
   end
 end

data/lib/ooxml_parser/xlsx_parser/xlsx_data/view_model/workbook/chartsheet.rb

@@ -0,0 +1,28 @@
+module OoxmlParser
+  # Class for storing data of chartsheets files
+  class Chartsheet < OOXMLDocumentObject
+    # @return [Array, SheetView] array of views
+    attr_accessor :sheet_views
+
+    def initialize(parent: nil)
+      @sheet_views = []
+      @parent = parent
+    end
+
+    def parse(file)
+      OOXMLDocumentObject.add_to_xmls_stack(OOXMLDocumentObject.root_subfolder + file)
+      doc = Nokogiri::XML(File.open(OOXMLDocumentObject.current_xml))
+      node = doc.xpath('//xmlns:chartsheet').first
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'sheetViews'
+          node_child.xpath('*').each do |view_child|
+            @sheet_views << SheetView.new(parent: self).parse(view_child)
+          end
+        end
+      end
+      OOXMLDocumentObject.xmls_stack.pop
+      self
+    end
+  end
+end

data/lib/ooxml_parser/xlsx_parser/xlsx_data/view_model/workbook/style_sheet/fills/fill/pattern_fill.rb

@@ -0,0 +1,33 @@
+module OoxmlParser
+  # Parsing `patternFill` tag
+  class PatternFill < OOXMLDocumentObject
+    # @return [String] pattern type
+    attr_accessor :pattern_type
+    # @return [Color] foreground color
+    attr_accessor :foreground_color
+    # @return [Color] background color
+    attr_accessor :background_color
+
+    # Parse PatternFill data
+    # @param [Nokogiri::XML:Element] node with PatternFill data
+    # @return [PatternFill] value of PatternFill data
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'patternType'
+          @pattern_type = value.value.to_sym
+        end
+      end
+
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'fgColor'
+          @foreground_color = Color.parse_color_tag(node_child)
+        when 'bgColor'
+          @background_color = Color.parse_color_tag(node_child)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/xlsx_parser/xlsx_data/view_model/workbook/style_sheet/fills/fill.rb

@@ -0,0 +1,25 @@
+require_relative 'fill/pattern_fill'
+module OoxmlParser
+  # Parsing `fill` tag
+  class Fill < OOXMLDocumentObject
+    # @return [PatternFill] pattern fill
+    attr_accessor :pattern_fill
+
+    # Parse Fill data
+    # @param [Nokogiri::XML:Element] node with Fill data
+    # @return [Fill] value of Fill data
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'patternFill'
+          @pattern_fill = PatternFill.new(parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+
+    def to_color
+      pattern_fill.foreground_color
+    end
+  end
+end

data/lib/ooxml_parser/xlsx_parser/xlsx_data/view_model/workbook/style_sheet/fills.rb

@@ -0,0 +1,38 @@
+require_relative 'fills/fill'
+module OoxmlParser
+  # Parsing `fonts` tag
+  class Fills < OOXMLDocumentObject
+    # @return [Array, Fill] array of fills
+    attr_accessor :fills_array
+
+    def initialize(parent: nil)
+      @fills_array = []
+      @parent = parent
+    end
+
+    # @return [Array, Fill] accessor
+    def [](key)
+      @fills_array[key]
+    end
+
+    # Parse Fills data
+    # @param [Nokogiri::XML:Element] node with Fills data
+    # @return [Fills] value of Fills data
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'count'
+          @count = value.value.to_i
+        end
+      end
+
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'fill'
+          @fills_array << Fill.new(parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/xlsx_parser/xlsx_data/view_model/workbook/style_sheet/fonts/font.rb

@@ -0,0 +1,35 @@
+module OoxmlParser
+  # Parsing `fonts` tag
+  class Font < OOXMLDocumentObject
+    attr_accessor :name, :size, :font_style, :color
+
+    def initialize(parent: nil)
+      @name = 'Calibri'
+      @size = 11
+      @parent = parent
+    end
+
+    def parse(node)
+      @font_style = FontStyle.new
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'name'
+          @name = node_child.attribute('val').value
+        when 'sz'
+          @size = node_child.attribute('val').value.to_f
+        when 'b'
+          @font_style.bold = true
+        when 'i'
+          @font_style.italic = true
+        when 'strike'
+          @font_style.strike = :single
+        when 'u'
+          @font_style.underlined = Underline.new(:single)
+        when 'color'
+          @color = Color.parse_color_tag(node_child)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/xlsx_parser/xlsx_data/view_model/workbook/style_sheet/fonts.rb

@@ -0,0 +1,38 @@
+require_relative 'fonts/font'
+module OoxmlParser
+  # Parsing `fonts` tag
+  class Fonts < OOXMLDocumentObject
+    # @return [Array, Font] array of number formats
+    attr_accessor :fonts_array
+
+    def initialize(parent: nil)
+      @fonts_array = []
+      @parent = parent
+    end
+
+    # @return [Array, Font] accessor
+    def [](key)
+      @fonts_array[key]
+    end
+
+    # Parse NumberFormats data
+    # @param [Nokogiri::XML:Element] node with NumberFormats data
+    # @return [NumberFormats] value of NumberFormats data
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'count'
+          @count = value.value.to_i
+        end
+      end
+
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'font'
+          @fonts_array << Font.new(parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/xlsx_parser/xlsx_data/view_model/workbook/style_sheet/number_formats/number_format.rb

@@ -0,0 +1,24 @@
+module OoxmlParser
+  # Parsing `numFmt` tag
+  class NumberFormat < OOXMLDocumentObject
+    # @return [Integer] id of number format
+    attr_accessor :id
+    # @return [String] code of format
+    attr_accessor :format_code
+
+    # Parse NumberFormat data
+    # @param [Nokogiri::XML:Element] node with NumberFormat data
+    # @return [NumberFormat] value of NumberFormat data
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'numFmtId'
+          @id = value.value.to_i
+        when 'formatCode'
+          @format_code = value.value.to_s
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/xlsx_parser/xlsx_data/view_model/workbook/style_sheet/number_formats.rb

@@ -0,0 +1,47 @@
+require_relative 'number_formats/number_format'
+module OoxmlParser
+  # Parsing `numFmts` tag
+  class NumberFormats < OOXMLDocumentObject
+    # @return [Array, NumberFormat] array of number formats
+    attr_accessor :number_formats_array
+
+    def initialize(parent: nil)
+      @number_formats_array = []
+      @parent = parent
+    end
+
+    # @return [Array, NumberFormats] accessor
+    def [](key)
+      @number_formats_array[key]
+    end
+
+    # Parse NumberFormats data
+    # @param [Nokogiri::XML:Element] node with NumberFormats data
+    # @return [NumberFormats] value of NumberFormats data
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'count'
+          @count = value.value.to_i
+        end
+      end
+
+      node.xpath('*').each do |node_child|
+        case node_child.name
+        when 'numFmt'
+          @number_formats_array << NumberFormat.new(parent: self).parse(node_child)
+        end
+      end
+      self
+    end
+
+    # @param id [Integer] id of format
+    # @return [NumberFormat, nil] value of format
+    def format_by_id(id)
+      @number_formats_array.each do |cur_format|
+        return cur_format if cur_format.id == id
+      end
+      nil
+    end
+  end
+end

data/lib/ooxml_parser/xlsx_parser/xlsx_data/view_model/workbook/style_sheet.rb

@@ -0,0 +1,36 @@
+require_relative 'style_sheet/fills'
+require_relative 'style_sheet/fonts'
+require_relative 'style_sheet/number_formats'
+module OoxmlParser
+  # Parsing file styles.xml
+  class StyleSheet < OOXMLDocumentObject
+    # @return [NumberFormats] number formats
+    attr_accessor :number_formats
+    # @return [Fonts] fonts
+    attr_accessor :fonts
+    # @return [Fills] fills
+    attr_accessor :fills
+
+    def initialize(parent: nil)
+      @number_formats = NumberFormats.new(parent: self)
+      @fonts = Fonts.new(parent: self)
+      @fills = Fills.new(parent: self)
+      @parent = parent
+    end
+
+    def parse
+      doc = Nokogiri::XML(File.open("#{OOXMLDocumentObject.path_to_folder}/#{OOXMLDocumentObject.root_subfolder}/styles.xml"))
+      doc.root.xpath('*').each do |node_child|
+        case node_child.name
+        when 'numFmts'
+          @number_formats.parse(node_child)
+        when 'fonts'
+          @fonts.parse(node_child)
+        when 'fills'
+          @fills.parse(node_child)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/ooxml_parser/xlsx_parser/xlsx_data/view_model/workbook/workbook_helpers.rb

@@ -0,0 +1,11 @@
+module OoxmlParser
+  # method to help to work with DocumentStructure
+  module WorkbookHelpers
+    # @return [True, false] if structure contain any user data
+    def with_data?
+      return true if @worksheets.length > 1
+      return true if @worksheets.first.with_data?
+      false
+    end
+  end
+end

data/lib/ooxml_parser/xlsx_parser/xlsx_data/view_model/workbook/worksheet/excel_comments/excel_comment.rb

@@ -1,20 +1,21 @@
-require_relative 'excel_comment/excel_comment_character'
-# Single Comment of XLSX
 module OoxmlParser
+  # Single Comment of XLSX
   class ExcelComment < OOXMLDocumentObject
     attr_accessor :characters
 
-    def initialize(characters = [])
-      @characters = characters
+    def initialize(parent: nil)
+      @characters = []
+      @parent = parent
     end
 
-    def self.parse(comment_node)
-      comment = ExcelComment.new
-      comment_node.xpath('xmlns:text/xmlns:r').each do |character_node|
-        character = ExcelCommentCharacter.parse(character_node)
-        comment.characters << character.dup
+    # Parse ExcelComment object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [ExcelComment] result of parsing
+    def parse(node)
+      node.xpath('xmlns:text/xmlns:r').each do |node_child|
+        @characters << ParagraphRun.new(parent: self).parse(node_child)
       end
-      comment
+      self
     end
   end
 end

data/lib/ooxml_parser/xlsx_parser/xlsx_data/view_model/workbook/worksheet/excel_comments.rb

@@ -21,7 +21,7 @@ module OoxmlParser
           end
         when 'commentList'
           comments_node_child.xpath('xmlns:comment').each do |comment_node|
-            excel_comments.comments << ExcelComment.parse(comment_node)
+            excel_comments.comments << ExcelComment.new(parent: excel_comments).parse(comment_node)
           end
         end
       end
@@ -29,15 +29,13 @@ module OoxmlParser
     end
 
     def self.parse_file(file_name, path_to_folder)
-      path_to_comments_xml = ''
-      return nil unless File.exist?(path_to_folder + "xl/worksheets/_rels/#{file_name}.rels")
-      relationships = XmlSimple.xml_in(File.open(path_to_folder + "xl/worksheets/_rels/#{file_name}.rels"))
-      if relationships['Relationship']
-        relationships['Relationship'].each do |relationship|
-          path_to_comments_xml = path_to_folder + 'xl/' + relationship['Target'].gsub('..', '') if File.basename(relationship['Target']).include?('comment')
-        end
-      end
-      ExcelComments.parse(path_to_comments_xml) unless path_to_comments_xml == ''
+      file = path_to_folder + "xl/worksheets/_rels/#{file_name}.rels"
+      return nil unless File.exist?(file)
+      relationships = Relationships.parse_rels(file)
+      target = relationships.target_by_type('comment')
+      return if target.nil?
+      comment_file = "#{OOXMLDocumentObject.path_to_folder}/#{OOXMLDocumentObject.root_subfolder}/#{target.gsub('..', '')}"
+      ExcelComments.parse(comment_file)
     end
   end
 end