goldendocx 0.2.2 → 0.3.0

data/lib/goldendocx/element.rb

@@ -1,19 +1,13 @@
 # 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
+require 'goldendocx/has_attributes'
+require 'goldendocx/has_children'
 
 module Goldendocx
   module Element
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
+    extend ActiveSupport::Concern
+    include Goldendocx::HasAttributes
+    include Goldendocx::HasChildren
 
     module ClassMethods
       def tag(*args)
@@ -26,124 +20,36 @@ module Goldendocx
         @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
+      def tag_name
+        @tag_name ||= [namespace, tag].compact.join(':')
       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
+      def parse(xml_string)
+        root_node = Goldendocx.xml_serializer.parse(xml_string).root
+        read_from(root_node)
       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
+      def adapt?(xml_node)
+        tag_name == xml_node.tag_name
       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 read_from(xml_node)
+        return unless adapt?(xml_node)
 
-      def children
-        @children ||= {}
+        instance = new
+        instance.read_attributes(xml_node)
+        instance.read_children(xml_node)
+        instance
       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}=") }
+    def initialize(attributes = nil)
+      attributes ||= {}
+      assign_attributes(**attributes)
     end
 
     def tag
@@ -154,39 +60,26 @@ module Goldendocx
       self.class.concerning_ancestors.find { |ancestor| ancestor.namespace.present? }&.namespace
     end
 
-    def root_tag
-      @root_tag ||= [namespace, tag].compact.join(':')
+    def tag_name
+      @tag_name ||= [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) }
+    def to_element(**context, &)
+      Goldendocx.xml_serializer.build_element(tag_name, **context) { |xml| build_element(xml, &) }
     end
 
-    def children
-      self.class.children.keys.flat_map do |name|
-        send(name)
-      end.concat(siblings).compact
+    def to_xml(&)
+      Goldendocx.xml_serializer.build_xml(tag_name) { |xml| build_element(xml, &) }
     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 }
+    def build_element(xml)
+      attributes.each { |name, value| xml[name] = value }
+      unparsed_attributes.each { |name, value| xml[name] = value }
 
-        yield(xml) if block_given?
-      end
-    end
+      children.each { |child| xml << child }
+      unparsed_children.each { |child| xml << child }
 
-    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
+      yield(xml) if block_given?
     end
   end
 end

data/lib/goldendocx/has_associations.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module HasAssociations
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :associations, default: {}
+      class_attribute :relationships_xml_path
+
+      delegate :add_relationship, to: :relationships
+    end
+
+    Options = Data.define(:class_name, :isolate)
+
+    class_methods do
+      def relationships_at(xml_path)
+        self.relationships_xml_path = xml_path
+      end
+
+      def associate(name, class_name:, isolate: false)
+        named = name.to_s
+        associations[named] = Options.new(class_name:, isolate:)
+
+        define_method named do
+          return instance_variable_get("@#{name}") if instance_variable_defined?("@#{name}")
+
+          new_instance = class_name.constantize.new
+          instance_variable_set("@#{name}", new_instance)
+        end
+      end
+    end
+
+    def read_associations(docx_file)
+      associations.each do |association, options|
+        association_class = options.class_name.constantize
+        association_document_xml = docx_file.read(association_class::XML_PATH)
+        instance_variable_set("@#{association}", association_class.parse(association_document_xml))
+      end
+    end
+
+    def read_relationships(docx_file)
+      @relationships = Goldendocx::Models::Relationships.parse(docx_file.read(relationships_xml_path))
+    end
+
+    def write_relationships(zos)
+      relationships.write_to(zos, relationships_xml_path)
+    end
+
+    def relationships
+      @relationships ||= Goldendocx::Models::Relationships.new
+    end
+  end
+end

data/lib/goldendocx/has_attributes.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module HasAttributes
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :attributes, instance_accessor: false, default: {}
+
+      def unparsed_attributes
+        @unparsed_attributes ||= {}
+      end
+    end
+
+    class_methods do
+      # 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
+    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 read_attributes(node)
+      node_attributes = node.attributes_hash
+
+      attributes = self.class.attributes.each_with_object({}) do |(name, options), result|
+        attribute_tag = [options[:namespace], (options[:alias_name] || name)].compact.join(':')
+        result[name] = node_attributes.delete(attribute_tag)
+      end
+      assign_attributes(**attributes)
+
+      unparsed_attributes.update(node_attributes)
+    end
+
+    def assign_attributes(**attributes)
+      attributes.each { |key, value| send("#{key}=", value) if respond_to?("#{key}=") }
+    end
+  end
+end

data/lib/goldendocx/has_children.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'goldendocx/has_attributes'
+
+module Goldendocx
+  module HasChildren
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :children, instance_accessor: false, default: {}
+
+      def unparsed_children
+        @unparsed_children ||= []
+      end
+    end
+
+    module ClassMethods
+      def embeds_one(name, class_name:, auto_build: false)
+        warning_naming_suggestion(__method__, name, name.to_s.singularize)
+
+        options = { class_name:, multiple: false, auto_build: }
+        self.children = children.merge(name => options)
+
+        create_children_getter(name)
+        create_children_setter(name)
+        create_children_builder(name)
+      end
+
+      def embeds_many(name, class_name:, uniqueness: false)
+        warning_naming_suggestion(__method__, name, name.to_s.pluralize)
+
+        options = { class_name:, multiple: true, uniqueness: }
+        self.children = children.merge(name => options)
+
+        create_children_getter(name)
+        create_children_setter(name)
+        create_children_builder(name)
+      end
+
+      def default_value(name)
+        options = children[name]
+        return [] if options[:multiple]
+
+        options[:class_name].constantize.new if options[:auto_build]
+      end
+
+      private
+
+      def create_children_getter(name)
+        define_method name do
+          return instance_variable_get("@#{name}") if instance_variable_defined?("@#{name}")
+
+          instance_variable_set("@#{name}", self.class.default_value(name))
+        end
+      end
+
+      def create_children_setter(name)
+        define_method("#{name}=") { |value| instance_variable_set("@#{name}", value) }
+      end
+
+      def create_children_appender(name)
+        options = children[name]
+
+        define_method "append_#{name.to_s.singularize}" do |child|
+          return instance_variable_set("@#{name}", child) unless options[:multiple]
+
+          children = send(name)
+          children << child unless options[:uniqueness] && children.any?(child)
+          child
+        end
+      end
+
+      def create_children_builder(name)
+        options = children[name]
+        create_children_appender(name)
+
+        define_method "build_#{name.to_s.singularize}" do |**attributes|
+          child = options[:class_name].constantize.new
+          attributes.each { |key, value| child.send("#{key}=", value) if child.respond_to?("#{key}=") }
+          send("append_#{name.to_s.singularize}", child)
+        end
+      end
+
+      # :nocov:
+      def warning_naming_suggestion(method, name, suggestion_name)
+        return if suggestion_name == name.to_s
+
+        location = caller.find { |c| c.include?('goldendocx/') && !c.include?('goldendocx/element.rb') }
+        warn "warning: [#{method}] `#{name}` better be `#{suggestion_name}` at #{location}"
+      end
+      # :nocov:
+    end
+
+    def children
+      self.class.children.keys.flat_map { |name| send(name) }.compact
+    end
+
+    def read_children(xml_node)
+      xml_node.children.each do |child_node|
+        read_child(child_node)
+      end
+    end
+
+    def read_child(child_node)
+      name, options = self.class.children.find do |_, opts|
+        opts[:class_name].constantize.adapt?(child_node)
+      end
+      if name.present?
+        child = options[:class_name].constantize.read_from(child_node)
+        send("append_#{name.to_s.singularize}", child)
+      else
+        unparsed_children << child_node
+      end
+    end
+  end
+end

data/lib/goldendocx/images/picture.rb

@@ -31,7 +31,7 @@ module Goldendocx
         return unless relationship_id
 
         non_visual_picture.non_visual_drawing.assign_attributes(
-          relationship_id: relationship_id,
+          relationship_id:,
           name: "#{relationship_id}.png"
         )
         picture_fill.blip.relationship_id = relationship_id

data/lib/goldendocx/images/properties.rb

@@ -7,6 +7,6 @@ module Goldendocx
   end
 end
 
-Dir.glob(File.join(File.dirname(__FILE__), 'properties', '*.rb').to_s).sort.each do |file|
+Dir.glob(File.join(File.dirname(__FILE__), 'properties', '*.rb').to_s).each do |file|
   require file
 end

data/lib/goldendocx/images.rb

@@ -7,6 +7,6 @@ end
 
 require 'goldendocx/images/properties'
 
-Dir.glob(File.join(File.dirname(__FILE__), 'images', '*.rb').to_s).sort.each do |file|
+Dir.glob(File.join(File.dirname(__FILE__), 'images', '*.rb').to_s).each do |file|
   require file
 end

data/lib/goldendocx/{documents → models}/relationship.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Goldendocx
-  module Documents
+  module Models
     class Relationship
       include Goldendocx::Element
 

data/lib/goldendocx/models/relationships.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Models
+    class Relationships
+      include Goldendocx::Document
+
+      NAMESPACE = 'http://schemas.openxmlformats.org/package/2006/relationships'
+
+      tag :Relationships
+      attribute :xmlns, default: NAMESPACE, readonly: true
+
+      embeds_many :relationships, class_name: 'Goldendocx::Models::Relationship'
+
+      def size
+        relationships.size
+      end
+
+      def write_to(zos, xml_path)
+        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:, target:)
+        relationship_id
+      end
+    end
+  end
+end

data/lib/goldendocx/models.rb

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

data/lib/goldendocx/parts/app.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Parts
+    class App
+      include Goldendocx::Document
+
+      TYPE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties'
+      XML_PATH = 'docProps/app.xml'
+      NAMESPACE = 'http://schemas.openxmlformats.org/officeDocument/2006/extended-properties'
+      CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.extended-properties+xml'
+
+      tag :Properties
+      attribute :xmlns, default: NAMESPACE, readonly: true
+
+      class << self
+        def read_from(app_document)
+          new_instance = new
+
+          app_document.children.map do |node|
+            new_instance.properties[node.name.to_sym] = node.text
+          end
+
+          new_instance
+        end
+      end
+
+      def write_to(zos)
+        zos.put_next_entry XML_PATH
+        zos.write to_document_xml
+      end
+
+      def to_document_xml
+        super do |xml|
+          properties.each do |name, value|
+            xml << Goldendocx.xml_serializer.build_element(name).tap { |app| app << value }
+          end
+        end
+      end
+
+      def properties
+        @properties ||= { Application: "Goldendocx_#{Goldendocx::VERSION}" }
+      end
+    end
+  end
+end

data/lib/goldendocx/parts/content_types.rb

@@ -11,52 +11,38 @@ module Goldendocx
       XML_PATH = '[Content_Types].xml'
       NAMESPACE = 'http://schemas.openxmlformats.org/package/2006/content-types'
 
-      attr_reader :defaults, :overrides
+      REQUIRED_DEFAULTS = {
+        rels: 'application/vnd.openxmlformats-package.relationships+xml',
+        xml: 'application/xml'
+      }.with_indifferent_access.freeze
 
       tag :Types
       attribute :xmlns, default: NAMESPACE, readonly: true
 
-      class << self
-        def read_from(docx_file)
-          content_types = Goldendocx::Parts::ContentTypes.new
-          content_types.read_defaults(docx_file)
-          content_types.read_overrides(docx_file)
-          content_types
-        end
-      end
+      embeds_many :defaults, class_name: 'Goldendocx::ContentTypes::Default', uniqueness: true
+      embeds_many :overrides, class_name: 'Goldendocx::ContentTypes::Override', uniqueness: true
 
       def initialize
-        @defaults = []
-        @overrides = []
-      end
-
-      def read_defaults(docx_file)
-        @defaults = Goldendocx.xml_serializer.parse(docx_file.read(XML_PATH), %w[Types Default]).map do |node|
-          Goldendocx::ContentTypes::Default.new(node[:Extension], node[:ContentType])
+        REQUIRED_DEFAULTS.map do |extension, content_type|
+          build_defaults(extension:, content_type:)
         end
       end
 
-      def read_overrides(docx_file)
-        @overrides = Goldendocx.xml_serializer.parse(docx_file.read(XML_PATH), %w[Types Override]).map do |node|
-          Goldendocx::ContentTypes::Override.new(node[:PartName], node[:ContentType])
-        end
+      def write_to(zos)
+        zos.put_next_entry XML_PATH
+        zos.write to_document_xml
       end
 
       def add_default(extension, content_type)
-        new_default = Goldendocx::ContentTypes::Default.new(extension, content_type)
-        defaults << new_default if defaults.none?(new_default)
+        return if defaults.any? { |default| extension == default.extension && content_type == default.content_type }
+
+        build_defaults(extension:, content_type:)
       end
 
       def add_override(part_name, content_type)
-        new_override = Goldendocx::ContentTypes::Override.new(part_name, content_type)
-        overrides << new_override if overrides.none?(new_override)
-      end
+        return if overrides.any? { |override| part_name == override.part_name && content_type == override.content_type }
 
-      def to_document_xml
-        super do |xml|
-          defaults.each { |default| xml << default }
-          overrides.each { |override| xml << override }
-        end
+        build_override(part_name:, content_type:)
       end
     end
   end