excel_to_code 0.0.1

data/src/compile/ruby/map_sheet_names_to_ruby_names.rb

@@ -0,0 +1,19 @@
+class MapSheetNamesToRubyNames
+  
+  def self.rewrite(*args)
+    self.new.rewrite(*args)
+  end
+  
+  def rewrite(input,output)
+    ruby_names_assigned = {}
+    input.lines do |line|
+      excel_worksheet_name = line.split("\t").first
+      ruby_name = excel_worksheet_name.downcase.gsub(/[^a-z0-9]+/,'_')
+      ruby_name = "s"+ruby_name if ruby_name[0] !~ /[a-z]/
+      ruby_name = ruby_name + "2" if ruby_names_assigned.has_key?(ruby_name)
+      ruby_name.succ! while ruby_names_assigned.has_key?(ruby_name)
+      output.puts "#{excel_worksheet_name}\t#{ruby_name}"
+      ruby_names_assigned[ruby_name] = excel_worksheet_name
+    end
+  end
+end

data/src/compile/ruby/map_values_to_ruby.rb

@@ -0,0 +1,65 @@
+require_relative '../../util/not_supported_exception'
+
+class MapValuesToRuby
+
+  def map(ast)
+    if ast.is_a?(Array)
+      operator = ast[0]
+      if respond_to?(operator)
+        send(operator,*ast[1..-1])
+      else
+        raise NotSupportedException.new("#{operator} in #{ast.inspect} not supported")
+      end
+    else
+      raise NotSupportedException.new("#{ast} not supported")
+    end
+  end
+  
+  def blank
+    "nil"
+  end
+  
+  alias :null :blank
+    
+  def number(text)
+    case text
+    when /\./
+      text.to_f.to_s
+    when /e/i
+      text.to_f.to_s
+    else
+      text.to_i.to_s
+    end
+  end
+  
+  def percentage(text)
+    (text.to_f / 100.0).to_s
+  end
+  
+  def string(text)
+    text.inspect
+  end
+  
+  ERRORS = {
+    "#NAME?" => ":name",
+    "#VALUE!" => ":value",
+    "#DIV/0!" => ":div0",
+    "#REF!" => ":ref",
+    "#N/A" => ":na"
+  }
+  
+  REVERSE_ERRORS = ERRORS.invert
+  
+  def error(text)
+    ERRORS[text] || (raise NotSupportedException.new("#{text.inspect} error not recognised"))
+  end
+  
+  def boolean_true
+    "true"
+  end
+  
+  def boolean_false
+    "false"
+  end
+  
+end

data/src/excel.rb

@@ -0,0 +1,5 @@
+require_relative 'excel/area'
+require_relative 'excel/reference'
+require_relative 'excel/formula_peg'
+require_relative 'excel/table'
+require_relative 'excel/excel_functions'

data/src/excel/area.rb

@@ -0,0 +1,93 @@
+require_relative 'reference'
+
+class Area < String
+  
+  # This is so that we only have one instance for a given area
+  @@areas_for_text ||= Hash.new do |hash,text|
+    hash[text] = area = Area.new(text)
+    area
+  end
+    
+  # This is so that we only have one instance of a given reference specified by its variables
+  def Area.for(text)
+     @@areas_for_text[text]
+  end
+  
+  attr_reader :excel_start, :excel_finish
+  
+  def calculate_excel_variables
+    return if @excel_variables_calculated
+    if self =~ /([^:]+):(.*)/
+      @excel_start = Reference.for($1)
+      @excel_finish = Reference.for($2)
+    else
+      @excel_start = @excel_finish = Reference.for(self)
+    end      
+    @excel_start.calculate_excel_variables
+    @excel_finish.calculate_excel_variables
+  end
+  
+  def offset(row,column)
+    calculate_excel_variables
+    Area.for([
+      @excel_start.offset(row,column),
+      ':',
+      @excel_finish.offset(row,column),
+    ].join)
+  end
+  
+  def offsets
+    Enumerator.new do |yielder|
+      0.upto(width).each do |c|
+        0.upto(height).each do |r|
+          yielder.yield([r,c])
+        end
+      end
+    end
+  end
+  
+  def height
+    calculate_excel_variables
+    @excel_finish.excel_row_number -  @excel_start.excel_row_number
+  end
+  
+  def width
+    calculate_excel_variables
+    @excel_finish.excel_column_number -  @excel_start.excel_column_number
+  end
+  
+  def to_array_literal(sheet = nil)
+    calculate_excel_variables
+    unfixed_start = @excel_start.unfix
+    [:array,
+      *(0.upto(height).map do |row|
+        [:row,
+          *(0.upto(width).map do |column|
+            if sheet
+              [:sheet_reference, 
+                sheet,
+                [:cell,
+                  unfixed_start.offset(row,column)
+                ]
+              ]
+            else
+              [:cell,
+                unfixed_start.offset(row,column)
+              ]
+            end
+          end)
+        ]
+      end)
+    ]
+  end
+  
+  def includes?(reference)
+    calculate_excel_variables
+    r = Reference.for(reference)
+    r.calculate_excel_variables
+    return false if r.excel_row_number < @excel_start.excel_row_number || r.excel_row_number > @excel_finish.excel_row_number
+    return false if r.excel_column_number < @excel_start.excel_column_number || r.excel_column_number > @excel_finish.excel_column_number
+    true
+  end
+  
+end

data/src/excel/excel_functions.rb

@@ -0,0 +1,84 @@
+module ExcelFunctions
+end
+
+# Support functions
+require_relative 'excel_functions/number_argument'
+
+# Constants
+require_relative 'excel_functions/pi'
+
+# Comparators
+require_relative 'excel_functions/excel_equal'
+require_relative 'excel_functions/less_than'
+require_relative 'excel_functions/more_than'
+require_relative 'excel_functions/less_than_or_equal'
+require_relative 'excel_functions/more_than_or_equal'
+require_relative 'excel_functions/not_equal'
+
+require_relative 'excel_functions/excel_if'
+require_relative 'excel_functions/iferror'
+
+# Basic arithmetic
+require_relative 'excel_functions/add'
+require_relative 'excel_functions/subtract'
+require_relative 'excel_functions/multiply'
+require_relative 'excel_functions/divide'
+require_relative 'excel_functions/power'
+
+# More advanced arithmetic
+require_relative 'excel_functions/abs'
+require_relative 'excel_functions/and'
+require_relative 'excel_functions/mod'
+
+# Array arithmetic
+require_relative 'excel_functions/sum'
+require_relative 'excel_functions/average'
+require_relative 'excel_functions/max'
+require_relative 'excel_functions/min'
+
+# Financial functions
+require_relative 'excel_functions/pmt'
+
+# Geometry functions
+require_relative 'excel_functions/cosh'
+
+# String functions
+require_relative 'excel_functions/string_join'
+require_relative 'excel_functions/excel_match'
+require_relative 'excel_functions/find'
+
+# Search functions
+require_relative 'excel_functions/choose'
+
+# Other functions
+
+
+
+
+
+
+require_relative 'excel_functions/round'
+
+require_relative 'excel_functions/subtotal'
+
+require_relative 'excel_functions/count'
+
+require_relative 'excel_functions/counta'
+
+require_relative 'excel_functions/sumif'
+
+require_relative 'excel_functions/sumifs'
+
+require_relative 'excel_functions/sumproduct'
+
+require_relative 'excel_functions/vlookup'
+
+require_relative 'excel_functions/index'
+
+require_relative 'excel_functions/left'
+
+require_relative 'excel_functions/roundup'
+
+require_relative 'excel_functions/rounddown'
+
+require_relative 'excel_functions/negative'

data/src/excel/excel_functions/abs.rb

@@ -0,0 +1,14 @@
+module ExcelFunctions
+  
+  def abs(a)
+    case a
+    when Numeric; return a.abs
+    when Symbol; return a
+    when nil; return 0
+    when true; return 1
+    when false; return 0
+    else; return :value
+    end
+  end
+  
+end

data/src/excel/excel_functions/add.rb

@@ -0,0 +1,18 @@
+require_relative 'number_argument'
+require_relative 'apply_to_range'
+
+module ExcelFunctions
+  
+  def add(a,b)
+    # return apply_to_range(a,b) { |a,b| add(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/and.rb

@@ -0,0 +1,30 @@
+module ExcelFunctions
+  
+  def excel_and(*args)
+    # Flatten arrays
+    args = args.flatten
+    
+    # If an argument is an error, return that
+    error = args.find {|a| a.is_a?(Symbol)}
+    return error if error
+    
+    # Replace 1 and 0 with true and false
+    args.map! do |a|
+      case a
+      when 1; true
+      when 0; false
+      else; a
+      end
+    end
+    
+    # Remove anything not boolean
+    args.delete_if { |a| !(a.is_a?(TrueClass) || a.is_a?(FalseClass)) }
+    
+    # Return an error if nothing less
+    return :value if args.empty?
+    
+    # Now calculate and return
+    args.all? {|a| a == true }
+  end
+  
+end

data/src/excel/excel_functions/apply_to_range.rb

@@ -0,0 +1,17 @@
+module ExcelFunctions
+
+  def apply_to_range(a,b)
+    a = Array.new(b.length,Array.new(b.first.length,a)) unless a.is_a?(Array)
+    b = Array.new(a.length,Array.new(a.first.length,b)) unless b.is_a?(Array)
+    
+    return :value unless b.length == a.length
+    return :value unless b.first.length == a.first.length
+    
+    a.map.with_index do |row,i|
+      row.map.with_index do |cell,j|
+        yield cell, b[i][j]
+      end
+    end
+  end
+  
+end

data/src/excel/excel_functions/average.rb

@@ -0,0 +1,12 @@
+module ExcelFunctions
+  
+  def average(*args)
+    args = args.flatten
+    error = args.find {|a| a.is_a?(Symbol)}
+    return error if error
+    args.delete_if { |a| !a.is_a?(Numeric) }
+    return :div0 if args.empty?
+    args.inject(0.0) { |m,i| m + i.to_f } / args.size.to_f
+  end
+  
+end

data/src/excel/excel_functions/choose.rb

@@ -0,0 +1,18 @@
+module ExcelFunctions
+  
+  def choose(index,*args)
+    # If an argument is an error, return that
+    return index if index.is_a?(Symbol)
+    error = args.find {|a| a.is_a?(Symbol)}
+    return error if error
+    
+    # If the index is out of bounds, return an error
+    return :value unless index
+    return :value if index < 1
+    return :value if index > args.length
+    
+    return args[index-1] || 0
+    
+  end
+  
+end

data/src/excel/excel_functions/cosh.rb

@@ -0,0 +1,9 @@
+module ExcelFunctions
+  
+  def cosh(x)
+    return x if x.is_a?(Symbol)
+    x ||= 0
+    Math.cosh(x)
+  end
+  
+end

data/src/excel/excel_functions/count.rb

@@ -0,0 +1,9 @@
+module ExcelFunctions
+  
+  def count(*args)
+    args = args.flatten
+    args.delete_if { |a| !a.is_a?(Numeric)}
+    args.size
+  end
+  
+end

data/src/excel/excel_functions/counta.rb

@@ -0,0 +1,8 @@
+module ExcelFunctions
+  
+  def counta(*args)
+    args = args.flatten.compact
+    args.size
+  end
+  
+end

data/src/excel/excel_functions/divide.rb

@@ -0,0 +1,23 @@
+require_relative 'number_argument'
+require_relative 'apply_to_range'
+
+module ExcelFunctions
+  
+  def divide(a,b)
+    # return apply_to_range(a,b) { |a,b| divide(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)
+    
+    return :div0 if b == 0
+    
+    a / b.to_f
+
+  rescue ZeroDivisionError
+    :div0
+  end
+  
+end