goldendocx 0.2.2

data/lib/goldendocx/documents/relationship.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Documents
+    class Relationship
+      include Goldendocx::Element
+
+      attr_reader :id, :type, :target
+
+      tag :Relationship
+
+      attribute :id, alias_name: :Id
+      attribute :type, alias_name: :Type
+      attribute :target, alias_name: :Target
+    end
+  end
+end

data/lib/goldendocx/documents/relationships.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Documents
+    class Relationships
+      include Goldendocx::Document
+
+      XML_PATH = 'word/_rels/document.xml.rels'
+      NAMESPACE = 'http://schemas.openxmlformats.org/package/2006/relationships'
+
+      tag :Relationships
+      attribute :xmlns, default: NAMESPACE, readonly: true
+
+      embeds_many :relationships, class_name: 'Goldendocx::Documents::Relationship'
+
+      def size
+        relationships.size
+      end
+
+      def read_from(docx_file)
+        paths = %w[Relationships Relationship]
+        Goldendocx.xml_serializer.parse(docx_file.read(XML_PATH), paths).map do |node|
+          build_relationship(id: node[:Id], type: node[:Type], target: node[:Target])
+        end
+      end
+
+      def write_to(zos)
+        zos.put_next_entry XML_PATH
+        zos.write to_document_xml
+      end
+
+      def add_relationship(type, target)
+        relationship_id = "rId#{relationships.size + 1}"
+        build_relationship(id: relationship_id, type: type, target: target)
+        relationship_id
+      end
+    end
+  end
+end

data/lib/goldendocx/documents/style.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Documents
+    class Style
+      attr_reader :node, :id, :type, :name
+
+      def initialize(node)
+        @node = node
+        @id = node['w:styleId']
+        @type = node['w:type']
+        @name = node.public_send(:'w:name')['w:val']
+        @default = node['w:default']
+      end
+
+      def to_element(**_context)
+        @node
+      end
+    end
+  end
+end

data/lib/goldendocx/documents/styles.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Documents
+    class Styles
+      include Goldendocx::Document
+
+      XML_PATH = 'word/styles.xml'
+
+      tag :styles
+      namespace :w
+      concern_namespaces :mc, :r, :w, :w14, :w15
+      ignore_namespaces :w14, :w15
+
+      attr_reader :styles, :doc_defaults, :latent_styles
+
+      def initialize
+        @styles = []
+      end
+
+      def size
+        styles.size
+      end
+
+      def read_from(docx_file)
+        @styles = Goldendocx.xml_serializer.parse(docx_file.read(XML_PATH), %w[w:styles w:style]).map do |node|
+          Goldendocx::Documents::Style.new(node)
+        end
+        @doc_defaults = Goldendocx.xml_serializer.parse(docx_file.read(XML_PATH), %w[w:styles w:docDefaults]).map do |node|
+          Goldendocx::Documents::UnparsedStyle.new(node)
+        end
+        @latent_styles = Goldendocx.xml_serializer.parse(docx_file.read(XML_PATH), %w[w:styles w:latentStyles]).map do |node|
+          Goldendocx::Documents::UnparsedStyle.new(node)
+        end
+      end
+
+      def to_document_xml
+        super do |xml|
+          @doc_defaults&.each { |element| xml << element }
+          @latent_styles&.each { |element| xml << element }
+          styles.each { |style| xml << style }
+        end
+      end
+
+      def write_to(zos)
+        zos.put_next_entry XML_PATH
+        zos.write to_document_xml
+      end
+
+      def find_text_style(style_name)
+        return if style_name.nil?
+
+        styles.find { |s| s.type == 'paragraph' && s.name == style_name }
+      end
+
+      def find_table_style(style_name)
+        return if style_name.nil?
+
+        styles.find { |s| s.type == 'table' && s.name == style_name }
+      end
+
+      def add_style(fragment)
+        # FIXME: Not a good implementation for Nokogiri compatibility
+        raise NotImplementedError unless Goldendocx.config.xml_serializer == :ox
+
+        style_id = (@styles.size + 1).to_s
+        style = Goldendocx.xml_serializer.parse(fragment)
+        style['w:styleId'] = style_id if style['w:styleId'].nil? || style['w:styleId'].empty?
+        @styles << Goldendocx::Documents::Style.new(style)
+        style_id
+      end
+    end
+  end
+end

data/lib/goldendocx/documents/unparsed_style.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Documents
+    class UnparsedStyle
+      attr_reader :node
+
+      def initialize(node)
+        @node = node
+      end
+
+      def to_element(**_context)
+        @node
+      end
+    end
+  end
+end

data/lib/goldendocx/documents.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Documents
+  end
+end
+
+Dir.glob(File.join(File.dirname(__FILE__), 'documents', '*.rb').to_s).sort.each do |file|
+  require file
+end

data/lib/goldendocx/docx.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'goldendocx/units'
+require 'goldendocx/element'
+require 'goldendocx/document'
+
+require 'goldendocx/components'
+require 'goldendocx/documents'
+require 'goldendocx/parts'
+
+module Goldendocx
+  class Docx
+    attr_reader :unstructured_entries, :documents, :content_types
+
+    STRUCTURED_ENTRIES = [
+      Goldendocx::Parts::ContentTypes::XML_PATH,
+
+      Goldendocx::Documents::Body::XML_PATH,
+      Goldendocx::Documents::Relationships::XML_PATH,
+      Goldendocx::Documents::Styles::XML_PATH
+    ].freeze
+
+    def initialize(file_path)
+      docx_file = Zip::File.new(file_path)
+      @documents = Goldendocx::Parts::Documents.read_from(docx_file)
+      @content_types = Goldendocx::Parts::ContentTypes.read_from(docx_file)
+      @unstructured_entries = docx_file.entries.filter_map do |entry|
+        UnStructuredEntry.new(entry) unless STRUCTURED_ENTRIES.include?(entry.name)
+      end
+    end
+
+    def write_to(new_path)
+      File.binwrite(new_path, to_stream.string)
+    end
+
+    def create_text(text, options = {})
+      documents.create_text(text, options)
+    end
+
+    def create_table(options = {})
+      documents.create_table(options)
+    end
+
+    def create_image(image_data, options = {})
+      ensure_image_content_type!(image_data)
+      documents.create_image(image_data, options)
+    end
+
+    def create_embed_image(image_data, options = {})
+      ensure_image_content_type!(image_data)
+      documents.create_embed_image(image_data, options)
+    end
+
+    def add_style(style_path)
+      documents.add_style(style_path)
+    end
+
+    def create_chart(chart_type, width: nil, height: nil)
+      chart = documents.create_chart(
+        chart_type, width || Charts::DEFAULT_WIDTH, height || Charts::DEFAULT_HEIGHT
+      )
+      ensure_chart_content_type!(chart)
+      chart
+    end
+
+    private
+
+    def ensure_image_content_type!(_image_data)
+      extension = 'png'
+      content_type = 'image/png'
+      content_types.add_default(extension, content_type)
+    end
+
+    def ensure_chart_content_type!(chart)
+      content_types.add_override(
+        format(Charts::PART_NAME_PATTERN, id: chart.id), Charts::CONTENT_TYPE
+      )
+    end
+
+    def to_stream
+      Zip::OutputStream.write_buffer do |zos|
+        zos.put_next_entry Goldendocx::Parts::ContentTypes::XML_PATH
+        zos.write content_types.to_document_xml
+
+        zos.put_next_entry Goldendocx::Parts::Documents::XML_PATH
+        documents.write_stream(zos)
+
+        @unstructured_entries.each { |unstructured_entry| unstructured_entry.write_to(zos) }
+      end
+    end
+
+    # TODO: Remove this after all structured
+    class UnStructuredEntry
+      attr_reader :entry
+
+      def initialize(entry)
+        @entry = entry
+      end
+
+      def write_to(zos)
+        zos.put_next_entry entry.name
+        return if entry.directory?
+
+        zos.write entry.get_input_stream.read
+      end
+    end
+  end
+end

data/lib/goldendocx/element.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string/inflections'
+
+ActiveSupport::Inflector.inflections do |inflect|
+  inflect.uncountable 'extents', 'image_data', 'data'
+  inflect.irregular 'axis', 'axes'
+
+  inflect.uncountable 'values' # TODO: Find better names
+end
+
+module Goldendocx
+  module Element
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def tag(*args)
+        @tag = args.first if args.any?
+        @tag
+      end
+
+      def namespace(*args)
+        @namespace = args.first if args.any?
+        @namespace
+      end
+
+      # alias_name: nil
+      # readonly: false
+      # default: nil
+      # namespace: nil
+      # setter: nil
+      def attribute(name, **options)
+        named = name.to_s
+        attributes[named] = {
+          alias_name: options[:alias_name],
+          default: options[:default],
+          namespace: options[:namespace],
+          method: options[:method]
+        }.compact
+
+        readonly = options[:readonly] || false
+        if readonly
+          attr_reader named
+        elsif options[:method]
+          attr_writer named
+        else
+          attr_accessor named
+        end
+      end
+
+      def attributes
+        @attributes ||= {}
+      end
+
+      def create_children_getter(name)
+        options = children[name]
+        class_name = options[:class_name]
+        multiple = options[:multiple]
+        auto_build = options[:auto_build]
+
+        define_method name do
+          return instance_variable_get("@#{name}") if instance_variable_defined?("@#{name}")
+
+          default_value = if multiple
+                            []
+                          else
+                            auto_build ? Kernel.const_get(class_name).new : nil
+                          end
+          instance_variable_set("@#{name}", default_value)
+        end
+      end
+
+      def create_children_setter(name)
+        options = children[name]
+        class_name = options[:class_name]
+
+        define_method "#{name}=" do |value|
+          value = value.to_s if value && class_name == 'String'
+          instance_variable_set("@#{name}", value)
+        end
+      end
+
+      def create_children_builder(name)
+        options = children[name]
+        class_name = options[:class_name]
+        multiple = options[:multiple]
+
+        define_method "build_#{name.to_s.singularize}" do |**attributes|
+          child = Kernel.const_get(class_name).new
+          attributes.each { |key, value| child.send("#{key}=", value) if child.respond_to?("#{key}=") }
+          multiple ? send(name) << child : instance_variable_set("@#{name}", child)
+          child
+        end
+      end
+
+      def embeds_one(name, class_name:, auto_build: false)
+        warning_naming_suggestion(name, name.to_s.singularize)
+
+        children[name] = { class_name: class_name, multiple: false, auto_build: auto_build }
+        create_children_getter(name)
+        create_children_setter(name)
+        create_children_builder(name)
+      end
+
+      def embeds_many(name, class_name:)
+        warning_naming_suggestion(name, name.to_s.pluralize)
+
+        children[name] = { class_name: class_name, multiple: true, auto_build: false }
+        create_children_getter(name)
+        create_children_builder(name)
+      end
+
+      def children
+        @children ||= {}
+      end
+
+      def concerning_ancestors
+        ancestors.filter { |ancestor| ancestor.include?(Goldendocx::Element) }
+      end
+
+      private
+
+      # :nocov:
+      def warning_naming_suggestion(name, suggestion_name)
+        return if suggestion_name == name.to_s
+
+        location = caller.find { |c| c.include?('goldendocx/') && !c.include?('goldendocx/element.rb') }
+        warn "warning: [embeds_one] `#{name}` better be singular `#{suggestion_name}` at #{location}"
+      end
+      # :nocov:
+    end
+
+    def attributes
+      self.class.attributes.each_with_object({}) do |(name, options), result|
+        value = public_send(options[:method] || name) || options[:default]
+        next if value.nil?
+
+        key = [options[:namespace], options[:alias_name] || name].compact.join(':')
+        result[key] = value
+      end
+    end
+
+    def assign_attributes(**attributes)
+      attributes.each { |key, value| send("#{key}=", value) if respond_to?("#{key}=") }
+    end
+
+    def tag
+      self.class.concerning_ancestors.find { |ancestor| ancestor.tag.present? }&.tag
+    end
+
+    def namespace
+      self.class.concerning_ancestors.find { |ancestor| ancestor.namespace.present? }&.namespace
+    end
+
+    def root_tag
+      @root_tag ||= [namespace, tag].compact.join(':')
+    end
+
+    def siblings
+      return [] unless self.class.superclass.include?(Goldendocx::Element)
+
+      self.class.superclass.children.keys.flat_map { |name| send(name) }
+    end
+
+    def children
+      self.class.children.keys.flat_map do |name|
+        send(name)
+      end.concat(siblings).compact
+    end
+
+    def to_element(**context)
+      Goldendocx.xml_serializer.build_element(root_tag, **context) do |xml|
+        attributes.each { |name, value| xml[name] = value }
+        children.each { |child| xml << child }
+
+        yield(xml) if block_given?
+      end
+    end
+
+    def to_xml
+      Goldendocx.xml_serializer.build_xml(root_tag) do |xml|
+        attributes.each { |name, value| xml[name] = value }
+
+        yield(xml) if block_given?
+
+        children.each { |child| xml << child }
+      end
+    end
+  end
+end

data/lib/goldendocx/images/picture.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Images
+    class Picture
+      include Goldendocx::Element
+
+      namespace :pic
+      tag :pic
+
+      embeds_one :non_visual_picture, class_name: 'Goldendocx::Images::Properties::NonVisualPictureProperty', auto_build: true
+      embeds_one :drawing, class_name: 'Goldendocx::Images::Properties::DrawingProperty', auto_build: true
+      embeds_one :picture_fill, class_name: 'Goldendocx::Images::Properties::PictureFillProperty', auto_build: true
+      embeds_one :picture_shape, class_name: 'Goldendocx::Images::Properties::PictureShapeProperty', auto_build: true
+
+      def initialize(**attributes)
+        attributes.each do |name, value|
+          send("#{name}=", value) if respond_to?("#{name}=")
+        end
+      end
+
+      def width=(width)
+        picture_shape.transform.extents.width = width if width
+      end
+
+      def height=(height)
+        picture_shape.transform.extents.height = height if height
+      end
+
+      def relationship_id=(relationship_id)
+        return unless relationship_id
+
+        non_visual_picture.non_visual_drawing.assign_attributes(
+          relationship_id: relationship_id,
+          name: "#{relationship_id}.png"
+        )
+        picture_fill.blip.relationship_id = relationship_id
+      end
+    end
+  end
+end

data/lib/goldendocx/images/properties/blip_property.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Images
+    module Properties
+      class BlipProperty
+        include Goldendocx::Element
+
+        namespace :a
+        tag :blip
+
+        attribute :relationship_id, alias_name: :embed, namespace: :r
+      end
+    end
+  end
+end

data/lib/goldendocx/images/properties/drawing_property.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Images
+    module Properties
+      class DrawingProperty
+        include Goldendocx::Element
+
+        namespace :pic
+        tag :cNvPicPr
+      end
+    end
+  end
+end

data/lib/goldendocx/images/properties/extents_property.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Images
+    module Properties
+      class ExtentsProperty
+        include Goldendocx::Element
+
+        namespace :a
+        tag :ext
+
+        attribute :width, alias_name: :cx
+        attribute :height, alias_name: :cy
+      end
+    end
+  end
+end

data/lib/goldendocx/images/properties/fill_rectangle_property.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Images
+    module Properties
+      class FillRectangleProperty
+        include Goldendocx::Element
+
+        namespace :a
+        tag :fillRect
+      end
+    end
+  end
+end

data/lib/goldendocx/images/properties/image_data_property.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Images
+    module Properties
+      class ImageDataProperty
+        include Goldendocx::Element
+
+        namespace :v
+        tag :imagedata
+
+        attribute :relationship_id, alias_name: :id, namespace: :r
+        attribute :title, namespace: :o
+      end
+    end
+  end
+end

data/lib/goldendocx/images/properties/non_visual_drawing_property.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Images
+    module Properties
+      class NonVisualDrawingProperty
+        include Goldendocx::Element
+
+        namespace :pic
+        tag :cNvPr
+
+        attribute :relationship_id, alias_name: :id
+        attribute :name
+      end
+    end
+  end
+end

data/lib/goldendocx/images/properties/non_visual_picture_property.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Images
+    module Properties
+      class NonVisualPictureProperty
+        include Goldendocx::Element
+
+        namespace :pic
+        tag :nvPicPr
+
+        embeds_one :non_visual_drawing, class_name: 'Goldendocx::Images::Properties::NonVisualDrawingProperty',
+                                        auto_build: true
+      end
+    end
+  end
+end

data/lib/goldendocx/images/properties/picture_fill_property.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Images
+    module Properties
+      class PictureFillProperty
+        include Goldendocx::Element
+
+        namespace :pic
+        tag :blipFill
+
+        embeds_one :blip, class_name: 'Goldendocx::Images::Properties::BlipProperty', auto_build: true
+        embeds_one :stretch, class_name: 'Goldendocx::Images::Properties::StretchProperty', auto_build: true
+      end
+    end
+  end
+end

data/lib/goldendocx/images/properties/picture_shape_property.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Images
+    module Properties
+      class PictureShapeProperty
+        include Goldendocx::Element
+
+        namespace :pic
+        tag :spPr
+
+        embeds_one :transform, class_name: 'Goldendocx::Images::Properties::TransformProperty', auto_build: true
+      end
+    end
+  end
+end