furud 0.1.0

data/lib/furud/types.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Furud
+  Reference = Data.define(:sheet, :row, :column, :absolute_row, :absolute_column) do
+    def initialize(sheet: nil, row:, column:, absolute_row: false, absolute_column: false)
+      raise ArgumentError, "row and column must be positive" unless row.to_i.positive? && column.to_i.positive?
+
+      super(sheet: sheet&.to_s, row: Integer(row), column: Integer(column),
+            absolute_row: !!absolute_row, absolute_column: !!absolute_column)
+    end
+  end
+
+  Area = Data.define(:sheet, :top, :left, :bottom, :right) do
+    def initialize(sheet: nil, top:, left:, bottom:, right:)
+      values = [top, left, bottom, right].map { |value| Integer(value) }
+      raise ArgumentError, "area coordinates must be positive" unless values.all?(&:positive?)
+
+      top, left, bottom, right = values
+      super(sheet: sheet&.to_s, top: [top, bottom].min, left: [left, right].min,
+            bottom: [top, bottom].max, right: [left, right].max)
+    end
+
+    def include?(reference)
+      (sheet.nil? || reference.sheet == sheet) && reference.row.between?(top, bottom) &&
+        reference.column.between?(left, right)
+    end
+  end
+
+  ERROR_CODES = { div0: "#DIV/0!", value: "#VALUE!", ref: "#REF!", name: "#NAME?",
+                  na: "#N/A", num: "#NUM!", cycle: "#CYCLE!", spill: "#SPILL!",
+                  calc: "#CALC!" }.freeze
+  ErrorValue = Data.define(:code) do
+    def initialize(code:)
+      super(code: code.to_sym)
+    end
+
+    def to_s = ERROR_CODES.fetch(code, "#VALUE!")
+  end
+
+  Node = Data.define(:type, :value, :children) do
+    def initialize(type:, value: nil, children: [])
+      super(type: type.to_sym, value: value, children: children.freeze)
+    end
+  end
+
+  Adjustment = Data.define(:type, :sheet, :at, :count) do
+    def initialize(type:, sheet: nil, at:, count: 1)
+      type = type.to_sym
+      raise ArgumentError, "type must be insert_rows, delete_rows, insert_columns, or delete_columns" unless
+        %i[insert_rows delete_rows insert_columns delete_columns].include?(type)
+      raise ArgumentError, "at and count must be positive" unless Integer(at).positive? && Integer(count).positive?
+
+      super(type: type, sheet: sheet&.to_s, at: Integer(at), count: Integer(count))
+    end
+  end
+
+  ArrayValue = Data.define(:rows) do
+    def initialize(rows:)
+      rows = rows.map { |row| row.dup.freeze }.freeze
+      raise ArgumentError, "array must not be empty" if rows.empty? || rows.any?(&:empty?)
+      raise ArgumentError, "array rows must have equal length" unless rows.map(&:length).uniq.one?
+
+      super(rows: rows)
+    end
+
+    def height = rows.length
+    def width = rows.first.length
+    def [](row, column) = rows[row][column]
+  end
+end

data/lib/furud/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Furud
+  VERSION = "0.1.0"
+end

data/lib/furud.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "furud/version"
+require_relative "furud/types"
+require_relative "furud/formula"
+require_relative "furud/functions"
+require_relative "furud/format"
+require_relative "furud/engine"
+
+module Furud
+  module Source; end
+
+  class Error < StandardError; end
+  class ParseError < Error; end
+end

data/sig/furud.rbs

@@ -0,0 +1,128 @@
+module Furud
+  VERSION: String
+  ERROR_CODES: Hash[Symbol, String]
+
+  class Error < StandardError
+  end
+
+  class ParseError < Error
+  end
+
+  class Reference
+    attr_reader sheet: String?
+    attr_reader row: Integer
+    attr_reader column: Integer
+    attr_reader absolute_row: bool
+    attr_reader absolute_column: bool
+    def initialize: (?sheet: String?, row: Integer, column: Integer, ?absolute_row: bool, ?absolute_column: bool) -> void
+    def with: (**untyped) -> Reference
+  end
+
+  class Area
+    attr_reader sheet: String?
+    attr_reader top: Integer
+    attr_reader left: Integer
+    attr_reader bottom: Integer
+    attr_reader right: Integer
+    def initialize: (?sheet: String?, top: Integer, left: Integer, bottom: Integer, right: Integer) -> void
+    def include?: (Reference) -> bool
+  end
+
+  class ErrorValue
+    attr_reader code: Symbol
+    def initialize: (code: Symbol) -> void
+    def to_s: () -> String
+  end
+
+  class Node
+    attr_reader type: Symbol
+    attr_reader value: untyped
+    attr_reader children: Array[Node]
+    def initialize: (type: Symbol, ?value: untyped, ?children: Array[Node]) -> void
+  end
+
+  class Adjustment
+    attr_reader type: Symbol
+    attr_reader sheet: String?
+    attr_reader at: Integer
+    attr_reader count: Integer
+    def initialize: (type: Symbol, ?sheet: String?, at: Integer, ?count: Integer) -> void
+  end
+
+  class ArrayValue
+    attr_reader rows: Array[Array[untyped]]
+    def initialize: (rows: Array[Array[untyped]]) -> void
+    def height: () -> Integer
+    def width: () -> Integer
+    def []: (Integer row, Integer column) -> untyped
+  end
+
+  module Formula
+    def self.parse: (String source, ?origin: Reference | Hash[Symbol, untyped]?) -> Node
+    def self.render: (Node ast, ?origin: Reference | Hash[Symbol, untyped]?) -> String
+    def self.references: (Node ast) -> Array[Reference | Area]
+    def self.translate: (Node ast, from: Reference | Hash[Symbol, untyped], to: Reference | Hash[Symbol, untyped]) -> Node
+    def self.adjust: (Node ast, (Adjustment | Hash[Symbol, untyped]) operation) -> Node
+  end
+
+  module Source
+    def value_at: (Reference) -> untyped
+  end
+
+  class Engine
+    attr_reader source: untyped
+    attr_reader locale: Symbol
+    def initialize: (?untyped source, ?functions: Functions::Registry, ?locale: Symbol, ?iterative: bool, ?max_iterations: Integer, ?epsilon: Numeric) -> void
+    def set: (Reference, untyped input) -> untyped
+    def clear: (Reference) -> nil
+    def value: (Reference) -> untyped
+    def formula: (Reference) -> String?
+    def recalculate: () -> Array[Reference]
+    def dirty: () -> Set[Reference]
+    def cycles: () -> Array[Array[Reference]]
+    def insert_rows: (String? sheet, Integer at, ?Integer count) -> self
+    def delete_rows: (String? sheet, Integer at, ?Integer count) -> self
+    def insert_columns: (String? sheet, Integer at, ?Integer count) -> self
+    def delete_columns: (String? sheet, Integer at, ?Integer count) -> self
+    def define_name: (String name, (Reference | Area) area) -> (Reference | Area)
+    def precedents: (Reference) -> Array[Reference | Area]
+    def dependents: (Reference) -> Array[Reference]
+  end
+
+  module Functions
+    class Entry
+      attr_reader name: String
+      attr_reader arity: untyped
+      attr_reader volatile: bool
+      def call: (*untyped) -> untyped
+      def accepts?: (Integer) -> bool
+    end
+
+    class Registry
+      include Enumerable[Entry]
+      def register: (String name, arity: Integer | Range[Integer] | Array[Integer], ?volatile: bool) { (*untyped) -> untyped } -> self
+      def []: (String name) -> Entry?
+      def names: () -> Array[String]
+      def each: () { (Entry) -> void } -> self
+      def size: () -> Integer
+      def call: (String name, *untyped args) -> untyped
+    end
+
+    def self.standard: () -> Registry
+  end
+
+  module Format
+    class Section
+      attr_reader pattern: String
+      attr_reader condition: [String, Numeric]?
+      attr_reader color: Symbol?
+    end
+    class Spec
+      attr_reader sections: Array[Section]
+      attr_reader locale: Symbol
+    end
+    def self.parse: (String pattern, ?locale: Symbol) -> Spec
+    def self.apply: (untyped value, Spec spec) -> [String, Hash[Symbol, untyped]]
+    def self.infer: (String text, locale: Symbol) -> [untyped, String]
+  end
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: furud
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Parses spreadsheet formulas, evaluates 192 standard functions, tracks
+  dependencies, recalculates incrementally, and formats values.
+email:
+- t.yudai92@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/furud.rb
+- lib/furud/engine.rb
+- lib/furud/format.rb
+- lib/furud/formula.rb
+- lib/furud/functions.rb
+- lib/furud/types.rb
+- lib/furud/version.rb
+- sig/furud.rbs
+homepage: https://github.com/noxdea/furud
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/noxdea/furud
+  source_code_uri: https://github.com/noxdea/furud/tree/main
+  changelog_uri: https://github.com/noxdea/furud/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Dependency-free spreadsheet formula and recalculation engine
+test_files: []