odf-report 0.1.3

data/Manifest

@@ -0,0 +1,7 @@
+lib/odf-report.rb
+odf-report.gemspec
+Rakefile
+README.textile
+test/test.odt
+test/test.rb
+Manifest

data/README.textile

@@ -0,0 +1,181 @@
+h1. ODF-REPORT
+
+Gem for generating .odt files by making strings, images and tables substitutions in a previously created .odt file.
+
+<hr/>
+
+h3. INSTALL
+
+@gem install sandrods-odf-report --source=http://gems.github.com@
+
+<hr/>
+
+h3. USAGE
+
+h4. Step 1  --  the template
+
+First of all, you need to create a .odt file to serve as a template
+
+Templates are normal .odt files with placeholders for Substitutions
+
+There are now three kinds of substitutions available: *fields*, *tables* and *images*.
+
+h4. Fields placeholders
+
+It's just an upcase sentence, surrounded by brackets. It will be replaced for wathever value you supply.
+
+In the folowing example:
+
+<pre>
+report = ODFReport.new("Users/john/my_template.odt") do |r|
+
+  r.add_field :user_name, @user.name
+  r.add_field :address, "My new address"
+  
+end
+</pre>
+
+All occurences of @[USER_NAME]@ found in the file will be replaced by the value of @@user.name@ whereas all @[ADDRESS]@ 'es will contains @My new address@
+
+It's as simple as that.
+
+h4. Table placeholders
+
+To use table placeholders, you should create a Table in your document and give it a name. In OpenOffice, it's just a matter of right-clicking the table you just created, choose _Table Properties..._ and type a name in the Name field.
+
+If the table has two rows, the first one will be treated as a *header* and left untouched. Otherwise you should use a table with one row only.
+
+As with Field placeholders, just insert a @[FIELD_NAME]@ in each cell and let the magic takes place.
+
+Taking the folowing example:
+
+<pre>
+report = ODFReport.new("Users/john/my_template.odt") do |r|
+
+  r.add_field "USER_NAME", @user.nome
+  r.add_field "ADDRESS", @user.address
+
+  r.add_table("TABLE_1", @list_of_itens) do |row, item|
+    row["ITEM_ID"] = item.id
+    row["DESCRIPTION"] = "==> #{item.description}"
+  end
+
+end
+</pre>
+
+and considering you have a table like this in your template
+
+<pre>
+---------------------------------
+|  [ITEM_ID]  |  [DESCRIPTION]  |
+---------------------------------
+
+* this is my lame attempt to draw a table. 
+  you don't suppose to type this. 
+  you have to use an actual table. 
+  i don't know... just thought I'd mention it ;-)
+</pre>
+
+and a collection @list_of_itens, it will be created one row for each item in the collection, and the replacement will take place accordingly.
+
+Any format applied to the fields in the template will be preserved.
+
+h4. Images
+
+You must put a mock image in your odt template and give it a name. That name will be used to replace the mock image for the actual image.
+You can also assign any properties you want to the mock image and they will be kept once the image is replaced.
+
+An image replace would look like this:
+
+<pre>
+report = ODFReport.new("Users/john/my_template.odt") do |r|
+
+  r.add_image :graphics1, "/path/to/the/image.jpg"
+
+end
+</pre>
+
+And that's it.
+
+<hr/><br/>
+
+h4. Step 2  --  generating the document 
+
+It's fairly simple to generate the document. You can use this inside a Rails application or in a standalone script.
+
+h4. Generating a document in a Rails application 
+
+In a controller, you can have a code like this:
+	
+<pre>
+def print
+
+  @ticket = Ticket.find(params[:id])
+
+  report = ODFReport.new("#{RAILS_ROOT}/app/reports/ticket.odt") do |r|
+   
+    r.add_field(:id, @ticket.id.to_s)
+    r.add_field(:created_by, @ticket.created_by)
+    r.add_field(:created_at, @ticket.created_at.strftime("%d/%m/%Y - %H:%M"))
+    r.add_field(:type, @ticket.type.name)
+    r.add_field(:status, @ticket.status_text)
+    r.add_field(:date, Time.now.strftime("%d/%m/%Y - %H:%M"))
+    r.add_field(:solution, (@ticket.solution || ''))
+
+    r.add_table("OPERATORS", @ticket.operators) do | row, op |
+      row["OPERATOR_NAME"] = "#{op.name} (#{op.department.short_name})"
+    end
+   
+    r.add_table("FIELDS", @ticket.fields) do | row, field |
+     
+      if field.is_a?(String)
+        row["FIELD_NAME"] = 'Materials'
+        row["FIELD_VALUE"] = field
+      else
+        row["FIELD_NAME"] = field.name
+        row["FIELD_VALUE"] = field.text_value || ''
+      end
+
+    end
+
+  end
+
+  report_file_name = report.generate
+
+  send_file(report_file_name) 
+
+end
+</pre>
+
+The @generate@ method will, er... generate the document in a temp dir and returns the full path of the generated file, so you can send it back to the user.
+
+_That's all I have to say about that._
+
+h4. Generating a document in a standalone script 
+
+It's just the same as in a Rails app, but you can inform the path where the file will be generated instead of using a temp dir.
+
+<pre>
+report = ODFReport.new("ticket.odt") do |r|
+
+... populates the report ...
+
+end
+
+report.generate("./documents/")
+</pre>
+
+<hr/>
+
+h3. REQUIREMENTS
+
+*rubyzip*: for manipulating the contents of the odt file, since it's actually a zip file.
+
+
+<hr/>
+
+h3. THE FUTURE
+
+Well, this is my first attempt. This gem was extracted from an actual project we developed internally, to fulfill our specific needs.
+
+That said, I would really appreciate any input you can come up with. Critics, suggestions, bug reports are welcome and will be thoroughly examined.

data/Rakefile

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'rake'
+require 'echoe'
+
+Echoe.new('odf-report', '0.1.1') do |p|
+  p.description     = "Generates ODF files, given a template (.odt) and data, replacing tags"
+  p.url             = ""
+  p.author          = "Sandro Duarte"
+  p.email           = "sandrods@gmail.com"
+  p.ignore_pattern  = ["tmp/*", "script/*"]
+  p.development_dependencies = []
+  p.runtime_dependencies = ['rubyzip >= 0.9.1']
+end
+

data/lib/odf-report.rb

@@ -0,0 +1,218 @@
+require 'rubygems'
+require 'zip/zipfilesystem'
+require 'fileutils'
+
+class ODFReport
+
+  def initialize(template_name, &block)
+    @template = template_name
+    @data={:values=>{}, :tables=>{}, :images => {} }
+
+    @tmp_dir = Dir.tmpdir + "/" + random_filename(:prefix=>'odt_')
+    Dir.mkdir(@tmp_dir) unless File.exists? @tmp_dir
+
+    yield self
+  end
+
+  def add_field(field_tag, value)
+    @data[:values][field_tag] = value
+  end
+
+  def add_table(table_tag, collection, &block)
+
+    @data[:tables][table_tag] = []
+
+    collection.each do |item|
+      row = {}
+      yield(row, item)
+      @data[:tables][table_tag] << row
+    end
+
+  end
+
+  def add_image(name, path)
+    @data[:images][name] = path
+  end
+
+  def generate(dest = nil)
+
+    if dest
+
+      FileUtils.cp(@template, dest)
+      new_file = dest
+
+    else
+
+      FileUtils.cp(@template, @tmp_dir)
+      new_file = "#{@tmp_dir}/#{File.basename(@template)}"
+
+    end
+
+    %w(content.xml styles.xml).each do |content_file|
+
+      update_file_from_zip(new_file, content_file) do |txt|
+
+        replace_fields!(txt)
+        replace_tables!(txt)
+        replace_image_refs!(txt)
+      end
+
+    end
+
+    unless @data[:images].empty?
+      image_dir_name = "Pictures"
+      dir = File.join("#{@tmp_dir}", image_dir_name)
+      add_image_files_to_dir(dir)
+      add_dir_to_zip(new_file, dir, image_dir_name)
+    end
+
+    new_file
+
+  end
+
+private
+
+  def add_image_files_to_dir(dir)
+    FileUtils.mkdir(dir)
+    @data[:images].each_pair do |name, path|
+      FileUtils.cp(path, File.join(dir, File.basename(path)))
+    end
+  end
+
+  def add_dir_to_zip(zip_file, dir, entry)
+    Zip::ZipFile.open(zip_file, true) do |z|
+      Dir["#{dir}/**/*"].each { |f| z.add("#{entry}/#{File.basename(f)}", f) }
+    end
+  end
+
+  def update_file_from_zip(zip_file, content_file, &block)
+
+    Zip::ZipFile.open(zip_file) do |z|
+      cont = "#{@tmp_dir}/#{content_file}"
+
+      z.extract(content_file, cont)
+
+      txt = ''
+
+      File.open(cont, "r") do |f|
+        txt = f.read
+      end
+
+      yield(txt)
+
+      File.open(cont, "w") do |f|
+         f.write(txt)
+      end
+
+      z.replace(content_file, cont)
+    end
+
+  end
+
+
+  def replace_fields!(content)
+    hash_gsub!(content, @data[:values])
+  end
+
+  def replace_image_refs!(content)
+    @data[:images].each_pair do |image_name, path|
+      #Set the new image path
+      new_path = File.join("Pictures", File.basename(path))
+      #Search for the image
+      image_rgx = Regexp.new("draw:name=\"#{image_name}\".*?><draw:image.*?xlink:href=\"([^\s]*)\" .*?/></draw:frame>")
+      content_match = content.match(image_rgx)
+      if content_match
+        replace_path = content_match[1]
+        content.gsub!(content_match[0], content_match[0].gsub(replace_path, new_path))
+      end
+    end
+  end
+
+  def replace_tables!(content)
+
+    @data[:tables].each do |table_name, records|
+
+      # search for the table inside the content
+      table_rgx = Regexp.new("(<table:table table:name=\"#{table_name}.*?>.*?<\/table:table>)", "m")
+      table_match = content.match(table_rgx)
+
+      if table_match
+        table = table_match[0]
+
+        # extract the table from the content
+        content.gsub!(table, "[TABLE_#{table_name}]")
+
+        # search for the table:row's
+        row_rgx = Regexp.new("(<table:table-row.*?<\/table:table-row>)", "m")
+
+        # use scan (instead of match) as the table can have more than one table-row (header and data)
+        # and scan returns all matches
+        row_match = table.scan(row_rgx)
+
+        unless row_match.empty?
+
+          # If there more than one line in the table, takes the second entry (row_match[1])
+          # since the first one represents the column header.
+          # If there just one line, takes the first line. Besides, since the entry is an Array itself,
+          # takes the entry's first element ( entry[0] )
+          model_row = (row_match[1] || row_match[0])[0]
+
+          # extract the row from the table
+          table.gsub!(model_row, "[ROW_#{table_name}]")
+
+          new_rows = ""
+
+          # for each record
+          records.each do |_values|
+
+            # generates one new row (table-row), based in the model extracted
+            # from the original table
+            tmp_row = model_row.dup
+
+            # replace values in the model_row and stores in new_rows
+            hash_gsub!(tmp_row, _values)
+
+            new_rows << tmp_row
+          end
+
+          # replace back the lines into the table
+          table.gsub!("[ROW_#{table_name}]", new_rows)
+
+        end # unless row_match.empty?
+
+        # replace back the table into content
+        content.gsub!("[TABLE_#{table_name}]", table)
+
+      end # if table match
+
+    end # tables each
+
+  end # replace_tables
+
+  def hash_gsub!(_text, hash_of_values)
+    hash_of_values.each do |key, val|
+      _text.gsub!("[#{key.to_s.upcase}]", html_escape(val)) unless val.nil?
+    end
+  end
+
+  def random_filename(opts={})
+    opts = {:chars => ('0'..'9').to_a + ('A'..'F').to_a + ('a'..'f').to_a,
+            :length => 24, :prefix => '', :suffix => '',
+            :verify => true, :attempts => 10}.merge(opts)
+    opts[:attempts].times do
+      filename = ''
+      opts[:length].times { filename << opts[:chars][rand(opts[:chars].size)] }
+      filename = opts[:prefix] + filename + opts[:suffix]
+      return filename unless opts[:verify] && File.exists?(filename)
+    end
+    nil
+  end
+
+  HTML_ESCAPE = { '&' => '&amp;',  '>' => '&gt;',   '<' => '&lt;', '"' => '&quot;' }
+
+  def html_escape(s)
+    return "" unless s
+    s.to_s.gsub(/[&"><]/) { |special| HTML_ESCAPE[special] }
+  end
+
+end

data/odf-report.gemspec

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{odf-report}
+  s.version = "0.1.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Sandro Duarte"]
+  s.date = %q{2009-07-28}
+  s.description = %q{Generates ODF files, given a template (.odt) and data, replacing tags}
+  s.email = %q{sandrods@gmail.com}
+  s.extra_rdoc_files = ["lib/odf-report.rb", "README.textile"]
+  s.files = ["lib/odf-report.rb", "odf-report.gemspec", "Rakefile", "README.textile", "test/test.odt", "test/test.rb", "Manifest"]
+  s.has_rdoc = true
+  s.homepage = %q{}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Odf-report", "--main", "README.textile"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{odf-report}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Generates ODF files, given a template (.odt) and data, replacing tags}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rubyzip>, [">= 0", "= 0.9.1"])
+    else
+      s.add_dependency(%q<rubyzip>, [">= 0", "= 0.9.1"])
+    end
+  else
+    s.add_dependency(%q<rubyzip>, [">= 0", "= 0.9.1"])
+  end
+end

data/test/test.rb

@@ -0,0 +1,39 @@
+require '../lib/odf-report'
+
+col1 = []
+col1 << {:name=>"name 01",  :id=>"01",  :address=>"this is address 01"}
+col1 << {:name=>"name 03",  :id=>"03",  :address=>"this is address 03"}
+col1 << {:name=>"name 02",  :id=>"02",  :address=>"this is address 02"}
+col1 << {:name=>"name 04",  :id=>"04",  :address=>"this is address 04"}
+
+col2 = []
+col2 << {:name=>"josh harnet",  :id=>"02",    :address=>"testing <&> ",                 :phone=>99025668, :zip=>"90420-002"}
+col2 << {:name=>"sandro",       :id=>"45",    :address=>"address with &",               :phone=>88774451, :zip=>"90490-002"}
+col2 << {:name=>"ellen bicca",  :id=>"77",    :address=>"<address with escaped html>",  :phone=>77025668, :zip=>"94420-002"}
+
+report = ODFReport.new("test.odt") do |r|
+
+  r.add_field("HEADER_FIELD", "This &field was in the HEADER")
+
+  r.add_field("TAG_01", "New tag")
+  r.add_field("TAG_02", "TAG-2 -> New tag")
+
+  r.add_table("TABLE_01", col1) do |row, item|
+    row["FIELD_01"] = item[:id]
+    row["FIELD_02"] = item[:name]
+    row["FIELD_03"] = item[:address]
+  end
+
+  r.add_table("TABLE_02", col2) do |row, item|
+    row["FIELD_04"] = item[:id]
+    row["FIELD_05"] = item[:name]
+    row["FIELD_06"] = item[:address]
+    row["FIELD_07"] = item[:phone]
+    row["FIELD_08"] = item[:zip]
+  end
+
+  r.add_image("graphics1", File.join(Dir.pwd, 'piriapolis.jpg'))
+
+end
+
+report.generate("result.odt")

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: odf-report
+version: !ruby/object:Gem::Version 
+  version: 0.1.3
+platform: ruby
+authors: 
+- Sandro Duarte
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-28 00:00:00 -03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rubyzip
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 0.9.1
+    version: 
+description: Generates ODF files, given a template (.odt) and data, replacing tags
+email: sandrods@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- lib/odf-report.rb
+- README.textile
+files: 
+- lib/odf-report.rb
+- odf-report.gemspec
+- Rakefile
+- README.textile
+- test/test.odt
+- test/test.rb
+- Manifest
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Odf-report
+- --main
+- README.textile
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "1.2"
+  version: 
+requirements: []
+
+rubyforge_project: odf-report
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: Generates ODF files, given a template (.odt) and data, replacing tags
+test_files: []
+