interrotron 0.0.3 → 0.0.4

data/README.md

@@ -11,7 +11,7 @@ A simple non-turing complete lisp meant to be embedded in apps as a rules engine
 
 ## Installation
 
-Either add the `interrotron` gem, or just copy and paste [interratron.rb](https://github.com/andrewvc/interrotron/blob/master/lib/interrotron.rb)
+Either add the `interrotron` gem, or just copy and paste [interrotron.rb](https://github.com/andrewvc/interrotron/blob/master/lib/interrotron.rb)
 
 ## Usage
 
@@ -46,7 +46,7 @@ Interrotron.run("(if false
 
 # Additionally, it is possible to constrain execution to a maximum number of
 # operations by passing in a third argument
-Interrotron.run("str (+ 1 2) (+ 3 4) (+ 5 7))", {}, 4)
+Interrotron.run("(str (+ 1 2) (+ 3 4) (+ 5 7))", {}, 3)
 # => raises Interrotron::OpsThresholdError since 4 operations were executed
 
 ```
@@ -64,14 +64,20 @@ The following functions and variables are built in to Interrotron (and more are
 (floor expr) ; equiv to num.floor
 (ceil expr) ; equiv to num.ceil
 (round expr) ; equiv to num.round
-(max lst) ; returns the largest element in a list
-(min lst) ; returns the smallest element in a list
 (to_i expr) ; int conversion
 (to_f expr) ; float conversion
 (rand) ; returns a random float between 0 and 1
 (upcase str) ; uppercases a string
 (downcase) ; lowercases a string
 (now) ; returns the current DateTime
+(array e1, e2, ...) ; creates an array
+(max arr) ; returns the largest element of an array
+(min arr) ; returns the smallest element of an array
+(length arr) ; get the length of an array
+(first arr) ; get arr head
+(last arr) ; get arr tail
+(nth pos arr) ; get array at index
+(member? val arr) ; check if the array has a member with value 'val'
 ```
 
 ## Contributing

data/lib/interrotron.rb

@@ -47,9 +47,11 @@ class Interrotron
             [:lpar, /\(/],
             [:rpar, /\)/],
             [:fn, /fn/],
-            [:var, /[A-Za-z_><\+\>\<\!\=\*\/\%\-]+/],
-            [:num, /(\-?[0-9]+(\.[0-9]+)?)/],
-            [:datetime, /#dt\{([^\{]+)\}/, {capture: 1}],
+            [:var, /[A-Za-z_><\+\>\<\!\=\*\/\%\-\?]+/],
+            [:num, /(\-?[0-9]+(\.[0-9]+)?)/, 
+             {cast: proc {|v| v =~ /\./ ? v.to_f : v.to_i }}],
+            [:datetime, /#dt\{([^\{]+)\}/,
+             {capture: 1, cast: proc {|v| DateTime.parse(v) }}],
             [:spc, /\s+/, {discard: true}],
             [:str, /"([^"\\]*(\\.[^"\\]*)*)"/, {capture: 1}],
             [:str, /'([^'\\]*(\\.[^'\\]*)*)'/, {capture: 1}]
@@ -61,19 +63,19 @@ class Interrotron
   end
 
   DEFAULT_VARS = Hashie::Mash.new({
-    'if' => Macro.new {|i,pred,t_clause,f_clause| i.vm_eval(pred) ? t_clause : f_clause },
+    'if' => Macro.new {|i,pred,t_clause,f_clause| i.iro_eval(pred) ? t_clause : f_clause },
     'cond' => Macro.new {|i,*args|
                  raise InterroArgumentError, "Cond requires at least 3 args" unless args.length >= 3
                  raise InterroArgumentError, "Cond requires an even # of args!" unless args.length.even?
                  res = qvar('nil')
                  args.each_slice(2).any? {|slice|
                    pred, expr = slice
-                   res = expr if i.vm_eval(pred)
+                   res = expr if i.iro_eval(pred)
                  }
                  res
     },
-    'and' => Macro.new {|i,*args| args.all? {|a| i.vm_eval(a)} ? args.last : qvar('false')  },
-    'or' => Macro.new {|i,*args| args.detect {|a| i.vm_eval(a) } || qvar('false') },
+    'and' => Macro.new {|i,*args| args.all? {|a| i.iro_eval(a)} ? args.last : qvar('false')  },
+    'or' => Macro.new {|i,*args| args.detect {|a| i.iro_eval(a) } || qvar('false') },
     'array' => proc {|*args| args},
     'identity' => proc {|a| a},
     'not' => proc {|a| !a},
@@ -99,7 +101,9 @@ class Interrotron
     'min' => proc {|arr| arr.min},
     'first' => proc {|arr| arr.first},
     'last' => proc {|arr| arr.last},
+    'nth' => proc {|pos, arr| arr[pos]},
     'length' => proc {|arr| arr.length},
+    'member?' => proc {|v,arr| arr.member? v},
     'to_i' => proc {|a| a.to_i},
     'to_f' => proc {|a| a.to_f},
     'rand' => proc { rand },
@@ -130,10 +134,12 @@ class Interrotron
         if !matches || !matches.pre_match.empty?
           false
         else
-          mlen = matches[0].length
-          str = str[mlen..-1]
-          m = matches[opts[:capture] || 0]
-          tokens << Token.new(name, m) unless opts[:discard] == true
+          str = str[matches[0].length..-1]
+          unless opts[:discard] == true
+            val = matches[opts[:capture] || 0]
+            val = opts[:cast].call(val) if opts[:cast]
+            tokens << Token.new(name, val)
+          end
           true
         end
       }
@@ -142,45 +148,26 @@ class Interrotron
     tokens
   end
   
-  # Transforms token values to ruby types
-  def cast(t)
-    new_val = case t.type
-              when :num
-                t.value =~ /\./ ? t.value.to_f : t.value.to_i
-              when :datetime
-                DateTime.parse(t.value)
-              else
-                t.value
-              end
-    t.value = new_val
-    t
-  end
-  
   def parse(tokens)
-    return [] if tokens.empty?
+    return [] if !tokens || tokens.empty?
+    
     expr = []
-    t = tokens.shift
-    if t.type == :lpar
-      while t = tokens[0]
-        if t.type == :lpar
-          expr << parse(tokens)
-        else
-          tokens.shift
-          break if t.type == :rpar
-          expr << cast(t)
-        end
+    while !tokens.empty?
+      t = tokens.shift
+      case t.type
+      when :lpar
+        expr << parse(tokens)
+      when :rpar
+        return expr
+      else
+        expr << t
       end
-    elsif t.type != :rpar
-      tokens.shift
-      expr << cast(t)
-      #raise SyntaxError, "Expected :lparen, got #{t} while parsing #{tokens}"
     end
     expr
   end
   
   def resolve_token(token)
-    case token.type
-    when :var
+    if  token.type == :var
       frame = @stack.reverse.find {|frame| frame.has_key?(token.value) }
       raise UndefinedVarError, "Var '#{token.value}' is undefined!" unless frame
       frame[token.value]
@@ -190,24 +177,26 @@ class Interrotron
   end
   
   def register_op
-    return unless @max_ops
-    @op_count += 1
-    raise OpsThresholdError, "Exceeded max ops(#{@max_ops}) allowed!" if @op_count && @op_count > @max_ops
+    return unless @max_ops # noop when op counting disabled
+    if  (@op_count+=1) > @max_ops
+      raise OpsThresholdError, "Exceeded max ops(#{@max_ops}) allowed!"
+    end
   end
   
-  def vm_eval(expr,max_ops=nil)
+  def iro_eval(expr,max_ops=nil)
     return resolve_token(expr) if expr.is_a?(Token)
     return nil if expr.empty?
     register_op
     
-    head = vm_eval(expr[0])
+    head = iro_eval(expr[0])
     if head.is_a?(Macro)
       expanded = head.call(self, *expr[1..-1])
-      vm_eval(expanded)
+      iro_eval(expanded)
+    elsif head.is_a?(Proc)
+      args = expr[1..-1].map {|e| iro_eval(e) }
+      head.call(*args)
     else
-      args = expr[1..-1].map {|e|vm_eval(e)}
-
-      head.is_a?(Proc) ? head.call(*args) : head
+      raise InterroArgumentError, "Non FN/macro Value in head position!"
     end
   end
 
@@ -222,7 +211,8 @@ class Interrotron
       reset!
       @max_ops = max_ops
       @stack = [@instance_default_vars.merge(vars)]
-      vm_eval(ast)
+      #iro_eval(ast)
+      ast.map {|expr| iro_eval(expr)}.last
     }
   end
 

data/lib/interrotron/version.rb

@@ -1,3 +1,3 @@
 class Interrotron
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/spec/interrotron_spec.rb

@@ -122,9 +122,13 @@ describe "running" do
       run("(length (array 1 2 3 'bob'))").should == 4
     end
 
-    it "should implement detect correctly in the positive case" do
-      pending "not now"
-      #run("(detect (> 10 n) (array 1 5 30 1))").should 
+    describe "checking membership" do
+      it "should work in the false case" do
+        run("(member? 5 (array 10 20 30))").should be_false
+      end
+      it "should work in the true case" do
+        run("(member? 5 (array 10 5 30))").should be_true
+      end
     end
   end
 
@@ -143,7 +147,7 @@ describe "running" do
 
   describe "op counter" do
     it "should not stop scripts under or at the threshold" do
-      run("(str (+ 1 2) (+ 3 4) (+ 5 7))", {}, 4)
+      run("(str (+ 1 2) (+ 3 4) (+ 5 7))", {}, 5)
     end
     it "should terminate with the proper exception if over the threshold" do
       proc {
@@ -151,4 +155,20 @@ describe "running" do
       }.should raise_exception(Interrotron::OpsThresholdError)
     end
   end
+
+  describe "multiple forms at the root" do
+    it "should return the second form" do
+      run("(+ 1 1) (+ 2 2)").should == 4
+    end
+
+    it "should raise an exception if a number is in a fn pos" do
+      proc { run("(1)") }.should raise_exception(Interrotron::InterroArgumentError)
+    end
+  end
+
+  describe "empty input" do
+    it "should return nil" do
+      run("").should be_nil
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: interrotron
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2012-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70115221983600 !ruby/object:Gem::Requirement
+  requirement: &70187372115860 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,7 +21,7 @@ dependencies:
         version: '2.6'
   type: :development
   prerelease: false
-  version_requirements: *70115221983600
+  version_requirements: *70187372115860
 description: A tiny, embeddable, lisp VM
 email:
 - andrew@andrewvc.com