aniani/vim
0
0
Fork 1
mirror of https://github.com/vim/vim.git synced 2025-09-25 03:54:15 -04:00
Code Activity

patch 8.1.1056: no eval function for Ruby

Browse Source 
Problem:    No eval function for Ruby.
Solution:   Add rubyeval(). (Ozaki Kiichi, closes #4152)
This commit is contained in:
Bram Moolenaar
2019-03-26 22:51:09 +01:00
parent 75bf3d22f4
commit e99be0e6d2
7 changed files with 431 additions and 183 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
runtime/doc/eval.txt
View File

@@ -2521,6 +2521,7 @@ repeat({expr}, {count}) String repeat {expr} {count} times
resolve({filename}) String get filename a shortcut points to resolve({filename}) String get filename a shortcut points to
reverse({list}) List reverse {list} in-place reverse({list}) List reverse {list} in-place
round({expr}) Float round off {expr} round({expr}) Float round off {expr}
rubyeval({expr}) any evaluate |Ruby| expression
screenattr({row}, {col}) Number attribute at screen position screenattr({row}, {col}) Number attribute at screen position
screenchar({row}, {col}) Number character at screen position screenchar({row}, {col}) Number character at screen position
screencol() Number current cursor column screencol() Number current cursor column
@@ -7432,6 +7433,17 @@ round({expr}) *round()*
< -5.0 < -5.0
{only available when compiled with the |+float| feature} {only available when compiled with the |+float| feature}
rubyeval({expr}) *rubyeval()*
Evaluate Ruby expression {expr} and return its result
converted to Vim data structures.
Numbers, floats and strings are returned as they are (strings
are copied though).
Arrays are represented as Vim |List| type.
Hashes are represented as Vim |Dictionary| type.
Other objects are represented as strings resulted from their
"Object#to_s" method.
{only available when compiled with the |+ruby| feature}
screenattr({row}, {col}) *screenattr()* screenattr({row}, {col}) *screenattr()*
Like |screenchar()|, but return the attribute. This is a rather Like |screenchar()|, but return the attribute. This is a rather
arbitrary number that can only be used to compare to the arbitrary number that can only be used to compare to the

14
runtime/doc/if_ruby.txt
View File

@@ -11,7 +11,8 @@ The Ruby Interface to Vim *ruby* *Ruby*
3. Vim::Buffer objects |ruby-buffer| 3. Vim::Buffer objects |ruby-buffer|
4. Vim::Window objects |ruby-window| 4. Vim::Window objects |ruby-window|
5. Global variables |ruby-globals| 5. Global variables |ruby-globals|
6. Dynamic loading |ruby-dynamic| 6. rubyeval() Vim function |ruby-rubyeval|
7. Dynamic loading |ruby-dynamic|
{Vi does not have any of these commands} {Vi does not have any of these commands}
*E266* *E267* *E268* *E269* *E270* *E271* *E272* *E273* *E266* *E267* *E268* *E269* *E270* *E271* *E272* *E273*
@@ -198,7 +199,16 @@ $curwin The current window object.
$curbuf The current buffer object. $curbuf The current buffer object.
============================================================================== ==============================================================================
6. Dynamic loading *ruby-dynamic* 6. rubyeval() Vim function *ruby-rubyeval*
To facilitate bi-directional interface, you can use |rubyeval()| function to
evaluate Ruby expressions and pass their values to Vim script.
The Ruby value "true", "false" and "nil" are converted to v:true, v:false and
v:null, respectively.
==============================================================================
7. Dynamic loading *ruby-dynamic*
On MS-Windows and Unix the Ruby library can be loaded dynamically. The On MS-Windows and Unix the Ruby library can be loaded dynamically. The
|:version| output then includes |+ruby/dyn|. |:version| output then includes |+ruby/dyn|.

21
src/evalfunc.c
View File

@@ -338,6 +338,9 @@ static void f_reverse(typval_T *argvars, typval_T *rettv);
#ifdef FEAT_FLOAT #ifdef FEAT_FLOAT
static void f_round(typval_T *argvars, typval_T *rettv); static void f_round(typval_T *argvars, typval_T *rettv);
#endif #endif
#ifdef FEAT_RUBY
static void f_rubyeval(typval_T *argvars, typval_T *rettv);
#endif
static void f_screenattr(typval_T *argvars, typval_T *rettv); static void f_screenattr(typval_T *argvars, typval_T *rettv);
static void f_screenchar(typval_T *argvars, typval_T *rettv); static void f_screenchar(typval_T *argvars, typval_T *rettv);
static void f_screencol(typval_T *argvars, typval_T *rettv); static void f_screencol(typval_T *argvars, typval_T *rettv);
@@ -828,6 +831,9 @@ static struct fst
{"reverse", 1, 1, f_reverse}, {"reverse", 1, 1, f_reverse},
#ifdef FEAT_FLOAT #ifdef FEAT_FLOAT
{"round", 1, 1, f_round}, {"round", 1, 1, f_round},
#endif
#ifdef FEAT_RUBY
{"rubyeval", 1, 1, f_rubyeval},
#endif #endif
{"screenattr", 2, 2, f_screenattr}, {"screenattr", 2, 2, f_screenattr},
{"screenchar", 2, 2, f_screenchar}, {"screenchar", 2, 2, f_screenchar},
@@ -10351,6 +10357,21 @@ f_round(typval_T *argvars, typval_T *rettv)
} }
#endif #endif
#ifdef FEAT_RUBY
/*
* "rubyeval()" function
*/
static void
f_rubyeval(typval_T *argvars, typval_T *rettv)
{
char_u *str;
char_u buf[NUMBUFLEN];
str = tv_get_string_buf(&argvars[0], buf);
do_rubyeval(str, rettv);
}
#endif
/* /*
* "screenattr()" function * "screenattr()" function
*/ */

420
src/if_ruby.c
View File

@@ -205,6 +205,7 @@ static int ensure_ruby_initialized(void);
static void error_print(int); static void error_print(int);
static void ruby_io_init(void); static void ruby_io_init(void);
static void ruby_vim_init(void); static void ruby_vim_init(void);
static int ruby_convert_to_vim_value(VALUE val, typval_T *rettv);
#if defined(RUBY19_OR_LATER) || defined(RUBY_INIT_STACK) #if defined(RUBY19_OR_LATER) || defined(RUBY_INIT_STACK)
# if defined(__ia64) && !defined(ruby_init_stack) # if defined(__ia64) && !defined(ruby_init_stack)
@@ -259,6 +260,7 @@ static void ruby_vim_init(void);
# endif # endif
# define rb_global_variable dll_rb_global_variable # define rb_global_variable dll_rb_global_variable
# define rb_hash_aset dll_rb_hash_aset # define rb_hash_aset dll_rb_hash_aset
# define rb_hash_foreach dll_rb_hash_foreach
# define rb_hash_new dll_rb_hash_new # define rb_hash_new dll_rb_hash_new
# define rb_inspect dll_rb_inspect # define rb_inspect dll_rb_inspect
# define rb_int2inum dll_rb_int2inum # define rb_int2inum dll_rb_int2inum
@@ -275,6 +277,7 @@ static void ruby_vim_init(void);
# endif # endif
# define rb_num2uint dll_rb_num2uint # define rb_num2uint dll_rb_num2uint
# endif # endif
# define rb_num2dbl dll_rb_num2dbl
# define rb_lastline_get dll_rb_lastline_get # define rb_lastline_get dll_rb_lastline_get
# define rb_lastline_set dll_rb_lastline_set # define rb_lastline_set dll_rb_lastline_set
# define rb_protect dll_rb_protect # define rb_protect dll_rb_protect
@@ -409,6 +412,7 @@ static VALUE (*dll_rb_funcall2) (VALUE, ID, int, const VALUE*);
# endif # endif
static void (*dll_rb_global_variable) (VALUE*); static void (*dll_rb_global_variable) (VALUE*);
static VALUE (*dll_rb_hash_aset) (VALUE, VALUE, VALUE); static VALUE (*dll_rb_hash_aset) (VALUE, VALUE, VALUE);
static VALUE (*dll_rb_hash_foreach) (VALUE, int (*)(VALUE, VALUE, VALUE), VALUE);
static VALUE (*dll_rb_hash_new) (void); static VALUE (*dll_rb_hash_new) (void);
static VALUE (*dll_rb_inspect) (VALUE); static VALUE (*dll_rb_inspect) (VALUE);
static VALUE (*dll_rb_int2inum) (long); static VALUE (*dll_rb_int2inum) (long);
@@ -418,6 +422,7 @@ static long (*dll_rb_fix2int) (VALUE);
static long (*dll_rb_num2int) (VALUE); static long (*dll_rb_num2int) (VALUE);
static unsigned long (*dll_rb_num2uint) (VALUE); static unsigned long (*dll_rb_num2uint) (VALUE);
# endif # endif
static double (*dll_rb_num2dbl) (VALUE);
static VALUE (*dll_rb_lastline_get) (void); static VALUE (*dll_rb_lastline_get) (void);
static void (*dll_rb_lastline_set) (VALUE); static void (*dll_rb_lastline_set) (VALUE);
static VALUE (*dll_rb_protect) (VALUE (*)(VALUE), VALUE, int*); static VALUE (*dll_rb_protect) (VALUE (*)(VALUE), VALUE, int*);
@@ -501,42 +506,50 @@ static void (*dll_rb_gc_writebarrier_unprotect)(VALUE obj);
# if defined(RUBY19_OR_LATER) && !defined(PROTO) # if defined(RUBY19_OR_LATER) && !defined(PROTO)
# if defined(DYNAMIC_RUBY_VER) && DYNAMIC_RUBY_VER >= 22 # if defined(DYNAMIC_RUBY_VER) && DYNAMIC_RUBY_VER >= 22
long rb_num2long_stub(VALUE x) long
rb_num2long_stub(VALUE x)
# else # else
SIGNED_VALUE rb_num2long_stub(VALUE x) SIGNED_VALUE
rb_num2long_stub(VALUE x)
# endif # endif
{ {
return dll_rb_num2long(x); return dll_rb_num2long(x);
} }
# if defined(DYNAMIC_RUBY_VER) && DYNAMIC_RUBY_VER >= 26 # if defined(DYNAMIC_RUBY_VER) && DYNAMIC_RUBY_VER >= 26
VALUE rb_int2big_stub(intptr_t x) VALUE
rb_int2big_stub(intptr_t x)
# else # else
VALUE rb_int2big_stub(SIGNED_VALUE x) VALUE
rb_int2big_stub(SIGNED_VALUE x)
# endif # endif
{ {
return dll_rb_int2big(x); return dll_rb_int2big(x);
} }
# if defined(DYNAMIC_RUBY_VER) && DYNAMIC_RUBY_VER >= 19 \ # if defined(DYNAMIC_RUBY_VER) && DYNAMIC_RUBY_VER >= 19 \
&& VIM_SIZEOF_INT < VIM_SIZEOF_LONG && VIM_SIZEOF_INT < VIM_SIZEOF_LONG
long rb_fix2int_stub(VALUE x) long
rb_fix2int_stub(VALUE x)
{ {
return dll_rb_fix2int(x); return dll_rb_fix2int(x);
} }
long rb_num2int_stub(VALUE x) long
rb_num2int_stub(VALUE x)
{ {
return dll_rb_num2int(x); return dll_rb_num2int(x);
} }
# endif # endif
# if defined(DYNAMIC_RUBY_VER) && DYNAMIC_RUBY_VER >= 20 # if defined(DYNAMIC_RUBY_VER) && DYNAMIC_RUBY_VER >= 20
VALUE VALUE
rb_float_new_in_heap(double d) rb_float_new_in_heap(double d)
{ {
return dll_rb_float_new(d); return dll_rb_float_new(d);
} }
# if defined(DYNAMIC_RUBY_VER) && DYNAMIC_RUBY_VER >= 22 # if defined(DYNAMIC_RUBY_VER) && DYNAMIC_RUBY_VER >= 22
unsigned long rb_num2ulong(VALUE x) unsigned long
rb_num2ulong(VALUE x)
# else # else
VALUE rb_num2ulong(VALUE x) VALUE
rb_num2ulong(VALUE x)
# endif # endif
{ {
return (long)RSHIFT((SIGNED_VALUE)(x),1); return (long)RSHIFT((SIGNED_VALUE)(x),1);
@@ -547,12 +560,14 @@ VALUE rb_num2ulong(VALUE x)
/* Do not generate a prototype here, VALUE isn't always defined. */ /* Do not generate a prototype here, VALUE isn't always defined. */
# if defined(USE_RGENGC) && USE_RGENGC && !defined(PROTO) # if defined(USE_RGENGC) && USE_RGENGC && !defined(PROTO)
# if defined(DYNAMIC_RUBY_VER) && DYNAMIC_RUBY_VER == 21 # if defined(DYNAMIC_RUBY_VER) && DYNAMIC_RUBY_VER == 21
void rb_gc_writebarrier_unprotect_promoted_stub(VALUE obj) void
rb_gc_writebarrier_unprotect_promoted_stub(VALUE obj)
{ {
dll_rb_gc_writebarrier_unprotect_promoted(obj); dll_rb_gc_writebarrier_unprotect_promoted(obj);
} }
# else # else
void rb_gc_writebarrier_unprotect_stub(VALUE obj) void
rb_gc_writebarrier_unprotect_stub(VALUE obj)
{ {
dll_rb_gc_writebarrier_unprotect(obj); dll_rb_gc_writebarrier_unprotect(obj);
} }
@@ -560,7 +575,8 @@ void rb_gc_writebarrier_unprotect_stub(VALUE obj)
# endif # endif
# if defined(DYNAMIC_RUBY_VER) && DYNAMIC_RUBY_VER >= 26 # if defined(DYNAMIC_RUBY_VER) && DYNAMIC_RUBY_VER >= 26
void rb_ary_detransient_stub(VALUE x) void
rb_ary_detransient_stub(VALUE x)
{ {
dll_rb_ary_detransient(x); dll_rb_ary_detransient(x);
} }
@@ -629,6 +645,7 @@ static struct
# endif # endif
{"rb_global_variable", (RUBY_PROC*)&dll_rb_global_variable}, {"rb_global_variable", (RUBY_PROC*)&dll_rb_global_variable},
{"rb_hash_aset", (RUBY_PROC*)&dll_rb_hash_aset}, {"rb_hash_aset", (RUBY_PROC*)&dll_rb_hash_aset},
{"rb_hash_foreach", (RUBY_PROC*)&dll_rb_hash_foreach},
{"rb_hash_new", (RUBY_PROC*)&dll_rb_hash_new}, {"rb_hash_new", (RUBY_PROC*)&dll_rb_hash_new},
{"rb_inspect", (RUBY_PROC*)&dll_rb_inspect}, {"rb_inspect", (RUBY_PROC*)&dll_rb_inspect},
{"rb_int2inum", (RUBY_PROC*)&dll_rb_int2inum}, {"rb_int2inum", (RUBY_PROC*)&dll_rb_int2inum},
@@ -638,6 +655,7 @@ static struct
{"rb_num2int", (RUBY_PROC*)&dll_rb_num2int}, {"rb_num2int", (RUBY_PROC*)&dll_rb_num2int},
{"rb_num2uint", (RUBY_PROC*)&dll_rb_num2uint}, {"rb_num2uint", (RUBY_PROC*)&dll_rb_num2uint},
# endif # endif
{"rb_num2dbl", (RUBY_PROC*)&dll_rb_num2dbl},
{"rb_lastline_get", (RUBY_PROC*)&dll_rb_lastline_get}, {"rb_lastline_get", (RUBY_PROC*)&dll_rb_lastline_get},
{"rb_lastline_set", (RUBY_PROC*)&dll_rb_lastline_set}, {"rb_lastline_set", (RUBY_PROC*)&dll_rb_lastline_set},
{"rb_protect", (RUBY_PROC*)&dll_rb_protect}, {"rb_protect", (RUBY_PROC*)&dll_rb_protect},
@@ -789,7 +807,8 @@ ruby_end(void)
#endif #endif
} }
void ex_ruby(exarg_T *eap) void
ex_ruby(exarg_T *eap)
{ {
int state; int state;
char *script = NULL; char *script = NULL;
@@ -860,7 +879,8 @@ eval_enc_string_protect(const char *str, int *state)
return rb_eval_string_protect(str, state); return rb_eval_string_protect(str, state);
} }
void ex_rubydo(exarg_T *eap) void
ex_rubydo(exarg_T *eap)
{ {
int state; int state;
linenr_T i; linenr_T i;
@@ -906,13 +926,15 @@ void ex_rubydo(exarg_T *eap)
} }
} }
static VALUE rb_load_wrap(VALUE file_to_load) static VALUE
rb_load_wrap(VALUE file_to_load)
{ {
rb_load(file_to_load, 0); rb_load(file_to_load, 0);
return Qnil; return Qnil;
} }
void ex_rubyfile(exarg_T *eap) void
ex_rubyfile(exarg_T *eap)
{ {
int state; int state;
@@ -925,7 +947,8 @@ void ex_rubyfile(exarg_T *eap)
} }
} }
void ruby_buffer_free(buf_T *buf) void
ruby_buffer_free(buf_T *buf)
{ {
if (buf->b_ruby_ref) if (buf->b_ruby_ref)
{ {
@@ -934,7 +957,8 @@ void ruby_buffer_free(buf_T *buf)
} }
} }
void ruby_window_free(win_T *win) void
ruby_window_free(win_T *win)
{ {
if (win->w_ruby_ref) if (win->w_ruby_ref)
{ {
@@ -943,7 +967,8 @@ void ruby_window_free(win_T *win)
} }
} }
static int ensure_ruby_initialized(void) static int
ensure_ruby_initialized(void)
{ {
if (!ruby_initialized) if (!ruby_initialized)
{ {
@@ -993,7 +1018,8 @@ static int ensure_ruby_initialized(void)
return ruby_initialized; return ruby_initialized;
} }
static void error_print(int state) static void
error_print(int state)
{ {
#if !defined(DYNAMIC_RUBY) && !defined(RUBY19_OR_LATER) #if !defined(DYNAMIC_RUBY) && !defined(RUBY19_OR_LATER)
RUBYEXTERN VALUE ruby_errinfo; RUBYEXTERN VALUE ruby_errinfo;
@@ -1018,66 +1044,67 @@ static void error_print(int state)
switch (state) switch (state)
{ {
case TAG_RETURN: case TAG_RETURN:
emsg(_("E267: unexpected return")); emsg(_("E267: unexpected return"));
break; break;
case TAG_NEXT: case TAG_NEXT:
emsg(_("E268: unexpected next")); emsg(_("E268: unexpected next"));
break; break;
case TAG_BREAK: case TAG_BREAK:
emsg(_("E269: unexpected break")); emsg(_("E269: unexpected break"));
break; break;
case TAG_REDO: case TAG_REDO:
emsg(_("E270: unexpected redo")); emsg(_("E270: unexpected redo"));
break; break;
case TAG_RETRY: case TAG_RETRY:
emsg(_("E271: retry outside of rescue clause")); emsg(_("E271: retry outside of rescue clause"));
break; break;
case TAG_RAISE: case TAG_RAISE:
case TAG_FATAL: case TAG_FATAL:
#ifdef RUBY19_OR_LATER #ifdef RUBY19_OR_LATER
error = rb_errinfo(); error = rb_errinfo();
#else #else
error = ruby_errinfo; error = ruby_errinfo;
#endif #endif
eclass = CLASS_OF(error); eclass = CLASS_OF(error);
einfo = rb_obj_as_string(error); einfo = rb_obj_as_string(error);
if (eclass == rb_eRuntimeError && RSTRING_LEN(einfo) == 0) if (eclass == rb_eRuntimeError && RSTRING_LEN(einfo) == 0)
{ {
emsg(_("E272: unhandled exception")); emsg(_("E272: unhandled exception"));
} }
else else
{ {
VALUE epath; VALUE epath;
char *p; char *p;
epath = rb_class_path(eclass); epath = rb_class_path(eclass);
vim_snprintf(buff, BUFSIZ, "%s: %s", vim_snprintf(buff, BUFSIZ, "%s: %s",
RSTRING_PTR(epath), RSTRING_PTR(einfo)); RSTRING_PTR(epath), RSTRING_PTR(einfo));
p = strchr(buff, '\n'); p = strchr(buff, '\n');
if (p) *p = '\0'; if (p) *p = '\0';
emsg(buff); emsg(buff);
} }
attr = syn_name2attr((char_u *)"Error"); attr = syn_name2attr((char_u *)"Error");
# ifdef RUBY21_OR_LATER # ifdef RUBY21_OR_LATER
bt = rb_funcallv(error, rb_intern("backtrace"), 0, 0); bt = rb_funcallv(error, rb_intern("backtrace"), 0, 0);
for (i = 0; i < RARRAY_LEN(bt); i++) for (i = 0; i < RARRAY_LEN(bt); i++)
msg_attr(RSTRING_PTR(RARRAY_AREF(bt, i)), attr); msg_attr(RSTRING_PTR(RARRAY_AREF(bt, i)), attr);
# else # else
bt = rb_funcall2(error, rb_intern("backtrace"), 0, 0); bt = rb_funcall2(error, rb_intern("backtrace"), 0, 0);
for (i = 0; i < RARRAY_LEN(bt); i++) for (i = 0; i < RARRAY_LEN(bt); i++)
msg_attr(RSTRING_PTR(RARRAY_PTR(bt)[i]), attr); msg_attr(RSTRING_PTR(RARRAY_PTR(bt)[i]), attr);
# endif # endif
break; break;
default: default:
vim_snprintf(buff, BUFSIZ, _("E273: unknown longjmp status %d"), state); vim_snprintf(buff, BUFSIZ, _("E273: unknown longjmp status %d"), state);
emsg(buff); emsg(buff);
break; break;
} }
} }
static VALUE vim_message(VALUE self UNUSED, VALUE str) static VALUE
vim_message(VALUE self UNUSED, VALUE str)
{ {
char *buff, *p; char *buff, *p;
@@ -1098,21 +1125,24 @@ static VALUE vim_message(VALUE self UNUSED, VALUE str)
return Qnil; return Qnil;
} }
static VALUE vim_set_option(VALUE self UNUSED, VALUE str) static VALUE
vim_set_option(VALUE self UNUSED, VALUE str)
{ {
do_set((char_u *)StringValuePtr(str), 0); do_set((char_u *)StringValuePtr(str), 0);
update_screen(NOT_VALID); update_screen(NOT_VALID);
return Qnil; return Qnil;
} }
static VALUE vim_command(VALUE self UNUSED, VALUE str) static VALUE
vim_command(VALUE self UNUSED, VALUE str)
{ {
do_cmdline_cmd((char_u *)StringValuePtr(str)); do_cmdline_cmd((char_u *)StringValuePtr(str));
return Qnil; return Qnil;
} }
#ifdef FEAT_EVAL #ifdef FEAT_EVAL
static VALUE vim_to_ruby(typval_T *tv) static VALUE
vim_to_ruby(typval_T *tv)
{ {
VALUE result = Qnil; VALUE result = Qnil;
@@ -1188,7 +1218,8 @@ static VALUE vim_to_ruby(typval_T *tv)
} }
#endif #endif
static VALUE vim_evaluate(VALUE self UNUSED, VALUE str) static VALUE
vim_evaluate(VALUE self UNUSED, VALUE str)
{ {
#ifdef FEAT_EVAL #ifdef FEAT_EVAL
typval_T *tv; typval_T *tv;
@@ -1221,13 +1252,15 @@ static const rb_data_type_t buffer_type = {
# endif # endif
}; };
static size_t buffer_dsize(const void *buf UNUSED) static size_t
buffer_dsize(const void *buf UNUSED)
{ {
return sizeof(buf_T); return sizeof(buf_T);
} }
#endif #endif
static VALUE buffer_new(buf_T *buf) static VALUE
buffer_new(buf_T *buf)
{ {
if (buf->b_ruby_ref) if (buf->b_ruby_ref)
{ {
@@ -1246,7 +1279,8 @@ static VALUE buffer_new(buf_T *buf)
} }
} }
static buf_T *get_buf(VALUE obj) static buf_T *
get_buf(VALUE obj)
{ {
buf_T *buf; buf_T *buf;
@@ -1260,7 +1294,8 @@ static buf_T *get_buf(VALUE obj)
return buf; return buf;
} }
static VALUE vim_blob(VALUE self UNUSED, VALUE str) static VALUE
vim_blob(VALUE self UNUSED, VALUE str)
{ {
VALUE result = rb_str_new("0z", 2); VALUE result = rb_str_new("0z", 2);
char buf[4]; char buf[4];
@@ -1273,12 +1308,14 @@ static VALUE vim_blob(VALUE self UNUSED, VALUE str)
return result; return result;
} }
static VALUE buffer_s_current(void) static VALUE
buffer_s_current(void)
{ {
return buffer_new(curbuf); return buffer_new(curbuf);
} }
static VALUE buffer_s_count(void) static VALUE
buffer_s_count(void)
{ {
buf_T *b; buf_T *b;
int n = 0; int n = 0;
@@ -1294,7 +1331,8 @@ static VALUE buffer_s_count(void)
return INT2NUM(n); return INT2NUM(n);
} }
static VALUE buffer_s_aref(VALUE self UNUSED, VALUE num) static VALUE
buffer_s_aref(VALUE self UNUSED, VALUE num)
{ {
buf_T *b; buf_T *b;
int n = NUM2INT(num); int n = NUM2INT(num);
@@ -1314,35 +1352,40 @@ static VALUE buffer_s_aref(VALUE self UNUSED, VALUE num)
return Qnil; return Qnil;
} }
static VALUE buffer_name(VALUE self) static VALUE
buffer_name(VALUE self)
{ {
buf_T *buf = get_buf(self); buf_T *buf = get_buf(self);
return buf->b_ffname ? rb_str_new2((char *)buf->b_ffname) : Qnil; return buf->b_ffname ? rb_str_new2((char *)buf->b_ffname) : Qnil;
} }
static VALUE buffer_number(VALUE self) static VALUE
buffer_number(VALUE self)
{ {
buf_T *buf = get_buf(self); buf_T *buf = get_buf(self);
return INT2NUM(buf->b_fnum); return INT2NUM(buf->b_fnum);
} }
static VALUE buffer_count(VALUE self) static VALUE
buffer_count(VALUE self)
{ {
buf_T *buf = get_buf(self); buf_T *buf = get_buf(self);
return INT2NUM(buf->b_ml.ml_line_count); return INT2NUM(buf->b_ml.ml_line_count);
} }
static VALUE get_buffer_line(buf_T *buf, linenr_T n) static VALUE
get_buffer_line(buf_T *buf, linenr_T n)
{ {
if (n <= 0 || n > buf->b_ml.ml_line_count) if (n <= 0 || n > buf->b_ml.ml_line_count)
rb_raise(rb_eIndexError, "line number %ld out of range", (long)n); rb_raise(rb_eIndexError, "line number %ld out of range", (long)n);
return vim_str2rb_enc_str((char *)ml_get_buf(buf, n, FALSE)); return vim_str2rb_enc_str((char *)ml_get_buf(buf, n, FALSE));
} }
static VALUE buffer_aref(VALUE self, VALUE num) static VALUE
buffer_aref(VALUE self, VALUE num)
{ {
buf_T *buf = get_buf(self); buf_T *buf = get_buf(self);
@@ -1351,7 +1394,8 @@ static VALUE buffer_aref(VALUE self, VALUE num)
return Qnil; /* For stop warning */ return Qnil; /* For stop warning */
} }
static VALUE set_buffer_line(buf_T *buf, linenr_T n, VALUE str) static VALUE
set_buffer_line(buf_T *buf, linenr_T n, VALUE str)
{ {
char *line = StringValuePtr(str); char *line = StringValuePtr(str);
aco_save_T aco; aco_save_T aco;
@@ -1383,7 +1427,8 @@ static VALUE set_buffer_line(buf_T *buf, linenr_T n, VALUE str)
return str; return str;
} }
static VALUE buffer_aset(VALUE self, VALUE num, VALUE str) static VALUE
buffer_aset(VALUE self, VALUE num, VALUE str)
{ {
buf_T *buf = get_buf(self); buf_T *buf = get_buf(self);
@@ -1392,7 +1437,8 @@ static VALUE buffer_aset(VALUE self, VALUE num, VALUE str)
return str; return str;
} }
static VALUE buffer_delete(VALUE self, VALUE num) static VALUE
buffer_delete(VALUE self, VALUE num)
{ {
buf_T *buf = get_buf(self); buf_T *buf = get_buf(self);
long n = NUM2LONG(num); long n = NUM2LONG(num);
@@ -1427,7 +1473,8 @@ static VALUE buffer_delete(VALUE self, VALUE num)
return Qnil; return Qnil;
} }
static VALUE buffer_append(VALUE self, VALUE num, VALUE str) static VALUE
buffer_append(VALUE self, VALUE num, VALUE str)
{ {
buf_T *buf = get_buf(self); buf_T *buf = get_buf(self);
char *line = StringValuePtr(str); char *line = StringValuePtr(str);
@@ -1479,13 +1526,15 @@ static const rb_data_type_t window_type = {
# endif # endif
}; };
static size_t window_dsize(const void *win UNUSED) static size_t
window_dsize(const void *win UNUSED)
{ {
return sizeof(win_T); return sizeof(win_T);
} }
#endif #endif
static VALUE window_new(win_T *win) static VALUE
window_new(win_T *win)
{ {
if (win->w_ruby_ref) if (win->w_ruby_ref)
{ {
@@ -1504,7 +1553,8 @@ static VALUE window_new(win_T *win)
} }
} }
static win_T *get_win(VALUE obj) static win_T *
get_win(VALUE obj)
{ {
win_T *win; win_T *win;
@@ -1518,7 +1568,8 @@ static win_T *get_win(VALUE obj)
return win; return win;
} }
static VALUE window_s_current(void) static VALUE
window_s_current(void)
{ {
return window_new(curwin); return window_new(curwin);
} }
@@ -1527,24 +1578,26 @@ static VALUE window_s_current(void)
* Added line manipulation functions * Added line manipulation functions
* SegPhault - 03/07/05 * SegPhault - 03/07/05
*/ */
static VALUE line_s_current(void) static VALUE
line_s_current(void)
{ {
return get_buffer_line(curbuf, curwin->w_cursor.lnum); return get_buffer_line(curbuf, curwin->w_cursor.lnum);
} }
static VALUE set_current_line(VALUE self UNUSED, VALUE str) static VALUE
set_current_line(VALUE self UNUSED, VALUE str)
{ {
return set_buffer_line(curbuf, curwin->w_cursor.lnum, str); return set_buffer_line(curbuf, curwin->w_cursor.lnum, str);
} }
static VALUE current_line_number(void) static VALUE
current_line_number(void)
{ {
return INT2FIX((int)curwin->w_cursor.lnum); return INT2FIX((int)curwin->w_cursor.lnum);
} }
static VALUE
window_s_count(void)
static VALUE window_s_count(void)
{ {
win_T *w; win_T *w;
int n = 0; int n = 0;
@@ -1554,7 +1607,8 @@ static VALUE window_s_count(void)
return INT2NUM(n); return INT2NUM(n);
} }
static VALUE window_s_aref(VALUE self UNUSED, VALUE num) static VALUE
window_s_aref(VALUE self UNUSED, VALUE num)
{ {
win_T *w; win_T *w;
int n = NUM2INT(num); int n = NUM2INT(num);
@@ -1565,21 +1619,24 @@ static VALUE window_s_aref(VALUE self UNUSED, VALUE num)
return Qnil; return Qnil;
} }
static VALUE window_buffer(VALUE self) static VALUE
window_buffer(VALUE self)
{ {
win_T *win = get_win(self); win_T *win = get_win(self);
return buffer_new(win->w_buffer); return buffer_new(win->w_buffer);
} }
static VALUE window_height(VALUE self) static VALUE
window_height(VALUE self)
{ {
win_T *win = get_win(self); win_T *win = get_win(self);
return INT2NUM(win->w_height); return INT2NUM(win->w_height);
} }
static VALUE window_set_height(VALUE self, VALUE height) static VALUE
window_set_height(VALUE self, VALUE height)
{ {
win_T *win = get_win(self); win_T *win = get_win(self);
win_T *savewin = curwin; win_T *savewin = curwin;
@@ -1590,12 +1647,14 @@ static VALUE window_set_height(VALUE self, VALUE height)
return height; return height;
} }
static VALUE window_width(VALUE self UNUSED) static VALUE
window_width(VALUE self UNUSED)
{ {
return INT2NUM(get_win(self)->w_width); return INT2NUM(get_win(self)->w_width);
} }
static VALUE window_set_width(VALUE self UNUSED, VALUE width) static VALUE
window_set_width(VALUE self UNUSED, VALUE width)
{ {
win_T *win = get_win(self); win_T *win = get_win(self);
win_T *savewin = curwin; win_T *savewin = curwin;
@@ -1606,14 +1665,16 @@ static VALUE window_set_width(VALUE self UNUSED, VALUE width)
return width; return width;
} }
static VALUE window_cursor(VALUE self) static VALUE
window_cursor(VALUE self)
{ {
win_T *win = get_win(self); win_T *win = get_win(self);
return rb_assoc_new(INT2NUM(win->w_cursor.lnum), INT2NUM(win->w_cursor.col)); return rb_assoc_new(INT2NUM(win->w_cursor.lnum), INT2NUM(win->w_cursor.col));
} }
static VALUE window_set_cursor(VALUE self, VALUE pos) static VALUE
window_set_cursor(VALUE self, VALUE pos)
{ {
VALUE lnum, col; VALUE lnum, col;
win_T *win = get_win(self); win_T *win = get_win(self);
@@ -1631,12 +1692,14 @@ static VALUE window_set_cursor(VALUE self, VALUE pos)
return Qnil; return Qnil;
} }
static VALUE f_nop(VALUE self UNUSED) static VALUE
f_nop(VALUE self UNUSED)
{ {
return Qnil; return Qnil;
} }
static VALUE f_p(int argc, VALUE *argv, VALUE self UNUSED) static VALUE
f_p(int argc, VALUE *argv, VALUE self UNUSED)
{ {
int i; int i;
VALUE str = rb_str_new("", 0); VALUE str = rb_str_new("", 0);
@@ -1656,7 +1719,8 @@ static VALUE f_p(int argc, VALUE *argv, VALUE self UNUSED)
return ret; return ret;
} }
static void ruby_io_init(void) static void
ruby_io_init(void)
{ {
#ifndef DYNAMIC_RUBY #ifndef DYNAMIC_RUBY
RUBYEXTERN VALUE rb_stdout; RUBYEXTERN VALUE rb_stdout;
@@ -1672,7 +1736,8 @@ static void ruby_io_init(void)
rb_define_global_function("p", f_p, -1); rb_define_global_function("p", f_p, -1);
} }
static void ruby_vim_init(void) static void
ruby_vim_init(void)
{ {
objtbl = rb_hash_new(); objtbl = rb_hash_new();
rb_global_variable(&objtbl); rb_global_variable(&objtbl);
@@ -1736,8 +1801,139 @@ static void ruby_vim_init(void)
rb_define_virtual_variable("$curwin", window_s_current, 0); rb_define_virtual_variable("$curwin", window_s_current, 0);
} }
void vim_ruby_init(void *stack_start) void
vim_ruby_init(void *stack_start)
{ {
/* should get machine stack start address early in main function */ /* should get machine stack start address early in main function */
ruby_stack_start = stack_start; ruby_stack_start = stack_start;
} }
static int
convert_hash2dict(VALUE key, VALUE val, VALUE arg)
{
dict_T *d = (dict_T *)arg;
dictitem_T *di;
di = dictitem_alloc((char_u *)RSTRING_PTR(RSTRING(rb_obj_as_string(key))));
if (di == NULL || ruby_convert_to_vim_value(val, &di->di_tv) != OK
|| dict_add(d, di) != OK)
{
d->dv_hashtab.ht_error = TRUE;
return ST_STOP;
}
return ST_CONTINUE;
}
static int
ruby_convert_to_vim_value(VALUE val, typval_T *rettv)
{
switch (TYPE(val))
{
case T_NIL:
rettv->v_type = VAR_SPECIAL;
rettv->vval.v_number = VVAL_NULL;
break;
case T_TRUE:
rettv->v_type = VAR_SPECIAL;
rettv->vval.v_number = VVAL_TRUE;
break;
case T_FALSE:
rettv->v_type = VAR_SPECIAL;
rettv->vval.v_number = VVAL_FALSE;
break;
case T_BIGNUM:
case T_FIXNUM:
rettv->v_type = VAR_NUMBER;
rettv->vval.v_number = (varnumber_T)NUM2LONG(val);
break;
#ifdef FEAT_FLOAT
case T_FLOAT:
rettv->v_type = VAR_FLOAT;
rettv->vval.v_float = (float_T)NUM2DBL(val);
break;
#endif
default:
val = rb_obj_as_string(val);
// FALLTHROUGH
case T_STRING:
{
VALUE str = (VALUE)RSTRING(val);
rettv->v_type = VAR_STRING;
rettv->vval.v_string = vim_strnsave((char_u *)RSTRING_PTR(str),
(int)RSTRING_LEN(str));
}
break;
case T_ARRAY:
{
list_T *l;
long i;
typval_T v;
l = list_alloc();
if (l == NULL)
return FAIL;
for (i = 0; i < RARRAY_LEN(val); ++i)
{
if (ruby_convert_to_vim_value((VALUE)RARRAY_PTR(val)[i],
&v) != OK)
{
list_unref(l);
return FAIL;
}
list_append_tv(l, &v);
clear_tv(&v);
}
rettv->v_type = VAR_LIST;
rettv->vval.v_list = l;
++l->lv_refcount;
}
break;
case T_HASH:
{
dict_T *d;
d = dict_alloc();
if (d == NULL)
return FAIL;
rb_hash_foreach(val, convert_hash2dict, (VALUE)d);
if (d->dv_hashtab.ht_error)
{
dict_unref(d);
return FAIL;
}
rettv->v_type = VAR_DICT;
rettv->vval.v_dict = d;
++d->dv_refcount;
}
break;
}
return OK;
}
void
do_rubyeval(char_u *str, typval_T *rettv)
{
int retval = FAIL;
if (ensure_ruby_initialized())
{
int state;
VALUE obj;
obj = rb_eval_string_protect((const char *)str, &state);
if (state)
error_print(state);
else
retval = ruby_convert_to_vim_value(obj, rettv);
}
if (retval == FAIL)
{
rettv->v_type = VAR_NUMBER;
rettv->vval.v_number = 0;
}
}

1
src/proto/if_ruby.pro
View File

@@ -7,4 +7,5 @@ void ex_rubyfile(exarg_T *eap);
void ruby_buffer_free(buf_T *buf); void ruby_buffer_free(buf_T *buf);
void ruby_window_free(win_T *win); void ruby_window_free(win_T *win);
void vim_ruby_init(void *stack_start); void vim_ruby_init(void *stack_start);
void do_rubyeval(char_u *str, typval_T *rettv);
/* vim: set ft=c : */ /* vim: set ft=c : */

144
src/testdir/test_ruby.vim
View File

@@ -4,13 +4,6 @@ if !has('ruby')
finish finish
end end
" Helper function as there is no builtin rubyeval() function similar
" to perleval, luaevel() or pyeval().
func RubyEval(ruby_expr)
let s = split(execute('ruby print ' . a:ruby_expr), "\n")
return (len(s) == 0) ? '' : s[-1]
endfunc
func Test_ruby_change_buffer() func Test_ruby_change_buffer()
call setline(line('$'), ['1 line 1']) call setline(line('$'), ['1 line 1'])
ruby Vim.command("normal /^1\n") ruby Vim.command("normal /^1\n")
@@ -49,12 +42,12 @@ func Test_set_cursor()
normal gg normal gg
rubydo $curwin.cursor = [1, 5] rubydo $curwin.cursor = [1, 5]
call assert_equal([1, 6], [line('.'), col('.')]) call assert_equal([1, 6], [line('.'), col('.')])
call assert_equal('[1, 5]', RubyEval('$curwin.cursor')) call assert_equal([1, 5], rubyeval('$curwin.cursor'))
" Check that movement after setting cursor position keeps current column. " Check that movement after setting cursor position keeps current column.
normal j normal j
call assert_equal([2, 6], [line('.'), col('.')]) call assert_equal([2, 6], [line('.'), col('.')])
call assert_equal('[2, 5]', RubyEval('$curwin.cursor')) call assert_equal([2, 5], rubyeval('$curwin.cursor'))
call assert_fails('ruby $curwin.cursor = [1]', call assert_fails('ruby $curwin.cursor = [1]',
\ 'ArgumentError: array length must be 2') \ 'ArgumentError: array length must be 2')
@@ -65,25 +58,25 @@ endfunc
func Test_buffer_count() func Test_buffer_count()
new new
call setline(1, ['one', 'two', 'three']) call setline(1, ['one', 'two', 'three'])
call assert_equal('3', RubyEval('$curbuf.count')) call assert_equal(3, rubyeval('$curbuf.count'))
call assert_equal('3', RubyEval('$curbuf.length')) call assert_equal(3, rubyeval('$curbuf.length'))
bwipe! bwipe!
endfunc endfunc
" Test buffer.name (buffer name) " Test buffer.name (buffer name)
func Test_buffer_name() func Test_buffer_name()
new Xfoo new Xfoo
call assert_equal(expand('%:p'), RubyEval('$curbuf.name')) call assert_equal(expand('%:p'), rubyeval('$curbuf.name'))
bwipe bwipe
call assert_equal('', RubyEval('$curbuf.name')) call assert_equal(v:null, rubyeval('$curbuf.name'))
endfunc endfunc
" Test buffer.number (number of the buffer). " Test buffer.number (number of the buffer).
func Test_buffer_number() func Test_buffer_number()
new new
call assert_equal(string(bufnr('%')), RubyEval('$curbuf.number')) call assert_equal(bufnr('%'), rubyeval('$curbuf.number'))
new new
call assert_equal(string(bufnr('%')), RubyEval('$curbuf.number')) call assert_equal(bufnr('%'), rubyeval('$curbuf.number'))
%bwipe %bwipe
endfunc endfunc
@@ -124,7 +117,7 @@ func Test_buffer_line()
new new
call setline(1, ['one', 'two', 'three']) call setline(1, ['one', 'two', 'three'])
2 2
call assert_equal('two', RubyEval('$curbuf.line')) call assert_equal('two', rubyeval('$curbuf.line'))
ruby $curbuf.line = 'TWO' ruby $curbuf.line = 'TWO'
call assert_equal(['one', 'TWO', 'three'], getline(1, '$')) call assert_equal(['one', 'TWO', 'three'], getline(1, '$'))
@@ -137,7 +130,7 @@ func Test_buffer_line_number()
new new
call setline(1, ['one', 'two', 'three']) call setline(1, ['one', 'two', 'three'])
2 2
call assert_equal('2', RubyEval('$curbuf.line_number')) call assert_equal(2, rubyeval('$curbuf.line_number'))
bwipe! bwipe!
endfunc endfunc
@@ -145,8 +138,8 @@ endfunc
func Test_buffer_get() func Test_buffer_get()
new new
call setline(1, ['one', 'two']) call setline(1, ['one', 'two'])
call assert_equal('one', RubyEval('$curbuf[1]')) call assert_equal('one', rubyeval('$curbuf[1]'))
call assert_equal('two', RubyEval('$curbuf[2]')) call assert_equal('two', rubyeval('$curbuf[2]'))
call assert_fails('ruby $curbuf[0]', call assert_fails('ruby $curbuf[0]',
\ 'IndexError: line number 0 out of range') \ 'IndexError: line number 0 out of range')
@@ -178,7 +171,7 @@ func Test_window_height()
call assert_equal(2, winheight(0)) call assert_equal(2, winheight(0))
" Test getting window height " Test getting window height
call assert_equal('2', RubyEval('$curwin.height')) call assert_equal(2, rubyeval('$curwin.height'))
bwipe bwipe
endfunc endfunc
@@ -192,7 +185,7 @@ func Test_window_width()
call assert_equal(2, winwidth(0)) call assert_equal(2, winwidth(0))
" Test getting window width " Test getting window width
call assert_equal('2', RubyEval('$curwin.width')) call assert_equal(2, rubyeval('$curwin.width'))
bwipe bwipe
endfunc endfunc
@@ -207,10 +200,10 @@ func Test_window_buffer()
ruby $b1 = $curwin.buffer ruby $b1 = $curwin.buffer
ruby $w1 = $curwin ruby $w1 = $curwin
call assert_equal(RubyEval('$b1'), RubyEval('$w1.buffer')) call assert_equal(rubyeval('$b1'), rubyeval('$w1.buffer'))
call assert_equal(RubyEval('$b2'), RubyEval('$w2.buffer')) call assert_equal(rubyeval('$b2'), rubyeval('$w2.buffer'))
call assert_equal(string(bufnr('Xfoo1')), RubyEval('$w1.buffer.number')) call assert_equal(bufnr('Xfoo1'), rubyeval('$w1.buffer.number'))
call assert_equal(string(bufnr('Xfoo2')), RubyEval('$w2.buffer.number')) call assert_equal(bufnr('Xfoo2'), rubyeval('$w2.buffer.number'))
ruby $b1, $w1, $b2, $w2 = nil ruby $b1, $w1, $b2, $w2 = nil
%bwipe %bwipe
@@ -218,8 +211,8 @@ endfunc
" Test Vim::Window.current (get current window object) " Test Vim::Window.current (get current window object)
func Test_Vim_window_current() func Test_Vim_window_current()
let cw = RubyEval('$curwin') let cw = rubyeval('$curwin')
call assert_equal(cw, RubyEval('Vim::Window.current')) call assert_equal(cw, rubyeval('Vim::Window.current'))
call assert_match('^#<Vim::Window:0x\x\+>$', cw) call assert_match('^#<Vim::Window:0x\x\+>$', cw)
endfunc endfunc
@@ -228,27 +221,27 @@ func Test_Vim_window_count()
new Xfoo1 new Xfoo1
new Xfoo2 new Xfoo2
split split
call assert_equal('4', RubyEval('Vim::Window.count')) call assert_equal(4, rubyeval('Vim::Window.count'))
%bwipe %bwipe
call assert_equal('1', RubyEval('Vim::Window.count')) call assert_equal(1, rubyeval('Vim::Window.count'))
endfunc endfunc
" Test Vim::Window[n] (get window object of window n) " Test Vim::Window[n] (get window object of window n)
func Test_Vim_window_get() func Test_Vim_window_get()
new Xfoo1 new Xfoo1
new Xfoo2 new Xfoo2
call assert_match('Xfoo2$', RubyEval('Vim::Window[0].buffer.name')) call assert_match('Xfoo2$', rubyeval('Vim::Window[0].buffer.name'))
wincmd j wincmd j
call assert_match('Xfoo1$', RubyEval('Vim::Window[1].buffer.name')) call assert_match('Xfoo1$', rubyeval('Vim::Window[1].buffer.name'))
wincmd j wincmd j
call assert_equal('', RubyEval('Vim::Window[2].buffer.name')) call assert_equal(v:null, rubyeval('Vim::Window[2].buffer.name'))
%bwipe %bwipe
endfunc endfunc
" Test Vim::Buffer.current (return the buffer object of current buffer) " Test Vim::Buffer.current (return the buffer object of current buffer)
func Test_Vim_buffer_current() func Test_Vim_buffer_current()
let cb = RubyEval('$curbuf') let cb = rubyeval('$curbuf')
call assert_equal(cb, RubyEval('Vim::Buffer.current')) call assert_equal(cb, rubyeval('Vim::Buffer.current'))
call assert_match('^#<Vim::Buffer:0x\x\+>$', cb) call assert_match('^#<Vim::Buffer:0x\x\+>$', cb)
endfunc endfunc
@@ -256,9 +249,9 @@ endfunc
func Test_Vim_buffer_count() func Test_Vim_buffer_count()
new Xfoo1 new Xfoo1
new Xfoo2 new Xfoo2
call assert_equal('3', RubyEval('Vim::Buffer.count')) call assert_equal(3, rubyeval('Vim::Buffer.count'))
%bwipe %bwipe
call assert_equal('1', RubyEval('Vim::Buffer.count')) call assert_equal(1, rubyeval('Vim::Buffer.count'))
endfunc endfunc
" Test Vim::buffer[n] (return the buffer object of buffer number n) " Test Vim::buffer[n] (return the buffer object of buffer number n)
@@ -267,9 +260,9 @@ func Test_Vim_buffer_get()
new Xfoo2 new Xfoo2
" Index of Vim::Buffer[n] goes from 0 to the number of buffers. " Index of Vim::Buffer[n] goes from 0 to the number of buffers.
call assert_equal('', RubyEval('Vim::Buffer[0].name')) call assert_equal(v:null, rubyeval('Vim::Buffer[0].name'))
call assert_match('Xfoo1$', RubyEval('Vim::Buffer[1].name')) call assert_match('Xfoo1$', rubyeval('Vim::Buffer[1].name'))
call assert_match('Xfoo2$', RubyEval('Vim::Buffer[2].name')) call assert_match('Xfoo2$', rubyeval('Vim::Buffer[2].name'))
call assert_fails('ruby print Vim::Buffer[3].name', call assert_fails('ruby print Vim::Buffer[3].name',
\ "NoMethodError: undefined method `name' for nil:NilClass") \ "NoMethodError: undefined method `name' for nil:NilClass")
%bwipe %bwipe
@@ -295,43 +288,43 @@ func Test_Vim_set_option()
endfunc endfunc
func Test_Vim_evaluate() func Test_Vim_evaluate()
call assert_equal('123', RubyEval('Vim::evaluate("123")')) call assert_equal(123, rubyeval('Vim::evaluate("123")'))
" Vim::evaluate("123").class gives Integer or Fixnum depending " Vim::evaluate("123").class gives Integer or Fixnum depending
" on versions of Ruby. " on versions of Ruby.
call assert_match('^Integer\|Fixnum$', RubyEval('Vim::evaluate("123").class')) call assert_match('^Integer\|Fixnum$', rubyeval('Vim::evaluate("123").class'))
call assert_equal('1.23', RubyEval('Vim::evaluate("1.23")')) call assert_equal(1.23, rubyeval('Vim::evaluate("1.23")'))
call assert_equal('Float', RubyEval('Vim::evaluate("1.23").class')) call assert_equal('Float', rubyeval('Vim::evaluate("1.23").class'))
call assert_equal('foo', RubyEval('Vim::evaluate("\"foo\"")')) call assert_equal('foo', rubyeval('Vim::evaluate("\"foo\"")'))
call assert_equal('String', RubyEval('Vim::evaluate("\"foo\"").class')) call assert_equal('String', rubyeval('Vim::evaluate("\"foo\"").class'))
call assert_equal('["\x01\xAB"]', RubyEval('Vim::evaluate("0z01ab").unpack("M")')) call assert_equal(["\x01\xAB"], rubyeval('Vim::evaluate("0z01ab").unpack("M")'))
call assert_equal('String', RubyEval('Vim::evaluate("0z01ab").class')) call assert_equal('String', rubyeval('Vim::evaluate("0z01ab").class'))
call assert_equal('[1, 2]', RubyEval('Vim::evaluate("[1, 2]")')) call assert_equal([1, 2], rubyeval('Vim::evaluate("[1, 2]")'))
call assert_equal('Array', RubyEval('Vim::evaluate("[1, 2]").class')) call assert_equal('Array', rubyeval('Vim::evaluate("[1, 2]").class'))
call assert_equal('{"1"=>2}', RubyEval('Vim::evaluate("{1:2}")')) call assert_equal({'1': 2}, rubyeval('Vim::evaluate("{1:2}")'))
call assert_equal('Hash', RubyEval('Vim::evaluate("{1:2}").class')) call assert_equal('Hash', rubyeval('Vim::evaluate("{1:2}").class'))
call assert_equal('', RubyEval('Vim::evaluate("v:null")')) call assert_equal(v:null, rubyeval('Vim::evaluate("v:null")'))
call assert_equal('NilClass', RubyEval('Vim::evaluate("v:null").class')) call assert_equal('NilClass', rubyeval('Vim::evaluate("v:null").class'))
call assert_equal('', RubyEval('Vim::evaluate("v:none")')) call assert_equal(v:null, rubyeval('Vim::evaluate("v:none")'))
call assert_equal('NilClass', RubyEval('Vim::evaluate("v:none").class')) call assert_equal('NilClass', rubyeval('Vim::evaluate("v:none").class'))
call assert_equal('true', RubyEval('Vim::evaluate("v:true")')) call assert_equal(v:true, rubyeval('Vim::evaluate("v:true")'))
call assert_equal('TrueClass', RubyEval('Vim::evaluate("v:true").class')) call assert_equal('TrueClass', rubyeval('Vim::evaluate("v:true").class'))
call assert_equal('false', RubyEval('Vim::evaluate("v:false")')) call assert_equal(v:false, rubyeval('Vim::evaluate("v:false")'))
call assert_equal('FalseClass',RubyEval('Vim::evaluate("v:false").class')) call assert_equal('FalseClass',rubyeval('Vim::evaluate("v:false").class'))
endfunc endfunc
func Test_Vim_blob() func Test_Vim_blob()
call assert_equal('0z', RubyEval('Vim::blob("")')) call assert_equal('0z', rubyeval('Vim::blob("")'))
call assert_equal('0z31326162', RubyEval('Vim::blob("12ab")')) call assert_equal('0z31326162', rubyeval('Vim::blob("12ab")'))
call assert_equal('0z00010203', RubyEval('Vim::blob("\x00\x01\x02\x03")')) call assert_equal('0z00010203', rubyeval('Vim::blob("\x00\x01\x02\x03")'))
call assert_equal('0z8081FEFF', RubyEval('Vim::blob("\x80\x81\xfe\xff")')) call assert_equal('0z8081FEFF', rubyeval('Vim::blob("\x80\x81\xfe\xff")'))
endfunc endfunc
func Test_Vim_evaluate_list() func Test_Vim_evaluate_list()
@@ -364,9 +357,22 @@ func Test_Vim_message()
endfunc endfunc
func Test_print() func Test_print()
ruby print "Hello World!" func RubyPrint(expr)
let messages = split(execute('message'), "\n") return trim(execute('ruby print ' . a:expr))
call assert_equal('Hello World!', messages[-1]) endfunc
call assert_equal('123', RubyPrint('123'))
call assert_equal('1.23', RubyPrint('1.23'))
call assert_equal('Hello World!', RubyPrint('"Hello World!"'))
call assert_equal('[1, 2]', RubyPrint('[1, 2]'))
call assert_equal('{"k1"=>"v1", "k2"=>"v2"}', RubyPrint('({"k1" => "v1", "k2" => "v2"})'))
call assert_equal('true', RubyPrint('true'))
call assert_equal('false', RubyPrint('false'))
call assert_equal('', RubyPrint('nil'))
call assert_match('Vim', RubyPrint('Vim'))
call assert_match('Module', RubyPrint('Vim.class'))
delfunc RubyPrint
endfunc endfunc
func Test_p() func Test_p()
@@ -376,13 +382,13 @@ func Test_p()
" Check return values of p method " Check return values of p method
call assert_equal('123', RubyEval('p(123)')) call assert_equal(123, rubyeval('p(123)'))
call assert_equal('[1, 2, 3]', RubyEval('p(1, 2, 3)')) call assert_equal([1, 2, 3], rubyeval('p(1, 2, 3)'))
" Avoid the "message maintainer" line. " Avoid the "message maintainer" line.
let $LANG = '' let $LANG = ''
messages clear messages clear
call assert_equal('true', RubyEval('p() == nil')) call assert_equal(v:true, rubyeval('p() == nil'))
let messages = split(execute('message'), "\n") let messages = split(execute('message'), "\n")
call assert_equal(0, len(messages)) call assert_equal(0, len(messages))

2
src/version.c
View File

@@ -775,6 +775,8 @@ static char *(features[]) =
static int included_patches[] = static int included_patches[] =
{ /* Add new patch number below this line */ { /* Add new patch number below this line */
/**/
1056,
/**/ /**/
1055, 1055,
/**/ /**/