php_embed 0.0.2 → 0.0.3

data/README.md

@@ -1,2 +1,37 @@
-ruby-ext-php
-============
+php_embed
+============
+
+Ruby 上で PHP のコードを実行します
+
+Requirements
+-----------
+* ruby >= 1.9
+* php embed-sapi
+
+ruby 1.9 系でしか動きません。 
+
+コンパイル時に phpize が、
+実行に php embed-sapi 共有ライブラリが、
+それぞれ必要となります。
+
+php をソースからコンパイルする場合、そのままでは embed-sapi はコンパイルされません。
+configure 時に、 --enable-embed オプションを指定してください。
+
+CentOS6 であれば php-embeded と php-devel パッケージでも代替可能です。
+
+
+Installation
+-----------
+1. prepare php embed-sapi
+2. **gem install php_embed**
+
+Usage
+-----------
+spec ディレクトリにある rspec を参考にしてください。
+
+
+### Slide 
+http://www.slideshare.net/do_aki/php-in-ruby
+
+php-embed となっているところは php_embed の誤りです。
+

data/ext/php_embed/php.c

@@ -2,6 +2,9 @@
 #include <ruby.h>
 #include <sapi/embed/php_embed.h>
 
+#include <php_embed_value.h>
+VALUE zval_to_value(zval* val);
+
 static VALUE callback_output = Qnil;
 static VALUE callback_error = Qnil;
 
@@ -29,6 +32,75 @@ static void php_sapi_error(int type, const char *fmt, ...)
     va_end(va);
 }
 
+static int is_array_convertable(HashTable* ht) {
+  HashPosition pos;
+  char  *string_key;
+  ulong num_index;
+  ulong index = 0;
+
+  zend_hash_internal_pointer_reset_ex(ht, &pos);
+  do {
+    switch(zend_hash_get_current_key_ex(ht, &string_key, NULL, &num_index, 0, &pos)) {
+      case HASH_KEY_IS_STRING:
+        return 0;
+      case HASH_KEY_NON_EXISTANT:
+        return 1;
+      case HASH_KEY_IS_LONG:
+        if (num_index != index) {
+          return 0;
+        }
+        ++index;
+    }
+  } while(SUCCESS == zend_hash_move_forward_ex(ht, &pos));
+  return 1;
+}
+
+static VALUE hash_to_array(HashTable* ht) {
+  HashPosition pos;
+  zval** data;
+  VALUE ret;
+
+  ret = rb_ary_new2(zend_hash_num_elements(ht));
+
+  zend_hash_internal_pointer_reset_ex(ht, &pos);
+  while (SUCCESS == zend_hash_get_current_data_ex(ht, (void **)&data, &pos)) {
+    VALUE t = zval_to_value(*data);
+    rb_ary_push(ret, t);
+    zend_hash_move_forward_ex(ht, &pos);
+  }
+  return ret;
+}
+
+static VALUE hash_to_hash(HashTable* ht) {
+  HashPosition pos;
+  zval** data;
+  VALUE ret;
+
+  ret = rb_hash_new();
+
+  zend_hash_internal_pointer_reset_ex(ht, &pos);
+  while (SUCCESS == zend_hash_get_current_data_ex(ht, (void **)&data, &pos)) {
+    char* string_key;
+    ulong num_index;
+    VALUE key = Qnil;
+    VALUE val = zval_to_value(*data);
+
+    switch(zend_hash_get_current_key_ex(ht, &string_key, NULL, &num_index, 0, &pos)) {
+      case HASH_KEY_IS_STRING:
+        key = rb_str_new_cstr(string_key);
+        break;
+      case HASH_KEY_IS_LONG:
+        key = LONG2NUM(num_index);
+        break;
+    }
+
+    rb_hash_aset(ret, key, val);
+    zend_hash_move_forward_ex(ht, &pos);
+  }
+  return ret;
+}
+
+
 VALUE zval_to_value(zval* val) {
   VALUE r;
 
@@ -42,144 +114,139 @@ VALUE zval_to_value(zval* val) {
     case IS_DOUBLE:
       return DBL2NUM(Z_DVAL_P(val));
     case IS_ARRAY:
+    case IS_CONSTANT_ARRAY:
       {
         HashTable* ht = Z_ARRVAL_P(val);
-        HashPosition p;
-        int idx = 0;
-        zval** data;
 
-        r = rb_ary_new2(zend_hash_num_elements(ht));
+        if (0 == zend_hash_num_elements(ht)) {
+          return rb_ary_new();
+        }
 
-        zend_hash_internal_pointer_reset_ex(ht, &p);
-        while (zend_hash_get_current_data_ex(ht, (void **)&data, &p) == SUCCESS) {
-          VALUE t = zval_to_value(*data);
-          rb_ary_store(r, idx++, t);
-          zend_hash_move_forward_ex(ht, &p);
+        if (is_array_convertable(ht)) {
+          return hash_to_array(ht);
         }
-        return r; 
+
+        return hash_to_hash(ht);
       }
     case IS_OBJECT:
-    case IS_STRING:
     case IS_RESOURCE:
     case IS_CONSTANT:
-    case IS_CONSTANT_ARRAY:
-    default:
       convert_to_string(val);
+    case IS_STRING:
       return rb_str_new(Z_STRVAL_P(val), Z_STRLEN_P(val));
+    default:
+      return Qnil;
   }
 }
 
-void value2php_arg(VALUE v, char* out_arg) {
-  switch (TYPE(v)) {
-    case T_FALSE:
-    	strcat(out_arg, "false");
-      return;
-    case T_TRUE:
-    	strcat(out_arg, "true");
-      return;
-    case T_UNDEF:
-    case T_NIL:
-    	strcat(out_arg, "null");
-      return;
-    case T_FIXNUM:
-      {
-        VALUE t = rb_fix2str(v, 10);
-        strcat(out_arg, StringValuePtr(t));
-      }
-      return;
-    case T_BIGNUM:
-      {
-        VALUE t = rb_big2str(v, 10);
-        strcat(out_arg, StringValuePtr(t));
-      }
-      return;
-    case T_FLOAT:
-      {
-        VALUE t = rb_funcall(v, rb_intern("to_s"), 0);
-        strcat(out_arg, StringValuePtr(t));
-      }
-      return;
-    case T_ARRAY:
-      {
-        int i;
-        strcat(out_arg, "array(");
-        for(i=0;i<RARRAY_LEN(v);++i) {
-          value2php_arg(RARRAY_PTR(v)[i], out_arg);
-          if (i != RARRAY_LEN(v)-1) {
-            strcat(out_arg, ",");
-          }
-        }
-        strcat(out_arg, ")");
-      }
-    case T_HASH:
-      /* no implement */
-      return;
-    case T_STRING:
-    default:
-      strcat(out_arg, "'");
-      strcat(out_arg, StringValuePtr(v));
-      strcat(out_arg, "'");
-  }
+int eval_php_code(char* code) {
+  int ret = 0;
+
+  zend_try {
+    ret = zend_eval_string(code, NULL, (char*)"" TSRMLS_CC);
+  } zend_catch {
+
+  } zend_end_try();
+
+  return FAILURE == ret;
 }
 
-int eval_php_code(char* code, VALUE* return_value) {
-  const char *argv[2] = {"ruby", NULL};
+int eval_and_return_php_code(char* code, VALUE* return_value) {
   int err = 0;
-  zval **data;
   zval retval;
 
-  PHP_EMBED_START_BLOCK(1, (char**)argv);
-
-  if (zend_eval_string(code, &retval, (char*)"" TSRMLS_CC) == FAILURE) {
-    err = 1;
-  }
+  zend_try {
+    if (zend_eval_string(code, &retval, (char*)"" TSRMLS_CC) == FAILURE) {
+      err = 1;
+    } else {
+      *return_value = zval_to_value(&retval);
+      zval_dtor(&retval);
+    }
 
-  PHP_EMBED_END_BLOCK();
+  } zend_catch {
 
-  *return_value = zval_to_value(&retval);
-  zval_dtor(&retval);
+  } zend_end_try();
 
   return err;
 }
 
 VALUE php_eval(VALUE self, VALUE code) {
-  VALUE retval;
-  if (eval_php_code(StringValuePtr(code), &retval)) {
+  if (eval_php_code(StringValuePtr(code))) {
     rb_raise(rb_eRuntimeError, "invalid code");
   }
 
-  return retval;
+  return Qnil;
 }
 
 VALUE php_call(int argc, VALUE *argv, VALUE self) {
-  VALUE func, args, retval;
+  VALUE func, args, arg_str, retval;
   int i;
-  char arg_str[1024], call_str[2048];
-  zval* t = NULL;
+  char* call_str;
 
   rb_scan_args(argc, argv, "1*", &func, &args);
 
-  
-  arg_str[0] = '\0';
+  if (T_SYMBOL == TYPE(func)) {
+    func = rb_sym_to_s(func); 
+  }
+
+  if (T_STRING != TYPE(func)) {
+    rb_raise(rb_eRuntimeError, "invalid function name");
+  }
+
+  arg_str = rb_str_new_cstr("");
   for(i=0; i<argc-1; ++i) {
-    char arg[255] = "";
-    value2php_arg(RARRAY_PTR(args)[i], arg);
-    strcat(arg_str, arg);
+    VALUE r = convert_value_into_php_string(RARRAY_PTR(args)[i]);
+    rb_str_cat(arg_str, RSTRING_PTR(r), RSTRING_LEN(r));
     
     if (i != argc-2) {
-      strcat(arg_str, ",");
+      rb_str_cat2(arg_str, ",");
     }
   }
 
-  sprintf(call_str, "%s(%s)", StringValuePtr(func), arg_str);
-  //printf("\n***%s***\n", call_str);
-  if (eval_php_code(call_str, &retval)) {
+  call_str = malloc(RSTRING_LEN(func) + RSTRING_LEN(arg_str) + sizeof("()") + 1);
+  sprintf(call_str, "%s(%s)", RSTRING_PTR(func), RSTRING_PTR(arg_str));
+  if (eval_and_return_php_code(call_str, &retval)) {
     rb_raise(rb_eRuntimeError, "eval error");
-  }	
+  }
 
   return retval;
 }
 
+VALUE php_run(VALUE self, VALUE file) {
+  VALUE retval = Qtrue;
+  zend_file_handle handle;
+
+  if (T_STRING != TYPE(file)) {
+    rb_raise(rb_eRuntimeError, "file must be string");
+  }
+
+  handle.type = ZEND_HANDLE_FILENAME;
+  handle.filename = RSTRING_PTR(file);
+  handle.opened_path = NULL;
+  handle.free_filename = 0;
+  
+  zend_try {
+    zend_execute_scripts(ZEND_REQUIRE TSRMLS_CC, NULL, 1, &handle);
+  } zend_catch {
+    retval = Qfalse;
+  } zend_end_try();
+
+  return retval;
+
+}
+
+VALUE php_fetch_variable(VALUE self, VALUE name) {
+  zval *data = NULL;
+  if (FAILURE == zend_hash_find(&EG(symbol_table), StringValuePtr(name), RSTRING_LEN(name), (void **)&data)) {
+    /* Name not found in $GLOBALS */
+  }
+  if (data == NULL) {
+    /* Value is NULL (not possible for symbol_table?) */
+  }
+ 
+  return Qnil;
+}
+
 VALUE php_set_output_handler(VALUE self, VALUE callback) {
   if (rb_obj_is_proc(callback)) {
     callback_output = callback;
@@ -200,21 +267,49 @@ VALUE php_set_error_handler(VALUE self, VALUE callback) {
   return Qnil;
 }
 
+void initialize_php_embed() {
+  const char *argv[2] = {"ruby", NULL};
+  php_embed_init(1, (char**)argv);
+  EG(bailout)=NULL;
+}
+
+void shutdown_php_embed() {
+  php_embed_shutdown(TSRMLS_C);
+}
+
+VALUE mPhpEmbed;
+
 Init_php() {
 
-  VALUE cPhp;
-  cPhp = rb_define_module("PhpEmbed");
-  //rb_define_const(cPhp, "VERSION", rb_ary_new3(3, INT2FIX(0), INT2FIX(0), INT2FIX(1)));
+  mPhpEmbed = rb_define_module("PhpEmbed");
+
+  init_php_value();
 
-  rb_define_singleton_method(cPhp, "eval", php_eval, 1);
-  rb_define_singleton_method(cPhp, "call", php_call, -1);
-  rb_define_singleton_method(cPhp, "setOutputHandler", php_set_output_handler, 1);
-  rb_define_singleton_method(cPhp, "setErrorHandler", php_set_error_handler, 1);
+  //rb_define_const(mPhpEmbed, "VERSION", rb_ary_new3(3, INT2FIX(0), INT2FIX(0), INT2FIX(1)));
+
+  rb_define_singleton_method(mPhpEmbed, "eval", php_eval, 1);
+  rb_define_singleton_method(mPhpEmbed, "call", php_call, -1);
+  rb_define_singleton_method(mPhpEmbed, "run", php_run, 1);
+  rb_define_singleton_method(mPhpEmbed, "fetchVariable", php_fetch_variable, 1);
+  rb_define_singleton_method(mPhpEmbed, "setOutputHandler", php_set_output_handler, 1);
+  rb_define_singleton_method(mPhpEmbed, "setErrorHandler", php_set_error_handler, 1);
    
   php_embed_module.ub_write = php_ub_write;
   php_embed_module.log_message = php_log_message;
   php_embed_module.sapi_error = php_sapi_error;
 
+  initialize_php_embed();
+  atexit(shutdown_php_embed);
+
+/*
+  zend_try {
+    zend_alter_ini_entry((char*)"display_errors", sizeof("display_errors")
+      , (char*)"0", sizeof("0")-1, PHP_INI_SYSTEM, PHP_INI_STAGE_RUNTIME);
+    zend_alter_ini_entry((char*)"log_errors", sizeof("log_errors")
+      , (char*)"1", sizeof("1")-1, PHP_INI_SYSTEM, PHP_INI_STAGE_RUNTIME);
+  } zend_catch {
+  } zend_end_try();
+*/
 }
 
 

data/ext/php_embed/php_embed_value.c

@@ -0,0 +1,156 @@
+#include <ruby.h>
+#include <php.h>
+#include <php_embed_value.h>
+
+static void php_value_mark(php_value* pv) {
+  if (pv) {
+    rb_gc_mark(pv->value);
+  }
+}
+
+static void php_value_free(php_value* pv) {
+  if (pv) {
+    xfree(pv);
+  }
+}
+
+static VALUE php_value_alloc(VALUE klass) {
+  php_value * pv;
+  return Data_Make_Struct(klass, php_value, php_value_mark, php_value_free, pv);
+}
+
+static int hash_to_php_string_array(VALUE key, VALUE value, VALUE ary) {
+    VALUE k,v,r;
+    int key_type;
+
+    if (key == Qundef) { 
+      return ST_CONTINUE;
+    }
+
+    key_type = TYPE(key);
+    if (T_FIXNUM != key_type && T_BIGNUM != key_type 
+        && T_STRING != key_type && T_SYMBOL != key_type) {
+      rb_raise(rb_eRuntimeError, "invalid key (%d)", key_type);
+    }
+
+    k = convert_value_into_php_string(key);
+    r = rb_str_new_cstr(RSTRING_PTR(k));
+    rb_str_cat2(r, "=>");
+    v = convert_value_into_php_string(value);
+    rb_str_cat2(r, RSTRING_PTR(v));
+
+    rb_ary_push(ary, r);
+    return ST_CONTINUE;
+}
+
+VALUE convert_value_into_php_string(VALUE v) {
+  switch (TYPE(v)) {
+    case T_FALSE:
+      return rb_str_new_cstr("false");
+    case T_TRUE:
+      return rb_str_new_cstr("true");
+    case T_UNDEF:
+    case T_NIL:
+      return rb_str_new_cstr("null");
+    case T_FIXNUM:
+      return rb_fix2str(v, 10);
+    case T_BIGNUM:
+      return rb_big2str(v, 10);
+    case T_FLOAT:
+      return rb_funcall(v, rb_intern("to_s"), 0);
+    case T_ARRAY:
+      {
+        int i;
+        VALUE ret = rb_str_new_cstr("array(");
+        for(i=0;i<RARRAY_LEN(v);++i) {
+          VALUE p = convert_value_into_php_string(RARRAY_PTR(v)[i]);
+          if (T_STRING == TYPE(p)) {
+            rb_str_cat2(ret, StringValuePtr(p));
+          }
+          if (i != RARRAY_LEN(v)-1) {
+            rb_str_cat2(ret, ",");
+          }
+        }
+        rb_str_cat2(ret, ")");
+        return ret;
+      }
+    case T_HASH:
+      {
+        VALUE ret = rb_str_new_cstr("array(");
+        VALUE ary = rb_ary_new();
+
+        rb_hash_foreach(v, hash_to_php_string_array, ary);
+        
+        {
+          int i;
+          int len = RARRAY_LEN(ary);
+
+          VALUE* p = RARRAY_PTR(ary);
+          for(i=0; i<len; ++i) {
+            rb_str_cat2(ret, StringValuePtr(p[i]));
+            if (i != len-1) {
+              rb_str_cat2(ret, ",");
+            }
+          }
+        }
+        rb_str_cat2(ret, ")");
+        return ret;
+      }
+    case T_SYMBOL:
+      {
+        VALUE symbol_str = rb_sym_to_s(v);
+        VALUE ret = rb_str_new_cstr("'");
+        rb_str_cat2(ret, StringValuePtr(symbol_str));
+        rb_str_cat2(ret, "'");
+        return ret;
+      }
+    case T_STRING:
+      {
+        VALUE ret = rb_str_new_cstr("'");
+        rb_str_cat2(ret, StringValuePtr(v));
+        rb_str_cat2(ret, "'");
+        return ret;
+      } 
+    default:
+      rb_raise(rb_eRuntimeError, "no implemented");
+  }
+}
+
+
+VALUE php_value_initialize(VALUE self, VALUE value) {
+  php_value* pv;
+  Data_Get_Struct(self, php_value, pv);
+
+  pv->value = value;
+  return Qnil;
+}
+
+VALUE php_value_to_string(VALUE self) {
+  VALUE ret;
+  php_value* pv;
+  Data_Get_Struct(self, php_value, pv);
+
+  return convert_value_into_php_string(pv->value);
+}
+
+VALUE php_value_parse_php_string(VALUE self, VALUE php_string) {
+  return Qnil;
+}
+
+
+extern mPhpEmbed;
+VALUE cPhpEmbedValue;
+void init_php_value() {
+#if 0
+  mPhpEmbed = rb_define_module("PhpEmbed");
+#endif
+
+  cPhpEmbedValue = rb_define_class_under(mPhpEmbed, "Value", rb_cObject);
+  rb_define_alloc_func(cPhpEmbedValue, php_value_alloc);
+  rb_define_method(cPhpEmbedValue, "initialize", php_value_initialize, 1);
+  rb_define_method(cPhpEmbedValue, "to_s", php_value_to_string, 0);
+
+  rb_define_singleton_method(cPhpEmbedValue, "parse", php_value_parse_php_string, 1);
+
+
+}

data/ext/php_embed/php_embed_value.h

@@ -0,0 +1,13 @@
+#ifndef PHP_EMBED_VALUE
+#define PHP_EMBED_VALUE
+
+void init_php_value();
+
+VALUE convert_value_into_php_string(VALUE v);
+
+typedef struct {
+  VALUE value;
+} php_value;
+
+#endif
+

data/lib/php_embed/version.rb

@@ -1,3 +1,3 @@
 module PhpEmbed
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/spec/php_spec.rb

@@ -1,18 +1,9 @@
 # encoding: UTF-8
 require 'php_embed'
 
-describe 'PhpEmbed' do
+describe PhpEmbed do
 
   describe 'eval' do 
-      it 'return any types' do
-          PhpEmbed.eval('true').should be_true 
-          PhpEmbed.eval('false').should be_false;
-          PhpEmbed.eval('null').should be_nil
-          PhpEmbed.eval('1').should == 1
-          PhpEmbed.eval('array()').should == []
-          PhpEmbed.eval('array(1)').should == [1]
-      end
-     
       it 'raise error with invalid PhpEmbed code' do
           proc {
               PhpEmbed.eval("i n v a l i d")
@@ -20,11 +11,25 @@ describe 'PhpEmbed' do
       end 
   end 
 
-  describe 'call' do
-      it 'return phpversion' do
-          PhpEmbed.call("phpversion").should == "5.4.5"
-      end 
+  describe 'eval and call' do
+      it '1' do 
+          PhpEmbed.eval('function hoge(){ return 1; }');
+          PhpEmbed.call('hoge').should == 1;
+      end
+      it 'any value' do 
+          PhpEmbed.eval('function hoge2($arg){ return $arg; }');
+          PhpEmbed.call('hoge2', 1).should == 1;
+          PhpEmbed.call('hoge2', 'a').should == 'a';
+          PhpEmbed.call('hoge2', []).should == [];
+          PhpEmbed.call('hoge2', [1]).should == [1];
+          PhpEmbed.call('hoge2', {0=>1,1=>2}).should == [1,2];
+          PhpEmbed.call('hoge2', {10=>2}).should == {10=>2};
+          PhpEmbed.call('hoge2', {'a'=>1}).should == {'a'=>1};
+      end
+  end
 
+
+  describe 'call' do
       it 'bin2hex return hex string' do
           PhpEmbed.call("bin2hex", "+").should == "2b"
       end 
@@ -44,7 +49,7 @@ describe 'PhpEmbed' do
       end 
     
       it 'call with array' do
-          PhpEmbed.call("array_diff", [1,2,3,4,5], [3,4]).should == [1,2,5]
+          PhpEmbed.call("array_diff", [1,2,3,4,5], [3,4]).should == {0=>1,1=>2,4=>5}
       end 
 
       it 'raise error with invalid PhpEmbed code' do
@@ -61,7 +66,7 @@ describe 'PhpEmbed' do
           capture = output
         })
         
-        PhpEmbed.eval('print("hoge")')
+        PhpEmbed.eval('print("hoge");')
         capture.should == 'hoge'
     end 
   end
@@ -73,13 +78,8 @@ describe 'PhpEmbed' do
           capture << error
         })
         
-        PhpEmbed.eval('trigger_error("hoge")')
-        capture.should == [
-          "PHP Notice:  hoge in  on line 1",
-          "PHP Stack trace:",
-          "PHP   1. {main}() :0",
-          "PHP   2. trigger_error() :1"
-        ]
+        PhpEmbed.eval('trigger_error("hoge");')
+        capture.join('').should match('PHP Notice:')
     end 
   end
 

data/spec/php_value_spec.rb

@@ -0,0 +1,29 @@
+describe PhpEmbed::Value do
+  it 'convert nil' do
+    PhpEmbed::Value.new(nil).to_s.should == 'null';
+  end
+  it 'convert boolean' do
+    PhpEmbed::Value.new(false).to_s.should == 'false';
+    PhpEmbed::Value.new(true).to_s.should == 'true';
+  end
+
+  it 'convert scalar' do
+    PhpEmbed::Value.new(1).to_s.should == '1';
+    PhpEmbed::Value.new("a").to_s.should == "'a'";
+    PhpEmbed::Value.new(:a).to_s.should == "'a'";
+  end
+
+  it 'convert array' do
+    PhpEmbed::Value.new([]).to_s.should == 'array()';
+    PhpEmbed::Value.new([1,2,3]).to_s.should == 'array(1,2,3)';
+    PhpEmbed::Value.new(['a', 'b']).to_s.should == "array('a','b')";
+  end
+
+  it 'convert hash' do
+    PhpEmbed::Value.new({}).to_s.should == 'array()';
+    PhpEmbed::Value.new({1=>'a'}).to_s.should == "array(1=>'a')";
+    PhpEmbed::Value.new({'a'=>1}).to_s.should == "array('a'=>1)";
+    PhpEmbed::Value.new({:a=>1}).to_s.should == "array('a'=>1)";
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: php_embed
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-01 00:00:00.000000000 Z
+date: 2012-09-16 00:00:00.000000000 Z
 dependencies: []
 description: execute PHP code in Ruby code
 email:
@@ -26,10 +26,13 @@ files:
 - Rakefile
 - ext/php_embed/extconf.rb
 - ext/php_embed/php.c
+- ext/php_embed/php_embed_value.c
+- ext/php_embed/php_embed_value.h
 - lib/php_embed.rb
 - lib/php_embed/version.rb
 - php_embed.gemspec
 - spec/php_spec.rb
+- spec/php_value_spec.rb
 homepage: https://github.com/do-aki/php_embed
 licenses: []
 post_install_message: 
@@ -56,3 +59,4 @@ specification_version: 3
 summary: execute PHP code in Ruby code
 test_files:
 - spec/php_spec.rb
+- spec/php_value_spec.rb