goldendocx 0.2.2 → 0.2.3

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: class_name, multiple: false, auto_build: 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: class_name, multiple: true, uniqueness: 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/{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/{documents → models}/relationships.rb

@@ -1,31 +1,23 @@
 # frozen_string_literal: true
 
 module Goldendocx
-  module Documents
+  module Models
     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'
+      embeds_many :relationships, class_name: 'Goldendocx::Models::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
+      def write_to(zos, xml_path)
+        zos.put_next_entry xml_path
         zos.write to_document_xml
       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).sort.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: extension, content_type: 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: extension, content_type: 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: part_name, content_type: content_type)
       end
     end
   end

data/lib/goldendocx/parts/core.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Parts
+    class Core
+      include Goldendocx::Document
+
+      TYPE = 'http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties'
+      XML_PATH = 'docProps/core.xml'
+      NAMESPACE = 'http://schemas.openxmlformats.org/officeDocument/2006/extended-properties'
+      CONTENT_TYPE = 'application/vnd.openxmlformats-package.core-properties+xml'
+
+      concern_namespaces :cp, :dc, :dcterms, :dcmitype, :xsi
+
+      namespace :cp
+      tag :coreProperties
+
+      embeds_one :creator, class_name: 'Goldendocx::Parts::Properties::CreatorProperty'
+      embeds_one :created_at, class_name: 'Goldendocx::Parts::Properties::CreatedAtProperty'
+      embeds_one :revision, class_name: 'Goldendocx::Parts::Properties::RevisionProperty'
+      embeds_one :updater, class_name: 'Goldendocx::Parts::Properties::UpdaterProperty'
+      embeds_one :updated_at, class_name: 'Goldendocx::Parts::Properties::UpdatedAtProperty'
+
+      class << self
+        def read_from(xml_node)
+          core = super(xml_node)
+          revision = (core.revision || core.build_revision)
+          revision.value = revision.value.to_i + 1
+          core.build_updater(name: "Goldendocx_#{Goldendocx::VERSION}")
+          core.build_updated_at(timestamp: Time.now)
+          core
+        end
+      end
+
+      def initialize
+        build_creator(name: "Goldendocx_#{Goldendocx::VERSION}")
+        build_created_at(timestamp: Time.now)
+      end
+
+      def write_to(zos)
+        zos.put_next_entry XML_PATH
+        zos.write to_document_xml
+      end
+    end
+  end
+end

data/lib/goldendocx/parts/documents.rb

@@ -4,37 +4,50 @@
 module Goldendocx
   module Parts
     class Documents
+      include Goldendocx::HasAssociations
+
       XML_PATH = 'word/'
+      RELATIONSHIPS_XML_PATH = 'word/_rels/document.xml.rels'
 
       attr_reader :document, # document.xml
-                  :styles, # styles.xml
-                  :relationships, # _rels/document.xml.rels
                   :charts, # charts/
                   :medias # New Medias to media/
 
       attr_accessor :media_amount # Entries amount in directory media/ for generating relationship id
 
+      relationships_at RELATIONSHIPS_XML_PATH
+      associate :styles, class_name: 'Goldendocx::Documents::Styles'
+      associate :settings, class_name: 'Goldendocx::Documents::Settings'
+      associate :document, class_name: 'Goldendocx::Documents::Document', isolate: true
+
       class << self
         def read_from(docx_file)
           parts = Goldendocx::Parts::Documents.new
-          parts.document.read_from(docx_file)
-          parts.styles.read_from(docx_file)
-          parts.relationships.read_from(docx_file)
+          parts.read_relationships(docx_file)
+          parts.read_associations(docx_file)
           parts.media_amount = docx_file.entries.count { |entry| entry.name.start_with?('word/media/') }
           parts
         end
       end
 
       def initialize
-        @document = Goldendocx::Documents::Document.new
-        @styles = Goldendocx::Documents::Styles.new
-        @relationships = Goldendocx::Documents::Relationships.new
+        associations.each do |association, options|
+          association_class = options[:class_name].constantize
+          instance_variable_set("@#{association}", association_class.new)
+          add_relationship association_class::TYPE, association_class::XML_PATH.gsub(XML_PATH, '') unless options[:isolate]
+        end
+
         @medias = []
+        @media_amount = 0
       end
 
       def write_stream(zos)
-        styles.write_to(zos)
-        relationships.write_to(zos)
+        write_relationships(zos)
+
+        associations.each_key do |association|
+          send(association).write_to(zos)
+        end
+
         document.write_to(zos)
         medias.each { |media| media.write_to(zos) }
         document.body.charts.each { |chart| chart.write_to(zos) }
@@ -60,14 +73,14 @@ module Goldendocx
 
       def create_image(image_data, options = {})
         image_media = add_image_media(image_data, options)
-        relationship_id = relationships.add_relationship(image_media.type, image_media.target)
+        relationship_id = add_relationship(image_media.type, image_media.target)
 
         document.body.create_image(relationship_id, options)
       end
 
       def create_embed_image(image_data, options = {})
         image_media = add_image_media(image_data, options)
-        relationship_id = relationships.add_relationship(image_media.type, image_media.target)
+        relationship_id = add_relationship(image_media.type, image_media.target)
 
         document.body.create_embed_image(relationship_id, options)
       end
@@ -87,7 +100,7 @@ module Goldendocx
 
         chart_id = document.body.charts.size + 1
 
-        relationship_id = relationships.add_relationship(
+        relationship_id = add_relationship(
           Goldendocx::Charts::RELATIONSHIP_TYPE,
           format(Goldendocx::Charts::RELATIONSHIP_NAME_PATTERN, id: chart_id)
         )

data/lib/goldendocx/parts/properties/created_at_property.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Parts
+    module Properties
+      class CreatedAtProperty
+        include Goldendocx::Element
+
+        namespace :dcterms
+        tag :created
+
+        attribute :type, namespace: :xsi, default: 'dcterms:W3CDTF'
+        embeds_one :timestamp, class_name: 'Time'
+      end
+    end
+  end
+end

data/lib/goldendocx/parts/properties/creator_property.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Parts
+    module Properties
+      class CreatorProperty
+        include Goldendocx::Element
+
+        namespace :dc
+        tag :creator
+
+        embeds_one :name, class_name: 'String'
+      end
+    end
+  end
+end

data/lib/goldendocx/parts/properties/revision_property.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Parts
+    module Properties
+      class RevisionProperty
+        include Goldendocx::Element
+
+        namespace :cp
+        tag :revision
+
+        embeds_one :value, class_name: 'Integer'
+      end
+    end
+  end
+end

data/lib/goldendocx/parts/properties/updated_at_property.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Parts
+    module Properties
+      class UpdatedAtProperty
+        include Goldendocx::Element
+
+        namespace :dcterms
+        tag :modified
+
+        attribute :type, namespace: :xsi, default: 'dcterms:W3CDTF'
+        embeds_one :timestamp, class_name: 'Time'
+      end
+    end
+  end
+end

data/lib/goldendocx/parts/properties/updater_property.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Parts
+    module Properties
+      class UpdaterProperty
+        include Goldendocx::Element
+
+        namespace :cp
+        tag :lastModifiedBy
+
+        embeds_one :name, class_name: 'String'
+      end
+    end
+  end
+end

data/lib/goldendocx/parts/properties.rb

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

data/lib/goldendocx/tables/row.rb

@@ -18,7 +18,7 @@ module Goldendocx
       def add_cell(data)
         cell = case data
                when Goldendocx::Tables::Cell then data
-               when Hash then Goldendocx::Tables::Cell.new(data)
+               when Hash then Goldendocx::Tables::Cell.new(**data)
                else Goldendocx::Tables::Cell.new(content: data.to_s)
                end
         cells << cell

data/lib/goldendocx/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Goldendocx
-  VERSION = '0.2.2'
+  VERSION = '0.2.3'
 end