spreadshit 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8458cafa69246fc6038f2ac8a6823569e39de820
+  data.tar.gz: 2982c754d56740b6234255cf2c90c50b141f78cd
+SHA512:
+  metadata.gz: 0cc85771b717af20087bc7ee1a64da872a26143f6e40d2682acf8afe093eb850193e2737ab2676f5ff1a657b9c3f2523592028583d0516a5c30c2497aab575a7
+  data.tar.gz: 497cb849983596238a0a49b742517c126ddc4473abe2a730ba4540a03a1faee053a0eb74be2fedb0cdc05a538d875424e32fb84c7e9f8db58fac5919c2ab2a0b

data/.gitignore

@@ -0,0 +1 @@
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "pry"

data/README.md

@@ -0,0 +1,25 @@
+# Spreadsheet
+
+Esse projeto é um exercício sugerido pelo [Casssiano](https://github.com/cassiano), que consiste na implementação em uma planilha de cálculos.
+
+Por ora, o projeto está em fase alpha, e não trata quase nenhum caso de excessão.
+
+[![Obligatory gif](https://asciinema.org/a/4677dtu9ippkmzgttr85vnj22.png)](https://asciinema.org/a/4677dtu9ippkmzgttr85vnj22)
+
+## Implementação
+
+Foram utilizados vários conceitos descritos no paper [Deprecating the Observer Pattern](http://infoscience.epfl.ch/record/148043/files/DeprecatingObserversTR2010.pdf) para implementação, já que cada célula representa um `Signal` descrito no paper.
+
+Para o parsing das fórmulas da planilha, foi desenvolvido um simples parser com o [Treetop](http://treetop.rubyforge.org/).
+
+A UI (ainda bastante simplista) foi produzida com a ajuda da biblioteca [Curses](https://en.wikipedia.org/wiki/Curses_(programming_library)).
+
+## Demo
+
+Para rodar o demo, primeiro instale as dependências com:
+
+    $ bundle install
+
+E depois execute
+
+    $ ./demo.rb

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/console

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "spreadshit"
+require "pry"
+
+@sheet = Spreadshit.new
+@sheet[:A1] = 10
+@sheet[:A2] = "0"
+@sheet[:A3] = "=A1 + A2"
+
+@sheet[:B1] = 0
+@sheet[:B2] = 1
+3.upto(300).each do |n|
+  @sheet["B#{n}"] = "=B#{n - 1} + B#{n - 2}"
+end
+
+Pry.start

data/bin/demo

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "spreadshit"
+require "spreadshit/window"
+
+sheet = Spreadshit.new
+[
+  "Sum",
+  10,
+  20,
+  30,
+  "",
+  "=A2 + A3 + A4",
+  "=SUM(A2; A3; A4)",
+  "=SUM(A2:A4)"
+].each_with_index do |cel, index|
+  sheet["A#{index + 1}"] = cel
+end
+
+# Fibonacci
+sheet[:B1] = "Fibonacci"
+sheet[:B2] = 0
+sheet[:B3] = 1
+4.upto(30).each do |n|
+  sheet["B#{n}"] = "=B#{n - 1} + B#{n - 2}"
+end
+
+window = Spreadshit::Window.new do |delegate|
+  delegate.cell_updated { |address, value| sheet[address] = value }
+  delegate.cell_value { |address| sheet[address] }
+  delegate.cell_content { |address| sheet.cell_at(address).raw }
+end
+window.start

data/bin/setup

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install

data/lib/spreadshit.rb

@@ -0,0 +1,112 @@
+class Spreadshit
+  require "spreadshit/formula"
+  require "spreadshit/functions"
+
+  def initialize(parser = Formula.new, functions = Functions.new)
+    @cells = Hash.new { |hash, key| hash[key] = Cell.new }
+    @parser = parser
+    @functions = functions
+  end
+
+  def [](address)
+    @cells[address.to_sym].value
+  end
+
+  def []=(address, value)
+    @cells[address.to_sym].update(value) { parse(value) }
+  end
+
+  def cell_at(address)
+    @cells[address.to_sym]
+  end
+
+  private
+
+  def parse(value)
+    if value.to_s.start_with? "="
+      eval @parser.parse(value[1..-1])
+    else
+      value
+    end
+  end
+
+  def eval(expression, refs = Set.new)
+    case expression
+    when Formula::Literal
+      expression.content
+    when Formula::Addition
+      @functions.add(eval(expression.left, refs), eval(expression.right, refs))
+    when Formula::Subtraction
+      @functions.minus(eval(expression.left, refs), eval(expression.right, refs))
+    when Formula::Multiplication
+      @functions.multiply(eval(expression.left, refs), eval(expression.right, refs))
+    when Formula::Division
+      @functions.divide(eval(expression.left, refs), eval(expression.right, refs))
+    when Formula::Function
+      @functions.send(expression.name.downcase, *expression.arguments.map { |arg| eval arg, refs })
+    when Formula::Reference
+      if refs.include? expression.address
+        "CYCLIC"
+      else
+        refs << expression.address
+        self[expression.address]
+      end
+    when Formula::Range
+      expand_range(expression.top, expression.bottom).map { |ref| eval ref, refs }
+    end
+  end
+
+  def expand_range(top, bottom)
+    cols = top.col..bottom.col
+    rows = top.row..bottom.row
+    cols.flat_map do |col|
+      rows.map { |row| Formula::Reference.new(col, row) }
+    end
+  end
+end
+
+class Cell
+  attr_reader :raw
+
+  def initialize(raw = "", &expression)
+    @raw = raw
+    @observers = Set.new
+    @observed = []
+    update(&expression) if block_given?
+  end
+
+  def value
+    if @@caller
+      @observers << @@caller
+      @@caller.observed << self
+    end
+    @value
+  end
+
+  def update(value = raw || "", &expression)
+    @raw = value
+    @expression = expression
+    compute
+    @value
+  end
+
+  protected
+
+  attr_reader :observers, :observed
+
+  def compute
+    @observed.each { |observed| observed.observers.delete(self) }
+    @observed = []
+
+    @@caller = self
+    new_value = @expression.call
+    @@caller = nil
+
+    if new_value != @value
+      @value = new_value
+      observers = @observers
+      @observers = Set.new
+      observers.each { |observer| observer.compute }
+    end
+  end
+end

data/lib/spreadshit/formula.rb

@@ -0,0 +1,113 @@
+require "treetop"
+
+class Spreadshit::Formula
+  module Nodes
+    class Node < Treetop::Runtime::SyntaxNode; end
+    class NumberNode < Node; end
+    class StringNode < Node; end
+    class GroupNode < Node; end
+    class FunctionNode < Node; end
+    class ArgumentListNode < Node; end
+    class AdditiveNode < Node; end
+    class MultiplicativeNode < Node; end
+    class RangeNode < Node; end
+    class ReferenceNode < Node; end
+  end
+
+  class Literal < Struct.new(:content); end
+  class String < Literal; end
+  class Number < Literal; end
+  class Integer < Number; end
+  class Decimal < Number; end
+
+  class BinaryOperation < Struct.new(:left, :right); end
+  class Addition < BinaryOperation; end
+  class Subtraction < BinaryOperation; end
+  class Multiplication < BinaryOperation; end
+  class Division < BinaryOperation; end
+  class Function < Struct.new(:name, :arguments); end
+
+  class Reference < Struct.new(:col, :row)
+    def address
+      [col, row].join
+    end
+
+    def to_s
+      address
+    end
+  end
+
+  class Range < Struct.new(:top, :bottom)
+    def to_s
+      [top.address, bottom.address].join(":")
+    end
+  end
+
+  @@parser = Treetop.load(File.join(File.dirname(__FILE__), "formula.treetop")).new
+
+  def parse(formula)
+    process @@parser.parse(formula)
+  end
+
+  private
+
+  def process(node)
+    case node
+    when Nodes::NumberNode
+      node.text_value.include?(".") ?
+        Decimal.new(node.text_value.to_f) :
+        Integer.new(node.text_value.to_i)
+
+    when Nodes::StringNode
+      String.new(node.chars.text_value)
+
+    when Nodes::GroupNode
+      process node.content
+
+    when Nodes::FunctionNode
+      Function.new(
+        node.name.text_value.upcase,
+        process(node.arguments) || []
+      )
+
+    when Nodes::ArgumentListNode
+      if node.tail.elements.empty?
+        [process(node.head)]
+      else
+        [process(node.head)] + process(node.tail.elements[0].arguments)
+      end
+
+    when Nodes::RangeNode
+      Range.new(process(node.top), process(node.bottom))
+
+    when Nodes::ReferenceNode
+      Reference.new(node.col.text_value.upcase, node.row.text_value.to_i)
+
+    when Nodes::AdditiveNode
+      if node.tail.elements.empty?
+        process node.head
+      else
+        node.tail.elements.reduce(process(node.head)) do |left, node|
+          right = process(node.operand)
+          case node.operator.text_value
+            when "+" then Addition.new(left, right)
+            when "-" then Subtraction.new(left, right)
+          end
+        end
+      end
+
+    when Nodes::MultiplicativeNode
+      if node.tail.elements.empty?
+        process node.head
+      else
+        node.tail.elements.reduce(process(node.head)) do |left, node|
+          right = process(node.operand)
+          case node.operator.text_value
+            when "*" then Multiplication.new(left, right)
+            when "/" then Division.new(left, right)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spreadshit/formula.treetop

@@ -0,0 +1,61 @@
+grammar FormulaGrammar
+  rule additive
+    head:multiplicative tail:(space* operator:[+-] space* operand:multiplicative)* <Spreadshit::Formula::Nodes::AdditiveNode>
+  end
+
+  rule multiplicative
+    head:operand tail:(space* operator:[*/] space* operand:operand)* <Spreadshit::Formula::Nodes::MultiplicativeNode>
+  end
+
+  rule operand
+    reference / signed_number / string / group / function
+  end
+
+  rule group
+    '(' space* content:additive space* ')' <Spreadshit::Formula::Nodes::GroupNode>
+  end
+
+  rule function
+    name:[a-zA-Z]+ '(' space* arguments:arguments_list? space* ')' <Spreadshit::Formula::Nodes::FunctionNode>
+  end
+
+  rule arguments_list
+    head:argument tail:(space* ';' space* arguments:arguments_list)* <Spreadshit::Formula::Nodes::ArgumentListNode>
+  end
+
+  rule argument
+    range / additive / operand
+  end
+
+  rule range
+    top:reference ':' bottom:reference <Spreadshit::Formula::Nodes::RangeNode>
+  end
+
+  rule reference
+    col:[a-zA-Z]+ row:([1-9] [0-9]+ / [1-9]) <Spreadshit::Formula::Nodes::ReferenceNode>
+  end
+
+  rule signed_number
+    sign? number <Spreadshit::Formula::Nodes::NumberNode>
+  end
+
+  rule number
+    ([0-9]+ '.')? [0-9]+
+  end
+
+  rule sign
+    [+-]
+  end
+
+  rule string
+    quote chars:(!quote .)* quote <Spreadshit::Formula::Nodes::StringNode>
+  end
+
+  rule quote
+    '"'
+  end
+
+  rule space
+    ' '
+  end
+end

data/lib/spreadshit/functions.rb

@@ -0,0 +1,68 @@
+class Spreadshit::Functions
+  [[:+, :add], [:-, :minus], [:*, :multiply]].each do |operator, name|
+    define_method(name) { |left, right| to_number(left).send(operator, to_number(right)) }
+  end
+
+  def divide(left, right)
+    right = to_number(right)
+    return Float::NAN if right.zero?
+    to_number(to_number(left) / right.to_f)
+  end
+
+  def sum(*args)
+    to_number args.flatten.map { |arg| to_number(arg) }.reduce(:+)
+  end
+
+  def average(*args)
+    to_number(sum(*args) / args.size.to_f)
+  end
+
+  def sqrt(number)
+    Math.sqrt to_number(number)
+  end
+
+  def ln(number)
+    Math.log to_number(number)
+  end
+
+  def var(*args)
+    average = average(*args)
+
+    args.flatten.map { |arg| to_number(arg) }.reduce(0) do |variance, value|
+      variance + (value - average) ** 2
+    end
+  end
+
+  def stdev(*args)
+    sqrt(var(*args))
+  end
+
+  def date(year, month, date)
+    Date.new(year, month, date)
+  end
+
+  private
+
+  def to_number(value)
+    case value
+    when Float::INFINITY
+      value
+    when nil
+      0
+    when Numeric
+      if !value.to_f.nan? && value.to_f - value.to_i == 0
+        value.to_i
+      else
+        value.to_f
+      end
+    when Date
+      value
+    when -> string { string.to_s =~ /\A[-+]?([0-9]+\.)?[0-9]+\z/ }
+      to_number(value.to_f)
+    when String && -> string { string.strip.empty? }
+      0
+    else
+      Float::NAN
+    end
+  end
+end

data/lib/spreadshit/version.rb

@@ -0,0 +1,3 @@
+class Spreadshit
+  VERSION = "0.1.0"
+end

data/lib/spreadshit/window.rb

@@ -0,0 +1,263 @@
+require "curses"
+
+class Spreadshit::Window
+  class Address < Struct.new(:col, :row)
+    def to_s
+      [col, row].join
+    end
+
+    def to_sym
+      to_s.to_sym
+    end
+  end
+
+  class SpreadsheetDelegate
+    def initialize
+      @cell_updated, @cell_value, @cell_content = Proc.new {}
+    end
+
+    def cell_updated(&block)
+      if block_given?
+        @cell_updated = block
+      else
+        @cell_updated
+      end
+    end
+
+    def cell_value(&block)
+      if block_given?
+        @cell_value = block
+      else
+        @cell_value
+      end
+    end
+
+    def cell_content(&block)
+      if block_given?
+        @cell_content = block
+      else
+        @cell_content
+      end
+    end
+  end
+
+  include Curses
+
+  def initialize
+    @mode = :navigation
+    @x, @y = 0, 0
+    @sx, @sy = 0, 0
+    @col_width = 13
+    @letters = ("A".."ZZZ").to_a
+    @spreadsheet_delegate = SpreadsheetDelegate.new
+    yield @spreadsheet_delegate
+  end
+
+  def start
+    init_screen
+    start_color
+    init_pair(COLOR_WHITE, COLOR_BLACK, COLOR_WHITE)
+    init_pair(COLOR_BLUE, COLOR_BLACK, COLOR_BLUE)
+    init_pair(COLOR_GREEN, COLOR_BLACK, COLOR_GREEN)
+    init_pair(COLOR_RED, COLOR_BLACK, COLOR_MAGENTA)
+    use_default_colors
+    redraw
+
+    loop { capture_input }
+  end
+
+  private
+
+  def max_cols
+    cols / @col_width
+  end
+
+  def max_rows
+    lines - 3
+  end
+
+  def address
+    Address.new(@letters[@x], @y + 1)
+  end
+
+  def current_cell_value
+    cell_value_at(address)
+  end
+
+  def cell_value_at(address)
+    @spreadsheet_delegate.cell_value.call(address)
+  end
+
+  def current_cell_content
+    @spreadsheet_delegate.cell_content.call(address)
+  end
+
+  def current_cell_content=(value)
+    @spreadsheet_delegate.cell_updated.call(address, value)
+  end
+
+  def capture_input
+    case @mode
+    when :navigation
+      navigate
+    when :edit
+      read_cell_definition
+    end
+  end
+
+  def navigate
+    cbreak
+    noecho
+    stdscr.keypad = true
+    case getch
+    when KEY_UP
+      @y -= 1
+      @y = 0 if @y < 0
+      @sy -= 1 if @y < @sy
+      @sy = 0 if @sy < 0
+    when KEY_DOWN
+      @y += 1
+      @sy += 1 if @y >= max_rows
+    when KEY_LEFT
+      @x -= 1
+      @x = 0 if @x < 0
+      @sx -= 1 if @x < @sx
+      @sx = 0 if @sx < 0
+    when KEY_RIGHT
+      @x += 1
+      @sx += 1 if @x >= max_cols
+    when 10
+      @mode = :edit
+    when 27
+      exit 0
+    else
+      return
+    end
+
+    redraw
+  end
+
+  def read_cell_definition
+    echo
+    self.current_cell_content = getstr
+    @mode = :navigation
+    redraw
+  end
+
+  def redraw
+    draw_cells
+    draw_letters_header
+    draw_numbers_header
+    draw_text_field
+    cursor_to_input_line
+    refresh
+  end
+
+  def draw_text_field
+    setpos(divider_line, 0)
+
+    case @mode
+    when :navigation
+      draw_divider(
+        color: color_pair(COLOR_RED) | A_NORMAL,
+        left_text: current_cell_value.to_s,
+        center_text: "Press ENTER to edit #{address}",
+      )
+      cursor_to_input_line
+      addstr(current_cell_content.to_s)
+      clrtoeol
+    when :edit
+      draw_divider(
+        color: color_pair(COLOR_GREEN) | A_NORMAL,
+        left_text: current_cell_content.to_s,
+        center_text: "Editing #{address}"
+      )
+      cursor_to_input_line
+      clrtoeol
+    end
+  end
+
+  def draw_divider(color: color_pair(COLOR_GREEN) | A_NORMAL, left_text: "", right_text: "", center_text: "")
+    attron color do
+      setpos(divider_line, 0)
+      addstr(" " * cols)
+
+      setpos(divider_line, 2)
+      addstr(left_text.ljust(cols / 3))
+
+      setpos(divider_line, cols / 3)
+      addstr(center_text.center(cols / 3))
+
+      setpos(divider_line, cols - right_text.size - 2)
+      addstr(right_text)
+    end
+  end
+
+  def visible_letters
+    (@sx...max_cols + @sx).map { |col| @letters[col] }
+  end
+
+  def selected?(row, col)
+    address.col == col && address.row == (@sy + row)
+  end
+
+  def draw_cells(padding: 4)
+    1.upto(max_rows).each do |row|
+      visible_letters.each.with_index do |col, index|
+        setpos(row, padding + index * @col_width)
+
+        if selected? row, col
+          attron(color_pair(@mode == :edit ? COLOR_GREEN : COLOR_WHITE) | A_TOP) do
+            draw_cell @sy + row, col
+          end
+        else
+          draw_cell @sy + row, col
+        end
+      end
+    end
+  end
+
+  def draw_letters_header(padding: 4, color: COLOR_BLUE)
+    visible_letters.each.with_index do |letter, index|
+      setpos(0, padding + index * @col_width)
+
+      attron(color_pair(color) | A_TOP) do
+        addstr(letter.center(@col_width))
+      end
+    end
+  end
+
+  def draw_numbers_header(padding: 4, color: COLOR_BLUE)
+    1.upto(max_rows).each.with_index do |row, index|
+      setpos(row, 0)
+
+      attron(color_pair(COLOR_BLUE) | A_TOP) do
+        addstr (@sy + row).to_s.rjust(padding)
+      end
+    end
+  end
+
+  def draw_cell(row, col)
+    value = cell_value_at(Address.new(col, row)).to_s
+
+    if value == Float::NAN.to_s
+      addstr("#VALUE!".center(@col_width))
+    elsif value.size >= @col_width
+      addstr(value.chars.last(@col_width).join)
+    else
+      addstr(value.rjust(@col_width))
+    end
+  end
+
+  def input_line
+    lines - 1
+  end
+
+  def divider_line
+    lines - 2
+  end
+
+  def cursor_to_input_line
+    setpos(input_line, 2)
+  end
+end

data/spreadshit.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "spreadshit/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "spreadshit"
+  spec.version       = Spreadshit::VERSION
+  spec.authors       = ["Rodrigo Navarro"]
+  spec.email         = ["rnavarro@rnavarro.com.br"]
+
+  spec.summary       = %q{Simple spreadsheet implementation}
+  spec.description   = %q{Simple spreadsheet implementation}
+  spec.homepage      = "https://github.com/reu/spreadshit"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "treetop", "~> 1.6"
+  spec.add_dependency "curses"
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: spreadshit
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Rodrigo Navarro
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-01-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: treetop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: curses
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Simple spreadsheet implementation
+email:
+- rnavarro@rnavarro.com.br
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/demo
+- bin/setup
+- lib/spreadshit.rb
+- lib/spreadshit/formula.rb
+- lib/spreadshit/formula.treetop
+- lib/spreadshit/functions.rb
+- lib/spreadshit/version.rb
+- lib/spreadshit/window.rb
+- spreadshit.gemspec
+homepage: https://github.com/reu/spreadshit
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Simple spreadsheet implementation
+test_files: []