erlix 0.5.0a
Sign up to get free protection for your applications and to get access to all the features.
- data/_extconf.rb +27 -0
- data/configure +27 -0
- data/extconf.rb +17 -0
- data/findei.erl +6 -0
- data/src/erlix.c +30 -0
- data/src/erlix_atom.c +62 -0
- data/src/erlix_binary.c +67 -0
- data/src/erlix_connection.c +247 -0
- data/src/erlix_connection.h +47 -0
- data/src/erlix_float.c +65 -0
- data/src/erlix_int.c +64 -0
- data/src/erlix_list.c +262 -0
- data/src/erlix_message.c +122 -0
- data/src/erlix_node.c +83 -0
- data/src/erlix_node.h +39 -0
- data/src/erlix_pid.c +68 -0
- data/src/erlix_ref.c +59 -0
- data/src/erlix_term.c +362 -0
- data/src/erlix_term.h +118 -0
- data/src/erlix_tuple.c +215 -0
- data/src/erlix_uint.c +63 -0
- metadata +66 -0
data/src/erlix_term.h
ADDED
@@ -0,0 +1,118 @@
|
|
1
|
+
/*
|
2
|
+
* project : erlix
|
3
|
+
* author : kdr2
|
4
|
+
*
|
5
|
+
*/
|
6
|
+
|
7
|
+
#ifndef ERLIX_TERM_H_
|
8
|
+
#define ERLIX_TERM_H_
|
9
|
+
|
10
|
+
#include "ruby.h"
|
11
|
+
|
12
|
+
#include "erl_interface.h"
|
13
|
+
#include "ei.h"
|
14
|
+
|
15
|
+
#ifndef RUBY_VERSION_MINOR
|
16
|
+
#define RUBY_VERSION_MINOR 8
|
17
|
+
#endif
|
18
|
+
|
19
|
+
|
20
|
+
#ifndef RSTRING_LEN
|
21
|
+
#define RSTRING_LEN(x) (RSTRING(x)->len)
|
22
|
+
#define RSTRING_PTR(x) (RSTRING(x)->ptr)
|
23
|
+
#endif
|
24
|
+
|
25
|
+
#ifndef RARRAY_LEN
|
26
|
+
#define RARRAY_LEN(x) (RARRAY(x)->len)
|
27
|
+
#define RARRAY_PTR(x) (RARRAY(x)->ptr)
|
28
|
+
#endif
|
29
|
+
|
30
|
+
|
31
|
+
/*********** erlix_term ***********/
|
32
|
+
|
33
|
+
#define TYPE_ATOM (1<<0) //DONE
|
34
|
+
#define TYPE_INT (1<<1) //DONE bug?
|
35
|
+
#define TYPE_UINT (1<<2) //DONE bug?
|
36
|
+
#define TYPE_FLOAT (1<<3) //DONE
|
37
|
+
#define TYPE_PID (1<<4) //DONE
|
38
|
+
#define TYPE_PORT (1<<5) //TODO now?
|
39
|
+
#define TYPE_REF (1<<6) //DONE
|
40
|
+
#define TYPE_TUPLE (1<<7) //DONE
|
41
|
+
#define TYPE_BINARY (1<<8) //DONE
|
42
|
+
#define TYPE_LIST (1<<9) //DONE
|
43
|
+
#define TYPE_EMPTY_LIST (1<<10) //NONE
|
44
|
+
#define TYPE_CONS (1<<11) //NONE
|
45
|
+
|
46
|
+
typedef struct _erlix_term{
|
47
|
+
unsigned long flags;
|
48
|
+
unsigned long type;
|
49
|
+
ETERM *term;
|
50
|
+
}ErlixTerm;
|
51
|
+
|
52
|
+
|
53
|
+
extern VALUE erlix_cErlixInt;
|
54
|
+
extern VALUE erlix_cErlixUInt;
|
55
|
+
extern VALUE erlix_cErlixFloat;
|
56
|
+
extern VALUE erlix_cErlixPid;
|
57
|
+
extern VALUE erlix_cErlixRef;
|
58
|
+
extern VALUE erlix_cErlixAtom;
|
59
|
+
extern VALUE erlix_cErlixList;
|
60
|
+
extern VALUE erlix_cErlixTuple;
|
61
|
+
extern VALUE erlix_cErlixBinary;
|
62
|
+
extern VALUE erlix_cErlixConnection;
|
63
|
+
|
64
|
+
extern VALUE erlix_mErlixTerm;
|
65
|
+
extern VALUE erlix_mErlixNode;
|
66
|
+
|
67
|
+
/*
|
68
|
+
* Type Automatic Convert
|
69
|
+
* Ruby-Type -> Erlang-Type
|
70
|
+
* FixNum -> ErlixInt
|
71
|
+
* Float -> ErlixFloat
|
72
|
+
* String -> ErlixList
|
73
|
+
* Symbol -> ErlixAtom
|
74
|
+
*
|
75
|
+
*/
|
76
|
+
#define CAN_AUTO_CONV(v) ((FIXNUM_P(v)) || \
|
77
|
+
(SYMBOL_P(v)) || \
|
78
|
+
(TYPE(v)==T_FLOAT) || \
|
79
|
+
(TYPE(v)==T_STRING))
|
80
|
+
ETERM *erlix_auto_conv(VALUE v);
|
81
|
+
|
82
|
+
#define STRING_P(s) (RB_TYPE_P((s), T_STRING) && CLASS_OF(s) == rb_cString)
|
83
|
+
#define ARRAY_P(s) (RB_TYPE_P((s), T_ARRAY) && CLASS_OF(s) == rb_cArray)
|
84
|
+
#define IS_ETERM(v) (TYPE(v)==T_DATA && RDATA(v)->dfree==(RUBY_DATA_FUNC)free_erlix_term)
|
85
|
+
|
86
|
+
ErlixTerm* new_erlix_term();
|
87
|
+
void free_erlix_term(void* ptr);
|
88
|
+
VALUE erlix_term(ETERM *term);
|
89
|
+
unsigned long erlix_term_type(ETERM *term);
|
90
|
+
|
91
|
+
|
92
|
+
VALUE erlix_int_alloc(VALUE klass);
|
93
|
+
VALUE erlix_uint_alloc(VALUE klass);
|
94
|
+
VALUE erlix_float_alloc(VALUE klass);
|
95
|
+
VALUE erlix_pid_alloc(VALUE klass);
|
96
|
+
VALUE erlix_ref_alloc(VALUE klass);
|
97
|
+
VALUE erlix_atom_alloc(VALUE klass);
|
98
|
+
VALUE erlix_list_alloc(VALUE klass);
|
99
|
+
VALUE erlix_tuple_alloc(VALUE klass);
|
100
|
+
VALUE erlix_binary_alloc(VALUE klass);
|
101
|
+
VALUE erlix_message_alloc(VALUE klass);
|
102
|
+
|
103
|
+
|
104
|
+
void init_erlix_term(VALUE erlix);
|
105
|
+
void init_erlix_int(VALUE erlix);
|
106
|
+
void init_erlix_uint(VALUE erlix);
|
107
|
+
void init_erlix_float(VALUE erlix);
|
108
|
+
void init_erlix_pid(VALUE erlix);
|
109
|
+
void init_erlix_ref(VALUE erlix);
|
110
|
+
void init_erlix_atom(VALUE erlix);
|
111
|
+
void init_erlix_list(VALUE erlix);
|
112
|
+
void init_erlix_node(VALUE erlix);
|
113
|
+
void init_erlix_tuple(VALUE erlix);
|
114
|
+
void init_erlix_binary(VALUE erlix);
|
115
|
+
void init_erlix_message(VALUE erlix);
|
116
|
+
void init_erlix_connection(VALUE erlix);
|
117
|
+
|
118
|
+
#endif /* ERLIX_TERM_H_ */
|
data/src/erlix_tuple.c
ADDED
@@ -0,0 +1,215 @@
|
|
1
|
+
/*
|
2
|
+
* project : erlix
|
3
|
+
* author : kdr2
|
4
|
+
*
|
5
|
+
*/
|
6
|
+
|
7
|
+
#include "erlix_term.h"
|
8
|
+
|
9
|
+
VALUE erlix_cErlixTuple;
|
10
|
+
|
11
|
+
VALUE erlix_tuple_alloc(VALUE klass){
|
12
|
+
VALUE obj;
|
13
|
+
ErlixTerm *tuple=new_erlix_term();
|
14
|
+
tuple->type=TYPE_TUPLE;
|
15
|
+
obj=Data_Wrap_Struct(klass,0,free_erlix_term,tuple);
|
16
|
+
return obj;
|
17
|
+
}
|
18
|
+
|
19
|
+
static VALUE erlix_tuple_init(VALUE self,VALUE ary){
|
20
|
+
ErlixTerm *tuple;
|
21
|
+
VALUE array, e;
|
22
|
+
int i;
|
23
|
+
ETERM **tes;
|
24
|
+
ErlixTerm *ep;
|
25
|
+
|
26
|
+
Data_Get_Struct(self,ErlixTerm,tuple);
|
27
|
+
|
28
|
+
array=rb_check_array_type(ary);
|
29
|
+
if(NIL_P(array)||RARRAY_LEN(array)==0){
|
30
|
+
//empty tuple
|
31
|
+
tuple->term=erl_mk_tuple(NULL,0);
|
32
|
+
return self;
|
33
|
+
}
|
34
|
+
//check: all elements' must be Erlix::Term or auto-convertable Type
|
35
|
+
for(i=0;i<RARRAY_LEN(array);i++){
|
36
|
+
e=RARRAY_PTR(array)[i];
|
37
|
+
if(!IS_ETERM(e) && !CAN_AUTO_CONV(e)){
|
38
|
+
rb_raise(rb_eTypeError,"all tuple's elements must be Erlix::Term or Auto-Convertable-Type!");
|
39
|
+
}
|
40
|
+
}
|
41
|
+
tes=(ETERM**)malloc(sizeof(ETERM*)*(RARRAY_LEN(array)));
|
42
|
+
for(i=0;i<RARRAY_LEN(array);i++){
|
43
|
+
VALUE e=RARRAY_PTR(array)[i];
|
44
|
+
if(IS_ETERM(e)){
|
45
|
+
Data_Get_Struct(e,ErlixTerm,ep);
|
46
|
+
*(tes+i)=erl_copy_term(ep->term);
|
47
|
+
}else{
|
48
|
+
*(tes+i)=erlix_auto_conv(e);
|
49
|
+
}
|
50
|
+
}
|
51
|
+
//TODO
|
52
|
+
tuple->term=erl_mk_tuple(tes,(uint32_t)RARRAY_LEN(array));
|
53
|
+
//for(i=0;i<RARRAY(array)->len;i++){
|
54
|
+
// erl_free_term(*(tes+i));
|
55
|
+
//}
|
56
|
+
free(tes);
|
57
|
+
return self;
|
58
|
+
}
|
59
|
+
|
60
|
+
|
61
|
+
static VALUE erlix_tuple_init2(int argc, VALUE *argv, VALUE self){
|
62
|
+
ErlixTerm *tuple;
|
63
|
+
VALUE array, e;
|
64
|
+
int i;
|
65
|
+
ETERM **tes;
|
66
|
+
ErlixTerm *ep;
|
67
|
+
|
68
|
+
Data_Get_Struct(self,ErlixTerm,tuple);
|
69
|
+
|
70
|
+
if(argc==1 && ARRAY_P(*argv)){
|
71
|
+
return erlix_tuple_init(self, *argv);
|
72
|
+
}
|
73
|
+
|
74
|
+
if(argc==0){
|
75
|
+
//empty tuple
|
76
|
+
tuple->term=erl_mk_tuple(NULL,0);
|
77
|
+
return self;
|
78
|
+
}
|
79
|
+
|
80
|
+
|
81
|
+
//check: all elements' must be Erlix::Term or auto-convertable Type
|
82
|
+
for(i=0; i<argc; i++){
|
83
|
+
e=*(argv+i);
|
84
|
+
if(!IS_ETERM(e) && !CAN_AUTO_CONV(e)){
|
85
|
+
rb_raise(rb_eTypeError,"all tuple's elements must be Erlix::Term or Auto-Convertable-Type!");
|
86
|
+
}
|
87
|
+
}
|
88
|
+
tes=(ETERM**)malloc(sizeof(ETERM*)*argc);
|
89
|
+
for(i=0; i<argc; i++){
|
90
|
+
e=*(argv+i);
|
91
|
+
if(IS_ETERM(e)){
|
92
|
+
Data_Get_Struct(e,ErlixTerm,ep);
|
93
|
+
*(tes+i)=erl_copy_term(ep->term);
|
94
|
+
}else{
|
95
|
+
*(tes+i)=erlix_auto_conv(e);
|
96
|
+
}
|
97
|
+
}
|
98
|
+
//TODO
|
99
|
+
tuple->term=erl_mk_tuple(tes,(uint32_t)RARRAY_LEN(array));
|
100
|
+
//for(i=0;i<RARRAY(array)->len;i++){
|
101
|
+
// erl_free_term(*(tes+i));
|
102
|
+
//}
|
103
|
+
free(tes);
|
104
|
+
return self;
|
105
|
+
}
|
106
|
+
|
107
|
+
static VALUE erlix_tuple_create(int argc,VALUE *argv,VALUE klass){
|
108
|
+
|
109
|
+
ETERM *rterm=NULL;
|
110
|
+
ETERM **tes;
|
111
|
+
ErlixTerm *ep;
|
112
|
+
int i;
|
113
|
+
|
114
|
+
if(argc==0){
|
115
|
+
//empty tuple
|
116
|
+
rterm=erl_mk_tuple(NULL,0);
|
117
|
+
}else if(argc>0){
|
118
|
+
//check: all elements' must be Erlix::Term
|
119
|
+
//or automatic conversions
|
120
|
+
for(i=0;i<argc;i++){
|
121
|
+
if(!IS_ETERM(argv[i]) && !CAN_AUTO_CONV(argv[i])){
|
122
|
+
rb_raise(rb_eTypeError,"all tuple's elements must be Erlix::Term!");
|
123
|
+
}
|
124
|
+
}
|
125
|
+
tes=(ETERM**)malloc(sizeof(ETERM*)*argc);
|
126
|
+
for(i=0;i<argc;i++){
|
127
|
+
if(IS_ETERM(argv[i])){
|
128
|
+
Data_Get_Struct(argv[i],ErlixTerm,ep);
|
129
|
+
*(tes+i)=erl_copy_term(ep->term);
|
130
|
+
}else{
|
131
|
+
*(tes+i)=erlix_auto_conv(argv[i]);
|
132
|
+
}
|
133
|
+
}
|
134
|
+
rterm=erl_mk_tuple(tes,argc);
|
135
|
+
//for(i=0;i<argc;i++){
|
136
|
+
// erl_free_term(*(tes+i));
|
137
|
+
//}
|
138
|
+
free(tes);
|
139
|
+
}
|
140
|
+
return erlix_term(rterm);
|
141
|
+
}
|
142
|
+
|
143
|
+
static VALUE erlix_tuple_nth(VALUE self,VALUE index){
|
144
|
+
ErlixTerm *tuple;
|
145
|
+
ETERM *e;
|
146
|
+
|
147
|
+
if(TYPE(index)!=T_FIXNUM){
|
148
|
+
rb_raise(rb_eTypeError,"index must be a fixnum(1..len)!");
|
149
|
+
return Qnil;
|
150
|
+
}
|
151
|
+
Data_Get_Struct(self,ErlixTerm,tuple);
|
152
|
+
if(ERL_TUPLE_SIZE(tuple->term)<FIX2INT(index)||FIX2INT(index)<=0){
|
153
|
+
return Qnil;
|
154
|
+
}
|
155
|
+
e=erl_element(FIX2INT(index),tuple->term);
|
156
|
+
return erlix_term(erl_copy_term(e));
|
157
|
+
}
|
158
|
+
|
159
|
+
static VALUE erlix_tuple_to_ary(VALUE self){
|
160
|
+
ErlixTerm *tuple;
|
161
|
+
int len, i;
|
162
|
+
ETERM *e;
|
163
|
+
VALUE ret;
|
164
|
+
|
165
|
+
Data_Get_Struct(self,ErlixTerm,tuple);
|
166
|
+
len=ERL_TUPLE_SIZE(tuple->term);
|
167
|
+
ret=rb_ary_new2(len);
|
168
|
+
for(i=0;i<len;i++){
|
169
|
+
e=erl_element(i+1,tuple->term);
|
170
|
+
rb_ary_store(ret,i,erlix_term(erl_copy_term(e)));
|
171
|
+
}
|
172
|
+
return ret;
|
173
|
+
}
|
174
|
+
|
175
|
+
|
176
|
+
static VALUE erlix_tuple_size(VALUE self){
|
177
|
+
ErlixTerm *tuple;
|
178
|
+
int len;
|
179
|
+
|
180
|
+
Data_Get_Struct(self,ErlixTerm,tuple);
|
181
|
+
len=ERL_TUPLE_SIZE(tuple->term);
|
182
|
+
return INT2FIX(len);
|
183
|
+
}
|
184
|
+
|
185
|
+
static VALUE erlix_tuple_inspect(VALUE self){
|
186
|
+
VALUE ret=rb_str_new2("#<Erlix::Tuple:");
|
187
|
+
ID concat=rb_intern("concat");
|
188
|
+
rb_funcall(ret,concat,1,rb_funcall(self,rb_intern("to_s"),0));
|
189
|
+
rb_funcall(ret,concat,1,rb_str_new2(">"));
|
190
|
+
return ret;
|
191
|
+
}
|
192
|
+
|
193
|
+
static VALUE erlix_tuple_etype(VALUE self){
|
194
|
+
return rb_str_new2("tuple");
|
195
|
+
}
|
196
|
+
|
197
|
+
void init_erlix_tuple(VALUE erlix){
|
198
|
+
erlix_cErlixTuple=rb_define_class_under(erlix,"Tuple",rb_cObject);
|
199
|
+
|
200
|
+
rb_define_alloc_func(erlix_cErlixTuple,erlix_tuple_alloc);
|
201
|
+
rb_define_method(erlix_cErlixTuple,"initialize",erlix_tuple_init2,-1);
|
202
|
+
rb_define_method(erlix_cErlixTuple,"nth",erlix_tuple_nth,1);
|
203
|
+
rb_define_method(erlix_cErlixTuple,"[]",erlix_tuple_nth,1);
|
204
|
+
rb_define_method(erlix_cErlixTuple,"to_a",erlix_tuple_to_ary,0);
|
205
|
+
rb_define_method(erlix_cErlixTuple,"size",erlix_tuple_size,0);
|
206
|
+
rb_define_method(erlix_cErlixTuple,"inspect",erlix_tuple_inspect,0);
|
207
|
+
rb_define_method(erlix_cErlixTuple,"etype",erlix_tuple_etype,0);
|
208
|
+
|
209
|
+
rb_define_singleton_method(erlix_cErlixTuple, "[]", erlix_tuple_create, -1);
|
210
|
+
|
211
|
+
rb_include_module(erlix_cErlixTuple,erlix_mErlixTerm);
|
212
|
+
}
|
213
|
+
|
214
|
+
|
215
|
+
|
data/src/erlix_uint.c
ADDED
@@ -0,0 +1,63 @@
|
|
1
|
+
/*
|
2
|
+
* project : erlix
|
3
|
+
* author : kdr2
|
4
|
+
*
|
5
|
+
*/
|
6
|
+
|
7
|
+
#include <stdio.h>
|
8
|
+
#include <string.h>
|
9
|
+
|
10
|
+
#include "erlix_term.h"
|
11
|
+
|
12
|
+
VALUE erlix_cErlixUInt;
|
13
|
+
|
14
|
+
VALUE erlix_uint_alloc(VALUE klass){
|
15
|
+
ErlixTerm* euint;
|
16
|
+
VALUE obj;
|
17
|
+
euint=new_erlix_term();
|
18
|
+
euint->type=TYPE_UINT;
|
19
|
+
obj=Data_Wrap_Struct(klass,0,free_erlix_term,euint);
|
20
|
+
return obj;
|
21
|
+
}
|
22
|
+
|
23
|
+
static VALUE erlix_uint_init(VALUE self,VALUE fix){
|
24
|
+
ErlixTerm* euint;
|
25
|
+
unsigned int i=FIX2UINT(fix);
|
26
|
+
Data_Get_Struct(self,ErlixTerm,euint);
|
27
|
+
euint->term=erl_mk_uint(i);
|
28
|
+
return self;
|
29
|
+
}
|
30
|
+
|
31
|
+
|
32
|
+
static VALUE erlix_uint_to_fix(VALUE self){
|
33
|
+
ErlixTerm *euint;
|
34
|
+
unsigned int l;
|
35
|
+
Data_Get_Struct(self,ErlixTerm,euint);
|
36
|
+
l=ERL_INT_VALUE(euint->term);
|
37
|
+
return INT2FIX(l);
|
38
|
+
}
|
39
|
+
|
40
|
+
static VALUE erlix_uint_inspect(VALUE self){
|
41
|
+
VALUE ret=rb_str_new2("#<Erlix::UInt:");
|
42
|
+
ID concat=rb_intern("concat");
|
43
|
+
rb_funcall(ret,concat,1,rb_funcall(self,rb_intern("to_s"),0));
|
44
|
+
rb_funcall(ret,concat,1,rb_str_new2(">"));
|
45
|
+
return ret;
|
46
|
+
}
|
47
|
+
|
48
|
+
static VALUE erlix_uint_etype(VALUE self){
|
49
|
+
return rb_str_new2("unsigned int");
|
50
|
+
}
|
51
|
+
|
52
|
+
void init_erlix_uint(VALUE erlix){
|
53
|
+
erlix_cErlixUInt=rb_define_class_under(erlix,"UInt",rb_cObject);
|
54
|
+
|
55
|
+
rb_define_alloc_func(erlix_cErlixUInt,erlix_uint_alloc);
|
56
|
+
rb_define_method(erlix_cErlixUInt,"initialize",erlix_uint_init,1);
|
57
|
+
rb_define_method(erlix_cErlixUInt,"to_i",erlix_uint_to_fix,0);
|
58
|
+
rb_define_method(erlix_cErlixUInt,"inspect",erlix_uint_inspect,0);
|
59
|
+
rb_define_method(erlix_cErlixUInt,"etype",erlix_uint_etype,0);
|
60
|
+
|
61
|
+
rb_include_module(erlix_cErlixUInt,erlix_mErlixTerm);
|
62
|
+
}
|
63
|
+
|
metadata
ADDED
@@ -0,0 +1,66 @@
|
|
1
|
+
--- !ruby/object:Gem::Specification
|
2
|
+
name: erlix
|
3
|
+
version: !ruby/object:Gem::Version
|
4
|
+
version: 0.5.0a
|
5
|
+
prerelease: 5
|
6
|
+
platform: ruby
|
7
|
+
authors:
|
8
|
+
- KDr2
|
9
|
+
autorequire:
|
10
|
+
bindir: bin
|
11
|
+
cert_chain: []
|
12
|
+
date: 2012-07-25 00:00:00.000000000 Z
|
13
|
+
dependencies: []
|
14
|
+
description: Run ruby as an Erlang Node!
|
15
|
+
email: killy.draw@gmail.com
|
16
|
+
executables: []
|
17
|
+
extensions:
|
18
|
+
- _extconf.rb
|
19
|
+
extra_rdoc_files: []
|
20
|
+
files:
|
21
|
+
- configure
|
22
|
+
- _extconf.rb
|
23
|
+
- extconf.rb
|
24
|
+
- findei.erl
|
25
|
+
- src/erlix.c
|
26
|
+
- src/erlix_atom.c
|
27
|
+
- src/erlix_binary.c
|
28
|
+
- src/erlix_connection.c
|
29
|
+
- src/erlix_float.c
|
30
|
+
- src/erlix_int.c
|
31
|
+
- src/erlix_list.c
|
32
|
+
- src/erlix_message.c
|
33
|
+
- src/erlix_node.c
|
34
|
+
- src/erlix_pid.c
|
35
|
+
- src/erlix_ref.c
|
36
|
+
- src/erlix_term.c
|
37
|
+
- src/erlix_tuple.c
|
38
|
+
- src/erlix_uint.c
|
39
|
+
- src/erlix_connection.h
|
40
|
+
- src/erlix_node.h
|
41
|
+
- src/erlix_term.h
|
42
|
+
homepage: http://github.com/KDr2/erlix
|
43
|
+
licenses: []
|
44
|
+
post_install_message: Thanks for installing!
|
45
|
+
rdoc_options: []
|
46
|
+
require_paths:
|
47
|
+
- lib
|
48
|
+
required_ruby_version: !ruby/object:Gem::Requirement
|
49
|
+
none: false
|
50
|
+
requirements:
|
51
|
+
- - ! '>='
|
52
|
+
- !ruby/object:Gem::Version
|
53
|
+
version: 1.9.2
|
54
|
+
required_rubygems_version: !ruby/object:Gem::Requirement
|
55
|
+
none: false
|
56
|
+
requirements:
|
57
|
+
- - ! '>'
|
58
|
+
- !ruby/object:Gem::Version
|
59
|
+
version: 1.3.1
|
60
|
+
requirements: []
|
61
|
+
rubyforge_project:
|
62
|
+
rubygems_version: 1.8.24
|
63
|
+
signing_key:
|
64
|
+
specification_version: 3
|
65
|
+
summary: Run ruby as an Erlang Node!
|
66
|
+
test_files: []
|