ooxml_parser 0.1.2 → 0.2.0

data/lib/ooxml_parser/pptx_parser/pptx_data/presentation/slide/shape/non_visual_shape_properties/hyperlinks/hyperlink_for_hover.rb

@@ -1,5 +1,6 @@
 module OoxmlParser
-  class HyperlinkForHover
+  # Class for parsing `hlinkHover` tags
+  class HyperlinkForHover < OOXMLDocumentObject
     attr_accessor :id, :action, :sound
 
     def initialize(id = '', action = '')
@@ -7,17 +8,19 @@ module OoxmlParser
       @action = action
     end
 
-    def self.parse(hyperlink_for_hover_node)
-      hyperlink_for_hover = HyperlinkForHover.new
-      hyperlink_for_hover.id = hyperlink_for_hover_node.attribute('id').value
-      hyperlink_for_hover.action = hyperlink_for_hover_node.attribute('action').value
-      hyperlink_for_hover_node.xpath('*').each do |hyperlink_for_hover_node_child|
+    # Parse HyperlinkForHover
+    # @param [Nokogiri::XML:Node] node with NumberingProperties
+    # @return [HyperlinkForHover] result of parsing
+    def parse(node)
+      @id = node.attribute('id').value
+      @action = node.attribute('action').value
+      node.xpath('*').each do |hyperlink_for_hover_node_child|
         case hyperlink_for_hover_node_child.name
         when 'snd'
-          hyperlink_for_hover.sound = Sound.parse(hyperlink_for_hover_node_child)
+          @sound = Sound.new(parent: self).parse(hyperlink_for_hover_node_child)
         end
       end
-      hyperlink_for_hover
+      self
     end
   end
 end

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

@@ -1,30 +1,34 @@
-require_relative 'shapes_grouping/grouping_properties'
 module OoxmlParser
-  class ShapesGrouping
+  # Class for parsing `grpSp`
+  class ShapesGrouping < OOXMLDocumentObject
     attr_accessor :elements, :properties
 
-    def initialize(elements = [])
-      @elements = elements
+    def initialize(parent: nil)
+      @elements = []
+      @parent = parent
     end
 
-    def self.parse(grouping_node)
-      grouping = ShapesGrouping.new
-      grouping_node.xpath('*').each do |grouping_node_child|
-        case grouping_node_child.name
-        when 'nvGrpSpPr'
+    # Parse ShapesGrouping object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [ShapesGrouping] result of parsing
+    def parse(node)
+      node.xpath('*').each do |child_node|
+        case child_node.name
         when 'grpSpPr'
-          grouping.properties = GroupingProperties.parse(grouping_node_child)
+          @properties = DocxShapeProperties.new(parent: self).parse(child_node)
         when 'pic'
-          grouping.elements << DocxPicture.parse(grouping_node_child)
+          @elements << DocxPicture.new(parent: self).parse(child_node)
         when 'sp'
-          grouping.elements << PresentationShape.parse(grouping_node_child).dup
+          @elements << DocxShape.new(parent: self).parse(child_node).dup
         when 'grpSp'
-          grouping.elements << parse(grouping_node_child)
+          @elements << ShapesGrouping.new(parent: self).parse(child_node)
         when 'graphicFrame'
-          grouping.elements << GraphicFrame.parse(grouping_node_child)
+          @elements << GraphicFrame.new(parent: self).parse(child_node)
+        when 'wsp'
+          @elements << DocxShape.new(parent: self).parse(child_node)
         end
       end
-      grouping
+      self
     end
   end
 end

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

@@ -1,22 +1,27 @@
 module OoxmlParser
-  class AnimationEffect
+  class AnimationEffect < OOXMLDocumentObject
     attr_accessor :transition, :filter, :behavior
 
-    def initialize(behavior = nil)
-      @behavior = behavior
-    end
+    # Parse AnimationEffect object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [AnimationEffect] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'transition'
+          @transition = value.value
+        when 'filter'
+          @filter = value.value
+        end
+      end
 
-    def self.parse(animation_effect_node)
-      animation_effect = AnimationEffect.new
-      animation_effect.transition = animation_effect_node.attribute('transition').value if animation_effect_node.attribute('transition')
-      animation_effect.filter = animation_effect_node.attribute('filter').value if animation_effect_node.attribute('filter')
-      animation_effect_node.xpath('*').each do |animation_effect_node_child|
-        case animation_effect_node_child.name
+      node.xpath('*').each do |node_child|
+        case node_child.name
         when 'cBhvr'
-          animation_effect.behavior = Behavior.parse(animation_effect_node_child)
+          @behavior = Behavior.new(parent: self).parse(node_child)
         end
       end
-      animation_effect
+      self
     end
   end
 end

data/lib/ooxml_parser/pptx_parser/pptx_data/presentation/slide/slide/timing/set_time_node/behavior/behavior.rb

@@ -1,29 +1,30 @@
 require_relative 'target_element'
 module OoxmlParser
-  class Behavior
+  class Behavior < OOXMLDocumentObject
     attr_accessor :common_time_node, :attribute_name_list, :target
 
-    def initialize(common_time_node = nil, attribute_name_list = [], target = nil)
-      @common_time_node = common_time_node
-      @attribute_name_list = attribute_name_list
-      @target = target
+    def initialize(parent: nil)
+      @attribute_name_list = []
+      @parent = parent
     end
 
-    def self.parse(behavior_node)
-      behavior = Behavior.new
-      behavior_node.xpath('*').each do |behavior_node_child|
-        case behavior_node_child.name
+    # Parse Behavior object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [Behavior] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
         when 'cTn'
-          behavior.common_time_node = CommonTiming.parse(behavior_node_child)
+          @common_time_node = CommonTiming.new(parent: self).parse(node_child)
         when 'tgtEl'
-          behavior.target = TargetElement.parse(behavior_node_child)
+          @target = TargetElement.new(parent: self).parse(node_child)
         when 'attrNameLst'
-          behavior_node_child.xpath('p:attrName').each do |attribute_name_node|
-            behavior.attribute_name_list << attribute_name_node.text
+          node_child.xpath('p:attrName').each do |attribute_name_node|
+            @attribute_name_list << attribute_name_node.text
           end
         end
       end
-      behavior
+      self
     end
   end
 end

data/lib/ooxml_parser/pptx_parser/pptx_data/presentation/slide/slide/timing/set_time_node/behavior/target_element.rb

@@ -1,31 +1,34 @@
 module OoxmlParser
-  class TargetElement
+  class TargetElement < OOXMLDocumentObject
     attr_accessor :type, :id, :name, :built_in
 
-    def initialize(type = '', id = '')
+    def initialize(type = '', id = '', parent: nil)
       @type = type
       @id = id
+      @parent = parent
     end
 
-    def self.parse(target_node)
-      target = TargetElement.new
-      target_node.xpath('*').each do |target_node_child|
-        case target_node_child.name
+    # Parse TargetElement object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [TargetElement] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
         when 'sldTgt'
-          target.type = :slide
+          @type = :slide
         when 'sndTgt'
-          target.type = :sound
-          target.name = target_node_child.attribute('name').value
-          target.built_in = target_node_child.attribute('builtIn').value ? StringHelper.to_bool(target_node_child.attribute('builtIn').value) : false
+          @type = :sound
+          @name = node_child.attribute('name').value
+          @built_in = node_child.attribute('builtIn').value ? StringHelper.to_bool(node_child.attribute('builtIn').value) : false
         when 'spTgt'
-          target.type = :shape
-          target.id = target_node_child.attribute('spid').value
+          @type = :shape
+          @id = node_child.attribute('spid').value
         when 'inkTgt'
-          target.type = :ink
-          target.id = target_node_child.attribute('spid').value
+          @type = :ink
+          @id = node_child.attribute('spid').value
         end
       end
-      target
+      self
     end
   end
 end

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

@@ -1,22 +1,20 @@
 require_relative 'behavior/behavior'
 
 module OoxmlParser
-  class SetTimeNode
+  class SetTimeNode < OOXMLDocumentObject
     attr_accessor :behavior, :to
 
-    def initialize(behavior = nil)
-      @behavior = behavior
-    end
-
-    def self.parse(set_time_node)
-      set_time = SetTimeNode.new
-      set_time_node.xpath('*').each do |set_time_node_child|
-        case set_time_node_child.name
+    # Parse SetTimeNode object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [SetTimeNode] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
         when 'cBhvr'
-          set_time.behavior = Behavior.parse(set_time_node_child)
+          @behavior = Behavior.new(parent: self).parse(node_child)
         end
       end
-      set_time
+      self
     end
   end
 end

data/lib/ooxml_parser/pptx_parser/pptx_data/presentation/slide/slide/timing/time_node/common_timing/condition.rb

@@ -1,24 +1,27 @@
 module OoxmlParser
-  class Condition
+  # Class for parsing `cond` tags
+  class Condition < OOXMLDocumentObject
     attr_accessor :event, :delay, :duration
 
-    def initialize(event = nil, delay = nil, duration = nil)
-      @event = event
-      @delay = delay
-      @duration = duration
-    end
-
-    def self.parse(condition_node)
-      condition = Condition.new
-      condition.event = condition_node.attribute('evt').value if condition_node.attribute('evt')
-      condition.delay = condition_node.attribute('delay').value if condition_node.attribute('delay')
-      condition
+    # Parse Condition
+    # @param node [Nokogiri::XML::Element] node to parse
+    # @return [Condition] value of SheetFormatProperties
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'evt'
+          @event = value.value
+        when 'delay'
+          @delay = value.value
+        end
+      end
+      self
     end
 
     def self.parse_list(conditions_list_node)
       conditions = []
       conditions_list_node.xpath('p:cond').each do |condition_node|
-        conditions << Condition.parse(condition_node)
+        conditions << Condition.new(parent: conditions).parse(condition_node)
       end
       conditions
     end

data/lib/ooxml_parser/pptx_parser/pptx_data/presentation/slide/slide/timing/time_node/common_timing.rb

@@ -3,31 +3,39 @@ module OoxmlParser
   class CommonTiming
     attr_accessor :id, :duration, :restart, :children, :start_conditions, :end_conditions
 
-    def initialize
-      @id = nil
-      @duration = nil
-      @restart = nil
+    def initialize(parent: nil)
       @children = []
       @start_conditions = []
       @end_conditions = []
+      @parent = parent
     end
 
-    def self.parse(common_time_node)
-      common_timing = CommonTiming.new
-      common_timing.duration = common_time_node.attribute('dur').value unless common_time_node.attribute('dur').nil?
-      common_timing.restart = common_time_node.attribute('restart').value unless common_time_node.attribute('restart').nil?
-      common_timing.id = common_time_node.attribute('id').value
-      common_time_node.xpath('*').each do |common_time_node_child|
-        case common_time_node_child.name
+    # Parse CommonTiming object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [CommonTiming] result of parsing
+    def parse(node)
+      node.attributes.each do |key, value|
+        case key
+        when 'dur'
+          @duration = value.value
+        when 'restart'
+          @restart = value.value
+        when 'id'
+          @id = value.value
+        end
+      end
+
+      node.xpath('*').each do |node_child|
+        case node_child.name
         when 'stCondLst'
-          common_timing.start_conditions = Condition.parse_list(common_time_node_child)
+          @start_conditions = Condition.parse_list(node_child)
         when 'endCondLst'
-          common_timing.end_conditions = Condition.parse_list(common_time_node_child)
+          @end_conditions = Condition.parse_list(node_child)
         when 'childTnLst'
-          common_timing.children = TimeNode.parse_list(common_time_node_child)
+          @children = TimeNode.parse_list(node_child)
         end
       end
-      common_timing
+      self
     end
   end
 end

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

@@ -2,28 +2,30 @@ require_relative 'time_node/common_timing'
 require_relative 'animation_effect/animation_effect'
 require_relative 'set_time_node/set_time_node'
 module OoxmlParser
-  class TimeNode
+  # Class for parsing TimeNode tags
+  class TimeNode < OOXMLDocumentObject
     attr_accessor :type, :common_time_node, :previous_conditions_list, :next_conditions_list
 
-    def initialize(type = nil, common_time_node = nil, previous_conditions_list = [], next_conditions_list = [])
+    def initialize(type = nil, parent: nil)
       @type = type
-      @common_time_node = common_time_node
-      @previous_conditions_list = previous_conditions_list
-      @next_conditions_list = next_conditions_list
+      @previous_conditions_list = []
+      @next_conditions_list = []
+      @parent = parent
     end
 
-    def self.parse(time_node, type)
-      time = TimeNode.new
-      time.type = type
-      time_node.xpath('*').each do |time_node_child|
-        case time_node_child.name
+    # Parse TimeNode
+    # @param node [Nokogiri::XML::Element] node to parse
+    # @return [TimeNode] value of SheetFormatProperties
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
         when 'cTn'
-          time.common_time_node = CommonTiming.parse(time_node_child)
+          @common_time_node = CommonTiming.new(parent: self).parse(node_child)
         when 'prevCondLst'
-          time.previous_conditions_list = Condition.parse_list(time_node_child)
+          @previous_conditions_list = Condition.parse_list(node_child)
         end
       end
-      time
+      self
     end
 
     def self.parse_list(timing_list_node)
@@ -31,17 +33,17 @@ module OoxmlParser
       timing_list_node.xpath('*').each do |time_node|
         case time_node.name
         when 'par'
-          timings << TimeNode.parse(time_node, :parallel)
+          timings << TimeNode.new(:parallel, parent: timings).parse(time_node)
         when 'seq'
-          timings << TimeNode.parse(time_node, :sequence)
+          timings << TimeNode.new(:sequence, parent: timings).parse(time_node)
         when 'excl'
-          timings << TimeNode.parse(time_node, :exclusive)
+          timings << TimeNode.new(:exclusive, parent: timings).parse(time_node)
         when 'anim'
-          timings << TimeNode.parse(time_node, :animate)
+          timings << TimeNode.new(:animate, parent: timings).parse(time_node)
         when 'set'
-          timings << SetTimeNode.parse(time_node)
+          timings << SetTimeNode.new(parent: timings).parse(time_node)
         when 'animEffect'
-          timings << AnimationEffect.parse(time_node)
+          timings << AnimationEffect.new(parent: timings).parse(time_node)
         when 'video'
           timings << :video
         when 'audio'

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

@@ -1,23 +1,27 @@
 require_relative 'timing/time_node'
 module OoxmlParser
-  class Timing
+  # Class for parsing `timing`
+  class Timing < OOXMLDocumentObject
     attr_accessor :time_node_list, :build_list, :extension_list
 
-    def initialize(time_node_list = [], build_list = [], extension_list = [])
-      @time_node_list = time_node_list
-      @build_list = build_list
-      @extension_list = extension_list
+    def initialize(parent: nil)
+      @time_node_list = []
+      @build_list = []
+      @extension_list = []
+      @parent = parent
     end
 
-    def self.parse(timing_node)
-      timing = Timing.new
-      timing_node.xpath('*').each do |timing_node_child|
-        case timing_node_child.name
+    # Parse Timing object
+    # @param node [Nokogiri::XML:Element] node to parse
+    # @return [Timing] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
         when 'tnLst'
-          timing.time_node_list = TimeNode.parse_list(timing_node_child)
+          @time_node_list = TimeNode.parse_list(node_child)
         end
       end
-      timing
+      self
     end
   end
 end

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

@@ -0,0 +1,52 @@
+module OoxmlParser
+  # Methods to help working with slide data
+  module SlideHelper
+    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
+        elements.find { |e| e.is_a? Picture }.properties.transform
+      when :chart
+        elements.find { |e| e.is_a? GraphicFrame }.transform
+      when :table
+        elements.find { |e| e.is_a? GraphicFrame }.transform
+      when :shape
+        elements.find { |e| !e.shape_properties.preset.nil? }.shape_properties.transform
+      else
+        raise "Dont know this type object - #{object}"
+      end
+    end
+
+    def content_horizontal_align(object, slide_size)
+      transform = transform_of_object(object)
+      return :left if transform.offset.x.zero?
+      return :center if OoxmlSize.new((slide_size.width.value / 2) - (transform.extents.x.value / 2)) == OoxmlSize.new(transform.offset.x.value)
+      return :right if OoxmlSize.new((slide_size.width.value - transform.extents.x.value)) == OoxmlSize.new(transform.offset.x.value)
+      :unknown
+    end
+
+    def content_vertical_align(object, slide_size)
+      transform = transform_of_object(object)
+      return :top if transform.offset.y.zero?
+      return :middle if OoxmlSize.new((slide_size.height.value / 2) - (transform.extents.y.value / 2)) == OoxmlSize.new(transform.offset.y.value)
+      return :bottom if OoxmlSize.new(slide_size.height.value - transform.extents.y.value) == OoxmlSize.new(transform.offset.y.value)
+      :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
+  end
+end

data/lib/ooxml_parser/pptx_parser/pptx_data/presentation/slide/transition/transition/sound_action/sound.rb

@@ -1,17 +1,23 @@
 module OoxmlParser
+  # Class for parsing `snd` tags
   class Sound < OOXMLDocumentObject
-    attr_accessor :path, :name
+    attr_accessor :name
+    # @return [FileReference] image structure
+    attr_accessor :file_reference
 
-    def initialize(path = '', name = '')
+    def initialize(path = '', name = '', parent: nil)
       @path = path
       @name = name
+      @parent = parent
     end
 
-    def self.parse(sound_node)
-      sound = Sound.new
-      sound.path = OOXMLDocumentObject.copy_media_file("#{OOXMLDocumentObject.root_subfolder}/#{get_link_from_rels(sound_node.attribute('embed').value).gsub('..', '')}")
-      sound.name = sound_node.attribute('name').value
-      sound
+    # Parse Sound
+    # @param [Nokogiri::XML:Node] node with NumberingProperties
+    # @return [Sound] result of parsing
+    def parse(node)
+      @file_reference = FileReference.new(parent: self).parse(node)
+      @name = node.attribute('name').value
+      self
     end
   end
 end

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

@@ -1,20 +1,22 @@
 require_relative 'sound_action/sound'
 module OoxmlParser
-  class SoundAction
+  # Class for parsing SoundAction
+  class SoundAction < OOXMLDocumentObject
     attr_accessor :start_sound, :end_sound
 
-    def self.parse(sound_action_node)
-      return nil unless sound_action_node.name == 'sndAc'
-      sound_action = SoundAction.new
-      sound_action_node.xpath('*').each do |sound_action_node_child|
-        case sound_action_node_child.name
+    # Parse HyperlinkForHover
+    # @param [Nokogiri::XML:Node] node with NumberingProperties
+    # @return [HyperlinkForHover] result of parsing
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        case node_child.name
         when 'stSnd'
-          sound_action.start_sound = Sound.parse(sound_action_node_child.xpath('p:snd').first) unless sound_action_node_child.xpath('p:snd').first.nil?
+          @start_sound = Sound.new(parent: self).parse(node_child.xpath('p:snd').first) unless node_child.xpath('p:snd').first.nil?
         when 'endSnd'
-          sound_action.end_sound = Sound.parse(sound_action_node_child.xpath('p:snd').first) unless sound_action_node_child.xpath('p:snd').first.nil?
+          @end_sound = Sound.new(parent: self).parse(node_child.xpath('p:snd').first) unless node_child.xpath('p:snd').first.nil?
         end
       end
-      sound_action
+      self
     end
   end
 end

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

@@ -4,29 +4,27 @@ module OoxmlParser
   class Transition < OOXMLDocumentObject
     attr_accessor :speed, :properties, :sound_action, :advance_on_click, :delay, :duration
 
-    def initialize(properties = TransitionProperties.new)
-      @properties = properties
-    end
-
-    def self.parse(transition_node)
-      transition = Transition.new
-      transition_node.xpath('*').each do |transition_node_child|
-        transition.properties = TransitionProperties.parse(transition_node_child)
-        transition.sound_action = SoundAction.parse(transition_node_child)
+    def parse(node)
+      node.xpath('*').each do |node_child|
+        @properties = TransitionProperties.new(parent: self).parse(node_child)
+        case node_child.name
+        when 'sndAc'
+          @sound_action = SoundAction.new(parent: self).parse(node_child)
+        end
       end
-      transition_node.attributes.each do |key, value|
+      node.attributes.each do |key, value|
         case key
         when 'spd'
-          transition.speed = value.value.to_sym
+          @speed = value.value.to_sym
         when 'advClick'
-          transition.advance_on_click = OOXMLDocumentObject.option_enabled?(transition_node, key)
+          @advance_on_click = attribute_enabled?(value)
         when 'advTm'
-          transition.delay = value.value.to_f / 1_000.0
+          @delay = value.value.to_f / 1_000.0
         when 'dur'
-          transition.duration = value.value.to_f / 1_000.0
+          @duration = value.value.to_f / 1_000.0
         end
       end
-      transition
+      self
     end
   end
 end