goldendocx 0.2.2 → 0.2.3

data/lib/goldendocx/documents/properties/page_margin_property.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Documents
+    module Properties
+      class PageMarginProperty
+        include Goldendocx::Element
+
+        namespace :w
+        tag :pgMar
+
+        attribute :top, namespace: :w, default: 1440
+        attribute :bottom, namespace: :w, default: 1440
+        attribute :left, namespace: :w, default: 1800
+        attribute :right, namespace: :w, default: 1800
+        attribute :header, namespace: :w, default: 851
+        attribute :footer, namespace: :w, default: 992
+        attribute :gutter, namespace: :w, default: 0
+
+        # Follow html margin style setting
+        def margin=(*args)
+          args = Array(*args)
+          raise StandardError("wrong number of arguments (given #{args.length}, expected 1..4)") unless (1..4).cover?(args.length)
+
+          margins =
+            case args.length
+            when 1 then [args.first] * 4
+            when 2 then [args.first, args.last, args.first, args.last]
+            when 3 then [args.first, args.second, args.last, args.second]
+            else args
+            end
+          assign_attributes(**%i[top right bottom left].zip(margins).to_h)
+        end
+      end
+    end
+  end
+end

data/lib/goldendocx/documents/properties/page_size_property.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Documents
+    module Properties
+      class PageSizeProperty
+        include Goldendocx::Element
+
+        namespace :w
+        tag :pgSz
+
+        attribute :width, alias_name: :w, namespace: :w, default: 11906
+        attribute :height, alias_name: :h, namespace: :w, default: 16838
+      end
+    end
+  end
+end

data/lib/goldendocx/documents/properties/paragraph_default_style_property.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Documents
+    module Properties
+      class ParagraphDefaultStyleProperty
+        include Goldendocx::Element
+
+        namespace :w
+        tag :pPrDefault
+
+        embeds_one :property, class_name: 'Goldendocx::Components::Properties::Property'
+      end
+    end
+  end
+end

data/lib/goldendocx/documents/properties/run_default_style_property.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Documents
+    module Properties
+      class RunDefaultStyleProperty
+        include Goldendocx::Element
+
+        namespace :w
+        tag :rPrDefault
+
+        embeds_one :property, class_name: 'Goldendocx::Components::Properties::RunProperty'
+
+        def initialize
+          build_property
+          property.build_language
+          property.build_font
+        end
+      end
+    end
+  end
+end

data/lib/goldendocx/documents/properties/section_property.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Documents
+    module Properties
+      class SectionProperty
+        include Goldendocx::Element
+
+        namespace :w
+        tag :sectPr
+
+        embeds_one :size, class_name: 'Goldendocx::Documents::Properties::PageSizeProperty', auto_build: true
+        embeds_one :margin, class_name: 'Goldendocx::Documents::Properties::PageMarginProperty', auto_build: true
+      end
+    end
+  end
+end

data/lib/goldendocx/documents/properties/style_name_property.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Documents
+    module Properties
+      class StyleNameProperty
+        include Goldendocx::Element
+
+        namespace :w
+        tag :name
+
+        attribute :name, alias_name: :val, namespace: :w
+      end
+    end
+  end
+end

data/lib/goldendocx/documents/properties.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Documents
+    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/documents/settings.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Goldendocx
+  module Documents
+    class Settings
+      include Goldendocx::Document
+
+      XML_PATH = 'word/settings.xml'
+      TYPE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/settings'
+      CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml'
+
+      namespace :w
+      tag :settings
+      concern_namespaces :mc, :o, :r, :m, :v, :w10, :w, :w14, :w15, :w16cid, :w16se, :sl
+      ignore_namespaces :w14, :w15, :w16se, :w16cid
+
+      def write_to(zos)
+        zos.put_next_entry XML_PATH
+        zos.write to_document_xml
+      end
+    end
+  end
+end

data/lib/goldendocx/documents/style.rb

@@ -3,18 +3,18 @@
 module Goldendocx
   module Documents
     class Style
-      attr_reader :node, :id, :type, :name
+      include Goldendocx::Element
 
-      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
+      namespace :w
+      tag :style
+
+      attribute :id, alias_name: :styleId, namespace: :w
+      attribute :type, namespace: :w
+
+      embeds_one :style_name, class_name: 'Goldendocx::Documents::Properties::StyleNameProperty', auto_build: true
 
-      def to_element(**_context)
-        @node
+      def name
+        style_name.name
       end
     end
   end

data/lib/goldendocx/documents/styles.rb

@@ -6,42 +6,22 @@ module Goldendocx
       include Goldendocx::Document
 
       XML_PATH = 'word/styles.xml'
+      TYPE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles'
+      CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.wordprocessingml.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
+      embeds_one :defaults, class_name: 'Goldendocx::Documents::Properties::DefaultStyleProperty', auto_build: true
+      embeds_one :latentStyles, class_name: 'Goldendocx::Documents::LatentStyles'
+      embeds_many :styles, class_name: 'Goldendocx::Documents::Style'
 
       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
@@ -60,14 +40,10 @@ module Goldendocx
       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
+        style = Goldendocx::Documents::Style.parse(fragment)
+        style.id = (styles.size + 1).to_s # Rearrange id to prevent duplicates
+        styles << style
+        style.id
       end
     end
   end

data/lib/goldendocx/docx.rb

@@ -1,32 +1,54 @@
 # frozen_string_literal: true
 
-require 'goldendocx/units'
-require 'goldendocx/element'
-require 'goldendocx/document'
-
+require 'goldendocx/models'
 require 'goldendocx/components'
 require 'goldendocx/documents'
 require 'goldendocx/parts'
 
 module Goldendocx
   class Docx
-    attr_reader :unstructured_entries, :documents, :content_types
+    include Goldendocx::HasAssociations
+
+    attr_reader :unstructured_entries, :documents
+
+    RELATIONSHIPS_XML_PATH = '_rels/.rels'
 
     STRUCTURED_ENTRIES = [
+      RELATIONSHIPS_XML_PATH,
+
       Goldendocx::Parts::ContentTypes::XML_PATH,
+      Goldendocx::Parts::App::XML_PATH,
+      Goldendocx::Parts::Core::XML_PATH,
+
+      Goldendocx::Parts::Documents::RELATIONSHIPS_XML_PATH,
 
-      Goldendocx::Documents::Body::XML_PATH,
-      Goldendocx::Documents::Relationships::XML_PATH,
+      Goldendocx::Documents::Document::XML_PATH,
+      Goldendocx::Documents::Settings::XML_PATH,
       Goldendocx::Documents::Styles::XML_PATH
     ].freeze
 
-    def initialize(file_path)
+    relationships_at RELATIONSHIPS_XML_PATH
+    associate :app, class_name: 'Goldendocx::Parts::App'
+    associate :core, class_name: 'Goldendocx::Parts::Core'
+    associate :content_types, class_name: 'Goldendocx::Parts::ContentTypes', isolate: true
+
+    def initialize(file_path = nil)
+      file_path.present? ? read_from(file_path) : build_default
+    end
+
+    def read_from(file_path)
       docx_file = Zip::File.new(file_path)
+
+      read_relationships(docx_file)
+      read_associations(docx_file)
+
       @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
+
+      self
     end
 
     def write_to(new_path)
@@ -65,6 +87,25 @@ module Goldendocx
 
     private
 
+    def build_default
+      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 unless options[:isolate]
+      end
+
+      content_types.add_override "/#{Goldendocx::Parts::App::XML_PATH}", Goldendocx::Parts::App::CONTENT_TYPE
+      content_types.add_override "/#{Goldendocx::Parts::Core::XML_PATH}", Goldendocx::Parts::Core::CONTENT_TYPE
+      content_types.add_override "/#{Goldendocx::Documents::Styles::XML_PATH}", Goldendocx::Documents::Styles::CONTENT_TYPE
+      content_types.add_override "/#{Goldendocx::Documents::Settings::XML_PATH}", Goldendocx::Documents::Settings::CONTENT_TYPE
+
+      @documents = Goldendocx::Parts::Documents.new
+      add_relationship Goldendocx::Documents::Document::TYPE, Goldendocx::Documents::Document::XML_PATH
+      content_types.add_override "/#{Goldendocx::Documents::Document::XML_PATH}", Goldendocx::Documents::Document::CONTENT_TYPE
+
+      @unstructured_entries = []
+    end
+
     def ensure_image_content_type!(_image_data)
       extension = 'png'
       content_type = 'image/png'
@@ -79,10 +120,12 @@ module Goldendocx
 
     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
+        write_relationships(zos)
+
+        associations.each_key do |association|
+          send(association).write_to(zos)
+        end
 
-        zos.put_next_entry Goldendocx::Parts::Documents::XML_PATH
         documents.write_stream(zos)
 
         @unstructured_entries.each { |unstructured_entry| unstructured_entry.write_to(zos) }

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, &block)
+      Goldendocx.xml_serializer.build_element(tag_name, **context) { |xml| build_element(xml, &block) }
     end
 
-    def children
-      self.class.children.keys.flat_map do |name|
-        send(name)
-      end.concat(siblings).compact
+    def to_xml(&block)
+      Goldendocx.xml_serializer.build_xml(tag_name) { |xml| build_element(xml, &block) }
     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,52 @@
+# 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
+
+    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] = { class_name: class_name, isolate: 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