documatic 0.0.1

data/README

@@ -0,0 +1,29 @@
+= Documatic
+
+Documatic is an OpenDocument processor for Ruby. It can be used to
+produce attractive printable documents such as database reports,
+invoices, letters, faxes and more. Both the data inputs and the
+printable output are very flexible and easy to configure.
+
+
+== Installation
+
+Documatic can be installed via Rubygems.
+
+  % gem install documatic
+
+
+== Licence
+
+Documatic is (p) Public Domain 2007, no rights reserved.
+
+Documatic comes with no warranty whatsoever.
+
+
+== Support
+
+Further information is available on the Documatic homepage at
+http://documatic.240gl.org.
+
+The Documatic project page (including tracker) is at
+http://rubyforge.org/projects/documatic.

data/lib/documatic/component.rb

@@ -0,0 +1,78 @@
+require 'erb'
+
+module Documatic
+  class Component
+    include ERB::Util
+    include Documatic::Helper
+    
+    attr_accessor :erb
+    
+    def initialize(erb_text)
+      @erb = ERB.new(erb_text)
+    end
+    
+    # Injects the provided assigns into this component and sends it through ERB.
+    def process(local_assigns)
+      if local_assigns.is_a? Binding
+        context = local_assigns
+      else  # Hash
+        local_assigns.each do |key, val|
+          self.define_singleton_method(key) do val end
+        end
+        context = binding
+      end
+
+      @xml = nil ; @text = self.erb.result(context)
+    end
+
+    # Returns a REXML::Document constructed from the text of this
+    # component.  Note that this flushes self.text: subsequently if
+    # self.text is called it will be reconstructed from this XML
+    # document and self.xml will be flushed.  Therefore the content of
+    # this partial is always stored either as XML or text, never both.
+    def xml
+      @xml ||= REXML::Document.new( remove_instance_variable(:@text) )
+    end
+
+    # Returns the text of this component.  Note that this flushes
+    # self.xml: subsequently if self.xml is called it will be
+    # reconstructed from this text and self.text will be flushed.
+    def text
+      @text ||= ( remove_instance_variable(:@xml) ).to_s
+    end
+
+    # Merge the auto-styles from the cached partials into
+    # <office:automatic-styles> of this component.  This method isn't
+    # intended to be called directly by client applications: it is
+    # called automatically by Documatic::Template after processing.
+    def merge_partial_styles
+      cache = Documatic::Partial.cache_by_prefix
+      if cache.length > 0
+        styles = self.xml.root.elements['office:automatic-styles']
+        if styles
+          cache.each_value do |partial|
+            partial.styles.each_element do |e|
+              styles << e
+            end
+          end
+        end
+      end
+    end
+    
+    # to_s() is a synonym for text()
+    alias_method :to_s, :text
+
+
+    protected
+    
+    # Adds methods to the singleton class representing the current
+    # instance.  Useful for injecting faux local variables into an
+    # instance object.
+    # Courtesy John Hume,
+    # http://practicalruby.blogspot.com/2007/02/ruby-metaprogramming-introduction.html
+    def define_singleton_method(name, &body)
+      (class << self ; self ; end).send(:define_method, name, &body)
+    end
+    
+  end
+end

data/lib/documatic/helper.rb

@@ -0,0 +1,53 @@
+require 'erb'
+
+module Documatic
+  module Helper
+
+    include ERB::Util
+    
+
+    # Inserts a paragraph (<text:p>) containing the provided content;
+    # or nothing if no content is provided.  This helper should be
+    # invoked from within "Ruby Block" because paragraphs are
+    # block-level elements.
+    # 
+    # Note that the content is not escaped by default because you
+    # might want to include other tags in the content.  You should use
+    # ERB::Util.h() to escape any content that could possibly contain
+    # XML characters.
+    def para(stylename, content = nil)
+      end_element = ( content ? ">#{content}</text:p>" : "/>" )
+      %Q(<text:p text:style-name="#{stylename}"#{end_element})
+    end
+
+    # Inserts a text span (<text:span>) containing the provided
+    # content.  This helper should be invoked from within "Ruby
+    # Literal" because the tag is a text-level element that shouldn't
+    # be escaped.  However the content is escaped.
+    def span(stylename, content)
+      %Q(<text:span text:style-name="#{stylename}">#{ERB::Util.h(content)}</text:span>)
+    end
+
+
+    # Inserts a partial into the document at the chosen position.
+    # This helper should be invoked from within "Ruby Block" because
+    # it inserts unescaped block-level material in the current
+    # template.
+    # 
+    # The +assigns+ hash is passed through to the partial for binding.
+    # 
+    # This method will add the provided partial to the
+    # Documatic::Partial cache if it hasn't yet been loaded; or if it
+    # has been loaded then the existing partial will be re-used.
+    def partial(filename, *assigns)
+      if Documatic::Partial.cache.has_key?(filename)
+        p = Documatic::Partial.cache[filename]
+      else
+        p = Documatic::Partial.new(filename)
+        Documatic::Partial.add_partial(filename, p)
+      end
+      p.process(*assigns)
+    end
+
+  end
+end

data/lib/documatic/partial.rb

@@ -0,0 +1,124 @@
+require 'rexml/document'
+
+module Documatic
+  class Partial < Documatic::Template
+
+    attr_accessor :content
+    attr_accessor :filename
+
+    class << self
+      def add_partial(name, partial)
+        self.cache[name] = partial
+      end
+
+      def cache
+        @cache ||= Hash.new
+      end
+
+      def cache_by_prefix
+        by_prefix = Hash.new
+        self.cache.each_value do |partial|
+          by_prefix[partial.prefix] = partial
+        end
+        by_prefix
+      end
+        
+      def flush_cache
+        @cache = Hash.new
+      end
+        
+    end  # class << self
+    
+    def initialize(filename, prefix_name = nil)
+      super filename
+      @prefix = prefix_name || self.prefix
+    end
+
+    def process(local_assigns = {})
+      self.zip_file.find_entry('documatic/partial') || self.compile
+      @content = Documatic::Component.new( self.content_erb )
+      @content.process(local_assigns)
+    end
+
+    def compile
+      doc = REXML::Document.new( self.zip_file.read('content.xml') )
+      style_names = Hash.new
+
+      # Gather all auto style names from <office:automatic-styles>
+      doc.root.each_element('office:automatic-styles/*') do |e|
+        attr = e.attributes.get_attribute('style:name')
+        attr && style_names[attr.value] = attr
+      end
+
+      # Replace all auto styles in the document's attributes with the prefixed form.
+      doc.each_element('//*') do |e|
+        e.attributes.each_attribute do |attr|
+          if style_names.has_key? attr.value
+            e.add_attribute(attr.expanded_name, "#{self.prefix}_#{attr.value}")
+          end
+        end
+      end
+
+      # Create 'documatic/partial/' in zip file
+      self.zip_file.find_entry('documatic/partial') || self.zip_file.mkdir('documatic/partial')
+      
+      # Save the prefix in documatic/partial.txt
+      self.zip_file.get_output_stream('documatic/partial/partial.txt') do |f|
+        f.write self.prefix
+      end
+
+      # Set @styles, & save it in documatic/styles.xml
+      @styles = doc.root.elements['office:automatic-styles']
+      self.zip_file.get_output_stream('documatic/partial/styles.xml') do |f|
+        f.write @styles.to_s
+      end
+
+      # Get body text, erbify it, keep it in @content and save it in documatic/content.erb
+      body_text = doc.root.elements['office:body/office:text']
+      body_text.elements.delete('text:sequence-decls')
+      body_text.elements.delete('office:forms')
+      @content_erb = self.erbify( (body_text.elements.to_a.collect do |e| e.to_s ; end ).join )
+      self.zip_file.get_output_stream('documatic/partial/content.erb') do |f|
+        f.write @content_erb
+      end
+
+    end
+
+    # Partials aren't saved in the same way that templates are: this is a no-op.
+    def save ; end
+    
+    def prefix
+      if not @prefix
+        if self.zip_file.find_entry('documatic/partial/partial.txt')
+          @prefix = self.zip_file.read('documatic/partial/partial.txt')
+        else
+          @prefix = File.basename(self.filename, '.odt').gsub(/[^A-Za-z0-9_]/, '_')
+        end
+      end
+      return @prefix
+    end
+
+    def content_erb
+      if not @content_erb
+        if self.zip_file.find_entry('documatic/partial/content.erb')
+          self.zip_file.read('documatic/partial/content.erb')
+        else
+          self.compile
+        end
+      end
+      @content_erb
+    end
+
+    def styles
+      if not @styles
+        if self.zip_file.find_entry('documatic/partial/styles.xml')
+          @styles = REXML::Document.new( self.zip_file.read('documatic/partial/styles.xml') ).root
+        else
+          self.compile
+        end
+      end
+      @styles
+    end
+    
+  end
+end

data/lib/documatic/template.rb

@@ -0,0 +1,303 @@
+require 'rexml/text'
+require 'rexml/attribute'
+require 'zip/zip'
+require 'erb'
+
+module Documatic
+  class Template
+    include ERB::Util
+    
+    attr_accessor :content
+    attr_accessor :styles
+    attr_accessor :zip_file
+    # The raw contents of 'content.xml'.
+    attr_accessor :content_raw
+    # Compiled text, to be written to 'content.erb'
+    attr_accessor :content_erb
+    # The raw contents of 'styles.xml'
+    attr_accessor :styles_raw
+    # Compiled text, to be written to 'styles.erb'
+    attr_accessor :styles_erb
+
+    # RE_STYLES match positions
+    STYLE_NAME = 1
+    STYLE_TYPE = 2
+    
+    # RE_ERB match positions
+    TYPE       =  5
+    ERB_CODE   =  6
+    
+    ROW_START  =  1
+    ROW_END    = 11
+
+    ITEM_START =  2
+    ITEM_END   = 10
+    
+    PARA_START =  3
+    PARA_END   =  9
+    
+    SPAN_END   =  4
+    SPAN_START =  8
+  
+    # Match types:
+    TABLE_ROW = 1
+    PARAGRAPH = 2
+    INLINE_CODE = 3
+    VALUE = 4
+
+    class << self
+
+      # Includes the number and text helpers from Rails' ActionPack.
+      # Requires that the Rails gems be installed.
+      def include_rails_helpers
+        require 'action_pack'
+        require 'action_controller'
+        require 'action_view'
+
+        require 'action_view/helpers/number_helper'
+        require 'action_view/helpers/text_helper'
+
+        [self, Documatic::Partial].each do |klass|
+          klass.class_eval do
+            include ActionView::Helpers::NumberHelper
+            include ActionView::Helpers::TextHelper
+          end
+        end
+      end
+
+    end  # class << self
+    
+    def initialize(filename)
+      @filename = filename
+      @zip_file = Zip::ZipFile.open(@filename)
+      return true
+    end
+    
+    def process(local_assigns = {})
+      # Compile this template, if not compiled already.
+      self.zip_file.find_entry('documatic/master') || self.compile
+      # Process the styles (incl. headers and footers).
+      # This is conditional because partials don't need styles.erb.
+      @styles = Documatic::Component.new( self.zip_file.read('documatic/master/styles.erb') )
+      @styles.process(local_assigns)
+      # Process the main (body) content.
+      @content = Documatic::Component.new( self.zip_file.read('documatic/master/content.erb') )
+      @content.process(local_assigns)
+      @content.merge_partial_styles
+    end
+
+    def save
+      # Gather all the styles from the partials, add them to the master's styles.
+      # Put the body into the document.
+      self.zip_file.get_output_stream('content.xml') do |f|
+        f.write self.content.to_s
+      end
+
+      if self.styles
+        self.zip_file.get_output_stream('styles.xml') do |f|
+          f.write self.styles.to_s
+        end
+      end
+    end
+
+    def close
+      self.zip_file.close
+    end
+    
+    def compile
+      # Read the raw files
+      @content_raw = self.zip_file.read('content.xml')
+      @styles_raw = self.zip_file.read('styles.xml')
+      
+      @content_erb = self.erbify(@content_raw)
+      @styles_erb = self.erbify(@styles_raw)
+
+      # Create 'documatic/master/' in zip file
+      self.zip_file.find_entry('documatic/master') || self.zip_file.mkdir('documatic/master')
+      
+      self.zip_file.get_output_stream('documatic/master/content.erb') do |f|
+        f.write @content_erb
+      end
+      self.zip_file.get_output_stream('documatic/master/styles.erb') do |f|
+        f.write @styles_erb
+      end
+    end
+
+
+    protected
+
+    # Change OpenDocument line breaks and tabs in the ERb code to regular characters.
+    def unnormalize(code)
+      code = code.gsub(/<text:line-break\/>/, "\n")
+      code = code.gsub(/<text:tab\/>/, "\t")
+      return REXML::Text.unnormalize(code)
+    end
+
+    # Massage OpenDocument XML into ERb.  (This is the heart of the compiler.)
+    def erbify(code, escape = true)
+      # First gather all the ERb-related derived styles
+      remaining = code
+      styles = {'Ruby_20_Code' => 'Code', 'Ruby_20_Value' => 'Value',
+        'Ruby_20_Block' => 'Block', 'Ruby_20_Literal' => 'Literal'}
+      re_styles = /<style:style style:name="([^"]+)" style:family="text" style:parent-style-name="Ruby_20_(Code|Value|Block|Literal)">/
+      
+      while remaining.length > 0
+        md = re_styles.match remaining
+        if md
+          styles[md[STYLE_NAME]] = md[STYLE_TYPE]
+          remaining = md.post_match
+        else
+          remaining = ""
+        end
+      end
+      
+      remaining = code
+      result = String.new
+      
+      # Then make a RE that includes the ERb-related styles.
+      # Match positions:
+      # 
+      #  1. ROW_START   Begin table row ?
+      #  2. ITEM_START  Begin list item ?
+      #  3. PARA_START  Begin paragraph ?
+      #  4. SPAN_END    Another text span ends immediately before ERb ?
+      #  5. TYPE        ERb text style type
+      #  6. ERB_CODE    ERb code
+      #  7.             (ERb inner brackets)
+      #  8. SPAN_START  Another text span begins immediately after ERb ?
+      #  9. PARA_END    End paragraph ?
+      # 10. ITEM_END    End list item ?
+      # 11. ROW_END     End table row (incl. covered rows) ?
+      #
+      # "?": optional, might not occur every time
+      re_erb = /(<table:table-row><table:table-cell [^>]+>)?(<text:list-item>)?(<text:p [^>]+>)?(<\/text:span>)?<text:span text:style-name="(#{styles.keys.join '|'})">(([^<]*|<text:line-break\/>|<text:tab\/>)+)<\/text:span>(<text:span [^>]+>)?(<\/text:p>)?(<\/text:list-item>)?(<\/table:table-cell>(<table:covered-table-cell\/>)*<\/table:table-row>)?/
+
+      # Then search for all text using those styles
+      while remaining.length > 0
+
+        md = re_erb.match remaining
+        
+        if md
+          
+          ###       TESTING ONLY
+          #          puts "#{md[ERB_CODE]}:"
+          #          for i in 1 ... md.size do
+          #            puts "\t#{i}: #{md[i]}"
+          #          end
+          #          puts ""
+          
+          result += md.pre_match
+          
+          match_code = false
+          match_row  = false
+          match_item = false
+          match_para = false
+          match_span = false
+
+          if styles[md[TYPE]] == 'Code'
+            match_code = true
+            delim_start = '<% ' ; delim_end = ' %>'
+            if md[PARA_START] and md[PARA_END]
+              match_para = true
+              if md[ITEM_START] and md[ITEM_END]
+                match_item = true
+              end
+              if md[ROW_START] and md[ROW_END]
+                match_row = true
+              end
+            end
+          elsif styles[md[TYPE]] == 'Block'
+            delim_start = '<%= ' ; delim_end = ' %>'
+            if md[PARA_START] and md[PARA_END]
+              match_para = true
+            end
+          else  # style is Value or Literal
+            if (not escape) || (styles[md[TYPE]] == 'Literal')
+              delim_start = '<%= ' ; delim_end = ' %>'
+            else
+              delim_start = '<%= ERB::Util.h(' ; delim_end = ') %>'
+            end
+            
+            if md[SPAN_END] and md[SPAN_START]
+              match_span = true
+            end
+          end
+          
+          if md[ROW_START] and not match_row
+            result += md[ROW_START]
+          end
+
+          if md[ITEM_START] and not match_item
+            result += md[ITEM_START]
+          end
+          
+          if md[PARA_START] and not match_para
+            result += md[PARA_START]
+          end
+          
+          # Text formatting before ERb
+          if match_code
+            if md[SPAN_END]
+              result += md[SPAN_END]
+            end
+          else
+            if md[SPAN_START] and not md[SPAN_END]
+              result += md[SPAN_START]
+            end
+          end
+          #         if md[SPAN_START] and not match_span
+          #           result += md[SPAN_START]
+          #         end
+          
+          result += "#{delim_start}#{self.unnormalize md[ERB_CODE]}#{delim_end}"
+          
+          # Text formatting after ERb
+          if match_code
+            if md[SPAN_START]
+              result += md[SPAN_START]
+            end
+          else
+            if md[SPAN_END]
+              result += md[SPAN_END]
+              if md[SPAN_START]
+                result += md[SPAN_START]
+              end
+            end
+          end
+
+          #         if md[SPAN_END] and not match_span
+          #           result += md[SPAN_END]
+          #         end
+          
+          if md[PARA_END] and not match_para
+            result += md[PARA_END]
+          end
+
+          if md[ITEM_END] and not match_item
+            result += md[ITEM_END]
+          end
+          
+          if md[ROW_END] and not match_row
+          result += md[ROW_END]
+          end
+          
+          remaining = md.post_match
+          
+        else  # no further matches
+          result += remaining
+          remaining = ""
+        end
+      end
+      
+      return result
+    end
+
+  end
+end
+
+# Force REXML to use double-quotes (consistent with OOo).
+REXML::Attribute.class_eval do
+  def to_string
+    %Q[#@expanded_name="#{to_s().gsub(/"/, '&quot;')}"]
+  end
+end

data/lib/documatic.rb

@@ -0,0 +1,7 @@
+require 'documatic/helper'
+require 'documatic/template'
+require 'documatic/component'
+require 'documatic/partial'
+
+module Documatic
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: documatic
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2007-05-16 00:00:00 +10:00
+summary: Documatic is a Ruby OpenDocument processor for preparing documents and reports.
+require_paths: 
+- lib
+email: urbanus@240gl.org
+homepage: http://documatic.240gl.org
+rubyforge_project: documatic
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: []
+
+files: 
+- lib
+- lib/documatic
+- lib/documatic.rb
+- lib/documatic/template.rb
+- lib/documatic/component.rb
+- lib/documatic/helper.rb
+- lib/documatic/partial.rb
+- tests
+- README
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rubyzip
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.1
+    version: