partialruby 0.1.0

data/spec/block_spec.rb

@@ -0,0 +1,83 @@
+require "partialruby"
+
+include PartialRuby
+
+describe Context, "PartialRuby context" do
+
+  class BlockTest
+    def self.foo(*args)
+      yield(*args)
+    end
+
+    def self.bar(*args)
+    end
+  end
+
+  it "should pass block statements" do
+    BlockTest.should_receive :bar
+    PartialRuby.eval("BlockTest.foo{ BlockTest.bar }", binding)
+  end
+
+  def self.test_block_argument(args, args_result)
+    it "should pass block statements with arguments #{args_result}" do
+      BlockTest.should_receive(:bar).with(*args_result)
+      PartialRuby.eval("BlockTest.foo(#{args}) { |x| BlockTest.bar(x) }", binding)
+    end
+  end
+
+  def self.test_block_arguments(args, args_result)
+    it "should pass block statements with arguments #{args_result}" do
+      BlockTest.should_receive(:bar).with(*args_result)
+      PartialRuby.eval("BlockTest.foo(#{args}) { |*x| BlockTest.bar(*x) }", binding)
+    end
+  end
+
+  test_block_argument "1", [1]
+  test_block_argument "'test'", ["test"]
+
+  test_block_arguments "1,2", [1,2]
+  test_block_arguments "'test',2", ["test",2]
+
+  it "should implement yield statement" do
+    def foo
+      PartialRuby.eval("yield", binding)
+    end
+    foo{}
+  end
+
+  it "should implement yield statement with one argument" do
+    def foo_2
+      PartialRuby.eval("yield(4)", binding)
+    end
+
+    a = nil
+    foo_2{|x| a = x }
+    a.should be == 4
+  end
+
+  it "should implement yield statement with two argument" do
+    def foo_2
+      PartialRuby.eval("yield(4,5)", binding)
+    end
+
+    a = nil
+    b = nil
+    foo_2{|x,y| a = x; b = y }
+    a.should be == 4
+    b.should be == 5
+  end
+
+  it "should implement yield statement with multiple arguments" do
+    def foo_2
+      x = [4,5]
+      PartialRuby.eval("yield(*x)", binding)
+    end
+
+    a = nil
+    b = nil
+    foo_2{|x,y| a = x; b = y }
+    a.should be == 4
+    b.should be == 5
+  end
+
+end

data/spec/call_spec.rb

@@ -0,0 +1,26 @@
+require "partialruby"
+
+include PartialRuby
+
+describe Context, "PartialRuby context" do
+  class X
+    def self.foo(*args)
+    end
+  end
+
+  it "should make call without arguments" do
+
+    X.should_receive(:foo)
+    PartialRuby.eval("X.foo", binding)
+  end
+
+  def self.test_args(args, args_result)
+    it "should make call without arguments #{args} and receive #{args_result.inspect}" do
+
+      X.should_receive(:foo).with(*args_result)
+      PartialRuby.eval("X.foo(#{args})", binding)
+    end
+  end
+
+  test_args "1,2,3", [1,2,3]
+end

data/spec/class_spec.rb

@@ -0,0 +1,34 @@
+require "partialruby"
+
+include PartialRuby
+
+describe Context, "PartialRuby context" do
+
+  def self.test_classname(classname)
+    it "should declare class with name #{classname}" do
+      PartialRuby.eval("class #{classname}; end", binding)
+      newclass = eval(classname)
+      newclass.should be == newclass
+    end
+  end
+
+  def self.test_modulename(modulename)
+    it "should declare module with name #{modulename}" do
+      PartialRuby.eval("module #{modulename}; end", binding)
+      newmodl = eval(modulename)
+      newmodl.should be == newmodl
+    end
+
+  end
+
+  test_classname "X"
+
+  module TestModuleA
+  end
+  test_classname "TestModuleA::X"
+  test_classname "::X"
+
+  test_modulename "TestModuleA::Y"
+  test_modulename "::Y"
+
+end

data/spec/const_spec.rb

@@ -0,0 +1,33 @@
+require "partialruby"
+
+include PartialRuby
+
+describe Context, "PartialRuby context" do
+  def self.test_const_read(*const_names)
+    const_names.each do |const_name|
+      it "should read constant of name #{const_name}" do
+        eval("#{const_name} = 9")
+        PartialRuby.eval("#{const_name}", binding).should be == 9
+      end
+    end
+  end
+
+  def self.test_const_assign(*const_names)
+    const_names.each do |const_name|
+      it "should assign constant of name #{const_name}" do
+        PartialRuby.eval("#{const_name} = 10", binding)
+        eval("#{const_name}").should be == 10
+      end
+    end
+  end
+
+  test_const_read "TEST_CONST"
+  test_const_assign "TEST_CONST2"
+
+  test_const_read "Fixnum::TEST_CONST"
+  test_const_assign "Fixnum::TEST_CONST2"
+
+  test_const_read "::TEST_CONST3"
+  test_const_assign "::TEST_CONST4"
+
+end

data/spec/def_spec.rb

@@ -0,0 +1,35 @@
+require "partialruby"
+
+include PartialRuby
+
+describe Context, "PartialRuby context" do
+
+  def self.test_method_def(method_name, arguments=nil, arguments_value=nil)
+
+    if arguments
+      it "should define method of name #{method_name} with arguments #{arguments}: #{arguments_value}" do
+        PartialRuby.eval("def #{method_name}(#{arguments}); end; #{method_name}(#{arguments_value})", binding)
+      end
+    else
+      it "should define method of name #{method_name} with no arguments" do
+        PartialRuby.eval("def #{method_name}; end; #{method_name}()", binding)
+      end
+    end
+  end
+
+  ["foo", "bar"].each do |method_name|
+    test_method_def method_name
+    { "a" => "1", "a,b" => "1,2"}.each do |k,v|
+      test_method_def method_name, k, v
+    end
+  end
+
+  it "should define singleton method" do
+    x = "test object"
+    PartialRuby.eval("def x.foo; end", binding)
+  end
+
+  it "should compile return statements" do
+    PartialRuby.eval("def test_foo; return 4; end; test_foo", binding).should be == 4
+  end
+end

data/spec/eval_spec.rb

@@ -0,0 +1,85 @@
+require "partialruby"
+
+include PartialRuby
+
+describe Context, "PartialRuby context" do
+
+  it "should eval literal 'hello world'" do
+    PartialRuby.eval('"hello world"', binding).should be == "hello world"
+  end
+
+	it "should eval hello world string" do
+		PartialRuby.eval 'print "hello world\n"', binding
+	end
+
+  it "should define a class" do
+
+    module TestEmptyClass
+    PartialRuby.eval 'class X; end', binding
+    end
+
+    TestEmptyClass::X.should be == TestEmptyClass::X
+  end
+
+  it "should define a class with a method" do
+
+    module TestClassWithFoo
+    PartialRuby.eval 'class X; def foo; end; end', binding
+    end
+
+    TestClassWithFoo::X.should be == TestClassWithFoo::X
+  end
+
+  it "should define a class with a method and the method must be callable" do
+
+    module TestClassWithFoo2
+    PartialRuby.eval 'class X; def foo; end; end', binding
+    end
+
+    x = TestClassWithFoo2::X.new
+    x.foo.should be == nil
+  end
+
+  it "should define a class with two methods and the methods must be callable" do
+
+    module TestClassWithFoo3
+    PartialRuby.eval 'class X; def foo; end; def bar; end; end', binding
+    end
+
+    x = TestClassWithFoo3::X.new
+    x.foo.should be == nil
+    x.bar.should be == nil
+  end
+
+   # This does not work in the original ruby!
+#  it "should write a local variable" do
+ #   PartialRuby.eval "a = 5", binding
+  #  a.should be == 5
+#  end
+
+  def self.test_local_with_value(value)
+    it "should allow represent literal #{value}" do
+      PartialRuby.eval(value, binding).should be == eval(value)
+    end
+
+    it "should read a local variable with value #{value}" do
+      a = eval(value)
+      PartialRuby.eval("a", binding).should be == eval(value)
+    end
+
+    it "should declare and read a local variable with value #{value}" do
+      PartialRuby.eval("a = #{value}; a", binding).should be == eval(value)
+    end
+  end
+
+  test_local_with_value "5"
+  test_local_with_value "5.5"
+  test_local_with_value "'teststring'"
+  test_local_with_value "[5]"
+  test_local_with_value "[5,6,7,8,9]"
+  test_local_with_value "[[9,6],7,8,9]"
+
+  test_local_with_value "{ 1 => 3, 5 => 9}"
+
+
+end

data/spec/exception_spec.rb

@@ -0,0 +1,53 @@
+require "partialruby"
+
+include PartialRuby
+
+describe Context, "PartialRuby context" do
+
+  def self.assert_ruby_expr(expr, expected = nil)
+
+    exception = nil
+
+    begin
+      expected ||= eval(expr)
+    rescue Exception => e
+      exception = e
+    end
+
+    if exception
+      it "should raise #{exception} on expresion #{expr}" do
+        lambda{
+          PartialRuby.eval(expr,binding)
+        }.should raise_error(exception.class)
+      end
+    else
+      it "should return #{expected} on expresion #{expr}" do
+        PartialRuby.eval(expr,binding).to_s.should be == expected.to_s
+      end
+    end
+  end
+
+  assert_ruby_expr("raise Exception")
+  assert_ruby_expr("begin; raise Exception; rescue; 5; end")
+  assert_ruby_expr("begin; raise Exception; rescue Exception; 4; end")
+  assert_ruby_expr("begin; raise Exception; rescue Exception => e; 9; ensure; 4; end")
+  assert_ruby_expr("begin; raise '999'; rescue RuntimeError; end")
+  assert_ruby_expr("begin; raise '999'; rescue RuntimeError; end; 5")
+  assert_ruby_expr("begin; raise '999'; rescue RuntimeError, Exception; end")
+  assert_ruby_expr("begin; raise '999'; rescue RuntimeError, Exception; end; 5")
+
+  [
+   "rescue RuntimeError; end",
+   "rescue RuntimeError => e; end",
+   "rescue Errno::EINVAL; end",
+   "rescue Errno::EINVAL => e; end",
+   "rescue RuntimeError, Errno::EINVAL; end",
+   "rescue RuntimeError, Errno::EINVAL => e; e; end",
+  ].each do |x|
+  assert_ruby_expr("begin; raise Errno::EINVAL; #{x}")
+  assert_ruby_expr("begin; raise RuntimeError; #{x}")
+  assert_ruby_expr("begin; raise Errno::EINVAL; #{x}")
+  assert_ruby_expr("begin; raise RuntimeError; #{x}")
+  end
+
+end

data/spec/flow_control_spec.rb

@@ -0,0 +1,38 @@
+require "partialruby"
+
+include PartialRuby
+
+describe Context, "PartialRuby context" do
+
+  def self.assert_ruby_expr(expr, expected = nil)
+
+    expected ||= eval(expr)
+
+    it "should return #{expected} on expresion #{expr}" do
+      PartialRuby.eval(expr,binding).should be == expected
+    end
+  end
+
+  def self.test_if(keyword)
+    assert_ruby_expr keyword + " true; true; else; false; end"
+    assert_ruby_expr keyword + " true; true; else; true; end"
+    assert_ruby_expr keyword + " true; false; else; true; end"
+    assert_ruby_expr keyword + " true; false; else; false; end"
+  end
+
+  test_if "if"
+  test_if "unless"
+
+  assert_ruby_expr "i = 5 ; while(i>0); i=i-1; end; i"
+  assert_ruby_expr "i = 5 ; until(i==0); i=i-1; end; i"
+
+
+  (1..4).each do |x|
+  assert_ruby_expr "case #{x}; when 1; 2; end"
+  assert_ruby_expr "case #{x}; when 1; 2; when 2; 3; end"
+  assert_ruby_expr "case #{x}; when 1; 2; when 2; 3; end"
+  assert_ruby_expr "case #{x}; when 1; 2; when 2; 3; when 3; 4; else; 9; end"
+  assert_ruby_expr "case #{x}; when (if true; 1; else; false; end),9; 2; when 2; 3; else; 9; end"
+  end
+
+end

data/spec/gvar_spec.rb

@@ -0,0 +1,18 @@
+require "partialruby"
+
+include PartialRuby
+
+describe Context, "PartialRuby context" do
+
+  def self.assert_ruby_expr(expr, expected = nil)
+
+    expected ||= eval(expr)
+
+    it "should return #{expected} on expresion #{expr}" do
+      PartialRuby.eval(expr,binding).should be == expected
+    end
+  end
+
+  assert_ruby_expr "$b"
+  assert_ruby_expr "$a = 4; $a"
+end

data/spec/ivar_spec.rb

@@ -0,0 +1,18 @@
+require "partialruby"
+
+include PartialRuby
+
+describe Context, "PartialRuby context" do
+
+  def self.assert_ruby_expr(expr, expected = nil)
+
+    expected ||= eval(expr)
+
+    it "should return #{expected} on expresion #{expr}" do
+      PartialRuby.eval(expr,binding).should be == expected
+    end
+  end
+
+  assert_ruby_expr "@b"
+  assert_ruby_expr "@a = 4; @a"
+end

data/spec/literal_spec.rb

@@ -0,0 +1,24 @@
+require "partialruby"
+
+include PartialRuby
+
+describe Context, "PartialRuby context" do
+
+  def self.assert_ruby_expr(expr, expected = nil)
+
+    expected ||= eval(expr)
+
+    it "should return #{expected} on expresion #{expr}" do
+      PartialRuby.eval(expr,binding).should be == expected
+    end
+  end
+
+  assert_ruby_expr "'xxx'"
+  assert_ruby_expr "43"
+  assert_ruby_expr "(0..9)"
+  assert_ruby_expr "{ 1 => 2, 3 => 4 }"
+  assert_ruby_expr "[1,2,3,4,5]"
+  assert_ruby_expr "/aaa/"
+
+  assert_ruby_expr 'a="x"; "xxxxx#{a}"'
+end