redmine_api_helper 0.3.24

data/lib/odf_writer/table.rb

@@ -0,0 +1,135 @@
+# encoding: utf-8
+#
+# Ruby Gem to create a self populating Open Document Format (.odf) text file.
+#
+# Copyright  2021 Stephan Wenzel <stephan.wenzel@drwpatent.de>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+#
+
+module ODFWriter
+
+  ########################################################################################
+  #
+  # Table: poulate and grow tables
+  #
+  ########################################################################################
+  class Table
+  
+    include Nested
+    
+    attr_accessor :name, :collection, :proc
+    
+    ######################################################################################
+    #
+    # initialize
+    #
+    ######################################################################################
+    def initialize(options)
+      @name          = options[:name]
+      @field         = options[:field]
+      @collection    = options[:collection]
+      @proc          = options[:proc]
+      @key           = @field || @name
+         
+      @fields        = []
+      @texts         = []
+      @tables        = []
+      @images        = []
+      @bookmarks     = []
+      
+      @template_rows = []
+      @header        = options[:header] || false
+      @skip_if_empty = options[:skip_if_empty] || false
+      
+    end #def
+    
+    ######################################################################################
+    #
+    # replace!
+    #
+    ######################################################################################
+    def replace!(doc, manifest, file, row = nil)
+    
+      return unless table = find_table_node(doc)
+      
+      @template_rows = table.xpath("table:table-row")
+      
+      @header = table.xpath("table:table-header-rows").empty? ? @header : false
+      
+      @collection = items(row, @key, @proc) if row
+      
+      if @skip_if_empty && @collection.empty?
+        table.remove
+        return
+      end
+      
+      @collection.each do |item|
+      
+        new_node = get_next_row
+        #
+        # experimental: new node must be added to doc prior to replace!
+        #               else new_section does not have a name space
+        #
+        table.add_child(new_node)
+        
+        @tables.each    { |t| t.replace!(new_node, manifest, file, item) }
+        @texts.each     { |t| t.replace!(new_node, item) }
+        @fields.each    { |f| f.replace!(new_node, item) }
+        @images.each    { |f| f.replace!(new_node, manifest, file, item) }
+        
+      end
+      Image.unique_image_names( doc) if @images.present?
+      
+      @template_rows.each_with_index do |r, i|
+        r.remove if (get_start_node..template_length) === i
+      end
+      
+    end #def
+    
+    ######################################################################################
+    #
+    # private
+    #
+    ######################################################################################
+    private
+  
+    def get_next_row
+      @row_cursor = get_start_node unless defined?(@row_cursor)
+      
+      ret = @template_rows[@row_cursor]
+      if @template_rows.size == @row_cursor + 1
+        @row_cursor = get_start_node
+      else
+        @row_cursor += 1
+      end
+      return ret.dup
+    end #def
+    
+    def get_start_node
+      @header ? 1 : 0
+    end #def
+    
+    def template_length
+      @tl ||= @template_rows.size
+    end #def
+    
+    def find_table_node(doc)
+      tables = doc.xpath(".//table:table[@table:name='#{@name}']")
+      tables.empty? ? nil : tables.first
+    end #def
+    
+  end #class
+end #module

data/lib/odf_writer/table_reader.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+#
+# Ruby Gem to create a self populating Open Document Format (.odf) text file.
+#
+# Copyright  2021 Stephan Wenzel <stephan.wenzel@drwpatent.de>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+#
+
+module ODFWriter
+  
+  ########################################################################################
+  #
+  # TableReader: find all tables and set name
+  #
+  ########################################################################################
+  class TableReader
+    
+    attr_accessor :name
+    
+    ######################################################################################
+    #
+    # initialize
+    #
+    ######################################################################################
+    def initialize(opts)
+      @name = opts[:name]
+    end #def
+    
+    ######################################################################################
+    #
+    # tables
+    #
+    ######################################################################################
+    def tables( doc )
+      nodes( doc ).keys
+    end #def
+    
+    ######################################################################################
+    #
+    # nodes
+    #
+    ######################################################################################
+    def nodes( doc )
+      doc.xpath(".//table:table").map{|node| [node.attr("table:name"), node] }.to_h
+    end #def
+  end #class
+  
+end #module

data/lib/odf_writer/template.rb

@@ -0,0 +1,222 @@
+# encoding: utf-8
+#
+# Ruby Gem to create a self populating Open Document Format (.odf) text file.
+#
+# Copyright  2021 Stephan Wenzel <stephan.wenzel@drwpatent.de>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+#
+
+module ODFWriter
+
+  ########################################################################################
+  #
+  # Template: handles files in .odt-package
+  #
+  ########################################################################################
+  class Template
+    
+    ######################################################################################
+    #
+    # constants - we only work and content and styles (contains headers and footers) parts of odf
+    #
+    ######################################################################################
+    CONTENT_ENTRIES = {
+      "content.xml"  => {:symbol => :content,  :path => "content.xml"},
+      "styles.xml"   => {:symbol => :styles,   :path => "styles.xml" }
+    }.freeze
+    
+    CONTENT_FILES = {
+      :content       => {:file => "content.xml",  :path => "content.xml"},
+      :styles        => {:file => "styles.xml",   :path => "styles.xml" }
+    }.freeze
+    
+    MANIFEST       = 'META-INF/manifest.xml'.freeze
+    
+    ######################################################################################
+    #
+    # accessors
+    #
+    ######################################################################################
+    attr_accessor :output_stream
+    
+    ######################################################################################
+    #
+    # initialize
+    #
+    ######################################################################################
+    def initialize(path = nil, zip_stream: nil)
+    
+      raise "You must provide either a filename or a zip_stream: string" unless path || zip_stream
+      raise "Template [#{template}] not found." if path && !::File.exist?(path)
+      
+      @path       = path
+      @zip_stream = zip_stream
+    end #def
+    
+    ######################################################################################
+    #
+    # content
+    #
+    ######################################################################################
+    def content(&block)
+    
+      entries.each do |entry|
+      
+        if entry.directory?
+          next
+          
+        elsif CONTENT_ENTRIES.keys.include?(entry.name)
+          # relevant file with valid file name
+          entry.get_input_stream do |input_stream|
+            file_content = input_stream.sysread
+            yield CONTENT_ENTRIES[entry.name][:symbol], to_xml(file_content)
+          end
+          
+        end #if
+      end #each
+    end #def
+    
+    ######################################################################################
+    #
+    # update_content: create write buffer for zip 
+    #
+    ######################################################################################
+    def update_content
+      @buffer = Zip::OutputStream.write_buffer do |out|
+        @output_stream = out
+        yield self
+      end
+    end
+    
+    ######################################################################################
+    #
+    # update_files: open and traverse zip directory, pick content.xml 
+    #               and styles.xml process and eventually write contents 
+    #               to buffer
+    #               a pointer to manifest.xml is provided
+    #
+    ######################################################################################
+    def update_files(&block)
+      
+      # get manifest, in case a file is added
+      @manifest = manifest; digest = Digest::MD5.hexdigest(@manifest)
+      
+      entries.each do |entry|
+      
+        # search content files
+        if entry.directory?
+          next
+          
+        # process content files
+        elsif CONTENT_ENTRIES.keys.include?(entry.name)
+        
+          entry.get_input_stream do |input_stream|
+            file_content = input_stream.sysread
+            file_symbol  = CONTENT_ENTRIES[entry.name][:symbol]
+            process_entry(file_symbol, file_content, @manifest, &block)
+            @output_stream.put_next_entry(entry.name)
+            @output_stream.write file_content
+          end #do
+          
+        else
+          entry.get_input_stream do |input_stream|
+            @output_stream.put_next_entry(entry.name)
+            @output_stream.write input_stream.sysread
+          end
+        end #if
+      end #each
+      
+      # eventually write back content file
+      if @manifest && digest != Digest::MD5.hexdigest(@manifest)
+        @output_stream.put_next_entry(MANIFEST)
+        @output_stream.write @manifest
+      end #if
+      
+    end #def
+    
+    
+    ######################################################################################
+    #
+    # data: just a handle to data in buffer
+    # 
+    ######################################################################################
+    def data
+      @buffer.string
+    end
+    
+    ######################################################################################
+    #
+    # private
+    # 
+    ######################################################################################
+    private
+    
+    ######################################################################################
+    # entries: just open zip file or buffer
+    ######################################################################################
+    def entries
+      if @path
+        Zip::File.open(@path)
+      elsif @zip_stream
+        Zip::File.open_buffer(@zip_stream.force_encoding("ASCII-8BIT"))
+      end
+    end #def
+    
+    ######################################################################################
+    # manifest: read manifest 
+    ######################################################################################
+    def manifest
+      manifest = nil
+      entries.each do |entry|
+        next if entry.directory?
+        entry.get_input_stream do |input_stream|
+          if MANIFEST == entry.name
+            manifest = input_stream.sysread.dup
+          end
+        end
+      end
+      manifest
+    end #def
+    
+    ######################################################################################
+    # to_xml
+    ######################################################################################
+    def to_xml(raw_xml)
+      Nokogiri::XML(raw_xml)
+    end #def
+    
+    ######################################################################################
+    # process_entry: provide Nokogiri Object to caller, after having provided a file
+    ######################################################################################
+    def process_entry(file_symbol, file_content, manifest)
+    
+      # create xml from file content
+      doc = to_xml(file_content ) # { |x| x.noblanks }
+      man = to_xml(manifest     ) # { |x| x.noblanks }
+      
+      # yield xml
+      yield file_symbol, doc, man
+      
+      # replace file_content and manifest in place
+      # remove spurious whitespaces between tags ">  <" becomes "><"
+      file_content.replace(doc.to_xml(save_with: Nokogiri::XML::Node::SaveOptions::AS_XML).squish.gsub(/(?<=>)\s+(?=<)/, ""))
+      # Microsoft Words complains if no trailing newline is present
+      manifest.replace(man.to_xml(save_with: Nokogiri::XML::Node::SaveOptions::AS_XML))
+      
+    end #def
+    
+  end #class
+end #module

data/lib/odf_writer/text.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+#
+# Ruby Gem to create a self populating Open Document Format (.odf) text file.
+#
+# Copyright  2021 Stephan Wenzel <stephan.wenzel@drwpatent.de>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+#
+
+module ODFWriter
+
+  ########################################################################################
+  #
+  # Text: replace text items
+  #
+  ########################################################################################
+  class Text < Field
+  
+    ######################################################################################
+    #
+    # constants
+    #
+    ######################################################################################
+    DELIMITERS = %w({ })
+    
+    ######################################################################################
+    #
+    # replace!
+    #
+    ######################################################################################
+    def replace!(content, item = nil)
+    
+      return unless node = find_text_node(content)
+      
+      text = value(item)
+      
+      @parser = Parser::Default.new(text, node, 
+        :doc                 => content,
+        :remove_classes      => @remove_classes,
+        :remove_class_prefix => @remove_class_prefix,
+        :remove_class_suffix => @remove_class_suffix
+      )
+      
+      @parser.paragraphs.each do |p|
+        node.before(p)
+      end
+      
+      node.remove
+      
+    end #def
+    
+    ######################################################################################
+    #
+    # private
+    #
+    ######################################################################################
+    private
+    
+    ######################################################################################
+    # find_text_node
+    ######################################################################################
+    def find_text_node(doc)
+      texts = doc.xpath(".//text:p[text()='#{placeholder}']")
+      if texts.empty?
+        texts = doc.xpath(".//text:p/text:span[text()='#{placeholder}']")
+        if texts.empty?
+          texts = nil
+        else
+          texts = texts.first.parent
+        end
+      else
+        texts = texts.first
+      end
+      
+      texts
+    end #def
+    
+    ######################################################################################
+    # placeholder
+    ######################################################################################
+    def placeholder
+      "#{DELIMITERS[0]}#{@name.to_s.upcase}#{DELIMITERS[1]}"
+    end #def
+  end #class
+end #module