duby 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (69) hide show
  1. data/History.txt +4 -0
  2. data/Manifest.txt +68 -0
  3. data/README.txt +31 -0
  4. data/Rakefile +37 -0
  5. data/bin/duby +9 -0
  6. data/bin/dubyc +9 -0
  7. data/bin/dubyp +9 -0
  8. data/examples/appengine/src/com/google/appengine/ext/duby/db/Model.duby +132 -0
  9. data/examples/appengine/src/com/ribrdb/DubyApp.duby +28 -0
  10. data/examples/bench_fractal.duby +57 -0
  11. data/examples/construction.duby +8 -0
  12. data/examples/edb.duby +3 -0
  13. data/examples/fib.duby +24 -0
  14. data/examples/fields.duby +22 -0
  15. data/examples/java_thing.duby +13 -0
  16. data/examples/simple_class.duby +12 -0
  17. data/examples/swing.duby +20 -0
  18. data/examples/tak.duby +15 -0
  19. data/javalib/JRubyParser.jar +0 -0
  20. data/lib/duby.rb +170 -0
  21. data/lib/duby/ast.rb +340 -0
  22. data/lib/duby/ast/call.rb +73 -0
  23. data/lib/duby/ast/class.rb +145 -0
  24. data/lib/duby/ast/flow.rb +328 -0
  25. data/lib/duby/ast/intrinsics.rb +46 -0
  26. data/lib/duby/ast/literal.rb +93 -0
  27. data/lib/duby/ast/local.rb +77 -0
  28. data/lib/duby/ast/method.rb +187 -0
  29. data/lib/duby/ast/structure.rb +44 -0
  30. data/lib/duby/ast/type.rb +93 -0
  31. data/lib/duby/c/compiler.rb +134 -0
  32. data/lib/duby/compiler.rb +261 -0
  33. data/lib/duby/jvm/compiler.rb +684 -0
  34. data/lib/duby/jvm/method_lookup.rb +185 -0
  35. data/lib/duby/jvm/source_compiler.rb +516 -0
  36. data/lib/duby/jvm/source_generator/builder.rb +368 -0
  37. data/lib/duby/jvm/source_generator/loops.rb +132 -0
  38. data/lib/duby/jvm/source_generator/precompile.rb +154 -0
  39. data/lib/duby/jvm/source_generator/typer.rb +11 -0
  40. data/lib/duby/jvm/typer.rb +118 -0
  41. data/lib/duby/jvm/types.rb +326 -0
  42. data/lib/duby/jvm/types/basic_types.rb +18 -0
  43. data/lib/duby/jvm/types/boolean.rb +11 -0
  44. data/lib/duby/jvm/types/factory.rb +151 -0
  45. data/lib/duby/jvm/types/floats.rb +70 -0
  46. data/lib/duby/jvm/types/integers.rb +110 -0
  47. data/lib/duby/jvm/types/intrinsics.rb +157 -0
  48. data/lib/duby/jvm/types/literals.rb +82 -0
  49. data/lib/duby/jvm/types/methods.rb +344 -0
  50. data/lib/duby/jvm/types/number.rb +92 -0
  51. data/lib/duby/nbcompiler.rb +29 -0
  52. data/lib/duby/old/compiler_old.rb +845 -0
  53. data/lib/duby/old/declaration.rb +72 -0
  54. data/lib/duby/old/mapper.rb +72 -0
  55. data/lib/duby/old/signature.rb +52 -0
  56. data/lib/duby/old/typer_old.rb +163 -0
  57. data/lib/duby/plugin/edb.rb +25 -0
  58. data/lib/duby/plugin/java.rb +42 -0
  59. data/lib/duby/plugin/math.rb +84 -0
  60. data/lib/duby/transform.rb +908 -0
  61. data/lib/duby/typer.rb +359 -0
  62. data/test/test_ast.rb +391 -0
  63. data/test/test_compilation.rb +98 -0
  64. data/test/test_java_typer.rb +199 -0
  65. data/test/test_javac_compiler.rb +57 -0
  66. data/test/test_jvm_compiler.rb +1459 -0
  67. data/test/test_math_plugin.rb +87 -0
  68. data/test/test_typer.rb +246 -0
  69. metadata +155 -0
@@ -0,0 +1,87 @@
1
+ require 'test/unit'
2
+ require 'duby'
3
+ require 'duby/plugin/math'
4
+
5
+ class TestMathPlugin < Test::Unit::TestCase
6
+ include Duby
7
+
8
+ def setup
9
+ @typer = Typer::Simple.new :bar
10
+ end
11
+
12
+ def assert_resolves_to(type, script)
13
+ ast = AST.parse("1 + 1")
14
+ ast.infer(@typer)
15
+ assert_nothing_raised {@typer.resolve(true)}
16
+ assert_equal(@typer.fixnum_type, ast.inferred_type)
17
+ end
18
+
19
+ def test_plus
20
+ assert_resolves_to(@typer.fixnum_type, '1 + 1')
21
+ assert_resolves_to(@typer.float_type, '1.0 + 1.0')
22
+ end
23
+
24
+ def test_minus
25
+ assert_resolves_to(@typer.fixnum_type, '1 - 1')
26
+ assert_resolves_to(@typer.float_type, '1.0 - 1.0')
27
+ end
28
+
29
+ def test_times
30
+ assert_resolves_to(@typer.fixnum_type, '1 * 1')
31
+ assert_resolves_to(@typer.float_type, '1.0 * 1.0')
32
+ end
33
+
34
+ def test_divide
35
+ assert_resolves_to(@typer.fixnum_type, '1 / 1')
36
+ assert_resolves_to(@typer.float_type, '1.0 / 1.0')
37
+ end
38
+
39
+ def test_remainder
40
+ assert_resolves_to(@typer.fixnum_type, '1 % 1')
41
+ assert_resolves_to(@typer.float_type, '1.0 % 1.0')
42
+ end
43
+
44
+ def test_shift_left
45
+ assert_resolves_to(@typer.fixnum_type, '1 << 1')
46
+ end
47
+
48
+ def test_shift_right
49
+ assert_resolves_to(@typer.fixnum_type, '1 >> 1')
50
+ end
51
+
52
+ def test_ushift_right
53
+ assert_resolves_to(@typer.fixnum_type, '1 >>> 1')
54
+ end
55
+
56
+ def test_bitwise_and
57
+ assert_resolves_to(@typer.fixnum_type, '1 & 1')
58
+ end
59
+
60
+ def test_bitwise_or
61
+ assert_resolves_to(@typer.fixnum_type, '1 | 1')
62
+ end
63
+
64
+ def test_bitwise_xor
65
+ assert_resolves_to(@typer.fixnum_type, '1 ^ 1')
66
+ end
67
+
68
+ def test_less_than
69
+ assert_resolves_to(@typer.boolean_type, '1 < 1')
70
+ assert_resolves_to(@typer.boolean_type, '1.0 < 1.0')
71
+ end
72
+
73
+ def test_greater_than
74
+ assert_resolves_to(@typer.boolean_type, '1 > 1')
75
+ assert_resolves_to(@typer.boolean_type, '1.0 > 1.0')
76
+ end
77
+
78
+ def test_less_than_or_equal
79
+ assert_resolves_to(@typer.boolean_type, '1 <= 1')
80
+ assert_resolves_to(@typer.boolean_type, '1.0 <= 1.0')
81
+ end
82
+
83
+ def test_greater_than_or_equal
84
+ assert_resolves_to(@typer.boolean_type, '1 >= 1')
85
+ assert_resolves_to(@typer.boolean_type, '1.0 >= 1.0')
86
+ end
87
+ end
@@ -0,0 +1,246 @@
1
+ require 'test/unit'
2
+ require 'duby'
3
+
4
+ class TestTyper < Test::Unit::TestCase
5
+ include Duby
6
+
7
+ def test_fixnum
8
+ ast = AST.parse("1")
9
+
10
+ assert_equal(AST::TypeReference.new("fixnum"), ast.infer(Typer::Simple.new(:bar)))
11
+ end
12
+
13
+ def test_float
14
+ ast = AST.parse("1.0")
15
+
16
+ assert_equal(AST::TypeReference.new("float"), ast.infer(Typer::Simple.new(:bar)))
17
+ end
18
+
19
+ def test_string
20
+ ast = AST.parse("'foo'")
21
+
22
+ assert_equal(AST::TypeReference.new("string"), ast.infer(Typer::Simple.new(:bar)))
23
+ end
24
+
25
+ def test_boolean
26
+ ast1 = AST.parse("true")
27
+ ast2 = AST.parse("false")
28
+
29
+ assert_equal(AST::TypeReference.new("boolean"), ast1.infer(Typer::Simple.new(:bar)))
30
+ assert_equal(AST::TypeReference.new("boolean"), ast2.infer(Typer::Simple.new(:bar)))
31
+ end
32
+
33
+ def test_body
34
+ ast1 = AST.parse("'foo'; 1.0; 1")
35
+ ast2 = AST.parse("begin; end")
36
+
37
+ assert_equal(AST::TypeReference.new("fixnum"), ast1.infer(Typer::Simple.new(:bar)))
38
+ assert_equal(AST::no_type, ast2.infer(Typer::Simple.new(:bar)))
39
+ end
40
+
41
+ def test_local
42
+ ast1 = AST.parse("a = 1; a")
43
+ typer = Typer::Simple.new :bar
44
+
45
+ ast1.infer(typer)
46
+
47
+ assert_equal(AST::TypeReference.new("fixnum"), typer.local_type(ast1, 'a'))
48
+ assert_equal(AST::TypeReference.new("fixnum"), ast1.body.children[0].inferred_type)
49
+ assert_equal(AST::TypeReference.new("fixnum"), ast1.body.children[1].inferred_type)
50
+
51
+ ast2 = AST.parse("b = a = 1")
52
+ ast2.infer(typer)
53
+
54
+ assert_equal(AST::TypeReference.new("fixnum"), typer.local_type(ast2, 'a'))
55
+ assert_equal(AST::TypeReference.new("fixnum"), ast2.body.children[0].inferred_type)
56
+ end
57
+
58
+ def test_signature
59
+ ["def foo", "def self.foo"].each do |def_foo|
60
+ ast1 = AST.parse("#{def_foo}(a); {a => :string}; end")
61
+ typer = Typer::Simple.new :bar
62
+
63
+ ast1.infer(typer)
64
+
65
+ assert_nothing_raised {typer.resolve(true)}
66
+ assert_nothing_raised {typer.resolve}
67
+
68
+
69
+ if def_foo =~ /self/
70
+ type = typer.self_type.meta
71
+ else
72
+ type = typer.self_type
73
+ end
74
+
75
+ assert_equal(typer.no_type, typer.method_type(type, 'foo', [typer.string_type]))
76
+ assert_equal(typer.string_type, typer.local_type(ast1.body, 'a'))
77
+ assert_equal(typer.no_type, ast1.body.inferred_type)
78
+ assert_equal(typer.string_type, ast1.body.arguments.args[0].inferred_type)
79
+
80
+ ast1 = AST.parse("#{def_foo}(a); 1 end")
81
+ typer = Typer::Simple.new :bar
82
+
83
+ ast1.infer(typer)
84
+
85
+ assert_equal(typer.fixnum_type, typer.method_type(type, 'foo', [typer.default_type]))
86
+ assert_equal(typer.default_type, typer.local_type(ast1.body, 'a'))
87
+ assert_equal(typer.fixnum_type, ast1.body.inferred_type)
88
+ assert_equal(typer.default_type, ast1.body.arguments.args[0].inferred_type)
89
+
90
+ ast1 = AST.parse("#{def_foo}(a); {a => :string}; a; end")
91
+ typer = Typer::Simple.new :bar
92
+
93
+ ast1.infer(typer)
94
+
95
+ assert_equal(typer.string_type, typer.method_type(type, 'foo', [typer.string_type]))
96
+ assert_equal(typer.string_type, typer.local_type(ast1.body, 'a'))
97
+ assert_equal(typer.string_type, ast1.body.inferred_type)
98
+ assert_equal(typer.string_type, ast1.body.arguments.args[0].inferred_type)
99
+
100
+ ast1 = AST.parse("#{def_foo}(a); {:return => :string}; end")
101
+ typer = Typer::Simple.new :bar
102
+
103
+ assert_raise(Typer::InferenceError) do
104
+ ast1.infer(typer)
105
+ typer.resolve(true)
106
+ end
107
+
108
+ ast1 = AST.parse("#{def_foo}(a); a = 'foo'; end")
109
+ typer = Typer::Simple.new :bar
110
+
111
+ ast1.infer(typer)
112
+
113
+ assert_equal(typer.string_type, typer.method_type(type, 'foo', [typer.default_type]))
114
+ assert_equal(typer.string_type, typer.local_type(ast1.body, 'a'))
115
+ assert_equal(typer.string_type, ast1.body.inferred_type)
116
+ assert_equal(typer.default_type, ast1.body.arguments.args[0].inferred_type)
117
+
118
+ typer.resolve
119
+
120
+ assert_equal(typer.string_type, ast1.body.arguments.args[0].inferred_type)
121
+ end
122
+ end
123
+
124
+ def test_call
125
+ ast = AST.parse("1.foo(2)").body
126
+ typer = Typer::Simple.new "bar"
127
+
128
+ typer.learn_method_type(typer.fixnum_type, "foo", [typer.fixnum_type], typer.string_type, [])
129
+ assert_equal(typer.string_type, typer.method_type(typer.fixnum_type, "foo", [typer.fixnum_type]))
130
+
131
+ ast.infer(typer)
132
+
133
+ assert_equal(typer.string_type, ast.inferred_type)
134
+
135
+ ast = AST.parse("def bar(a, b); {a => :fixnum, b => :string}; 1.0; end; def baz; bar(1, 'x'); end").body
136
+
137
+ ast.infer(typer)
138
+
139
+ assert_equal(typer.float_type, typer.method_type(typer.self_type, "bar", [typer.fixnum_type, typer.string_type]))
140
+ assert_equal(typer.float_type, typer.method_type(typer.self_type, "baz", []))
141
+ assert_equal(typer.float_type, ast.children[0].inferred_type)
142
+ assert_equal(typer.float_type, ast.children[1].inferred_type)
143
+
144
+ # Reverse the order, ensure deferred inference succeeds
145
+ ast = AST.parse("def baz; bar(1, 'x'); end; def bar(a, b); {a => :fixnum, b => :string}; 1.0; end").body
146
+ typer = Typer::Simple.new("bar")
147
+
148
+ ast.infer(typer)
149
+
150
+ assert_equal(typer.default_type, typer.method_type(typer.self_type, "baz", []))
151
+ assert_equal(typer.float_type, typer.method_type(typer.self_type, "bar", [typer.fixnum_type, typer.string_type]))
152
+ assert_equal(typer.default_type, ast.children[0].inferred_type)
153
+ assert_equal(typer.float_type, ast.children[1].inferred_type)
154
+
155
+ # allow resolution to run
156
+ assert_nothing_raised {typer.resolve}
157
+
158
+ assert_equal(typer.float_type, typer.method_type(typer.self_type, "baz", []))
159
+ assert_equal(typer.float_type, typer.method_type(typer.self_type, "bar", [typer.fixnum_type, typer.string_type]))
160
+ assert_equal(typer.float_type, ast.children[0].inferred_type)
161
+ assert_equal(typer.float_type, ast.children[1].inferred_type)
162
+
163
+ # modify bar call to have bogus types, ensure resolution fails
164
+ ast = AST.parse("def baz; bar(1, 1); end; def bar(a, b); {a => :fixnum, b => :string}; 1.0; end").body
165
+ typer = Typer::Simple.new("bar")
166
+
167
+ ast.infer(typer)
168
+
169
+ assert_equal(typer.default_type, typer.method_type(typer.self_type, "baz", []))
170
+ assert_equal(typer.float_type, typer.method_type(typer.self_type, "bar", [typer.fixnum_type, typer.string_type]))
171
+ assert_equal(typer.default_type, ast.children[0].inferred_type)
172
+ assert_equal(typer.float_type, ast.children[1].inferred_type)
173
+
174
+ # allow resolution to run and produce error
175
+ assert_raise(Typer::InferenceError) {typer.resolve(true)}
176
+ error_nodes = typer.errors.map {|e| e.node}
177
+ inspected = "[FunctionalCall(bar)\n Fixnum(1)\n Fixnum(1)]"
178
+ assert_equal(inspected, error_nodes.inspect)
179
+ end
180
+
181
+ def test_if
182
+ ast = AST.parse("if true; 1.0; else; ''; end").body
183
+ typer = Typer::Simple.new("bar")
184
+
185
+ # incompatible body types
186
+ assert_raise(Typer::InferenceError) {ast.infer(typer)}
187
+
188
+ ast = AST.parse("if true; 1.0; else; 2.0; end").body
189
+
190
+ assert_nothing_raised {ast.infer(typer); typer.resolve(true)}
191
+
192
+ assert_equal(typer.boolean_type, ast.condition.inferred_type)
193
+ assert_equal(typer.float_type, ast.body.inferred_type)
194
+ assert_equal(typer.float_type, ast.else.inferred_type)
195
+
196
+ ast = AST.parse("if foo; bar; else; baz; end").body
197
+
198
+ assert_nothing_raised {ast.infer(typer)}
199
+
200
+ assert_equal(typer.default_type, ast.condition.inferred_type)
201
+ assert_equal(typer.default_type, ast.body.inferred_type)
202
+ assert_equal(typer.default_type, ast.else.inferred_type)
203
+
204
+ # unresolved types for the foo, bar, and baz calls
205
+ assert_raise(Typer::InferenceError) {typer.resolve(true)}
206
+
207
+ ast2 = AST.parse("def foo; 1; end; def bar; 1.0; end")
208
+
209
+ ast2.infer(typer)
210
+ ast.infer(typer)
211
+
212
+ # unresolved types for the baz call
213
+ assert_raise(Typer::InferenceError) {typer.resolve(true)}
214
+
215
+ assert_equal(AST.error_type, ast.condition.inferred_type)
216
+ assert_equal(AST.error_type, ast.body.inferred_type)
217
+ assert_equal(AST.error_type, ast.else.inferred_type)
218
+
219
+ typer.errors.clear
220
+
221
+ ast2 = AST.parse("def baz; 2.0; end")
222
+
223
+ ast2.infer(typer)
224
+ ast.infer(typer)
225
+
226
+ assert_nothing_raised {typer.resolve(true)}
227
+
228
+ assert_equal(typer.float_type, ast2.body.inferred_type)
229
+ end
230
+
231
+ def test_class
232
+ ast = AST.parse("class Foo; def foo; 1; end; def baz; foo; end; end")
233
+ cls = ast.body
234
+ foo = cls.body[0]
235
+ baz = cls.body[1]
236
+
237
+ typer = Typer::Simple.new("script")
238
+ ast.infer(typer)
239
+
240
+ assert_nothing_raised {typer.resolve(true)}
241
+
242
+ assert_not_nil(typer.known_types["Foo"])
243
+ assert(AST::TypeDefinition === typer.known_types["Foo"])
244
+ assert_equal(typer.known_types["Foo"], cls.inferred_type)
245
+ end
246
+ end
metadata ADDED
@@ -0,0 +1,155 @@
1
+ --- !ruby/object:Gem::Specification
2
+ name: duby
3
+ version: !ruby/object:Gem::Version
4
+ version: 0.0.1
5
+ platform: ruby
6
+ authors:
7
+ - Charles Oliver Nutter
8
+ - Ryan Brown
9
+ autorequire:
10
+ bindir: bin
11
+ cert_chain: []
12
+
13
+ date: 2009-10-27 00:00:00 -05:00
14
+ default_executable:
15
+ dependencies:
16
+ - !ruby/object:Gem::Dependency
17
+ name: bitescript
18
+ type: :runtime
19
+ version_requirement:
20
+ version_requirements: !ruby/object:Gem::Requirement
21
+ requirements:
22
+ - - ">="
23
+ - !ruby/object:Gem::Version
24
+ version: 0.0.4
25
+ version:
26
+ - !ruby/object:Gem::Dependency
27
+ name: hoe
28
+ type: :development
29
+ version_requirement:
30
+ version_requirements: !ruby/object:Gem::Requirement
31
+ requirements:
32
+ - - ">="
33
+ - !ruby/object:Gem::Version
34
+ version: 2.3.3
35
+ version:
36
+ description: Duby is a customizable programming language featuring static types, local type inference and a heavily Ruby-inspired syntax. Duby currently includes a typer/compiler backend for the JVM which can output either JVM bytecode or Java source files.
37
+ email:
38
+ - headius@headius.com
39
+ - ribrdb@google.com
40
+ executables:
41
+ - duby
42
+ - dubyc
43
+ - dubyp
44
+ extensions: []
45
+
46
+ extra_rdoc_files:
47
+ - History.txt
48
+ - Manifest.txt
49
+ - README.txt
50
+ files:
51
+ - bin/duby
52
+ - bin/dubyc
53
+ - bin/dubyp
54
+ - lib/duby.rb
55
+ - lib/duby/ast.rb
56
+ - lib/duby/compiler.rb
57
+ - lib/duby/nbcompiler.rb
58
+ - lib/duby/transform.rb
59
+ - lib/duby/typer.rb
60
+ - lib/duby/ast/call.rb
61
+ - lib/duby/ast/class.rb
62
+ - lib/duby/ast/flow.rb
63
+ - lib/duby/ast/intrinsics.rb
64
+ - lib/duby/ast/literal.rb
65
+ - lib/duby/ast/local.rb
66
+ - lib/duby/ast/method.rb
67
+ - lib/duby/ast/structure.rb
68
+ - lib/duby/ast/type.rb
69
+ - lib/duby/c/compiler.rb
70
+ - lib/duby/jvm/compiler.rb
71
+ - lib/duby/jvm/method_lookup.rb
72
+ - lib/duby/jvm/source_compiler.rb
73
+ - lib/duby/jvm/typer.rb
74
+ - lib/duby/jvm/types.rb
75
+ - lib/duby/jvm/source_generator/builder.rb
76
+ - lib/duby/jvm/source_generator/loops.rb
77
+ - lib/duby/jvm/source_generator/precompile.rb
78
+ - lib/duby/jvm/source_generator/typer.rb
79
+ - lib/duby/jvm/types/basic_types.rb
80
+ - lib/duby/jvm/types/boolean.rb
81
+ - lib/duby/jvm/types/factory.rb
82
+ - lib/duby/jvm/types/floats.rb
83
+ - lib/duby/jvm/types/integers.rb
84
+ - lib/duby/jvm/types/intrinsics.rb
85
+ - lib/duby/jvm/types/literals.rb
86
+ - lib/duby/jvm/types/methods.rb
87
+ - lib/duby/jvm/types/number.rb
88
+ - lib/duby/old/compiler_old.rb
89
+ - lib/duby/old/declaration.rb
90
+ - lib/duby/old/mapper.rb
91
+ - lib/duby/old/signature.rb
92
+ - lib/duby/old/typer_old.rb
93
+ - lib/duby/plugin/edb.rb
94
+ - lib/duby/plugin/java.rb
95
+ - lib/duby/plugin/math.rb
96
+ - test/test_ast.rb
97
+ - test/test_compilation.rb
98
+ - test/test_java_typer.rb
99
+ - test/test_javac_compiler.rb
100
+ - test/test_jvm_compiler.rb
101
+ - test/test_math_plugin.rb
102
+ - test/test_typer.rb
103
+ - examples/bench_fractal.duby
104
+ - examples/construction.duby
105
+ - examples/edb.duby
106
+ - examples/fib.duby
107
+ - examples/fields.duby
108
+ - examples/java_thing.duby
109
+ - examples/simple_class.duby
110
+ - examples/swing.duby
111
+ - examples/tak.duby
112
+ - examples/appengine/src/com/google/appengine/ext/duby/db/Model.duby
113
+ - examples/appengine/src/com/ribrdb/DubyApp.duby
114
+ - History.txt
115
+ - Manifest.txt
116
+ - README.txt
117
+ - Rakefile
118
+ - javalib/JRubyParser.jar
119
+ has_rdoc: true
120
+ homepage: http://kenai.com/projects/duby
121
+ licenses: []
122
+
123
+ post_install_message:
124
+ rdoc_options:
125
+ - --main
126
+ - README.txt
127
+ require_paths:
128
+ - lib
129
+ required_ruby_version: !ruby/object:Gem::Requirement
130
+ requirements:
131
+ - - ">="
132
+ - !ruby/object:Gem::Version
133
+ version: "0"
134
+ version:
135
+ required_rubygems_version: !ruby/object:Gem::Requirement
136
+ requirements:
137
+ - - ">="
138
+ - !ruby/object:Gem::Version
139
+ version: "0"
140
+ version:
141
+ requirements: []
142
+
143
+ rubyforge_project: duby
144
+ rubygems_version: 1.3.5
145
+ signing_key:
146
+ specification_version: 3
147
+ summary: Duby is a customizable programming language featuring static types, local type inference and a heavily Ruby-inspired syntax
148
+ test_files:
149
+ - test/test_ast.rb
150
+ - test/test_compilation.rb
151
+ - test/test_java_typer.rb
152
+ - test/test_javac_compiler.rb
153
+ - test/test_jvm_compiler.rb
154
+ - test/test_math_plugin.rb
155
+ - test/test_typer.rb