excel_to_code 0.0.1

data/src/excel/excel_functions/excel_equal.rb

@@ -0,0 +1,20 @@
+require_relative 'apply_to_range'
+
+module ExcelFunctions
+  
+  def excel_equal?(a,b)
+    return apply_to_range(a,b) { |a,b| excel_equal?(a,b) } if a.is_a?(Array) || b.is_a?(Array)
+    
+    return a if a.is_a?(Symbol)
+    return b if b.is_a?(Symbol)
+    
+    case a
+    when String
+      a.downcase == b.downcase
+    else
+      a == b
+    end
+    
+  end
+  
+end

data/src/excel/excel_functions/excel_if.rb

@@ -0,0 +1,8 @@
+module ExcelFunctions
+  
+  def excel_if(condition,true_value,false_value = false)
+    return condition if condition.is_a?(Symbol)
+    condition ? true_value : false_value
+  end
+  
+end

data/src/excel/excel_functions/excel_match.rb

@@ -0,0 +1,51 @@
+module ExcelFunctions
+  
+  def excel_match(lookup_value,lookup_array,match_type = 0)
+    return lookup_value if lookup_value.is_a?(Symbol)
+    return lookup_array if lookup_array.is_a?(Symbol)
+    return match_type if match_type.is_a?(Symbol)
+    
+    lookup_value ||= 0
+    lookup_array ||= [0]
+    match_type ||= 0
+    lookup_array = [lookup_array] unless lookup_array.is_a?(Array)
+    lookup_array = lookup_array.flatten
+    
+    lookup_value = lookup_value.downcase if lookup_value.respond_to?(:downcase)
+    case match_type      
+    when 0, 0.0, false
+      lookup_array.each_with_index do |item,index|
+        item ||= 0
+        item = item.downcase if item.respond_to?(:downcase)
+        return index+1 if lookup_value == item
+      end
+      return :na
+    when 1, 1.0, true
+      lookup_array.each_with_index do |item, index|
+        item ||= 0
+        next if lookup_value.is_a?(String) && !item.is_a?(String)
+        next if lookup_value.is_a?(Numeric) && !item.is_a?(Numeric)
+        item = item.downcase if item.respond_to?(:downcase)
+        if item > lookup_value
+          return :na if index == 0
+          return index
+        end
+      end
+      return lookup_array.to_a.size
+    when -1, -1.0
+      lookup_array.each_with_index do |item, index|
+        item ||= 0
+        next if lookup_value.is_a?(String) && !item.is_a?(String)
+        next if lookup_value.is_a?(Numeric) && !item.is_a?(Numeric)
+        item = item.downcase if item.respond_to?(:downcase)
+        if item < lookup_value
+          return :na if index == 0
+          return index
+        end
+      end
+      return lookup_array.to_a.size - 1
+    end
+    return :na
+  end
+  
+end

data/src/excel/excel_functions/find.rb

@@ -0,0 +1,39 @@
+module ExcelFunctions
+  
+  def find(find_text,within_text,start_number = 1)
+    return find_text if find_text.is_a?(Symbol)
+    return within_text if within_text.is_a?(Symbol)
+    return start_number if start_number.is_a?(Symbol)
+
+    # nils are treated as empty strings
+    find_text ||= ""
+    within_text ||= ""
+    
+    # there are some cases where the start_number is remapped
+    case start_number
+    when nil; return :value
+    when String; 
+      begin
+        start_number = Float(start_number)
+      rescue ArgumentError
+        return :value
+      end
+    when true; start_number = 1
+    when false; return :value
+    when Numeric; # ok
+    else; return :value
+    end
+    
+    # edge case
+    return 1 if find_text == "" && within_text == "" && start_number == 1
+    
+    # length check
+    return :value if start_number < 1
+    return :value if start_number > within_text.length
+      
+    # Ok, lets go
+    result = within_text.index(find_text,start_number - 1 )
+    result ? result + 1 : :value
+  end
+  
+end

data/src/excel/excel_functions/iferror.rb

@@ -0,0 +1,10 @@
+module ExcelFunctions
+  
+  def iferror(value,value_if_error)
+    value_if_error ||= 0
+    return value_if_error if value.is_a?(Symbol)
+    return value_if_error if value.is_a?(Float) && value.nan?
+    value
+  end
+  
+end

data/src/excel/excel_functions/index.rb

@@ -0,0 +1,48 @@
+module ExcelFunctions
+  
+  def index(array, row_number, column_number = :not_specified)
+    
+    return array if array.is_a?(Symbol)
+    return row_number if row_number.is_a?(Symbol)
+    return column_number if column_number.is_a?(Symbol) && column_number != :not_specified
+
+    array = [[array]] unless array.is_a?(Array)
+        
+    if column_number == :not_specified
+      if array.length == 1 # It is a single row
+        index_for_row_column(array,1,row_number)
+      elsif array.first.length == 1 # it is a single column
+        index_for_row_column(array,row_number,1)
+      else
+        return :ref
+      end
+    else
+      if row_number == nil || row_number == 0
+        index_for_whole_column(array,column_number)    
+      elsif column_number == nil || column_number == 0
+        index_for_whole_row(array,row_number)
+      else 
+        index_for_row_column(array,row_number,column_number)
+      end
+    end
+  end
+  
+  def index_for_row_column(array,row_number,column_number)
+    return :ref if row_number < 1 || row_number > array.length
+    row = array[row_number-1]
+    return :ref if column_number < 1 || column_number > row.length
+    row[column_number-1] || 0
+  end
+  
+  def index_for_whole_row(array,row_number)
+    return :ref if row_number < 1
+    return :ref if row_number > array.length
+    [array[row_number-1]]
+  end
+  
+  def index_for_whole_column(array,column_number)
+    return :ref if column_number < 1
+    return :ref if column_number > array[0].length
+    array.map { |row| [row[column_number-1]]}
+  end
+end

data/src/excel/excel_functions/left.rb

@@ -0,0 +1,12 @@
+module ExcelFunctions
+  
+  def left(string,characters = 1)
+    return string if string.is_a?(Symbol)
+    return characters if characters.is_a?(Symbol)
+    return nil if string == nil || characters == nil
+    string = "TRUE" if string == true
+    string = "FALSE" if string == false
+    string.to_s.slice(0,characters)
+  end
+  
+end

data/src/excel/excel_functions/less_than.rb

@@ -0,0 +1,26 @@
+require_relative 'apply_to_range'
+
+module ExcelFunctions
+  
+  def less_than?(a,b)
+    # return apply_to_range(a,b) { |a,b| less_than?(a,b) } if a.is_a?(Array) || b.is_a?(Array)
+    
+    return a if a.is_a?(Symbol)
+    return b if b.is_a?(Symbol)
+
+    a = 0 if a == nil
+    b = 0 if b == nil
+    
+    case a
+    when String
+      a.downcase < b.downcase
+    when TrueClass, FalseClass
+      a = a ? 1 : 0
+      b = b ? 1 : 0 if (b.is_a?(TrueClass) || b.is_a?(FalseClass))
+      a < b
+    else
+      a < b
+    end
+  end
+  
+end

data/src/excel/excel_functions/less_than_or_equal.rb

@@ -0,0 +1,26 @@
+require_relative 'apply_to_range'
+
+module ExcelFunctions
+  
+  def less_than_or_equal?(a,b)
+    # return apply_to_range(a,b) { |a,b| less_than_or_equal?(a,b) } if a.is_a?(Array) || b.is_a?(Array)
+
+    return a if a.is_a?(Symbol)
+    return b if b.is_a?(Symbol)
+    
+    a = 0 if a == nil
+    b = 0 if b == nil
+    
+    case a
+    when String
+      a.downcase <= b.downcase
+    when TrueClass, FalseClass
+      a = a ? 1 : 0
+      b = b ? 1 : 0 if (b.is_a?(TrueClass) || b.is_a?(FalseClass))
+      a <= b
+    else
+      a <= b
+    end
+  end
+  
+end

data/src/excel/excel_functions/max.rb

@@ -0,0 +1,12 @@
+module ExcelFunctions
+  
+  def max(*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 0 if args.empty?
+    args.max
+  end
+  
+end

data/src/excel/excel_functions/min.rb

@@ -0,0 +1,12 @@
+module ExcelFunctions
+  
+  def min(*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 0 if args.empty?
+    args.min
+  end
+  
+end

data/src/excel/excel_functions/mod.rb

@@ -0,0 +1,15 @@
+module ExcelFunctions
+  
+  def mod(a,b)
+    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
+  end
+
+end

data/src/excel/excel_functions/more_than.rb

@@ -0,0 +1,26 @@
+require_relative 'apply_to_range'
+
+module ExcelFunctions
+  
+  def more_than?(a,b)
+    # return apply_to_range(a,b) { |a,b| more_than?(a,b) } if a.is_a?(Array) || b.is_a?(Array)
+    
+    return a if a.is_a?(Symbol)
+    return b if b.is_a?(Symbol)
+    
+    a = 0 if a == nil
+    b = 0 if b == nil
+    
+    case a
+    when String
+      a.downcase > b.downcase
+    when TrueClass, FalseClass
+      a = a ? 1 : 0
+      b = b ? 1 : 0 if (b.is_a?(TrueClass) || b.is_a?(FalseClass))
+      a > b
+    else
+      a > b
+    end
+  end
+  
+end

data/src/excel/excel_functions/more_than_or_equal.rb

@@ -0,0 +1,26 @@
+require_relative 'apply_to_range'
+
+module ExcelFunctions
+  
+  def more_than_or_equal?(a,b)
+    # return apply_to_range(a,b) { |a,b| more_than_or_equal?(a,b) } if a.is_a?(Array) || b.is_a?(Array)
+    
+    return a if a.is_a?(Symbol)
+    return b if b.is_a?(Symbol)
+    
+    a = 0 if a == nil
+    b = 0 if b == nil
+    
+    case a
+    when String
+      a.downcase >= b.downcase
+    when TrueClass, FalseClass
+      a = a ? 1 : 0
+      b = b ? 1 : 0 if (b.is_a?(TrueClass) || b.is_a?(FalseClass))
+      a >= b
+    else
+      a >= b
+    end
+  end
+  
+end

data/src/excel/excel_functions/multiply.rb

@@ -0,0 +1,24 @@
+require_relative 'number_argument'
+require_relative 'apply_to_range'
+
+module ExcelFunctions
+  
+  def multiply(a,b)
+  begin
+    # return apply_to_range(a,b) { |a,b| multiply(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
+    
+  rescue Error => e
+    print e.backtrace.join('\n')
+    raise
+  end
+  end
+  
+end

data/src/excel/excel_functions/negative.rb

@@ -0,0 +1,12 @@
+module ExcelFunctions
+  
+  def negative(a)
+    a = number_argument(a)
+  
+    return a if a.is_a?(Symbol)
+    
+    -a
+
+  end
+  
+end

data/src/excel/excel_functions/not_equal.rb

@@ -0,0 +1,19 @@
+require_relative 'apply_to_range'
+
+module ExcelFunctions
+  
+  def not_equal?(a,b)
+    # return apply_to_range(a,b) { |a,b| not_equal?(a,b) } if a.is_a?(Array) || b.is_a?(Array)
+    
+    return a if a.is_a?(Symbol)
+    return b if b.is_a?(Symbol)
+    
+    case a
+    when String
+      a.downcase != b.downcase
+    else
+      a != b
+    end
+  end
+  
+end

data/src/excel/excel_functions/number_argument.rb

@@ -0,0 +1,30 @@
+module ExcelFunctions
+  
+  # This is a support function for mapping arguments that are numbers to numeric values
+  # deals with the fact that in Excel "2.14" == 2.14, TRUE == 1, FALSE == 0 and nil == 0
+  def number_argument(a)
+    case a
+    when Symbol
+      return a
+    when String
+      begin
+        return Float(a)
+      rescue ArgumentError
+        return :value
+      end
+    when nil
+      return 0
+    when true
+      return 1
+    when false
+      return 0
+    when Numeric
+      return a
+    when Array
+      return a[0][0]
+    else
+      return :value
+    end
+  end
+  
+end