mirah 0.1.3-java → 0.1.4-java

data/examples/ant/README.md

@@ -0,0 +1,8 @@
+Ant support
+=============
+
+mirahc.jar includes a simple ant compile script. `example-build.xml` has an example usage.
+
+Try it out by compiling mirah, then running:
+
+    $ ant -lib ../../dist compile

data/examples/ant/example-build.xml

@@ -1,7 +1,7 @@
 <project name="test">
-  <taskdef name="dubyc" classname="org.mirah.ant.Compile"/>
+  <taskdef name="mirahc" classname="org.mirah.ant.Compile"/>
 
-  <target name="blah">
-    <dubyc src="examples/fib.duby" target="build"/>
+  <target name="compile">
+    <mirahc src="../fib.mirah" target="build"/>
   </target>
 </project>

data/examples/ant/example-build.xml~

@@ -0,0 +1,7 @@
+<project name="test">
+  <taskdef name="dubyc" classname="org.mirah.ant.Compile"/>
+
+  <target name="blah">
+    <dubyc src="examples/fib.duby" target="build"/>
+  </target>
+</project>

data/examples/rosettacode/100-doors.mirah

@@ -47,8 +47,8 @@ end
 
 1.upto(100) do |multiplier|
     index = 0
-    doors.each do |door|
-        Door(door).toggle if (index+1)%multiplier == 0
+    doors.each do |door: Door|
+        door.toggle if (index+1)%multiplier == 0
         index += 1
     end
 end

data/examples/sort_closure.mirah

@@ -18,5 +18,5 @@ import java.util.ArrayList
 
 list = ArrayList.new [9,5,2,6,8,5,0,3,6,1,8,3,6,4,7,5,0,8,5,6,7,2,3]
 puts "unsorted: #{list}"
-Collections.sort(list) {|a,b| Integer(a).compareTo(Integer(b))}
+Collections.sort(list) {|a: Integer, b: Integer| a.compareTo(b)}
 puts "sorted:   #{list}"

data/lib/mirah.rb

@@ -26,8 +26,6 @@ require 'mirah/typer'
 
 require "mirah/util/process_errors"
 require "mirah/util/logging"
-require "mirah/util/class_loader"
-
 
 module Mirah
   java_import 'org.mirah.tool.RunCommand'

data/lib/mirah/version.rb

@@ -14,5 +14,5 @@
 # limitations under the License.
 
 module Mirah
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

data/test/core/util/class_loader_test.rb

@@ -23,7 +23,7 @@ class ClassLoaderTest < Test::Unit::TestCase
 
   def test_mirah_class_loader_find_class_in_map_successful
     class_map = {
-      'org.foo.A' => Mirah::Util.binary_string(File.open(A_CLASS, 'rb') {|f| f.read })
+      'org.foo.A' => File.open(A_CLASS, 'rb') {|f| java.lang.String.new f.read.to_java_bytes, "ISO-8859-1" }
     }
     class_loader = MirahClassLoader.new nil, class_map
     cls = class_loader.load_class 'org.foo.A'

data/test/core/util/{argument_processor_test.rb → mirah_arguments_test.rb}

@@ -1,4 +1,4 @@
-# Copyright (c) 2013 The Mirah project authors. All Rights Reserved.
+# Copyright (c) 2013-2014 The Mirah project authors. All Rights Reserved.
 # All contributing project authors may be found in the NOTICE file.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -14,7 +14,7 @@
 # limitations under the License.
 require 'test_helper'
 
-class ArgumentProcessorTest < Test::Unit::TestCase
+class MirahArgumentsTest < Test::Unit::TestCase
   java_import 'org.mirah.tool.MirahArguments'
   def test_arg_dash_v_prints_version_and_has_exit_0
     arg_processor = MirahArguments.new

data/test/jvm/annotations_test.rb

@@ -54,5 +54,24 @@ class AnnotationsTest < Test::Unit::TestCase
       cls.main nil
     end
   end
+  def test_annotation_from_constant
+    return
+    cls, = compile(<<-EOF)
+      import org.foo.IntAnno
+      class IntValAnnotation
+        Value = 1
+        $IntAnno[name: "bar", value: Value]
+        def bar
+        end
+      end
+      method = IntValAnnotation.class.getMethod("bar")
+      anno = method.getAnnotation(IntAnno.class)
+      puts anno.value
+    EOF
+
+    assert_output "1\n" do
+      cls.main nil
+    end
+  end
 
 end

data/test/jvm/blocks_test.rb

@@ -20,7 +20,7 @@ class BlocksTest < Test::Unit::TestCase
     parse_and_resolve_types name, code
   end
 
-  #this should probably be a core test
+  # this should probably be a core test
   def test_empty_block_parses_and_types_without_error
     assert_nothing_raised do
       parse_and_type(<<-CODE)
@@ -47,7 +47,7 @@ class BlocksTest < Test::Unit::TestCase
 
         class NotEmptyAccepter
           def initialize; end
-          def foo(a:Bar)
+          def foo(a: Bar)
             1
           end
         end
@@ -136,7 +136,7 @@ class BlocksTest < Test::Unit::TestCase
         x.run
       end
       def foo a: int
-        run {a += 1}
+        run { a += 1 }
         a
       end
     EOF
@@ -202,16 +202,11 @@ class BlocksTest < Test::Unit::TestCase
   end
 
   def test_parameter_used_in_block
-    cls, = compile(<<-EOF)
-      def foo(x:String):void
-        thread = Thread.new do
-          puts "Hello \#{x}"
-        end
-        begin
-          thread.run
-          thread.join
-        rescue
-          puts "Uh Oh!"
+    cls, = compile(<<-'EOF')
+      def r(r:Runnable); r.run; end
+      def foo(x: String): void
+        r do
+          puts "Hello #{x}"
         end
       end
 
@@ -239,23 +234,12 @@ class BlocksTest < Test::Unit::TestCase
     end
   end
 
-  def assert_jraise(klass)
-    assert_block("#{klass} expected, but none thrown") do
-      begin
-        yield
-      rescue klass
-        break
-      end
-      false
-    end
-  end
-
   def test_block_impling_interface_w_multiple_methods
    begin
       parse_and_type(<<-CODE)
         interface RunOrRun2 do
           def run:void;end
-          def run2:void;end;
+          def run2:void;end
         end
 
         class RunOrRun2Fooer
@@ -295,7 +279,7 @@ class BlocksTest < Test::Unit::TestCase
   end
 
   def test_block_with_too_many_params
-    assert_raises Mirah::MirahError do
+    exception = assert_raises Mirah::MirahError do
       parse_and_type(<<-CODE)
         interface SingleArgMethod do
           def run(a:String):void;end
@@ -310,10 +294,35 @@ class BlocksTest < Test::Unit::TestCase
           1
         end
         CODE
-      end
+    end
+    assert_equal 'Does not override a method from a supertype.',
+                  exception.message
+  end
+
+  def test_call_with_block_assigned_to_macro
+    #cls, = with_finest_logging{compile(<<-CODE)}
+    cls, = compile(<<-CODE)
+        class S
+          def initialize(run: Runnable)
+            run.run
+          end
+          def toString
+            "1"
+          end
+        end
+        if true
+          a = {}
+          a["wut"]= b = S.new { puts "hey" }
+          puts a
+          puts b
+        end
+      CODE
+    assert_output "hey\n{wut=1}\n1\n" do
+      cls.main(nil)
+    end
   end
 
-  def test_closure_in_closure_doesnt_raise_error
+  def test_nested_closure_in_closure_doesnt_raise_error
     cls, = compile(<<-CODE)
         interface BarRunner do;def run:void;end;end
 
@@ -334,6 +343,32 @@ class BlocksTest < Test::Unit::TestCase
     end
   end
 
+  def test_nested_closure_with_var_from_outer_closure
+    pend "bindings in nested closures are incorrectly generated" do
+      #cls, = with_finest_logging{compile(<<-'CODE')}
+      cls, = compile(<<-'CODE')
+        interface BarRunner do;def run:void;end;end
+
+        class Nestable
+          def foo(a:BarRunner)
+            a.run
+          end
+        end
+        Nestable.new.foo do
+          c = "closure"
+          puts "first #{c}"
+          Nestable.new.foo do
+            puts "second #{c}"
+          end
+        end
+      CODE
+      assert_output "first closure\nsecond closure\n" do
+        cls.main(nil)
+      end
+    end
+  end
+
+
   def test_method_requiring_subclass_of_abstract_class_finds_abstract_method
     cls, = compile(<<-EOF)
       import java.io.OutputStream
@@ -436,7 +471,6 @@ class BlocksTest < Test::Unit::TestCase
   end
 
   def test_when_non_local_return_types_incompatible_has_error
-    pend "nlr doesnt work right now" do
     error = assert_raises Mirah::MirahError do
       parse_and_type(<<-CODE)
       class NonLocalMe
@@ -446,13 +480,15 @@ class BlocksTest < Test::Unit::TestCase
         end
       end
       def nlr: int
-        NonLocalMe.new.foo { return "not an int"}
+        NonLocalMe.new.foo { return "not an int" }
         5678
       end
 
       CODE
     end
-    assert error.message.include? 'int'
+    pend "differing type signatures for nlr" do
+      # could be better, if future knew it was a return type
+      assert_equal "Invalid return type java.lang.String, expected int", error.message
     end
   end
 
@@ -512,7 +548,6 @@ class BlocksTest < Test::Unit::TestCase
       end
       ClosureInVoidMethodInClass.new.nlr
     EOF
-    puts "before running"
     assert_output "before\n" do
       cls.main(nil)
     end
@@ -592,6 +627,56 @@ class BlocksTest < Test::Unit::TestCase
   end
 
 
+  def test_method_returning_init_call_with_closure
+    cls, = compile(<<-EOF)
+      class InitWithRunnable
+        def initialize(a: Runnable)
+          a.run
+        end
+        def finish
+          "finish"
+        end
+      end
+      class Huh
+      def wut(i: InitWithRunnable)
+        puts i.finish
+      end
+      def regular
+        InitWithRunnable.new { puts "Closure!"; nil }
+      end
+    end
+      Huh.new.wut(Huh.new.regular)
+    EOF
+
+    assert_output "Closure!\nfinish\n" do
+      cls.main(nil)
+    end
+  end
+
+
+  def test_closure_with_or
+    cls, = with_finest_logging{compile(<<-EOF)}
+    def r(run: Runnable) run.run; end
+    r { puts "a" || "b"}
+    EOF
+
+    assert_output "a\n" do
+      cls.main(nil)
+    end
+  end
+
+  def test_closure_with_or_ii
+    cls, = with_finest_logging{compile(<<-EOF)}
+    interface C; def c(): String;end;end
+    def r(cee: C) puts cee.c; end
+    r { "a" || "b"}
+    EOF
+
+    assert_output "a\n" do
+      cls.main(nil)
+    end
+  end
+
   def test_two_closures_in_the_same_method
     cls, = compile(<<-EOF)
       def foo(a: Runnable)
@@ -609,6 +694,87 @@ class BlocksTest < Test::Unit::TestCase
     end
   end
 
+  def test_closures_in_a_rescue
+    cls, = compile(<<-EOF)
+      def foo(a: Runnable)
+        a.run
+      end
+      def regular: String
+        begin
+          foo { puts "Closure!" }
+          raise "wut"
+        rescue
+          foo { puts "We Want it" }
+        end
+        "finish"
+      end
+      regular
+    EOF
+    assert_output "Closure!\nWe Want it\n" do
+      cls.main(nil)
+    end
+  end
+
+  def test_lambda_with_type_defined_before
+    cls, = compile(<<-EOF)
+      interface Fooable
+        def foo: void; end
+      end
+      x = lambda(Fooable) { puts "hey you" }
+      x.foo
+    EOF
+    assert_output "hey you\n" do
+      cls.main(nil)
+    end
+  end
+
+  def test_lambda_with_type_defined_later
+    pend "I think it'd be nice if this worked" do
+      cls, = compile(<<-EOF)
+        x = lambda(Fooable) { puts "hey you" }
+        interface Fooable
+          def foo: void; end
+        end
+        x.foo
+      EOF
+      assert_output "hey you\n" do
+        cls.main(nil)
+      end
+    end
+  end
+
+  def test_closure_with_primitive_array_param
+    cls, = compile(<<-EOF)
+      interface Byter
+        def byteme(bytes: byte[]): void; end
+      end
+      def r b: Byter
+        b.byteme "yay".getBytes
+      end
+      r {|b| puts String.new(b) }
+    EOF
+    assert_output "yay\n" do
+      cls.main(nil)
+    end
+  end
+
+
+  def test_lambda_closure
+    pend "not working yet" do
+      cls, = compile(<<-EOF)
+        def r b: Runnable
+          b.run
+        end
+        msg = "yay"
+        l = lambda(Runnable) { puts msg }
+        r l
+      EOF
+      assert_output "yay\n" do
+        cls.main(nil)
+      end
+    end
+  end
+
   # nested nlr scopes
 
 # works with script as end

data/test/jvm/import_test.rb

@@ -62,7 +62,9 @@ class ImportTest < Test::Unit::TestCase
     list = cls.list(o)
     assert_kind_of(Java::JavaUtil::List, list)
     assert_equal(["1", "2", "3"], list.to_a)
+  end
 
+  def test_static_import_nested_in_class
     cls, = compile(<<-EOF)
       import java.util.Arrays
       class StaticImports
@@ -73,6 +75,7 @@ class ImportTest < Test::Unit::TestCase
       end
     EOF
 
+    o = ["1", "2", "3"].to_java(:object)
     list = cls.new.list(o)
     assert_kind_of(Java::JavaUtil::List, list)
     assert_equal(["1", "2", "3"], list.to_a)