php_embed 0.0.3 → 0.1.0

data/.gitignore

@@ -15,3 +15,9 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+
+ext/php_embed/*.so
+ext/php_embed/*.o
+ext/php_embed/mkmf.log
+ext/php_embed/Makefile
+

data/Rakefile

@@ -4,9 +4,6 @@ require "bundler/gem_tasks"
 require 'rspec'
 require 'rspec/core/rake_task'
 
-desc "Run test"
-RSpec::Core::RakeTask.new('spec') do |t|
-    t.verbose = true
-end
 
-task :default => :spec
+RSpec::Core::RakeTask.new(:spec)
+

data/ext/php_embed/convert.c

@@ -0,0 +1,271 @@
+#include "value.h"
+#include "convert.h"
+
+
+VALUE zval_to_array(zval* zv) {
+  HashTable* ht;
+  HashPosition pos;
+  zval** data;
+  VALUE ret;
+
+  convert_to_array(zv);
+  ht = Z_ARRVAL_P(zv);  
+
+  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)) {
+    rb_ary_push(ret, new_php_embed_value(*data));
+    zend_hash_move_forward_ex(ht, &pos);
+  }
+  return ret;
+}
+
+VALUE zval_to_hash(zval* zv) {
+  HashTable* ht;
+  HashPosition pos;
+  zval** data;
+  VALUE ret;
+
+  convert_to_array(zv);
+  ht = Z_ARRVAL_P(zv);  
+
+  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* key_str;
+    uint key_len;
+    ulong num_index;
+    VALUE key = Qnil;
+    VALUE val = new_php_embed_value(*data);
+
+    switch(zend_hash_get_current_key_ex(ht, &key_str, &key_len, &num_index, 0, &pos)) {
+      case HASH_KEY_IS_STRING:
+        //key = rb_str_new(key_str, key_len);
+        key = rb_str_new_cstr(key_str);
+        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;
+}
+
+
+
+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_to_php_string(key);
+  r = rb_str_new_cstr(RSTRING_PTR(k));
+  rb_str_cat2(r, "=>");
+  v = convert_value_to_php_string(value);
+  rb_str_cat2(r, RSTRING_PTR(v));
+
+  rb_ary_push(ary, r);
+  return ST_CONTINUE;
+}
+
+
+static int hash_to_zval(VALUE key, VALUE value, VALUE zval_array) {
+  zval *v;
+  zval *ary;
+
+  if (key == Qundef) { 
+    return ST_CONTINUE;
+  }
+
+  ary = (zval*)zval_array;
+  v = value_to_zval(value);
+
+  if (Qtrue == key) {
+    zend_hash_index_update(Z_ARRVAL_P(ary), 1, &v, sizeof(zval *), NULL);
+    return ST_CONTINUE;
+  }
+
+  if (Qfalse == key || Qnil == key) {
+    zend_hash_index_update(Z_ARRVAL_P(ary), 0, &v, sizeof(zval *), NULL);
+    return ST_CONTINUE;
+  }
+
+  if (T_FIXNUM == TYPE(key)) {
+    int idx = FIX2INT(key);
+    zend_hash_index_update(Z_ARRVAL_P(ary), idx, &v, sizeof(zval *), NULL);
+    return ST_CONTINUE;
+  }
+
+  switch (TYPE(key)) {
+    case T_BIGNUM:
+      key = rb_big2str(key, 10);
+      break;
+    case T_SYMBOL:
+      key = rb_sym_to_s(key);
+      break;
+    case T_STRING:
+      key = rb_string_value(&key);
+      break;
+    default:
+      rb_raise(rb_eRuntimeError, "invalid key (%d)", TYPE(key));
+  }
+
+  //ZEND_HANDLE_NUMERIC(RSTRING_PTR(key), RSTRING_LEN(key), zend_hash_index_update(Z_ARRVAL_P(ary), idx, &v, sizeof(zval *), NULL));
+  zend_symtable_update(Z_ARRVAL_P(ary), RSTRING_PTR(key), RSTRING_LEN(key) + 1, &v, sizeof(zval *), NULL);
+
+  return ST_CONTINUE;
+}
+
+
+VALUE convert_value_to_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_to_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");
+  }
+}
+
+zval* value_to_zval(VALUE v) {
+  zval* zv;
+  MAKE_STD_ZVAL(zv);
+
+  switch (TYPE(v)) {
+    case T_FALSE:
+      ZVAL_FALSE(zv);
+      return zv;
+    case T_TRUE:
+      ZVAL_TRUE(zv);
+      return zv;
+    case T_UNDEF:
+    case T_NIL:
+      ZVAL_NULL(zv);
+      return zv;
+    case T_FIXNUM:
+      ZVAL_LONG(zv, rb_fix2int(v));
+      return zv;
+    case T_BIGNUM:
+      ZVAL_LONG(zv, rb_big2long(v)); // FIXME: bignum over long
+      return zv;
+    case T_FLOAT:
+      ZVAL_DOUBLE(zv, RFLOAT_VALUE(v));
+      return zv;
+    case T_ARRAY:
+      {
+        int i;
+        array_init(zv);
+        for(i=0;i<RARRAY_LEN(v);++i) {
+          zval *add = value_to_zval(RARRAY_PTR(v)[i]);
+          zend_hash_next_index_insert(Z_ARRVAL_P(zv), &add, sizeof(zval*), NULL);
+        }
+        return zv;
+      }
+    case T_HASH:
+      {
+        array_init(zv);
+        rb_hash_foreach(v, hash_to_zval, (VALUE)zv);
+        return zv;
+      }
+    case T_SYMBOL:
+      {
+        VALUE symbol_str = rb_sym_to_s(v);
+        ZVAL_STRINGL(zv, StringValuePtr(symbol_str), RSTRING_LEN(symbol_str), 1);
+        return zv;
+      }
+    case T_STRING:
+      {
+        ZVAL_STRINGL(zv, StringValuePtr(v), RSTRING_LEN(v), 1);
+        return zv;
+      } 
+    default:
+      {
+        if (CLASS_OF(v) == cPhpEmbedValue) {
+          php_value* pv;
+          Data_Get_Struct(v, php_value, pv);
+          MAKE_COPY_ZVAL(&pv->value, zv);
+          return zv;
+        }
+      }
+      FREE_ZVAL(zv);
+      rb_raise(rb_eRuntimeError, "no implemented");
+  }
+}
+

data/ext/php_embed/convert.h

@@ -0,0 +1,14 @@
+#ifndef PHP_EMBED_CONVERT
+#define PHP_EMBED_CONVERT
+
+#include <ruby.h>
+#include <php.h>
+
+
+VALUE zval_to_hash(zval* zv);
+VALUE zval_to_array(zval* zv);
+
+VALUE convert_value_to_php_string(VALUE v);
+zval* value_to_zval(VALUE v);
+
+#endif

data/ext/php_embed/php.c

@@ -1,13 +1,19 @@
 #include <stdio.h>
 #include <ruby.h>
 #include <sapi/embed/php_embed.h>
-
-#include <php_embed_value.h>
-VALUE zval_to_value(zval* val);
+#include "value.h"
+#include "convert.h"
 
 static VALUE callback_output = Qnil;
 static VALUE callback_error = Qnil;
 
+
+VALUE mPhpEmbed;
+
+VALUE rb_ePhpEmbedStanderdError;
+VALUE rb_ePhpEmbedSyntaxError;
+VALUE rb_ePhpEmbedMissingError;
+
 static int php_ub_write(const char *str, unsigned int str_length TSRMLS_DC)
 {
   if (!NIL_P(callback_output)) {
@@ -32,113 +38,6 @@ 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;
-
-  switch(Z_TYPE_P(val)) {
-    case IS_NULL:
-      return Qnil;
-    case IS_BOOL:
-      return (zval_is_true(val)) ? Qtrue : Qfalse;
-    case IS_LONG:
-      return INT2NUM(Z_LVAL_P(val));
-    case IS_DOUBLE:
-      return DBL2NUM(Z_DVAL_P(val));
-    case IS_ARRAY:
-    case IS_CONSTANT_ARRAY:
-      {
-        HashTable* ht = Z_ARRVAL_P(val);
-
-        if (0 == zend_hash_num_elements(ht)) {
-          return rb_ary_new();
-        }
-
-        if (is_array_convertable(ht)) {
-          return hash_to_array(ht);
-        }
-
-        return hash_to_hash(ht);
-      }
-    case IS_OBJECT:
-    case IS_RESOURCE:
-    case IS_CONSTANT:
-      convert_to_string(val);
-    case IS_STRING:
-      return rb_str_new(Z_STRVAL_P(val), Z_STRLEN_P(val));
-    default:
-      return Qnil;
-  }
-}
-
 int eval_php_code(char* code) {
   int ret = 0;
 
@@ -159,7 +58,8 @@ int eval_and_return_php_code(char* code, VALUE* return_value) {
     if (zend_eval_string(code, &retval, (char*)"" TSRMLS_CC) == FAILURE) {
       err = 1;
     } else {
-      *return_value = zval_to_value(&retval);
+      //*return_value = zval_to_value(&retval);
+      *return_value = new_php_embed_value(&retval);
       zval_dtor(&retval);
     }
 
@@ -172,52 +72,114 @@ int eval_and_return_php_code(char* code, VALUE* return_value) {
 
 VALUE php_eval(VALUE self, VALUE code) {
   if (eval_php_code(StringValuePtr(code))) {
-    rb_raise(rb_eRuntimeError, "invalid code");
+    rb_raise(rb_ePhpEmbedSyntaxError, "invalid code");
   }
 
   return Qnil;
 }
 
+
+zend_function* php_find_function(char* name) {
+  char* lcname;
+  int name_len;
+  int found;
+  zend_function *func;
+
+  name_len = strlen(name);
+  lcname = zend_str_tolower_dup(name, name_len);
+
+  name = lcname;
+  if ('\\' == lcname[0]) {
+    name = &lcname[1];
+    name_len--;
+  }
+
+  found = (SUCCESS == zend_hash_find(EG(function_table), name, name_len+1, (void**)&func));
+  efree(lcname);
+
+  if (found) {
+    return func;
+  }
+
+  return NULL;
+}
+
+
+
 VALUE php_call(int argc, VALUE *argv, VALUE self) {
-  VALUE func, args, arg_str, retval;
-  int i;
-  char* call_str;
+  VALUE name, args, retval;
+  zend_function* func;
+  int call_result, i;
+  zval *retval_ptr;
+  zend_fcall_info fci;
+  zend_fcall_info_cache fcc;
+  zval ***call_args;
+  zval **zval_array;
+
+  rb_scan_args(argc, argv, "1*", &name, &args);
+
+  if (T_SYMBOL == TYPE(name)) {
+    name = rb_sym_to_s(name); 
+  }
 
-  rb_scan_args(argc, argv, "1*", &func, &args);
+  if (T_STRING != TYPE(name)) {
+    rb_raise(rb_eArgError, "invalid function name");
+  }
 
-  if (T_SYMBOL == TYPE(func)) {
-    func = rb_sym_to_s(func); 
+
+  func = php_find_function(StringValueCStr(name));
+  if (!func) {
+    rb_raise(rb_ePhpEmbedMissingError, "function not found");
   }
 
-  if (T_STRING != TYPE(func)) {
-    rb_raise(rb_eRuntimeError, "invalid function name");
+  zval_array = (zval**)malloc(sizeof(zval*) * argc-1); 
+  call_args = (zval***)malloc(sizeof(zval**) * argc-1); 
+  for(i=0; i<argc-1; ++i) {
+    zval_array[i] = value_to_zval(RARRAY_PTR(args)[i]);
+    call_args[i] = &zval_array[i];
   }
+  
+  fci.size = sizeof(fci);
+  fci.function_table = NULL;
+  fci.function_name = NULL;
+  fci.symbol_table = NULL;
+  fci.object_ptr = NULL;
+  fci.retval_ptr_ptr = &retval_ptr;
+  fci.param_count = argc-1;
+  fci.params = call_args;
+  fci.no_separation = 1;
+
+  fcc.initialized = 1;
+  fcc.function_handler = func;
+  fcc.calling_scope = EG(scope);
+  fcc.called_scope = NULL;
+  fcc.object_ptr = NULL;
+
+  call_result = zend_call_function(&fci, &fcc TSRMLS_CC);
+  retval = new_php_embed_value(retval_ptr);
+
+  free(call_args);
 
-  arg_str = rb_str_new_cstr("");
   for(i=0; i<argc-1; ++i) {
-    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) {
-      rb_str_cat2(arg_str, ",");
-    }
+    zval_dtor(zval_array[i]);
+    FREE_ZVAL(zval_array[i]);
   }
+  free(zval_array);
 
-  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");
+  if (FAILURE == call_result) {
+    rb_raise(rb_ePhpEmbedStanderdError, "function call fairure");
   }
 
   return retval;
 }
 
-VALUE php_run(VALUE self, VALUE file) {
+VALUE php_require(VALUE self, VALUE file) {
   VALUE retval = Qtrue;
   zend_file_handle handle;
 
   if (T_STRING != TYPE(file)) {
-    rb_raise(rb_eRuntimeError, "file must be string");
+    rb_raise(rb_eArgError, "file must be string");
+    return Qnil;
   }
 
   handle.type = ZEND_HANDLE_FILENAME;
@@ -232,7 +194,6 @@ VALUE php_run(VALUE self, VALUE file) {
   } zend_end_try();
 
   return retval;
-
 }
 
 VALUE php_fetch_variable(VALUE self, VALUE name) {
@@ -277,7 +238,6 @@ void shutdown_php_embed() {
   php_embed_shutdown(TSRMLS_C);
 }
 
-VALUE mPhpEmbed;
 
 Init_php() {
 
@@ -289,7 +249,7 @@ Init_php() {
 
   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, "require", php_require, 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);
@@ -301,6 +261,10 @@ Init_php() {
   initialize_php_embed();
   atexit(shutdown_php_embed);
 
+
+  rb_ePhpEmbedStanderdError = rb_define_class_under(mPhpEmbed, "StanderdError", rb_eException);
+  rb_ePhpEmbedSyntaxError = rb_define_class_under(mPhpEmbed, "SyntaxError", rb_ePhpEmbedStanderdError);
+  rb_ePhpEmbedMissingError = rb_define_class_under(mPhpEmbed, "MissingError", rb_ePhpEmbedStanderdError);
 /*
   zend_try {
     zend_alter_ini_entry((char*)"display_errors", sizeof("display_errors")

data/ext/php_embed/value.c

@@ -0,0 +1,192 @@
+#include <string.h>
+#include <ruby.h>
+#include <php.h>
+#include "value.h"
+#include "convert.h"
+
+extern mPhpEmbed;
+VALUE cPhpEmbedValue;
+
+static void php_value_mark(php_value* pv) {
+  if (pv) {
+    pv->value = NULL;
+    //rb_gc_mark(pv->value);
+  }
+}
+
+static void php_value_free(php_value* pv) {
+  if (pv) {
+    if (NULL != pv->value) {
+      zval_dtor(pv->value);
+      FREE_ZVAL(pv->value);
+    }
+    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);
+}
+
+
+VALUE new_php_embed_value(zval* value) {
+
+  VALUE new_value;
+  php_value* pv;
+  zval* new_zval;
+  VALUE arg = INT2FIX(0);
+
+  ALLOC_ZVAL(new_zval);
+  *new_zval = *value;
+  zval_copy_ctor(new_zval);
+  INIT_PZVAL(new_zval);
+  
+  new_value = php_value_alloc(cPhpEmbedValue);
+  Data_Get_Struct(new_value, php_value, pv);
+  pv->value = new_zval;
+
+  return new_value;
+}
+
+
+VALUE php_value_initialize(VALUE self, VALUE value) {
+  php_value* pv;
+  zval* retval;
+  VALUE code;
+
+  Data_Get_Struct(self, php_value, pv);
+  pv->value = value_to_zval(value);
+
+  return Qnil;
+}
+
+VALUE php_value_to_php(VALUE self, VALUE value) {
+  return convert_value_to_php_string(value);
+}
+
+VALUE php_value_to_string(VALUE self) {
+  php_value* pv;
+  Data_Get_Struct(self, php_value, pv);
+ 
+    
+  if (pv->value) {
+    convert_to_string(pv->value);
+    return rb_str_new(Z_STRVAL_P(pv->value), Z_STRLEN_P(pv->value)); 
+  }
+
+  return Qnil;
+}
+
+VALUE php_value_to_integer(VALUE self) {
+  php_value* pv;
+  Data_Get_Struct(self, php_value, pv);
+ 
+    
+  if (pv->value) {
+    convert_to_long(pv->value);
+    return rb_fix_new(Z_LVAL_P(pv->value)); 
+  }
+
+  return Qnil;
+}
+
+VALUE php_value_to_float(VALUE self) {
+  php_value* pv;
+  Data_Get_Struct(self, php_value, pv);
+ 
+    
+  if (pv->value) {
+    convert_to_double(pv->value);
+    return rb_float_new(Z_DVAL_P(pv->value)); 
+  }
+
+  return Qnil;
+}
+
+VALUE php_value_to_boolean(VALUE self) {
+  php_value* pv;
+  Data_Get_Struct(self, php_value, pv);
+    
+  if (pv->value) {
+    convert_to_boolean(pv->value);
+    if (Z_LVAL_P(pv->value)) {
+      return Qtrue;
+    } else {
+      return Qfalse;
+    }
+  }
+
+  return Qnil;
+}
+
+VALUE php_value_to_array(VALUE self) {
+  php_value* pv;
+  Data_Get_Struct(self, php_value, pv);
+ 
+  if (pv->value) {
+    return zval_to_array(pv->value);
+  }
+
+  return Qnil;
+}
+
+VALUE php_value_to_hash(VALUE self) {
+  php_value* pv;
+  Data_Get_Struct(self, php_value, pv);
+ 
+  if (pv->value) {
+    return zval_to_hash(pv->value);
+  }
+
+  return Qnil;
+}
+
+VALUE php_value_obj_equal(VALUE self, VALUE rhs) {
+  php_value* pv;
+  zval* rhs_zv;
+  zval* result;    
+  int cmp_ret;
+
+  Data_Get_Struct(self, php_value, pv);
+  if (pv->value == NULL) {
+    return Qnil;
+  }
+
+  if (CLASS_OF(rhs) == cPhpEmbedValue) {
+    php_value* rhs_pv;
+    Data_Get_Struct(rhs, php_value, rhs_pv);
+
+    rhs_zv = rhs_pv->value;
+  } else {
+    rhs_zv = value_to_zval(rhs);
+  }
+
+  MAKE_STD_ZVAL(result);
+  compare_function(result, pv->value, rhs_zv);
+  cmp_ret = Z_LVAL_P(result);
+  FREE_ZVAL(result); 
+
+  return cmp_ret == 0 ? Qtrue: Qfalse;
+}
+
+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_method(cPhpEmbedValue, "to_i", php_value_to_integer, 0);
+  rb_define_method(cPhpEmbedValue, "to_f", php_value_to_float, 0);
+  rb_define_method(cPhpEmbedValue, "to_b", php_value_to_boolean, 0);
+  rb_define_method(cPhpEmbedValue, "to_a", php_value_to_array, 0);
+  rb_define_method(cPhpEmbedValue, "to_h", php_value_to_hash, 0);
+  rb_define_method(cPhpEmbedValue, "==", php_value_obj_equal, 1);
+
+  rb_define_singleton_method(cPhpEmbedValue, "to_php", php_value_to_php, 1);
+
+
+}

data/ext/php_embed/value.h

@@ -0,0 +1,17 @@
+#ifndef PHP_EMBED_VALUE
+#define PHP_EMBED_VALUE
+
+#include <ruby.h>
+#include <php.h>
+
+extern VALUE cPhpEmbedValue;
+
+void init_php_value();
+VALUE new_php_embed_value(zval* value);
+
+typedef struct {
+  zval* value;
+} php_value;
+
+#endif
+

data/lib/php_embed.rb

@@ -3,5 +3,7 @@ require 'php_embed/version'
 
 
 module PhpEmbed
-  # Your code goes here...
+  def self.Value(value)
+    self::Value.new(value)
+  end
 end

data/lib/php_embed/version.rb

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

data/php_embed.gemspec

@@ -13,7 +13,10 @@ Gem::Specification.new do |gem|
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = "php_embed"
-  gem.require_paths = ['lib']
+  gem.require_paths = ['lib', 'ext']
   gem.version       = PhpEmbed::VERSION
 
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'rake'
+
 end

data/spec/php_spec.rb

@@ -7,27 +7,41 @@ describe PhpEmbed do
       it 'raise error with invalid PhpEmbed code' do
           proc {
               PhpEmbed.eval("i n v a l i d")
-          }.should raise_error
+          }.should raise_error(PhpEmbed::SyntaxError)
       end 
   end 
 
   describe 'eval and call' do
-      it '1' do 
-          PhpEmbed.eval('function hoge(){ return 1; }');
-          PhpEmbed.call('hoge').should == 1;
+      it 'return fixnum' do 
+          PhpEmbed.eval('function ret_1(){ return 1; }');
+          PhpEmbed.call('ret_1').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};
+      it 'return string' do 
+          PhpEmbed.eval('function ret_string(){ return "string"; }');
+          PhpEmbed.call('ret_string').should == 'string';
       end
-  end
+      it 'return array' do 
+          PhpEmbed.eval('function ret_array(){ return array(1,2); }');
+          PhpEmbed.call('ret_array').to_a.should == [1,2];
+      end
+      it 'return hash' do 
+          PhpEmbed.eval('function ret_hash(){ return array("a"=>1,"b"=>2); }');
+          PhpEmbed.call('ret_hash').to_a.should == [1, 2];
+          PhpEmbed.call('ret_hash').to_h.should == {'a'=>1,'b'=>2};
+      end
+      it 'return arg' do 
+          PhpEmbed.eval('function ret_arg($arg){ return $arg; }');
+          PhpEmbed.call('ret_arg', 1).should == 1;
+          PhpEmbed.call('ret_arg', 'a').should == 'a';
+          PhpEmbed.call('ret_arg', []).to_a.should == [];
+          PhpEmbed.call('ret_arg', [1]).to_a.should == [1];
+          PhpEmbed.call('ret_arg', {0=>1,1=>2}).to_a.should == [1,2];
+          PhpEmbed.call('ret_arg', {10=>2}).to_h.should == {10=>2};
+          PhpEmbed.call('ret_arg', {'a'=>1}).to_h.should == {'a'=>1};
 
+          PhpEmbed.call('ret_arg', PhpEmbed::Value('a')).should == 'a';
+      end
+  end
 
   describe 'call' do
       it 'bin2hex return hex string' do
@@ -49,13 +63,17 @@ describe PhpEmbed do
       end 
     
       it 'call with array' do
-          PhpEmbed.call("array_diff", [1,2,3,4,5], [3,4]).should == {0=>1,1=>2,4=>5}
+          PhpEmbed.call("array_diff", [1,2,3,4,5], [3,4]).to_h.should == {0=>1,1=>2,4=>5}
       end 
 
+      it 'call by symbol' do
+          PhpEmbed.call(:intval, 123).should == 123
+      end
+
       it 'raise error with invalid PhpEmbed code' do
           proc {
               PhpEmbed.call("i n v a l i d")
-          }.should raise_error
+          }.should raise_error(PhpEmbed::MissingError)
       end 
   end
 
@@ -83,7 +101,17 @@ describe PhpEmbed do
     end 
   end
 
-end 
-
+  describe 'require' do
+    it 'require' do
+      PhpEmbed.require(File.dirname(File.expand_path(__FILE__)) + '/require.php')
+      PhpEmbed.call(:required_function).should == 'ok'
+    end
+    it 'invalid argument' do
+      proc {
+        PhpEmbed.require(nil)
+      }.should raise_error(ArgumentError)
+    end
+  end
 
+end 
 

data/spec/value_spec.rb

@@ -0,0 +1,100 @@
+# encoding: UTF-8
+require 'php_embed'
+
+describe PhpEmbed::Value do
+  it 'convert nil' do
+    PhpEmbed::Value.to_php(nil).should == 'null'
+  end
+
+  it 'convert boolean' do
+    PhpEmbed::Value.to_php(false).should == 'false'
+    PhpEmbed::Value.to_php(true).should == 'true'
+  end
+
+  it 'convert scalar' do
+    PhpEmbed::Value.to_php(1).should == '1'
+    PhpEmbed::Value.to_php("a").should == "'a'"
+    PhpEmbed::Value.to_php(:a).should == "'a'"
+  end
+
+  it 'convert array' do
+    PhpEmbed::Value.to_php([]).should == 'array()'
+    PhpEmbed::Value.to_php([1,2,3]).should == 'array(1,2,3)'
+    PhpEmbed::Value.to_php(['a', 'b']).should == "array('a','b')"
+  end
+
+  it 'convert hash' do
+    PhpEmbed::Value.to_php({}).should == 'array()'
+    PhpEmbed::Value.to_php({1=>'a'}).should == "array(1=>'a')"
+    PhpEmbed::Value.to_php({'a'=>1}).should == "array('a'=>1)"
+    PhpEmbed::Value.to_php({:a=>1}).should == "array('a'=>1)"
+  end
+
+
+  it 'to_s' do
+    PhpEmbed::Value.new('test').to_s.should == 'test'
+    PhpEmbed::Value.new(:test).to_s.should == 'test'
+
+    PhpEmbed::Value.new(123).to_s.should == '123'
+    PhpEmbed::Value.new(nil).to_s.should == ''
+
+    PhpEmbed::Value.new(false).to_s.should == ''
+    PhpEmbed::Value.new(true).to_s.should == '1'
+  end
+
+  it 'to_i' do
+    PhpEmbed::Value.new('test').to_i.should == 0
+    PhpEmbed::Value.new('10test').to_i.should == 10
+
+    PhpEmbed::Value.new(123).to_i.should == 123
+    PhpEmbed::Value.new(nil).to_i.should == 0
+    PhpEmbed::Value.new(true).to_i.should == 1
+    PhpEmbed::Value.new(false).to_i.should == 0
+    PhpEmbed::Value.new(12.3).to_i.should == 12
+  end
+
+  it 'to_b' do
+    PhpEmbed::Value.new(0).to_b.should be false
+    PhpEmbed::Value.new([]).to_b.should be false
+    PhpEmbed::Value.new({}).to_b.should be false
+    PhpEmbed::Value.new(true).to_b.should be true
+    PhpEmbed::Value.new(false).to_b.should be false
+    PhpEmbed::Value.new(nil).to_b.should be false
+  end
+
+  it 'to_a' do
+    PhpEmbed::Value.new([]).to_a.should == []
+    PhpEmbed::Value.new([1]).to_a.should == [PhpEmbed::Value.new(1)]
+    PhpEmbed::Value.new([1,"2",nil]).to_a
+      .should == [PhpEmbed::Value.new(1), PhpEmbed::Value.new("2"), PhpEmbed::Value(nil)]
+    PhpEmbed::Value.new({1=>1, 2=>2}).to_a.should == [1,2]
+  end
+
+  it 'to_h' do
+    PhpEmbed::Value.new([]).to_h.should == {}
+    PhpEmbed::Value.new([1,"2",nil]).to_h
+      .should == {0=>PhpEmbed::Value.new(1), 1=>PhpEmbed::Value.new("2"), 2=>PhpEmbed::Value(nil)}
+    PhpEmbed::Value.new({a:1}).to_h
+      .should == {'a'=>PhpEmbed::Value.new(1)}
+    PhpEmbed::Value.new({1=>1, 2=>2}).to_h.should == {1=>1,2=>2}
+  end
+
+  it 'to_f' do
+    PhpEmbed::Value.new('test').to_f.should == 0
+    PhpEmbed::Value.new(12.3).to_f.should == 12.3
+  end
+
+  it 'equqal' do
+    PhpEmbed::Value.new(true).should == PhpEmbed::Value.new(true)
+    PhpEmbed::Value.new(false).should == PhpEmbed::Value.new(false)
+
+    PhpEmbed::Value.new(nil).should == PhpEmbed::Value.new(false)
+
+    PhpEmbed::Value.new(nil).should == nil
+    PhpEmbed::Value.new(true).should == true
+    PhpEmbed::Value.new(false).should == false
+    PhpEmbed::Value.new(1).should == 1
+    PhpEmbed::Value.new('a').should == 'a'
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: php_embed
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,40 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-16 00:00:00.000000000 Z
-dependencies: []
+date: 2013-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: execute PHP code in Ruby code
 email:
 - do.hiroaki@gmail.com
@@ -24,21 +56,24 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- ext/php_embed/convert.c
+- ext/php_embed/convert.h
 - ext/php_embed/extconf.rb
 - ext/php_embed/php.c
-- ext/php_embed/php_embed_value.c
-- ext/php_embed/php_embed_value.h
+- ext/php_embed/value.c
+- ext/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
+- spec/value_spec.rb
 homepage: https://github.com/do-aki/php_embed
 licenses: []
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
+- ext
 required_ruby_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -59,4 +94,4 @@ specification_version: 3
 summary: execute PHP code in Ruby code
 test_files:
 - spec/php_spec.rb
-- spec/php_value_spec.rb
+- spec/value_spec.rb

data/ext/php_embed/php_embed_value.c

@@ -1,156 +0,0 @@
-#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

@@ -1,13 +0,0 @@
-#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/spec/php_value_spec.rb

@@ -1,29 +0,0 @@
-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
-