extract 0.1.1

data/lib/extract/tree/base.rb

@@ -0,0 +1,7 @@
+module Extract
+  module Tree
+    module Base
+
+    end
+  end
+end

data/lib/extract/tree/cell.rb

@@ -0,0 +1,33 @@
+module Extract
+  module Tree
+    module Cell
+      def proper_cell
+        text_value.gsub("-","").gsub("$","")
+      end
+      def leading_neg?
+        text_value[0..0] == '-'
+      end
+      def excel_value
+        res = find_sheet[proper_cell]
+        #raise proper_cell if text_value == "-A2"
+        if res.present?
+          leading_neg? ? res * -1 : res
+        else
+          res
+        end
+      end
+      def row
+        r.text_value.to_i
+      end
+      def col
+        c.text_value
+      end
+      def deps
+        [proper_cell]
+      end
+      def tt
+        :cell
+      end
+    end
+  end
+end

data/lib/extract/tree/cond_exp.rb

@@ -0,0 +1,25 @@
+module Extract
+  module Tree
+    module CondExp
+      def excel_value
+        if op.text_value == "="
+          a.excel_value == b.excel_value
+        elsif op.text_value == ">"
+          a.excel_value > b.excel_value
+        elsif op.text_value == "<"
+          a.excel_value < b.excel_value
+        elsif op.text_value == ">="
+          a.excel_value >= b.excel_value
+        elsif op.text_value == "<="
+          a.excel_value <= b.excel_value
+        else
+          raise "bad"
+        end
+      end
+
+      def deps
+        [a.text_value,b.text_value].uniq
+      end
+    end
+  end
+end

data/lib/extract/tree/formula.rb

@@ -0,0 +1,24 @@
+module Extract
+  module Tree
+    module Formula
+      def excel_value
+        args = formula_args.excel_values
+        ExcelFormulas.send(formula_name.text_value.downcase,*args)
+      end
+      def deps
+        #raise "foo"
+        formula_args.deps.flatten.map do |f|
+          if f =~ /^-/
+            raise 'foo'
+            f[1..-1]
+          else
+            f
+          end
+        end.uniq
+      end
+      def tt
+        :formula
+      end
+    end
+  end
+end

data/lib/extract/tree/formula_args.rb

@@ -0,0 +1,30 @@
+module Extract
+  module Tree
+    module FormulaArgs
+      def excel_values
+        res = []
+        res << formula_arg.excel_value
+
+        rest.elements.each do |e|
+          arg = e.elements[1]
+          res << arg.excel_value
+        end
+
+        res
+      end
+
+      def deps
+        res = []
+        res << formula_arg.deps
+
+        rest.elements.each do |e|
+          arg = e.elements[1]
+          raise "no deps for arg #{arg.inspect}" unless arg.respond_to?(:deps)
+          res << arg.deps
+        end
+
+        res.flatten
+      end
+    end
+  end
+end

data/lib/extract/tree/math.rb

@@ -0,0 +1,106 @@
+module Extract
+  module Tree
+    module Math
+      def get_math_exp
+        if respond_to?(:math_exp)
+          math_exp
+        elsif respond_to?(:math_exp_full)
+          math_exp_full
+        elsif respond_to?(:num)
+          num
+        elsif respond_to?(:primary)
+          primary
+        else
+          nil
+        end
+      end
+      def excel_value
+        return eval
+        raise 'foo'
+        unless get_math_exp
+          str = %w(math_exp naked_exp cell).map { |x| "#{x} #{respond_to?(x)}" }.join(", ")
+          #raise str + "\n" + inspect
+          #raise (methods - 7.methods).inspect + "\n" + inspect
+        end
+
+
+        res = 0
+        #res = math_exp.excel_value if respond_to?(:math_exp)
+
+        rest.elements.each do |e|
+          #arg = e.elements[1]
+          #res += arg.excel_value
+          #res += 
+        end
+
+        res
+      end
+
+      def deps(start=self)
+        res = []
+        #res << get_math_exp.deps
+
+        return [] unless start.elements
+
+        start.elements.each do |e|
+          #arg = e.elements[1]
+          if e.respond_to?(:deps)
+            res << e.deps 
+          else
+            res << deps(e)
+          end
+        end
+
+        res.flatten.select { |x| x }
+
+      end
+
+      def tokens(start=self)
+        if start.respond_to?("paren?")
+          res = start.math_exp.eval
+          return [OpenStruct.new(:text_value => res.to_s)]
+          #return [start.exp.eval]
+        end
+        #puts "parsing #{start.text_value} #{start.class}"
+        res = []
+
+        return res unless start.elements
+        start.elements.each do |el|
+          if el.respond_to?(:tt)
+            t = el.tt
+            if t == :num
+              res << el
+            elsif t == :operator
+              res << el
+            elsif t == :cell
+              res << el
+            elsif t == :formula
+              res << el
+            elsif t == :math
+              res += el.tokens
+            else
+              raise "unknown"
+            end
+          else
+            res += tokens(el)
+          end
+        end
+        res
+      end
+
+      def eval
+        #puts "evaling #{text_value}"
+        #raise tokens.map { |x| x.text_value }.inspect + "\n" + inspect
+        MathCalc.parse_eval(tokens)
+      end
+    end
+
+    module ParenMath
+      include Math
+
+      def paren?
+        true
+      end
+    end
+  end
+end

data/lib/extract/tree/num.rb

@@ -0,0 +1,18 @@
+module Extract
+  module Tree
+    module Num
+      def excel_value
+        text_value.to_f
+      end
+      def deps
+        []
+      end
+      def eval
+        excel_value
+      end
+      def tt
+        :num
+      end
+    end
+  end
+end

data/lib/extract/tree/operator.rb

@@ -0,0 +1,9 @@
+module Extract
+  module Tree
+    module Operator
+      def tt
+        :operator
+      end
+    end
+  end
+end

data/lib/extract/tree/range.rb

@@ -0,0 +1,58 @@
+module Extract
+  module Tree
+    module Range
+
+      class << self
+        def cells_in_range_nodes(a,b)
+          res = []
+          ((a.row)..(b.row)).each do |r|
+            tmp = []
+            ((a.col)..(b.col)).each do |c|
+              tmp << "#{c}#{r}"
+            end
+            res << tmp
+          end
+          res
+        end
+
+        def cells_in_range(str)
+          arr = str.split(":").tap { |x| raise "bad" unless x.size == 2 }.map do |c|
+            raise "bad" unless c =~ /^([A-Z])([0-9]+)$/
+            OpenStruct.new(:row => $2, :col => $1)
+          end
+          cells_in_range_nodes(*arr)
+        end
+      end
+
+      def excel_value_old
+        res = []
+        ((a.row)..(b.row)).each do |r|
+          tmp = []
+          ((a.col)..(b.col)).each do |c|
+            tmp << find_sheet["#{c}#{r}"]
+          end
+          res << tmp
+        end
+        res
+      end
+
+      def excel_value
+        Extract::Tree::Range.cells_in_range_nodes(a,b).map do |arr|
+          arr.map do |c|
+            find_sheet[c]
+          end
+        end
+      end
+      def deps
+        res = []
+        ((a.row)..(b.row)).each do |r|
+          tmp = []
+          ((a.col)..(b.col)).each do |c|
+            res << "#{c}#{r}"
+          end
+        end
+        res.flatten.select { |x| x }
+      end
+    end
+  end
+end

data/lib/extract/tree/string.rb

@@ -0,0 +1,12 @@
+module Extract
+  module Tree
+    module String
+      def excel_value
+        text_value[1..-2]
+      end
+      def deps
+        []
+      end
+    end
+  end
+end

data/spec/config/mongoid.yml

@@ -0,0 +1,6 @@
+development:
+  sessions:
+    default:
+      database: mongoid_dev
+      hosts:
+        - localhost:27017

data/spec/deps_spec.rb

@@ -0,0 +1,48 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+def should_have_deps(cell,*deps)
+  it "#{cell} should have deps #{deps.inspect}" do
+    if cell =~ /^=/
+      sheet["X99"] = cell
+      sheet.deps("X99").uniq.sort.should == deps.flatten.select { |x| x }.sort
+    else
+      sheet.deps(cell).should == deps.flatten.select { |x| x }
+    end
+  end
+end
+
+describe "Deps" do
+  let(:sheet) do
+    res = Extract::Sheet.new
+    {"A1" => 1, "A2" => 2, "A3" => 3, "B1" => 4, "B2" => 5, "B3" => 6}.each do |k,v|
+      res[k] = v
+    end
+    res["C1"] = "=A1"
+    res['D1'] = "=C1"
+    res['E1'] = "=D1"
+
+    res['F1'] = "=A1+A2"
+    res
+  end
+  it 'smoke' do
+    sheet['C1'].should == 1
+  end
+
+  should_have_deps "C1","A1"
+  should_have_deps "14",[]
+  should_have_deps "D1","A1"
+  should_have_deps "E1","A1"
+
+  should_have_deps "F1","A1","A2"
+
+  should_have_deps "=A1+4","A1"
+
+  should_have_deps "=A1 = A2","A1","A2"
+
+  should_have_deps "=DOUBLE(A1)","A1"
+  should_have_deps "=SUM(A1,A2)","A1","A2"
+  should_have_deps "=SUM(A1:B2)","A1","A2","B1","B2"
+  should_have_deps "=SUM(A1,C1)","A1"
+
+  should_have_deps "=SUM(2+3+A1,A2)","A1","A2"
+end

data/spec/extract_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+if false
+describe "Extract" do
+  it 'smoke' do
+    2.should == 2
+  end
+
+  it 'cash flow' do
+    sheet = Extract::Sheet.load("/users/mharris717/documents/cashflow.xlsx")
+
+    #sheet["A1"] = 999
+    sheet["B42"].to_i.should == 14888
+  end
+
+  if true
+    it 'dev' do
+    sheet = Extract::Sheet.load("/users/mharris717/code/orig/extract/samples/div.xlsx")
+
+    #sheet["A1"] = 999
+    sheet["B52"].to_i.should == 10
+    %w(B38 B41 B51 B52).each do |c|
+      sheet[c]
+    end
+  end
+end
+  
+end
+
+
+describe 'Dev Sheet' do
+  let(:sheet_def) do
+    Extract::SheetDefinition.load("/users/mharris717/code/orig/extract/samples/div.xlsx",output_cells)
+  end
+  let(:output_cells) do
+    %w(B38 B41 B51 B52)
+  end
+  it 'input cells' do
+    exp = ["B30", "B29", "B30", "B31", "B46", "B47", "C35", "D35", "E35", "F35", "G35", "H35", "I35", "J35", "K35", "L35", "M35"].sort.uniq
+    sheet_def.input_cells.sort.should == exp
+  end
+
+
+end
+end