ruby_pptx 0.1.0 → 0.2.0

data/lib/ruby_pptx/image.rb

@@ -50,7 +50,9 @@ module Pptx
     attr_reader :blob, :filename
 
     class << self
-      def from_blob(blob, filename = nil) = new(blob, filename)
+      def from_blob(blob, filename = nil)
+        new(blob, filename)
+      end
 
       # Load from a path or an IO stream.
       def from_file(image_file)
@@ -69,18 +71,28 @@ module Pptx
     end
 
     # @return [Symbol] :PNG, :JPEG, :GIF, :BMP, :TIFF or :WMF
-    def format = header.fetch(:format)
+    def format
+      header.fetch(:format)
+    end
 
     # True for a vector image, which has no pixel size of its own and needs a
     # raster fallback to be placed in a slide.
-    def vector? = format == :SVG
+    def vector?
+      format == :SVG
+    end
 
     # @return [Array(Integer, Integer)] width and height in pixels
-    def size = [header.fetch(:width), header.fetch(:height)]
+    def size
+      [header.fetch(:width), header.fetch(:height)]
+    end
 
-    def width_px = header.fetch(:width)
+    def width_px
+      header.fetch(:width)
+    end
 
-    def height_px = header.fetch(:height)
+    def height_px
+      header.fetch(:height)
+    end
 
     # @return [Array(Integer, Integer)] horizontal and vertical dots per inch
     def dpi
@@ -94,9 +106,13 @@ module Pptx
       end
     end
 
-    def content_type = CONTENT_TYPE_FOR_EXT.fetch(ext)
+    def content_type
+      CONTENT_TYPE_FOR_EXT.fetch(ext)
+    end
 
-    def sha1 = @sha1 ||= Digest::SHA1.hexdigest(@blob)
+    def sha1
+      @sha1 ||= Digest::SHA1.hexdigest(@blob)
+    end
 
     # Native size in EMU, derived from the pixel size and resolution.
     #
@@ -109,7 +125,9 @@ module Pptx
        Length.emu((EMU_PER_INCH * height_px / vert_dpi).to_i)]
     end
 
-    def inspect = "#<Pptx::Image #{format} #{width_px}x#{height_px} #{dpi.join("x")}dpi>"
+    def inspect
+      "#<Pptx::Image #{format} #{width_px}x#{height_px} #{dpi.join("x")}dpi>"
+    end
 
     private
 

data/lib/ruby_pptx/length.rb

@@ -30,16 +30,31 @@ module Pptx
 
     class << self
       # @param emu [Integer] distance in English Metric Units
-      def emu(emu) = new(emu)
+      def emu(emu)
+        new(emu)
+      end
+
+      def inches(inches)
+        new((inches * EMUS_PER_INCH).to_i)
+      end
+
+      def cm(cm)
+        new((cm * EMUS_PER_CM).to_i)
+      end
 
-      def inches(inches) = new((inches * EMUS_PER_INCH).to_i)
-      def cm(cm)         = new((cm * EMUS_PER_CM).to_i)
-      def mm(mm)         = new((mm * EMUS_PER_MM).to_i)
-      def pt(points)     = new((points * EMUS_PER_PT).to_i)
+      def mm(mm)
+        new((mm * EMUS_PER_MM).to_i)
+      end
+
+      def pt(points)
+        new((points * EMUS_PER_PT).to_i)
+      end
 
       # Hundredths of a point (1/7200 inch); the unit PowerPoint stores font
       # sizes in.
-      def centipoints(centipoints) = new((centipoints * EMUS_PER_CENTIPOINT).to_i)
+      def centipoints(centipoints)
+        new((centipoints * EMUS_PER_CENTIPOINT).to_i)
+      end
 
       # Coerce +value+ to a Length, treating a bare Integer as EMU.
       #
@@ -63,23 +78,48 @@ module Pptx
       freeze
     end
 
-    def inches = @emu / EMUS_PER_INCH.to_f
-    def cm     = @emu / EMUS_PER_CM.to_f
-    def mm     = @emu / EMUS_PER_MM.to_f
-    def pt     = @emu / EMUS_PER_PT.to_f
+    def inches
+      @emu / EMUS_PER_INCH.to_f
+    end
+
+    def cm
+      @emu / EMUS_PER_CM.to_f
+    end
+
+    def mm
+      @emu / EMUS_PER_MM.to_f
+    end
+
+    def pt
+      @emu / EMUS_PER_PT.to_f
+    end
 
     # @return [Integer] whole hundredths of a point, rounded toward negative infinity
-    def centipoints = @emu / EMUS_PER_CENTIPOINT
+    def centipoints
+      @emu / EMUS_PER_CENTIPOINT
+    end
 
-    def to_i = @emu
+    def to_i
+      @emu
+    end
     alias to_int to_i
 
-    def +(other) = Length.new(@emu + Length.coerce(other).emu)
-    def -(other) = Length.new(@emu - Length.coerce(other).emu)
-    def -@ = Length.new(-@emu)
+    def +(other)
+      Length.new(@emu + Length.coerce(other).emu)
+    end
+
+    def -(other)
+      Length.new(@emu - Length.coerce(other).emu)
+    end
+
+    def -@
+      Length.new(-@emu)
+    end
 
     # Scaling by a plain number; `length * 2` is twice as long.
-    def *(factor) = Length.new((@emu * factor).to_i)
+    def *(factor)
+      Length.new((@emu * factor).to_i)
+    end
 
     # Deliberately no #coerce, so `2 * length` raises rather than working.
     #
@@ -96,25 +136,52 @@ module Pptx
       @emu <=> other.emu
     end
 
-    def ==(other) = (self <=> other)&.zero? || false
+    def ==(other)
+      (self <=> other)&.zero? || false
+    end
     alias eql? ==
 
-    def hash = @emu.hash
+    def hash
+      @emu.hash
+    end
 
-    def zero? = @emu.zero?
+    def zero?
+      @emu.zero?
+    end
 
-    def to_s = "#{@emu}emu"
+    def to_s
+      "#{@emu}emu"
+    end
 
-    def inspect = "#<Pptx::Length #{@emu}emu (#{format("%g", inches)}in)>"
+    def inspect
+      "#<Pptx::Length #{@emu}emu (#{format("%g", inches)}in)>"
+    end
   end
 
   class << self
     # Convenience constructors, e.g. `Pptx.inches(1.5)`.
-    def emu(v)         = Length.emu(v)
-    def inches(v)      = Length.inches(v)
-    def cm(v)          = Length.cm(v)
-    def mm(v)          = Length.mm(v)
-    def pt(v)          = Length.pt(v)
-    def centipoints(v) = Length.centipoints(v)
+    def emu(v)
+      Length.emu(v)
+    end
+
+    def inches(v)
+      Length.inches(v)
+    end
+
+    def cm(v)
+      Length.cm(v)
+    end
+
+    def mm(v)
+      Length.mm(v)
+    end
+
+    def pt(v)
+      Length.pt(v)
+    end
+
+    def centipoints(v)
+      Length.centipoints(v)
+    end
   end
 end

data/lib/ruby_pptx/media.rb

@@ -28,7 +28,9 @@ module Pptx
 
     attr_reader :blob, :content_type
 
-    def self.from_blob(blob, content_type, filename = nil) = new(blob, content_type, filename)
+    def self.from_blob(blob, content_type, filename = nil)
+      new(blob, content_type, filename)
+    end
 
     # Load from a path or an IO stream.
     def self.from_file(movie_file, content_type)
@@ -55,10 +57,16 @@ module Pptx
     end
 
     # The name PowerPoint shows for the shape.
-    def filename = @source_filename || "movie.#{ext}"
+    def filename
+      @source_filename || "movie.#{ext}"
+    end
 
-    def sha1 = @sha1 ||= Digest::SHA1.hexdigest(@blob)
+    def sha1
+      @sha1 ||= Digest::SHA1.hexdigest(@blob)
+    end
 
-    def inspect = "#<Pptx::Video #{filename} #{@content_type}>"
+    def inspect
+      "#<Pptx::Video #{filename} #{@content_type}>"
+    end
   end
 end

data/lib/ruby_pptx/numeric_lengths.rb

@@ -14,17 +14,42 @@ module Pptx
   # Prefer the refinement. It is scoped to the file that asks for it, so it
   # cannot surprise another library that happens to share the process.
   module NumericLengths
-    def emu         = Pptx::Length.emu(self)
-    def inches      = Pptx::Length.inches(self)
-    def cm          = Pptx::Length.cm(self)
-    def mm          = Pptx::Length.mm(self)
-    def pt          = Pptx::Length.pt(self)
-    def centipoints = Pptx::Length.centipoints(self)
+    def emu
+      Pptx::Length.emu(self)
+    end
+
+    def inches
+      Pptx::Length.inches(self)
+    end
+
+    def cm
+      Pptx::Length.cm(self)
+    end
+
+    def mm
+      Pptx::Length.mm(self)
+    end
+
+    def pt
+      Pptx::Length.pt(self)
+    end
+
+    def centipoints
+      Pptx::Length.centipoints(self)
+    end
 
     # Spelled out rather than aliased: `import_methods`, which the refinement
     # uses to share these, cannot carry an alias across.
-    def inch   = inches
-    def points = pt
-    def point  = pt
+    def inch
+      inches
+    end
+
+    def points
+      pt
+    end
+
+    def point
+      pt
+    end
   end
 end

data/lib/ruby_pptx/opc/oxml.rb

@@ -20,9 +20,7 @@ module Pptx
       # to match what python-pptx (and lxml) produce, so packages compare
       # byte-for-byte.
       def self.serialize_part_xml(element)
-        node = element.is_a?(Element) ? element.node : element
-        body = node.to_xml(save_with: Nokogiri::XML::Node::SaveOptions::AS_XML |
-                                      Nokogiri::XML::Node::SaveOptions::NO_DECLARATION)
+        body = Element.wrap(element).to_xml
         %(<?xml version='1.0' encoding='UTF-8' standalone='yes'?>\n#{body})
       end
 
@@ -70,7 +68,9 @@ module Pptx
         optional_attr "TargetMode", type: ST::ST_TargetMode,
                                     default: RELATIONSHIP_TARGET_MODE::INTERNAL, as: :targetMode
 
-        def external? = targetMode == RELATIONSHIP_TARGET_MODE::EXTERNAL
+        def external?
+          targetMode == RELATIONSHIP_TARGET_MODE::EXTERNAL
+        end
       end
 
       # `<Relationships>`, the root of a `.rels` item.
@@ -92,7 +92,9 @@ module Pptx
         end
 
         # Bytes for a `.rels` item, with the XML declaration.
-        def xml_file_bytes = Oxml.serialize_part_xml(self)
+        def xml_file_bytes
+          Oxml.serialize_part_xml(self)
+        end
       end
     end
   end

data/lib/ruby_pptx/opc/pack_uri.rb

@@ -99,7 +99,9 @@ module Pptx
 
       # The part name without its leading slash -- the form used as the Zip
       # entry name.
-      def member_name = @to_s[1..]
+      def member_name
+        @to_s[1..]
+      end
 
       # A reference to this part relative to +base_uri+, as written into a
       # .rels part.
@@ -130,14 +132,22 @@ module Pptx
         @to_s <=> other.to_s
       end
 
-      def ==(other) = (self <=> other)&.zero? || false
+      def ==(other)
+        (self <=> other)&.zero? || false
+      end
       alias eql? ==
 
-      def hash = @to_s.hash
+      def hash
+        @to_s.hash
+      end
 
-      def to_str = @to_s
+      def to_str
+        @to_s
+      end
 
-      def inspect = "#<Pptx::Opc::PackURI #{@to_s.inspect}>"
+      def inspect
+        "#<Pptx::Opc::PackURI #{@to_s.inspect}>"
+      end
 
       PACKAGE       = new("/")
       CONTENT_TYPES = new("/[Content_Types].xml")

data/lib/ruby_pptx/opc/package.rb

@@ -15,7 +15,9 @@ module Pptx
       #
       # @raise [NotFoundError] when there is no such relationship
       # @raise [Error] when there is more than one
-      def part_related_by(reltype) = rels.part_with_reltype(reltype)
+      def part_related_by(reltype)
+        rels.part_with_reltype(reltype)
+      end
 
       # Relate this part to +target+, returning the rId. An existing matching
       # relationship is reused rather than duplicated.
@@ -29,12 +31,18 @@ module Pptx
         end
       end
 
-      def related_part(r_id) = rels.fetch(r_id).target_part
+      def related_part(r_id)
+        rels.fetch(r_id).target_part
+      end
 
-      def target_ref(r_id) = rels.fetch(r_id).target_ref
+      def target_ref(r_id)
+        rels.fetch(r_id).target_ref
+      end
 
       # @return [Relationships]
-      def rels = raise(NotImplementedError, "#{self.class} must implement #rels")
+      def rels
+        raise(NotImplementedError, "#{self.class} must implement #rels")
+      end
     end
 
     # An OPC package: the object graph behind a .pptx file.
@@ -43,18 +51,26 @@ module Pptx
 
       # Open a package from a path, an IO stream, or a directory holding an
       # unzipped package.
-      def self.open(pkg_file) = new(pkg_file).load
+      def self.open(pkg_file)
+        new(pkg_file).load
+      end
 
       def initialize(pkg_file = nil)
         @pkg_file = pkg_file
       end
 
-      def rels = @rels ||= Relationships.new(PackURI::PACKAGE.base_uri)
+      def rels
+        @rels ||= Relationships.new(PackURI::PACKAGE.base_uri)
+      end
 
-      def drop_rel(r_id) = rels.delete(r_id)
+      def drop_rel(r_id)
+        rels.delete(r_id)
+      end
 
       # The presentation part, which is the package's main document part.
-      def main_document_part = part_related_by(RELATIONSHIP_TYPE::OFFICE_DOCUMENT)
+      def main_document_part
+        part_related_by(RELATIONSHIP_TYPE::OFFICE_DOCUMENT)
+      end
 
       # Every part in the package, each yielded once.
       def parts
@@ -125,7 +141,9 @@ module Pptx
     # Loads a package from its serialized form.
     class PackageLoader
       # @return [Array(Oxml::CT_Relationships, Hash{String=>Part})]
-      def self.load(pkg_file, package) = new(pkg_file, package).load
+      def self.load(pkg_file, package)
+        new(pkg_file, package).load
+      end
 
       def initialize(pkg_file, package)
         @pkg_file = pkg_file
@@ -140,7 +158,9 @@ module Pptx
 
       private
 
-      def reader = @reader ||= PackageReader.new(@pkg_file)
+      def reader
+        @reader ||= PackageReader.new(@pkg_file)
+      end
 
       def content_types
         @content_types ||= ContentTypeMap.from_xml(reader[PackURI::CONTENT_TYPES])
@@ -199,7 +219,9 @@ module Pptx
 
       attr_reader :partname, :content_type, :package
 
-      def self.load(partname, content_type, package, blob) = new(partname, content_type, package, blob)
+      def self.load(partname, content_type, package, blob)
+        new(partname, content_type, package, blob)
+      end
 
       def initialize(partname, content_type, package, blob = nil)
         @partname = partname
@@ -215,19 +237,27 @@ module Pptx
       end
 
       # @return [String] the bytes this part serializes to
-      def blob = @blob || ""
+      def blob
+        @blob || ""
+      end
 
       attr_writer :blob
 
-      def rels = @rels ||= Relationships.new(@partname.base_uri)
+      def rels
+        @rels ||= Relationships.new(@partname.base_uri)
+      end
 
       def load_rels_from_xml(xml_rels, parts)
         rels.load_from_xml(@partname.base_uri, xml_rels, parts)
       end
 
-      def drop_rel(r_id) = rels.delete(r_id)
+      def drop_rel(r_id)
+        rels.delete(r_id)
+      end
 
-      def inspect = "#<#{self.class.name} #{@partname}>"
+      def inspect
+        "#<#{self.class.name} #{@partname}>"
+      end
     end
 
     # A part whose payload is XML, which is most of them.
@@ -243,11 +273,15 @@ module Pptx
         @element = element
       end
 
-      def blob = Oxml.serialize_part_xml(@element)
+      def blob
+        Oxml.serialize_part_xml(@element)
+      end
 
       # This part. Objects further down the tree delegate up to find the part
       # they live in; the chain ends here.
-      def part = self
+      def part
+        self
+      end
 
       # Drop a relationship unless the XML still refers to it more than once.
       #
@@ -274,12 +308,18 @@ module Pptx
           @part_type_for[content_type] = part_class
         end
 
-        def part_class_for(content_type) = @part_type_for.fetch(content_type, Part)
+        def part_class_for(content_type)
+          @part_type_for.fetch(content_type, Part)
+        end
 
-        def registered = @part_type_for.dup
+        def registered
+          @part_type_for.dup
+        end
 
         # Test seam: restore a previous registration table.
-        def reset!(to) = (@part_type_for = to)
+        def reset!(to)
+          (@part_type_for = to)
+        end
 
         def build(partname, content_type, package, blob)
           part_class_for(content_type).load(partname, content_type, package, blob)
@@ -325,21 +365,41 @@ module Pptx
         @rels = {}
       end
 
-      def each(&) = @rels.each_value(&)
+      def each(&)
+        @rels.each_value(&)
+      end
 
-      def each_value(&) = @rels.each_value(&)
+      def each_value(&)
+        @rels.each_value(&)
+      end
 
-      def [](r_id) = @rels[r_id]
+      def [](r_id)
+        @rels[r_id]
+      end
 
       def fetch(r_id)
         @rels.fetch(r_id) { raise NotFoundError, "no relationship with key #{r_id.inspect}" }
       end
 
-      def key?(r_id) = @rels.key?(r_id)
-      def keys = @rels.keys
-      def size = @rels.size
-      def empty? = @rels.empty?
-      def delete(r_id) = @rels.delete(r_id)
+      def key?(r_id)
+        @rels.key?(r_id)
+      end
+
+      def keys
+        @rels.keys
+      end
+
+      def size
+        @rels.size
+      end
+
+      def empty?
+        @rels.empty?
+      end
+
+      def delete(r_id)
+        @rels.delete(r_id)
+      end
 
       # The rId of a relationship of +reltype+ to +target_part+, adding one if
       # no match exists.
@@ -458,7 +518,9 @@ module Pptx
       end
 
       # True when the target is outside the package, such as a URL.
-      def external? = @target_mode == RELATIONSHIP_TARGET_MODE::EXTERNAL
+      def external?
+        @target_mode == RELATIONSHIP_TARGET_MODE::EXTERNAL
+      end
 
       def target_part
         raise Error, "#target_part is undefined for an external relationship" if external?
@@ -474,9 +536,13 @@ module Pptx
 
       # The reference as written into the `.rels` item: a relative partname
       # internally, or the URL for an external relationship.
-      def target_ref = external? ? @target : target_partname.relative_ref(@base_uri)
+      def target_ref
+        external? ? @target : target_partname.relative_ref(@base_uri)
+      end
 
-      def inspect = "#<Pptx::Opc::Relationship #{@r_id} #{@reltype}>"
+      def inspect
+        "#<Pptx::Opc::Relationship #{@r_id} #{@reltype}>"
+      end
     end
   end
 end

data/lib/ruby_pptx/opc/serialized.rb

@@ -20,11 +20,15 @@ module Pptx
       end
 
       # @return [Boolean] whether the package holds an item at +pack_uri+
-      def key?(pack_uri) = @reader.key?(pack_uri)
+      def key?(pack_uri)
+        @reader.key?(pack_uri)
+      end
 
       # @return [String] binary contents of the item at +pack_uri+
       # @raise [KeyError] when there is no such item
-      def [](pack_uri) = @reader[pack_uri]
+      def [](pack_uri)
+        @reader[pack_uri]
+      end
 
       # The XML of the `.rels` item belonging to +partname+, or nil when that
       # part has no relationships.
@@ -86,7 +90,9 @@ module Pptx
         @path = File.expand_path(path)
       end
 
-      def key?(pack_uri) = File.file?(path_for(pack_uri))
+      def key?(pack_uri)
+        File.file?(path_for(pack_uri))
+      end
 
       def [](pack_uri)
         File.binread(path_for(pack_uri))
@@ -115,7 +121,9 @@ module Pptx
         @pkg_file = pkg_file
       end
 
-      def key?(pack_uri) = blobs.key?(pack_uri.to_s)
+      def key?(pack_uri)
+        blobs.key?(pack_uri.to_s)
+      end
 
       def [](pack_uri)
         blobs.fetch(pack_uri.to_s) { raise KeyError, "no member #{pack_uri} in package" }
@@ -132,9 +140,11 @@ module Pptx
       def each_entry(&block)
         return enum_for(:each_entry) unless block
 
+        # get_input_stream without a block opens a file handle per member and
+        # leaves it for GC; on Windows that keeps the .pptx locked after open.
         open_zip do |zip|
           zip.each do |entry|
-            block.call(entry.name, entry.get_input_stream.read) if entry.file?
+            block.call(entry.name, entry.get_input_stream(&:read)) if entry.file?
           end
         end
       end