ruby_pptx 0.1.0

data/lib/ruby_pptx/oxml/text.rb

@@ -0,0 +1,324 @@
+# frozen_string_literal: true
+
+require "ruby_pptx/oxml/element"
+require "ruby_pptx/oxml/content_model"
+require "ruby_pptx/oxml/simple_types"
+require "ruby_pptx/oxml/dml/fill"
+require "ruby_pptx/enum/text"
+require "ruby_pptx/enum/lang"
+
+module Pptx
+  module Oxml
+    # The fill choice and its successor list, shared by run properties and
+    # shape properties.
+    FILL_CHOICES = %w[a:noFill a:solidFill a:gradFill a:blipFill a:pattFill a:grpFill].freeze
+
+    # `a:t`, the literal text of a run.
+    class CT_TextCharacterText < Element
+      tag "a:t"
+    end
+
+    # `a:r`, a run: a span of text sharing one set of character properties.
+    class CT_RegularTextRun < Element
+      tag "a:r"
+      zero_or_one "a:rPr", successors: %w[a:t]
+      one_and_only_one "a:t"
+
+      def text = t.text
+
+      def text=(value)
+        t.text = CT_RegularTextRun.escape_control_chars(value.to_s)
+      end
+
+      # XML 1.0 cannot carry most control characters, so PowerPoint writes
+      # them as a literal escape like "_x0007_". Tab and line-feed are legal
+      # and pass through unchanged.
+      def self.escape_control_chars(string)
+        string.gsub(/([\x00-\x08\x0B-\x1F])/) { format("_x%04X_", ::Regexp.last_match(1).ord) }
+      end
+    end
+
+    # `a:br`, a soft line break within a paragraph.
+    class CT_TextLineBreak < Element
+      tag "a:br"
+      zero_or_one "a:rPr", successors: []
+
+      # A break carries no text of its own; it *is* the line feed, which we
+      # report as a vertical tab to match how PowerPoint puts it on the
+      # clipboard.
+      def text = "\v"
+    end
+
+    # `a:fld`, a slide-number or date field.
+    class CT_TextField < Element
+      tag "a:fld"
+      zero_or_one "a:rPr", successors: %w[a:pPr a:t]
+      zero_or_one "a:t", successors: []
+
+      def text = t&.text.to_s
+    end
+
+    # `a:latin`, `a:ea`, `a:cs` and `a:sym`: a typeface reference.
+    class CT_TextFont < Element
+      tag "a:latin", "a:ea", "a:cs", "a:sym"
+      required_attr "typeface", type: SimpleTypes::ST_TextTypeface
+    end
+
+    # `a:rPr`, `a:defRPr` and `a:endParaRPr`: character properties.
+    class CT_TextCharacterProperties < Element
+      tag "a:rPr", "a:defRPr", "a:endParaRPr"
+
+      FILL_SUCCESSORS = %w[a:effectLst a:effectDag a:highlight a:uLnTx a:uLn
+                           a:uFillTx a:uFill a:latin a:ea a:cs a:sym
+                           a:hlinkClick a:hlinkMouseOver a:rtl a:extLst].freeze
+
+      zero_or_one_choice FILL_CHOICES.map { |t| choice(t) },
+                         successors: FILL_SUCCESSORS, as: :eg_fillProperties
+      zero_or_one "a:latin",
+                  successors: %w[a:ea a:cs a:sym a:hlinkClick a:hlinkMouseOver a:rtl a:extLst]
+      zero_or_one "a:hlinkClick", successors: %w[a:hlinkMouseOver a:rtl a:extLst]
+
+      optional_attr "lang", type: Enum::MSO_LANGUAGE_ID
+      optional_attr "sz", type: SimpleTypes::ST_TextFontSize
+      optional_attr "b", type: SimpleTypes::XsdBoolean
+      optional_attr "i", type: SimpleTypes::XsdBoolean
+      optional_attr "u", type: Enum::MSO_TEXT_UNDERLINE_TYPE
+
+      def new_gradFill = CT_GradientFillProperties.new_grad_fill(self)
+    end
+
+    # `a:bodyPr`, the properties of a text body: margins, anchoring, autofit.
+    class CT_TextBodyProperties < Element
+      tag "a:bodyPr"
+
+      zero_or_one_choice [choice("a:noAutofit"), choice("a:normAutofit"), choice("a:spAutoFit")],
+                         successors: %w[a:scene3d a:sp3d a:flatTx a:extLst], as: :eg_textAutoFit
+
+      optional_attr "lIns", type: SimpleTypes::ST_Coordinate32, default: Pptx::Length.emu(91_440)
+      optional_attr "tIns", type: SimpleTypes::ST_Coordinate32, default: Pptx::Length.emu(45_720)
+      optional_attr "rIns", type: SimpleTypes::ST_Coordinate32, default: Pptx::Length.emu(91_440)
+      optional_attr "bIns", type: SimpleTypes::ST_Coordinate32, default: Pptx::Length.emu(45_720)
+      optional_attr "anchor", type: Enum::MSO_VERTICAL_ANCHOR
+      optional_attr "wrap", type: SimpleTypes::ST_TextWrappingType
+
+      # @return [Pptx::Enum::MSO_AUTO_SIZE, nil] nil when inherited
+      def autofit
+        return Enum::MSO_AUTO_SIZE::NONE unless find("a:noAutofit").nil?
+        return Enum::MSO_AUTO_SIZE::TEXT_TO_FIT_SHAPE unless find("a:normAutofit").nil?
+        return Enum::MSO_AUTO_SIZE::SHAPE_TO_FIT_TEXT unless find("a:spAutoFit").nil?
+
+        nil
+      end
+
+      def autofit=(value)
+        remove_eg_textAutoFit
+        return if value.nil?
+
+        member = Enum::MSO_AUTO_SIZE.fetch(value)
+        case member.name
+        when :NONE then add_noAutofit
+        when :TEXT_TO_FIT_SHAPE then add_normAutofit
+        when :SHAPE_TO_FIT_TEXT then add_spAutoFit
+        else
+          raise ArgumentError, "#{member} cannot be assigned as an autofit setting"
+        end
+      end
+    end
+
+    # `a:normAutofit`, shrink-text-on-overflow with its font scale.
+    class CT_TextNormalAutofit < Element
+      tag "a:normAutofit"
+      optional_attr "fontScale", type: SimpleTypes::ST_TextFontScalePercentOrPercentString,
+                                 default: 100.0
+    end
+
+    # `a:spcPct`, spacing as a multiple of line height.
+    class CT_TextSpacingPercent < Element
+      tag "a:spcPct"
+      required_attr "val", type: SimpleTypes::ST_TextSpacingPercentOrPercentString
+    end
+
+    # `a:spcPts`, spacing as a fixed distance.
+    class CT_TextSpacingPoint < Element
+      tag "a:spcPts"
+      required_attr "val", type: SimpleTypes::ST_TextSpacingPoint
+    end
+
+    # `a:lnSpc`, `a:spcBef` and `a:spcAft`: a spacing value, expressed either
+    # as a multiple of line height or as a fixed distance.
+    class CT_TextSpacing < Element
+      tag "a:lnSpc", "a:spcBef", "a:spcAft"
+      # Strictly a one-and-only-one choice; modelling it as two optional
+      # children is simpler and the setters keep only one present.
+      zero_or_one "a:spcPct", successors: []
+      zero_or_one "a:spcPts", successors: []
+
+      # Spacing as a multiple of line height, e.g. 1.75 lines.
+      def set_spc_pct(value)
+        remove_spcPts
+        get_or_add_spcPct.val = value
+      end
+
+      # Spacing as a fixed distance.
+      def set_spc_pts(value)
+        remove_spcPct
+        get_or_add_spcPts.val = value
+      end
+    end
+
+    # `a:pPr`, paragraph properties.
+    class CT_TextParagraphProperties < Element
+      tag "a:pPr"
+      TAG_SEQ = %w[a:lnSpc a:spcBef a:spcAft a:buClrTx a:buClr a:buSzTx a:buSzPct
+                   a:buSzPts a:buFontTx a:buFont a:buNone a:buAutoNum a:buChar
+                   a:buBlip a:tabLst a:defRPr a:extLst].freeze
+
+      zero_or_one "a:lnSpc", successors: TAG_SEQ[1..]
+      zero_or_one "a:spcBef", successors: TAG_SEQ[2..]
+      zero_or_one "a:spcAft", successors: TAG_SEQ[3..]
+      zero_or_one "a:defRPr", successors: TAG_SEQ[16..]
+      optional_attr "lvl", type: SimpleTypes::ST_TextIndentLevelType, default: 0
+      optional_attr "algn", type: Enum::PP_PARAGRAPH_ALIGNMENT
+
+      # A Float means a number of lines; a {Pptx::Length} means a fixed
+      # distance. nil when no spacing is set.
+      def line_spacing
+        spacing = lnSpc
+        return nil if spacing.nil?
+
+        spacing.spcPts ? spacing.spcPts.val : spacing.spcPct&.val
+      end
+
+      def line_spacing=(value)
+        remove_lnSpc
+        return if value.nil?
+
+        spacing = get_or_add_lnSpc
+        value.is_a?(Pptx::Length) ? spacing.set_spc_pts(value) : spacing.set_spc_pct(value)
+      end
+
+      def space_before = spcBef&.spcPts&.val
+
+      def space_before=(value)
+        remove_spcBef
+        get_or_add_spcBef.set_spc_pts(value) unless value.nil?
+      end
+
+      def space_after = spcAft&.spcPts&.val
+
+      def space_after=(value)
+        remove_spcAft
+        get_or_add_spcAft.set_spc_pts(value) unless value.nil?
+      end
+    end
+
+    # `a:p`, a paragraph.
+    class CT_TextParagraph < Element
+      tag "a:p"
+      zero_or_one "a:pPr", successors: %w[a:r a:br a:fld a:endParaRPr]
+      zero_or_more "a:r", successors: %w[a:endParaRPr], as: :r
+      zero_or_more "a:br", successors: %w[a:endParaRPr], as: :br
+      zero_or_one "a:endParaRPr", successors: []
+
+      CONTENT_TAGS = %w[a:r a:br a:fld].freeze
+
+      # A run is created with its required `a:t` already in place.
+      def new_r = build_from_xml(%(<a:r #{Ns.nsdecls("a")}><a:t/></a:r>))
+
+      def add_run(text = nil)
+        run = add_r
+        run.text = text if text && !text.empty?
+        run
+      end
+
+      def add_line_break = add_br
+
+      # Append +text+ as runs, turning each "\n" or "\v" into a line break.
+      #
+      # Breaks go *between* items, so leading text never produces one, and an
+      # empty segment contributes no run.
+      def append_text(text)
+        text.to_s.split(/[\n\v]/, -1).each_with_index do |segment, index|
+          add_line_break if index.positive?
+          add_run(segment) unless segment.empty?
+        end
+        self
+      end
+
+      # The `a:r`, `a:br` and `a:fld` children, in document order.
+      def content_children
+        tags = CONTENT_TAGS.map { |t| Ns.qn(t) }
+        @node.element_children
+             .select { |c| tags.include?(Ns.clark_name_of(c)) }
+             .map { |c| Element.wrap(c) }
+      end
+
+      def text = content_children.map(&:text).join
+    end
+
+    # `p:txBody`, `a:txBody` and `c:txPr`: a body of text.
+    class CT_TextBody < Element
+      # `c:rich` is a text body under a different name: it is what a chart or
+      # axis title holds.
+      tag "p:txBody", "a:txBody", "c:txPr", "c:rich"
+      one_and_only_one "a:bodyPr"
+      one_or_more "a:p", successors: [], as: :p
+
+      # A chart's `c:txPr` holds a paragraph for its formatting alone; the
+      # default run properties of that first paragraph are where a chart,
+      # axis, legend or data-label font lives.
+      def defRPr = p_list.first.get_or_add_pPr.get_or_add_defRPr
+
+      # The `c:txPr` a chart element gains when its font is first set.
+      TXPR_XML = <<~XML.freeze
+        <c:txPr #{Ns.nsdecls("c", "a")}>
+          <a:bodyPr/>
+          <a:lstStyle/>
+          <a:p>
+            <a:pPr>
+              <a:defRPr/>
+            </a:pPr>
+          </a:p>
+        </c:txPr>
+      XML
+
+      class << self
+        # A `p:txBody` with one empty paragraph, built in +context+'s document.
+        def new_element(context) = context.build_from_xml(txbody_xml)
+
+        # A standalone `p:txBody`, for callers with no element to build from.
+        def parse_new = Element.parse(txbody_xml)
+
+        def txbody_xml
+          <<~XML
+            <p:txBody #{Ns.nsdecls("a", "p")}>
+              <a:bodyPr/>
+              <a:lstStyle/>
+              <a:p/>
+            </p:txBody>
+          XML
+        end
+      end
+
+      # Remove every paragraph, leaving any other children alone.
+      def clear_content
+        p_list.each { |paragraph| remove(paragraph) }
+        self
+      end
+
+      # Restore the minimum the schema requires: at least one paragraph.
+      def unclear_content
+        add_p if p_list.empty?
+        self
+      end
+
+      # True when the body holds a single empty paragraph.
+      def empty?
+        paragraphs = p_list
+        raise InvalidXmlError, "a text body must have at least one a:p" if paragraphs.empty?
+
+        paragraphs.size == 1 && paragraphs.first.text.empty?
+      end
+    end
+  end
+end

data/lib/ruby_pptx/oxml/theme.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "ruby_pptx/oxml/element"
+require "ruby_pptx/oxml/content_model"
+require "ruby_pptx/oxml/simple_types"
+require "ruby_pptx/oxml/dml/color"
+require "ruby_pptx/oxml/text"
+
+module Pptx
+  module Oxml
+    # `a:theme`, the root of a theme part.
+    #
+    # Only the parts a caller can reasonably edit are modelled: the colour
+    # scheme and the font scheme. The format scheme -- fills, lines, effects
+    # and background fills, keyed by the `idx` values that shapes and slide
+    # backgrounds refer to -- is carried through from the base theme unchanged.
+    # See PORTING.md for why.
+    class CT_OfficeStyleSheet < Element
+      tag "a:theme"
+      one_and_only_one "a:themeElements"
+      required_attr "name", type: SimpleTypes::XsdString
+
+      def self.new_default = Oxml.parse_from_template("theme")
+
+      def clrScheme = themeElements.clrScheme
+      def fontScheme = themeElements.fontScheme
+    end
+
+    # `a:themeElements`, the four schemes that make up a theme.
+    class CT_BaseStyles < Element
+      tag "a:themeElements"
+      one_and_only_one "a:clrScheme"
+      one_and_only_one "a:fontScheme"
+      one_and_only_one "a:fmtScheme"
+    end
+
+    # `a:clrScheme`, the twelve theme colours.
+    class CT_ColorScheme < Element
+      tag "a:clrScheme"
+      required_attr "name", type: SimpleTypes::XsdString
+
+      # In schema order, which is also the order PowerPoint shows them in.
+      SLOTS = %w[dk1 lt1 dk2 lt2 accent1 accent2 accent3 accent4 accent5
+                 accent6 hlink folHlink].freeze
+
+      SLOTS.each do |slot|
+        one_and_only_one "a:#{slot}"
+      end
+
+      def slot(name)
+        raise NotFoundError, "no theme colour named #{name}" unless SLOTS.include?(name.to_s)
+
+        send(name.to_s)
+      end
+    end
+
+    # One slot of a colour scheme, such as `a:accent1`.
+    #
+    # Every slot holds the same six-way colour choice as any other colour in
+    # DrawingML, so {Pptx::ColorFormat} drives them unchanged.
+    class CT_ThemeColor < Element
+      include ColorChoice
+
+      tag(*CT_ColorScheme::SLOTS.map { |slot| "a:#{slot}" })
+    end
+
+    # `a:fontScheme`, the major (heading) and minor (body) font collections.
+    class CT_FontScheme < Element
+      tag "a:fontScheme"
+      required_attr "name", type: SimpleTypes::XsdString
+      one_and_only_one "a:majorFont"
+      one_and_only_one "a:minorFont"
+    end
+
+    # `a:majorFont` and `a:minorFont`.
+    #
+    # The Latin typeface is the one that matters here; the East Asian and
+    # complex-script slots are required by the schema and are left as the base
+    # theme has them unless set.
+    class CT_FontCollection < Element
+      tag "a:majorFont", "a:minorFont"
+      one_and_only_one "a:latin"
+      one_and_only_one "a:ea"
+      one_and_only_one "a:cs"
+
+      def typeface = latin.typeface
+
+      def typeface=(value)
+        latin.typeface = value
+      end
+    end
+  end
+end

data/lib/ruby_pptx/package.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "ruby_pptx/opc/package"
+require "ruby_pptx/opc/constants"
+require "ruby_pptx/parts/core_properties"
+require "ruby_pptx/parts/media"
+require "ruby_pptx/parts/presentation"
+require "ruby_pptx/parts/slide"
+require "ruby_pptx/parts/theme"
+
+module Pptx
+  # A .pptx package: an OPC package that knows about PowerPoint's parts.
+  class Package < Opc::OpcPackage
+    # The core-properties part, created if the package has none.
+    def core_properties
+      @core_properties ||= begin
+        part_related_by(Opc::RELATIONSHIP_TYPE::CORE_PROPERTIES)
+      rescue NotFoundError
+        Parts::CorePropertiesPart.default(self).tap do |part|
+          relate_to(part, Opc::RELATIONSHIP_TYPE::CORE_PROPERTIES)
+        end
+      end
+    end
+
+    def presentation_part = main_document_part
+
+    # The media part holding +video+, created if the package has no part with
+    # the same content. Matched by SHA-1, as images are.
+    def get_or_add_media_part(video)
+      find_media_part(video.sha1) || Parts::MediaPart.new_media(self, video)
+    end
+
+    # The image part holding +image_file+, created if the package has no part
+    # with the same content.
+    #
+    # Images are matched by SHA-1 of their bytes, so the same picture used on
+    # several slides is stored once.
+    def get_or_add_image_part(image_file)
+      image = Image.from_file(image_file)
+      find_image_part(image.sha1) || Parts::ImagePart.new_image(self, image)
+    end
+
+    # The next free `/ppt/media/imageN.<ext>` partname, reusing gaps.
+    def next_image_partname(ext) = next_media_like_partname("image", ext)
+
+    # The next free `/ppt/media/mediaN.<ext>` partname, reusing gaps.
+    def next_media_partname(ext) = next_media_like_partname("media", ext)
+
+    private
+
+    def find_media_part(sha1)
+      media_parts.find { |part| part.respond_to?(:sha1) && part.sha1 == sha1 }
+    end
+
+    # Parts reached by a media relationship, each once.
+    def media_parts
+      seen = {}.compare_by_identity
+      each_rel.filter_map do |rel|
+        next if rel.external? || rel.reltype != Opc::RELATIONSHIP_TYPE::MEDIA
+
+        part = rel.target_part
+        next if seen.key?(part)
+
+        seen[part] = true
+        part
+      end
+    end
+
+    def find_image_part(sha1)
+      image_parts.find { |part| part.respond_to?(:sha1) && part.sha1 == sha1 }
+    end
+
+    # Parts reached by an image relationship, each once.
+    #
+    # Scoped by relationship rather than by class on purpose: the package
+    # thumbnail is also an image part, but it is related as a thumbnail, and
+    # matching a new picture against it would relate the picture by the wrong
+    # reltype.
+    def image_parts
+      seen = {}.compare_by_identity
+      each_rel.filter_map do |rel|
+        next if rel.external? || rel.reltype != Opc::RELATIONSHIP_TYPE::IMAGE
+
+        part = rel.target_part
+        next if seen.key?(part)
+
+        seen[part] = true
+        part
+      end
+    end
+
+    def next_media_like_partname(stem, ext)
+      prefix = "/ppt/media/#{stem}"
+      indexes = parts.filter_map do |part|
+        name = part.partname.to_s
+        part.partname.idx if name.start_with?(prefix)
+      end.sort
+
+      idx = indexes.each_with_index.find { |used, i| (i + 1) < used }&.last&.succ ||
+            (indexes.size + 1)
+      Opc::PackURI.new("#{prefix}#{idx}.#{ext}")
+    end
+  end
+end
+
+# Register the part classes for the content types this library models. Anything
+# not listed here loads as a plain Opc::Part, which is enough to carry it
+# through a round-trip untouched.
+{
+  Pptx::Opc::CONTENT_TYPE::PML_PRESENTATION_MAIN => Pptx::Parts::PresentationPart,
+  Pptx::Opc::CONTENT_TYPE::PML_PRES_MACRO_MAIN => Pptx::Parts::PresentationPart,
+  Pptx::Opc::CONTENT_TYPE::PML_SLIDE => Pptx::Parts::SlidePart,
+  Pptx::Opc::CONTENT_TYPE::PML_SLIDE_LAYOUT => Pptx::Parts::SlideLayoutPart,
+  Pptx::Opc::CONTENT_TYPE::PML_SLIDE_MASTER => Pptx::Parts::SlideMasterPart,
+  Pptx::Opc::CONTENT_TYPE::PML_NOTES_MASTER => Pptx::Parts::NotesMasterPart,
+  Pptx::Opc::CONTENT_TYPE::OFC_THEME => Pptx::Parts::ThemePart,
+  Pptx::Opc::CONTENT_TYPE::PML_NOTES_SLIDE => Pptx::Parts::NotesSlidePart,
+  Pptx::Opc::CONTENT_TYPE::OPC_CORE_PROPERTIES => Pptx::Parts::CorePropertiesPart,
+  Pptx::Opc::CONTENT_TYPE::PNG => Pptx::Parts::ImagePart,
+  Pptx::Opc::CONTENT_TYPE::JPEG => Pptx::Parts::ImagePart,
+  Pptx::Opc::CONTENT_TYPE::GIF => Pptx::Parts::ImagePart,
+  Pptx::Opc::CONTENT_TYPE::BMP => Pptx::Parts::ImagePart,
+  Pptx::Opc::CONTENT_TYPE::TIFF => Pptx::Parts::ImagePart,
+  Pptx::Opc::CONTENT_TYPE::MS_PHOTO => Pptx::Parts::ImagePart,
+  Pptx::Opc::CONTENT_TYPE::X_EMF => Pptx::Parts::ImagePart,
+  Pptx::Opc::CONTENT_TYPE::X_WMF => Pptx::Parts::ImagePart,
+  Pptx::Opc::CONTENT_TYPE::DML_CHART => Pptx::Parts::ChartPart,
+  Pptx::Opc::CONTENT_TYPE::SML_SHEET => Pptx::Parts::EmbeddedXlsxPart,
+  Pptx::Opc::CONTENT_TYPE::ASF => Pptx::Parts::MediaPart,
+  Pptx::Opc::CONTENT_TYPE::AVI => Pptx::Parts::MediaPart,
+  Pptx::Opc::CONTENT_TYPE::MOV => Pptx::Parts::MediaPart,
+  Pptx::Opc::CONTENT_TYPE::MP4 => Pptx::Parts::MediaPart,
+  Pptx::Opc::CONTENT_TYPE::MPG => Pptx::Parts::MediaPart,
+  Pptx::Opc::CONTENT_TYPE::MS_VIDEO => Pptx::Parts::MediaPart,
+  Pptx::Opc::CONTENT_TYPE::SWF => Pptx::Parts::MediaPart,
+  Pptx::Opc::CONTENT_TYPE::VIDEO => Pptx::Parts::MediaPart,
+  Pptx::Opc::CONTENT_TYPE::WMV => Pptx::Parts::MediaPart,
+  Pptx::Opc::CONTENT_TYPE::X_MS_VIDEO => Pptx::Parts::MediaPart
+}.each { |content_type, part_class| Pptx::Opc::PartFactory.register(content_type, part_class) }

data/lib/ruby_pptx/parts/chart.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "ruby_pptx/opc/package"
+require "ruby_pptx/opc/constants"
+require "ruby_pptx/oxml/chart"
+require "ruby_pptx/chart/chart"
+
+module Pptx
+  module Parts
+    # Another OPC package embedded inside this one -- here, the Excel workbook
+    # that backs a chart.
+    class EmbeddedXlsxPart < Opc::Part
+      PARTNAME_TEMPLATE = "/ppt/embeddings/Microsoft_Excel_Sheet%d.xlsx"
+
+      def self.new_xlsx(blob, package)
+        new(package.next_partname(PARTNAME_TEMPLATE),
+            Opc::CONTENT_TYPE::SML_SHEET, package, blob)
+      end
+    end
+
+    # A chart part, `/ppt/charts/chartN.xml`.
+    class ChartPart < Opc::XmlPart
+      PARTNAME_TEMPLATE = "/ppt/charts/chart%d.xml"
+
+      # A new chart part depicting +chart_data+, together with the embedded
+      # workbook that backs it.
+      def self.new_chart(chart_type, chart_data, package)
+        part = load(package.next_partname(PARTNAME_TEMPLATE), Opc::CONTENT_TYPE::DML_CHART,
+                    package, ChartXmlWriter.write(chart_type, chart_data))
+        part.workbook.replace_with(chart_data.xlsx_blob)
+        part
+      end
+
+      # A chart part drawing several plots over the same categories.
+      def self.new_combo_chart(builder, package)
+        part = load(package.next_partname(PARTNAME_TEMPLATE), Opc::CONTENT_TYPE::DML_CHART,
+                    package, ComboChartWriter.new(builder.validate!).xml)
+        part.workbook.replace_with(builder.chart_data.xlsx_blob)
+        part
+      end
+
+      def chart = @chart ||= Chart.new(element, self)
+
+      def workbook = @workbook ||= ChartWorkbook.new(element, self)
+    end
+
+    # The embedded workbook behind a chart.
+    class ChartWorkbook
+      def initialize(chart_space, chart_part)
+        @chart_space = chart_space
+        @chart_part = chart_part
+      end
+
+      # @return [EmbeddedXlsxPart, nil]
+      def xlsx_part
+        r_id = @chart_space.xlsx_part_rId
+        r_id && @chart_part.related_part(r_id)
+      end
+
+      # Put +xlsx_blob+ behind this chart, adding the part and the
+      # `c:externalData` link if the chart does not have one yet.
+      def replace_with(xlsx_blob)
+        existing = xlsx_part
+        return existing.blob = xlsx_blob if existing
+
+        part = EmbeddedXlsxPart.new_xlsx(xlsx_blob, @chart_part.package)
+        r_id = @chart_part.relate_to(part, Opc::RELATIONSHIP_TYPE::PACKAGE)
+        external_data = @chart_space.get_or_add_externalData
+        external_data.rId = r_id
+        external_data.ensure_auto_update
+        part
+      end
+    end
+  end
+end

data/lib/ruby_pptx/parts/core_properties.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "ruby_pptx/opc/package"
+require "ruby_pptx/opc/constants"
+require "ruby_pptx/oxml/core_properties"
+
+module Pptx
+  module Parts
+    # `/docProps/core.xml`, the Dublin Core metadata for the package.
+    #
+    # Reads and writes are delegated straight to the root element, so this
+    # class is mostly a named home for them.
+    class CorePropertiesPart < Opc::XmlPart
+      DELEGATED = (Oxml::CT_CoreProperties::TEXT_PROPERTIES.keys +
+                   Oxml::CT_CoreProperties::DATETIME_PROPERTIES.keys +
+                   [:revision]).freeze
+
+      DELEGATED.each do |name|
+        define_method(name) { element.public_send(name) }
+        define_method("#{name}=") { |value| element.public_send("#{name}=", value) }
+      end
+
+      # A core-properties part for a package that has none, matching what
+      # PowerPoint would write for a new presentation.
+      def self.default(package)
+        part = new(
+          Opc::PackURI.new("/docProps/core.xml"),
+          Opc::CONTENT_TYPE::OPC_CORE_PROPERTIES,
+          package,
+          Oxml::CT_CoreProperties.new_element
+        )
+        part.title = "PowerPoint Presentation"
+        part.last_modified_by = "ruby_pptx"
+        part.revision = 1
+        part.modified = Time.now.utc
+        part
+      end
+    end
+  end
+end