excel_to_code 0.0.1

data/src/excel/excel_functions/pi.rb

@@ -0,0 +1,7 @@
+module ExcelFunctions
+  
+  def pi
+    Math::PI
+  end
+  
+end

data/src/excel/excel_functions/pmt.rb

@@ -0,0 +1,16 @@
+module ExcelFunctions
+  
+  def pmt(rate,number_of_periods,present_value)
+    rate = number_argument(rate)
+    number_of_periods = number_argument(number_of_periods)
+    present_value = number_argument(present_value)
+    
+    return rate if rate.is_a?(Symbol)
+    return number_of_periods if number_of_periods.is_a?(Symbol)
+    return present_value if present_value.is_a?(Symbol)
+    
+    return -(present_value / number_of_periods) if rate == 0
+    -present_value*(rate*((1+rate)**number_of_periods))/(((1+rate)**number_of_periods)-1)
+  end
+  
+end

data/src/excel/excel_functions/power.rb

@@ -0,0 +1,18 @@
+require_relative 'number_argument'
+require_relative 'apply_to_range'
+
+module ExcelFunctions
+  
+  def power(a,b)
+    # return apply_to_range(a,b) { |a,b| power(a,b) } if a.is_a?(Array) || b.is_a?(Array)
+    
+    a = number_argument(a)
+    b = number_argument(b)
+    
+    return a if a.is_a?(Symbol)
+    return b if b.is_a?(Symbol)
+    
+    a**b
+  end
+  
+end

data/src/excel/excel_functions/round.rb

@@ -0,0 +1,13 @@
+module ExcelFunctions
+  
+  def round(number,decimal_places)
+    number = number_argument(number)
+    decimal_places = number_argument(decimal_places)
+    
+    return number if number.is_a?(Symbol)
+    return decimal_places if decimal_places.is_a?(Symbol)
+    
+    number.round(decimal_places)
+  end
+  
+end

data/src/excel/excel_functions/rounddown.rb

@@ -0,0 +1,14 @@
+module ExcelFunctions
+  
+  def rounddown(number,decimal_places)
+    number = number_argument(number)
+    decimal_places = number_argument(decimal_places)
+    
+    return number if number.is_a?(Symbol)
+    return decimal_places if decimal_places.is_a?(Symbol)
+    
+    (number * 10**decimal_places).truncate.to_f / 10**decimal_places
+  end
+
+  
+end

data/src/excel/excel_functions/roundup.rb

@@ -0,0 +1,17 @@
+module ExcelFunctions
+  
+  def roundup(number,decimal_places)
+    number = number_argument(number)
+    decimal_places = number_argument(decimal_places)
+    
+    return number if number.is_a?(Symbol)
+    return decimal_places if decimal_places.is_a?(Symbol)
+    
+    if number < 0
+      (number * 10**decimal_places).floor.to_f / 10**decimal_places
+    else
+      (number * 10**decimal_places).ceil.to_f / 10**decimal_places
+    end
+  end
+  
+end

data/src/excel/excel_functions/string_join.rb

@@ -0,0 +1,19 @@
+module ExcelFunctions
+  
+  def string_join(*strings)
+    strings.find {|s| s.is_a?(Symbol)} || strings.map do |s| 
+      case s
+      when nil; "0"
+      when Numeric
+        if s.round == s
+          s.to_i.to_s
+        else
+          s.to_s
+        end
+      else
+        s.to_s
+      end
+    end.join('')
+  end
+  
+end

data/src/excel/excel_functions/subtotal.rb

@@ -0,0 +1,13 @@
+module ExcelFunctions
+  
+  def subtotal(type,*args)
+    case number_argument(type)
+    when Symbol; type
+    when 1.0, 101.0; average(*args)
+    when 2.0, 102.0; count(*args)
+    when 3.0, 103.0; counta(*args)
+    when 9.0, 109.0; sum(*args)
+    else :value
+    end
+  end  
+end

data/src/excel/excel_functions/subtract.rb

@@ -0,0 +1,18 @@
+require_relative 'number_argument'
+require_relative 'apply_to_range'
+
+module ExcelFunctions
+  
+  def subtract(a,b)
+    # return apply_to_range(a,b) { |a,b| subtract(a,b) } if a.is_a?(Array) || b.is_a?(Array)
+  
+    a = number_argument(a)
+    b = number_argument(b)
+  
+    return a if a.is_a?(Symbol)
+    return b if b.is_a?(Symbol)
+    
+    a - b
+  end
+  
+end

data/src/excel/excel_functions/sum.rb

@@ -0,0 +1,8 @@
+module ExcelFunctions
+  
+  def sum(*args)
+    args = args.flatten
+    args.find {|a| a.is_a?(Symbol)} || args.delete_if { |a| !a.is_a?(Numeric) }.inject(0) { |m,i| m + i }
+  end
+  
+end

data/src/excel/excel_functions/sumif.rb

@@ -0,0 +1,7 @@
+module ExcelFunctions
+  
+  def sumif(check_range,criteria,sum_range = check_range)
+    sumifs(sum_range,check_range,criteria)
+  end
+  
+end

data/src/excel/excel_functions/sumifs.rb

@@ -0,0 +1,74 @@
+module ExcelFunctions
+  
+  def sumifs(sum_range,*criteria)
+    # First, get rid of the errors
+    return sum_range if sum_range.is_a?(Symbol)
+    error = criteria.find { |a| a.is_a?(Symbol) }
+    return error if error
+    
+    # Sort out the sum range
+    sum_range = [sum_range] unless sum_range.is_a?(Array)
+    sum_range = sum_range.flatten
+    
+    # Sort out the criteria
+    0.step(criteria.length-1,2).each do |i|
+      if criteria[i].is_a?(Array)
+        criteria[i] = criteria[i].flatten
+      else
+        criteria[i] = [criteria[i]]
+      end
+    end
+      
+    # This will be the final answer
+    accumulator = 0
+    
+    # Work through each part of the sum range
+    sum_range.each_with_index do |potential_sum,index|
+      next unless potential_sum.is_a?(Numeric)
+      
+      # If a criteria fails, this is set to false and no further criteria are evaluated
+      pass = true
+      
+      0.step(criteria.length-1,2).each do |i|
+        check_range = criteria[i]
+        required_value = criteria[i+1]
+        return :value if index >= check_range.length
+        check_value = check_range[index]
+        
+        pass = case check_value
+        when String
+          check_value.downcase == required_value.to_s.downcase
+        when true, false
+          check_value == required_value
+        when nil
+          required_value == ""
+        when Numeric
+          case required_value
+          when Numeric
+            check_value == required_value
+          when String
+            required_value =~ /^(<=|>=|<|>)?([-+]?[0-9]+\.?[0-9]*([eE][-+]?[0-9]+)?)$/
+            if $1 && $2
+              check_value.send($1,$2.to_f)
+            elsif $2
+              check_value == $2.to_f
+            else
+              false
+            end
+          else
+            check_value == required_value
+          end
+        end # case check_value
+                
+        break unless pass
+      end # criteria loop
+      
+      accumulator += potential_sum if pass
+        
+      end
+      
+      return accumulator
+      
+    end
+  
+end

data/src/excel/excel_functions/sumproduct.rb

@@ -0,0 +1,32 @@
+module ExcelFunctions
+  
+  def sumproduct(*args)
+    error = args.find { |a| a.is_a?(Symbol) }
+    return error if error
+    return :value if args.any? { |a| a == nil }
+    args = args.map { |a| a.is_a?(Array) ? a : [[a]] }
+    first = args.shift
+    accumulator = 0
+    first.each_with_index do |row,row_number|
+      row.each_with_index do |cell,column_number|
+        next unless cell.is_a?(Numeric)
+        product = cell
+        args.each do |area|
+          return :value unless area.length > row_number
+          r = area[row_number]
+          return :value unless r.length > column_number
+          c = r[column_number]
+          if c.is_a?(Numeric)
+            product = product * c
+          else
+            product = product * 0
+            break
+          end
+        end
+        accumulator += product
+      end
+    end
+    accumulator
+  end
+  
+end

data/src/excel/excel_functions/vlookup.rb

@@ -0,0 +1,49 @@
+module ExcelFunctions
+  
+  def vlookup(lookup_value,lookup_table,column_number, match_type = true)    
+    return lookup_value if lookup_value.is_a?(Symbol)
+    return lookup_table if lookup_table.is_a?(Symbol)
+    return column_number if column_number.is_a?(Symbol)
+    return match_type if match_type.is_a?(Symbol)
+    
+    return :na if lookup_value == nil
+    return :na if lookup_table == nil
+    return :na if column_number == nil
+    return :na if match_type == nil
+  
+    lookup_value = lookup_value.downcase if lookup_value.is_a?(String)
+    
+    last_good_match = 0
+    
+    lookup_table.each_with_index do |row,index|
+      possible_match = row.first
+      
+      next if lookup_value.is_a?(String) && !possible_match.is_a?(String)
+      next if lookup_value.is_a?(Numeric) && !possible_match.is_a?(Numeric)
+      
+      possible_match.downcase! if lookup_value.is_a?(String)
+
+      if lookup_value == possible_match
+        return :value unless column_number <= row.length
+        return row[column_number-1]
+      elsif match_type == true
+        if possible_match > lookup_value
+          return :na if index == 0
+          previous_row = lookup_table[last_good_match]
+          return :value unless column_number <= previous_row.length
+          return previous_row[column_number-1]
+        else
+          last_good_match = index
+        end
+      end      
+    end
+
+    # We don't have a match
+    if match_type == true
+      return lookup_table[last_good_match][column_number-1]
+    else
+      return :na
+    end
+  end
+  
+end

data/src/excel/formula_peg.rb

@@ -0,0 +1,238 @@
+# encoding: utf-8
+require 'rubypeg'
+
+class Formula < RubyPeg
+  
+  def root
+    formula
+  end
+  
+  def formula
+    node :formula do
+      optional { space } && one_or_more { expression }
+    end
+  end
+  
+  def expression
+    string_join || comparison || arithmetic || thing
+  end
+  
+  def thing
+    function || array || brackets || any_reference || string || percentage || number || boolean || prefix || named_reference
+  end
+  
+  def argument
+    expression || null
+  end
+  
+  def function
+    node :function do
+      terminal(/[A-Z]+/) && ignore { terminal("(") } && space && optional { argument } && any_number_of { (space && ignore { terminal(",") } && space && argument) } && space && ignore { terminal(")") }
+    end
+  end
+  
+  def brackets
+    node :brackets do
+      ignore { terminal("(") } && space && one_or_more { expression } && space && ignore { terminal(")") }
+    end
+  end
+  
+  def array
+    node :array do
+      ignore { terminal("{") } && space && row && any_number_of { (space && ignore { terminal(";") } && space && row) } && space && ignore { terminal("}") }
+    end
+  end
+  
+  def row
+    node :row do
+      basic_type && any_number_of { (space && ignore { terminal(",") } && space && basic_type) }
+    end
+  end
+  
+  def basic_type
+    string || percentage || number || boolean
+  end
+  
+  def string_join
+    node :string_join do
+      (arithmetic || thing) && one_or_more { (space && ignore { terminal("&") } && space && (arithmetic || thing)) }
+    end
+  end
+  
+  def arithmetic
+    node :arithmetic do
+      thing && one_or_more { (space && operator && space && thing) }
+    end
+  end
+  
+  def comparison
+    node :comparison do
+      (arithmetic || thing) && space && comparator && space && (arithmetic || thing)
+    end
+  end
+  
+  def comparator
+    node :comparator do
+      terminal(">=") || terminal("<=") || terminal("<>") || terminal(">") || terminal("<") || terminal("=")
+    end
+  end
+  
+  def string
+    node :string do
+      ignore { terminal("\"") } && terminal(/(""|[^"])*/) && ignore { terminal("\"") }
+    end
+  end
+  
+  def any_reference
+    external_reference || any_internal_reference
+  end
+  
+  def any_internal_reference
+    table_reference || local_table_reference || sheet_reference || sheetless_reference
+  end
+  
+  def percentage
+    node :percentage do
+      terminal(/[-+]?[0-9]+\.?[0-9]*/) && ignore { terminal("%") }
+    end
+  end
+  
+  def number
+    node :number do
+      terminal(/[-+]?[0-9]+\.?[0-9]*([eE][-+]?[0-9]+)?/)
+    end
+  end
+  
+  def operator
+    node :operator do
+      terminal("+") || terminal("-") || terminal("/") || terminal("*") || terminal("^")
+    end
+  end
+  
+  def external_reference
+    node :external_reference do
+      terminal(/\[\d+\]!?/) && any_internal_reference
+    end
+  end
+  
+  def table_reference
+    node :table_reference do
+      table_name && ignore { terminal("[") } && (range_structured_reference || complex_structured_reference || simple_structured_reference) && ignore { terminal("]") }
+    end
+  end
+  
+  def local_table_reference
+    node :local_table_reference do
+      ignore { terminal("[") } && (range_structured_reference || complex_structured_reference || overly_structured_reference || simple_structured_reference) && ignore { terminal("]") }
+    end
+  end
+  
+  def table_name
+    terminal(/[.a-zA-Z0-9_]+/)
+  end
+  
+  def range_structured_reference
+    terminal(/\[[^\u005d]*\],\[[^\u005d]*\]:\[[^\u005d]*\]/)
+  end
+  
+  def complex_structured_reference
+    terminal(/\[[^\u005d]*\],\[[^\u005d]*\]/)
+  end
+  
+  def overly_structured_reference
+    ignore { terminal("[") } && simple_structured_reference && ignore { terminal("]") }
+  end
+  
+  def simple_structured_reference
+    terminal(/[^\u005d]*/)
+  end
+  
+  def named_reference
+    node :named_reference do
+      terminal(/[#a-zA-Z][\w_.!]+/)
+    end
+  end
+  
+  def sheet_reference
+    node :sheet_reference do
+      (single_quoted_string || terminal(/[a-zA-Z0-9][\w_.]+/)) && ignore { terminal("!") } && (sheetless_reference || named_reference)
+    end
+  end
+  
+  def single_quoted_string
+    ignore { terminal("'") } && terminal(/[^']*/) && ignore { terminal("'") }
+  end
+  
+  def sheetless_reference
+    column_range || row_range || area || cell
+  end
+  
+  def column_range
+    node :column_range do
+      column && ignore { terminal(":") } && column
+    end
+  end
+  
+  def row_range
+    node :row_range do
+      row_number && ignore { terminal(":") } && row_number
+    end
+  end
+  
+  def area
+    node :area do
+      reference && ignore { terminal(":") } && reference
+    end
+  end
+  
+  def cell
+    node :cell do
+      reference
+    end
+  end
+  
+  def row_number
+    terminal(/\$?\d+/)
+  end
+  
+  def column
+    terminal(/\$?[A-Za-z]{1,3}/)
+  end
+  
+  def reference
+    terminal(/\$?[A-Za-z]{1,3}\$?[0-9]+(?![0-9A-Za-z_])/)
+  end
+  
+  def boolean
+    boolean_true || boolean_false
+  end
+  
+  def boolean_true
+    node :boolean_true do
+      ignore { terminal("TRUE") }
+    end
+  end
+  
+  def boolean_false
+    node :boolean_false do
+      ignore { terminal("FALSE") }
+    end
+  end
+  
+  def prefix
+    node :prefix do
+      terminal(/[-+]/) && thing
+    end
+  end
+  
+  def space
+    ignore { terminal(/[ \n]*/) }
+  end
+  
+  def null
+    node :null do
+      followed_by { terminal(",") }
+    end
+  end
+  
+end