static VALUE
env_inspect(VALUE rcv, SEL sel)
{
rb_secure(4);
VALUE str = rb_str_buf_new2("{");
char **env = GET_ENVIRON();
while (*env != NULL) {
const char *s = strchr(*env, '=');
if (env != GET_ENVIRON()) {
rb_str_buf_cat2(str, ", ");
}
if (s != NULL) {
rb_str_buf_cat2(str, "\"");
rb_str_buf_cat(str, *env, s - *env);
rb_str_buf_cat2(str, "\"=>");
VALUE i = rb_inspect(rb_str_new2(s + 1));
rb_str_buf_append(str, i);
}
env++;
}
rb_str_buf_cat2(str, "}");
OBJ_TAINT(str);
return str;
}
static VALUE
method_inspect(VALUE method, SEL sel)
{
rb_vm_method_t *data;
VALUE str;
const char *s;
const char *sharp = "#";
Data_Get_Struct(method, rb_vm_method_t, data);
str = rb_str_buf_new2("#<");
s = rb_obj_classname(method);
rb_str_buf_cat2(str, s);
rb_str_buf_cat2(str, ": ");
rb_str_buf_cat2(str, rb_class2name(data->rclass));
if (data->rclass != data->oclass) {
rb_str_buf_cat2(str, "(");
rb_str_buf_cat2(str, rb_class2name(data->oclass));
rb_str_buf_cat2(str, ")");
}
rb_str_buf_cat2(str, sharp);
rb_str_buf_cat2(str, sel_getName(data->sel));
rb_str_buf_cat2(str, ">");
return str;
}
/*
* call-seq:
* conn.subtransaction( name, *args) { |conn,sp| ... }
*
* Open and close a transaction savepoint. The savepoints name +nam+ may
* contain % directives that will be expanded by +args+.
*/
VALUE
pgconn_subtransaction( int argc, VALUE *argv, VALUE self)
{
struct pgconn_data *c;
int a;
VALUE sp, par, cmd, ya;
const char *q;
char *p;
int n;
Data_Get_Struct( self, struct pgconn_data, c);
a = rb_scan_args( argc, argv, "1*", &sp, &par);
StringValue( sp);
if (a > 1)
sp = rb_str_format(RARRAY_LEN(par), RARRAY_PTR(par), sp);
cmd = rb_str_buf_new2( "savepoint ");
q = pgconn_destring( c, sp, &n);
p = PQescapeIdentifier( c->conn, q, n);
rb_str_buf_cat2( cmd, p);
ya = rb_ary_new3( 2, self, rb_str_new2( p));
PQfreemem( p);
rb_str_buf_cat2( cmd, ";");
pgresult_clear( pg_statement_exec( self, cmd, Qnil));
return rb_ensure( yield_subtransaction, ya, release_subtransaction, ya);
}
/*
* call-seq:
* conn.transaction( ser = nil, ro = nil) { |conn| ... }
*
* Open and close a transaction block. The isolation level will be
* 'serializable' if +ser+ is true, else 'repeatable read'.
* +ro+ means 'read only'.
*
* (In C++ terms, +ro+ is const, and +ser+ is not volatile.)
*
*/
VALUE
pgconn_transaction( int argc, VALUE *argv, VALUE self)
{
struct pgconn_data *c;
VALUE ser, ro;
VALUE cmd;
int p;
rb_scan_args( argc, argv, "02", &ser, &ro);
cmd = rb_str_buf_new2( "begin");
p = 0;
if (!NIL_P( ser)) {
rb_str_buf_cat2( cmd, " isolation level ");
rb_str_buf_cat2( cmd, RTEST(ser) ? "serializable" : "read committed");
p++;
}
if (!NIL_P( ro)) {
if (p) rb_str_buf_cat2( cmd, ",");
rb_str_buf_cat2( cmd, " read ");
rb_str_buf_cat2( cmd, (RTEST(ro) ? "only" : "write"));
}
rb_str_buf_cat2( cmd, ";");
Data_Get_Struct( self, struct pgconn_data, c);
if (PQtransactionStatus( c->conn) > PQTRANS_IDLE)
rb_raise( rb_ePgConnTrans,
"Nested transaction block. Use Conn#subtransaction.");
pgresult_clear( pg_statement_exec( self, cmd, Qnil));
return rb_ensure( yield_transaction, self, commit_transaction, self);
}
static VALUE
inspect_hash(VALUE hash, VALUE dummy, int recur)
{
if (recur) {
return rb_usascii_str_new2("{...}");
}
VALUE str = rb_str_buf_new2("{");
rhash_foreach(hash, inspect_i, str);
rb_str_buf_cat2(str, "}");
OBJ_INFECT(str, hash);
return str;
}
VALUE
rollback_subtransaction( VALUE ary)
{
VALUE cmd;
cmd = rb_str_buf_new2( "rollback to savepoint ");
rb_str_buf_append( cmd, rb_ary_entry( ary, 1));
rb_str_buf_cat2( cmd, ";");
pgresult_clear( pg_statement_exec( rb_ary_entry( ary, 0), cmd, Qnil));
rb_ary_store( ary, 1, Qnil);
rb_exc_raise( RB_ERRINFO);
return Qnil;
}
extern VALUE StringRaw(const char *buf, int bsiz){
VALUE vval;
int i;
vval = rb_str_buf_new2("");
char s[5];
for(i=0;i<bsiz;i++){
char c = *buf++;
s[0] = c;
rb_str_buf_cat(vval, s, 1);
}
// buf -= bsiz;
// rb_str_buf_cat2(vval, "");
return vval;
}
VALUE
release_subtransaction( VALUE ary)
{
VALUE cmd;
VALUE n;
n = rb_ary_entry( ary, 1);
if (!NIL_P( n)) {
cmd = rb_str_buf_new2( "release savepoint ");
rb_str_buf_append( cmd, n);
rb_str_buf_cat2( cmd, ";");
pgresult_clear( pg_statement_exec( rb_ary_entry( ary, 0), cmd, Qnil));
}
return Qnil;
}
static VALUE
method_inspect(VALUE method)
{
struct METHOD *data;
VALUE str;
const char *s;
char *sharp = "#";
Data_Get_Struct(method, struct METHOD, data);
str = rb_str_buf_new2("#<");
s = rb_obj_classname(method);
rb_str_buf_cat2(str, s);
rb_str_buf_cat2(str, ": ");
if (FL_TEST(data->klass, FL_SINGLETON)) {
VALUE v = rb_iv_get(data->klass, "__attached__");
if (data->recv == Qundef) {
rb_str_buf_append(str, rb_inspect(data->klass));
}
else if (data->recv == v) {
rb_str_buf_append(str, rb_inspect(v));
sharp = ".";
}
else {
rb_str_buf_append(str, rb_inspect(data->recv));
rb_str_buf_cat2(str, "(");
rb_str_buf_append(str, rb_inspect(v));
rb_str_buf_cat2(str, ")");
sharp = ".";
}
}
else {
rb_str_buf_cat2(str, rb_class2name(data->rklass));
if (data->rklass != data->klass) {
rb_str_buf_cat2(str, "(");
rb_str_buf_cat2(str, rb_class2name(data->klass));
rb_str_buf_cat2(str, ")");
}
}
rb_str_buf_cat2(str, sharp);
rb_str_buf_cat2(str, rb_id2name(data->oid));
rb_str_buf_cat2(str, ">");
return str;
}
/*
* Returns a string containing a human-readable representation of the
* CouchRequest.
*
* @since 1.2.0
*
* @return [String]
*/
VALUE
cb_http_request_inspect(VALUE self)
{
VALUE str;
struct cb_http_request_st *req = DATA_PTR(self);
char buf[200];
str = rb_str_buf_new2("#<");
rb_str_buf_cat2(str, rb_obj_classname(self));
snprintf(buf, 20, ":%p \"", (void *)self);
rb_str_buf_cat2(str, buf);
rb_str_buf_cat2(str, req->cmd.v.v0.path);
snprintf(buf, 100, "\" chunked:%s>", req->cmd.v.v0.chunked ? "true" : "false");
rb_str_buf_cat2(str, buf);
return str;
}
/*
* Returns a string containing a human-readable representation of the
* Timer.
*
* @since 1.2.0.dp6
*
* @return [String]
*/
VALUE
cb_timer_inspect(VALUE self)
{
VALUE str;
struct timer_st *tm = DATA_PTR(self);
char buf[200];
str = rb_str_buf_new2("#<");
rb_str_buf_cat2(str, rb_obj_classname(self));
snprintf(buf, 20, ":%p", (void *)self);
rb_str_buf_cat2(str, buf);
snprintf(buf, 100, " timeout:%u periodic:%s>",
tm->usec, tm->periodic ? "true" : "false");
rb_str_buf_cat2(str, buf);
return str;
}
static VALUE
exc_inspect(VALUE exc)
{
VALUE str, klass;
klass = CLASS_OF(exc);
exc = rb_obj_as_string(exc);
if (RSTRING_LEN(exc) == 0) {
return rb_str_dup(rb_class_name(klass));
}
str = rb_str_buf_new2("#<");
klass = rb_class_name(klass);
rb_str_buf_append(str, klass);
rb_str_buf_cat(str, ": ", 2);
rb_str_buf_append(str, exc);
rb_str_buf_cat(str, ">", 1);
return str;
}
static VALUE
inspect_struct(VALUE s)
{
const char *cname = rb_class2name(rb_obj_class(s));
VALUE str, members;
long i;
members = rb_struct_members(s);
str = rb_str_buf_new2("#<struct ");
rb_str_cat2(str, cname);
rb_str_cat2(str, " ");
for (i=0; i<RSTRUCT(s)->len; i++) {
VALUE slot;
ID id;
const char *p;
if (i > 0) {
rb_str_cat2(str, ", ");
}
slot = RARRAY(members)->ptr[i];
id = SYM2ID(slot);
if (rb_is_local_id(id) || rb_is_const_id(id)) {
p = rb_id2name(id);
rb_str_cat2(str, p);
}
else {
rb_str_append(str, rb_inspect(slot));
}
rb_str_cat2(str, "=");
rb_str_append(str, rb_inspect(RSTRUCT(s)->ptr[i]));
}
rb_str_cat2(str, ">");
OBJ_INFECT(str, s);
return str;
}
/* Helper to convert return code from libcouchbase to meaningful exception.
* Returns nil if the code considering successful and exception object
* otherwise. Store given string to exceptions as message, and also
* initialize +error+ attribute with given return code. */
VALUE
cb_check_error_with_status(lcb_error_t rc, const char *msg, VALUE key,
lcb_http_status_t status)
{
VALUE klass, exc, str;
char buf[300];
if ((rc == LCB_SUCCESS && (status == 0 || status / 100 == 2)) ||
rc == LCB_AUTH_CONTINUE) {
return Qnil;
}
switch (rc) {
case LCB_AUTH_ERROR:
klass = cb_eAuthError;
break;
case LCB_DELTA_BADVAL:
klass = cb_eDeltaBadvalError;
break;
case LCB_E2BIG:
klass = cb_eTooBigError;
break;
case LCB_EBUSY:
klass = cb_eBusyError;
break;
case LCB_EINTERNAL:
klass = cb_eInternalError;
break;
case LCB_EINVAL:
klass = cb_eInvalidError;
break;
case LCB_ENOMEM:
klass = cb_eNoMemoryError;
break;
case LCB_ERANGE:
klass = cb_eRangeError;
break;
case LCB_ETMPFAIL:
klass = cb_eTmpFailError;
break;
case LCB_KEY_EEXISTS:
klass = cb_eKeyExistsError;
break;
case LCB_KEY_ENOENT:
klass = cb_eNotFoundError;
break;
case LCB_DLOPEN_FAILED:
klass = cb_eDlopenFailedError;
break;
case LCB_DLSYM_FAILED:
klass = cb_eDlsymFailedError;
break;
case LCB_NETWORK_ERROR:
klass = cb_eNetworkError;
break;
case LCB_NOT_MY_VBUCKET:
klass = cb_eNotMyVbucketError;
break;
case LCB_NOT_STORED:
klass = cb_eNotStoredError;
break;
case LCB_NOT_SUPPORTED:
klass = cb_eNotSupportedError;
break;
case LCB_UNKNOWN_COMMAND:
klass = cb_eUnknownCommandError;
break;
case LCB_UNKNOWN_HOST:
klass = cb_eUnknownHostError;
break;
case LCB_PROTOCOL_ERROR:
klass = cb_eProtocolError;
break;
case LCB_ETIMEDOUT:
klass = cb_eTimeoutError;
break;
case LCB_CONNECT_ERROR:
klass = cb_eConnectError;
break;
case LCB_BUCKET_ENOENT:
klass = cb_eBucketNotFoundError;
break;
case LCB_CLIENT_ENOMEM:
klass = cb_eClientNoMemoryError;
break;
case LCB_CLIENT_ETMPFAIL:
klass = cb_eClientTmpFailError;
break;
case LCB_EBADHANDLE:
klass = cb_eBadHandleError;
break;
case LCB_ERROR:
/* fall through */
default:
klass = cb_eLibcouchbaseError;
}
str = rb_str_buf_new2(msg ? msg : "");
rb_str_buf_cat2(str, " (");
if (key != Qnil) {
snprintf(buf, 300, "key=\"%s\", ", RSTRING_PTR(key));
rb_str_buf_cat2(str, buf);
}
if (status > 0) {
const char *reason = NULL;
klass = cb_eHTTPError;
snprintf(buf, 300, "status=\"%d\"", status);
rb_str_buf_cat2(str, buf);
switch (status) {
case LCB_HTTP_STATUS_BAD_REQUEST:
reason = " (Bad Request)";
break;
case LCB_HTTP_STATUS_UNAUTHORIZED:
reason = " (Unauthorized)";
break;
case LCB_HTTP_STATUS_PAYMENT_REQUIRED:
reason = " (Payment Required)";
break;
case LCB_HTTP_STATUS_FORBIDDEN:
reason = " (Forbidden)";
break;
case LCB_HTTP_STATUS_NOT_FOUND:
reason = " (Not Found)";
break;
case LCB_HTTP_STATUS_METHOD_NOT_ALLOWED:
reason = " (Method Not Allowed)";
break;
case LCB_HTTP_STATUS_NOT_ACCEPTABLE:
reason = " (Not Acceptable)";
break;
case LCB_HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED:
reason = " (Proxy Authentication Required)";
break;
case LCB_HTTP_STATUS_REQUEST_TIMEOUT:
reason = " (Request Timeout)";
break;
case LCB_HTTP_STATUS_CONFLICT:
reason = " (Conflict)";
break;
case LCB_HTTP_STATUS_GONE:
reason = " (Gone)";
break;
case LCB_HTTP_STATUS_LENGTH_REQUIRED:
reason = " (Length Required)";
break;
case LCB_HTTP_STATUS_PRECONDITION_FAILED:
reason = " (Precondition Failed)";
break;
case LCB_HTTP_STATUS_REQUEST_ENTITY_TOO_LARGE:
reason = " (Request Entity Too Large)";
break;
case LCB_HTTP_STATUS_REQUEST_URI_TOO_LONG:
reason = " (Request Uri Too Long)";
break;
case LCB_HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE:
reason = " (Unsupported Media Type)";
break;
case LCB_HTTP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE:
reason = " (Requested Range Not Satisfiable)";
break;
case LCB_HTTP_STATUS_EXPECTATION_FAILED:
reason = " (Expectation Failed)";
break;
case LCB_HTTP_STATUS_UNPROCESSABLE_ENTITY:
reason = " (Unprocessable Entity)";
break;
case LCB_HTTP_STATUS_LOCKED:
reason = " (Locked)";
break;
case LCB_HTTP_STATUS_FAILED_DEPENDENCY:
reason = " (Failed Dependency)";
break;
case LCB_HTTP_STATUS_INTERNAL_SERVER_ERROR:
reason = " (Internal Server Error)";
break;
case LCB_HTTP_STATUS_NOT_IMPLEMENTED:
reason = " (Not Implemented)";
break;
case LCB_HTTP_STATUS_BAD_GATEWAY:
reason = " (Bad Gateway)";
break;
case LCB_HTTP_STATUS_SERVICE_UNAVAILABLE:
reason = " (Service Unavailable)";
break;
case LCB_HTTP_STATUS_GATEWAY_TIMEOUT:
reason = " (Gateway Timeout)";
break;
case LCB_HTTP_STATUS_HTTP_VERSION_NOT_SUPPORTED:
reason = " (Http Version Not Supported)";
break;
case LCB_HTTP_STATUS_INSUFFICIENT_STORAGE:
reason = " (Insufficient Storage)";
break;
default:
reason = "";
}
rb_str_buf_cat2(str, reason);
rb_str_buf_cat2(str, ", ");
}
snprintf(buf, 300, "error=0x%02x)", rc);
rb_str_buf_cat2(str, buf);
exc = rb_exc_new3(klass, str);
rb_ivar_set(exc, cb_id_iv_error, INT2FIX(rc));
rb_ivar_set(exc, cb_id_iv_key, key);
rb_ivar_set(exc, cb_id_iv_cas, Qnil);
rb_ivar_set(exc, cb_id_iv_operation, Qnil);
rb_ivar_set(exc, cb_id_iv_status, status ? INT2FIX(status) : Qnil);
return exc;
}
/*
* Returns a string containing a human-readable representation of the Result.
*
* @since 1.0.0
*
* @return [String]
*/
VALUE
cb_result_inspect(VALUE self)
{
VALUE str, attr;
char buf[100];
str = rb_str_buf_new2("#<");
rb_str_buf_cat2(str, rb_obj_classname(self));
snprintf(buf, 100, ":%p", (void *)self);
rb_str_buf_cat2(str, buf);
attr = rb_attr_get(self, cb_id_iv_operation);
if (RTEST(attr)) {
rb_str_buf_cat2(str, " operation=");
rb_str_append(str, rb_inspect(attr));
}
attr = rb_attr_get(self, cb_id_iv_error);
if (RTEST(attr)) {
rb_str_buf_cat2(str, " error=");
rb_str_append(str, rb_inspect(attr));
}
attr = rb_attr_get(self, cb_id_iv_key);
if (RTEST(attr)) {
rb_str_buf_cat2(str, " key=");
rb_str_append(str, rb_inspect(attr));
}
attr = rb_attr_get(self, cb_id_iv_status);
if (RTEST(attr)) {
rb_str_buf_cat2(str, " status=");
rb_str_append(str, rb_inspect(attr));
}
attr = rb_attr_get(self, cb_id_iv_cas);
if (RTEST(attr)) {
rb_str_buf_cat2(str, " cas=");
rb_str_append(str, rb_inspect(attr));
}
attr = rb_attr_get(self, cb_id_iv_flags);
if (RTEST(attr)) {
rb_str_buf_cat2(str, " flags=0x");
rb_str_append(str, rb_funcall(attr, cb_id_to_s, 1, INT2FIX(16)));
}
attr = rb_attr_get(self, cb_id_iv_node);
if (RTEST(attr)) {
rb_str_buf_cat2(str, " node=");
rb_str_append(str, rb_inspect(attr));
}
attr = rb_attr_get(self, cb_id_iv_from_master);
if (attr != Qnil) {
rb_str_buf_cat2(str, " from_master=");
rb_str_append(str, rb_inspect(attr));
}
attr = rb_attr_get(self, cb_id_iv_time_to_persist);
if (RTEST(attr)) {
rb_str_buf_cat2(str, " time_to_persist=");
rb_str_append(str, rb_inspect(attr));
}
attr = rb_attr_get(self, cb_id_iv_time_to_replicate);
if (RTEST(attr)) {
rb_str_buf_cat2(str, " time_to_replicate=");
rb_str_append(str, rb_inspect(attr));
}
attr = rb_attr_get(self, cb_id_iv_headers);
if (RTEST(attr)) {
rb_str_buf_cat2(str, " headers=");
rb_str_append(str, rb_inspect(attr));
}
rb_str_buf_cat2(str, ">");
return str;
}
VALUE string_spec_rb_str_buf_new2(VALUE self) {
return rb_str_buf_new2("hello\0invisible");
}
