trxl 0.1.8 → 0.1.9

data/VERSION

@@ -1 +1 @@
-0.1.8
+0.1.9

data/lib/trxl/trxl_grammar.rb

@@ -4857,16 +4857,26 @@ module Trxl
                                   if r16
                                     r0 = r16
                                   else
-                                    r17 = _nt_matching_ids_function
+                                    r17 = _nt_compact_function
                                     if r17
                                       r0 = r17
                                     else
-                                      r18 = _nt_values_of_type_function
+                                      r18 = _nt_is_empty_function
                                       if r18
                                         r0 = r18
                                       else
-                                        @index = i0
-                                        r0 = nil
+                                        r19 = _nt_matching_ids_function
+                                        if r19
+                                          r0 = r19
+                                        else
+                                          r20 = _nt_values_of_type_function
+                                          if r20
+                                            r0 = r20
+                                          else
+                                            @index = i0
+                                            r0 = nil
+                                          end
+                                        end
                                       end
                                     end
                                   end
@@ -4923,7 +4933,8 @@ module Trxl
       help << "    HELP,ENV,SIZE,SPLIT,ROUND,MIN,MAX\n"
       help << "    SUM, MULT, AVG, PRINT, PRINT_LINE\n"
       help << "    TO_INT, TO_FLOAT, TO_ARRAY, AVG_SUM\n"
-      help << "    MATCHING_IDS, VALUES_OF_TYPE\n"
+      help << "    MATCHING_IDS, VALUES_OF_TYPE, COMPACT\n"
+      help << "    IS_EMPTY\n"
       help << "-----------------------------------------\n"
       help << "7)  Standard library functions:\n"
       help << "    foreach_in, inject, map, select\n"
@@ -6694,6 +6705,344 @@ module Trxl
     r0
   end
 
+  module CompactFunction0
+    def space1
+      elements[1]
+    end
+
+    def space2
+      elements[3]
+    end
+
+    def expression
+      elements[4]
+    end
+
+    def space3
+      elements[5]
+    end
+
+  end
+
+  module CompactFunction1
+    def eval(env = Environment.new)
+      arr = expression.eval(env)
+      arr.compact
+    end
+  end
+
+  module CompactFunction2
+    def space1
+      elements[1]
+    end
+
+    def space2
+      elements[3]
+    end
+
+  end
+
+  module CompactFunction3
+    def eval(env = Environment.new)
+      []
+    end
+  end
+
+  def _nt_compact_function
+    start_index = index
+    if node_cache[:compact_function].has_key?(index)
+      cached = node_cache[:compact_function][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    i1, s1 = index, []
+    if has_terminal?('COMPACT', false, index)
+      r2 = instantiate_node(SyntaxNode,input, index...(index + 7))
+      @index += 7
+    else
+      terminal_parse_failure('COMPACT')
+      r2 = nil
+    end
+    s1 << r2
+    if r2
+      r3 = _nt_space
+      s1 << r3
+      if r3
+        if has_terminal?('(', false, index)
+          r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure('(')
+          r4 = nil
+        end
+        s1 << r4
+        if r4
+          r5 = _nt_space
+          s1 << r5
+          if r5
+            r6 = _nt_expression
+            s1 << r6
+            if r6
+              r7 = _nt_space
+              s1 << r7
+              if r7
+                if has_terminal?(')', false, index)
+                  r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                  @index += 1
+                else
+                  terminal_parse_failure(')')
+                  r8 = nil
+                end
+                s1 << r8
+              end
+            end
+          end
+        end
+      end
+    end
+    if s1.last
+      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+      r1.extend(CompactFunction0)
+      r1.extend(CompactFunction1)
+    else
+      @index = i1
+      r1 = nil
+    end
+    if r1
+      r0 = r1
+    else
+      i9, s9 = index, []
+      if has_terminal?('COMPACT', false, index)
+        r10 = instantiate_node(SyntaxNode,input, index...(index + 7))
+        @index += 7
+      else
+        terminal_parse_failure('COMPACT')
+        r10 = nil
+      end
+      s9 << r10
+      if r10
+        r11 = _nt_space
+        s9 << r11
+        if r11
+          if has_terminal?('(', false, index)
+            r12 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure('(')
+            r12 = nil
+          end
+          s9 << r12
+          if r12
+            r13 = _nt_space
+            s9 << r13
+            if r13
+              if has_terminal?(')', false, index)
+                r14 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                @index += 1
+              else
+                terminal_parse_failure(')')
+                r14 = nil
+              end
+              s9 << r14
+            end
+          end
+        end
+      end
+      if s9.last
+        r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
+        r9.extend(CompactFunction2)
+        r9.extend(CompactFunction3)
+      else
+        @index = i9
+        r9 = nil
+      end
+      if r9
+        r0 = r9
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:compact_function][start_index] = r0
+
+    r0
+  end
+
+  module IsEmptyFunction0
+    def space1
+      elements[1]
+    end
+
+    def space2
+      elements[3]
+    end
+
+    def expression
+      elements[4]
+    end
+
+    def space3
+      elements[5]
+    end
+
+  end
+
+  module IsEmptyFunction1
+    def eval(env = Environment.new)
+      arr = expression.eval(env)
+      arr.empty?
+    end
+  end
+
+  module IsEmptyFunction2
+    def space1
+      elements[1]
+    end
+
+    def space2
+      elements[3]
+    end
+
+  end
+
+  module IsEmptyFunction3
+    def eval(env = Environment.new)
+      true
+    end
+  end
+
+  def _nt_is_empty_function
+    start_index = index
+    if node_cache[:is_empty_function].has_key?(index)
+      cached = node_cache[:is_empty_function][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    i1, s1 = index, []
+    if has_terminal?('IS_EMPTY', false, index)
+      r2 = instantiate_node(SyntaxNode,input, index...(index + 8))
+      @index += 8
+    else
+      terminal_parse_failure('IS_EMPTY')
+      r2 = nil
+    end
+    s1 << r2
+    if r2
+      r3 = _nt_space
+      s1 << r3
+      if r3
+        if has_terminal?('(', false, index)
+          r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure('(')
+          r4 = nil
+        end
+        s1 << r4
+        if r4
+          r5 = _nt_space
+          s1 << r5
+          if r5
+            r6 = _nt_expression
+            s1 << r6
+            if r6
+              r7 = _nt_space
+              s1 << r7
+              if r7
+                if has_terminal?(')', false, index)
+                  r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                  @index += 1
+                else
+                  terminal_parse_failure(')')
+                  r8 = nil
+                end
+                s1 << r8
+              end
+            end
+          end
+        end
+      end
+    end
+    if s1.last
+      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+      r1.extend(IsEmptyFunction0)
+      r1.extend(IsEmptyFunction1)
+    else
+      @index = i1
+      r1 = nil
+    end
+    if r1
+      r0 = r1
+    else
+      i9, s9 = index, []
+      if has_terminal?('IS_EMPTY', false, index)
+        r10 = instantiate_node(SyntaxNode,input, index...(index + 8))
+        @index += 8
+      else
+        terminal_parse_failure('IS_EMPTY')
+        r10 = nil
+      end
+      s9 << r10
+      if r10
+        r11 = _nt_space
+        s9 << r11
+        if r11
+          if has_terminal?('(', false, index)
+            r12 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure('(')
+            r12 = nil
+          end
+          s9 << r12
+          if r12
+            r13 = _nt_space
+            s9 << r13
+            if r13
+              if has_terminal?(')', false, index)
+                r14 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                @index += 1
+              else
+                terminal_parse_failure(')')
+                r14 = nil
+              end
+              s9 << r14
+            end
+          end
+        end
+      end
+      if s9.last
+        r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
+        r9.extend(IsEmptyFunction2)
+        r9.extend(IsEmptyFunction3)
+      else
+        @index = i9
+        r9 = nil
+      end
+      if r9
+        r0 = r9
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:is_empty_function][start_index] = r0
+
+    r0
+  end
+
   module AvgFunction0
     def space1
       elements[0]

data/lib/trxl/trxl_grammar.treetop

@@ -825,6 +825,10 @@ grammar Trxl
     /
     avg_function
     /
+    compact_function
+    /
+    is_empty_function
+    /
     matching_ids_function
     /
     values_of_type_function
@@ -863,7 +867,8 @@ grammar Trxl
         help << "    HELP,ENV,SIZE,SPLIT,ROUND,MIN,MAX\n"
         help << "    SUM, MULT, AVG, PRINT, PRINT_LINE\n"
         help << "    TO_INT, TO_FLOAT, TO_ARRAY, AVG_SUM\n"
-        help << "    MATCHING_IDS, VALUES_OF_TYPE\n"
+        help << "    MATCHING_IDS, VALUES_OF_TYPE, COMPACT\n"
+        help << "    IS_EMPTY\n"
         help << "-----------------------------------------\n"
         help << "7)  Standard library functions:\n"
         help << "    foreach_in, inject, map, select\n"
@@ -1173,6 +1178,36 @@ grammar Trxl
     }
   end
 
+  rule compact_function
+    'COMPACT' space '(' space expression space ')' {
+      def eval(env = Environment.new)
+        arr = expression.eval(env)
+        arr.compact
+      end
+    }
+    /
+    'COMPACT' space '(' space ')' {
+      def eval(env = Environment.new)
+        []
+      end
+    }
+  end
+
+  rule is_empty_function
+    'IS_EMPTY' space '(' space expression space ')' {
+      def eval(env = Environment.new)
+        arr = expression.eval(env)
+        arr.empty?
+      end
+    }
+    /
+    'IS_EMPTY' space '(' space ')' {
+      def eval(env = Environment.new)
+        true
+      end
+    }
+  end
+
   rule avg_function
     'AVG' space '(' space expression more_expressions:( space ',' space expression)* space ')' {
       def eval(env = Environment.new)

data/spec/trxl/builtins_spec.rb

@@ -3,16 +3,16 @@ require 'spec_helper'
 describe "The language" do
 
   include Trxl::SpecHelper
-  
+
   before(:each) do
     @parser = Trxl::Calculator.new
   end
-  
+
   it "should allow to access the current environment by calling ENV" do
     env = eval("ENV", {})
     env.should be_kind_of(Trxl::Environment)
     env.should be_empty
-    
+
     env = eval("ENV", { :a => 1, :b => 2 })
     env.should be_kind_of(Trxl::Environment)
     env.should have_key(:a)
@@ -36,24 +36,24 @@ describe "The language" do
     eval("ENV['a'..'c']", { :a => 1, :b => 2, :c => 3 }).should include(2)
     eval("ENV['a'..'c']", { :a => 1, :b => 2, :c => 3 }).should include(3)
   end
-  
+
   it "should be able to PRINT and PRINT_LINE to STDOUT" do
     eval("PRINT('- This is output from PRINT. ')").should be_nil
     eval("PRINT_LINE('And this is output from PRINT_LINE')").should be_nil
   end
-  
+
   it "should be able to split strings by calling SPLIT(some_string, split_char)" do
     eval("SPLIT('foo/bar', '/')").should == [ 'foo', 'bar' ]
   end
-  
+
   it "should be able to convert values into integers by calling TO_INT(alpha_numeric_string)" do
     eval("TO_INT('1')").should == 1
   end
-  
+
   it "should be able to convert values into floats by calling TO_FLOAT(alpha_numeric_string)" do
     eval("TO_FLOAT('1.12')").should == 1.12
   end
-  
+
   it "should be able to convert values into arrays by calling TO_ARRAY(some_value)" do
     eval("TO_ARRAY(1)").should == [ 1 ]
     eval("TO_ARRAY('1')").should == [ '1' ]
@@ -100,14 +100,14 @@ describe "The language" do
     eval(program).should == 12
     program = "SUM(x)"
     eval(program, { :x => [ 1, 2, 3 ] }).should == 6
-    
+
     program =  "SUM([2,2,2],[4,4,4],[3,3,3])"
     eval(program).should == 27
-    
+
     program =  "SUM([ [2,2,2], [4,4,4], [3,3,3] ])"
     eval(program).should == 27
   end
-  
+
   it "should be able to calculate MULT for an arbitrary number of argument expressions" do
     program =  "MULT()"
     eval(program).should == 0
@@ -126,20 +126,48 @@ describe "The language" do
     program = "MULT(x)"
     eval(program, { :x => [ 1, 2, 3 ] }).should == 6
   end
-  
+
+  it "should provide COMPACT in order to remove NULL values from arrays" do
+    program =  "COMPACT([1])"
+    eval(program).should == [1]
+    program =  "COMPACT([1, NULL])"
+    eval(program).should == [1]
+    program =  "COMPACT([NULL])"
+    eval(program).should == []
+    program =  "COMPACT([NULL, NULL])"
+    eval(program).should == []
+  end
+
+  it "should provide IS_EMPTY in order to test if an array contains elements" do
+    program =  "IS_EMPTY([])"
+    eval(program).should == true
+    program =  "IS_EMPTY([1])"
+    eval(program).should == false
+    program =  "IS_EMPTY([NULL])"
+    eval(program).should == false
+  end
+
   it "should be able to calculate AVG for an arbitrary number of argument expressions" do
     program =  "AVG()"
     eval(program).should == 0
     program =  "AVG(NULL)"
     eval(program).should be_nil
+    program =  "AVG(FALSE, NULL)"
+    eval(program).should be_nil
+    program =  "AVG(NULL, NULL)"
+    eval(program).should be_nil
+    program =  "AVG(FALSE, NULL, NULL)"
+    eval(program).should be_nil
+    program =  "AVG([NULL, NULL])"
+    eval(program).should == 0
+    program =  "AVG(FALSE, [NULL, NULL])"
+    eval(program).should == 0
     program =  "AVG(0)"
     eval(program).should == 0
     program =  "AVG(1)"
     eval(program).should == 1
     program =  "AVG(3,3,3)"
     eval(program).should == 3
-    program =  "AVG(3,3,3)"
-    eval(program).should == 3
     program =  "AVG(3,5,0)"
     eval(program).should be_close(2.66666666666, 0.01)
     program =  "AVG(FALSE, 3,5,0)"
@@ -154,19 +182,19 @@ describe "The language" do
     eval(program).should == 4
     program =  "AVG(fun(){4}(),fun(x){x}(4),fun(x,y){x+y}(2,2))"
     eval(program).should == 4
-    
+
     program =  "AVG([1,2,3],[4,4,4],[6,6,6])"
     eval(program).should == 4
     program =  "AVG([2,2],[4,4,4],[6,6])"
     eval(program).should == 4
   end
-  
+
   it "should be able to calculate AVG_SUM for an arbitrary number of argument expressions" do
     program =  "AVG_SUM([1,2,3],[4,4,4],[6,6,6])"
     eval(program).should == 12
     program =  "AVG_SUM([2,2],[4,4,4],[6,6])"
     eval(program).should == 12
-    
+
     env = {
       :ap => [138542.0, 136795.0, 134256.0], # 136531
       :aq => [124580.0, 21458.0, 34560.0],   #  60199.3333333333
@@ -176,10 +204,10 @@ describe "The language" do
       :au => [250.0, 250.0, 250.0]           #    250
                                              # ------------------
                                              # 206859
-                                             
+
     }
     eval("AVG_SUM(ENV['ap'..'au'])", env).should == 206859
-    
+
     env = {
       :ap => [138542.0, 136795.0, 134256.0], # 136531
       :aq => [124580.0, 21458.0, 34560.0],   #  60199.3333333333
@@ -189,10 +217,10 @@ describe "The language" do
       :au => [0, 0, 0]                       #      0
                                              # ------------------
                                              # 206609
-                                             
+
     }
     eval("AVG_SUM(ENV['ap'..'au'])", env).should == 206609
-    
+
   end
 
   it "should be able to calculate MIN for an arbitrary number of argument expressions" do
@@ -224,7 +252,7 @@ describe "The language" do
     program =  "MAX(fun(){4}(),fun(x){x}(4),fun(x,y){x+y}(2,2))"
     eval(program).should == 4
   end
-  
+
   it "should be able to map all hash ids that match a given value by calling MATCHING_IDS" do
     env = { :foo => { :a => "bar", :b => "bar", :c => "baz" } }
     eval("MATCHING_IDS('bar', foo)", env).should include(:a)
@@ -232,9 +260,9 @@ describe "The language" do
     eval("MATCHING_IDS('baz', foo)", env).should == [ :c ]
     eval("MATCHING_IDS('bam', foo)", env).should == []
   end
-  
+
   it "should define a VALUES_OF_TYPE function" do
-    env = { 
+    env = {
       :all_types => { :a => "bar", :b => "bar", :c => "baz" },
       :all_values => { :a => 100, :b => 200, :c => 300 }
     }
@@ -243,7 +271,7 @@ describe "The language" do
     eval("VALUES_OF_TYPE('baz', all_types, all_values)", env).should == [ 300 ]
     eval("VALUES_OF_TYPE('bam', all_types, all_values)", env).should == []
 
-    env = { 
+    env = {
       :all_types => { :a => "bar", :b => "bar", :c => "baz" },
       :all_values => { :a => [100,200,300], :b => [400,500,600], :c => [700,800,900] }
     }
@@ -252,17 +280,17 @@ describe "The language" do
     eval("VALUES_OF_TYPE('baz', all_types, all_values)", env).should == [ [700,800,900] ]
     eval("VALUES_OF_TYPE('bam', all_types, all_values)", env).should == []
 
-    env = { 
+    env = {
       :all_types => { :a => "bar", :b => "bar", :c => "baz" },
       :all_values => []
     }
     lambda { eval("VALUES_OF_TYPE('bar', all_types, all_values)", env) }.should raise_error(Trxl::InvalidArgumentException)
-    
-    env = { 
+
+    env = {
       :all_types => [],
       :all_values => { :a => [100,200,300], :b => [400,500,600], :c => [700,800,900] }
     }
     lambda { eval("VALUES_OF_TYPE('bar', all_types, all_values)", env) }.should raise_error(Trxl::InvalidArgumentException)
   end
-  
+
 end

data/trxl.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{trxl}
-  s.version = "0.1.8"
+  s.version = "0.1.9"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = [%q{Martin Gamsjaeger (snusnu)}, %q{Michael Aufreiter}]

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: trxl
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 9
   prerelease: 
   segments: 
   - 0
   - 1
-  - 8
-  version: 0.1.8
+  - 9
+  version: 0.1.9
 platform: ruby
 authors: 
 - Martin Gamsjaeger (snusnu)