extract 0.1.1

data/lib/extract/formula.treetop

@@ -0,0 +1,66 @@
+grammar Formula
+  include MathMy
+
+  rule top
+    "=" meat:(cond  / range / math_exp_full / formula / cell / num)
+  end
+
+  rule primary
+    num / cell / formula
+  end
+
+ 
+
+  rule cell
+    "-"? "$"? c:[A-Z] "$"? r:[0-9]+ <Extract::Tree::Cell>
+  end
+
+  rule range
+    a:cell ":" b:cell <Extract::Tree::Range>
+  end
+
+  rule cell_or_range
+    range / cell
+  end
+
+  rule num
+    "-"? [0-9]+ ("." [0-9]+)? <Extract::Tree::Num>
+  end
+
+
+  rule formula
+    formula_name "(" formula_args ")" <Extract::Tree::Formula>
+  end 
+
+  rule formula_name
+    "THING" / "DOUBLE" / "SUM" / "IF" / "MAX" / "VLOOKUP" / "SQRT" / "COMBIN"
+  end
+
+  rule formula_arg
+    cond / math_exp_full / formula / range / cell / num / string
+  end
+
+  rule formula_args
+    formula_arg rest:("," fa:formula_arg)* <Extract::Tree::FormulaArgs>
+  end
+
+  rule cond_exp
+    a:(num / cell / string / formula / math_exp_full) op:(">=" / "<=" / "=" / ">" / "<") b:(num / cell / string / formula / math_exp_full) <Extract::Tree::CondExp>
+  end
+
+  rule string
+    "\"" [^"]+ "\"" <Extract::Tree::String>
+  end 
+
+  rule cond_const
+    ("TRUE" / "FALSE") {
+      def excel_value
+        (text_value == "TRUE") ? true : false
+      end
+    }
+  end
+
+  rule cond
+    cond_exp / cond_const
+  end
+end

data/lib/extract/math.treetop

@@ -0,0 +1,33 @@
+grammar MathMy
+  rule math_exp_full
+    (paren_exp / primary) rest:(op math_exp)+ <Extract::Tree::Math>
+  end
+
+  rule naked_exp
+    primary rest:(op math_exp)* <Extract::Tree::Math>
+  end
+
+  rule paren_exp
+    "(" math_exp ")" <Extract::Tree::ParenMath> 
+  end
+
+  rule math_exp 
+    (paren_exp / naked_exp) rest:(op math_exp)* <Extract::Tree::Math>
+  end
+
+
+
+
+  rule num
+    "-"? [0-9]+ ("." [0-9]+)? <Extract::Tree::Num>
+  end
+
+  rule op
+    ("+" / "-" / "*" / "/" / "^") <Extract::Tree::Operator>
+  end
+
+  rule primary
+    num
+  end
+end
+

data/lib/extract/math_calc.rb

@@ -0,0 +1,111 @@
+
+
+module Extract
+  class MathWrapper
+    include FromHash
+    attr_accessor :str
+
+    def left_associative?
+      true
+    end
+    def operator?
+      %w(+ - / * ^).include?(str)
+    end
+    def precedence
+      h = {"*" => 10, "/" => 10, "+" => 5, "-" => 5, "^" => 15}
+      h[str]
+    end
+    def apply(l,r)
+      #puts "apply call #{l} #{str} #{r}"
+      raise "bad apply, not an operator" unless operator?
+      
+      #raise "bad apply, L #{l} R #{r}" unless l.to_s.present? && r.to_s.present?  
+
+      l.str = "0" if l.respond_to?(:str) && l.str.blank?
+      r.str = "0" if r.respond_to?(:str) && r.str.blank?
+
+      op = str
+      op = "**" if op == "^"
+
+      exp = "#{l.to_s} #{op} #{r.to_s}"
+      return 0 if exp =~ /infinity/i || exp =~ /[a-z]/i
+      #puts "evaling #{exp}"
+        #puts "eval, L #{l.class} #{l.inspect} #{str} R #{r.inspect}"
+      raise exp if exp =~ /[a-z]/i
+      res = eval(exp)
+      #puts "evaled #{exp} to #{res}"
+      res
+    end
+    def to_s
+      str
+    end
+  end
+
+  class MathCalc
+    def shunting_yard(input)
+      [].tap do |rpn|
+
+        # where I store operators before putting them onto final rpn list
+        operator_stack = []
+
+        input.each do |object|
+
+          if object.operator?
+            op1 = object
+
+            # while we have an operator on the temp stack
+            # and that op on the temp stack has a higher precedence than the current op
+            while (op2 = operator_stack.last) && (op1.left_associative? ? op1.precedence <= op2.precedence : op1.precedence < op2.precedence)
+              rpn << operator_stack.pop 
+            end
+            operator_stack << op1
+          else
+            rpn << object
+          end
+        end
+        rpn << operator_stack.pop until operator_stack.empty?
+      end
+    end
+
+    def shunting_yard_old(input)
+      input = input.map { |x| MathWrapper.new(:str => x) }
+      res = shunting_yard_inner(input)
+      res.map { |x| x.str }
+    end
+
+    def rpn(input)
+      results = []
+      input.each do |object|
+        if object.operator?
+          r, l = results.pop, results.pop
+          results << object.apply(l, r)
+        else
+          results << object
+        end
+      end
+      results.first
+    end
+
+    def parse_eval(input)
+      raw_input = input
+      #raise input.map { |x| x.text_value }.inspect
+      input = input.map { |x| MathWrapper.new(:str => (x.respond_to?(:excel_value) ? x.excel_value : x.text_value)) }
+      #input = input.split(" ") if input.kind_of?(String)
+      res = shunting_yard(input)
+      #puts "before rpn #{res.inspect}"
+      begin
+        res = rpn(res)
+      rescue => exp
+        puts raw_input.map { |x| x.text_value }.inspect
+        puts res.inspect
+        raise exp
+      end
+    end
+
+    class << self
+      def method_missing(sym,*args,&b)
+        new.send(sym,*args,&b)
+      end
+    end
+  end
+end

data/lib/extract/parser.rb

@@ -0,0 +1,90 @@
+
+
+#Treetop.load "lib/extract/math"
+#Treetop.load "lib/extract/formula"
+
+{:math => "MathMy", :formula => "Formula"}.each do |f,c|
+  f = File.expand_path(File.dirname(__FILE__)) + "/#{f}"
+  Treetop.load f
+  #Object.send(:remove_const,"#{c}Parser")
+end
+
+{:math => "MathMy", :formula => "Formula"}.each do |f,c|
+  #Treetop.load "lib/extract/#{f}"
+end
+
+
+
+
+class Object
+  attr_accessor :root_sheet
+
+  def find_sheet
+    if root_sheet
+      root_sheet
+    elsif parent
+      parent.find_sheet
+    else
+      raise "can't find sheet"
+    end
+  end
+end
+
+module Extract
+  class Parser
+    include FromHash
+    attr_accessor :str, :sheet
+
+    def result
+      p = FormulaParser.new
+      res = p.parse(str.gsub(" ",""))
+      if !res
+        strs = []
+        strs << p.failure_reason
+        strs << p.failure_line
+        strs << p.failure_column
+        strs << "no result for #{str}"
+        raise strs.join("\n")
+      end
+      res
+    end
+
+    def excel_value
+      res = result
+      raise "can't parse #{str}" unless res
+      res.root_sheet = sheet
+      res.meat.excel_value
+    end
+
+    def deps
+      res = result
+      res.root_sheet = sheet
+      #raise res.meat.inspect unless res.meat.respond_to?(:deps)
+      raise "can't parse #{str}" unless res
+      res.meat.deps.flatten.uniq.map do |c|
+        if c =~ /"/
+          nil
+        else
+          c.gsub("$","")
+        end
+      end.select { |x| x }.sort.uniq
+    end
+  end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

data/lib/extract/persist/sheet.rb

@@ -0,0 +1,26 @@
+module Extract
+  module Persist
+    class Sheet
+      include Mongoid::Document
+
+      field :cells, :type => Hash
+
+      field :input_cells, :type => Array
+      field :output_cells, :type => Array
+
+ 
+
+      def sheet_def
+        sheet = Extract::Sheet.new
+        cells.each do |k,v|
+          sheet.cells[k] = v
+        end
+
+        res = Extract::SheetDefinition.new(:sheet => sheet, :output_cells => output_cells)
+        res
+      end
+
+ 
+    end
+  end
+end

data/lib/extract/sheet.rb

@@ -0,0 +1,85 @@
+module Extract
+  class Sheet
+    include FromHash
+    fattr(:cells) { {} }
+    fattr(:cache) { {} }
+    fattr(:loaded_values) { {} }
+
+    def []=(c,val)
+      self.cells[c] = val
+    end
+    def [](c)
+      res = cells[c]
+      #puts "doing #{c} #{res}"
+      if res.to_s =~ /^=/
+        self.cache[c] ||= Extract::Parser.new(:str => res, :sheet => self).excel_value
+      else
+        res
+      end
+    end
+
+    def clear_cache!
+      self.cache = {}
+    end
+
+    def eval(str)
+      Extract::Parser.new(:str => str, :sheet => self).excel_value
+    end
+
+    def deps(c)
+      res = cells[c]
+      res = if res.to_s =~ /^=/
+        d = Extract::Parser.new(:str => res, :sheet => self).deps
+        d.map do |dep|
+          d2 = deps(dep)
+          if d2.empty?
+            dep
+          else
+            d2
+          end
+        end.flatten
+      else
+        []
+      end
+      res.flatten.uniq.map do |c|
+        if c =~ /"/
+          nil
+        else
+          c.gsub("$","")
+        end
+      end.select { |x| x }.sort.uniq
+    end
+
+    def each_value_comp
+      loaded_values.each do |k,v|
+        yield k,cells[k],self[k],v
+      end
+    end
+
+
+    class << self
+      def load(file)
+        w = Roo::Excelx.new(file)
+        w.default_sheet = w.sheets.first
+
+        sheet = Extract::Sheet.new
+
+        ("A".."Z").each do |col|
+          (1..100).each do |row|
+            val = if w.formula?(row,col)
+              "=" + w.formula(row,col).gsub(" ","")
+            else
+              w.cell(row,col)
+            end
+            loaded = w.cell(row,col)
+            sheet["#{col}#{row}"] = val if val.present?
+            sheet.loaded_values["#{col}#{row}"] = loaded if loaded.present?
+          end
+        end
+
+        sheet
+      end
+    end
+
+  end
+end

data/lib/extract/sheet_comp.rb

@@ -0,0 +1,7 @@
+module Extract
+  class SheetComp
+    include FromHash
+    attr_accessor :filename
+
+  end
+end

data/lib/extract/sheet_definition.rb

@@ -0,0 +1,127 @@
+module Extract
+  class SheetDefinition
+    include FromHash
+    attr_accessor :sheet
+
+    def prev_letter(letter)
+      r = ("A".."Z").to_a
+      raise "bad letter #{letter}" unless r.index(letter)
+      i = r.index(letter) - 1
+      r[i]
+    end
+    def left(c)
+      col = c[0..0]
+      row = c[1..-1]
+      col = prev_letter(col)
+      "#{col}#{row}"
+    end
+    fattr(:cell_names) do
+      res = {}
+      (input_cells + output_cells).each do |c|
+        n = left(c)
+        res[c] = sheet[n]
+      end
+      res
+    end
+    fattr(:output_cells) { [] }
+    def output_cells=(arr)
+      @output_cells = arr.map do |c|
+        if c =~ /:/
+          Extract::Tree::Range.cells_in_range(c)
+        else
+          c
+        end
+      end.flatten
+    end
+
+    fattr(:dep_map) do
+      res = {}
+      output_cells.each do |output_cell|
+        res[output_cell] = sheet.deps(output_cell).flatten.uniq.map do |c|
+          if c =~ /"/
+            nil
+          else
+            c.gsub("$","")
+          end
+        end.select { |x| x }.sort.uniq
+      end
+      res
+    end
+
+    fattr(:input_cells) do
+      output_cells.map do |c|
+        a = dep_map[c] || []
+        a = [c] if a.empty?
+        a
+      end.flatten.uniq.sort
+    end
+
+    def setup_persisted_sheet!(res=nil)
+      res.cells = {}
+      res.input_cells = []
+      res.output_cells = []
+
+      sheet.cells.each do |k,v|
+        res.cells[k] = v
+      end
+
+      input_cells.each do |c|
+        res.input_cells << c
+      end
+
+      output_cells.each do |c|
+        res.output_cells << c
+      end
+
+      res
+    end
+
+    def save!(res=nil)
+      res ||= Persist::Sheet.new
+      setup_persisted_sheet! res
+      res.save!
+      res
+    end
+
+    def [](c)
+      sheet[c]
+    end
+
+    def each_input
+      input_cells.each do |cell|
+        yield cell, cell_names[cell],sheet[cell]
+      end
+    end
+
+    def each_output
+      output_cells.sort.each do |cell|
+        yield cell, cell_names[cell],sheet[cell],dep_map[cell],sheet.cells[cell]
+      end
+    end
+
+    def each_other
+      res = []
+      bad = input_cells + output_cells
+      sheet.cells.each do |k,v|
+        if !bad.include?(k)
+          res << k
+        end
+      end
+
+      res.each do |c|
+        d = sheet.deps(c)
+        yield c,sheet.cells[c],d if sheet.cells[c].present? && d.size > 0
+      end
+
+    end
+
+    class << self
+      def load(file,output)
+        res = new
+        res.sheet = Sheet.load(file)
+        res.output_cells = output
+        res
+      end
+    end
+  end
+end