excel_templating 0.3.2

data/lib/excel_templating/excel_abstraction/sheet.rb

@@ -0,0 +1,102 @@
+module ExcelAbstraction
+  class Sheet < SimpleDelegator
+    attr_reader :active_cell_reference
+
+    def initialize(sheet, workbook)
+      super(sheet)
+      @workbook = workbook
+      @active_cell_reference = ExcelAbstraction::ActiveCellReference.new
+    end
+
+    def header(value, options = {})
+      cell(value, {bold: 1}.merge(options))
+      self
+    end
+
+    def headers(array, options = {})
+      Array(array).each { |element| header(element, options) }
+      self
+    end
+
+    # Fills the cell at the current pointer with the value and format or options specified
+    # @param [Object] value Value to place in the cell.
+    # @param [Object] options (optional) options to create a format object
+    # @param [Object] format (optional) The format to use when creating this cell
+    def cell(value, format: nil, type: :auto, **options)
+      format = format || _format(options)
+      value = Float(value) if value.is_a?(ExcelAbstraction::Time) || value.is_a?(ExcelAbstraction::Date)
+
+      writer = case type
+               when :string then method(:write_string)
+               else method(:write)
+               end
+
+      writer.call(active_cell_reference.row, active_cell_reference.col, value, format)
+
+      if options[:new_row]
+        next_row
+      else
+        active_cell_reference.right
+      end
+      self
+    end
+
+    # Advance the pointer to the next row.
+    # @return nil
+    def next_row
+      active_cell_reference.newline
+    end
+
+    def cells(array, options = {})
+      Array(array).each { |value| cell(value, options) }
+      self
+    end
+
+    def merge(length, value, options = {})
+      format = _format(options)
+      merge_range(active_cell_reference.row, active_cell_reference.col, active_cell_reference.row, active_cell_reference.col + length, value, format)
+      active_cell_reference.right(length + 1)
+      self
+    end
+
+    def style_row(row, properties = {})
+      height = properties[:height]
+      format = _format(properties[:format] || {})
+      hidden = properties[:hidden] || 0
+      outline_level = properties[:level] || 0
+      if outline_level
+        raise "Outline level can only be between 0 and 7" unless (0..7) === outline_level
+      end
+      collapse = properties[:collapse] || 0
+      set_row(row, height, format, hidden, outline_level, collapse)
+      self
+    end
+
+    # Style the numbered column
+    # @param [Integer] col 0 based index of the column.
+    # @param [Integer] width numeric width of the column (30 = 2.6 inches)
+    # @param [Hash] format Properties to set for the format of the column
+    # @param [Integer] level Outline level
+    # @param [Integer] collapse 1 = collapse, 0 = do not collapse
+    def style_col(col, width: nil, format: {}, level: 0, collapse: 0, hidden: nil)
+      format = _format(format || {})
+      if level
+        raise "Outline level can only be between 0 and 7" unless (0..7) === level
+      end
+      set_column(col, col, width, format, hidden, level, collapse)
+      self
+    end
+
+    private
+
+    def _format(options)
+      format = @workbook.add_format
+      format.set_align('valign')
+      options.each do |key, value|
+        method = "set_#{key.to_s}".to_sym
+        format.send(method, value) if format.respond_to?(method)
+      end
+      format
+    end
+  end
+end

data/lib/excel_templating/excel_abstraction/spread_sheet.rb

@@ -0,0 +1,28 @@
+require 'tempfile'
+
+module ExcelAbstraction
+  class SpreadSheet < DelegateClass(Tempfile)
+    attr_reader :workbook
+
+    def initialize(format: :xls, skip_default_sheet: false)
+      extension = format == :xls ? ".xls" : ".xlsx"
+      tmp_file = Tempfile.new(["temp_spreadsheet_#{::Time.now.to_i}", extension])
+      super(tmp_file)
+      @workbook = ExcelAbstraction::WorkBook.new(tmp_file.path, format: format, skip_default_sheet: skip_default_sheet)
+    end
+
+    def close
+      workbook.close
+      yield if block_given?
+      super
+    end
+
+    def to_s
+      data = nil
+      close do
+        data = read
+      end
+      data
+    end
+  end
+end

data/lib/excel_templating/excel_abstraction/time.rb

@@ -0,0 +1,42 @@
+module ExcelAbstraction
+  class Time < SimpleDelegator
+    ADJUSTMENT = "1900-03-01 00:00 +00:00"
+    REFERENCE = "1900-01-01 00:00 +00:00"
+
+    attr_reader :value
+
+    def initialize(raw_value)
+      super(convert(raw_value))
+    end
+
+    def to_excel_time
+      self
+    end
+
+    private
+
+    def adjustment
+      ::Time.parse(ADJUSTMENT)
+    end
+
+    def reference
+      ::Time.parse(REFERENCE)
+    end
+
+    def adjust(raw_value)
+      adjustment < raw_value ? two_days : one_day
+    end
+
+    def two_days
+      one_day * 2.0
+    end
+
+    def one_day
+      60 * 60 * 24.to_f
+    end
+
+    def convert(raw_value)
+      (raw_value - reference + adjust(raw_value)).to_f / one_day
+    end
+  end
+end

data/lib/excel_templating/excel_abstraction/work_book.rb

@@ -0,0 +1,47 @@
+module ExcelAbstraction
+  class WorkBook < SimpleDelegator
+    attr_accessor :active_sheet
+
+    def initialize(file, format: :xls, skip_default_sheet: false)
+      @format = format
+      @file = file
+      super(workbook)
+      unless skip_default_sheet
+        @active_sheet = ExcelAbstraction::Sheet.new(workbook.add_worksheet, workbook)
+      end
+    end
+
+
+    def title(text)
+      set_properties(title: text)
+      self
+    end
+
+    def organization(name)
+      set_properties(company: name)
+      self
+    end
+
+    private
+
+    attr_reader :format, :file
+
+    def default_options
+      {
+        :font => 'Calibri',
+        :size => 12,
+        :align => 'center',
+        :text_wrap => 1
+      }
+    end
+
+    def workbook
+      @workbook ||= if format == :xlsx
+        WriteXLSX.new(file, default_options)
+      else
+        WriteExcel.new(file, default_options)
+      end
+    end
+  end
+
+end

data/lib/excel_templating/excel_abstraction.rb

@@ -0,0 +1,16 @@
+require 'write_xlsx'
+require 'writeexcel'
+
+require_relative 'excel_abstraction/active_cell_reference'
+require_relative 'excel_abstraction/cell'
+require_relative 'excel_abstraction/cell_range'
+require_relative 'excel_abstraction/cell_reference'
+require_relative 'excel_abstraction/date'
+require_relative 'excel_abstraction/row'
+require_relative 'excel_abstraction/sheet'
+require_relative 'excel_abstraction/spread_sheet'
+require_relative 'excel_abstraction/time'
+require_relative 'excel_abstraction/work_book'
+
+module ExcelAbstraction
+end

data/lib/excel_templating/render_helper.rb

@@ -0,0 +1,14 @@
+module ExcelTemplating
+  module RenderHelper
+    class << self
+      def letter_for(one_based_index)
+        letters[one_based_index-1]
+      end
+
+      private
+      def letters
+        @row_letters ||= ('A' .. 'ZZ').to_a
+      end
+    end
+  end
+end

data/lib/excel_templating/renderer.rb

@@ -0,0 +1,251 @@
+require_relative 'excel_abstraction'
+require 'mustache'
+
+module ExcelTemplating
+  # Render class for ExcelTemplating Documents.  Used by the Document to render the defined document
+  # with the data to a new file.  Responsible for reading the template and applying the data to it
+  class Renderer
+    extend Forwardable
+
+    # @param [ExcelTemplating::Document] document Document to render with
+    def initialize(document)
+      @template_document = document
+      @data_source_registry = document.class.data_source_registry
+    end
+
+    # Render the document provided.  Yields the path to the tempfile created.
+    def render
+      @spreadsheet = ExcelAbstraction::SpreadSheet.new(format: :xlsx)
+      @template = Roo::Spreadsheet.open(template_path)
+      @registry_renderer = data_source_registry.renderer(data: data[:all_sheets])
+      apply_document_level_items
+      apply_data_to_sheets
+      protect_spreadsheet
+      registry_renderer.write_sheet(@spreadsheet.workbook)
+
+      @spreadsheet.close
+      yield(spreadsheet.path)
+    end
+
+    private
+
+    attr_reader :template_document, :spreadsheet, :template, :registry_renderer, :data_source_registry, :current_sheet
+    delegate [:workbook] => :spreadsheet
+    delegate [:data] => :template_document
+    delegate [:active_sheet] => :workbook
+    delegate [:active_cell_reference] => :active_sheet
+
+    def current_row
+      active_cell_reference.row
+    end
+
+    def current_col
+      active_cell_reference.col
+    end
+
+    def template_path
+      template_document.class.template_path
+    end
+
+    def default_format_styling
+      template_document.class.document_default_styling
+    end
+
+    def protected?
+      template_document.class.protected?
+    end
+
+    def sheets
+      template_document.class.sheets
+    end
+
+    def apply_document_level_items
+      workbook.title mustachify(template_document.class.document_title, locals: common_data_variables)
+      workbook.organization mustachify(template_document.class.document_organization, locals: common_data_variables)
+    end
+
+    def common_data_variables
+      stringify_keys(data[:all_sheets])
+    end
+
+    def stringify_keys(hash)
+      Hash[hash.map { |k, v| [k.to_s, v] } ]
+    end
+
+    def style_columns(sheet, template_sheet)
+      default_style = sheet.default_column_style
+      column_styles = sheet.column_styles
+      if column_styles || default_style
+        roo_columns(template_sheet).each do |column_number|
+          style = column_styles[column_number] || default_style
+          active_sheet.style_col(column_number - 1, style) # Note: Styling columns is zero indexed
+        end
+      end
+    end
+
+    def style_rows(sheet, template_sheet)
+      default_style = sheet.default_row_style
+      row_styles = sheet.row_styles
+      if row_styles || default_style
+        roo_rows(template_sheet).each do |row_number|
+          style = row_styles[row_number] || default_style
+          active_sheet.style_row(row_number - 1, style) # Note: Styling rows is zero indexed
+        end
+      end
+    end
+
+    def roo_columns(roo_sheet)
+      (roo_sheet.first_column .. roo_sheet.last_column)
+    end
+
+    def roo_rows(roo_sheet)
+      (roo_sheet.first_row .. roo_sheet.last_row)
+    end
+
+    def protect_spreadsheet
+      active_sheet.protect if protected?
+    end
+
+    def apply_data_to_sheets
+      sheets.each_with_index do |sheet, sheet_number|
+        @current_sheet = sheet
+        sheet_data = sheet.sheet_data(data)
+        template_sheet = template.sheet(sheet_number)
+
+        # column and row styles should be applied before writing any data to the sheet
+        style_columns(sheet, template_sheet)
+        # row styles have priority over column styles
+        style_rows(sheet, template_sheet)
+
+        roo_rows(template_sheet).each do |row_number|
+          sheet.each_row_at(row_number, sheet_data) do |row_data|
+            local_data = stringify_keys(data[:all_sheets]).merge(stringify_keys(row_data))
+            roo_columns(template_sheet).each do |column_number|
+              apply_data_to_cell(local_data, template_sheet, row_number, column_number)
+              if sheet.validated_cell?(row_number, column_number)
+                add_validation(sheet, row_number, column_number)
+              end
+            end
+            active_sheet.next_row
+          end
+        end
+      end
+    end
+
+    def apply_data_to_cell(local_data, template_sheet, row_number, column_number)
+      template_cell = template_sheet.cell(row_number, column_number)
+      font = template_sheet.font(row_number, column_number)
+      format = format_for(font, row_number, column_number)
+      value = mustachify(template_cell, locals: local_data)
+
+      active_sheet.cell(
+        value,
+        type: type_for_value(value),
+        format: format
+      )
+    end
+
+    def type_for_value(value)
+      looks_like_a_separator?(value) ? :string : :auto
+    end
+
+    def looks_like_a_separator?(value)
+      value.is_a?(String) && value =~ /^==/
+    end
+
+    def format_for(font, row_number, column_number)
+      format = font_formats(font)
+
+      set_column_lock(format, column_number) if column_is_locked?(column_number)
+      set_row_lock(format, row_number)  if row_is_locked?(row_number)
+
+      format
+    end
+
+    def column_is_locked?(column_number)
+      row_or_column_is_locked? current_sheet.column_styles[column_number]
+    end
+
+    def row_is_locked?(row_number)
+      row_or_column_is_locked? current_sheet.row_styles[row_number]
+    end
+
+    def row_or_column_is_locked?(row_or_column)
+      row_or_column && row_or_column[:format] && row_or_column[:format].has_key?(:locked)
+    end
+
+    def row_or_column_lock_attribute(row_or_column)
+      row_or_column && row_or_column[:format] && row_or_column[:format][:locked]
+    end
+
+    def set_row_lock(format, row_number)
+      format.set_locked row_or_column_lock_attribute(current_sheet.row_styles[row_number])
+    end
+
+    def set_column_lock(format, column_number)
+      format.set_locked row_or_column_lock_attribute(current_sheet.column_styles[column_number])
+    end
+
+    def font_formats(font=nil)
+      template_font = font || Roo::Font.new
+
+      format_details = {
+        bold: template_font.bold? ? 1 : 0,
+        italic: template_font.italic? ? 1 : 0,
+        underline: template_font.underline? ? 1 : 0
+      }.merge(default_format_styling)
+
+      workbook.add_format format_details
+    end
+
+    def mustachify(inline_template, locals: {})
+      if whole_cell_template?(inline_template)
+        locals.fetch(extract_key_from_template(inline_template))
+      elsif no_mustache_found?(inline_template)
+        inline_template
+      else
+        MustacheRenderer.render(inline_template, locals)
+      end
+    end
+
+    def no_mustache_found?(value)
+      !value.is_a?(String) || !(value.match(/{{.+}}/))
+    end
+
+    def extract_key_from_template(template)
+      template[whole_cell_template_matcher, 1]
+    end
+
+    def whole_cell_template_matcher
+      /^{{([^{}]+)}}$/
+    end
+
+    def whole_cell_template?(template)
+      template =~ whole_cell_template_matcher
+    end
+
+    def add_validation(sheet, row_number, column_number)
+      raise ArgumentError, "No :data_sources defined for validation!" unless data_source_registry
+      source = sheet.validation_source_name(row_number, column_number)
+      #Use current_row and current_col here because row_number and column_number refer to the template
+      #sheet and we want to write a reference to the cell we just wrote
+      active_sheet.data_validation absolute_reference(current_row + 1, current_col),
+                                   registry_renderer.absolute_reference_for(source)
+    end
+
+    def absolute_reference(row_number, column_number)
+      "$#{RenderHelper.letter_for(column_number)}$#{row_number}"
+    end
+
+    class MustacheRenderer < Mustache
+
+      def self.render(template, locals)
+        renderer = new
+        renderer.template = template
+        renderer.raise_on_context_miss = true
+        renderer.render(locals)
+      end
+
+    end
+  end
+end

data/lib/excel_templating/rspec_excel_matcher.rb

@@ -0,0 +1,129 @@
+require 'roo'
+require "roo-xls"
+
+# Matcher for rspec 'match_excel_content'
+# @example
+#   expect do
+#     subject.render do |path|
+#       expect(path).to match_excel_content('spec/assets/spreadsheets/seven_three_expected.xlsx')
+#     end
+#   end
+RSpec::Matchers.define :match_excel_content do |expected_excel_path|
+  match do |excel_path|
+    @excel_matcher = RSpec::Matchers::ExcelMatcher.new
+    @excel_matcher.expected_roo = Roo::Spreadsheet.open(expected_excel_path)
+    @excel_matcher.actual_roo = Roo::Spreadsheet.open(excel_path)
+    @excel_matcher.match?
+  end
+
+  failure_message do |excel_path|
+    messages = ["expected excel:#{expected_excel_path} to exactly match the content of #{excel_path} but did not."]
+    @excel_matcher.errors.group_by(&:first).each do |sheet_name, errors|
+      messages << "#{sheet_name}:"
+      errors.each do |_, error|
+        messages << "  #{error}:"
+      end
+    end
+    messages.join("\n")
+  end
+
+  failure_message_when_negated do |excel_path|
+    "expected excel:#{expected_excel_path} to not exactly match the content of #{excel_path} but it did."
+  end
+end
+
+# Specific Matcher class helper for comparing two excel documents.
+class RSpec::Matchers::ExcelMatcher
+
+  def initialize
+    @errors = []
+  end
+
+  def match?
+    sheet_count_equal? && all_sheets_equal?
+  end
+
+  attr_accessor :errors, :expected_roo, :actual_roo
+
+  private
+
+  def check(sheet_name, check_result, fail_msg)
+    if check_result
+      true
+    else
+      errors << [sheet_name, fail_msg]
+      false
+    end
+  end
+
+  def sheet_count_equal?
+    check(:base, expected_roo.sheets.count == actual_roo.sheets.count, "Number of sheets do not match.")
+  end
+
+  def all_sheets_equal?
+    sheets(expected_roo).zip(sheets(actual_roo)).all? do |expected_sheet, actual_sheet|
+      sheets_equal?(expected_sheet, actual_sheet)
+    end
+  end
+
+  def sheets(roo)
+    (0 .. (roo.sheets.count - 1)).map do |i|
+      roo.sheet(i)
+    end
+  end
+
+  def sheets_equal?(expected_workbook, actual_workbook)
+    expected_workbook.sheets.all? do |sheet_name|
+      expected = expected_workbook.sheet(sheet_name)
+      actual = begin
+        actual_workbook.sheet(sheet_name)
+      rescue
+        nil
+      end
+
+      check(sheet_name, actual, "Sheet names do not match.") if actual != nil
+      # check(sheet_name, expected.first_row == actual.first_row, "Number of rows do not match.")
+      # check(sheet_name, expected.last_row == actual.last_row, "Number of rows do not match")
+      # check(sheet_name, expected.first_column == actual.first_column, "Number of columns do not match")
+      # check(sheet_name, expected.last_column == actual.last_column, "Number of columns do not match")
+      check_cells(sheet_name, expected, actual)
+
+      errors.empty?
+    end
+  end
+
+  def check_cells(sheet_name, sheet1, sheet2)
+    (sheet1.first_row .. sheet1.last_row).each do |row|
+      (sheet1.first_column .. sheet1.last_column).each do |col|
+        check(sheet_name, compare_value(col, row, sheet1, sheet2), discrepancy_message(col, row, sheet1, sheet2))
+      end
+    end
+  end
+
+  def compare_value(col, row, sheet1, sheet2)
+    value2 = sheet2.cell(row, col)
+    value1 = sheet1.cell(row, col)
+    if value2.class == Float
+      value2 == value1.to_f
+    elsif value1.class == Float
+      value1 == value2.to_f
+    else
+      value2 == value1
+    end
+  end
+
+  def discrepancy_message(col, row, sheet1, sheet2)
+    cell_id = "#{column_letter(col)}#{row}"
+    actual_value = sheet2.cell(row, col).inspect
+    expected_value = sheet1.cell(row, col).inspect
+    "Cell #{cell_id} actual:#{actual_value} expected:#{expected_value}"
+  end
+
+  def column_letter(col_number)
+    column_letters[col_number - 1]
+  end
+
+  def column_letters
+    @column_letters ||= ('A' .. 'ZZ').to_a
+  end
+end

data/lib/excel_templating/version.rb

@@ -0,0 +1,4 @@
+module ExcelTemplating
+  # excel_templating version
+  VERSION = "0.3.2"
+end

data/lib/excel_templating.rb

@@ -0,0 +1,4 @@
+require 'excel_templating/version'
+require 'excel_templating/renderer'
+require 'excel_templating/document'
+require 'excel_templating/render_helper'