odf-report 0.5.1 → 0.7.1

data/lib/odf-report/field.rb

@@ -1,56 +1,55 @@
 module ODFReport
+  class Field
 
-class Field
+    DELIMITERS = %w([ ])
 
-  DELIMITERS = ['[', ']']
+    def initialize(opts, &block)
+      @name = opts[:name]
+      @data_source = DataSource.new(opts, &block)
+    end
 
-  def initialize(opts, &block)
-    @name = opts[:name]
-    @data_field = opts[:data_field]
+    def set_source(record)
+      @data_source.set_source(record)
+      self
+    end
 
-    unless @value = opts[:value]
+    def replace!(content, data_item = nil)
 
-      if block_given?
-        @block = block
+      txt = content.inner_html
 
-      else
-        @block = lambda { |item| self.extract_value(item) }
-      end
+      txt.gsub!(to_placeholder, sanitize(@data_source.value))
 
-    end
-
-  end
-
-  def get_value(data_item = nil)
-    @value || @block.call(data_item) || ''
-  end
+      content.inner_html = txt
 
-  def to_placeholder
-    if DELIMITERS.is_a?(Array)
-      "#{DELIMITERS[0]}#{@name.to_s.upcase}#{DELIMITERS[1]}"
-    else
-      "#{DELIMITERS}#{@name.to_s.upcase}#{DELIMITERS}"
     end
-  end
 
-  def extract_value(data_item)
-    return unless data_item
+  private
 
-    key = @data_field || @name
+    def to_placeholder
+      if DELIMITERS.is_a?(Array)
+        "#{DELIMITERS[0]}#{@name.to_s.upcase}#{DELIMITERS[1]}"
+      else
+        "#{DELIMITERS}#{@name.to_s.upcase}#{DELIMITERS}"
+      end
+    end
 
-    if data_item.is_a?(Hash)
-      data_item[key] || data_item[key.to_s.downcase] || data_item[key.to_s.upcase] || data_item[key.to_s.downcase.to_sym]
+    def sanitize(txt)
+      txt = html_escape(txt)
+      txt = odf_linebreak(txt)
+      txt
+    end
 
-    elsif data_item.respond_to?(key.to_s.downcase.to_sym)
-      data_item.send(key.to_s.downcase.to_sym)
+    HTML_ESCAPE = { '&' => '&amp;',  '>' => '&gt;',   '<' => '&lt;', '"' => '&quot;' }
 
-    else
-      raise "Can't find field [#{key}] in this #{data_item.class}"
+    def html_escape(s)
+      return "" unless s
+      s.to_s.gsub(/[&"><]/) { |special| HTML_ESCAPE[special] }
+    end
 
+    def odf_linebreak(s)
+      return "" unless s
+      s.to_s.gsub("\n", "<text:line-break/>")
     end
 
   end
-
 end
-
-end

data/lib/odf-report/image.rb

@@ -0,0 +1,57 @@
+module ODFReport
+  class Image < Field
+
+    IMAGE_DIR_NAME = "Pictures"
+
+    attr_reader :files
+
+    def initialize(opts, &block)
+      @files = []
+      super
+    end
+
+    def replace!(doc, data_item = nil)
+
+      frame = doc.xpath("//draw:frame[@draw:name='#{@name}']").first
+      image = doc.xpath("//draw:frame[@draw:name='#{@name}']/draw:image").first
+
+      return unless image
+
+      file = @data_source.value
+
+      if file
+        image.attribute('href').content = File.join(IMAGE_DIR_NAME, File.basename(file))
+        frame.attribute('name').content = SecureRandom.uuid
+
+        @files << file
+      else
+        frame.remove
+      end
+      
+    end
+
+    def self.include_image_file(zip_file, image_file)
+      return unless image_file
+
+      href = File.join(IMAGE_DIR_NAME, File.basename(image_file))
+
+      zip_file.update_file(href, File.read(image_file))
+    end
+
+    def self.include_manifest_entry(content, image_file)
+      return unless image_file
+
+      return unless root_node = content.at("//manifest:manifest")
+
+      href = File.join(IMAGE_DIR_NAME, File.basename(image_file))
+
+      entry = content.create_element('manifest:file-entry')
+      entry['manifest:full-path']  = href
+      entry['manifest:media-type'] = MIME::Types.type_for(href)[0].content_type
+
+      root_node.add_child entry
+
+    end
+
+  end
+end

data/lib/odf-report/nestable.rb

@@ -0,0 +1,65 @@
+module ODFReport
+  class Nestable
+
+    def initialize(opts)
+      @name = opts[:name]
+
+      @data_source = DataSource.new(opts)
+
+      @fields   = []
+      @texts    = []
+      @tables   = []
+      @sections = []
+      @images   = []
+
+    end
+
+    def set_source(data_item)
+      @data_source.set_source(data_item)
+      self
+    end
+
+    def add_field(name, data_field=nil, &block)
+      opts = { name: name, data_field: data_field }
+      @fields << Field.new(opts, &block)
+    end
+    alias_method :add_column, :add_field
+
+    def add_text(name, data_field=nil, &block)
+      opts = {name: name, data_field: data_field}
+      @texts << Text.new(opts, &block)
+    end
+
+    def add_image(name, data_field=nil, &block)
+      opts = {name: name, data_field: data_field}
+      @images << Image.new(opts, &block)
+    end
+
+    def add_table(table_name, collection_field, opts={})
+      opts.merge!(name: table_name, collection_field: collection_field)
+      tab = Table.new(opts)
+      @tables << tab
+
+      yield(tab)
+    end
+
+    def add_section(section_name, collection_field, opts={})
+      opts.merge!(name: section_name, collection_field: collection_field)
+      sec = Section.new(opts)
+      @sections << sec
+
+      yield(sec)
+    end
+
+    def all_images
+      (@images.map(&:files) + @sections.map(&:all_images) + @tables.map(&:all_images)).flatten
+    end
+
+    def wrap_with_ns(node)
+      <<-XML
+       <root xmlns:draw="a" xmlns:xlink="b" xmlns:text="c" xmlns:table="d">#{node.to_xml}</root>
+      XML
+    end
+    
+  end
+end

data/lib/odf-report/parser/default.rb

@@ -34,6 +34,7 @@ module Parser
     end
 
     def parse
+
       xml = @template_node.parse(@text)
 
       xml.css("p", "h1", "h2").each do |p|
@@ -59,9 +60,9 @@ module Parser
 
     def parse_formatting(text)
       text.strip!
-      text.gsub!(/<strong>(.+?)<\/strong>/)  { "<text:span text:style-name=\"bold\">#{$1}<\/text:span>" }
-      text.gsub!(/<em>(.+?)<\/em>/)          { "<text:span text:style-name=\"italic\">#{$1}<\/text:span>" }
-      text.gsub!(/<u>(.+?)<\/u>/)            { "<text:span text:style-name=\"underline\">#{$1}<\/text:span>" }
+      text.gsub!(/<strong.*?>(.+?)<\/strong>/)  { "<text:span text:style-name=\"bold\">#{$1}<\/text:span>" }
+      text.gsub!(/<em.*?>(.+?)<\/em>/)          { "<text:span text:style-name=\"italic\">#{$1}<\/text:span>" }
+      text.gsub!(/<u.*?>(.+?)<\/u>/)            { "<text:span text:style-name=\"underline\">#{$1}<\/text:span>" }
       text.gsub!("\n", "")
       text
     end
@@ -87,4 +88,4 @@ module Parser
 
 end
 
-end
+end

data/lib/odf-report/report.rb

@@ -1,38 +1,35 @@
 module ODFReport
 
 class Report
-  include Fields, Images
 
-  attr_accessor :fields, :tables, :images, :sections, :file, :texts
+  def initialize(template_name = nil, io: nil)
 
-  def initialize(template_name, &block)
-
-    @file = ODFReport::File.new(template_name)
+    @template = ODFReport::Template.new(template_name, io: io)
 
     @texts = []
     @fields = []
     @tables = []
-    @images = {}
-    @image_names_replacements = {}
     @sections = []
 
-    yield(self)
+    @images      = []
+
+    yield(self) if block_given?
 
   end
 
-  def add_field(field_tag, value='', &block)
+  def add_field(field_tag, value='')
     opts = {:name => field_tag, :value => value}
-    field = Field.new(opts, &block)
+    field = Field.new(opts)
     @fields << field
   end
 
-  def add_text(field_tag, value='', &block)
+  def add_text(field_tag, value='')
     opts = {:name => field_tag, :value => value}
     text = Text.new(opts)
     @texts << text
   end
 
-  def add_table(table_name, collection, opts={}, &block)
+  def add_table(table_name, collection, opts={})
     opts.merge!(:name => table_name, :collection => collection)
     tab = Table.new(opts)
     @tables << tab
@@ -40,7 +37,7 @@ class Report
     yield(tab)
   end
 
-  def add_section(section_name, collection, opts={}, &block)
+  def add_section(section_name, collection, opts={})
     opts.merge!(:name => section_name, :collection => collection)
     sec = Section.new(opts)
     @sections << sec
@@ -48,71 +45,46 @@ class Report
     yield(sec)
   end
 
-  def add_image(name, path)
-    @images[name] = path
+  def add_image(image_name, value=nil)
+    opts = {:name => image_name, :value => value}
+    image = Image.new(opts)
+    @images << image
   end
 
   def generate(dest = nil)
 
-    @file.update_content do |file|
+    @template.update_content do |file|
 
-      file.update_files('content.xml', 'styles.xml') do |txt|
+      file.update_files do |doc|
 
-        parse_document(txt) do |doc|
+        @sections.each { |c| c.replace!(doc) }
+        @tables.each   { |c| c.replace!(doc) }
 
-          replace_texts!(doc)
-          replace_fields!(doc)
+        @texts.each    { |c| c.replace!(doc) }
+        @fields.each   { |c| c.replace!(doc) }
 
-          replace_sections!(doc)
-          replace_tables!(doc)
+        @images.each   { |c| c.replace!(doc) }
 
-          find_image_name_matches(doc)
-          avoid_duplicate_image_names(doc)
+      end
 
-        end
+      all_images.each { |i| Image.include_image_file(file, i) }
 
+      file.update_manifest do |content|
+        all_images.each { |i| Image.include_manifest_entry(content, i) }
       end
 
-      replace_images(file)
-
     end
 
     if dest
-      ::File.open(dest, "wb") {|f| f.write(@file.data) }
+      File.open(dest, "wb") { |f| f.write(@template.data) }
     else
-      @file.data
-    end
-
-  end
-
-private
-
-  def parse_document(txt)
-    doc = Nokogiri::XML(txt)
-    yield doc
-    txt.replace(doc.to_xml(:save_with => Nokogiri::XML::Node::SaveOptions::AS_XML))
-  end
-
-  def replace_fields!(content)
-    field_replace!(content)
-  end
-
-  def replace_texts!(content)
-    @texts.each do |text|
-      text.replace!(content)
+      @template.data
     end
-  end
 
-  def replace_tables!(content)
-    @tables.each do |table|
-      table.replace!(content)
-    end
   end
 
-  def replace_sections!(content)
-    @sections.each do |section|
-      section.replace!(content)
-    end
+  def all_images
+    @all_images ||= (@images.map(&:files) + @sections.map(&:all_images) + @tables.map(&:all_images)).flatten.uniq
   end
 
 end

data/lib/odf-report/section.rb

@@ -1,102 +1,39 @@
 module ODFReport
+  class Section < Nestable
 
-  class Section
-    include Fields, Nested
+    def replace!(doc)
 
-    attr_accessor :fields, :tables, :data, :name, :collection_field, :parent
+      return unless find_section_node(doc)
 
-    def initialize(opts)
-      @name             = opts[:name]
-      @collection_field = opts[:collection_field]
-      @collection       = opts[:collection]
-      @parent           = opts[:parent]
+      @data_source.each do |record|
 
-      @fields = []
-      @texts = []
+        new_section = deep_clone(@section_node)
 
-      @tables = []
-      @sections = []
-    end
-
-    def add_field(name, data_field=nil, &block)
-      opts = {:name => name, :data_field => data_field}
-      field = Field.new(opts, &block)
-      @fields << field
-
-    end
-
-    def add_text(name, data_field=nil, &block)
-      opts = {:name => name, :data_field => data_field}
-      field = Text.new(opts, &block)
-      @texts << field
-
-    end
-
-    def add_table(table_name, collection_field, opts={}, &block)
-      opts.merge!(:name => table_name, :collection_field => collection_field, :parent => self)
-      tab = Table.new(opts)
-      @tables << tab
-
-      yield(tab)
-    end
-
-    def add_section(section_name, collection_field, opts={}, &block)
-      opts.merge!(:name => section_name, :collection_field => collection_field, :parent => self)
-      sec = Section.new(opts)
-      @sections << sec
-
-      yield(sec)
-    end
-
-    def populate!(row)
-      @collection = get_collection_from_item(row, @collection_field) if row
-    end
+        @tables.each    { |t| t.set_source(record).replace!(new_section) }
+        @sections.each  { |s| s.set_source(record).replace!(new_section) }
+        @texts.each     { |t| t.set_source(record).replace!(new_section) }
+        @fields.each    { |f| f.set_source(record).replace!(new_section) }
+        @images.each    { |i| i.set_source(record).replace!(new_section) }
 
-    def replace!(doc, row = nil)
-
-      return unless section = find_section_node(doc)
-
-      template = section.dup
-
-      populate!(row)
-
-      @collection.each do |data_item|
-        new_section = template.dup
-
-        @texts.each do |t|
-          t.replace!(new_section, data_item)
-        end
-
-        @tables.each do |t|
-          t.replace!(new_section, data_item)
-        end
-
-        @sections.each do |s|
-          s.replace!(new_section, data_item)
-        end
-
-        replace_fields!(new_section, data_item)
-
-        section.before(new_section)
+        @section_node.before(new_section.to_xml)
 
       end
 
-      section.remove
+      @section_node.remove
 
     end # replace_section
 
   private
 
     def find_section_node(doc)
+      @section_node = doc.at_css("text|section[@text|name='#{@name}']")
+    end
 
-      sections = doc.xpath(".//text:section[@text:name='#{@name}']")
-
-      sections.empty? ? nil : sections.first
+    def deep_clone(node)
+      Nokogiri::XML(wrap_with_ns(node)).at("text|section")
+                                       .tap { |n| n.attribute('name').content = SecureRandom.uuid }
 
     end
 
   end
-
 end
-
-