odf-report 0.5.2 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 639774f385b52ff5939a37b9e5d46f0ef32883fa
-  data.tar.gz: 518447cce1c1ccae65960ffd0d75b617f3bb48bf
+SHA256:
+  metadata.gz: c8d30a8580192ffaf7fa4908a5b674e69ecef19a5c3fe054baeaf1e72c3770ad
+  data.tar.gz: e402b3a61216a3070cdfcc0799930038ed9cd37687c7a844eaf76ead2b55a704
 SHA512:
-  metadata.gz: 823da1a19f5c7fa4d44d2f130fd208658fe38472ea252c71427e2a5580126f882c40ba5a3ccb0d4bcc55e93e54d739fd22142fc3cfb540696fa0d52539227fdd
-  data.tar.gz: ba034ba239cd822fccb1c08e2586d33aa3c7ffd9268dc372fbac54cdd5b7f2b09f63d7aa69e48b83bcc1056cd64d4e4ced757c226771eaf999428f5144f33518
+  metadata.gz: 72e8c9581c0f655dd1ba4ef5dcfd11706f36a2e69d810261fb7f233d72f0cb982a298da7f24055d7561551f3ac737abf018809ea982d495661e0386895ee75bf
+  data.tar.gz: 9113f76a643655aa46227a0390c425cca828ba2c05835eb33d3894c7cb2219253bda16c109bf885148e63736671be3389abe804782a196ca860fb958b786ecf5

data/.github/workflows/gem-push.yml

@@ -0,0 +1,40 @@
+name: Ruby Gem
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  build:
+    name: Build + Publish
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby 2.6
+      uses: actions/setup-ruby@v1
+      with:
+        version: 2.6.x
+
+#     - name: Publish to GPR
+#       run: |
+#         mkdir -p $HOME/.gem
+#         touch $HOME/.gem/credentials
+#         chmod 0600 $HOME/.gem/credentials
+#         printf -- "---\n:github: Bearer ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
+#         gem build *.gemspec
+#         gem push --KEY github --host https://rubygems.pkg.github.com/${OWNER} *.gem
+#       env:
+#         GEM_HOST_API_KEY: ${{secrets.GPR_AUTH_TOKEN}}
+#         OWNER: username
+
+    - name: Publish to RubyGems
+      run: |
+        mkdir -p $HOME/.gem
+        touch $HOME/.gem/credentials
+        chmod 0600 $HOME/.gem/credentials
+        printf -- "---\n:rubygems_api_key: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
+        gem build *.gemspec
+        gem push *.gem
+      env:
+        GEM_HOST_API_KEY: ${{secrets.RUBYGEMS_AUTH_TOKEN}}

data/.gitignore

@@ -5,3 +5,4 @@ doc
 test/result
 spec/result
 Gemfile.lock
+.DS_Store

data/CHANGELOG.md

@@ -0,0 +1,62 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+
+## Unreleased
+
+### Breaking Changes
+
+- None
+
+### Added
+
+- None
+
+### Fixed
+
+- None
+
+## 0.7.2
+
+### Fixed
+
+- files being recognized as "broken file" in Microsoft Word
+
+
+## 0.7.1
+
+### Added
+
+- remove image if path is null
+- remove section if collection is empty/null
+
+
+## 0.7.0
+
+### Added
+
+- allow nested images inside tables and sections
+- allow sections inside tables
+
+### Dependencies
+
+- rubyzip >= 1.3.0 (was ~> 1.2.0)
+
+
+## 0.6.0
+
+### Breaking Changes
+
+- `ODFReport::File` renamed to `ODFReport::Template`
+- `ODFReport::Report` constructor signature changed
+
+### Dependencies
+
+- rubyzip ~> 1.2.0 (was ~> 1.1.0)
+
+
+## Earlier Versions
+
+- No docs yet. Contributions welcome!

data/README.md

@@ -0,0 +1,220 @@
+
+# ODF-REPORT
+
+Gem for generating .odt files by making strings, images, tables and sections replacements in a previously created .odt file.
+
+## INSTALL
+
+In your Gemfile
+```ruby
+gem 'odf-report'
+```
+
+## USAGE
+
+### Step 1  --  the template
+
+First of all, you need a `.odt` file to serve as a template.
+Templates are normal .odt files with `[PLACEHOLDERS]` for *substitutions*.
+There are *four* kinds of substitutions available:
+* fields
+* tables
+* images
+* sections
+
+#### Fields
+
+It's just an upcase sentence, surrounded by brackets. It will be replaced by the value you supply.
+
+In the folowing example:
+
+```ruby
+report = ODFReport::Report.new("Users/john/my_template.odt") do |r|
+  r.add_field :user_name, @user.name
+  r.add_field :address, "My new address"
+end
+```
+
+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`
+
+
+#### Tables
+
+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 you inform `header: true`, the first row will be treated as a *header* and left untouched. The remaining rows will be used as the template for the table.
+
+If you have more than one template row, they will be cycled. This is usefull for making zebra tables.
+
+As with **Field placeholders**, just insert a `[FIELD_NAME]` in each cell and let the magic takes place.
+
+Taking the folowing example:
+
+```ruby
+report = ODFReport::Report.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, :header=>true) do |t|
+    t.add_column(:item_id, :id)
+    t.add_column(:description) { |item| "==> #{item.description}" }
+  end
+
+end
+```
+
+and considering you have a table like this in your template
+
+| #ID | Description |
+|--|--|
+| [ITEM_ID] | [DESCRIPTION] |
+
+
+and a collection `@list_of_itens`, it will create 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.
+
+#### Sections
+
+Sometimes, you have to repeat a whole chunk of a document, in a structure a lot more complex than a table. You can make a Section in your template and use it in this situations. Creating a Section in OpenOffice is as easy as select menu *Insert* and then *Section...*, and then choose a name for it.
+
+Sections are lot like Tables, in the sense that you can pass a collection and have that section repeated for each member of the collection. *But*, Sections can have anything inside it, even Tables *and nested Sections*, as long as you provide the appropriate data structure.
+
+Let's see an example:
+
+```ruby
+  @invoices = Invoice.find(:all)
+
+  report = ODFReport::Report.new("reports/invoice.odt") do |r|
+
+    r.add_field(:title, "INVOICES REPORT")
+    r.add_field(:date, Date.today)
+
+    r.add_section("SC_INVOICE", @invoices) do |s|
+
+      s.add_field(:number) { |invoice| invoice.number.to_s.rjust(5, '0') }
+      s.add_field(:name,    :customer_name)
+      s.add_field(:address, :customer_address)
+
+      s.add_table("TB_ITEMS", :items, header: true) do |t|
+        t.add_column(:id)
+        t.add_column(:product) {|item| item.product.name }
+        t.add_column(:value, :product_value)
+      end
+
+      s.add_field(:total) do |invoice|
+        if invoice.status == 'CLOSED'
+          invoice.total
+        else
+          invoice.items.sum('product_value')}
+        end
+      end
+
+      s.add_section("SUB_NOTES", :notes) do |s1|
+
+        s1.add_field(:note_title) { |n| n.title }
+
+        s1.add_table ...
+
+      end
+
+    end
+
+  end
+```
+
+Note that when you add a Table to a Section, you don't pass the collection itself, but the attribute of the item of that section that will return the collection for that particular Table. Sounds complicated, huh? But once you get it, it's quite straightforward.
+
+In the above example, `s.add_table("TB_ITEMS", :items, header: true) do |t|`, the `:items` thing refers to a `invoice.items`. Easy, right?
+
+
+#### 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:
+
+```ruby
+report = ODFReport::Report.new("my_template.odt") do |r|
+  r.add_image :graphic1, "/path/to/the/image.jpg"
+
+  r.add_table("TABLE_WITH_IMAGES", @items) do |t|
+    t.add_column(:id)
+    t.add_column(:product, :product_name)
+    t.add_image('PRODUCT_IMAGE') { |item| item.image_path }
+  end  
+end
+```
+
+<hr/>
+
+### 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.
+
+#### Generating a document in a Rails application
+
+In a controller, you can have a code like this:
+
+```ruby
+def print
+
+  @ticket = Ticket.find(params[:id])
+
+  report = ODFReport::Report.new(Rails.root.join("/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 |t|
+      t.add_column(:name) { |op| "#{op.name} (#{op.department.short_name})" }
+    end
+
+    r.add_table("FIELDS", @ticket.fields) do |t|
+      t.add_column(:field_name, :name)
+      t.add_column(:field_value) { |field| field.text_value || "Empty" }
+    end
+
+  end
+
+  send_data report.generate,
+		    type: 'application/vnd.oasis.opendocument.text',
+            disposition: 'attachment',
+            filename: 'report.odt'
+
+end
+```
+
+#### Generating a document in a standalone script
+
+It's very similar to a Rails app, but you can inform the path where the file will be saved.
+
+```ruby
+report = ODFReport::Report.new("ticket.odt") do |r|
+... populates the report ...
+end
+
+report.generate("./documents/new_ticket.odt")
+```
+
+#### Using a template stored in the database (or anywhere besides the file system)
+You can provide an `io:` param, containing the actual file read into a String.
+
+```ruby
+report = ODFReport::Report.new(io: @template.attachment.read) do |r|
+```
+
+<hr/>
+
+#### REQUIREMENTS
+
+**rubyzip**: manipulating the contents of the odt file, since it's actually a zip file.
+**nokogiri**: parsing and manipulating the document xml files.
+**mime-types**: identify images mime types

data/bin/odt-extract

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require 'launchy'
+
+arg = ARGV[0]
+dir = File.basename(arg, File.extname(arg))
+
+%x( rm -rf #{dir}; unzip -d #{dir} #{arg} )
+
+Launchy.open dir

data/bin/odt-viewer

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require 'launchy'
+require "nokogiri"
+require "zip"
+
+xml = ""
+
+Zip::File.open(ARGV[0]) do |zip|
+  content = zip.get_entry('content.xml').get_input_stream.read
+  xml = Nokogiri::XML(content).to_xml
+end
+
+filename = File.join(Dir.mktmpdir, "#{File.basename(ARGV[0])}.result.xml")
+
+File.open(filename, 'w') { |f| f.write xml }
+
+Launchy.open filename

data/lib/odf-report.rb

@@ -2,14 +2,17 @@ require 'rubygems'
 require 'zip'
 require 'fileutils'
 require 'nokogiri'
+require 'mime/types'
+require 'securerandom'
 
 require File.expand_path('../odf-report/parser/default',  __FILE__)
 
-require File.expand_path('../odf-report/images',    __FILE__)
-require File.expand_path('../odf-report/field',     __FILE__)
-require File.expand_path('../odf-report/text',      __FILE__)
-require File.expand_path('../odf-report/file',      __FILE__)
-require File.expand_path('../odf-report/nested',    __FILE__)
-require File.expand_path('../odf-report/section',   __FILE__)
-require File.expand_path('../odf-report/table',     __FILE__)
-require File.expand_path('../odf-report/report',    __FILE__)
+require File.expand_path('../odf-report/data_source',  __FILE__)
+require File.expand_path('../odf-report/field',        __FILE__)
+require File.expand_path('../odf-report/text',         __FILE__)
+require File.expand_path('../odf-report/template',     __FILE__)
+require File.expand_path('../odf-report/image',        __FILE__)
+require File.expand_path('../odf-report/nestable',     __FILE__)
+require File.expand_path('../odf-report/section',      __FILE__)
+require File.expand_path('../odf-report/table',        __FILE__)
+require File.expand_path('../odf-report/report',       __FILE__)

data/lib/odf-report/data_source.rb

@@ -0,0 +1,65 @@
+module ODFReport
+  class DataSource
+
+    attr_reader :value
+
+    def initialize(opts, &block)
+      @value      = opts[:value]      || opts[:collection]
+      @data_field = opts[:data_field] || opts[:collection_field] || opts[:name]
+      @block      = block
+    end
+
+    def set_source(record)
+      @value = extract_value_from_item(record)
+    end
+
+    def each(&block)
+      return unless @value
+      @value.each(&block)
+    end
+
+    def empty?
+      @value.nil? || @value.empty?
+    end
+
+    private
+
+    def extract_value_from_item(record)
+
+      if @block
+        @block.call(record)
+
+      elsif record.is_a?(Hash)
+        key = @data_field
+        record[key] || record[key.to_s.downcase] || record[key.to_s.upcase] || record[key.to_s.downcase.to_sym]
+
+      elsif @data_field.is_a?(Array)
+        execute_methods_on_item(record)
+
+      elsif @data_field.is_a?(Hash) && record.respond_to?(@data_field.keys[0])
+        record.send(@data_field.keys[0], @data_field.values[0])
+
+      elsif record.respond_to?(@data_field)
+        record.send(@data_field)
+
+      else
+        raise "Can't find [#{@data_field.to_s}] in this #{record.class}"
+
+      end
+
+    end
+
+    def execute_methods_on_item(record)
+      tmp = record.dup
+      @data_field.each do |f|
+        if f.is_a?(Hash)
+          tmp = tmp.send(f.keys[0], f.values[0])
+        else
+          tmp = tmp.send(f)
+        end
+      end
+      tmp
+    end
+
+  end
+end