phuby 1.0.0

data/ext/phuby/phuby_conversions.h

@@ -0,0 +1,12 @@
+#ifndef PHUBY_CONVERSIONS
+#define PHUBY_CONVERSIONS
+
+#include <phuby.h>
+
+VALUE Phuby_zval_to_value(VALUE rt, zval * value);
+zval * Phuby_value_to_zval(VALUE rt, VALUE thing);
+
+#define ZVAL2VALUE(rt, a) Phuby_zval_to_value(rt, a)
+#define VALUE2ZVAL(rt, a) Phuby_value_to_zval(rt, a)
+
+#endif

data/ext/phuby/phuby_runtime.c

@@ -0,0 +1,243 @@
+#include <phuby_runtime.h>
+
+VALUE cPhubyRuntime;
+
+PHP_METHOD(RubyProxy, __call)
+{
+  char *function;
+  int function_len;
+  zval *args = NULL;
+
+  if(zend_parse_parameters(ZEND_NUM_ARGS(), "sa|a", &function, &function_len,
+        &args) == FAILURE) {
+    printf("arg################:\n");
+  }
+
+  VALUE rt = rb_funcall(cPhubyRuntime, rb_intern("instance"), 0);
+
+  VALUE ret = rb_funcall(rt, rb_intern("call"), 3,
+      INT2NUM((int)this_ptr),
+      rb_str_new(function, function_len),
+      ZVAL2VALUE(rt, args)
+  );
+
+  if(ret != Qnil) {
+    zval * rv  = Phuby_value_to_zval(rt, ret);
+    RETURN_ZVAL(rv, 1, 1);
+  }
+  RETURN_NULL();
+}
+
+zend_class_entry *php_ruby_proxy;
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_foo___call, 0, 0, 2)
+  ZEND_ARG_INFO(0, function_name)
+  ZEND_ARG_INFO(0, arguments)
+ZEND_END_ARG_INFO()
+
+function_entry php_ruby_functions[] = {
+  PHP_ME(RubyProxy, __call, arginfo_foo___call, 0)
+  { NULL, NULL, NULL }
+};
+
+static int phuby_ub_write(const char *str, unsigned int strlen)
+{
+  VALUE self = rb_funcall(cPhubyRuntime, rb_intern("instance"), 0);
+  VALUE handler = rb_iv_get(self, "@events");
+
+  rb_funcall(handler, rb_intern("write"), 1, rb_str_new(str, strlen));
+  return strlen;
+}
+
+static int phuby_header_handler(
+    sapi_header_struct *sapi_header,
+    sapi_header_op_enum op,
+    sapi_headers_struct *sapi_headers)
+{
+  VALUE header = sapi_header->header ?
+    rb_str_new2(sapi_header->header) :
+    Qnil;
+
+  VALUE rb_op = Qnil;
+
+  int return_value = 0;
+
+  switch(op) {
+    case SAPI_HEADER_DELETE_ALL:
+      rb_op = ID2SYM(rb_intern("delete_all"));
+      break;
+    case SAPI_HEADER_DELETE:
+      rb_op = ID2SYM(rb_intern("delete"));
+      break;
+    case SAPI_HEADER_ADD:
+    case SAPI_HEADER_REPLACE:
+      rb_op = ID2SYM(rb_intern("store"));
+      return_value = SAPI_HEADER_ADD;
+      break;
+    default:
+      rb_raise(rb_eRuntimeError, "header_handler huh?");
+  }
+
+  VALUE self = rb_funcall(cPhubyRuntime, rb_intern("instance"), 0);
+  VALUE handler = rb_iv_get(self, "@events");
+
+  rb_funcall(handler, rb_intern("header"), 2, header, rb_op);
+
+  return return_value;
+}
+
+static int phuby_send_headers(sapi_headers_struct *sapi_headers)
+{
+  VALUE self = rb_funcall(cPhubyRuntime, rb_intern("instance"), 0);
+  VALUE handler = rb_iv_get(self, "@events");
+
+  int rc = sapi_headers->http_response_code == 0 ?
+    200 :
+    sapi_headers->http_response_code;
+
+  rb_funcall(handler, rb_intern("send_headers"), 1, INT2NUM(rc));
+
+  return SAPI_HEADER_SENT_SUCCESSFULLY;
+}
+
+static void phuby_flush(void *server_context)
+{
+  sapi_send_headers();
+}
+
+static VALUE start(VALUE self)
+{
+  VALUE mutex = rb_iv_get(self, "@mutex");
+  rb_funcall(mutex, rb_intern("lock"), 0);
+
+  /* FIXME:
+   * I got these from the book.  I don't know wtf they're for yet. */
+  int argc = 1;
+  char *argv[2] = { "embed4", NULL };
+  /* end FIXME */
+
+  php_embed_module.ub_write       = phuby_ub_write;
+  php_embed_module.header_handler = phuby_header_handler;
+  php_embed_module.send_headers   = phuby_send_headers;
+  php_embed_module.flush          = phuby_flush;
+
+  php_embed_init(argc, argv);
+  zend_class_entry ce;
+  INIT_CLASS_ENTRY(ce, "RubyProxy", php_ruby_functions);
+
+  php_ruby_proxy = zend_register_internal_class(&ce);
+
+  SG(headers_sent) = 0;
+  SG(request_info).no_headers = 0;
+
+  return Qnil;
+}
+
+static VALUE stop(VALUE self)
+{
+  php_embed_shutdown();
+
+  VALUE mutex = rb_iv_get(self, "@mutex");
+  rb_funcall(mutex, rb_intern("unlock"), 0);
+
+  return Qnil;
+}
+
+/* IO reader callback for PHP IO streams */
+static size_t rb_io_reader(void *handle, char *buf, size_t len)
+{
+  VALUE io = (VALUE)handle;
+  VALUE string = rb_funcall(io, rb_intern("read"), 1, INT2NUM(len));
+
+  if(Qnil == string) return 0;
+
+  memcpy(buf, StringValuePtr(string), (unsigned int)RSTRING_LEN(string));
+
+  return RSTRING_LEN(string);
+}
+
+static size_t rb_io_sizer(void *handle)
+{
+}
+
+static void rb_io_closer(void *handle)
+{
+  // We'll let the caller close their own IO
+  return;
+}
+
+static VALUE native_eval_io(VALUE self, VALUE io, VALUE filename)
+{
+  zend_file_handle script;
+
+  script.type = ZEND_HANDLE_STREAM;
+  script.filename = StringValuePtr(filename);
+  script.opened_path = NULL;
+
+  memset(&script.handle.stream.mmap, 0, sizeof(zend_mmap));
+
+  script.handle.stream.handle = (void *)io;
+  script.handle.stream.isatty = 0;
+
+  script.handle.stream.reader = rb_io_reader;
+  script.handle.stream.fsizer = rb_io_sizer;
+  script.handle.stream.closer = rb_io_closer;
+
+  script.free_filename = 0;
+
+  php_execute_script(&script);
+
+  return Qnil;
+}
+
+static VALUE native_eval(VALUE self, VALUE string, VALUE filename)
+{
+
+  zval return_value;
+
+  zend_first_try {
+    zend_eval_string(
+      StringValuePtr(string),
+      NULL,
+      StringValuePtr(filename)
+    );
+  } zend_end_try();
+
+  return Qnil;
+}
+
+static VALUE get(VALUE self, VALUE key)
+{
+  zval **value;
+
+  if(zend_hash_find(EG(active_symbol_table),
+        StringValuePtr(key),
+        RSTRING_LEN(key) + 1,
+        (void **)&value) == SUCCESS) {
+    return ZVAL2VALUE(self, *value);
+  }
+
+  return Qnil;
+}
+
+static VALUE set(VALUE self, VALUE key, VALUE value)
+{
+  zval *php_value = VALUE2ZVAL(self, value);
+
+  ZEND_SET_SYMBOL(EG(active_symbol_table), StringValuePtr(key), php_value);
+
+  return value;
+}
+
+void init_phuby_runtime()
+{
+  cPhubyRuntime = rb_define_class_under(mPhuby, "Runtime", rb_cObject);
+
+  rb_define_method(cPhubyRuntime, "start", start, 0);
+  rb_define_method(cPhubyRuntime, "stop", stop, 0);
+
+  rb_define_private_method(cPhubyRuntime, "get", get, 1);
+  rb_define_private_method(cPhubyRuntime, "set", set, 2);
+  rb_define_private_method(cPhubyRuntime, "native_eval", native_eval, 2);
+  rb_define_private_method(cPhubyRuntime, "native_eval_io", native_eval_io, 2);
+}

data/ext/phuby/phuby_runtime.h

@@ -0,0 +1,11 @@
+#ifndef PHUBY_RUNTIME
+#define PHUBY_RUNTIME
+
+#include <phuby.h>
+
+extern VALUE cPhubyRuntime;
+extern zend_class_entry *php_ruby_proxy;
+
+void init_phuby_runtime();
+
+#endif

data/lib/phuby.rb

@@ -0,0 +1,9 @@
+require 'phuby/phuby'
+require 'phuby/events'
+require 'phuby/runtime'
+require 'phuby/array'
+require 'phuby/php_handler'
+
+module Phuby
+  VERSION = '1.0.0'
+end

data/lib/phuby/array.rb

@@ -0,0 +1,24 @@
+module Phuby
+  class Array
+    def [] key
+      get key
+    end
+
+    def []= key, value
+      set key, value
+    end
+
+    def each &block
+      0.upto(length - 1) do |i|
+        block.call get(i)
+      end
+    end
+
+    def to_a
+      tmp = []
+      each { |x| tmp << x }
+
+      tmp
+    end
+  end
+end

data/lib/phuby/events.rb

@@ -0,0 +1,19 @@
+module Phuby
+  class Events
+    ###
+    # Called when PHP wants to write something out
+    def write string
+      $stdout.write string
+    end
+
+    ###
+    # Called when PHP wants to manipulate headers
+    def header header, op
+    end
+
+    ###
+    # Called when PHP wants to send response headers with +response_code+
+    def send_headers response_code
+    end
+  end
+end

data/lib/phuby/php_handler.rb

@@ -0,0 +1,96 @@
+require 'webrick'
+require 'cgi'
+require 'iconv'
+require 'logger'
+
+module Phuby
+  class PHPHandler < WEBrick::HTTPServlet::FileHandler
+    class Events < Phuby::Events
+      def initialize req, res
+        super()
+        @req = req
+        @res = res
+      end
+
+      def header value, op
+        k, v = *value.split(':', 2)
+        if k.downcase == 'set-cookie'
+          @res.cookies << v.strip
+        else
+          @res[k] = v.strip
+        end
+      end
+
+      def write string
+        @res.body ||= ''
+        @res.body << string
+      end
+
+      def send_headers response_code
+      end
+    end
+
+    def initialize server, root = server.config[:DocumentRoot] || Dir.pwd, *args
+      super
+    end
+
+    def do_POST req, res
+      req.path << "index.php" if req.path =~ /\/$/
+
+      return super(req, res) unless req.path =~ /\.php$/
+
+      process :POST, req, res
+    end
+
+    def do_GET req, res
+      req.path << "index.php" if req.path =~ /\/$/
+
+      return super(req, res) unless req.path =~ /\.php$/
+
+      process :GET, req, res
+    end
+
+    private
+    def process verb, req, res
+      file = File.join(@root, req.path)
+
+      Dir.chdir(File.dirname(file)) do
+        Phuby::Runtime.php do |rt|
+          rt.eval("date_default_timezone_set('America/Los_Angeles');")
+
+          rt['logger'] = Logger.new($stdout)
+          req.request_uri.query.split('&').each do |pair|
+            k, v = pair.split '='
+            rt["_GET"][k] = v
+          end if req.request_uri.query
+
+          req.query.each do |k,v|
+            rt["_#{verb}"][k] = v
+          end if :POST == verb
+
+          # Set CGI server options
+          req.meta_vars.each do |k,v|
+            rt["_SERVER"][k] = v || ''
+          end
+          rt["_SERVER"]['REQUEST_URI'] = req.request_uri.path
+
+          req.cookies.each do |cookie|
+            rt["_COOKIE"][cookie.name] = CGI.unescape(cookie.value)
+          end
+
+          events = Events.new req, res
+
+          rt.with_events(events) do
+            File.open(file, 'rb') { |f|
+              rt.eval f
+            }
+          end
+        end
+      end
+      if res['Location']
+        res['Location'] = CGI.unescape res['Location']
+        res.status = 302
+      end
+    end
+  end
+end

data/lib/phuby/rails.rb

@@ -0,0 +1,47 @@
+require 'phuby'
+
+class PHPHandler < ActionView::TemplateHandler
+  class Events < Struct.new(:code, :headers, :body)
+    def write string; body << string; end
+    def send_headers response_code;   end
+
+    def header value, op
+      k, v = value.split(': ', 2)
+      self.code = 302 if k == 'Location'
+      headers[k] = [headers[k], Rack::Utils.unescape(v)].compact.join "\n"
+    end
+  end
+
+  class ControllerProxy
+    def initialize controller
+      @controller = controller
+    end
+
+    def method_missing name
+      @controller.instance_variable_get :"@#{name}"
+    end
+  end
+
+  def initialize view
+    @controller = view.controller
+    @proxy      = ControllerProxy.new @controller
+  end
+
+  def render template, *args
+    filename = File.join template.load_path, template.template_path
+    events   = Events.new(200, {}, '')
+    Dir.chdir(File.dirname(filename)) do
+      Phuby::Runtime.php do |rt|
+        rt.eval "date_default_timezone_set('America/Los_Angeles');"
+        rt['at'] = @proxy
+        rt.with_events(events) do
+          open(filename) { |f| rt.eval f }
+        end
+      end
+    end
+
+    events.body
+  end
+end
+
+ActionView::Template.register_template_handler('php', PHPHandler)