trxl 0.1.5 → 0.1.8

data/README

@@ -20,11 +20,19 @@
 6)  Built in functions:
     HELP,ENV,SIZE,SPLIT,ROUND,MIN,MAX
     SUM,MULT,AVG, PRINT, PRINT_LINE
-    TO_INT, TO_FLOAT, TO_ARRAY
+    TO_INT, TO_FLOAT, TO_ARRAY, AVG_SUM
+    MATCHING_IDS, VALUES_OF_TYPE
 -----------------------------------------
 7)  Standard library functions:
-    Use to iterate over Arrays or Strings
-    FOREACH_IN, INJECT
+    foreach_in, inject, map, select
+    reject, in_groups_of, sum_of_type
+    avg_sum_of_type, avg_range_sum_of_type
+    total_range_sum_of_type, ratio
+    year_from_date, month_from_date,
+    hash_values, hash_value_sum,
+    avg_hash_value_sum, hash_range_values,
+    hash_range_value_sum,
+    avg_hash_range_value_sum
 -----------------------------------------
 8)  Access the current environment:
     ENV; (your output may differ)
@@ -129,10 +137,12 @@
 17) case expressions:
     foo = fun(x) {
       case x
-      when 0 then 0
-      when 1 then 1
-      when 2 then 2
-      else 3
+      when NULL then NULL
+      when 0    then 0
+      when 1    then 1
+      when 2    then 2
+      else          
+        3
       end
     }
     foo(1);

data/VERSION

@@ -1 +1 @@
-0.1.5
+0.1.8

data/lib/trxl.rb

@@ -2,4 +2,4 @@ require "rubygems"
 require "treetop"
 
 require 'trxl/trxl'
-require 'trxl/trxl_grammar'
+require 'trxl/trxl_grammar'

data/lib/trxl/trxl.rb

@@ -1,65 +1,54 @@
-# load treetop grammar
-# this is done independent of RAILS_ROOT to allow easy
-# speccing outside of rails context
-# TODO once stable, replace this with a simple require
+module Trxl
 
+  class TrxlException                   < Exception;       end
+  class InternalError                   < TrxlException;   end
+  class FatalParseError                 < TrxlException;   end
+  class DivisionByZeroError             < FatalParseError; end
+  class MissingFormulaException         < TrxlException;   end
+  class MissingVariableException        < TrxlException;   end
+  class InvalidOperationException       < TrxlException;   end
+  class InvalidArgumentException        < TrxlException;   end
+  class WrongNumberOfArgumentsException < TrxlException;   end
+  class MissingLibraryException         < TrxlException;   end
+  class NotImplementedException         < TrxlException;   end
+  class ExitScopeNotAllowedException    < TrxlException;   end
 
-# reopen treetop generated module
-module Trxl
-  
-  class TrxlException < Exception; end
-  class InternalError < TrxlException; end
-  class FatalParseError < TrxlException; end
-  class DivisionByZeroError < FatalParseError; end
-  class MissingFormulaException < TrxlException; end
-  class MissingVariableException < TrxlException; end
-  class InvalidOperationException < TrxlException; end
-  class InvalidArgumentException < TrxlException; end
-  class WrongNumberOfArgumentsException < TrxlException; end
-  
-  class MissingLibraryException < TrxlException; end
-  class NotImplementedException < TrxlException; end
-  
-  class ExitScopeNotAllowedException < TrxlException; end
-  
   class Assignment < Treetop::Runtime::SyntaxNode; end
-  class Variable < Treetop::Runtime::SyntaxNode; end
-  
-  
-  
+  class Variable   < Treetop::Runtime::SyntaxNode; end
+
   class Environment
-    
+
     # called when parsing starts
     def initialize(local_env = {})
       @stack = [ local_env ]
     end
-    
+
     def enter_scope
       push #peek.dup
     end
-    
+
     def exit_scope
       pop
     end
-    
+
     def local
       peek
     end
-    
-    
+
+
     def depth
       @stack.size
     end
-    
+
     def merge(other_env)
       self.class.new(local.merge(other_env))
     end
-    
+
     def merge!(other_env)
       local.merge!(other_env); self
     end
-    
-    
+
+
     def [](variable)
       var = variable.to_sym
       @stack.each do |env|
@@ -76,52 +65,52 @@ module Trxl
       # search all scopes
       @stack.each do |env|
         if env.has_key?(var)
-          return env[var] = value 
+          return env[var] = value
         end
       end
       # not found, assign it in local scope
       local[var] = value
     end
-    
+
     def to_s
       @stack.inject([]) do |stack, env|
         stack << env.inspect
       end.join(',')
     end
-    
+
     def empty?
       @stack.size == 1 ? peek.empty? : @stack.all? { |h| h.empty? }
     end
-    
+
     def has_key?(key)
       @stack.any? { |env| env.has_key?(key.to_sym) }
     end
-    
+
     def select(&block)
       @stack.inject([]) do |memo, env|
         memo << env.select(&block)
       end[0]
     end
-    
+
     def add_library(name)
       (@libraries || []) << name.to_sym
     end
-    
+
     def library_included?(name)
       @libraries ? @libraries.include?(name.to_sym) : false
     end
-    
+
     def libraries
       @libraries.dup # don't allow modifications outside
     end
-    
+
     protected
-    
+
     # called when a new scope is entered
     def push(local_env = {})
       @stack.insert(0, local_env)
     end
-    
+
     # called when a scope is left
     def pop
       if depth > 1
@@ -130,16 +119,16 @@ module Trxl
         raise Trxl::ExitScopeNotAllowedException, "cannot pop toplevel environment"
       end
     end
-    
+
     # always the local environment
     def peek
       @stack[0]
     end
-    
+
   end
-  
+
   class Function < Treetop::Runtime::SyntaxNode
-    
+
     class Closure
       attr_reader :env, :function
 
@@ -168,37 +157,37 @@ module Trxl
       text_value #eval(env).to_s(env)
     end
   end
-  
+
   class BinaryOperation < Treetop::Runtime::SyntaxNode
-    
+
     def eval(env = Environment.new)
       apply(operand_1.eval(env), operand_2.eval(env))
     end
-    
+
     def apply(a, b)
       operator.apply(a, b)
     end
-    
+
     def to_s(env = Environment.new)
       "#{operand_1.to_s(env)} #{operator.text_value} #{operand_2.to_s(env)}"
     end
-    
+
   end
-  
+
   module BinaryOperatorSupport
 
     def lhs_nil_allowed?
       raise InternalError, "Implement BinaryOperaterSupport#lhs_nil_allowed?"
     end
-    
+
     def rhs_nil_allowed?
       raise InternalError, "Implement BinaryOperaterSupport#rhs_nil_allowed?"
     end
-    
+
     def nils_allowed?
       lhs_nil_allowed? && rhs_nil_allowed?
     end
-    
+
     def apply(a, b)
       if a.nil?
         if b.nil?
@@ -224,9 +213,9 @@ module Trxl
         else
           perform_apply(a, b)
         end
-      end 
+      end
     end
-    
+
     def perform_apply(a, b)
       if a.respond_to?(ruby_operator)
         a.send(ruby_operator, b)
@@ -236,52 +225,52 @@ module Trxl
         eval "#{_a} #{ruby_operator} #{_b}"
       end
     end
-    
+
     def ruby_operator
       text_value
     end
-    
+
   end
-  
+
   class NilRejectingOperator < Treetop::Runtime::SyntaxNode
-    
+
     include BinaryOperatorSupport
-    
+
     def lhs_nil_allowed?
       false
     end
-    
+
     def rhs_nil_allowed?
       false
     end
-    
+
   end
-  
+
   class NilAcceptingOperator < Treetop::Runtime::SyntaxNode
-    
+
     include BinaryOperatorSupport
-    
+
     def lhs_nil_allowed?
       true
     end
-    
+
     def rhs_nil_allowed?
       true
     end
-    
+
   end
-  
-  
+
+
   class OffsetAccessExpression < Treetop::Runtime::SyntaxNode
-    
+
     def left_associative_apply(ruby_object, offsets)
       offsets.inject(ruby_object) { |obj, offset| obj = obj[offset] }
     end
-      
+
   end
-  
+
   class RequireDirective < Treetop::Runtime::SyntaxNode
-    
+
     def eval(env = Environment.new)
       library = ((l = load_library(env))[-1..-1]) == ';' ? "#{l} ENV" : "#{l}; ENV"
       unless env.library_included?(identifier(env))
@@ -290,12 +279,12 @@ module Trxl
       end
       env
     end
-    
+
     def identifier(env = Environment.new)
       @identifier ||= string_literal.eval(env)
     end
-    
-    # override this in subclasses    
+
+    # override this in subclasses
     def load_library(env = Environment.new)
       path = identifier(env).split('/')
       if path[0] == ('stdlib')
@@ -317,28 +306,25 @@ module Trxl
         raise NotImplementedException, "Only require 'stdlib' is supported"
       end
     end
-    
+
     def optimize_stdlib_access?
       true
     end
-      
+
   end
-  
-  
-  # This module exists only for performance reason.
-  # Loading the stdlib directly from a ruby object,
-  # should be much faster than loading it from a file.
-  
+
   module StdLib
-    
+
     FOREACH_IN = <<-PROGRAM
       foreach_in = fun(enumerable, body) {
-        _foreach_in_(enumerable, body, 0);
+        if(SIZE(enumerable) > 0)
+          __foreach_in__(enumerable, body, 0)
+        end
       };
-      _foreach_in_ = fun(enumerable, body, index) {
+      __foreach_in__ = fun(enumerable, body, index) {
         if(index < SIZE(enumerable) - 1)
           body(enumerable[index]);
-          _foreach_in_(enumerable, body, index + 1)
+          __foreach_in__(enumerable, body, index + 1)
         else
           body(enumerable[index])
         end
@@ -347,11 +333,15 @@ module Trxl
 
     INJECT = <<-PROGRAM
       inject = fun(memo, enumerable, body) {
-        _inject_(memo, enumerable, body, 0);
+        if(SIZE(enumerable) > 0)
+          __inject__(memo, enumerable, body, 0)
+        else
+          memo
+        end
       };
-      _inject_ = fun(memo, enumerable, body, index) {
+      __inject__ = fun(memo, enumerable, body, index) {
         if(index < SIZE(enumerable) - 1)
-          _inject_(body(memo, enumerable[index]), enumerable, body, index + 1)
+          __inject__(body(memo, enumerable[index]), enumerable, body, index + 1)
         else
           body(memo, enumerable[index])
         end
@@ -361,44 +351,44 @@ module Trxl
     MAP = <<-PROGRAM
       require 'stdlib/inject';
       map = fun(enumerable, body) {
-        b = body; # WORK AROUND a bug in Trxl::Environment
-        inject([], enumerable, fun(memo, e) { memo << b(e); });
+        __body__ = body; # WORK AROUND a bug in Trxl::Environment
+        inject([], enumerable, fun(memo, e) { memo << __body__(e); });
       };
     PROGRAM
 
     SELECT = <<-PROGRAM
       require 'stdlib/inject';
       select = fun(enumerable, body) {
-        b = body; # WORK AROUND a bug in Trxl::Environment
-        inject([], enumerable, fun(selected, value) { 
-          if(b(value))
+        __body__ = body; # WORK AROUND a bug in Trxl::Environment
+        inject([], enumerable, fun(selected, value) {
+          if(__body__(value))
             selected << value
           else
             selected
-          end 
+          end
         });
       };
     PROGRAM
-    
+
     REJECT = <<-REJECT
       require 'stdlib/inject';
       reject = fun(enumerable, filter) {
-        f = filter; # WORKAROUND for a bug in Trxl::Environment
+        __filter__ = filter; # WORKAROUND for a bug in Trxl::Environment
         inject([], enumerable, fun(rejected, value) {
-          if(f(value)) 
+          if(__filter__(value))
             rejected
           else
             rejected << value
-          end 
+          end
         })
       };
     REJECT
-    
+
     IN_GROUPS_OF = <<-IN_GROUPS_OF
       require 'stdlib/foreach_in';
       require 'stdlib/inject';
       in_groups_of = fun(size_of_group, enumerable, group_function) {
-        count = 0; groups = []; cur_group = []; 
+        count = 0; groups = []; cur_group = [];
         foreach_in(enumerable, fun(element) {
           if(count < size_of_group)
             cur_group << element;
@@ -418,7 +408,54 @@ module Trxl
         });
       };
     IN_GROUPS_OF
-    
+
+    HASH_VALUES = <<-HASH_VALUES
+      require 'stdlib/map';
+      hash_values = fun(hash) {
+        map(TO_ARRAY(hash), fun(pair) { pair[1] });
+      };
+    HASH_VALUES
+
+    HASH_VALUE_SUM = <<-VALUE_SUM
+      require 'stdlib/hash_values';
+      hash_value_sum = fun(hash) {
+        SUM(hash_values(hash))
+      };
+    VALUE_SUM
+
+    AVG_HASH_VALUE_SUM = <<-AVG_HASH_VALUE_SUM
+      require 'stdlib/hash_values';
+      avg_hash_value_sum = fun(hash) {
+        AVG_SUM(hash_values(hash))
+      };
+    AVG_HASH_VALUE_SUM
+
+    HASH_RANGE_VALUES = <<-HASH_RANGE_VALUES
+      require 'stdlib/foreach_in';
+      require 'stdlib/hash_values';
+      hash_range_values = fun(hash_range) {
+        inject([], hash_range, fun(values, hash_variable) {
+          values << hash_values(ENV[hash_variable]);
+        });
+      };
+    HASH_RANGE_VALUES
+
+    HASH_RANGE_VALUE_SUM = <<-HASH_RANGE_VALUE_SUM
+      require 'stdlib/hash_range_values';
+      hash_range_value_sum = fun(hash_range) {
+        SUM(hash_range_values(hash_range))
+      };
+    HASH_RANGE_VALUE_SUM
+
+    AVG_HASH_RANGE_VALUE_SUM = <<-AVG_HASH_RANGE_VALUE_SUM
+      require 'stdlib/hash_range_values';
+      avg_hash_range_value_sum = fun(hash_range) {
+        inject(0, hash_range_values(hash_range), fun(sum, bucket) {
+          sum + AVG_SUM(bucket);
+        });
+      };
+    AVG_HASH_RANGE_VALUE_SUM
+
     SUM_OF_TYPE = <<-SUM_OF_TYPE
       sum_of_type = fun(type, all_types, all_values) {
         SUM(VALUES_OF_TYPE(type, all_types, all_values));
@@ -435,22 +472,31 @@ module Trxl
       require 'stdlib/inject';
       require 'stdlib/avg_sum_of_type';
       avg_range_sum_of_type = fun(type, all_types, variable_range) {
-        inject(0, variable_range, fun(sum, variable) { 
-          sum + avg_sum_of_type(type, all_types, ENV[variable]) 
+        inject(0, variable_range, fun(sum, variable) {
+          sum + avg_sum_of_type(type, all_types, ENV[variable])
         });
       };
     AVG_RANGE_SUM_OF_TYPE
-    
+
     TOTAL_RANGE_SUM_OF_TYPE = <<-TOTAL_RANGE_SUM_OF_TYPE
       require 'stdlib/inject';
       require 'stdlib/sum_of_type';
       total_range_sum_of_type = fun(type, all_types, variable_range) {
-        inject(0, variable_range, fun(sum, variable) { 
-          sum + sum_of_type(type, all_types, ENV[variable]) 
+        inject(0, variable_range, fun(sum, variable) {
+          sum + sum_of_type(type, all_types, ENV[variable])
         });
       };
     TOTAL_RANGE_SUM_OF_TYPE
 
+    AVG_RANGE_SUM = <<-AVG_RANGE_SUM
+      require 'stdlib/inject';
+      avg_range_sum = fun(variable_range) {
+        inject(0, variable_range, fun(sum, variable) {
+          sum + AVG_SUM(ENV[variable])
+        });
+      };
+    AVG_RANGE_SUM
+
     YEAR_FROM_DATE = <<-YEAR_FROM_DATE
       year_from_date = fun(date) {
         date = SPLIT(date, '/');
@@ -469,7 +515,7 @@ module Trxl
       require 'stdlib/month_from_date';
       require 'stdlib/year_from_date';
     DATES
-    
+
     RATIO = <<-RATIO
       require 'stdlib/foreach_in';
       ratio = fun(enumerable, true_condition, base_condition) {
@@ -492,14 +538,14 @@ module Trxl
     RATIO
 
   end
-  
-  
+
+
   class Calculator
-    
-    extend StdLib # optimized for performance
-    
+
+    extend StdLib
+
     class << self
-      
+
       def stdlib(function = nil)
         if function
           Kernel.eval("Trxl::StdLib::#{function.to_s.upcase}").strip
@@ -509,7 +555,7 @@ module Trxl
           end.strip
         end
       end
-      
+
     end
 
     def initialize
@@ -523,19 +569,19 @@ module Trxl
         ast
       else
         failure_idx = @parser.failure_index
-        
+
         # extract code snippet where parse error happened
         start = ((idx = failure_idx - 12) < 0 ? 0 : idx)
         stop  = ((idx = failure_idx + 12) > code.size ? code.size : idx)
         local_code = code.slice(start..stop).to_s.gsub(/\n|\r/, "")
-        
+
         msg =  "Parse Error at index #{failure_idx} (showing excerpt):\n"
         msg << "... #{local_code} ...\n"
-        
+
         # mark the exact offset where the parse error happened
         offset = (start == 0) ? failure_idx + 4 : 16
         offset.times { msg << ' '}; msg << "^\n"
-        
+
         if verbose
           # show the originial trxl program
           msg << "Original Code:\n#{code}\n\n"
@@ -559,27 +605,27 @@ module Trxl
     end
 
   end
-  
+
   class Interpreter
-    
+
     attr_accessor :parser, :program, :env
-    
+
     def initialize
       @parser = Calculator.new
       @program = []
       @env = env
     end
-    
+
     def stash(loc)
       @program << loc
     end
-    
+
     def eval(env = [])
       @parser.eval(@program.join(' '), env)
     end
-    
+
   end
-  
+
 end