berkeley_library-tind 0.4.0

data/lib/berkeley_library/util/ods/xml/content_doc.rb

@@ -0,0 +1,26 @@
+require 'nokogiri'
+require 'berkeley_library/util/ods/xml/document_node'
+require 'berkeley_library/util/ods/xml/office/document_content'
+
+module BerkeleyLibrary
+  module Util
+    module ODS
+      module XML
+        class ContentDoc < DocumentNode
+
+          def initialize
+            super('content.xml')
+          end
+
+          def root_element_node
+            document_content
+          end
+
+          def document_content
+            @document_content ||= Office::DocumentContent.new(doc: doc)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/berkeley_library/util/ods/xml/document_node.rb

@@ -0,0 +1,57 @@
+require 'nokogiri'
+
+module BerkeleyLibrary
+  module Util
+    module ODS
+      module XML
+        class DocumentNode
+
+          ENCODING = 'UTF-8'.freeze
+
+          attr_reader :path
+
+          # Initializes a new DocumentNode
+          # @param path [String] the path to this document in the container
+          def initialize(path)
+            @path = path
+          end
+
+          def to_xml(out = nil, compact: true)
+            return write_xml_to_string(compact: compact) unless out
+            return write_xml_to_stream(out, compact: compact) if out.respond_to?(:write)
+
+            write_xml_to_file(out, compact: compact)
+          end
+
+          def doc
+            @doc ||= Nokogiri::XML::Document.new.tap do |doc|
+              doc.encoding = ENCODING
+            end
+          end
+
+          private
+
+          def write_xml_to_stream(out, compact:)
+            doc.root ||= root_element_node.element
+            if compact
+              doc.write_to(out, encoding: ENCODING, save_with: 0)
+            else
+              doc.write_to(out, encoding: ENCODING)
+            end
+          end
+
+          def write_xml_to_string(compact:)
+            StringIO.new.tap do |out|
+              out.binmode
+              write_xml_to_stream(out, compact: compact)
+            end.string
+          end
+
+          def write_xml_to_file(path, compact:)
+            File.open(path, 'wb') { |f| write_xml_to_stream(f, compact: compact) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/berkeley_library/util/ods/xml/element_node.rb

@@ -0,0 +1,106 @@
+require 'nokogiri'
+require 'berkeley_library/util/logging'
+require 'berkeley_library/util/ods/xml/namespace'
+
+module BerkeleyLibrary
+  module Util
+    module ODS
+      module XML
+        class ElementNode
+          include BerkeleyLibrary::Logging
+
+          # @return [Nokogiri::XML::Document] the document containing this element
+          attr_reader :doc
+
+          # @return [Namespace] the namespace for this element
+          attr_reader :namespace
+
+          # @return [String] the name of this element
+          attr_reader :element_name
+
+          # @param namespace [String, Symbol, Namespace] the element namespace
+          # @param element_name [String] the element name
+          # @param doc [Nokogiri::XML::Document] the document containing this element
+          def initialize(namespace, element_name, doc:)
+            @namespace = ensure_namespace(namespace)
+            @element_name = element_name
+            @doc = doc
+          end
+
+          def prefix
+            namespace.prefix
+          end
+
+          def element
+            ensure_element!
+          end
+
+          # Finalize this XML element and prepare for output.
+          def ensure_element!
+            @element ||= create_element
+          end
+
+          # rubocop:disable Style/OptionalArguments
+          def set_attribute(namespace = prefix, name, value)
+            attr_name = prefixed_attr_name(namespace, name)
+            attributes[attr_name] = value.to_s
+          end
+          # rubocop:enable Style/OptionalArguments
+
+          # rubocop:disable Style/OptionalArguments
+          def clear_attribute(namespace = prefix, name)
+            attr_name = prefixed_attr_name(namespace, name)
+            attributes.delete(attr_name)
+          end
+          # rubocop:enable Style/OptionalArguments
+
+          def add_child(child)
+            raise ArgumentError, "Not text or an element: #{child.inspect}" unless child.is_a?(ElementNode) || child.is_a?(String)
+
+            child.tap { |c| children << c }
+          end
+
+          protected
+
+          def prefixed_attr_name(ns, name)
+            return "xmlns:#{name}" if ns.to_s == 'xmlns'
+
+            "#{ensure_namespace(ns).prefix}:#{name}"
+          end
+
+          def create_element
+            doc.create_element("#{prefix}:#{element_name}", attributes).tap do |element|
+              children.each do |child|
+                next element.add_child(child.element) if child.is_a?(ElementNode)
+
+                text_node = doc.create_text_node(child.to_s)
+                element.add_child(text_node)
+              end
+            end
+          end
+
+          # @return [Hash<String, String>] the attributes, as a map from name to value
+          def attributes
+            # noinspection RubyYardReturnMatch
+            @attributes ||= {}
+          end
+
+          # @return [Array<ElementNode>] the child elements
+          # TODO: replace this with :each_child and a protected default array
+          def children
+            @children ||= []
+          end
+
+          private
+
+          def ensure_namespace(ns)
+            return ns if ns.is_a?(Namespace)
+            raise ArgumentError, "Not a recognized namespace: #{ns.inspect}" unless (ns_for_prefix = Namespace.for_prefix(ns.to_s.downcase))
+
+            ns_for_prefix
+          end
+        end
+      end
+    end
+  end
+end

data/lib/berkeley_library/util/ods/xml/loext/table_protection.rb

@@ -0,0 +1,26 @@
+require 'berkeley_library/util/ods/xml/element_node'
+
+module BerkeleyLibrary
+  module Util
+    module ODS
+      module XML
+        module LOExt
+          class TableProtection < ElementNode
+            def initialize(doc:)
+              super(:loext, 'table-protection', doc: doc)
+
+              set_default_attributes!
+            end
+
+            private
+
+            def set_default_attributes!
+              set_attribute('select-protected-cells', 'true')
+              set_attribute('select-unprotected-cells', 'true')
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/berkeley_library/util/ods/xml/manifest/file_entry.rb

@@ -0,0 +1,42 @@
+require 'berkeley_library/util/ods/xml/element_node'
+
+module BerkeleyLibrary
+  module Util
+    module ODS
+      module XML
+        module Manifest
+          class FileEntry < XML::ElementNode
+
+            attr_reader :full_path
+            attr_reader :media_type
+            attr_reader :manifest
+
+            def initialize(full_path, media_type = nil, manifest:)
+              super(:manifest, 'file-entry', doc: manifest.doc)
+
+              @full_path = full_path
+              @media_type = media_type || media_type_for(full_path)
+              @manifest = manifest
+
+              set_default_attributes!
+            end
+
+            private
+
+            def media_type_for(path)
+              return 'application/vnd.oasis.opendocument.spreadsheet' if path == '/'
+              return 'text/xml' if path.end_with?('.xml')
+
+              raise ArgumentError, "Can't determine media type for path: #{path.inspect}"
+            end
+
+            def set_default_attributes!
+              set_attribute('full-path', full_path)
+              set_attribute('media-type', media_type)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/berkeley_library/util/ods/xml/manifest/manifest.rb

@@ -0,0 +1,73 @@
+require 'berkeley_library/util/ods/xml/element_node'
+require 'berkeley_library/util/ods/xml/manifest/file_entry'
+
+module BerkeleyLibrary
+  module Util
+    module ODS
+      module XML
+        module Manifest
+          class Manifest < XML::ElementNode
+            REQUIRED_NAMESPACES = [:manifest].freeze
+            MANIFEST_VERSION = '1.2'.freeze
+
+            def initialize(doc:)
+              super(:manifest, 'manifest', doc: doc)
+
+              set_default_attributes!
+              add_file_entry(self_file_entry)
+            end
+
+            def version
+              MANIFEST_VERSION
+            end
+
+            # Adds a document to the manifest
+            # @param doc [XML::DocumentNode] the document to add
+            def add_entry_for(doc)
+              FileEntry.new(doc.path, manifest: self).tap { |e| add_file_entry(e) }
+            end
+
+            def add_child(child)
+              return add_file_entry(child) if child.is_a?(FileEntry)
+
+              child.tap { |c| other_children << c }
+            end
+
+            def children
+              [file_entries, other_children].flatten
+            end
+
+            private
+
+            def self_file_entry
+              FileEntry.new('/', manifest: self).tap do |entry|
+                entry.set_attribute('version', version)
+              end
+            end
+
+            def file_entries
+              @file_entries ||= []
+            end
+
+            def other_children
+              @other_children ||= []
+            end
+
+            def required_namespaces
+              @required_namespaces ||= REQUIRED_NAMESPACES.map { |p| Namespace.for_prefix(p) }
+            end
+
+            def add_file_entry(file_entry)
+              file_entry.tap { |fe| file_entries << fe }
+            end
+
+            def set_default_attributes!
+              required_namespaces.each { |ns| set_attribute(:xmlns, ns.prefix, ns.uri) }
+              set_attribute('version', version)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/berkeley_library/util/ods/xml/manifest_doc.rb

@@ -0,0 +1,26 @@
+require 'nokogiri'
+require 'berkeley_library/util/ods/xml/document_node'
+require 'berkeley_library/util/ods/xml/manifest/manifest'
+
+module BerkeleyLibrary
+  module Util
+    module ODS
+      module XML
+        class ManifestDoc < DocumentNode
+
+          def initialize
+            super('META-INF/manifest.xml')
+          end
+
+          def root_element_node
+            manifest
+          end
+
+          def manifest
+            @manifest ||= Manifest::Manifest.new(doc: doc)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/berkeley_library/util/ods/xml/namespace.rb

@@ -0,0 +1,46 @@
+require 'typesafe_enum'
+
+module BerkeleyLibrary
+  module Util
+    module ODS
+      module XML
+
+        class Namespace < TypesafeEnum::Base
+          new :CALCEXT, 'urn:org:documentfoundation:names:experimental:calc:xmlns:calcext:1.0'
+          new :CHART, 'urn:oasis:names:tc:opendocument:xmlns:chart:1.0'
+          new :DR3D, 'urn:oasis:names:tc:opendocument:xmlns:dr3d:1.0'
+          new :FIELD, 'urn:openoffice:names:experimental:ooo-ms-interop:xmlns:field:1.0'
+          new :FO, 'urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0'
+          new :FORM, 'urn:oasis:names:tc:opendocument:xmlns:form:1.0'
+          new :LOEXT, 'urn:org:documentfoundation:names:experimental:office:xmlns:loext:1.0'
+          new :MANIFEST, 'urn:oasis:names:tc:opendocument:xmlns:manifest:1.0'
+          new :META, 'urn:oasis:names:tc:opendocument:xmlns:meta:1.0'
+          new :OF, 'urn:oasis:names:tc:opendocument:xmlns:of:1.2'
+          new :OFFICE, 'urn:oasis:names:tc:opendocument:xmlns:office:1.0'
+          new :PRESENTATION, 'urn:oasis:names:tc:opendocument:xmlns:presentation:1.0'
+          new :SCRIPT, 'urn:oasis:names:tc:opendocument:xmlns:script:1.0'
+          new :STYLE, 'urn:oasis:names:tc:opendocument:xmlns:style:1.0'
+          new :SVG, 'urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0'
+          new :TABLE, 'urn:oasis:names:tc:opendocument:xmlns:table:1.0'
+          new :TEXT, 'urn:oasis:names:tc:opendocument:xmlns:text:1.0'
+
+          def prefix
+            key.to_s.downcase
+          end
+
+          def uri
+            value
+          end
+
+          class << self
+            def for_prefix(prefix)
+              @by_prefix ||= Namespace.map { |ns| [ns.prefix, ns] }.to_h
+              @by_prefix[prefix.to_s]
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/berkeley_library/util/ods/xml/office/automatic_styles.rb

@@ -0,0 +1,181 @@
+require 'berkeley_library/util/ods/xml/element_node'
+require 'berkeley_library/util/ods/xml/style/cell_style'
+require 'berkeley_library/util/ods/xml/style/column_style'
+require 'berkeley_library/util/ods/xml/style/row_style'
+require 'berkeley_library/util/ods/xml/style/style'
+require 'berkeley_library/util/ods/xml/style/table_style'
+
+module BerkeleyLibrary
+  module Util
+    module ODS
+      module XML
+        module Office
+          class AutomaticStyles < XML::ElementNode
+            # ------------------------------------------------------------
+            # Initializer
+
+            def initialize(doc:)
+              super(:office, 'automatic-styles', doc: doc)
+            end
+
+            # ------------------------------------------------------------
+            # Accessors
+
+            def default_style(family)
+              first_style = styles_for_family(family).first
+              return first_style if first_style
+
+              add_default_style(family)
+            end
+
+            # ------------------------------------------------------------
+            # Utility methods
+
+            # TODO: create a Stylesheet class and move most of this to it
+
+            # rubocop:disable Style/OptionalBooleanParameter
+            def add_cell_style(name = nil, protected = false, color = nil, font_weight: nil, wrap: false)
+              name ||= next_name_for(:table_cell)
+              add_style(Style::CellStyle.new(name, protected, color, font_weight: font_weight, wrap: wrap, styles: self))
+            end
+            # rubocop:enable Style/OptionalBooleanParameter
+
+            def add_column_style(name = nil, width = nil)
+              name ||= next_name_for(:table_column)
+              add_style(Style::ColumnStyle.new(name, width, styles: self))
+            end
+
+            def add_row_style(name = nil, height = nil)
+              name ||= next_name_for(:table_row)
+              add_style(Style::RowStyle.new(name, height, styles: self))
+            end
+
+            def add_table_style(name = nil)
+              name ||= next_name_for(:table)
+              add_style(Style::TableStyle.new(name, styles: self))
+            end
+
+            def add_style(style)
+              raise ArgumentError, "Not a style: #{style.inspect}" unless style.is_a?(Style::Style)
+
+              style.tap { |s| add_or_insert_style(s) }
+            end
+
+            # rubocop:disable Style/OptionalBooleanParameter
+            def find_cell_style(protected = false, color: nil, font_weight: nil, wrap: false)
+              styles_for_family(:table_cell).find { |s| [s.protected?, s.color, s.font_weight, s.wrap?] == [protected, color, font_weight, wrap] }
+            end
+            # rubocop:enable Style/OptionalBooleanParameter
+
+            def find_column_style(width = nil)
+              w = width || Style::ColumnStyle::DEFAULT_WIDTH
+              styles_for_family(:table_column).find { |s| s.width == w }
+            end
+
+            def find_row_style(height = nil)
+              h = height || Style::RowStyle::DEFAULT_HEIGHT
+              styles_for_family(:table_row).find { |s| s.height == h }
+            end
+
+            # rubocop:disable Style/OptionalBooleanParameter
+            def find_or_create_cell_style(protected = false, color: nil, font_weight: nil, wrap: false)
+              existing_style = find_cell_style(protected, color: color, font_weight: font_weight, wrap: wrap)
+              return existing_style if existing_style
+
+              add_cell_style(nil, protected, color, font_weight: font_weight, wrap: wrap)
+            end
+            # rubocop:enable Style/OptionalBooleanParameter
+
+            def find_or_create_column_style(width = nil)
+              existing_style = find_column_style(width)
+              return existing_style if existing_style
+
+              add_column_style(nil, width)
+            end
+
+            def find_or_create_row_style(height = nil)
+              existing_style = find_row_style(height)
+              return existing_style if existing_style
+
+              add_row_style(nil, height)
+            end
+
+            # ------------------------------------------------------------
+            # Public XML::ElementNode overrides
+
+            def add_child(child)
+              child.is_a?(Style::Style) ? add_style(child) : child.tap { |c| other_children << c }
+            end
+
+            # ------------------------------------------------------------
+            # Protected methods
+
+            protected
+
+            # ----------------------------------------
+            # Protected XML::ElementNode overrides
+
+            def children
+              [other_children, Style::Family.map { |f| styles_for_family(f) }].flatten
+            end
+
+            def create_element
+              Style::Family.each { |f| default_style(f) }
+
+              super
+            end
+
+            # ------------------------------------------------------------
+            # Private methods
+
+            private
+
+            def add_or_insert_style(s)
+              styles = styles_for_family(s.family)
+              insert_index = styles.find_index do |s1|
+                raise ArgumentError, "A #{s.family} style named #{s.style_name} already exists" if s1.style_name == s.style_name
+
+                s1 > s
+              end
+              insert_index ? styles.insert(insert_index, s) : styles << s
+            end
+
+            def add_default_style(family)
+              f = Style::Family.ensure_family(family)
+              return add_cell_style if f == Style::Family::TABLE_CELL
+              return add_column_style if f == Style::Family::TABLE_COLUMN
+              return add_row_style if f == Style::Family::TABLE_ROW
+              return add_table_style if f == Style::Family::TABLE
+            end
+
+            def next_name_for(family)
+              f = Style::Family.ensure_family(family)
+
+              max_suffix = styles_for_family(f).inject(0) do |max, s|
+                next max unless (n = s.style_name).start_with?(f.prefix)
+                next max unless (suffix = n[f.prefix.size..]) =~ /^[0-9]+$/
+
+                [max, suffix.to_i].max
+              end
+
+              "#{f.prefix}#{max_suffix + 1}"
+            end
+
+            def styles_for_family(family)
+              (styles_by_family[Style::Family.ensure_family(family)] ||= [])
+            end
+
+            def styles_by_family
+              @styles_by_family ||= {}
+            end
+
+            def other_children
+              @other_children ||= []
+            end
+
+          end
+        end
+      end
+    end
+  end
+end