excel_templating 0.3.2

data/lib/excel_templating/document/data_source_registry.rb

@@ -0,0 +1,64 @@
+module ExcelTemplating
+  # A registry for validation data sources within the excel spreadsheet DSL
+  # Supports Enumerable#each for iterating the registry entries.
+  class Document::DataSourceRegistry
+    include Enumerable
+    extend Forwardable
+
+    # Create an empty DataSourceRegistry
+    def initialize
+      @source_symbols = {}
+    end
+
+    # @param [Hash] data
+    # @return [RegistryRenderer]
+    def renderer(data:)
+      RegistryRenderer.new(self, data)
+    end
+
+    # @param [Symbol] source_symbol
+    # @param [String] title
+    # @param [Array<String>|Symbol] list
+    # @param [TrueClass|FalseClass] inline
+    def add_list(source_symbol, title, list, inline)
+      source_symbols[source_symbol] = RegistryList.new(source_symbols.size + 1, source_symbol, title, list, inline)
+    end
+
+    # @param [Symbol] source_symbol
+    # @return [RegistryList]
+    def [](source_symbol)
+      source_symbols[source_symbol]
+    end
+
+    # @param [Symbol] source_symbol
+    def has_registry?(source_symbol)
+      source_symbols.has_key?(source_symbol)
+    end
+
+    # @return [TrueClass|FalseClass]
+    def any_data_sheet_symbols?
+      select {|info|
+        info.data_sheet?
+      }.any?
+    end
+
+    # @return [Array<Symbol>]
+    def supported_registries
+      source_symbols.keys
+    end
+
+    delegate [:each] => :ordered_registries
+
+    private
+
+    attr_reader :source_symbols
+
+    def ordered_registries
+      source_symbols.values.sort_by(&:order)
+    end
+
+  end
+end
+
+require_relative 'data_source_registry/registry_renderer'
+require_relative 'data_source_registry/registry_list'

data/lib/excel_templating/document/sheet/repeated_row.rb

@@ -0,0 +1,39 @@
+module ExcelTemplating
+  # Simple class for representing a repeated row on a sheet.
+  class Document::Sheet::RepeatedRow
+    # @param [Integer] row_number
+    # @param [Symol] data_attribute
+    def initialize(row_number, data_attribute)
+      @row_number = row_number
+      @data_attribute = data_attribute
+      @column_validations = {}
+    end
+
+    ### Dsl Methods ###
+
+    # Validate a particular row in a repeated set as being part of a declared data source
+    # @example
+    #   validate_column 5, with: :valid_foos
+    # @param [Integer] column_number
+    # @param [Symbol] with
+    def validate_column(column_number, with:)
+      @column_validations[column_number] = with
+    end
+
+    ### Non Dsl Methods ###
+
+    attr_reader :row_number, :data_attribute
+
+    # @param [Integer] column_number
+    # @return [Symbol] Registered source at that column
+    def validated_column_source(column_number)
+      @column_validations[column_number]
+    end
+
+    # @param [Integer] column_number
+    # @return [TrueClass|FalseClass]
+    def validated_column?(column_number)
+      @column_validations.has_key?(column_number)
+    end
+  end
+end

data/lib/excel_templating/document/sheet.rb

@@ -0,0 +1,133 @@
+module ExcelTemplating
+  # Define a sheet on a document
+  # @example
+  #   sheet 1 do
+  #     repeat_row 17, with: :people
+  #   end
+  class Document::Sheet
+    # @param [Integer] sheet_number
+    def initialize(sheet_number)
+      @sheet_number = sheet_number
+      @repeated_rows = {}
+      @validated_cells = {}
+    end
+
+    ### Sheet Dsl Methods ####
+
+    # @param [Float] decimal_inches
+    # @return [Float] inches converted to excel integer size.
+    def inches(decimal_inches)
+      # empirically determined number. 30.0 seems to be the measurement for 2.6 inches
+      # in open office.
+      (30.0 / 2.6) * decimal_inches
+    end
+
+    # @param [Hash] default default styling for all columns.
+    # @param [Hash] columns specific styling for numbered columns.
+    def style_columns(default:, columns: {})
+      @default_column_style = default
+      @column_styles = columns
+    end
+
+    # @param [Hash] default default styling for all rows.
+    # @param [Hash] rows specific styling for numbered rows.
+    def style_rows(default:, rows: {})
+      @default_row_style = default
+      @row_styles = rows
+    end
+
+    # Repeat a numbered row in the template using an array from the data
+    # will result in expanding the produced excel document by a number of rows.
+    # it is expected that the sheet specific data will contain :with as an Array.
+    # @example
+    #   repeat_row 17, with: :employee_data
+    # @param [Integer] row_number
+    # @param [Symbol] with
+    def repeat_row(row_number, with:, &block)
+      repeated_rows[row_number] = RepeatedRow.new(row_number, with)
+      repeated_rows[row_number].instance_eval(&block) if block_given?
+    end
+
+    # Validate a particular cell using a declared data source
+    # @example
+    #   validate_cell row: 1, column :5, with: :valid_foos
+    # @param [Integer] row
+    # @param [Integer] column
+    # @param [Symbol] with
+    def validate_cell(row:, column:, with:)
+      validated_cells["#{row}:#{column}"] = with
+    end
+    
+    #### Non DSL Methods ###
+
+    def default_column_style
+      @default_column_style || {}
+    end
+
+    def column_styles
+      @column_styles || {}
+    end
+
+    def default_row_style
+      @default_row_style || {}
+    end
+
+    def row_styles
+      @row_styles || {}
+    end
+
+    def sheet_data(data)
+      data[sheet_number] || {}
+    end
+
+    # @param [Integer] row_number
+    def repeated_row?(row_number)
+      repeated_rows.has_key?(row_number)
+    end
+
+    # @param [Integer] row_number
+    # @param [Integer] column_number
+    def validated_cell?(row_number, column_number)
+      (repeated_row?(row_number) && repeated_rows[row_number].validated_column?(column_number)) ||
+        validated_cells.has_key?("#{row_number}:#{column_number}")
+    end
+
+    # @param [Integer] row_number
+    # @param [Integer] column_number
+    # @return [Symbol] The registered symbol for that row & column or Nil
+    def validation_source_name(row_number, column_number)
+      if repeated_row?(row_number)
+        repeated_rows[row_number].validated_column_source(column_number)
+      else
+        validated_cells["#{row_number}:#{column_number}"]
+      end
+    end
+
+    # Repeat each row of the data if it is repeated, yielding each item in succession.
+    # @param [Integer] row_number
+    # @param [Hash] sheet_data Data for this sheet
+    def each_row_at(row_number, sheet_data)
+      if repeated_row?(row_number)
+        repeater = repeated_rows[row_number]
+        verify_array!(sheet_data, repeater.data_attribute)
+        sheet_data[repeater.data_attribute].each_with_index do |row_data, index|
+          yield({ index: index }.merge(row_data).merge(sheet_data))
+        end
+      else
+        yield sheet_data
+      end
+    end
+
+    private
+
+    attr_reader :sheet_number, :repeated_rows, :validated_cells
+
+    def verify_array!(sheet_data, attribute)
+      unless sheet_data[attribute].is_a?(Array)
+        raise ArgumentError, "Data for sheet #{sheet_number} did not contain #{attribute} array as expected!"
+      end
+    end
+  end
+end
+
+require_relative 'sheet/repeated_row'

data/lib/excel_templating/document.rb

@@ -0,0 +1,71 @@
+require_relative 'document_dsl'
+
+module ExcelTemplating
+  # The base document class for an ExcelTemplating.
+  # Inherit from document to create your own ExcelTemplating that you may then use to generate
+  # Excel Spreadsheets from the template you supply.
+  # @example
+  #   class MyTemplate < ExcelTemplating::Document
+  #     template "my_template.mustache.xlsx"
+  #     title "My title: {{my_company}}"
+  #     organization "{{organization_name}}"
+  #     default_styling(
+  #       text_wrap: 0,
+  #       font: "Calibri",
+  #       size: 10,
+  #       align: :left,
+  #     )
+  #     sheet 1 do
+  #       repeat_row 17, with: :people
+  #     end
+  #   end
+  class Document
+    extend DocumentDsl
+    class << self
+      ## The non Dsl Methods, not expected to be used as part of the document description
+      # @return [String] The document title
+      def document_title
+        @document_title
+      end
+
+      # @return [String] The document organization
+      def document_organization
+        @document_organization
+      end
+
+      # @return [Hash] The default styling for the document
+      def document_default_styling
+        @default_styling || default_styling
+      end
+    end
+    # Create a new document with given data.  'all_sheets' is available to the template on each sheet.
+    # otherwise each numeric key in 'sheet_data' provides the data for that specific sheet.
+    # For example {all_sheets: {foo: 'bar'}, 1 => {var1: "foo"}}
+    # @param [Hash] data Hash with variables for rendering.
+    def initialize(data)
+      @data = data
+    end
+
+    # Render this template.
+    # @example
+    #   instance = MyTemplate.new(all_sheets: {foo: 1},1 => {bar: "foo"})
+    #   instance.render do |file_path|
+    #     FileUtils.cp(file_path, somewhere_else)
+    #   end
+    def render(&block)
+      new_renderer.render(&block)
+    end
+
+    attr_reader :data
+
+    private
+
+    def new_renderer
+      ExcelTemplating::Renderer.new(self)
+    end
+
+  end
+end
+
+require_relative 'document/sheet'
+require_relative 'document/data_source_registry'

data/lib/excel_templating/document_dsl.rb

@@ -0,0 +1,85 @@
+module ExcelTemplating
+  # The descriptor module for how to define your template class
+  module DocumentDsl
+    # @return [String] The template path.
+    def template_path
+      @template_path
+    end
+
+    # @param [String] path Set the path to the template for this document class.
+    def template(path)
+      raise ArgumentError, "Template path must be a string." unless path.is_a?(String)
+      @template_path = path
+    end
+
+    # @return [Array<ExcelTemplating::Document::Sheet>] The sheets defined for this document class.
+    def sheets
+      @sheets ||= []
+    end
+
+    # Define a sheet on this document
+    # @example
+    #   sheet 1 do
+    #     repeat_row 17, with: :people
+    #   end
+    # @param [Integer] sheet_number
+    # @param [Proc] block
+    def sheet(sheet_number, &block)
+      sheet = ExcelTemplating::Document::Sheet.new(sheet_number)
+      sheets << sheet
+      sheet.instance_eval(&block)
+      nil
+    end
+
+    def protect_document(protect=true)
+      @protected = protect
+    end
+
+    def protected?
+      !!@protected
+    end
+
+    # Add a list validator to the excel document
+    # @example
+    #   list_source :valid_foos, title: "Valid Foos", list: ['foo','bar'], inline: false
+    # @param [Symbol] source_symbol symbol to registry for the validator
+    # @param [String] title Title to show when displaying this validator
+    # @param [Array<String>|Symbol] list items to use for validation, you may also use :from_data and at render time
+    #                                    the validation items will be fetched from key 'source_symbol'
+    # @param [TrueClass|FalseClass] inline If true then the validator will be written to the document inline.
+    #                                       Otherwise it will be written to a 'DataSheet'
+    def list_source(source_symbol, title:, list: :from_data, inline: false)
+      data_source_registry.add_list(source_symbol, title, list, inline)
+    end
+
+    def data_source_registry
+      @data_source_registry ||= ExcelTemplating::Document::DataSourceRegistry.new
+    end
+
+    # Define a title for this workbook.  You may use mustaching here.
+    # @param [String] string
+    def title(string)
+      @document_title = string
+    end
+
+    # Define the default styling to use when writing
+    # a column to the worksheet.  See Writeexcel::Format
+    # @param [String] font Set the font name
+    # @param [Integer] size font size
+    # @param [Symbol] align :left, :right, or :center
+    # @param [Hash] options Additional options to pass to Format
+    def default_styling(font: "Calibri", size: 10, align: :left, ** options)
+      @default_styling = {
+        name: font,
+        size: size,
+        align: align
+      }.merge(options)
+    end
+
+    # Define an organization for the workbook.  May use mustaching.
+    # @param [String] string
+    def organization(string)
+      @document_organization = string
+    end
+  end
+end

data/lib/excel_templating/excel_abstraction/active_cell_reference.rb

@@ -0,0 +1,59 @@
+module ExcelAbstraction
+  class ActiveCellReference
+    extend Forwardable
+
+    def_delegators :position, :row, :col
+
+    def initialize(attrs = {})
+      @position = ExcelAbstraction::CellReference.new(attrs)
+    end
+
+    def move(directions = {})
+      directions.each do |type, times|
+        self.respond_to?(type) ? self.__send__(type, times) : raise(ArgumentError.new("Movement direction is not valid."))
+      end
+      position
+    end
+
+    def up(times = 1)
+      goto(row - times, col)
+    end
+
+    def down(times = 1)
+      goto(row + times, col)
+    end
+
+    def left(times = 1)
+      goto(row, col - times)
+    end
+
+    def right(times = 1)
+      goto(row, col + times)
+    end
+
+    def carriage_return
+      goto(row, 0)
+    end
+
+    def linefeed
+      down
+    end
+
+    def newline
+      carriage_return
+      linefeed
+    end
+
+    def goto(row, col)
+      self.position = ExcelAbstraction::CellReference.new(row: row, col: col)
+    end
+
+    def reset
+      self.position = ExcelAbstraction::CellReference.new(row: 0, col: 0)
+    end
+
+    protected
+
+    attr_accessor :position
+  end
+end

data/lib/excel_templating/excel_abstraction/cell.rb

@@ -0,0 +1,23 @@
+module ExcelAbstraction
+  class Cell
+    attr_reader :position, :val, :styles
+
+    def initialize(attrs = {})
+      @position = Integer(attrs.fetch(:position) { raise ArgumentError.new("Position absent for ExcelAbstraction cell") })
+      @val = attrs.fetch(:val) { raise ArgumentError.new("Value absent for ExcelAbstraction cell") }
+      @styles = attrs.fetch(:styles) { {} }
+    end
+
+    def <=>(other)
+      position <=> other.position
+    end
+
+    def ==(other)
+      position == other.position && val == other.val && styles == other.styles
+    end
+
+    def to_cell
+      self
+    end
+  end
+end

data/lib/excel_templating/excel_abstraction/cell_range.rb

@@ -0,0 +1,26 @@
+module ExcelAbstraction
+  class CellRange
+    include Enumerable
+
+    alias_method :first, :min
+    alias_method :last, :max
+
+    def initialize
+      @cell_references = []
+    end
+
+    def each(&block)
+      cell_references.each { |cell_reference| yield(cell_reference) }
+    end
+
+    def <<(attrs)
+      cell_reference = ExcelAbstraction::CellReference.new(attrs)
+      raise(ArgumentError, "Must be a CellReference belonging to the same row") if last && last.row != cell_reference.row
+      self.cell_references << cell_reference
+    end
+
+    protected
+
+    attr_reader :cell_references
+  end
+end

data/lib/excel_templating/excel_abstraction/cell_reference.rb

@@ -0,0 +1,39 @@
+module ExcelAbstraction
+  class CellReference
+    include Comparable
+
+    COLS = ('A'..'ZZ').to_a
+
+    attr_accessor :row, :col
+
+    def initialize(attrs = {})
+      @row = attrs.fetch(:row) { 0 }
+      @col = attrs.fetch(:col) { 0 }
+    end
+
+    def <=>(other)
+      other = other.to_cell_reference
+      (self.row == other.row) ? (self.col <=> other.col) : (self.row <=> other.row)
+    end
+
+    def succ
+      self.class.new(row: self.row, col: self.col + 1)
+    end
+
+    def to_s
+      COLS[col] + (row + 1).to_s
+    end
+
+    def to_cell_reference
+      self
+    end
+
+    def to_ary
+      [row, col]
+    end
+
+    def to_a
+      to_ary
+    end
+  end
+end

data/lib/excel_templating/excel_abstraction/date.rb

@@ -0,0 +1,36 @@
+require 'delegate'
+
+module ExcelAbstraction
+  class Date < DelegateClass(Float)
+    ADJUSTMENT = ::Date.parse("1900-03-01")
+    REFERENCE = ::Date.parse("1900-01-01")
+
+    attr_reader :value
+
+    def initialize(raw_value)
+      super(convert(raw_value))
+    end
+
+    def to_excel_date
+      self
+    end
+
+    private
+
+    def reference
+      REFERENCE
+    end
+
+    def adjustment
+      ADJUSTMENT
+    end
+
+    def adjust(raw_value)
+      adjustment < raw_value ? 2 : 1
+    end
+
+    def convert(raw_value)
+      (raw_value - reference + adjust(raw_value)).to_f
+    end
+  end
+end

data/lib/excel_templating/excel_abstraction/row.rb

@@ -0,0 +1,29 @@
+module ExcelAbstraction
+  class Row
+    include Enumerable
+    extend Forwardable
+
+    attr_accessor :styles
+    delegate [:each] => :cells
+
+    alias :first :min
+    alias :last :max
+
+    def initialize
+      @cells = []
+      @styles = {}
+    end
+
+    def [](index)
+      find { |cell| cell.position == index }
+    end
+
+    def <<(attrs)
+      @cells << ExcelAbstraction::Cell.new(attrs)
+    end
+
+    protected
+
+    attr_accessor :cells
+  end
+end