delorean_lang 0.0.40 → 0.0.42

data/lib/delorean/base.rb

@@ -36,6 +36,8 @@ module Delorean
       ######################################################################
 
       def self._index(obj, args, _e)
+        return nil if obj.nil?
+
         if obj.instance_of?(Hash)
           raise InvalidIndex unless args.length == 1
           obj[args[0]]

data/lib/delorean/error.rb

@@ -42,4 +42,7 @@ module Delorean
   class UndefinedParamError < StandardError
   end
 
+  class InvalidIndex < StandardError
+  end
+
 end

data/lib/delorean/functions.rb

@@ -82,7 +82,8 @@ module Delorean
         raise "Can only access date part of Infinity"
       end
 
-      raise "non-time arg to TIMEPART" unless time.is_a?(Time)
+      raise "non-time arg to TIMEPART" unless
+        time.is_a?(DateTime) || time.is_a?(Time)
       
       case part
       when "h" then time.hour
@@ -159,6 +160,7 @@ module Delorean
       uniq: 	[Array],
       length: 	[[Array, String]],
       flatten:	[Array, [Fixnum, nil]],
+      slice:    [Array, Fixnum, Fixnum],
     }
 
     def RUBY(_e, method, *args)
@@ -186,7 +188,7 @@ module Delorean
 
       args[0].send(msg, *args[1, args.length])
     end
-
+   
     RUBY_SIG = [ 1, Float::INFINITY ]
 
     ######################################################################

data/lib/delorean/version.rb

@@ -1,3 +1,3 @@
 module Delorean
-  VERSION = "0.0.40"
+  VERSION = "0.0.42"
 end

data/spec/func_spec.rb

@@ -217,6 +217,7 @@ describe "Delorean" do
                       "  e = RUBY('sort', dd)",
                       "  f = RUBY('uniq', e)",
                       "  g = RUBY('length', e)",
+                      "  gg = RUBY('length', a)",
                       )
 
     engine.evaluate("A", "c").should == x.flatten(1)
@@ -225,6 +226,16 @@ describe "Delorean" do
     engine.evaluate("A", "e").should == dd.sort
     engine.evaluate("A", "f").should == dd.sort.uniq
     engine.evaluate("A", "g").should == dd.length
+    engine.evaluate("A", "gg").should == x.length
   end
 
+  it "should handle RUBY slice function" do
+    x = [[1, 2, [-3]], 4, [5, 6], -3, 4, 5, 0]
+
+    engine.parse defn("A:",
+                      "  a = #{x}",
+                      "  b = RUBY('slice',a,0,4)",
+                      )
+    engine.evaluate("A", "b").should == x.slice(0,4)
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: delorean_lang
 version: !ruby/object:Gem::Version
-  version: 0.0.40
+  version: 0.0.42
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-19 00:00:00.000000000 Z
+date: 2013-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: treetop