kalc 0.3

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Chris Parker
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,74 @@
+h1. kalc
+
+h2. Introduction
+
+kalc is a small functional programming language that (gasp) borrows a lot of
+its syntax from the Excel formula language.
+
+h2. ikalc
+
+kalc comes with its own repl, known as ikalc.  It evaluates when you press return.
+
+h2. Syntax
+
+kalc is a tiny language, and it has very little syntax.  It does support
+functions, variable assignment, and arithmetic.
+
+h3. Arithmetic
+
+<pre>
+1 + 1 / (10 * 100) - 3 + 3 - (3 - 2)
+1 > 1
+SUM(1, 2, 3, 4, 5)
+</pre>
+
+Arithmetic is standard infix with nesting via parenthesis.
+
+h3. Logical operations
+
+<pre>
+1 > 2 ? 1 : 3 # Ternary
+(1 || 2) > 3
+1 > 2 or 3 < 2 # false
+OR(1 > 2, 3 < 2, 8 == 8) # true
+</pre>
+
+h3. Variable assignment
+
+<pre>
+a = 1
+b = 2
+d = a + b
+</pre>
+
+h3.  Creating functions
+
+<pre>
+DEFINE FOO(a, b) {
+  a + b
+}
+</pre>
+
+There are a few examples of functions in lib/stdlib.kalc
+
+h3. Loops
+
+There are no looping mechanisms to speak of, but recursion works well.
+
+<pre>
+DEFINE SAMPLE_LOOP(a) {
+  PUTS(a)
+  IF(a == 1, 1, SAMPLE_LOOP(a - 1))
+}
+</pre>
+
+h4. More inside
+
+Not everything is documented yet.  As you can see, it is a mix of
+a lot of different ideas.  The goal is to have an excel-like language
+that is somewhat functional.
+
+h2. Contributing
+
+Fork on GitHub and after you've committed tested patches, send a pull request.
+

data/bin/ikalc

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+kalc_dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(kalc_dir) unless $LOAD_PATH.include?(kalc_dir)
+
+require "kalc"
+
+repl = Kalc::Repl.new.run

data/bin/kalc

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+kalc_dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(kalc_dir) unless $LOAD_PATH.include?(kalc_dir)
+
+require "kalc"
+require "pp"
+
+input = File.read(ARGV.first)
+
+grammar = Kalc::Grammar.new
+g = grammar.parse(input)
+
+transform = Kalc::Transform.new
+ast = transform.apply(g)
+
+
+interpreter = Kalc::Interpreter.new
+puts interpreter.run(ast)

data/kalc.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "kalc/version"
+#
+Gem::Specification.new do |s|
+  s.name        = "kalc"
+  s.version     = Kalc::VERSION
+  s.authors     = ["Chris Parker"]
+  s.email       = ["mrcsparker@gmail.com"]
+  s.homepage    = "https://github.com/mrcsparker/kalc"
+  s.summary     = %q{Small calculation language.}
+  s.description = %q{Calculation language slightly based on Excel's formula language.}
+
+  s.rubyforge_project = "kalc"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec"
+  s.add_runtime_dependency "parslet", "~> 1.2"
+end

data/lib/kalc.rb

@@ -0,0 +1,14 @@
+require 'parslet'
+
+require 'kalc/version'
+require 'kalc/grammar'
+require 'kalc/ast'
+require 'kalc/transform'
+require 'kalc/environment'
+require 'kalc/interpreter'
+require 'kalc/repl'
+
+module Kalc
+
+end
+

data/lib/kalc/ast.rb

@@ -0,0 +1,198 @@
+module Kalc
+  module Ast
+
+    class Commands
+      attr_reader :commands
+
+      def initialize(commands)
+        @commands = commands
+      end
+
+      def eval(context)
+        last = nil
+        @commands.each do |command|
+          last = command.eval(context)
+        end
+        last
+      end
+    end
+
+
+    class Expressions
+      attr_reader :expressions
+
+      def initialize(expressions)
+        @expressions = expressions
+      end
+
+      def eval(context)
+        last = nil
+        @expressions.each do |exp|
+          last = exp.eval(context)
+        end
+        last
+      end
+    end
+
+    class BooleanValue
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+      end
+
+      def eval(context)
+        @value == 'TRUE' ? true : false
+      end
+    end
+
+    class FloatingPointNumber
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+      end
+
+      def eval(context)
+        Float(@value)
+      end
+    end
+
+    class Arithmetic
+      attr_reader :left
+      attr_reader :right
+      attr_reader :operator
+
+      def initialize(left, right, operator)
+        @left = left
+        @right = right
+        @operator = operator
+      end
+
+      def eval(context)
+
+        @left = @left.eval(context)
+        @right = @right.eval(context)
+
+        case @operator.to_s.strip
+        when '&&'
+          @left && @right
+        when 'and'
+          @left && @right
+        when '||'
+          @left || @right
+        when 'or'
+          @left || @right
+        when '<='
+          @left <= @right
+        when '>='
+          @left >= @right
+        when '=='
+          @left == @right
+        when '!='
+          @left != @right
+        when '-'
+          @left - @right
+        when '+'
+          @left + @right
+        when '*'
+          @left * @right
+        when '/'
+          @left / @right
+        when '%'
+          @left % @right
+        when '<'
+          @left < @right
+        when '>'
+          @left > @right
+        end
+      end
+    end
+
+    class Conditional
+      attr_reader :condition, :true_cond, :false_cond
+
+      def initialize(condition, true_cond, false_cond)
+        @condition = condition
+        @true_cond = true_cond
+        @false_cond = false_cond
+      end
+
+      def eval(context)
+        @condition ? true_cond : false_cond
+      end
+    end
+
+    class Identifier
+      attr_reader :identifier
+      attr_reader :value
+
+      def initialize(identifier, value)
+        @variable = identifier.to_s.strip
+        @value = value
+      end
+
+      def eval(context)
+        context.add_variable(@variable, @value.eval(context))
+      end
+    end
+
+    class Variable
+      attr_reader :variable
+      def initialize(variable)
+        @variable = variable
+      end
+
+      def eval(context)
+        context.get_variable(@variable)
+      end
+    end
+
+    class StringValue
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+      end
+
+      def eval(context)
+        value.to_s
+      end
+    end
+
+    class FunctionCall
+      attr_reader :name
+      attr_reader :variable_list
+
+      def initialize(name, variable_list)
+        @name = name
+        @variable_list = variable_list
+      end
+
+      def eval(context)
+        to_call = context.get_function(@name)
+        to_call.call(context, *@variable_list) if to_call
+      end
+    end
+
+    class FunctionDefinition
+      def initialize(name, argument_list, body)
+        @name = name
+        @argument_list = argument_list
+        @body = body
+      end
+
+      def eval(context)
+        context.add_function(@name.to_sym, lambda { |parent_context, *args|
+          dup_body = Marshal.load(Marshal.dump(@body))
+          cxt = Environment.new(parent_context)
+          args.each_with_index do |arg, idx|
+            cxt.add_variable(@argument_list[idx].value, arg.eval(cxt))
+          end
+          dup_body.eval(cxt)
+        })
+        nil
+      end
+    end
+  end
+end

data/lib/kalc/environment.rb

@@ -0,0 +1,43 @@
+module Kalc
+  class Environment
+
+    attr_reader :functions
+    attr_reader :variables
+
+    def initialize(parent = nil)
+      @functions = {}
+      @variables = {}
+      @parent = parent
+      yield self if block_given?
+    end
+
+    def add_function(name, value)
+      @functions.update({ name.to_s.strip => value })
+    end
+
+    def get_function(name)
+      if fun = @functions[name.to_s.strip]
+        fun
+      elsif !@parent.nil?
+        @parent.get_function(name)
+      else
+        nil
+      end
+    end
+
+    def add_variable(name, value)
+      @variables.update({ name.to_s.strip => value })
+      value
+    end
+
+    def get_variable(name)
+      if var = @variables[name.to_s.strip]
+        var
+      elsif !@parent.nil?
+        @parent.get_variable(name)
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/kalc/grammar.rb

@@ -0,0 +1,273 @@
+# Started with https://github.com/postmodern/cparser code
+# which is based on http://www.lysator.liu.se/c/ANSI-C-grammar-y.html
+# and worked from there
+# 
+# The second link really helped when it came to functions
+
+class Kalc::Grammar < Parslet::Parser
+
+  rule(:new_line) { match('[\n\r]').repeat(1) }
+
+  rule(:space) { match('[ \t\v\n\f]') }
+  rule(:spaces) { space.repeat(1) }
+  rule(:space?) { space.maybe }
+  rule(:spaces?) { space.repeat }
+
+  rule(:digit) { match('[0-9]') }
+  rule(:digits) { digit.repeat(1) }
+  rule(:digits?) { digit.repeat }
+
+  rule(:alpha) { match('[_a-zA-Z]') }
+
+  rule(:new_line) { match('[\n\r]').repeat(1) }
+  rule(:separator) { str(';') >> spaces? }
+
+  def self.symbols(symbols) 
+    symbols.each do |name, symbol|
+      rule(name) { str(symbol) >> spaces? }
+    end
+  end
+
+  symbols :left_paren => '(',
+          :right_paren => ')',
+          :left_brace => '{',
+          :right_brace => '}',
+          :comma => ',',
+          :colon => ':'
+
+  def self.operators(operators={})
+    trailing_chars = Hash.new { |hash,symbol| hash[symbol] = [] }
+
+    operators.each_value do |symbol|
+      operators.each_value do |op|
+        if op[0,symbol.length] == symbol
+          char = op[symbol.length,1]
+
+          unless (char.nil? || char.empty?)
+            trailing_chars[symbol] << char
+          end
+        end
+      end
+    end
+
+    operators.each do |name,symbol|
+      trailing = trailing_chars[symbol]
+
+      if trailing.empty?
+        rule(name) { str(symbol).as(:operator) >> spaces? }
+      else
+        pattern = "[#{Regexp.escape(trailing.join)}]"
+
+        rule(name) {
+          (str(symbol) >> match(pattern).absnt?).as(:operator) >> spaces?
+        }
+      end
+    end
+  end
+
+  operators :logical_and => '&&',
+            :string_and => 'and',
+            :logical_or => '||',
+            :string_or => 'or',
+            :less_equal => '<=',
+            :greater_equal => '>=',
+            :equal => '==',
+            :not_equal => '!=',
+
+            :assign => '=',
+            :question_mark => '?',
+
+            :subtract => '-',
+            :add => '+',
+            :multiply => '*',
+            :divide => '/',
+            :modulus => '%',
+
+            :less => '<',
+            :greater => '>'
+
+  rule(:true_keyword) {
+    str('TRUE') >> spaces?
+  }
+
+  rule(:false_keyword) {
+    str('FALSE') >> spaces?
+  }
+
+  rule(:boolean) {
+    (true_keyword | false_keyword).as(:boolean)
+  }
+
+  rule(:string) {
+    str('"') >> 
+    (
+      str('\\') >> any |
+      str('"').absnt? >> any
+    ).repeat.as(:string) >> 
+    str('"')
+  }
+
+  rule(:number) {
+    (match('[+-]').maybe >> digits >> (str('.') >> digits).maybe).as(:number) >> spaces?
+  }
+
+  rule(:identifier) {
+    (alpha >> (alpha | digit).repeat) >> spaces?
+  }
+
+  rule(:argument) {
+    identifier.as(:argument)
+  }
+
+  # Should look like 'Name'
+  rule(:variable) {
+    identifier | (str("'") >> identifier >> str("'")) >> spaces?
+  }
+
+  # Does not self-evaluate
+  # Use to call function: FUNCTION_NAME(variable_list, ..)
+  rule(:variable_list) {
+    conditional_expression >> (comma >> conditional_expression).repeat
+  }
+
+  rule(:paren_variable_list) {
+    (left_paren >> variable_list.repeat >> right_paren).as(:paren_list)
+  }
+
+  # Does not self-evaluate
+  # Used to create function: DEF FUNCTION_NAME(argument_list, ..)
+  rule(:argument_list) {
+    argument >> (comma >> argument).repeat
+  }
+
+  rule(:paren_argument_list) {
+    (left_paren >> argument_list.repeat >> right_paren).as(:paren_list)
+  }
+
+  # Atoms can self-evaluate
+  # This where the grammar starts
+  rule(:atom) {
+    boolean | variable.as(:variable) | number | string | paren_expression
+  }
+
+  # (1 + 2)
+  rule(:paren_expression) {
+    left_paren >> conditional_expression >> right_paren
+  }
+
+  # IF(1, 2, 3)
+  # AND(1, 2, ...)
+  rule(:function_call_expression) {
+    (identifier.as(:name) >> paren_variable_list.as(:variable_list)).as(:function_call) |
+    atom
+  }
+
+  # 1 * 2
+  rule(:multiplicative_expression) {
+    function_call_expression.as(:left) >> 
+      (multiply | divide | modulus) >> 
+      multiplicative_expression.as(:right) |
+    function_call_expression
+  }
+
+  # 1 + 2
+  rule(:additive_expression) {
+    multiplicative_expression.as(:left) >> 
+      (add | subtract) >> 
+      additive_expression.as(:right) |
+    multiplicative_expression
+  }
+
+  # 1 < 2
+  # 1 > 2
+  # 1 <= 2
+  # 1 >= 2
+  rule(:relational_expression) {
+    additive_expression.as(:left) >> 
+      (less | greater | less_equal | greater_equal) >>
+      relational_expression.as(:right) |
+    additive_expression
+  }
+
+  # 1 == 2
+  rule(:equality_expression) {
+    relational_expression.as(:left) >>
+      (equal | not_equal) >>
+      equality_expression.as(:right) |
+    relational_expression
+  }
+
+  # 1 && 2
+  rule(:logical_and_expression) {
+    equality_expression.as(:left) >>
+      (logical_and | string_and) >>
+      logical_and_expression.as(:right) |
+    equality_expression
+  }
+
+  # 1 || 2
+  rule(:logical_or_expression) {
+    logical_and_expression.as(:left) >>
+      (logical_or | string_or) >>
+      logical_or_expression.as(:right) |
+    logical_and_expression
+  }
+
+  # 1 > 2 ? 3 : 4
+  rule(:conditional_expression) {
+    logical_or_expression.as(:condition) >> 
+      question_mark >> 
+      conditional_expression.as(:true) >> 
+      colon >> 
+      conditional_expression.as(:false) | 
+    logical_or_expression
+  }
+
+  # 'a' = 1
+  # We don't allow for nested assignments:
+  # IF('a' = 1, 1, 2)
+  rule(:assignment_expression) {
+    (variable.as(:identifier) >> 
+      assign >> 
+      assignment_expression.as(:value)).as(:assign) |
+    conditional_expression
+  }
+
+  rule(:expression) {
+    assignment_expression
+  }
+
+  rule(:expressions) {
+    expression >> (separator >> expressions).repeat
+  }
+
+  rule(:function_body) {
+    expressions.as(:expressions)
+  }
+
+  rule(:function_definition_expression) {
+    (str('DEFINE') >> spaces? >> identifier.as(:name) >>
+         paren_argument_list.as(:argument_list) >>
+         left_brace >> function_body.as(:body) >> right_brace).as(:function_definition) |
+    expressions.as(:expressions)
+  }
+
+  rule(:function_definition_expressions) {
+    function_definition_expression >> separator.maybe >> function_definition_expressions.repeat
+  }
+
+  rule(:commands) {
+    function_definition_expressions | expressions
+  }
+
+  rule(:line) {
+    commands.as(:commands)
+  }
+
+  rule(:lines) {
+    line >> (new_line >> lines).repeat
+  }
+
+  root :lines
+end
+

data/lib/kalc/interpreter.rb

@@ -0,0 +1,119 @@
+# Code inspired by https://github.com/txus/schemer
+
+require 'pp'
+
+module Kalc
+  class Interpreter
+
+    attr_reader :env
+
+    def initialize
+      @env = Environment.new do |env|
+
+        env.add_function(:IF, lambda { |cxt, cond, if_true, if_false|
+          cond.eval(cxt) ? if_true.eval(cxt) : if_false.eval(cxt)
+        })
+
+        env.add_function(:OR, lambda { |cxt, *args|
+          retval = false
+          args.each do |arg|
+            if arg.eval(cxt) == true
+              retval = true
+              break
+            end
+          end
+          retval
+        })
+
+        env.add_function(:NOT, lambda { |cxt, val|  
+          !val.eval(cxt)
+        })
+
+        env.add_function(:AND, lambda { |cxt, *args|
+          retval = true
+          args.each do |arg|
+            if arg.eval(cxt) == false
+              retval = false
+              break
+            end
+          end
+          retval
+        })
+
+        # Math
+        env.add_function(:ABS, lambda { |cxt, val|
+          val.eval(cxt).abs
+        })
+
+        env.add_function(:DEGREES, lambda { | cxt, val|  
+          val.eval(cxt) * (180.0 / Math::PI)
+        })
+
+        env.add_function(:PRODUCT, lambda { |cxt, *args|  
+          args.map { |a| a.eval(cxt) }.inject(:*)
+        })
+
+        env.add_function(:RADIANS, lambda { |cxt, val|  
+          val.eval(cxt) * (Math::PI / 180.0)
+        })
+
+        env.add_function(:ROUND, lambda { |cxt, num, digits|  
+          num.eval(cxt).round(digits.eval(cxt))
+        })
+
+        env.add_function(:SUM, lambda { |cxt, *args|  
+          args.map { |a| a.eval(cxt) }.inject(:+)
+        })
+
+        env.add_function(:TRUNC, lambda { |cxt, val|  
+          Integer(val.eval(cxt))
+        })
+
+        env.add_function(:LN, lambda { |cxt, val|
+          Math.log(val.eval(cxt))
+        })
+
+        math_funs = 
+          [ 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh',
+            'cbrt', 'cos', 'cosh',
+            'erf', 'erfc', 'exp',
+            'log', 'log2', 'log10',
+            'sin', 'sinh', 'sqrt',
+            'tan', 'tanh',
+             ]
+
+        math_funs.each do |math_fun|
+          env.add_function(math_fun.upcase.to_sym, lambda { |cxt, val|
+            Math.send(math_fun.to_sym, val.eval(cxt))
+          })
+        end
+
+        env.add_function(:P, lambda { |cxt, *output|  
+          p output
+        })
+
+        env.add_function(:PP, lambda { |cxt, *output|  
+          pp output
+        })
+
+        env.add_function(:PUTS, lambda { |cxt, output|  
+          puts output.eval(cxt)
+        })
+
+      end
+
+    end
+
+    def load_stdlibs(grammar, transform)
+      stdlib = "#{File.dirname(__FILE__)}/stdlib.kalc"
+      input = File.read(stdlib)
+      g = grammar.parse(input)
+      ast = transform.apply(g)
+      run(ast)
+    end
+
+    def run(ast)
+      ast.eval(@env)
+    end
+  end
+end

data/lib/kalc/repl.rb

@@ -0,0 +1,76 @@
+require 'readline'
+require 'pp'
+
+require 'parslet/convenience'
+
+module Kalc
+  class Repl
+
+    def run
+
+      puts heading
+
+      puts "= Loading grammar"
+      @grammar = Kalc::Grammar.new
+
+      puts "= Loading transform"
+      @transform = Kalc::Transform.new
+
+      puts "= Loading interpreter"
+      @interpreter = Kalc::Interpreter.new
+      @interpreter.load_stdlibs(@grammar, @transform)
+
+      puts "You are ready to go.  Have fun!"
+      puts ""
+
+      ast = nil
+
+      function_list = [
+        'quit', 'exit', 'functions', 'variables', 'ast'
+      ] + @interpreter.env.functions.map { |f| f.first }
+
+      begin
+        comp = proc { |s| function_list.grep( /^#{Regexp.escape(s)}/ ) }
+        Readline.completion_append_character = ""
+        Readline.completion_proc = comp
+
+        while input = Readline.readline("kalc-#{Kalc::VERSION} > ", true)
+          begin
+            case
+            when (input == 'quit' || input == 'exit')
+              break
+            when input == "functions"
+              puts @interpreter.env.functions.map { |f| f.first }.join(", ")
+            when input == 'variables'
+              puts @interpreter.env.variables.map { |v| "#{v[0]} = #{v[1]}" }.join("\n\r")
+            when input == 'ast'
+              pp ast
+            when input != ""
+              g = @grammar.parse_with_debug(input)
+              ast = @transform.apply(g)
+              puts @interpreter.run(ast)
+            end
+          rescue Parslet::ParseFailed => e
+            puts e, g.root.error_tree
+          rescue Exception => e
+            puts e
+            puts e.backtrace
+          end
+        end
+      rescue Exception => e
+        puts e
+        puts e.backtrace
+      end
+    end
+
+    def heading
+      %q{
+This is Kalc, a small line-based language.
+More information about Kalc can be found at https://github.com/mrcsparker/kalc.
+
+Kalc is free software, provided as is, with no warranty.
+      }
+    end
+
+  end
+end

data/lib/kalc/stdlib.kalc

@@ -0,0 +1,17 @@
+DEFINE SQUARE(x) {
+  x * x * x
+}
+
+DEFINE FIB(x) {
+  IF(x == 0, 0, IF(x == 1, 1, (FIB(x - 1) + FIB(x - 2))))
+}
+
+DEFINE FACTORIAL(x) {
+  IF(x == 0, 1, (x * FACTORIAL(x - 1)))
+}
+
+DEFINE TOWERS_OF_HANOI(x) {
+  IF(x == 1, 1, (2 * TOWERS_OF_HANOI(x - 1) + 1))
+}
+
+

data/lib/kalc/transform.rb

@@ -0,0 +1,75 @@
+module Kalc
+  class Transform < Parslet::Transform
+    
+    rule(:commands => sequence(:commands)) {
+      Ast::Commands.new(commands)
+    }
+
+    rule(:commands => simple(:commands)) {
+      Ast::Commands.new([commands])
+    }
+
+    rule(:expressions => sequence(:expressions)) {
+      Ast::Expressions.new(expressions)
+    }
+
+    rule(:expressions => simple(:expressions)) {
+      Ast::Expressions.new([expressions])
+    }
+   
+    rule(:string => simple(:string)) {
+      Ast::StringValue.new(string)
+    }
+
+    rule(:boolean => simple(:boolean)) {
+      Ast::BooleanValue.new(boolean)
+    }
+
+    rule(:number => simple(:number)) { 
+      Ast::FloatingPointNumber.new(number) 
+    }
+
+    rule(:left => simple(:left), :right => simple(:right), :operator => simple(:operator)) { 
+      Ast::Arithmetic.new(left, right, operator)
+    }
+
+    rule(:condition => simple(:condition), :true => simple(:true_cond), :false => simple(:false_cond)) { 
+      Ast::Conditional.new(condition, true_cond, false_cond)
+    }
+
+    rule(:variable => simple(:variable)) {
+      Ast::Variable.new(variable)
+    }
+
+    rule(:identifier => simple(:identifier)) {
+      identifier
+    }
+
+    rule(:assign => {:value => simple(:value), :identifier => simple(:identifier), :operator => simple(:operator)}) {
+      Ast::Identifier.new(identifier, value)
+    }
+
+    rule(:paren_list => sequence(:paren_list)) {
+      paren_list
+    }
+
+    rule(:paren_list => "()") {
+      []
+    }
+
+    rule(:function_call => {:name => simple(:name),
+         :variable_list => sequence(:variable_list)}) {
+      Ast::FunctionCall.new(name, variable_list)
+    }
+
+    rule(:argument => simple(:argument)) {
+      Ast::Identifier.new(argument, argument)
+    }
+
+    rule(:function_definition => {:name => simple(:name),
+         :argument_list => sequence(:argument_list),
+         :body => simple(:body)}) {
+      Ast::FunctionDefinition.new(name, argument_list, body)
+    }
+  end
+end

data/lib/kalc/version.rb

@@ -0,0 +1,3 @@
+module Kalc
+  VERSION = "0.3"
+end

data/spec/grammar_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+describe Kalc::Grammar do
+  let(:grammar) { Kalc::Grammar.new }
+
+  context "integers" do
+    1.upto(10) do |i|
+      it { grammar.should parse("#{i}") }
+    end
+  end
+
+  context "floats" do
+    1.upto(10) do |i|
+      1.upto(10) do |n|
+        it { grammar.should parse("#{i}.#{n}") }
+      end
+    end
+  end
+
+  context "basic integer math" do
+    1.upto(10) do |i|
+      it { grammar.should parse("#{i} - #{i}") }
+      it { grammar.should parse("#{i} + #{i}") }
+      it { grammar.should parse("#{i} * #{i}") }
+      it { grammar.should parse("#{i} / #{i}") }
+      it { grammar.should parse("#{i} % #{i}") }
+    end
+  end
+
+  context "basic float math" do
+    1.upto(10) do |i|
+      1.upto(10) do |n|
+        it { grammar.should parse("#{i}.#{n} - #{i}.#{n}") }
+        it { grammar.should parse("#{i}.#{n} + #{i}.#{n}") }
+        it { grammar.should parse("#{i}.#{n} * #{i}.#{n}") }
+        it { grammar.should parse("#{i}.#{n} / #{i}.#{n}") }
+        it { grammar.should parse("#{i}.#{n} % #{i}.#{n}") }
+      end
+    end
+  end
+
+  context "Logical expressions" do
+    it { grammar.should parse("3 && 1") }
+    it { grammar.should_not parse("&& 1") }
+
+    it { grammar.should parse("3 || 1") }
+    it { grammar.should_not parse("|| 1") }
+  end
+
+  context "Comparison expressions" do
+    it { grammar.should parse("3 > 1") }
+    it { grammar.should parse("3 < 1") }
+    it { grammar.should parse("3 >= 1") }
+    it { grammar.should parse("3 <= 1") }
+
+    it { grammar.should_not parse("> 1") }
+    it { grammar.should_not parse("< 1") }
+    it { grammar.should_not parse(">= 1") }
+    it { grammar.should_not parse("<= 1") }
+  end
+
+  context "Equality" do
+    it { grammar.should parse("3 == 1") }
+    it { grammar.should parse("2 != 1") }
+  end
+
+  context "Block" do
+    it { grammar.should parse("(2 + 1)") }
+    it { grammar.should parse("(2 + 1) + 1") }
+    it { grammar.should parse("(2 + 1) * (1 / 2) + 3") }
+    it { grammar.should parse("(2 + 1) + (1 + 2) + ((3 + 2) / (2 + 1)) * 9") }
+    it { grammar.should parse("(2 + 1) - (1)") }
+    it { grammar.should parse("(2 ) + (  1)") }
+    it { grammar.should parse("((2) + (    1 ))") }
+  end
+
+  context "Ternary expressions" do
+    it { grammar.should parse("3 > 2 ? 1 : 5") }
+    it { grammar.should parse("3 > 2 || 4 <= 5 ? 1 : 5") }
+    it { grammar.should parse("(3 > (2 + 4)) ? 1 : 5") }
+    it { grammar.should parse("IF(2 > 3, 3 > 2 ? 1 : 5, 7)") }
+    it { grammar.should parse("3 > 2 ? 1 : 5 > 4 ? 7 : 5") }
+  end
+
+  context "AND statements" do
+    it { grammar.should parse("AND(1, 2, 3)") }
+    it { grammar.should parse("AND(1, 2, 3, 4, 5, 6)") }
+    it { grammar.should parse("AND(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)") }
+  end
+
+  context "OR statements" do
+    it { grammar.should parse("OR(1, 2, 3)") }
+    it { grammar.should parse("OR(1, 2, 3, 4, 5, 6)") }
+    it { grammar.should parse("OR(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)") }
+  end
+
+  context "IF statements" do
+    it { grammar.should parse("IF(3, 2, 1)") }
+    it { grammar.should parse("IF(3 > 1, 2, 1)") }
+    it { grammar.should parse("IF((3 > 1) || (2 < 1), 2, 1)") }
+    it { grammar.should parse("IF(OR(1 > 3, 2 < 5), 3, 2)") }
+  end
+
+  context "Nested IF statements" do
+    it { grammar.should parse("IF(3 > 2, IF(2 < 3, 1, 3), 5)") }
+    it { grammar.should parse("IF(3 > 2, IF(2 < 3, 1, 3), IF(5 > 1, 3, 9))") }
+  end
+
+end

data/spec/interpreter_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Kalc::Interpreter do
+  before(:each) do
+    @grammar = Kalc::Grammar.new
+    @transform = Kalc::Transform.new
+  end
+
+  it { evaluate("2 + 2").should == 4 }
+  it { evaluate("1 + 1").should == 2.0 }
+  it { evaluate("4 + 1").should == 5 }
+  it { evaluate("5 + 5").should == 10 }
+
+  it { evaluate("10 > 9").should == true }
+  it { evaluate("10 < 9").should == false }
+
+  it { evaluate("10 + 19 + 11 * 3").should == 62 }
+
+  it { evaluate("10 >= 10").should == true }
+
+  private
+  def evaluate(expression)
+    g = @grammar.parse(expression)
+    ast = @transform.apply(g)
+    Kalc::Interpreter.new.run(ast)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'parslet'
+require 'parslet/rig/rspec'
+require 'kalc'

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: kalc
+version: !ruby/object:Gem::Version
+  version: '0.3'
+  prerelease: 
+platform: ruby
+authors:
+- Chris Parker
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70212126361020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70212126361020
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70212126360600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70212126360600
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: &70212126360100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70212126360100
+description: Calculation language slightly based on Excel's formula language.
+email:
+- mrcsparker@gmail.com
+executables:
+- ikalc
+- kalc
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.textile
+- bin/ikalc
+- bin/kalc
+- kalc.gemspec
+- lib/kalc.rb
+- lib/kalc/ast.rb
+- lib/kalc/environment.rb
+- lib/kalc/grammar.rb
+- lib/kalc/interpreter.rb
+- lib/kalc/repl.rb
+- lib/kalc/stdlib.kalc
+- lib/kalc/transform.rb
+- lib/kalc/version.rb
+- spec/grammar_spec.rb
+- spec/interpreter_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/mrcsparker/kalc
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: kalc
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Small calculation language.
+test_files:
+- spec/grammar_spec.rb
+- spec/interpreter_spec.rb
+- spec/spec_helper.rb