calco 0.1.0

data/lib/calco.rb

@@ -0,0 +1,17 @@
+require "calco/version"
+
+require "calco/spreadsheet"
+require "calco/time_functions"
+require "calco/date_functions"
+require "calco/math_functions"
+require "calco/string_functions"
+
+def spreadsheet engine = Calco::DefaultEngine.new, &block
+
+  document = Calco::Spreadsheet.new(engine)
+
+  document.instance_eval(&block)
+
+  document
+
+end

data/lib/calco/core_ext/fixnum.rb

@@ -0,0 +1,22 @@
+class Fixnum
+
+  alias_method '_calco_original_+', :+
+  alias_method '_calco_original_-', :-
+  alias_method '_calco_original_*', :*
+  alias_method '_calco_original_/', :/
+  
+  %w[+ - / *].each do |op|
+
+    define_method(op) do |arg|
+    
+      if arg.respond_to?(:generate)
+        Calco::Operation.new(op, self, arg)
+      else
+        self.send("_calco_original_#{op}", arg)
+      end
+      
+    end
+
+  end
+  
+end

data/lib/calco/core_ext/float.rb

@@ -0,0 +1,22 @@
+class Float
+
+  alias_method '_calco_original_+', :+
+  alias_method '_calco_original_-', :-
+  alias_method '_calco_original_*', :*
+  alias_method '_calco_original_/', :/
+  
+  %w[+ - / *].each do |op|
+
+    define_method(op) do |arg|
+    
+      if arg.respond_to?(:generate)
+        Calco::Operation.new(op, self, arg)
+      else
+        self.send("_calco_original_#{op}", arg)
+      end
+      
+    end
+
+  end
+  
+end

data/lib/calco/core_ext/range.rb

@@ -0,0 +1,15 @@
+class Range
+
+  def as_grouping
+    
+    @grouping_range = true
+    
+    self
+    
+  end
+  
+  def grouping_range?
+    ! @grouping_range.nil?
+  end
+  
+end

data/lib/calco/core_ext/string.rb

@@ -0,0 +1,20 @@
+class String
+
+  alias_method '_calco_original_+', :+
+  alias_method '_calco_original_*', :*
+  
+  %w[+ *].each do |op|
+
+    define_method(op) do |arg|
+    
+      if arg.respond_to?(:generate)
+        Calco::Operation.new(op, self, arg)
+      else
+        self.send("_calco_original_#{op}", arg)
+      end
+      
+    end
+
+  end
+  
+end

data/lib/calco/date_functions.rb

@@ -0,0 +1,13 @@
+require 'date'
+
+module Calco
+
+  class BuiltinFunction
+
+    declare :today, 0, Date
+    declare :year, 1, Integer
+    declare :datevalue, 1, Date
+
+  end
+
+end

data/lib/calco/definition_dsl.rb

@@ -0,0 +1,127 @@
+require 'date'
+require 'time'
+
+require_relative 'elements/if'
+require_relative 'elements/or'
+require_relative 'elements/empty'
+require_relative 'elements/constant'
+require_relative 'elements/current'
+require_relative 'elements/element'
+require_relative 'elements/formula'
+require_relative 'elements/variable'
+require_relative 'elements/operation'
+require_relative 'elements/value_extractor'
+require_relative 'elements/builtin_function'
+
+require_relative 'core_ext/float'
+require_relative 'core_ext/range'
+require_relative 'core_ext/fixnum'
+require_relative 'core_ext/string'
+
+module Calco
+
+  module DefinitionDSL
+  
+    def set variable_assign
+
+      name = variable_assign.first[0]
+      value = variable_assign.first[1]
+
+      raise "Variable '#{name}' already set" if @variables.include?(name)
+
+      if value =~ /^\d{1,2}:\d{1,2}(:\d{1,2})?$/
+        value = Time.parse(value)
+      elsif value =~ /^\d{1,4}[-\/]\d{1,2}[-\/]\d{1,2}$/
+        value = Date.parse(value)
+      end
+      
+      @variables[name] = Variable.new(name, value)
+
+    end
+
+    def function formula_definition
+
+      name = formula_definition.first[0]
+      value = formula_definition.first[1]
+
+      raise "Function '#{name}' already defined" if @formulas.include?(name)
+      
+      @formulas[name] = Formula.new(value)
+
+    end
+
+  end
+  
+  module BuilderDSL
+  
+    def _if condition, then_, else_
+      If.new(condition, then_, else_)
+    end
+
+    def _or condition1, condition2
+      Or.new(condition1, condition2)
+    end
+    
+    def builtin_function? sym
+      BuiltinFunction.exists_function?(sym)
+    end
+    
+    def builtin_function sym, args
+      BuiltinFunction.create_function(sym, args)
+    end
+    
+  end
+  
+  class Definitions
+  
+    include BuilderDSL
+    include DefinitionDSL
+
+    attr_reader :variables, :formulas
+    
+    def initialize spreadsheet
+      
+      @formulas = {}
+      @variables = {}
+      
+      @spreadsheet = spreadsheet
+      
+    end
+  
+    def resolve! sym, *args
+
+      if @variables.include?(sym)
+        @variables[sym]
+      elsif @formulas.include?(sym)
+        @formulas[sym]
+      elsif builtin_function?(sym)
+        builtin_function(sym, args)
+      else
+        raise "Unknown function or variable '#{sym}'"
+      end
+
+    end
+    
+    def formula? name
+      @formulas.include?(name)
+    end
+    
+    def formula name
+      @formulas[name]
+    end
+    
+    def variable? name
+      @variables.include?(name)
+    end
+    
+    def variable name
+      @variables[name]
+    end
+    
+    def method_missing sym, *args
+      resolve! sym, *args
+    end
+
+  end
+  
+end

data/lib/calco/elements/aggregator.rb

@@ -0,0 +1,17 @@
+require_relative 'element'
+
+module Calco
+
+  class Aggregator < Element
+
+    def initialize variable, range
+      @variable, @range = variable, range
+    end
+
+    def generate row
+      @engine.range_reference(@variable, row, @range)
+    end
+
+  end
+
+end

data/lib/calco/elements/builtin_function.rb

@@ -0,0 +1,84 @@
+require_relative 'element'
+
+module Calco
+
+  class BuiltinFunction < Element
+
+    @@builtin_functions = {}
+
+    # arity is an integer or :n for a variable number of arguments
+    # type is the return type and expected to be a class object or an array
+    # of class objects
+    def self.declare name, arity, type = :any
+
+      unless arity == :n or arity.is_a?(Integer)
+        raise ArgumentError, "Artity must be an integer or :n but was a #{arity.class}"
+      end
+      unless type.is_a?(Class) or (type.respond_to?(:all?) and type.all?{|t| t.is_a?(Class)})
+        raise ArgumentError, "Type should be a Class or an array of Class objects" 
+      end
+      
+      @@builtin_functions[name.to_s.downcase] = [arity, type]
+
+    end
+
+    def self.undeclare name
+      @@builtin_functions.delete(name.to_s.downcase)
+    end
+
+    def self.exists_function? name
+      @@builtin_functions.include?(name.to_s.downcase)
+    end
+
+    def self.create_function name, args
+
+      raise NameError, "Builtin function not found '#{name}'" unless exists_function?(name)
+
+      name = name.to_s.upcase
+
+      definition = @@builtin_functions[name.to_s.downcase]
+
+      self.new(name, definition, args)
+
+    end
+
+    include Operators
+
+    def initialize name, definition, args
+
+      @arity = definition[0]
+      @return_type = definition[1]
+
+      unless @arity == :n
+
+        if @arity != args.length
+          raise ArgumentError, "Function #{name} requires #{@arity}, was #{args.length} (#{args.inspect})"
+        end
+
+      end
+
+      @name, @args = name, args
+
+    end
+
+    def generate row
+
+      sep = ''
+      arguments = ''
+
+      @args.each do |arg|
+
+        arguments << sep
+        arguments << (arg.respond_to?(:generate) ? arg.generate(row) : @engine.value(arg))
+
+        sep = ', '
+
+      end
+
+      "#{@name}(#{arguments})"
+
+    end
+
+  end
+
+end

data/lib/calco/elements/constant.rb

@@ -0,0 +1,31 @@
+require_relative 'element'
+
+module Calco
+
+  class Constant < Element
+
+    include Operators
+
+    attr_accessor :value
+
+    def initialize value
+      @value = value
+    end
+
+    def generate row
+      @engine.value(self)
+    end
+
+    def self.wrap value
+
+      if value.respond_to?(:generate)
+        value
+      else
+        Constant.new(value)
+      end
+
+    end
+
+  end
+
+end

data/lib/calco/elements/current.rb

@@ -0,0 +1,19 @@
+require_relative 'element'
+
+module Calco
+
+  class Current < Element
+
+    include Operators
+
+    def initialize
+      @reference_type = :current
+    end
+
+    def generate row
+      @engine.current
+    end
+
+  end
+
+end

data/lib/calco/elements/element.rb

@@ -0,0 +1,31 @@
+require_relative 'operator'
+
+module Calco
+
+  class Element
+
+    attr_accessor :reference_type, :column, :absolute_row
+
+    def initialize
+      @absolute_row = nil
+      @reference_type = :normal
+    end
+
+    def absolute_row= row_number
+      @absolute_row = row_number
+      @reference_type = :absolute
+    end
+    
+    def generate_operand o, row
+    
+      if o.respond_to?(:as_operand)
+        o.as_operand(row)
+      else
+        o.generate(row)
+      end
+
+    end
+
+  end
+  
+end

data/lib/calco/elements/empty.rb

@@ -0,0 +1,9 @@
+require_relative 'element'
+
+module Calco
+
+  class Empty < Element
+    include Singleton
+  end
+
+end

data/lib/calco/elements/formula.rb

@@ -0,0 +1,42 @@
+require_relative 'element'
+
+module Calco
+
+  class Formula < Element
+
+    include Operators
+
+    def initialize statement
+
+      super()
+
+      @statement = Constant.wrap(statement)
+
+    end
+
+    def [] range
+      
+      raise ArgumentError, "Expected Range got #{range.class}" unless range.is_a?(Range)
+      raise ArgumentError, "Invalid start of range (must be > 0, was #{range.first})" unless range.first > 0
+      
+      Aggregator.new(self, range)
+      
+    end
+
+    def generate row
+
+      if self.reference_type == :absolute and self.absolute_row != row
+        nil
+      else
+        @statement.generate(row)
+      end
+
+    end
+    
+    def as_operand row
+      @engine.column_reference(self, row)
+    end
+
+  end
+
+end