zaxcel 0.1.1

data/lib/zaxcel/functions/xirr.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+# typed: strict
+
+# https://support.microsoft.com/en-us/office/xirr-function-de1242ec-6477-445b-b11b-a303ad9adc9d
+class Zaxcel::Functions::Xirr < Zaxcel::Function
+  extend T::Sig
+
+  sig do
+    params(
+      values: Zaxcel::References::Range,
+      dates: Zaxcel::References::Range,
+      guess: T.nilable(Zaxcel::CellFormula),
+    ).void
+  end
+  def initialize(values, dates, guess: nil)
+    @values = values
+    @dates = dates
+    @guess = guess
+  end
+
+  sig { override.params(on_sheet: String).returns(String) }
+  def format(on_sheet:)
+    guess_string = ", #{Zaxcel::Cell.format(@guess, on_sheet: on_sheet)}" if @guess.present?
+
+    "XIRR(#{@values.format(on_sheet: on_sheet)},#{@dates.format(on_sheet: on_sheet)}#{guess_string})"
+  end
+end

data/lib/zaxcel/functions.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+# typed: strict
+
+module Zaxcel::Functions
+  class << self
+    extend T::Sig
+
+    sig { params(value: Zaxcel::Cell::ValueType).returns(Zaxcel::Functions::Abs) }
+    def abs(value)
+      Zaxcel::Functions::Abs.new(value)
+    end
+
+    sig do
+      params(
+        lh_value: Zaxcel::Cell::ValueType,
+        rh_value: Zaxcel::Cell::ValueType,
+      ).returns(Zaxcel::Functions::And)
+    end
+    def and(lh_value, rh_value)
+      Zaxcel::Functions::And.new(lh_value, rh_value)
+    end
+
+    sig { params(range: Zaxcel::References::Range).returns(Zaxcel::Functions::Average) }
+    def average(range)
+      Zaxcel::Functions::Average.new(range)
+    end
+
+    sig { params(values: Zaxcel::Cell::ValueType).returns(Zaxcel::Functions::Concatenate) }
+    def concatenate(*values)
+      Zaxcel::Functions::Concatenate.new(values)
+    end
+
+    sig do
+      params(
+        choice_index: Zaxcel::Cell::ValueType,
+        choices: T::Array[Zaxcel::Cell::ValueType],
+      ).returns(Zaxcel::Functions::Choose)
+    end
+    def choose(choice_index, choices:)
+      Zaxcel::Functions::Choose.new(choice_index, choices: choices)
+    end
+
+    sig do
+      params(
+        value: Zaxcel::Cell::ValueType,
+        default_value: Zaxcel::Cell::ValueType,
+      ).returns(Zaxcel::Functions::IfError)
+    end
+    def if_error(value, default_value:)
+      Zaxcel::Functions::IfError.new(value, default_value: default_value)
+    end
+
+    sig do
+      params(
+        index_value: Zaxcel::Cell::ValueType,
+        range: Zaxcel::References::Column,
+      ).returns(Zaxcel::Functions::Index)
+    end
+    def index(index_value:, range:)
+      Zaxcel::Functions::Index.new(index_value: index_value, range: Zaxcel::Lang.range(range))
+    end
+
+    sig { params(value: Zaxcel::Cell::ValueType, range: Zaxcel::References::Column, match_type: T.nilable(Zaxcel::Functions::Match::MatchType)).returns(Zaxcel::Functions::Match) }
+    def match(value:, range:, match_type: nil)
+      Zaxcel::Functions::Match.new(value: value, range: Zaxcel::Lang.range(range), match_type: match_type)
+    end
+
+    sig { params(values: T.any(Zaxcel::Cell::ValueType, Zaxcel::References::Range)).returns(Zaxcel::Functions::Max) }
+    def max(*values)
+      Zaxcel::Functions::Max.new(values)
+    end
+
+    sig { params(values: T.any(Zaxcel::Cell::ValueType, Zaxcel::References::Range)).returns(Zaxcel::Functions::Min) }
+    def min(*values)
+      Zaxcel::Functions::Min.new(values)
+    end
+
+    sig do
+      params(
+        lh_value: Zaxcel::Cell::ValueType,
+        rh_value: Zaxcel::Cell::ValueType,
+      ).returns(Zaxcel::Functions::Or)
+    end
+    def or(lh_value, rh_value)
+      Zaxcel::Functions::Or.new(lh_value, rh_value)
+    end
+
+    sig { params(value: Zaxcel::Cell::ValueType, precision: Integer).returns(Zaxcel::Functions::Round) }
+    def round(value, precision: 0)
+      Zaxcel::Functions::Round.new(value, precision: precision)
+    end
+
+    sig { params(values: T.any(Zaxcel::Cell::ValueType, Zaxcel::References::Range)).returns(Zaxcel::Functions::Sum) }
+    def sum(*values)
+      Zaxcel::Functions::Sum.new(values)
+    end
+
+    sig do
+      params(
+        column_to_check: Zaxcel::References::Column,
+        value_to_check: Zaxcel::Cell::ValueType,
+        column_to_sum: Zaxcel::References::Column,
+      ).returns(Zaxcel::Functions::SumIf)
+    end
+    def sum_if(column_to_check:, value_to_check:, column_to_sum:)
+      Zaxcel::Functions::SumIf.new(
+        range_to_check: Zaxcel::Lang.range(column_to_check),
+        value_to_check: value_to_check,
+        range_to_sum: Zaxcel::Lang.range(column_to_sum),
+      )
+    end
+
+    sig do
+      params(
+        ranges_to_check: T::Array[Zaxcel::References::Range],
+        values_to_check: T::Array[Zaxcel::Cell::ValueType],
+        range_to_sum: Zaxcel::References::Range,
+      ).returns(Zaxcel::Functions::SumIfs)
+    end
+    def sum_ifs(ranges_to_check:, values_to_check:, range_to_sum:)
+      Zaxcel::Functions::SumIfs.new(
+        ranges_to_check: ranges_to_check,
+        values_to_check: values_to_check,
+        range_to_sum: range_to_sum,
+      )
+    end
+
+    sig { params(range_values: T::Enumerable[Zaxcel::References::Range::RangeableType]).returns(Zaxcel::Functions::Sum) }
+    def sum_range(range_values)
+      range = Zaxcel::Lang.range(range_values.first!, range_values.last!) if range_values.any?
+      Zaxcel::Functions::Sum.new([range].compact)
+    end
+
+    sig { params(value: Zaxcel::Cell::ValueType, format_string: String).returns(Zaxcel::Functions::Text) }
+    def text(value, format_string:)
+      Zaxcel::Functions::Text.new(value, format_string: format_string)
+    end
+
+    sig { params(value: Zaxcel::Cell::ValueType).returns(Zaxcel::Functions::Len) }
+    def len(value)
+      Zaxcel::Functions::Len.new(value)
+    end
+
+    sig do
+      params(
+        condition: Zaxcel::Cell::ValueType,
+        idx_range: Zaxcel::References::Range,
+        value_range: Zaxcel::References::Range,
+      ).returns(Zaxcel::Functions::XLookup)
+    end
+    def x_lookup(condition, idx_range:, value_range:)
+      Zaxcel::Functions::XLookup.new(condition, idx_range: idx_range, value_range: value_range)
+    end
+
+    sig do
+      params(
+        values: T::Array[Zaxcel::References::Cell],
+        dates: T::Array[Zaxcel::References::Cell],
+        guess: T.nilable(Zaxcel::CellFormula),
+      ).returns(Zaxcel::Functions::Xirr)
+    end
+    def xirr(values:, dates:, guess: nil)
+      value_range = Zaxcel::References::Range.new(values.first!, values.last!)
+      date_range = Zaxcel::References::Range.new(dates.first!, dates.last!)
+
+      Zaxcel::Functions::Xirr.new(value_range, date_range, guess: guess)
+    end
+  end
+end

data/lib/zaxcel/if_builder.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Zaxcel::IfBuilder
+  extend T::Sig
+
+  sig { params(condition: Zaxcel::Cell::ValueType).void }
+  def initialize(condition)
+    @condition = T.let(condition, Zaxcel::Cell::ValueType)
+  end
+
+  sig { params(result: Zaxcel::Cell::ValueType).returns(Zaxcel::IfBuilder) }
+  def then(result)
+    @then = T.let(result, Zaxcel::Cell::ValueType)
+    self
+  end
+
+  sig { params(result: Zaxcel::Cell::ValueType).returns(Zaxcel::Functions::If) }
+  def else(result)
+    Zaxcel::Functions::If.new(@condition, if_true: @then, if_false: result)
+  end
+end

data/lib/zaxcel/lang.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+# typed: strict
+
+module Zaxcel::Lang
+  class << self
+    extend T::Sig
+
+    sig { params(condition: Zaxcel::Cell::ValueType).returns(Zaxcel::IfBuilder) }
+    def if(condition)
+      Zaxcel::IfBuilder.new(condition)
+    end
+
+    sig do
+      params(
+        lh_value: Zaxcel::References::Range::RangeableType,
+        rh_value: T.nilable(Zaxcel::References::Range::RangeableType),
+      ).returns(Zaxcel::References::Range)
+    end
+    def range(lh_value, rh_value = nil)
+      Zaxcel::References::Range.new(lh_value, rh_value)
+    end
+  end
+end

data/lib/zaxcel/reference.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Zaxcel::Reference
+  extend T::Sig
+  extend T::Helpers
+
+  abstract!
+
+  sig { abstract.returns(String) }
+  def sheet_name; end
+
+  sig { abstract.returns(String) }
+  def excel_sheet_name; end
+
+  sig { abstract.returns(String) }
+  def resolve; end
+
+  sig { params(on_sheet: String).returns(T.nilable(String)) }
+  def format(on_sheet:)
+    formatted_string = resolve
+    return if formatted_string.blank?
+
+    formatted_string = "'#{excel_sheet_name}'!#{formatted_string}" if on_sheet.present? && on_sheet != sheet_name
+
+    formatted_string
+  end
+end

data/lib/zaxcel/references/cell.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Zaxcel::References::Cell < Zaxcel::Reference
+  include Zaxcel::Arithmetic
+  include Zaxcel::Roundable
+  extend T::Sig
+
+  sig { override.returns(String) }
+  attr_reader :sheet_name
+
+  sig { returns(Zaxcel::Document) }
+  attr_reader :document
+
+  sig { returns(Symbol) }
+  attr_reader :column_name, :row_name
+
+  sig { params(document: Zaxcel::Document, sheet_name: String, row_name: Symbol, col_name: Symbol).void }
+  def initialize(document:, sheet_name:, row_name:, col_name:)
+    super()
+
+    @document = document
+    @sheet_name = sheet_name
+    @column_name = col_name
+    @row_name = row_name
+  end
+
+  sig { override.returns(String) }
+  def resolve
+    cell&.to_excel || ''
+  end
+
+  sig { override.returns(String) }
+  def excel_sheet_name
+    T.must(@document.sheet_by_name[@sheet_name]&.to_excel)
+  end
+
+  sig { returns(T.nilable(Zaxcel::Cell)) }
+  def cell
+    @document.sheet(@sheet_name)&.column(@column_name)&.cell(@row_name)
+  end
+end

data/lib/zaxcel/references/column.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Zaxcel::References::Column < Zaxcel::Reference
+  extend T::Sig
+
+  sig { override.returns(String) }
+  attr_reader :sheet_name
+
+  sig { params(sheet_name: String, col_name: Symbol, document: Zaxcel::Document).void }
+  def initialize(sheet_name:, col_name:, document:)
+    super()
+
+    @sheet_name = sheet_name
+    @col_name = col_name
+    @document = document
+  end
+
+  sig { override.returns(String) }
+  def resolve
+    T.must_because(column) { "No column on sheet #{sheet_name} named #{@col_name}" }
+      .to_excel
+  end
+
+  sig { returns(T.nilable(Zaxcel::Column)) }
+  def column
+    @column ||= T.let(@document.sheet(@sheet_name)&.column(@col_name), T.nilable(Zaxcel::Column))
+  end
+
+  sig { override.returns(String) }
+  def excel_sheet_name
+    T.must(@document.sheet_by_name[@sheet_name]&.to_excel)
+  end
+
+  sig { returns(T::Array[Zaxcel::Cell]) }
+  def cells
+    return [] if column.nil?
+
+    @cells ||= T.let(
+      begin
+        cells_in_column = T.must(column).cell_by_row_name.values
+        raise 'Must position cells before resolving references.' if cells_in_column.any? { |cell| cell.col_position.nil? }
+
+        cells_in_column.sort_by { |cell| T.must(cell.row_position) }
+      end,
+      T.nilable(T::Array[Zaxcel::Cell]),
+    )
+  end
+end

data/lib/zaxcel/references/range.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Zaxcel::References::Range < Zaxcel::Reference
+  extend T::Sig
+
+  RangeableType = T.type_alias { T.any(Zaxcel::References::Cell, Zaxcel::References::Row, Zaxcel::References::Column) }
+
+  sig { params(lh_value: RangeableType, rh_value: T.nilable(RangeableType)).void }
+  def initialize(lh_value, rh_value)
+    super()
+
+    rh_value ||= lh_value
+    raise 'Ranges must be from cells on the same sheet' if lh_value.sheet_name != rh_value.sheet_name
+    raise "Incompatible range values #{lh_value.class.name}:#{rh_value.class.name}" if lh_value.class != rh_value.class
+
+    @lh_value = lh_value
+    @rh_value = T.let(rh_value, RangeableType)
+  end
+
+  sig { override.returns(String) }
+  def resolve
+    "#{@lh_value.resolve}:#{@rh_value.resolve}"
+  end
+
+  sig { override.returns(String) }
+  def excel_sheet_name
+    @lh_value.excel_sheet_name
+  end
+
+  sig { override.returns(String) }
+  def sheet_name
+    @lh_value.sheet_name
+  end
+end

data/lib/zaxcel/references/row.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Zaxcel::References::Row < Zaxcel::Reference
+  extend T::Sig
+
+  sig { override.returns(String) }
+  attr_reader :sheet_name
+
+  sig { params(sheet_name: String, row_name: Symbol, document: Zaxcel::Document).void }
+  def initialize(sheet_name:, row_name:, document:)
+    super()
+
+    @sheet_name = sheet_name
+    @row_name = row_name
+    @document = document
+  end
+
+  sig { override.returns(String) }
+  def resolve
+    T.must_because(row) { "No row on sheet #{sheet_name} named #{@row_name}" }
+      .to_excel
+  end
+
+  sig { override.returns(String) }
+  def excel_sheet_name
+    T.must(@document.sheet_by_name[@sheet_name]&.to_excel)
+  end
+
+  sig { returns(T.nilable(Zaxcel::Row)) }
+  def row
+    @row ||= T.let(@document.sheet(sheet_name)&.row(@row_name), T.nilable(Zaxcel::Row))
+  end
+end

data/lib/zaxcel/references.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+# typed: strict
+
+module Zaxcel::References
+end

data/lib/zaxcel/roundable.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+# typed: strict
+
+module Zaxcel::Roundable
+  extend T::Sig
+  extend T::Helpers
+
+  requires_ancestor { Zaxcel::Arithmetic }
+
+  sig { params(precision: Integer).returns(Zaxcel::Functions::Round) }
+  def round(precision: 0)
+    Zaxcel::Functions::Round.new(T.bind(self, Zaxcel::Arithmetic), precision: precision)
+  end
+end

data/lib/zaxcel/row.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Zaxcel::Row
+  extend T::Sig
+
+  sig { returns(Symbol) }
+  attr_reader :name, :style_group
+
+  sig { returns(T.nilable(Integer)) }
+  attr_reader :height
+
+  sig { returns(T.nilable(Integer)) }
+  attr_reader :position
+
+  sig { params(row_name: Symbol, sheet: Zaxcel::Sheet, style_group: Symbol, height: T.nilable(Integer), hidden: T::Boolean).void }
+  def initialize(row_name, sheet:, style_group: :row_style, height: nil, hidden: false)
+    @name = row_name
+    @sheet = sheet
+    @style_group = style_group
+    @height = height
+    @print_boundary = T.let(false, T::Boolean)
+    @hidden = hidden
+  end
+
+  sig { params(col_name: T.any(String, Symbol), sheet_name: T.nilable(String)).returns(Zaxcel::References::Cell) }
+  def ref(col_name, sheet_name: nil)
+    Zaxcel::References::Cell.new(document: @sheet.document, sheet_name: sheet_name || @sheet.name, col_name: col_name.to_sym, row_name: @name)
+  end
+
+  sig { params(column_name: T.any(Symbol, String), value: Zaxcel::Cell::ValueType, style: T.nilable(Symbol), to_extract: T::Boolean).returns(Zaxcel::Row) }
+  def add!(column_name, value:, style: nil, to_extract: false)
+    column = @sheet.column(column_name)
+    raise "Cannot add a cell to a non-existent column #{column_name}" if column.nil?
+
+    cell_by_column_name[column_name.to_sym] = column.add_cell!(value: value, row: self, style: style, to_extract: to_extract)
+
+    self
+  end
+
+  sig { params(col_name: T.any(Symbol, String)).void }
+  def add_empty!(col_name)
+    add!(col_name, value: Zaxcel::Cell::EMPTY_VALUE)
+  end
+
+  sig { params(cell_value_hash: T::Hash[Symbol, Zaxcel::Cell::ValueType]).returns(Zaxcel::Row) }
+  def add_many!(cell_value_hash)
+    cell_value_hash.each do |col_name, value|
+      add!(col_name.to_sym, value: value)
+    end
+
+    self
+  end
+
+  sig { params(column_name: T.any(Symbol, String)).returns(T.nilable(Zaxcel::Cell)) }
+  def cell(column_name)
+    cell_by_column_name[column_name.to_sym]
+  end
+
+  sig { params(row_position: Integer).void }
+  def position!(row_position)
+    @position = T.let(row_position, T.nilable(Integer))
+  end
+
+  sig { returns(T::Hash[Symbol, Zaxcel::Cell]) }
+  def cell_by_column_name
+    @cell_by_column_name ||= T.let({}, T.nilable(T::Hash[Symbol, Zaxcel::Cell]))
+  end
+
+  sig { returns(String) }
+  def to_excel
+    raise 'Must position cells before calling to_excel' if @position.nil?
+
+    @position.to_s
+  end
+
+  sig { void }
+  def set_print_boundary!
+    raise 'Print boundary row already exists' if @sheet.print_boundary_row.present?
+
+    @print_boundary = true
+  end
+
+  sig { returns(T::Boolean) }
+  def print_boundary?
+    @print_boundary
+  end
+
+  sig { returns(T::Boolean) }
+  def hidden?
+    @hidden
+  end
+end