mirah 0.0.10-java → 0.0.11-java

data/lib/mirah/parser.rb

@@ -46,7 +46,7 @@ module Mirah
         end
       end
       raise 'nothing to parse? ' + files_or_scripts.inspect unless nodes.length > 0
-      nodes
+      nodes.compact
     end
     
     def parse_inline(source)
@@ -60,12 +60,8 @@ module Mirah
     end
     
     def parse_and_transform(filename, src)
-      parser_ast = Mirah::AST.parse_ruby(src, filename)
-      
-      transformer.filename = filename
-      mirah_ast = transformer.transform(parser_ast, nil)
+      mirah_ast = AST.parse src, filename, false, transformer
       process_errors(transformer.errors)
-      
       mirah_ast
     end
       

data/lib/mirah/transform/transformer.rb

@@ -76,6 +76,8 @@ module Mirah
         begin
           top = @extra_body.nil?
           if top
+            return nil if !node.children.empty? && node.children.all?(&:nil?)
+            
             @extra_body = Mirah::AST::Body.new(nil, position(node))
           end
           method = "transform_#{camelize(node[0])}"

data/lib/mirah/util/argument_processor.rb

@@ -21,7 +21,9 @@ module Mirah
         @args = args
       end
 
-      attr_accessor :state, :args
+      attr_accessor :state, :args, :exit_status_code
+
+      alias exit? exit_status_code
 
       def process
         state.args = args
@@ -29,7 +31,10 @@ module Mirah
           case args[0]
           when '--classpath', '-c'
             args.shift
-            Mirah::Env.decode_paths(args.shift, $CLASSPATH)
+            state.classpath = args.shift
+          when '--bootclasspath'
+            args.shift
+            state.bootclasspath = args.shift
           when '--cd'
             args.shift
             Dir.chdir(args.shift)
@@ -42,17 +47,21 @@ module Mirah
             args.shift
             Mirah::AST::Script.explicit_packages = true
           when '--help', '-h'
+            args.shift
             print_help
-            throw :exit
+            
+            self.exit_status_code = 0
+            break
           when '--java', '-j'
             if state.command == :compile
               require 'mirah/jvm/compiler/java_source'
               state.compiler_class = Mirah::JVM::Compiler::JavaSource
               args.shift
             else
-              puts "-j/--java flag only applies to \"compile\" mode."
-              print_help
-              throw :exit, 1
+              $stderr.puts "-j/--java flag only applies to \"compile\" mode."
+
+              self.exit_status_code = 1
+              break
             end
           when '--jvm'
             args.shift
@@ -73,22 +82,35 @@ module Mirah
           when '--version', '-v'
             args.shift
             print_version
+            
+            self.exit_status_code = 0 if args.empty?
+            break
           when '--no-save-extensions'
             args.shift
             state.save_extensions = false
           else
-            puts "unrecognized flag: " + args[0]
-            print_help
-            throw :exit, 1
+            $stderr.puts "unrecognized flag: " + args[0]
+            
+            self.exit_status_code = 1
+            break
           end
         end
+        
+        return if exit?
+        
         state.destination ||= File.join(File.expand_path('.'), '')
         state.compiler_class ||= Mirah::JVM::Compiler::JVMBytecode
       end
 
       def print_help
-        puts "#{$0} [flags] <files or -e SCRIPT>
+        puts help_message
+        state.help_printed = true
+      end
+
+      def help_message
+        "#{$0} [flags] <files or -e SCRIPT>
         -c, --classpath PATH\tAdd PATH to the Java classpath for compilation
+        --bootclasspath PATH\tSet the Java bootclasspath to PATH for compilation
         --cd DIR\t\tSwitch to the specified DIR befor compilation
         -d, --dir DIR\t\tUse DIR as the base dir for compilation, packages
         -e CODE\t\tCompile or run the inline script following -e
@@ -102,7 +124,6 @@ module Mirah
         -p, --plugin PLUGIN\trequire 'mirah/plugin/PLUGIN' before running
         -v, --version\t\tPrint the version of Mirah to the console
         -V, --verbose\t\tVerbose logging"
-        state.help_printed = true
       end
 
       def print_version
@@ -111,4 +132,4 @@ module Mirah
       end
     end
   end
-end
+end

data/lib/mirah/util/class_loader.rb

@@ -2,8 +2,13 @@ module Mirah
   module Util
     
     ClassLoader = Java::OrgMirah::MirahClassLoader
+
+    # converts string to a java string w/ binary encoding
+    # might be able to avoid this in 1.9 mode
     def ClassLoader.binary_string string
         java.lang.String.new string.to_java_bytes, "ISO-8859-1"
-    end    
+    end
+
+    IsolatedResourceLoader = Java::OrgMirah::IsolatedResourceLoader
   end
-end
+end

data/lib/mirah/util/compilation_state.rb

@@ -32,6 +32,14 @@ module Mirah
       attr_accessor :args
       attr_accessor :command
 
+      def classpath=(classpath)
+        Mirah::AST.type_factory.classpath = classpath
+      end
+
+      def bootclasspath=(classpath)
+        Mirah::AST.type_factory.bootclasspath = classpath
+      end
+
       def set_jvm_version(ver_str)
         case ver_str
         when '1.4'

data/lib/mirah/version.rb

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

data/lib/mirah/version.rb~

@@ -0,0 +1,18 @@
+# Copyright (c) 2010 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");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Mirah
+  VERSION = "0.0.9"
+end

data/test/core/{test_ast.rb → ast_test.rb}

@@ -14,7 +14,7 @@
 # limitations under the License.
 require 'test_helper'
 
-class TestAst < Test::Unit::TestCase
+class AstTest < Test::Unit::TestCase
   include Mirah
 
   def test_args
@@ -375,4 +375,8 @@ class TestAst < Test::Unit::TestCase
       AST.parse("puts( 'aoue'")
     end
   end
+  
+  def test_parsing_empty_string_raises_no_error
+    AST.parse("")
+  end
 end

data/test/core/{test_commands.rb → commands_test.rb}

@@ -15,7 +15,7 @@
 require 'test_helper'
 
 
-class TestCommands < Test::Unit::TestCase
+class CommandsTest < Test::Unit::TestCase
   def teardown
     Mirah::AST.type_factory = nil
   end
@@ -54,6 +54,12 @@ class TestCommands < Test::Unit::TestCase
     end
   end
   
+  def test_on_v_with_no_args_exits_without_running_command
+    assert_zero_exit do
+      RaisesMirahErrorCommand.new(['-v']).execute
+    end
+  end
+    
   def test_on_j_option_when_command_is_not_compile_has_non_zero_exit_code
     assert_non_zero_exit do
       RaisesMirahErrorCommand.new(['-j']).execute
@@ -70,6 +76,20 @@ class TestCommands < Test::Unit::TestCase
     end
   end
 
+  def test_run_says_no_main_and_exits_with_non_zero_with_no_main
+    cmd = Mirah::Commands::Run.new([])
+
+    #stub class generation, loading, return nil main
+    def cmd.load_classes_and_find_main *args;nil;end
+    def cmd.generate_class_map;end
+
+    assert_non_zero_exit do
+      assert_output "No main found\n" do
+        cmd.execute
+      end
+    end
+  end
+
   def assert_non_zero_exit
     ex = assert_raise SystemExit do
       yield
@@ -77,4 +97,11 @@ class TestCommands < Test::Unit::TestCase
     assert_not_equal 0, ex.status
   end
 
-end
+  def assert_zero_exit
+    ex = assert_raise SystemExit do
+      yield
+    end
+    assert_equal 0, ex.status
+  end
+
+end

data/test/core/{test_compilation.rb → compilation_test.rb}

@@ -14,7 +14,7 @@
 # limitations under the License.
 require 'test_helper'
 
-class TestCompilation < Test::Unit::TestCase
+class CompilationTest < Test::Unit::TestCase
   include Mirah
 
   class MockCompiler
@@ -127,4 +127,4 @@ class TestCompilation < Test::Unit::TestCase
 
     assert_equal([:array, a(Mirah::AST::Array), true], @compiler.calls.first)
   end
-end
+end

data/test/core/{test_env.rb → env_test.rb}

@@ -14,7 +14,7 @@
 # limitations under the License.
 require 'test_helper'
 
-class TestEnv < Test::Unit::TestCase
+class EnvTest < Test::Unit::TestCase
   include Mirah
 
   def test_use_file_path_separator
@@ -51,4 +51,4 @@ class TestEnv < Test::Unit::TestCase
     assert_equal(['a'], Mirah::Env.decode_paths('a'))
   end
   
-end
+end

data/test/core/{test_macros.rb → macros_test.rb}

@@ -15,7 +15,7 @@
 # TODO refactor this and test_jvm_compiler to use mirah.rb
 require 'test_helper'
 
-class TestMacros < Test::Unit::TestCase
+class MacrosTest < Test::Unit::TestCase
   java_import 'java.lang.System'
 
   def parse(code)
@@ -58,4 +58,4 @@ class TestMacros < Test::Unit::TestCase
     EOF
   end
 
-end
+end

data/test/core/{test_typer.rb → typer_test.rb}

@@ -14,7 +14,7 @@
 # limitations under the License.
 require 'test_helper'
 
-class TestTyper < Test::Unit::TestCase
+class TyperTest < Test::Unit::TestCase
   include Mirah
 
   def test_fixnum

data/test/core/util/argument_processor_test.rb

@@ -0,0 +1,64 @@
+require 'test_helper'
+
+class ArgumentProcessorTest < Test::Unit::TestCase
+
+  def test_arg_dash_v_prints_version_and_has_exit_0
+    state = Mirah::Util::CompilationState.new
+    processor = Mirah::Util::ArgumentProcessor.new state, ["-v"]
+
+    assert_output "Mirah v#{Mirah::VERSION}\n" do
+      processor.process
+    end
+
+    assert processor.exit?
+    assert_equal 0, processor.exit_status_code
+  end
+
+
+  def test_on_invalid_arg_prints_error_and_exits_1
+    state = Mirah::Util::CompilationState.new
+    processor = Mirah::Util::ArgumentProcessor.new state, ["--some-arg"]
+
+    assert_output "unrecognized flag: --some-arg\n" do
+      processor.process
+    end
+
+    assert processor.exit?
+    assert_equal 1, processor.exit_status_code
+  end
+
+  def test_arg_bootclasspath_sets_bootclasspath_on_type_factory_ugh
+    Mirah::AST.type_factory = Mirah::JVM::Types::TypeFactory.new # global state grumble grumble
+
+    path = "class:path"
+    state = Mirah::Util::CompilationState.new
+    processor = Mirah::Util::ArgumentProcessor.new state, ["--bootclasspath", path]
+    processor.process
+
+    assert_equal path, Mirah::AST.type_factory.bootclasspath
+  end
+
+  def test_dash_j_fails_when_not_compiling
+    state = Mirah::Util::CompilationState.new
+    processor = Mirah::Util::ArgumentProcessor.new state, ["-j"]
+
+    assert_output "-j/--java flag only applies to \"compile\" mode.\n" do
+      processor.process
+    end
+
+    assert processor.exit?
+    assert_equal 1, processor.exit_status_code
+  end
+
+  def test_dash_h_prints_help_and_exits
+    state = Mirah::Util::CompilationState.new
+    processor = Mirah::Util::ArgumentProcessor.new state, ["-h"]
+
+    assert_output processor.help_message + "\n" do
+      processor.process
+    end
+
+    assert processor.exit?
+    assert_equal 0, processor.exit_status_code
+  end
+end

data/test/core/util/class_loader_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+class ClassLoaderTest < Test::Unit::TestCase
+  FIXTURES = File.expand_path("#{__FILE__}/../../../fixtures/") +"/"
+  A_CLASS = "#{FIXTURES}org/foo/A.class"
+
+  def test_mirah_class_loader_find_class_in_map_successful
+    class_map = {
+      'org.foo.A' => Mirah::Util::ClassLoader.binary_string(File.open(A_CLASS, 'rb') {|f| f.read })
+    }
+    class_loader = Mirah::Util::ClassLoader.new nil, class_map
+    cls = class_loader.load_class 'org.foo.A'
+    assert_equal 'org.foo.A', cls.name
+  end
+
+  def test_mirah_class_loader_w_missing_class_raises_class_not_found
+    class_loader = Mirah::Util::ClassLoader.new nil, {}
+
+    ex = assert_raise NativeException do
+      class_loader.find_class 'org.doesnt.exist.Class'
+    end
+    assert_equal java.lang.ClassNotFoundException, ex.cause.class
+  end
+  
+  
+  def test_isolated_resource_loader_only_finds_resources_given_to_it
+    loader = Mirah::Util::IsolatedResourceLoader.new [java.net.URL.new("file:#{FIXTURES}")]
+    url = loader.get_resource "my.properties"
+    assert_not_nil url
+  end
+end

data/test/jvm/{test_annotations.rb → annotations_test.rb}

@@ -1,4 +1,4 @@
-class TestAnnotations < Test::Unit::TestCase
+class AnnotationsTest < Test::Unit::TestCase
   def deprecated
     @deprecated ||= java.lang.Deprecated.java_class
   end
@@ -55,4 +55,4 @@ class TestAnnotations < Test::Unit::TestCase
     assert_equal 1, method_annotation.optional
   end
 
-end
+end

data/test/jvm/blocks_test.rb

@@ -0,0 +1,262 @@
+# Copyright (c) 2010 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");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class BlocksTest < Test::Unit::TestCase
+
+  def setup
+    super
+    clear_tmp_files
+    reset_type_factory
+  end
+  
+  def parse_and_type code, name=tmp_script_name
+    parse_and_resolve_types name, code
+  end
+  
+  #this should probably be a core test
+  def test_empty_block_parses_and_types_without_error
+    assert_nothing_raised do
+      parse_and_type(<<-CODE)
+        interface Bar do;def run:void;end;end
+      
+        class Foo
+          def foo(a:Bar)
+            1
+          end
+        end
+        Foo.new.foo do
+        end
+      CODE
+    end
+  end
+  
+  def test_non_empty_block_parses_and_types_without_error
+    assert_nothing_raised do
+      parse_and_type(<<-CODE)
+        interface Bar do;def run:void;end;end
+      
+        class Foo
+          def foo(a:Bar)
+            1
+          end
+        end
+        Foo.new.foo do
+          1
+        end
+      CODE
+    end
+  end
+
+
+  def test_block_impling_interface_w_multiple_methods
+    assert_raises Mirah::NodeError do
+      parse_and_type(<<-CODE)
+        interface Bar do
+          def run:void;end
+          def run2:void;end;
+        end
+        
+        class Foo
+          def foo(a:Bar)
+            1
+          end
+        end
+        Foo.new.foo do
+          1
+        end
+        CODE
+    end
+  end
+
+  def test_block_with_no_params_on_interface_with
+    assert_raises Mirah::NodeError do
+      parse_and_type(<<-CODE)
+        interface Bar do
+          def run(a:string):void;end
+        end
+        
+        class Foo
+          def foo(a:Bar)
+            1
+          end
+        end
+        Foo.new.foo do
+          1
+        end
+        CODE
+      end
+  end
+
+  def test_block_with_too_many_params
+    assert_raises Mirah::NodeError do
+      parse_and_type(<<-CODE)
+        interface Bar do
+          def run(a:string):void;end
+        end
+        
+        class Foo
+          def foo(a:Bar)
+            1
+          end
+        end
+        Foo.new.foo do |a, b|
+          1
+        end
+        CODE
+      end
+  end
+
+  def test_block
+    cls, = compile(<<-EOF)
+      thread = Thread.new do
+        puts "Hello"
+      end
+      begin
+        thread.run
+        thread.join
+      rescue
+        puts "Uh Oh!"
+      end
+    EOF
+    assert_output("Hello\n") do
+      cls.main([].to_java :string)
+    end
+
+    script, cls = compile(<<-EOF)
+      import java.util.Observable
+      class MyObservable < Observable
+        def initialize
+          super
+          setChanged
+        end
+      end
+
+      o = MyObservable.new
+      o.addObserver {|x, a| puts a}
+      o.notifyObservers("Hello Observer")
+    EOF
+    assert_output("Hello Observer\n") do
+      script.main([].to_java :string)
+    end
+
+    cls, = compile(<<-EOF)
+      def foo
+        a = "Hello"
+        thread = Thread.new do
+          puts a
+        end
+        begin
+          a = a + " Closures"
+          thread.run
+          thread.join
+        rescue
+          puts "Uh Oh!"
+        end
+        return
+      end
+    EOF
+    assert_output("Hello Closures\n") do
+      cls.foo
+    end
+
+    cls, = compile(<<-EOF)
+      def run(x:Runnable)
+        x.run
+      end
+      def foo
+        a = 1
+        run {a += 1}
+        a
+      end
+    EOF
+    assert_equal(2, cls.foo)
+  end
+
+  def test_block_with_method_def
+    cls, = compile(<<-EOF)
+      import java.util.ArrayList
+      import java.util.Collections
+      list = ArrayList.new(["a", "ABC", "Cats", "b"])
+      Collections.sort(list) do
+        def equals(a:Object, b:Object)
+          String(a).equalsIgnoreCase(String(b))
+        end
+        def compare(a:Object, b:Object)
+          String(a).compareToIgnoreCase(String(b))
+        end
+      end
+      list.each {|x| puts x}
+    EOF
+
+    assert_output("a\nABC\nb\nCats\n") do
+      cls.main(nil)
+    end
+  end
+
+  def test_block_with_abstract_from_object
+    # Comparator interface also defines equals(Object) as abstract,
+    # but it can be inherited from Object. We test that here.
+    cls, = compile(<<-EOF)
+      import java.util.ArrayList
+      import java.util.Collections
+      list = ArrayList.new(["a", "ABC", "Cats", "b"])
+      Collections.sort(list) do |a, b|
+        String(a).compareToIgnoreCase(String(b))
+      end
+      list.each {|x| puts x}
+    EOF
+
+    assert_output("a\nABC\nb\nCats\n") do
+      cls.main(nil)
+    end
+  end
+  
+  def test_block_with_no_arguments_and_return_value
+    cls, = compile(<<-EOF)
+      import java.util.concurrent.Callable
+      def foo c:Callable
+        throws Exception
+         puts c.call
+      end
+      begin
+      foo do
+        "an object"
+      end
+      rescue
+        puts "never get here"
+      end
+    EOF
+    assert_output("an object\n") do
+      cls.main(nil)
+    end
+  end
+
+  def test_closure_in_closure_doesnt_raise_error
+    parse_and_type(<<-CODE)
+        interface Bar do;def run:void;end;end
+      
+        class Foo
+          def foo(a:Bar)
+            1
+          end
+        end
+        Foo.new.foo do
+          Foo.new.foo do
+            1
+          end
+        end
+      CODE
+  end
+end