pptx 0.0.1

data/lib/pptx/opc/binary_part.rb

@@ -0,0 +1,20 @@
+module PPTX
+  module OPC
+    class BinaryPart < BasePart
+      def initialize(package, original_name)
+        name = "ppt/media/binary-#{SecureRandom.hex(10)}#{File.extname(original_name)}"
+        super(package, name)
+        @original_name = original_name
+      end
+
+      def doc
+        throw "Binary parts can't be parsed as XML"
+      end
+
+      def marshal
+        throw 'Implement me!'
+      end
+    end
+  end
+end
+

data/lib/pptx/opc/content_types.rb

@@ -0,0 +1,18 @@
+module PPTX
+  module OPC
+    class ContentTypes < BasePart
+      NS = 'http://schemas.openxmlformats.org/package/2006/content-types'
+
+      def set_override(part_name, value)
+        type_list = doc.xpath('c:Types', c: NS).first
+        override = type_list.xpath("./xmlns:Override[@PartName='#{part_name}']").first
+        unless override
+          override = Nokogiri::XML::Node.new('Override', doc)
+          override['PartName'] = '/' + part_name
+          type_list.add_child(override)
+        end
+        override['ContentType'] = value
+      end
+    end
+  end
+end

data/lib/pptx/opc/file_part.rb

@@ -0,0 +1,28 @@
+module PPTX
+  module OPC
+    class FilePart < BinaryPart
+      def initialize(package, file)
+        super(package, File.basename(file))
+        @file = file
+        @chunk_size = 16 * 1024
+      end
+
+      def marshal
+        IO.read(@file)
+      end
+
+      def size
+        File.size(@file)
+      end
+
+      def stream(out)
+        File.open(@file, 'r') do |file|
+          while chunk = file.read(@chunk_size)
+            puts "Streaming file: #{chunk && chunk.bytesize} bytes"
+            out << chunk
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pptx/opc/package.rb

@@ -0,0 +1,115 @@
+require 'nokogiri'
+require 'zip'
+
+module PPTX
+  module OPC
+    # Package allows the following:
+    # * Create new package based on an existing PPTX file
+    #   (extracted ZIP for better version control)
+    # * Replace certain files with generated parts
+    class Package
+      # Create a new package using the directory strucuture base
+      def initialize(base = nil)
+        base ||= base || File.join(File.dirname(__FILE__), '..', 'base.pptx')
+        @base = File.absolute_path(base)
+        @parts = Hash[default_part_names.map {|fn| [fn, nil]}]
+      end
+
+      def base
+        @base
+      end
+
+      def content_types
+        @content_types ||= ContentTypes.new(self, '[Content_Types].xml')
+      end
+
+      def has_part?(name)
+        @parts.has_key?(name)
+      end
+
+      def part(name)
+        @parts[name]
+      end
+
+      # Returns a Hash of name -> Part
+      # Do not modify the hash directly, but use set_part.
+      def parts
+        @parts
+      end
+
+      def template_part(name)
+        file = File.join(@base, name)
+        IO.read(file) if File.exist? file
+      end
+
+      def marshal_part(name)
+        part = @parts[name]
+        if part
+          if part.is_a? BasePart
+            part.marshal
+          elsif part.instance_of? String
+            # TODO wrap binary parts, probably as references when implementing streaming
+            part
+          else
+            raise "marshal_part: Unknown part type: '#{p.class}' for part '#{name}'"
+          end
+        else
+          template_part name
+        end
+      end
+
+      # Used e.g. for creating slides with proper numbering (i.e. slide1.xml, slide2.xml)
+      def next_part_with_prefix(prefix, suffix)
+        num = @parts.select { |n, _| n.start_with?(prefix) && n.end_with?(suffix) }
+                   .map { |n, _| n[prefix.length..-1][0..-(suffix.size + 1)].to_i }
+                   .max
+        num = (num || 0) + 1
+        "#{prefix}#{num}#{suffix}"
+      end
+
+      def set_part(name, obj, content_type = nil)
+        @parts[name] = obj
+        if content_type
+          content_types.set_override(name, content_type)
+        end
+      end
+
+      def presentation
+        @presentation ||= PPTX::Presentation.new(self, 'ppt/presentation.xml')
+      end
+
+      # Stream a ZIP file while it's being generated
+      # The returned PackageStreamer instance has an each method that takes a block, which
+      # is called multiple times with chunks of data.
+      # When adding BinaryParts (e.g. S3ObjectPart or FilePart), these are also
+      # streamed into the ZIP file, so you can e.g. stream objects directly from S3
+      # to the client, encoded in the ZIP file.
+      # Use this e.g. in a Rails controller as `self.response_body`.
+      def stream_zip(ignore_part_exceptions=false)
+        PackageStreamer.new(self, ignore_part_exceptions)
+      end
+
+      def to_zip
+        buffer = ::StringIO.new('')
+
+        Zip::OutputStream.write_buffer(buffer) do |out|
+          @parts.each do |name, _|
+            out.put_next_entry name
+            out.write marshal_part(name)
+          end
+        end
+
+        buffer.string
+      end
+
+      private
+      def default_part_names
+        @default_part_names ||= Dir.glob(File.join(@base, '**/*'), File::FNM_DOTMATCH)
+                                   .reject {|fn| File.directory?(fn) }
+                                   .reject {|fn| fn.end_with?('.DS_Store')}
+                                   .map    {|fn| fn[(@base.length + 1)..-1]}
+      end
+
+    end
+  end
+end

data/lib/pptx/opc/package_streamer.rb

@@ -0,0 +1,48 @@
+module PPTX
+  module OPC
+    class PackageStreamer
+      # Use ignore_part_exceptions to ignore exceptions while marshalling or streaming
+      # a part. Useful to ignore missing files on S3.
+      def initialize(package, ignore_part_exceptions=false)
+        @package = package
+        @ignore_part_exceptions = ignore_part_exceptions
+      end
+
+      # This method uses parts of zipline to implement streaming.
+      #
+      # This is how Zipline usually works:
+      # * Rails calls response_body.each
+      # * response_body is Zipline::ZipGenerator, it creates a Zipline::FakeStream with the
+      #   block given to each
+      # * The FakeStream is used as output for ZipLine::OutputStream (which inherits
+      #   from Zip::OutputStream)
+      # * ZipGenerator goes through files and calls write_file on the OutputStream for each file
+      # * OutputStream writes the data as String to FakeStream via the << method
+      # * FakeStream yields the String to the block given by Rails
+      #
+      # This method uses Zipline's FakeStream and OutputStream, but writes the entries
+      # to the zip file on it's own, so we can write data for a file in multiple steps
+      # and don't have to rely on Zipline's crazy logic (e.g. on what can be streamed and
+      # what not - only IO and StringIO). Basically, this replaces ZipGenerator.
+      def each(&block)
+        fake_stream = Zipline::FakeStream.new(&block)
+        Zipline::OutputStream.open(fake_stream) do |zip|
+          @package.parts.each do |name, part|
+            begin
+              if part.respond_to?(:stream) && part.respond_to?(:size)
+                zip.put_next_entry name, part.size
+                part.stream zip
+              else
+                data = @package.marshal_part(name)
+                zip.put_next_entry name, data.size
+                zip << data
+              end
+            rescue => e
+              raise e unless @ignore_part_exceptions
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pptx/opc/part.rb

@@ -0,0 +1,27 @@
+require 'pathname'
+
+module PPTX
+  module OPC
+    class Part < BasePart
+      def initialize(package, part_name)
+        super(package, part_name)
+        @relationships = Relationships.new(package, relationship_part_name)
+      end
+
+      def relative_part_name(name)
+        source = Pathname.new(File.dirname(part_name))
+        target = Pathname.new(name)
+        target.relative_path_from(source).to_s
+      end
+
+      def relationships
+        @relationships
+      end
+
+      def relationship_part_name(part_name = nil)
+        part_name ||= @part_name
+        File.join(File.dirname(part_name), '_rels', File.basename(part_name) + '.rels')
+      end
+    end
+  end
+end

data/lib/pptx/opc/relationships.rb

@@ -0,0 +1,32 @@
+require 'securerandom'
+
+module PPTX
+  module OPC
+    class Relationships < BasePart
+      NS = 'http://schemas.openxmlformats.org/package/2006/relationships'
+
+      def base_xml
+        '''<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+          <Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+          </Relationships>
+        '''
+      end
+
+      def add(relative_part_name, type)
+        ref_id = "rId#{SecureRandom.hex(10)}"
+
+        relationship = Nokogiri::XML::Node.new('Relationship', doc)
+        relationship['Id'] = ref_id
+        relationship['Target'] = relative_part_name
+        relationship['Type'] = type
+        list_xml.add_child(relationship)
+
+        ref_id
+      end
+
+      def list_xml
+        @list_xml ||= doc.xpath('r:Relationships', r: NS).first
+      end
+    end
+  end
+end

data/lib/pptx/opc/s3_object_part.rb

@@ -0,0 +1,25 @@
+module PPTX
+  module OPC
+    class S3ObjectPart < BinaryPart
+      def initialize(package, s3obj, size)
+        super(package, File.basename(s3obj.key))
+        @object = s3obj
+        @size = size
+      end
+
+      def marshal
+        @object.read
+      end
+
+      def size
+        @size
+      end
+
+      def stream(out)
+        @object.read do |chunk|
+          out << chunk
+        end
+      end
+    end
+  end
+end

data/lib/pptx/presentation.rb

@@ -0,0 +1,33 @@
+module PPTX
+  class Presentation < OPC::Part
+    NS = 'http://schemas.openxmlformats.org/presentationml/2006/main'
+    MIN_SLIDE_ID = 256
+
+    def initialize(package, part_name)
+      super(package, part_name)
+    end
+
+    def add_slide(slide)
+      # TODO remove me - remove existing slide from template
+      # slide_list_xml.xpath('./p:sldId').each do |slide|
+      #   slide_list.children.delete(slide)
+      # end
+      ref_id = relationships.add(relative_part_name(slide.part_name), RELTYPE_SLIDE)
+
+      # add slide to sldIdList in presentation
+      slide_id = Nokogiri::XML::Node.new('p:sldId', doc)
+      slide_id['id'] = next_slide_id
+      slide_id['r:id'] = ref_id
+      slide_list_xml.add_child(slide_id)
+    end
+
+    def next_slide_id
+      ids = slide_list_xml.xpath('./p:sldId').map { |sid| sid['id'].to_i }
+      return (ids.max || MIN_SLIDE_ID - 1) + 1
+    end
+
+    def slide_list_xml
+      @slide_list_xml ||= doc.xpath('/p:presentation/p:sldIdLst', p: NS).first
+    end
+  end
+end

data/lib/pptx/shapes.rb

@@ -0,0 +1,10 @@
+module PPTX
+  module Shapes
+  end
+end
+
+require_relative 'shapes/shape'
+require_relative 'shapes/filled_rectangle'
+require_relative 'shapes/picture'
+require_relative 'shapes/textbox'
+require_relative 'shapes/slide_number'

data/lib/pptx/shapes/filled_rectangle.rb

@@ -0,0 +1,32 @@
+module PPTX
+  module Shapes
+    class FilledRectangle < Shape
+      def initialize(transform, color)
+        super(transform)
+        @color = color
+      end
+
+      def base_xml
+        # TODO replace cNvPr descr, id and name
+        """
+          <p:sp xmlns:a='http://schemas.openxmlformats.org/drawingml/2006/main'
+                xmlns:p='http://schemas.openxmlformats.org/presentationml/2006/main'>
+              <p:nvSpPr>
+                  <p:cNvPr id='2' name='Rectangle'/>
+                  <p:cNvSpPr/>
+                  <p:nvPr/>
+              </p:nvSpPr>
+              <p:spPr>
+              </p:spPr>
+          </p:sp>
+        """
+      end
+
+      def build_node
+        base_node.tap do |node|
+          node.xpath('.//p:spPr', p: Presentation::NS).first.add_child build_solid_fill @color
+        end
+      end
+    end
+  end
+end

data/lib/pptx/shapes/picture.rb

@@ -0,0 +1,40 @@
+module PPTX
+  module Shapes
+    class Picture < Shape
+      def initialize(transform, relationship_id)
+        super(transform)
+        @relationship_id = relationship_id
+      end
+
+      def base_xml
+        # TODO replace cNvPr descr, id and name
+        """
+          <p:pic xmlns:a='http://schemas.openxmlformats.org/drawingml/2006/main'
+                 xmlns:p='http://schemas.openxmlformats.org/presentationml/2006/main'>
+            <p:nvPicPr>
+                <p:cNvPr descr='test_photo.jpg' id='2' name='Picture 1'/>
+                <p:cNvPicPr>
+                    <a:picLocks noChangeAspect='1'/>
+                </p:cNvPicPr>
+                <p:nvPr/>
+            </p:nvPicPr>
+            <p:blipFill>
+                <a:blip r:embed='REPLACEME'/>
+                <a:stretch>
+                    <a:fillRect/>
+                </a:stretch>
+            </p:blipFill>
+            <p:spPr>
+            </p:spPr>
+        </p:pic>
+        """
+      end
+
+      def build_node
+        base_node.tap do |node|
+          node.xpath('.//a:blip', a: DRAWING_NS).first['r:embed'] = @relationship_id
+        end
+      end
+    end
+  end
+end

data/lib/pptx/shapes/shape.rb

@@ -0,0 +1,46 @@
+module PPTX
+  module Shapes
+    class Shape
+      def initialize(transform)
+        @transform = transform
+      end
+
+      def base_node
+        @base_node ||= Nokogiri::XML::DocumentFragment.parse(base_xml).tap do |node|
+          set_shape_properties(node, *@transform)
+        end
+      end
+
+      def set_shape_properties(node, x, y, width, height)
+        xml = """
+          <p:spPr xmlns:a='http://schemas.openxmlformats.org/drawingml/2006/main'
+                  xmlns:p='http://schemas.openxmlformats.org/presentationml/2006/main'>
+              <a:xfrm>
+                  <a:off x='#{x.to_i}' y='#{y.to_i}'/>
+                  <a:ext cx='#{width.to_i}' cy='#{height.to_i}'/>
+              </a:xfrm>
+              <a:prstGeom prst='rect'>
+                  <a:avLst/>
+              </a:prstGeom>
+          </p:spPr>
+          """
+
+        node.xpath('.//p:spPr', p: Presentation::NS)
+            .first
+            .replace(Nokogiri::XML::DocumentFragment.parse(xml))
+      end
+
+      def build_solid_fill(rgb_color)
+        fill_xml = """
+        <a:solidFill xmlns:a='http://schemas.openxmlformats.org/drawingml/2006/main'>
+          <a:srgbClr val='SETME'/>
+        </a:solidFill>
+        """
+
+        Nokogiri::XML::DocumentFragment.parse(fill_xml).tap do |node|
+          node.xpath('.//a:srgbClr', a: DRAWING_NS).first['val'] = rgb_color
+        end
+      end
+    end
+  end
+end