odt-serenity 3.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 78d869d91c4ce61e0894727676277786bac24d90a55faaba90d8124f7b009af6
+  data.tar.gz: 9fb183858137444a556fefb79a7caad6feb2375e997b45f5405e2640c0dbdc7d
+SHA512:
+  metadata.gz: 4c73043b050e81872efa7d3439082dffde2c77467112312083807639d5b7ff3097e001c4311a493bad5b272ca2c37d1000f03dabb16e9c36d7e4091a905f4777
+  data.tar.gz: e6021fc220675d29be8df904ce7e8a2e5cf34cc9a22cbe5ea6a042faf3369da0182e0856007e1a394b604be5d111986c00a2be619eb2b0fdeb2a3d5ea0274936

data/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2010 Tomas Kramar
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+

data/README.md

@@ -0,0 +1,74 @@
+Serenity is an embedded ruby for OpenOffice documents (.odt files). You provide an .odt template with ruby code inside a special markup and the data and Serenity generates the document. If you know erb all of this should sound familiar.
+
+Important Changes
+=================
+
+As of version 0.2.0 serenity is using instance variables in the templates. In previous versions, your instance variables would be converted to local before passing to the template, so while in the code you had `@title = 'Serenity'`, you had to put `{%= title }` in the template to get serenity to work. This has now changed and you need to use instance variables in the templates: `{%= @title }`. Honestly, I don't know why I did it this way in the first place, considering that people are used to instance variables in templates from rails.
+
+Usage
+======
+
+Serenity is best demonstrated with an example. The first picture shows the template with the ruby code, next image shows the generated document. The template, output and the sample script can be found in the showcase directory.
+
+![Serenity template](http://github.com/kremso/serenity/blob/master/showcase/imgs/serenity_template.png?raw=true)
+
+The image above is a screenshot of showcase.odt from the [showcase](http://github.com/kremso/serenity/blob/master/showcase) directory. It's a regular OpenOffice document with ruby code embedded inside a special markup. That ruby code drives the document creation. You can use conditionals, loops, blocks — in fact, the whole ruby language and you can apply any OpenOffice formatting to the outputted variables or static text.
+
+The second line in the template is `{%= @title%}` what means: output the value of variable title. It's bold and big, in fact, it's has the 'Heading 1' style applied. That variable will be replaced in the generated document, but it will still be a 'Heading 1'.
+
+You can now take that template, provide the data and generate the final document:
+
+    require 'rubygems'
+    require 'serenity'
+
+    class Showcase
+      include Serenity::Generator
+
+      Person = Struct.new(:name, :items)
+      Item = Struct.new(:name, :usage)
+
+      def generate_showcase
+        @title = 'Serenity inventory'
+
+        mals_items = [Item.new('Moses Brothers Self-Defense Engine Frontier Model B', 'Lock and load')]
+        mal = Person.new('Malcolm Reynolds', mals_items)
+
+        jaynes_items = [Item.new('Vera', 'Callahan full-bore auto-lock with a customized trigger, double cartridge and thorough gauge'),
+                        Item.new('Lux', 'Ratatata'),
+                        Item.new('Knife', 'Cut-throat')]
+        jayne = Person.new('Jayne Cobb', jaynes_items)
+
+        @crew = [mal, jayne]
+
+        render_odt 'showcase.odt'
+      end
+    end
+
+The key parts are `include Serenity::Generator` and `render_odt`. The data for the template must be provided as instance variables.
+
+Following picture shows the generated document. It's a screenshot of the showcase_output.odt document from the [showcase](http://github.com/kremso/serenity/blob/master/showcase) directory.
+
+![Generated document](http://github.com/kremso/serenity/blob/master/showcase/imgs/serenity_output.png?raw=true)
+
+Installation
+============
+
+    gem install serenity-odt
+
+Yeah, serenity is already taken on gemcutter.
+
+Creating templates
+===================
+
+Templates are created directly in OpenOffice. Ruby code is enclosed in special markup:
+
++ `{%= %}` is for ruby code which should be output to the final document. `to_s` is applied to anything found inside this markup
++ `{% %}` is for everything else — loops, ifs, ends and any other non-outputting code
+
+Any special formatting should by applied directly on the markup. E.g. if you need to ouput the value of variable title in bold font, write `{%= title %}`, select in in OpenOffice and make it bold. See the showcase.odt for more examples.
+
+Contact
+=======
+
+kramar[dot]tomas[at]gmail.com
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/odt-serenity.rb

@@ -0,0 +1 @@
+require_relative './serenity'

data/lib/serenity/debug.rb

@@ -0,0 +1,19 @@
+module Serenity
+  module Debug
+    def debug?
+      false
+    end
+
+    def debug_file_path
+      File.join(debug_dir, debug_file_name)
+    end
+
+    def debug_file_name
+      "serenity_debug_#{rand(100)}.rb"
+    end
+
+    def debug_dir
+      File.join(File.dirname(__FILE__), '..', '..', 'debug')
+    end
+  end
+end

data/lib/serenity/escape_xml.rb

@@ -0,0 +1,18 @@
+class String
+  def escape_xml
+    mgsub!([[/&/, '&amp;'], [/</, '&lt;'], [/>/, '&gt;']])
+  end
+
+  def convert_newlines
+    gsub!("\n", '<text:line-break/>')
+    self
+  end
+
+  def mgsub!(key_value_pairs=[].freeze)
+    regexp_fragments = key_value_pairs.collect { |k,v| k }
+    gsub!(Regexp.union(*regexp_fragments)) do |match|
+      key_value_pairs.detect{|k,v| k =~ match}[1]
+    end
+    self
+  end
+end

data/lib/serenity/generator.rb

@@ -0,0 +1,22 @@
+module Serenity
+  module Generator
+    def render_odt template_path, output_path = output_name(template_path)
+      template = Template.new template_path, output_path
+      template.process binding
+    end
+
+    def helper
+      @helper ||= Serenity::Helper.new
+    end
+
+    private
+
+    def output_name input
+      if input =~ /(.+)\.odt\Z/
+        "#{$1}_output.odt"
+      else
+        "#{input}_output.odt"
+      end
+    end
+  end
+end

data/lib/serenity/helper.rb

@@ -0,0 +1,7 @@
+require_relative './helpers/tables_helper'
+
+module Serenity
+  class Helper
+    include TablesHelper
+  end
+end

data/lib/serenity/helpers/tables_helper.rb

@@ -0,0 +1,13 @@
+module Serenity
+  module TablesHelper
+    # TODO: Fix static name of variable #builder
+    def merge_rows_tag(items, col:)
+      items.each_with_index do |item, index|
+        yield(
+          item,
+          OpenStruct.new(subject: item, index: index, count: items.count)
+        )
+      end
+    end
+  end
+end

data/lib/serenity/images_processor.rb

@@ -0,0 +1,32 @@
+module Serenity
+  class ImagesProcessor
+    include Debug
+
+    IMAGE_DIR_NAME = "Pictures"
+
+    def initialize(xml_content, context)
+      @replacements = []
+      @images = eval('@images', context)
+      @xml_content = xml_content
+    end
+
+    def generate_replacements
+      require 'nokogiri'
+
+      if @images && @images.kind_of?(Hash)
+        xml_data = Nokogiri::XML(@xml_content)
+
+        @images.each do |image_name, replacement_path|
+          if node = xml_data.xpath("//draw:frame[@draw:name='#{image_name}']/draw:image").first
+            placeholder_path = node.attribute('href').value
+            odt_image_path = ::File.join(IMAGE_DIR_NAME, ::File.basename(placeholder_path))
+
+            @replacements << [odt_image_path, replacement_path]
+          end
+        end
+      end
+
+      @replacements
+    end
+  end
+end

data/lib/serenity/line.rb

@@ -0,0 +1,81 @@
+module Serenity
+  class Line
+    attr_reader :text
+
+    def initialize text
+      @text = text
+    end
+
+    def to_s
+      @text
+    end
+
+    def clone
+      self.class.new(text)
+    end
+
+    def self.text txt
+      TextLine.new txt
+    end
+
+    def self.code txt
+      CodeLine.new txt
+    end
+
+    def self.string txt
+      StringLine.new txt
+    end
+
+    def self.literal txt
+      LiteralLine.new txt
+    end
+
+  end
+
+  class TextLine < Line
+    def to_buf
+      " _buf << '" << escape_text(@text) << "';"
+    end
+
+    def escape_text text
+      text.gsub(/['\\]/, '\\\\\&')
+    end
+
+    def set_attribute(key, val)
+      tag = Nokogiri.XML(@text).children[0]
+      tag[key] = val
+
+      updated_text = tag.to_s
+      updated_text.gsub!('/','') unless @text.include?('/')
+
+      @text = updated_text
+    end
+  end
+
+  class CodeLine < Line
+    def to_buf
+      escape_code(@text) << ';'
+    end
+
+    def escape_code code
+      code.mgsub! [[/&apos;/, "'"], [/&gt;/, '>'], [/&lt/, '<'], [/&quot;/, '"'], [/&amp;/, '&']]
+    end
+  end
+
+  class StringLine < CodeLine
+    def to_buf
+      " _buf << (" << escape_code(@text) << ").to_s.escape_xml.convert_newlines;"
+    end
+
+    def convert_newlines text
+      text.gsub("First line", '<text:line-break>')
+    end
+  end
+
+  class LiteralLine < CodeLine
+    def to_buf
+      " _buf << (" << escape_code(@text) << ").to_s;"
+    end
+  end
+
+end

data/lib/serenity/node_type.rb

@@ -0,0 +1,7 @@
+module Serenity
+  class NodeType
+    TAG = 1
+    CONTROL = 2
+    TEMPLATE = 3
+  end
+end

data/lib/serenity/odteruby.rb

@@ -0,0 +1,112 @@
+module Serenity
+  class OdtEruby
+    include Debug
+
+    EMBEDDED_PATTERN = /\{%([=%]+)?(.*?)-?%\}/m
+
+    attr_reader :template
+
+    def initialize template
+      @template = template
+    end
+
+    def src
+      @src ||= begin
+        script = convert_to_ruby_script template
+
+        if debug?
+          File.open(debug_file_path, 'w') { |f| f << script }
+        end
+
+        script
+      end
+    end
+
+    def evaluate context
+      encoding_src = src.force_encoding Encoding.default_external
+      eval(encoding_src, context)
+    end
+
+    def raw_lines
+      @sugar_lines ||= convert_to_raw_lines template
+    end
+
+    def lines
+      @lines ||= SyntacticSugar.all.translate(raw_lines)
+    end
+
+    private
+
+    def convert_to_ruby_script(template)
+      src = "_buf = '';"
+      lines.each { |line| src << line.to_buf }
+      src << "\n_buf.to_s\n"
+    end
+
+    def convert_to_raw_lines(template)
+      buffer = []
+      buffer_next = []
+
+      template.each_node do |node, type|
+        if !buffer_next.empty?
+          if is_matching_pair?(buffer.last, node)
+            buffer.pop
+            next
+          elsif is_nonpair_tag? node
+            next
+          else
+            buffer << buffer_next
+            buffer.flatten!
+            buffer_next = []
+          end
+        end
+
+        if type == NodeType::CONTROL
+          buffer_next = process_instruction(node)
+        else
+          buffer << process_instruction(node)
+          buffer.flatten!
+        end
+      end
+
+      buffer
+    end
+
+    def process_instruction text
+      #text = text.strip
+      pos = 0
+      src = []
+
+      text.scan(EMBEDDED_PATTERN) do |indicator, code|
+        m = Regexp.last_match
+        middle = text[pos...m.begin(0)]
+        pos  = m.end(0)
+        src << Line.text(middle) unless middle.empty?
+
+        if !indicator            # <% %>
+          src << Line.code(code)
+        elsif indicator == '='   # <%= %>
+          src << Line.string(code)
+        elsif indicator == '%'   # <%% %>
+          src << Line.literal(code)
+        end
+      end
+
+      rest = pos == 0 ? text : text[pos..-1]
+
+      src << Line.text(rest) unless rest.nil? or rest.empty?
+      src
+    end
+
+    def is_nonpair_tag? tag
+      tag =~ /<.+?\/>/
+    end
+
+    def is_matching_pair? open, close
+      open = open.to_s.strip
+      close = close.to_s.strip
+
+      close == "</#{open[1, close.length - 3]}>"
+    end
+  end
+end

data/lib/serenity/ruby_lexer.rb

@@ -0,0 +1 @@
+require_relative './ruby_lexer/method.rb'

data/lib/serenity/syntactic_sugar.rb

@@ -0,0 +1,24 @@
+require_relative "./syntactic_sugars/application_sugar"
+require_relative "./syntactic_sugars/row_sugar"
+
+module Serenity
+  class SyntacticSugar
+    class << self
+      def all
+        new [RowSugar.new]
+      end
+    end
+
+    attr_reader :sugars
+
+    def initialize(sugars = [])
+      @sugars = sugars
+    end
+
+    def translate(lines)
+      sugars.inject(lines) do |output, sugar|
+        sugar.translate(output)
+      end
+    end
+  end
+end

data/lib/serenity/syntactic_sugars/application_sugar.rb

@@ -0,0 +1,7 @@
+module Serenity
+  class ApplicationSugar
+    def translate(lines)
+      lines
+    end
+  end
+end

data/lib/serenity/syntactic_sugars/row_sugar.rb

@@ -0,0 +1,119 @@
+module Serenity
+  class RowSugar < ApplicationSugar
+    def translate(lines)
+      result = []
+      begin_index = nil
+
+      lines.each_with_index do |line, index|
+        if begin_construction? line
+          begin_index = index
+        elsif begin_index && end_construction?(line)
+          result += translate_construction(lines.slice(begin_index, index - begin_index + 1))
+          begin_index = nil
+        elsif begin_index.nil?
+          result << line
+        end
+      end
+
+      result
+    end
+
+    private
+
+    def begin_construction?(line)
+      line.is_a?(Serenity::CodeLine) && line.text.include?('merge_rows_tag')
+    end
+
+    def end_construction?(line)
+      line.is_a?(Serenity::CodeLine) && line.text.include?('end')
+    end
+
+    def begin_cell?(line)
+      line.is_a?(Serenity::TextLine) && line.text.include?('<table:table-cell')
+    end
+
+    def end_cell?(line)
+      line.is_a?(Serenity::TextLine) && line.text.include?('</table:table-cell>')
+    end
+
+    def add_attribute_to_other_row(lines, options)
+      curr_col, curr_index = 0, 0
+      result = []
+
+      while curr_index < lines.length
+        curr_col = curr_col + 1 if begin_cell? lines[curr_index]
+
+        if curr_col == options[:col]
+          result << Line.text("<table:covered-table-cell/>")
+          break
+        else
+          result << lines[curr_index]
+        end
+
+        curr_index = curr_index + 1
+      end
+
+      while curr_index < lines.length
+        if end_cell? lines[curr_index]
+          curr_index = curr_index + 1
+          break
+        end
+
+        curr_index = curr_index + 1
+      end
+
+      while curr_index < lines.length
+        result << lines[curr_index]
+        curr_index = curr_index + 1
+      end
+
+      result
+    end
+
+    def add_attribute_to_first_row(lines, options)
+      curr_col = 0
+
+      found_index = lines.index do |line|
+        curr_col = curr_col + 1 if begin_cell? line
+        curr_col == options[:col]
+      end
+
+      cloned_lines = lines.map(&:clone)
+
+      if found_index
+        cloned_lines[found_index].set_attribute 'table:number-rows-spanned', '%{rows_count}'
+        cloned_lines[found_index] = Line.literal("'#{cloned_lines[found_index]}' % { rows_count: builder.count }")
+      end
+
+      cloned_lines
+    end
+
+    def translate_construction(lines)
+      first_line, last_line = lines[0], lines[lines.length - 1]
+
+      construction_options = parse_construction_options first_line.text
+      construction_lines = lines.slice(1, lines.length - 2)
+
+      result = [first_line]
+      result << Line.code(" if builder.index == 0 ")
+      result += add_attribute_to_first_row(construction_lines, construction_options)
+      result << Line.code(" else ")
+      result += add_attribute_to_other_row(construction_lines, construction_options)
+      result << Line.code(" end ")
+      result << last_line
+
+      result
+    end
+
+    # TODO: May be add gem parser?
+    def parse_construction_options(text)
+      options = {}
+
+      if result = text.match(/col:\s(\d){1,}/)
+        options[:col] = result[1].to_i
+      end
+
+      options
+    end
+  end
+end

data/lib/serenity/template.rb

@@ -0,0 +1,38 @@
+require 'zip'
+require 'fileutils'
+
+module Serenity
+  class Template
+    attr_accessor :template
+
+    def initialize(template, output)
+      FileUtils.cp(template, output)
+      @template = output
+    end
+
+    def process context
+      tmpfiles = []
+      Zip::File.open(@template) do |zipfile|
+        %w(content.xml styles.xml).each do |xml_file|
+          content = zipfile.read(xml_file)
+
+          # Images replacement
+          images_replacements = ImagesProcessor.new(content, context).generate_replacements
+          images_replacements.each do |r|
+            zipfile.replace(r.first, r.last)
+          end
+
+          odteruby = OdtEruby.new(XmlReader.new(content))
+          out = odteruby.evaluate(context)
+          out.force_encoding Encoding.default_external
+
+          tmpfiles << (file = Tempfile.new("serenity"))
+          file << out
+          file.close
+
+          zipfile.replace(xml_file, file.path)
+        end
+      end
+    end
+  end
+end

data/lib/serenity/version.rb

@@ -0,0 +1,3 @@
+module Serenity
+  VERSION = '3.0.0'.freeze
+end

data/lib/serenity/xml_reader.rb

@@ -0,0 +1,31 @@
+module Serenity
+  class XmlReader
+
+    def initialize src
+      @src = src.force_encoding("UTF-8")
+    end
+
+    def each_node
+      last_match_pos = 0
+
+      @src.scan(/<.*?>/) do |node|
+        m = Regexp.last_match
+        if m.begin(0) > last_match_pos
+          text = @src[last_match_pos...m.begin(0)]
+          yield text, node_type(text) if text.gsub(/\s+/, '') != ''
+        end
+
+        last_match_pos = m.end(0)
+        yield node, NodeType::TAG
+      end
+    end
+
+    def node_type text
+      if text =~ /\s*\{%[^=#].+?%\}\s*/
+        NodeType::CONTROL
+      else
+        NodeType::TEMPLATE
+      end
+    end
+  end
+end

data/lib/serenity-odt.rb

@@ -0,0 +1 @@
+require_relative './serenity'

data/lib/serenity.rb

@@ -0,0 +1,15 @@
+require 'nokogiri'
+require 'ostruct'
+
+require 'serenity/version'
+require 'serenity/line'
+require 'serenity/debug'
+require 'serenity/node_type'
+require 'serenity/escape_xml'
+require 'serenity/odteruby'
+require 'serenity/images_processor'
+require 'serenity/template'
+require 'serenity/xml_reader'
+require 'serenity/helper'
+require 'serenity/syntactic_sugar'
+require 'serenity/generator'

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: odt-serenity
+version: !ruby/object:Gem::Version
+  version: 3.0.0
+platform: ruby
+authors:
+- kremso
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-03-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.9
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.9
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Embedded ruby for OpenOffice/LibreOffice Text Document (.odt) files.
+  You provide an .odt template with ruby code in a special markup and the data, and
+  Serenity generates the document. Very similar to .erb files.
+email: ''
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- lib/odt-serenity.rb
+- lib/serenity-odt.rb
+- lib/serenity.rb
+- lib/serenity/debug.rb
+- lib/serenity/escape_xml.rb
+- lib/serenity/generator.rb
+- lib/serenity/helper.rb
+- lib/serenity/helpers/tables_helper.rb
+- lib/serenity/images_processor.rb
+- lib/serenity/line.rb
+- lib/serenity/node_type.rb
+- lib/serenity/odteruby.rb
+- lib/serenity/ruby_lexer.rb
+- lib/serenity/syntactic_sugar.rb
+- lib/serenity/syntactic_sugars/application_sugar.rb
+- lib/serenity/syntactic_sugars/row_sugar.rb
+- lib/serenity/template.rb
+- lib/serenity/version.rb
+- lib/serenity/xml_reader.rb
+homepage: https://github.com/mr-dxdy/serenity
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: Fork of project serenity-odt. Parse ODT file and substitutes placeholders
+  like ERb.
+test_files: []