php_vm 1.3.10 → 1.3.11

data/ext/php_vm/php_vm.c

@@ -73,6 +73,13 @@ static void php_vm_exception_hook(zval *ex TSRMLS_DC)
 	EG(exception) = NULL;
 }
 
+static void php_vm_reset_status(TSRMLS_D)
+{
+	EG(exit_status) = 0;
+	EG(exception) = NULL;
+	rb_cv_set(rb_mPHPVM, "@@last_error_reporting", Qnil);
+}
+
 
 // PHP
 
@@ -81,12 +88,16 @@ VALUE php_eval_string(char *code, int code_len, int use_retval TSRMLS_DC)
 	int syntax_error = 0;
 	zval retval;
 
+	// reset
+	php_vm_reset_status(TSRMLS_C);
+
 	// eval
 	zend_try {
 		if (zend_eval_stringl(code, code_len, (use_retval ? &retval : NULL), "php_vm" TSRMLS_CC)==FAILURE) {
 			syntax_error = 1;
 		}
 	} zend_end_try();
+	EG(active_op_array) = NULL;
 
 	// syntax error
 	if (syntax_error) {
@@ -363,6 +374,9 @@ int call_php_method(zend_class_entry *ce, zval *obj, zend_function *mptr, int ar
 {
 	int result = FAILURE;
 
+	// reset
+	php_vm_reset_status(TSRMLS_C);
+
 	// call info
 	zend_fcall_info fci;
 	zend_fcall_info_cache fcc;
@@ -421,6 +435,7 @@ int call_php_method(zend_class_entry *ce, zval *obj, zend_function *mptr, int ar
 	// release
 	zend_fcall_info_args_clear(&fci, 1);
 	zval_ptr_dtor(&z_args);
+	EG(active_op_array) = NULL;
 
 	// result
 	if (g_exception || rb_cv_get(rb_mPHPVM, "@@last_error_reporting")!=Qnil) {
@@ -834,6 +849,7 @@ VALUE define_global_classes()
 	while (SUCCESS == zend_hash_get_current_data_ex(ht, (void **)&z_classname, &pos)) {
 		char *classname = Z_STRVAL_P(*z_classname);
 		int classname_len = Z_STRLEN_P(*z_classname);
+
 		if (0x41<=classname[0] && classname[0]<=0x5a) {
 			// define class as const if class name is uppercase
 			if (!rb_const_defined(rb_mPHPGlobal, rb_intern(classname))) {
@@ -844,6 +860,7 @@ VALUE define_global_classes()
 			// define class as module function if class name is lowercase
 			rb_define_module_function(rb_mPHPGlobal, classname, rb_php_global_class_call, 0);
 		}
+
 		zend_hash_move_forward_ex(ht, &pos);
 	}
 	zval_ptr_dtor(&z_val);
@@ -1467,7 +1484,7 @@ void Init_php_vm()
 	rb_define_singleton_method(rb_mPHPVM, "get_class", rb_php_vm_get_class, 1);
 	rb_define_singleton_method(rb_mPHPVM, "define_global", rb_php_vm_define_global, 0);
 
-	rb_define_const(rb_mPHPVM, "VERSION", rb_str_new2("1.3.10"));
+	rb_define_const(rb_mPHPVM, "VERSION", rb_str_new2("1.3.11"));
 
 	rb_cv_set(rb_mPHPVM, "@@output_handler", Qnil);
 	rb_cv_set(rb_mPHPVM, "@@error_handler", Qnil);

data/ext/php_vm/php_vm_z2v.c

@@ -82,8 +82,15 @@ static VALUE zval_to_value_object(zval *z)
 	const char *name = "";
 	zend_uint name_len = 0;
 	int dup;
+
+	// get class name
 	dup = zend_get_object_classname(z, &name, &name_len TSRMLS_CC);
+	if (dup!=SUCCESS) {
+		rb_raise(rb_ePHPError, "did not get class name from zend_class_entry");
+	}
+
 	VALUE v_name = rb_str_new(name, name_len);
+	efree((char*)name);
 
 	// class
 	VALUE class = rb_php_class_get(rb_cPHPClass, v_name);

data/test/require.php

@@ -0,0 +1 @@
+<?php

data/test/run_test.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/ruby
+
+require 'test/unit'
+
+test_dir = File.dirname(__FILE__)
+exit Test::Unit::AutoRunner.run(true, test_dir)

data/test/test_php_vm.rb

@@ -0,0 +1,113 @@
+#!/usr/bin/ruby
+
+$LOAD_PATH << File.expand_path(__FILE__+"/../../ext/php_vm")
+require "test/unit"
+require "php_vm"
+
+class TC_PHPVM < Test::Unit::TestCase
+  def setup
+    PHPVM.output_handler = Proc.new{|output| }
+    PHPVM.error_handler = Proc.new{|error_reporting| }
+  end
+
+  def test_output_handler_accessor
+    hooked_output = nil
+    pr = Proc.new {|output|
+      hooked_output = output
+    }
+
+    # proc object
+    PHPVM.output_handler = pr
+    assert_equal(pr, PHPVM.output_handler)
+
+    # hook
+    PHPVM.exec("echo 'HelloWorld';")
+    assert_equal("HelloWorld", hooked_output)
+
+    # nil object
+    PHPVM.output_handler = nil
+    assert_nil(PHPVM.output_handler)
+  end
+
+  def test_error_handler_accessor
+    hooked_error_reporting = nil
+    pr = Proc.new {|error_reporting|
+      hooked_error_reporting = error_reporting
+    }
+
+    # proc object
+    PHPVM.error_handler = pr
+    assert_equal(pr, PHPVM.error_handler)
+
+    # hook
+    PHPVM.exec("strpos();")
+    assert_instance_of(PHPVM::PHPErrorReporting, hooked_error_reporting)
+
+    # nil object
+    PHPVM.error_handler = nil
+    assert_nil(PHPVM.error_handler)
+  end
+
+  def test_require
+    # exists php file
+    filepath = File.expand_path(__FILE__+"/../require.php")
+    assert_equal(true, PHPVM.require(filepath))
+
+    # non exists php file
+    assert_raises(PHPVM::PHPErrorReporting) {
+      filepath = File.expand_path(__FILE__+"/../non_exists_file.php")
+      PHPVM.require(filepath)
+    }
+  end
+
+  def test_require_once
+    # exists php file
+    filepath = File.expand_path(__FILE__+"/../require.php")
+    assert_equal(true, PHPVM.require_once(filepath))
+
+    # non exists php file
+    assert_raises(PHPVM::PHPErrorReporting) {
+      filepath = File.expand_path(__FILE__+"/../non_exists_file.php")
+      PHPVM.require_once(filepath)
+    }
+  end
+
+  def test_include
+    # exists php file
+    filepath = File.expand_path(__FILE__+"/../require.php")
+    assert_equal(true, PHPVM.include(filepath))
+
+    # non exists php file
+    filepath = File.expand_path(__FILE__+"/../non_exists_file.php")
+    assert_equal(false, PHPVM.include(filepath))
+  end
+
+  def test_include_once
+    # exists php file
+    filepath = File.expand_path(__FILE__+"/../require.php")
+    assert_equal(true, PHPVM.include_once(filepath))
+
+    # non exists php file
+    filepath = File.expand_path(__FILE__+"/../non_exists_file.php")
+    assert_equal(false, PHPVM.include_once(filepath))
+  end
+
+  def test_get_class
+    # exists php class
+    assert_instance_of(PHPVM::PHPClass, PHPVM.get_class("SimpleXMLElement"))
+    assert_equal(PHPVM::PHPClass.get("SimpleXMLElement"), PHPVM.get_class("SimpleXMLElement"))
+
+    # non exists php class
+    assert_raises(PHPVM::PHPError) {
+      PHPVM.get_class("NonExistsClass")
+    }
+  end
+
+  def test_define_global
+    assert_equal(true, PHPVM.define_global)
+  end
+
+  def test_version
+    assert_match(/^\d+\.\d+\.\d+$/, PHPVM::VERSION)
+  end
+end

data/test/test_php_vm_php_class.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/ruby
+
+$LOAD_PATH << File.expand_path(__FILE__+"/../../ext/php_vm")
+require "test/unit"
+require "php_vm"
+
+class TC_PHPVM_PHPClass < Test::Unit::TestCase
+  def setup
+    PHPVM.output_handler = Proc.new{|output| }
+    PHPVM.error_handler = Proc.new{|error_reporting| }
+  end
+
+  def test_get
+    # exists php class
+    assert_instance_of(PHPVM::PHPClass, PHPVM::PHPClass.get("SimpleXMLElement"))
+
+    # non exists php class
+    assert_raises(PHPVM::PHPError) {
+      PHPVM.get_class("NonExistsClass")
+    }
+  end
+
+  def test_new
+    # normal object
+    phpSimpleXMLElement = PHPVM.get_class("SimpleXMLElement")
+    xml = phpSimpleXMLElement.new("<root><item>Hello World!!</item></root>")
+    assert_instance_of(PHPVM::PHPObject, xml)
+
+    # exception object
+    phpException = PHPVM.get_class("Exception")
+    exc = phpException.new("php error")
+    assert_instance_of(PHPVM::PHPExceptionObject, exc)
+  end
+
+  def test_name
+    phpSimpleXMLElement = PHPVM.get_class("SimpleXMLElement")
+    assert_equal("SimpleXMLElement", phpSimpleXMLElement.name)
+  end
+end

data/test/test_php_vm_php_error_reporting.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/ruby
+
+$LOAD_PATH << File.expand_path(__FILE__+"/../../ext/php_vm")
+require "test/unit"
+require "php_vm"
+
+class TC_PHPVM_PHPErrorReporting < Test::Unit::TestCase
+  def setup
+    PHPVM.output_handler = Proc.new{|output| }
+    PHPVM.error_handler = Proc.new{|error_reporting| }
+    PHPVM.error_handler = nil
+  end
+
+  def test_raise_exception
+    assert_raises(PHPVM::PHPErrorReporting) {
+      PHPVM.exec("trigger_error('fatal err', E_USER_ERROR);")
+    }
+
+    assert_raises(PHPVM::PHPErrorReporting) {
+      PHPVM::PHPGlobal.trigger_error("fatal err", PHPVM::PHPGlobal::E_USER_ERROR)
+    }
+  end
+end

data/test/test_php_vm_php_exception_object.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/ruby
+
+$LOAD_PATH << File.expand_path(__FILE__+"/../../ext/php_vm")
+require "test/unit"
+require "php_vm"
+
+class TC_PHPVM_PHPExceptionObject < Test::Unit::TestCase
+  def setup
+    PHPVM.output_handler = Proc.new{|output| }
+    PHPVM.error_handler = Proc.new{|error_reporting| }
+  end
+
+  def test_raise_exception
+    assert_raises(PHPVM::PHPExceptionObject) {
+      PHPVM.exec("throw new Exception('error');")
+    }
+  end
+end

data/test/test_php_vm_php_global.rb

@@ -0,0 +1,111 @@
+#!/usr/bin/ruby
+
+$LOAD_PATH << File.expand_path(__FILE__+"/../../ext/php_vm")
+require "test/unit"
+require "php_vm"
+
+class TC_PHPVM_PHPGlobal < Test::Unit::TestCase
+  def setup
+    PHPVM.output_handler = Proc.new{|output| }
+    PHPVM.error_handler = Proc.new{|error_reporting| }
+  end
+
+  def test_require
+    # exists php file
+    filepath = File.expand_path(__FILE__+"/../require.php")
+    assert_equal(true, PHPVM::PHPGlobal.require(filepath))
+
+    # exists ruby file
+    # return false if require already imported file.
+    filepath = "rubygems"
+    assert_equal(false, PHPVM::PHPGlobal.require(filepath))
+
+    # non exists file
+    assert_raises(LoadError) {
+      filepath = File.expand_path(__FILE__+"/../non_exists_file.php")
+      PHPVM::PHPGlobal.require(filepath)
+    }
+  end
+
+  def test_require_once
+    # exists php file
+    filepath = File.expand_path(__FILE__+"/../require.php")
+    assert_equal(true, PHPVM::PHPGlobal.require_once(filepath))
+
+    # exists ruby file
+    # return false if require already imported file.
+    filepath = "rubygems"
+    assert_equal(false, PHPVM::PHPGlobal.require(filepath))
+
+    # non exists file
+    assert_raises(LoadError) {
+      filepath = File.expand_path(__FILE__+"/../non_exists_file.php")
+      PHPVM::PHPGlobal.require_once(filepath)
+    }
+  end
+
+  def test_echo
+    hooked_output = nil
+    PHPVM.output_handler = Proc.new{|output|
+      hooked_output = output
+    }
+
+    # string
+    PHPVM::PHPGlobal.echo("abcdefg")
+    assert_equal("abcdefg", hooked_output)
+
+    # array
+    PHPVM::PHPGlobal.echo([])
+    assert_equal("Array", hooked_output)
+  end
+
+  def test_print
+    hooked_output = nil
+    PHPVM.output_handler = Proc.new{|output|
+      hooked_output = output
+    }
+
+    # string
+    PHPVM::PHPGlobal.print("abcdefg")
+    assert_equal("abcdefg", hooked_output)
+
+    # array
+    PHPVM::PHPGlobal.print([])
+    assert_equal("Array", hooked_output)
+  end
+
+  def test_array
+    assert_equal([], PHPVM::PHPGlobal.array())
+    assert_equal([1, 2, 3], PHPVM::PHPGlobal.array(1, 2, 3))
+    assert_equal({"aaa"=>"bbb"}, PHPVM::PHPGlobal.array("aaa"=>"bbb"))
+  end
+
+  def test_native_function
+    # http_build_query
+    assert_equal("aaa=bbb", PHPVM::PHPGlobal.http_build_query({"aaa"=>"bbb"}))
+
+    # preg_replace
+    assert_equal("aBcdef", PHPVM::PHPGlobal.preg_replace('/b/', "B", "abcdef"))
+
+    # number_format
+    assert_equal("123,456,789", PHPVM::PHPGlobal.number_format(123456789))
+  end
+
+  def test_native_class
+    # stdClass
+    assert_instance_of(PHPVM::PHPClass, PHPVM::PHPGlobal::stdClass)
+    assert_equal(PHPVM::PHPClass.get("stdClass"), PHPVM::PHPGlobal::stdClass)
+
+    # SimpleXMLElement
+    assert_instance_of(PHPVM::PHPClass, PHPVM::PHPGlobal::SimpleXMLElement)
+    assert_equal(PHPVM::PHPClass.get("SimpleXMLElement"), PHPVM::PHPGlobal::SimpleXMLElement)
+
+    xml = PHPVM::PHPGlobal::SimpleXMLElement.new("<root><item>Hello World!!</item></root>")
+    assert_equal("Hello World!!", xml.item.to_s)
+  end
+
+  def test_native_constant
+    # PHP_VERSION
+    assert_match(/^\d+\.\d+\.\d+$/, PHPVM::PHPGlobal::PHP_VERSION)
+  end
+end

data/test/test_php_vm_php_object.rb

@@ -0,0 +1,87 @@
+#!/usr/bin/ruby
+
+$LOAD_PATH << File.expand_path(__FILE__+"/../../ext/php_vm")
+require "test/unit"
+require "php_vm"
+
+class TC_PHPVM_PHPObject < Test::Unit::TestCase
+  def setup
+    PHPVM.output_handler = Proc.new{|output| }
+    PHPVM.error_handler = Proc.new{|error_reporting| }
+
+    # define MagicAccessor
+    begin
+      PHPVM.get_class("MagicAccessor")
+    rescue => e
+      PHPVM.exec <<-EOS
+        class MagicAccessor
+        {
+          protected $_data = array();
+
+          public function __get($name)
+          {
+            return isset($this->_data[$name]) ? $this->_data[$name] : null;
+          }
+
+          public function __set($name, $val)
+          {
+            $this->_data[$name] = $val;
+          }
+        }
+      EOS
+    end
+
+    # define MagicCaller
+    begin
+      PHPVM.get_class("MagicCaller")
+    rescue => e
+      PHPVM.exec <<-EOS
+        class MagicCaller
+        {
+          public function __call($name, $args)
+          {
+            return $name." ".implode(", ", $args);
+          }
+        }
+      EOS
+    end
+  end
+
+  def test_php_class
+    phpSimpleXMLElement = PHPVM.get_class("SimpleXMLElement")
+    xml = phpSimpleXMLElement.new("<root><item>Hello World!!</item></root>")
+
+    assert_equal(phpSimpleXMLElement, xml.php_class)
+  end
+
+  def test_call
+    phpException = PHPVM.get_class("Exception")
+    exc = phpException.new("exc message", 123)
+
+    assert_equal("exc message", exc.getMessage)
+    assert_equal(123, exc.getCode)
+  end
+
+  def test_magic_access
+    # default object handler
+    phpMagicAccessor = PHPVM.get_class("MagicAccessor")
+    acc = phpMagicAccessor.new
+    acc.aaa = "AAA"
+
+    assert_equal("AAA", acc.aaa)
+    assert_nil(acc.bbb)
+
+    # custom object handler
+    phpSimpleXMLElement = PHPVM.get_class("SimpleXMLElement")
+    xml = phpSimpleXMLElement.new("<root><item>Hello World!!</item></root>")
+
+    assert_equal("Hello World!!", xml.item.to_s)
+  end
+
+  def test_magic_call
+    phpMagicCaller = PHPVM.get_class("MagicCaller")
+    cal = phpMagicCaller.new
+
+    assert_equal("hello aaa, bbb, ccc", cal.hello("aaa", "bbb", "ccc"))
+  end
+end

data/test/test_php_vm_php_syntax_error.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/ruby
+
+$LOAD_PATH << File.expand_path(__FILE__+"/../../ext/php_vm")
+require "test/unit"
+require "php_vm"
+
+class TC_PHPVM_PHPSyntaxError < Test::Unit::TestCase
+  def setup
+    PHPVM.output_handler = Proc.new{|output| }
+    PHPVM.error_handler = Proc.new{|error_reporting| }
+  end
+
+  def test_raise_exception
+    assert_raises(PHPVM::PHPSyntaxError) {
+      PHPVM.exec("invalid syntax code")
+    }
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: php_vm
 version: !ruby/object:Gem::Version
-  version: 1.3.10
+  version: 1.3.11
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-08 00:00:00.000000000 Z
+date: 2013-01-09 00:00:00.000000000 Z
 dependencies: []
 description: php_vm is a native bridge between Ruby and PHP.
 email:
@@ -31,6 +31,15 @@ files:
 - ext/php_vm/php_vm_z2v.c
 - ext/php_vm/php_vm_z2v.h
 - php_vm.gemspec
+- test/require.php
+- test/run_test.rb
+- test/test_php_vm.rb
+- test/test_php_vm_php_class.rb
+- test/test_php_vm_php_error_reporting.rb
+- test/test_php_vm_php_exception_object.rb
+- test/test_php_vm_php_global.rb
+- test/test_php_vm_php_object.rb
+- test/test_php_vm_php_syntax_error.rb
 homepage: https://github.com/yoshida-eth0/ruby-php_vm
 licenses: []
 post_install_message: 
@@ -55,4 +64,13 @@ rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: php_vm is a native bridge between Ruby and PHP.
-test_files: []
+test_files:
+- test/require.php
+- test/run_test.rb
+- test/test_php_vm.rb
+- test/test_php_vm_php_class.rb
+- test/test_php_vm_php_error_reporting.rb
+- test/test_php_vm_php_exception_object.rb
+- test/test_php_vm_php_global.rb
+- test/test_php_vm_php_object.rb
+- test/test_php_vm_php_syntax_error.rb