subaltern 1.0.0

data/spec/control_flow_spec.rb

@@ -0,0 +1,251 @@
+
+require 'spec_helper'
+
+
+describe Subaltern do
+
+  describe 'if' do
+
+    it 'works (then)' do
+
+      Subaltern.eval(%{
+        if true
+          :ok
+        end
+      }).should == :ok
+    end
+
+    it 'works (complex expression)' do
+
+      Subaltern.eval(%{
+        if false or true
+          :ok
+        end
+      }).should == :ok
+    end
+
+    it 'works (else)' do
+
+      Subaltern.eval(%{
+        if false
+          :not_ok
+        else
+          :ok
+        end
+      }).should == :ok
+    end
+
+    it 'works postfix' do
+
+      Subaltern.eval(%{
+        'ok' if true
+      }).should == 'ok'
+    end
+  end
+
+  describe 'elsif' do
+
+    it 'works' do
+
+      Subaltern.eval(%{
+        if false
+          :not_ok
+        elsif true
+          :ok
+        else
+          :really_not_ok
+        end
+      }).should == :ok
+    end
+  end
+
+  describe 'unless' do
+
+    it 'works' do
+
+      Subaltern.eval(%{
+        unless false
+          :ok
+        else
+          :not_ok
+        end
+      }).should == :ok
+    end
+  end
+
+  describe 'case' do
+
+    it 'works' do
+
+      Subaltern.eval(%{
+        case true
+          when true then :ok
+          when false then :not_ok
+          else :really_not_ok
+        end
+      }).should == :ok
+    end
+
+    it 'works (else)' do
+
+      Subaltern.eval(%{
+        case false
+          when true then :not_ok
+          else :ok
+        end
+      }).should == :ok
+    end
+
+    it 'works (multiline)' do
+
+      Subaltern.eval(%{
+        case true
+          when true
+            :not_ok
+            :ok
+          else
+            :really_not_ok
+        end
+      }).should == :ok
+    end
+
+    it 'works (classes)' do
+
+      Subaltern.eval(%{
+        case true
+          when FalseClass
+            :not_ok
+          when TrueClass
+            :ok
+          else
+            :really_not_ok
+        end
+      }).should == :ok
+    end
+
+    it 'works (regexes)' do
+
+      Subaltern.eval(%{
+        case 'the little bird'
+          when /fox/
+            :not_ok
+          when /bird/
+            :ok
+          else
+            :really_not_ok
+        end
+      }).should == :ok
+    end
+
+    it 'works (regexes 2)' do
+
+      Subaltern.eval(%{
+        case 'the little bird'
+          when /squirrel/
+            :not_ok
+          when /chipmunk/
+            :really_not_ok
+          else
+            :ok
+        end
+      }).should == :ok
+    end
+  end
+
+  context '#each' do
+
+    describe 'break' do
+
+      it 'works' do
+
+        Subaltern.eval(%{
+          [ 1, 2, 3 ].each do |i|
+            break
+          end
+        }).should == nil
+      end
+    end
+
+    describe 'break y' do
+
+      it 'works' do
+
+        Subaltern.eval(%{
+          [ 1, 2, 3 ].each do |i|
+            break i
+          end
+        }).should == 1
+      end
+    end
+
+    describe 'next' do
+
+      it 'works' do
+
+        Subaltern.eval(%{
+          a = []
+          [ 1, 2, 3 ].each do |i|
+            next
+            a << i
+          end
+          a
+        }).should == []
+      end
+    end
+  end
+
+  context '#collect' do
+
+    describe 'next x' do
+
+      it 'works' do
+
+        Subaltern.eval(%{
+          [ 1, 2, 3 ].collect do |i|
+            next i * 3
+          end
+        }).should == [ 3, 6, 9 ]
+      end
+
+      it 'works with multiple values' do
+
+        Subaltern.eval(%{
+          [ 1, 2, 3 ].collect do |i|
+            next i, i * 3
+          end
+        }).should == [ [ 1, 3 ], [ 2, 6 ], [ 3, 9 ] ]
+      end
+    end
+  end
+
+  describe '#?' do
+
+    it 'works' do
+
+      Subaltern.eval(%{
+        true ? 1 : 0
+      }).should == 1
+    end
+
+    it 'works (then)' do
+
+      Subaltern.eval(%{
+        false ? 0 : 1
+      }).should == 1
+    end
+  end
+
+  describe 'rescue' do
+
+    describe 'rescue :x' do
+
+      it 'works' do
+
+        Subaltern.eval(%{
+          1 / 0 rescue :limit
+        }).should == :limit
+      end
+    end
+  end
+end
+

data/spec/evil_spec.rb

@@ -0,0 +1,106 @@
+
+require 'spec_helper'
+
+
+class String
+  def constantize
+    eval(self)
+  end
+end
+
+describe Subaltern do
+
+  context 'evil' do
+
+    describe "''.eval('1 + 1')" do
+
+      it 'raises' do
+
+        lambda {
+          Subaltern.eval("''.eval('1 + 1')")
+        }.should raise_error(Subaltern::NonWhitelistedMethodError)
+      end
+    end
+
+    describe 'calls on non-whitelisted classes' do
+
+      it 'raises' do
+
+        lambda {
+          Subaltern.eval("'File'.constantize.read('#{__FILE__}')")
+        #}.should raise_error(Subaltern::NonWhitelistedClassError)
+        }.should raise_error(Subaltern::NonWhitelistedMethodError)
+      end
+    end
+
+    describe 'a constant lookup' do
+
+      it 'raises (ENV)' do
+
+        lambda {
+          Subaltern.eval('ENV')
+        }.should raise_error(Subaltern::AccessError)
+      end
+
+      it 'raises (File::Utils)' do
+
+        lambda {
+          Subaltern.eval('File::Utils')
+        }.should raise_error(Subaltern::AccessError)
+      end
+    end
+
+    describe 'a call on a constant' do
+
+      it 'raises (ENV["HOME"])' do
+
+        lambda {
+          Subaltern.eval('ENV["HOME"]')
+        }.should raise_error(Subaltern::AccessError)
+      end
+    end
+
+    describe 'a global variable lookup' do
+
+      it 'raises ($nada)' do
+
+        lambda {
+          Subaltern.eval('$nada')
+        }.should raise_error(Subaltern::AccessError)
+      end
+    end
+
+    describe 'backquoting' do
+
+      it 'raises (simple case)' do
+
+        lambda {
+          Subaltern.eval('`ls -al`')
+        }.should raise_error(Subaltern::AccessError)
+      end
+
+      it 'raises (string extrapolation case)' do
+
+        lambda {
+          Subaltern.eval('`ls -al #{nada}`')
+        }.should raise_error(Subaltern::AccessError)
+      end
+    end
+
+    describe 'method with a block' do
+
+      it 'is not automatically whitelisted' do
+
+        class Array
+          def whatever
+          end
+        end
+
+        lambda {
+          Subaltern.eval('[].whatever { |e| false }')
+        }.should raise_error(Subaltern::NonWhitelistedMethodError)
+      end
+    end
+  end
+end
+

data/spec/fixnum_spec.rb

@@ -0,0 +1,20 @@
+
+require 'spec_helper'
+
+
+describe Subaltern do
+
+  describe 'Fixnum' do
+
+    it 'works' do
+
+      Subaltern.eval('1.0').should == 1.0
+      Subaltern.eval('1 + 1').should == 2
+      Subaltern.eval('1 * 2').should == 2
+      Subaltern.eval('3 - 1').should == 2
+      Subaltern.eval('1.even?').should == false
+      Subaltern.eval('1.odd?').should == true
+    end
+  end
+end
+

data/spec/functions_spec.rb

@@ -0,0 +1,123 @@
+
+require 'spec_helper'
+
+
+describe Subaltern do
+
+  context 'functions' do
+
+    it 'accepts function definitions' do
+
+      Subaltern.eval(%{
+        def addition(a, b)
+          a + b
+        end
+      }).should == nil
+    end
+
+    it 'accepts calls to defined functions' do
+
+      Subaltern.eval(%{
+        def addition(a, b)
+          a + b
+        end
+        addition(1, 2)
+      }).should == 3
+    end
+
+    it 'accepts functions with optional parameters' do
+
+      Subaltern.eval(%{
+        def add(a, b=1, c=2)
+          a + b + c
+        end
+        [ add(1, 2), add(4) ]
+      }).should == [ 5, 7 ]
+    end
+
+    it 'accepts functions with starred parameters' do
+
+      Subaltern.eval(%{
+        def concat(a, *args)
+          [ a ] + args
+        end
+        concat(1, 2, 3, 4)
+      }).should == [ 1, 2, 3, 4 ]
+    end
+
+    it 'accepts a final hash argument' do
+
+      Subaltern.eval(%{
+        def pretty(a, b)
+          [ a, b ]
+        end
+        pretty('a', 'b' => 'c')
+      }).should == [ 'a', { 'b' => 'c' } ]
+    end
+
+    it 'accepts "return" in the middle of functions' do
+
+      Subaltern.eval(%{
+        def hello
+          1
+          return 'nada'
+          2
+        end
+        hello
+      }).should == 'nada'
+    end
+
+    it 'accepts functions with blocks' do
+
+      Subaltern.eval(%{
+        def hello
+          1 + yield
+        end
+        hello { 3 }
+      }).should == 4
+    end
+
+    it 'accepts functions with explicit blocks' do
+
+      Subaltern.eval(%{
+        def hello(start, &block)
+          start + block.call
+        end
+        hello(1) { 3 }
+      }).should == 4
+    end
+
+    it 'accepts functions that call blocks with arguments' do
+
+      Subaltern.eval(%{
+        def hello(start, &block)
+          start + block.call(start)
+        end
+        hello(3) { |s| s * 3 }
+      }).should == 12
+    end
+
+    it 'accepts functions that yield arguments to blocks' do
+
+      Subaltern.eval(%{
+        def hello(start)
+          start + yield(start)
+        end
+        hello(3) { |s| s * 3 }
+      }).should == 12
+    end
+
+    it 'raises when a block is called without its arg' do
+
+      lambda {
+        Subaltern.eval(%{
+          def hello(start, &block)
+            start + block.call
+          end
+          hello(3) { |start| start * 3 }
+        })
+      }.should raise_error(Subaltern::NonWhitelistedMethodError)
+    end
+  end
+end
+