irpack 0.2.4 → 0.2.5

data/README.rdoc

@@ -0,0 +1,193 @@
+=irpack
+
+irpack converts your IronRuby scripts to a standalone .exe file.
+Generated executable does not require IronRuby, but only .NET Framework or mono.
+
+==Requirements
+IronRuby 1.1.3 or later.
+
+==Installation
+
+  $ igem install irpack
+
+You need to use igem (gem command for IronRuby) instead of gem.
+
+==Usage
+  $ irpack [options] ENTRYFILE [EMBEDFILES...]
+    -b BASEDIR               Specify base directory. [base of ENTRYFILE]
+    -o OUTPUTFILE            Specify output file name.
+        --window             Generate window app.
+        --console            Generate console app.[default]
+        --compress           Compress package.
+        --complete           Embed all standard libraries.
+        --no-embed           Do not embed IronRuby assemblies.
+  Runtime options:
+    -Idirectory              specify $LOAD_PATH directory (may be used more than once)
+    -rlibrary                require the library, before executing your script
+    -d                       set debugging flags (set $DEBUG to true)
+    -D                       emit debugging information (PDBs) for Visual Studio debugger
+    -v                       print version number, then turn on verbose mode
+    -w                       turn warnings on for your script
+    -W[level]                set warning level; 0=silence, 1=medium (default), 2=verbose
+        --trace              enable support for set_trace_func
+        --profile            enable support for 'pi = IronRuby::Clr.profile { block_to_profile }'
+        --exception-detail   enable ExceptionDetail mode
+        --no-adaptive-compilation
+                             disable adaptive compilation - all code will be compiled
+        --compilation-threshold THRESHOLD
+                             the number of iterations before the interpreter starts compiling
+        --pass-exceptions    do not catch exceptions that are unhandled by script code
+        --private-binding    enable binding to private members
+        --show-clr-exceptions
+                             display CLS Exception information
+
+Specify rb file on ENTRYFILE to generate exe. Executables includes ENTRYFILE and
+IronRuby dlls in their resource.
+
+When runtime, script can open EMBEDFILES with relative path from BASEDIR.
+
+for example:
+  $ irpack -o hoge/fuga.exe -d foo bar/entry.rb foo/hello.rb
+
+hoge/fuga.exe runs embedded bar/entry.rb.
+To load foo/hello.rb, require 'hello' (relative path from BASEDIR 'foo').
+A real file is used if hello.rb exists in both embedded and real filesystem in
+same directory as executable.
+
+To specify exe icon, embed ico file.
+
+To generate application which has no console window use '--window' option.
+
+'--no-embed' option exclude IronRuby dlls from embedded files. A generated
+executable requires IronRuby dlls.
+
+If scripts use any standard libraries, embed them too. '--complete' embeds
+all of standard libraries into exe.
+
+Executable file is compacted by '--compress' option that compresses embedded
+files. To load compressed file costs extra time.
+
+Runtime options are passed to script engine when generated executable started
+as well as ir.exe.
+
+==Limitations
+Embedded native dlls and mixed (C++/CLI) assemblies are not loadable.
+
+=irpack
+
+irpackはIronRubyのスクリプトを単体で動く.exeファイルに変換するアプリケーションで
+す。生成した実行ファイルは.NET FrameworkやmonoさえあればIronRubyをインストールし
+ていない環境でも動かすことができます。
+
+==動作環境
+IronRuby 1.1.3以降。
+
+==インストール
+
+  $ igem install irpack
+
+IronRubyでしか動かないのでigem (IronRubyのgemコマンド)を使ってインストールしてく
+ださい。
+
+==使い方
+
+  $ irpack [options] ENTRYFILE [EMBEDFILES...]
+    -b BASEDIR               埋め込み基準のディレクトリを指定します。[ENTRYFILEのあるディレクトリ]
+    -o OUTPUTFILE            出力ファイル名を指定します。[ENTRYFILEの拡張子を.exeにしたもの]
+        --window             ウィンドウアプリを生成します。
+        --console            コンソールアプリを生成します。[default]
+        --compress           パッケージの圧縮をします。
+        --complete           全ての標準ライブラリを埋め込みます。
+        --no-embed           IronRubyの埋め込みを行いません。
+  実行時オプション:
+    -Idirectory              $LOAD_PATHディレクトリを指定します。(複数回指定できます。)
+    -rlibrary                スクリプト実行前にlibraryを読み込みます。
+    -d                       デバッグフラグを設定します。($DEBUGをtrueに設定します。)
+    -D                       Visual Studioデバッガ用にデバッグ情報(PDB)を生成します。
+    -v                       バージョン番号を出力し、冗長モードを有効にします。
+    -w                       スクリプトの警告を有効します。
+    -W[level]                警告レベルを設定します: 0=無し, 1=普通(デフォルト), 2=冗長
+        --trace              set_trace_funcサポートを有効にします。
+        --profile            CLRプロファイラを有効にします。次のように使います
+                             'pi = IronRuby::Clr.profile { block_to_profile }'
+        --exception-detail   例外詳細モードを有効にします。
+        --no-adaptive-compilation
+                             適応型コンパイルを無効にします。全てのコードがコンパイルされます。
+        --compilation-threshold THRESHOLD
+                             インタプリタがコンパイル開始するまでの繰り返し回数を指定します。
+        --pass-exceptions    スクリプトで処理されなかった例外をcatchしないようにします。
+        --private-binding    privateメンバへのバインディングを有効にします。
+        --show-clr-exceptions
+                             CLS例外情報を表示します。
+
+ENTRYFILEに起動するrbファイルを指定するとexeファイルが生成されます。exeファイル
+にはENTRYFILEとIronRubyのdllが埋め込まれるので.NET Frameworkやmonoが入っている環
+境でIronRubyのインストール無しに実行することができます。
+
+ENTRYFILEに続けてファイルを指定することによって他のファイルもexeに埋め込むことが
+できます。
+
+埋め込まれたファイルはスクリプト中からは「実行ファイルのディレクトリ/基準ディレク
+トリからの相対パス」に存在するように見えます。
+たとえば、
+
+  $ irpack -o hoge/fuga.exe -d foo bar/entry.rb foo/hello.rb
+
+としたときにfuga.exeの実行中(bar/entry.rb)からはfoo/hello.rbはhoge/hello.rb
+(fuga.exeのあるディレクトリhoge)にあるように見えます。
+もしhoge/hello.rbが本当にファイルとして存在した場合はそちらが優先して開かれます。
+
+EMBEDFILESにアイコン(.ico)ファイルを指定するとexeのアイコンとして使用します。
+
+'--console'や'--window'オプションでコンソールアプリを生成するかウィンドウアプリを
+生成するか指定できます。省略時はコンソールアプリになります。ウィンドウアプリの場
+合はコンソールウィンドウが開かなくなりますが、標準入出力は使用できません。また例
+外が捕捉されずに落ちた場合のメッセージは標準エラー出力に出るようになっていますが、
+ウィンドウアプリの場合はそれも表示されません。
+
+'--no-embed'オプションを指定するとIronRuby.dllなどをexeに埋め込みません。配布する
+場合は実行環境にIronRubyがインストールするかIronRuby.dllなどの必要なdllを同じディ
+レクトリに置いて実行してください。
+
+標準ライブラリを使用する場合は、使用するライブラリも埋め込まなければいけません。
+'--complete'オプションを指定すると標準ライブラリを全て埋め込みます。実行ファイル
+サイズはその分大きくなります。
+
+'--compress'オプションは埋め込んだファイルを圧縮します。実行ファイルのサイズが小さ
+くなりますが、読み込みに時間がかかるようになります。
+
+実行時オプションは生成した実行ファイルの起動時にスクリプトエンジンに渡されます。
+ir.exeに指定するのと同じものです。
+
+==制限
+C++/CLIの混合アセンブリやネイティブdllは埋め込めません。
+
+生成したexeは生成に使用したIronRubyと同じバージョンの.NET Frameworkかそれに対応
+するmonoが必要です。
+.NET Framework 4のir.exeを使って生成したexeを実行するには.NET Framework4か
+mono 2.8以降が必要ということです。
+
+==License
+zlib/libpng License.
+
+    Copyright (c) 2010-2011 Ryuichi Sakamoto.
+
+    This software is provided 'as-is', without any express or implied
+    warranty. In no event will the authors be held liable for any damages
+    arising from the use of this software.
+
+    Permission is granted to anyone to use this software for any purpose,
+    including commercial applications, and to alter it and redistribute it
+    freely, subject to the following restrictions:
+
+        1. The origin of this software must not be misrepresented; you must not
+        claim that you wrote the original software. If you use this software
+        in a product, an acknowledgment in the product documentation would be
+        appreciated but is not required.
+
+        2. Altered source versions must be plainly marked as such, and must not be
+        misrepresented as being the original software.
+
+        3. This notice may not be removed or altered from any source
+        distribution.
+

data/lib/irpack.rb

@@ -33,6 +33,7 @@ module IRPack
     Microsoft.Dynamic
     Microsoft.Scripting
     Microsoft.Scripting.Core
+    Microsoft.Scripting.Metadata
     IronRuby
     IronRuby.Libraries
     IronRuby.Libraries.Yaml
@@ -77,14 +78,29 @@ module IRPack
     res
   end
 
-  def pack(output_file, files, entry_file, opts={})
+  def pack(output_file, files, entry_file, opts={}, runtime_options={})
     opts = {
-      :target           => :exe,
-      :compress         => false,
-      :complete         => false,
-      :embed_references => true,
-      :module_name      => path_to_module_name(output_file)
+      target:           :exe,
+      compress:         false,
+      complete:         false,
+      embed_references: true,
+      seach_paths:      [],
+      module_name:      path_to_module_name(output_file),
     }.update(opts)
+    runtime_options = {
+      DebugMode:             false,
+      PrivateBinding:        false,
+      NoAdaptiveCompilation: false,
+      CompilationThreshold:  -1,
+      ExceptionDetail:       false,
+      ShowClrExceptions:     false,
+      Profile:               false,
+      Verbosity:             1,
+      DebugVariable:         false,
+      EnableTracing:         false,
+      RequiredPaths:         [],
+      SearchPaths:           [],
+    }.update(runtime_options)
     output_file = File.expand_path(output_file)
     basename    = File.basename(output_file, '.*')
     module_name = opts[:module_name]
@@ -101,7 +117,7 @@ module IRPack
 
     Dir.mktmpdir(File.basename($0,'.*')) do |tmp_path|
       entry_dll = File.join(tmp_path, module_name+'.EntryPoint.dll')
-      EntryPoint.compile(entry_dll, module_name, entry_file, references)
+      EntryPoint.compile(entry_dll, module_name, entry_file, references, runtime_options)
       pack_files[entry_dll] = File.basename(entry_dll)
 
       package_file = File.join(tmp_path, basename+'.pkg')

data/lib/irpack/application.rb

@@ -33,6 +33,7 @@ module IRPack
       :compress,
       :complete,
       :embed_references,
+      :runtime_options,
       :entry_file,
       :files) do
       def self.parse!(argv)
@@ -45,7 +46,21 @@ module IRPack
         args.embed_references = true
         args.entry_file  = nil
         args.files = {}
-        opt = OptionParser.new
+        args.runtime_options = {
+          DebugMode:             false,
+          PrivateBinding:        false,
+          NoAdaptiveCompilation: false,
+          CompilationThreshold:  -1,
+          ExceptionDetail:       false,
+          ShowClrExceptions:     false,
+          Profile:               false,
+          Verbosity:             1,
+          DebugVariable:         false,
+          EnableTracing:         false,
+          RequiredPaths:         [],
+          SearchPaths:           [],
+        }
+        opt = OptionParser.new("Usage: #{$0} [options] ENTRYFILE [EMBEDFILES...]", 24, '  ')
         opt.on('-b BASEDIR',    'Specify base directory. [base of ENTRYFILE]') {|v| basedir = v }
         opt.on('-o OUTPUTFILE', 'Specify output file name.') {|v| args.output_file = v }
         opt.on('--window',      'Generate window app.') { args.target = :winexe }
@@ -53,7 +68,52 @@ module IRPack
         opt.on('--compress',    'Compress package.') { args.compress = true }
         opt.on('--complete',    'Embed all standard libraries.') { args.complete = true }
         opt.on('--no-embed',    'Do not embed IronRuby assemblies.') {|v| args.embed_references = v }
-        opt.banner = "Usage: #{$0} [options] ENTRYFILE [EMBEDFILES...]"
+        opt.separator('Runtime options:')
+        opt.on('-Idirectory', 'specify $LOAD_PATH directory (may be used more than once)') {|v|
+          args.runtime_options[:SearchPaths] << v
+        }
+        opt.on('-rlibrary', 'require the library, before executing your script') {|v|
+          args.runtime_options[:RequiredPaths] << v
+        }
+        opt.on('-d', 'set debugging flags (set $DEBUG to true)') {|v|
+          args.runtime_options[:DebugVariable] = v
+        }
+        opt.on('-D', 'emit debugging information (PDBs) for Visual Studio debugger') {|v|
+          args.runtime_options[:DebugMode] = v
+        }
+        opt.on('-v', 'print version number, then turn on verbose mode') {|v|
+          args.runtime_options[:Verbosity] = 2
+        }
+        opt.on('-w', 'turn warnings on for your script') {|v|
+          args.runtime_options[:Verbosity] = 2
+        }
+        opt.on('-W[level]', 'set warning level; 0=silence, 1=medium (default), 2=verbose', Integer) {|v|
+          args.runtime_options[:Verbosity] = (v || 2).to_i
+        }
+        opt.on('--trace', 'enable support for set_trace_func') {|v|
+          args.runtime_options[:EnableTracing] = v
+        }
+        opt.on('--profile', "enable support for 'pi = IronRuby::Clr.profile { block_to_profile }'") {|v|
+          args.runtime_options[:Profile] = v
+        }
+        opt.on('--exception-detail', 'enable ExceptionDetail mode') {|v|
+          args.runtime_options[:ExceptionDetail] = v
+        }
+        opt.on('--no-adaptive-compilation', 'disable adaptive compilation - all code will be compiled') {|v|
+          args.runtime_options[:NoAdaptiveCompilation] = true
+        }
+        opt.on('--compilation-threshold THRESHOLD', 'the number of iterations before the interpreter starts compiling', Integer) {|v|
+          args.runtime_options[:CompilationThreshold] = v.to_i
+        }
+        opt.on('--pass-exceptions', 'do not catch exceptions that are unhandled by script code') {|v|
+          args.runtime_options[:PassExceptions] = v
+        }
+        opt.on('--private-binding', 'enable binding to private members') {|v|
+          args.runtime_options[:PrivateBinding] = v
+        }
+        opt.on('--show-clr-exceptions', 'display CLS Exception information') {|v|
+          args.runtime_options[:ShowClrExceptions] = v
+        }
         opt.parse!(argv)
 
         if argv.size<1 then
@@ -80,10 +140,13 @@ module IRPack
         args.output_file,
         args.files,
         args.entry_file,
-        :target => args.target,
-        :compress => args.compress,
-        :complete => args.complete,
-        :embed_references => args.embed_references)
+        {
+          target:   args.target,
+          compress: args.compress,
+          complete: args.complete,
+          embed_references: args.embed_references,
+        },
+        args.runtime_options)
       return 0
     end
   end

data/lib/irpack/entrypoint.rb

@@ -176,19 +176,46 @@ module IRPack
           var entry_file = Path.Combine(entry_path, "<%= entry_file %>");
           var runtime_setup = new ScriptRuntimeSetup();
           runtime_setup.LanguageSetups.Add(IronRuby.Ruby.CreateRubySetup());
-          runtime_setup.Options["MainFile"]  = entry_file;
-          runtime_setup.Options["Arguments"] = args;
+          runtime_setup.DebugMode      = <%= options[:DebugMode] %>; 
+          runtime_setup.PrivateBinding = <%= options[:PrivateBinding] %>; 
+          runtime_setup.Options["NoAdaptiveCompilation"] = <%= options[:NoAdaptiveCompilation] %>;
+          runtime_setup.Options["CompilationThreshold"]  = <%= options[:CompilationThreshold] %>;
+          runtime_setup.Options["ExceptionDetail"]       = <%= options[:ExceptionDetail] %>; 
+          runtime_setup.Options["ShowClrExceptions"]     = <%= options[:ShowClrExceptions] %>; 
+          runtime_setup.Options["Profile"]       = <%= options[:Profile] %>;
+          runtime_setup.Options["Verbosity"]     = <%= options[:Verbosity] %>;
+          runtime_setup.Options["DebugVariable"] = <%= options[:DebugVariable] %>;
+          runtime_setup.Options["EnableTracing"] = <%= options[:EnableTracing] %>;
+          runtime_setup.Options["RequiredPaths"] = new string[] {
+            <%= options[:RequiredPaths].collect {|v| '@"' + v + '"'}.join(", ") %>
+          };
+          var search_paths = new string[] {
+            <%= options[:SearchPaths].collect   {|v| '@"' + v + '"'}.join(", ") %>
+          };
+          for (int i=0; i<search_paths.Length; i++) {
+            if (!Path.IsPathRooted(search_paths[i])) {
+              search_paths[i] = Path.GetFullPath(Path.Combine(entry_path, search_paths[i]));
+            }
+          }
+          runtime_setup.Options["SearchPaths"]     = search_paths;
+          runtime_setup.Options["MainFile"]        = entry_file;
+          runtime_setup.Options["Arguments"]       = args;
           runtime_setup.Options["ApplicationBase"] = entry_path;
-          runtime_setup.Options["StandardLibrary"] = Path.Combine(entry_path, "stdlib");
+          var stdlib = "<%= options[:StandardLibrary] %>";
+          if (Path.IsPathRooted(stdlib)) {
+            runtime_setup.Options["StandardLibrary"] = stdlib;
+          }
+          else {
+            runtime_setup.Options["StandardLibrary"] = Path.GetFullPath(Path.Combine(entry_path, stdlib));
+          }
           runtime_setup.HostType = typeof(IRHost);
           runtime_setup.HostArguments = new object[] { package };
           var engine = IronRuby.Ruby.GetEngine(IronRuby.Ruby.CreateRuntime(runtime_setup));
+          <% if options[:PassExceptions] then %>
+          return engine.CreateScriptSourceFromFile(entry_file).ExecuteProgram();
+          <% else %>
           try {
-            engine.ExecuteFile(entry_file);
-            return 0;
-          }
-          catch (IronRuby.Builtins.SystemExit e) {
-            return e.Status;
+            return engine.CreateScriptSourceFromFile(entry_file).ExecuteProgram();
           }
           catch (Exception e) {
             var thread_abort = e as System.Threading.ThreadAbortException;
@@ -197,17 +224,34 @@ module IRPack
             }
             return -1;
           }
+          <% end %>
         }
       }
     }
 CS
     module_function
-    def source(module_name, entry_file)
+    DefaultOptions = {
+      DebugMode:             false,
+      PrivateBinding:        false,
+      NoAdaptiveCompilation: false,
+      CompilationThreshold:  -1,
+      ExceptionDetail:       false,
+      ShowClrExceptions:     false,
+      Profile:               false,
+      Verbosity:             1,
+      DebugVariable:         false,
+      EnableTracing:         false,
+      RequiredPaths:         [],
+      SearchPaths:           [],
+      StandardLibrary:       'stdlib',
+    }
+    def source(module_name, entry_file, options={})
+      options = DefaultOptions.merge(options)
       ERB.new(Source).result(binding)
     end
 
-    def compile(output_file, module_name, entry_file, references)
-      src = source(module_name, entry_file)
+    def compile(output_file, module_name, entry_file, references, options={})
+      src = source(module_name, entry_file, options)
       sysasm = IRPack::CSCompiler.system_assemblies.collect {|asm|
         IRPack::CSCompiler.assembly_location(asm)
       }

data/test/test_application.rb

@@ -46,6 +46,17 @@ class TC_ApplicationArguments < Test::Unit::TestCase
     assert_equal('entry.rb', args.entry_file)
     assert_equal(1, args.files.size)
     assert_equal('entry.rb', args.files[File.expand_path('entry.rb')])
+    assert(!args.runtime_options[:DebugVariable])
+    assert(!args.runtime_options[:DebugMode])
+    assert_equal(1, args.runtime_options[:Verbosity])
+    assert(!args.runtime_options[:EnableTracing])
+    assert(!args.runtime_options[:Profile])
+    assert(!args.runtime_options[:ExceptionDetail])
+    assert(!args.runtime_options[:NoAdaptiveCompilation])
+    assert_equal(-1, args.runtime_options[:CompilationThreshold])
+    assert(!args.runtime_options[:PassExceptions])
+    assert(!args.runtime_options[:PrivateBinding])
+    assert(!args.runtime_options[:ShowClrExceptions])
   end
 
   def test_parse_output_file
@@ -101,5 +112,89 @@ class TC_ApplicationArguments < Test::Unit::TestCase
     assert_equal('hoge.rb', args.files[File.expand_path('foo/bar/hoge.rb')])
     assert_equal('hoge/fuga.rb', args.files[File.expand_path('foo/bar/hoge/fuga.rb')])
   end
+
+  def test_parse_debug_variable
+    argv = ['-d', 'entry.rb']
+    args = IRPack::Application::Arguments.parse!(argv)
+    assert(args.runtime_options[:DebugVariable])
+  end
+
+  def test_parse_debug_mode
+    argv = ['-D', 'entry.rb']
+    args = IRPack::Application::Arguments.parse!(argv)
+    assert(args.runtime_options[:DebugMode])
+  end
+
+  def test_parse_verbose
+    argv = ['-v', 'entry.rb']
+    args = IRPack::Application::Arguments.parse!(argv)
+    assert_equal(2, args.runtime_options[:Verbosity])
+  end
+
+  def test_parse_warn
+    argv = ['-w', 'entry.rb']
+    args = IRPack::Application::Arguments.parse!(argv)
+    assert_equal(2, args.runtime_options[:Verbosity])
+  end
+
+  def test_parse_warning
+    argv = ['-W', 'entry.rb']
+    args = IRPack::Application::Arguments.parse!(argv)
+    assert_equal(2, args.runtime_options[:Verbosity])
+  end
+
+  def test_parse_warning0
+    argv = ['-W0', 'entry.rb']
+    args = IRPack::Application::Arguments.parse!(argv)
+    assert_equal(0, args.runtime_options[:Verbosity])
+  end
+
+  def test_parse_trace
+    argv = ['--trace', 'entry.rb']
+    args = IRPack::Application::Arguments.parse!(argv)
+    assert(args.runtime_options[:EnableTracing])
+  end
+
+  def test_parse_profile
+    argv = ['--profile', 'entry.rb']
+    args = IRPack::Application::Arguments.parse!(argv)
+    assert(args.runtime_options[:Profile])
+  end
+
+  def test_parse_exception_detail
+    argv = ['--exception-detail', 'entry.rb']
+    args = IRPack::Application::Arguments.parse!(argv)
+    assert(args.runtime_options[:ExceptionDetail])
+  end
+
+  def test_parse_no_adaptive_compilation
+    argv = ['--no-adaptive-compilation', 'entry.rb']
+    args = IRPack::Application::Arguments.parse!(argv)
+    assert(args.runtime_options[:NoAdaptiveCompilation])
+  end
+
+  def test_parse_compilation_threshold
+    argv = ['--compilation-threshold', '8192', 'entry.rb']
+    args = IRPack::Application::Arguments.parse!(argv)
+    assert_equal(8192, args.runtime_options[:CompilationThreshold])
+  end
+
+  def test_parse_pass_exceptions
+    argv = ['--pass-exceptions', 'entry.rb']
+    args = IRPack::Application::Arguments.parse!(argv)
+    assert(args.runtime_options[:PassExceptions])
+  end
+
+  def test_parse_private_binding
+    argv = ['--private-binding', 'entry.rb']
+    args = IRPack::Application::Arguments.parse!(argv)
+    assert(args.runtime_options[:PrivateBinding])
+  end
+
+  def test_parse_show_clr_exceptions
+    argv = ['--show-clr-exceptions', 'entry.rb']
+    args = IRPack::Application::Arguments.parse!(argv)
+    assert(args.runtime_options[:ShowClrExceptions])
+  end
 end
 

data/test/test_entrypoint.rb

@@ -33,8 +33,9 @@ class TC_IRPack_EntryPoint < Test::Unit::TestCase
     module_name = 'TestModule'
     entry_file = 'foo.rb'
     references = ironruby_assemblies
+    runtime_options = {}
 
-    assert_equal(output_file, IRPack::EntryPoint.compile(output_file, module_name, entry_file, references))
+    assert_equal(output_file, IRPack::EntryPoint.compile(output_file, module_name, entry_file, references, runtime_options))
     assert(File.exist?(output_file))
     asm = nil
     assert_nothing_raised do
@@ -55,8 +56,9 @@ class TC_IRPack_EntryPoint < Test::Unit::TestCase
     module_name = 'TestModule'
     entry_file = 'main.rb'
     references = ironruby_assemblies
+    runtime_options = {}
 
-    IRPack::EntryPoint.compile(output_file, module_name, entry_file, references)
+    IRPack::EntryPoint.compile(output_file, module_name, entry_file, references, runtime_options)
     asm = System::Reflection::Assembly.load_from(output_file)
     main = asm.get_type("#{module_name}.EntryPoint").get_method('Main')
     assert_not_nil(main)
@@ -74,8 +76,9 @@ class TC_IRPack_EntryPoint < Test::Unit::TestCase
     module_name = 'TestModule'
     entry_file = 'main.rb'
     references = ironruby_assemblies
+    runtime_options = {}
 
-    IRPack::EntryPoint.compile(output_file, module_name, entry_file, references)
+    IRPack::EntryPoint.compile(output_file, module_name, entry_file, references, runtime_options)
     asm = System::Reflection::Assembly.load_from(output_file)
     main = asm.get_type("#{module_name}.EntryPoint").get_method('Main')
     assert_not_nil(main)
@@ -101,8 +104,9 @@ class TC_IRPack_EntryPoint < Test::Unit::TestCase
     module_name = 'TestModule'
     entry_file = 'main.rb'
     references = ironruby_assemblies
+    runtime_options = {}
 
-    IRPack::EntryPoint.compile(output_file, module_name, entry_file, references)
+    IRPack::EntryPoint.compile(output_file, module_name, entry_file, references, runtime_options)
     asm = System::Reflection::Assembly.load_from(output_file)
     main = asm.get_type("#{module_name}.EntryPoint").get_method('Main')
     assert_not_nil(main)
@@ -115,5 +119,169 @@ class TC_IRPack_EntryPoint < Test::Unit::TestCase
       end
     end
   end
+
+  def test_search_paths
+    output_file = tempfilename('.dll')
+    module_name = 'TestModule'
+    entry_file = 'main.rb'
+    references = ironruby_assemblies
+    runtime_options = {
+      SearchPaths: [
+        'foo',
+        '../bar',
+      ],
+    }
+
+    IRPack::EntryPoint.compile(output_file, module_name, entry_file, references, runtime_options)
+    asm = System::Reflection::Assembly.load_from(output_file)
+    main = asm.get_type("#{module_name}.EntryPoint").get_method('Main')
+    assert_not_nil(main)
+    main_rb = <<-RB
+    if $:.any? {|path| /foo$/=~path } and
+       $:.any? {|path| /bar$/=~path } then
+      exit 0
+    else
+      exit 1
+    end
+    RB
+    create_package('main.rb' => main_rb) do |package|
+      res = main.invoke(nil, System::Array[System::Object].new([package, System::Array[System::String].new(0)]))
+      assert_equal(0, res)
+    end
+  end
+
+  def test_required_paths
+    output_file = tempfilename('.dll')
+    module_name = 'TestModule'
+    entry_file = 'main.rb'
+    references = ironruby_assemblies
+    runtime_options = {
+      RequiredPaths: [
+        'stringio',
+        'date',
+      ],
+      StandardLibrary: '../Lib',
+    }
+
+    IRPack::EntryPoint.compile(output_file, module_name, entry_file, references, runtime_options)
+    asm = System::Reflection::Assembly.load_from(output_file)
+    main = asm.get_type("#{module_name}.EntryPoint").get_method('Main')
+    assert_not_nil(main)
+    main_rb = <<-RB
+    required_constants = [:StringIO, :DateTime]
+    if required_constants.all? {|const| Object.constants.include?(const) } then
+      exit 0
+    else
+      exit 1
+    end
+    RB
+    create_package('main.rb' => main_rb) do |package|
+      res = main.invoke(nil, System::Array[System::Object].new([package, System::Array[System::String].new(0)]))
+      assert_equal(0, res)
+    end
+  end
+
+  def test_debug_variable
+    output_file = tempfilename('.dll')
+    module_name = 'TestModule'
+    entry_file = 'main.rb'
+    references = ironruby_assemblies
+    runtime_options = {
+      DebugVariable: true,
+    }
+
+    IRPack::EntryPoint.compile(output_file, module_name, entry_file, references, runtime_options)
+    asm = System::Reflection::Assembly.load_from(output_file)
+    main = asm.get_type("#{module_name}.EntryPoint").get_method('Main')
+    assert_not_nil(main)
+    main_rb = <<-RB
+    exit($DEBUG ? 0 : 1)
+    RB
+    create_package('main.rb' => main_rb) do |package|
+      res = main.invoke(nil, System::Array[System::Object].new([package, System::Array[System::String].new(0)]))
+      assert_equal(0, res)
+    end
+  end
+
+  def test_profile
+    output_file = tempfilename('.dll')
+    module_name = 'TestModule'
+    entry_file = 'main.rb'
+    references = ironruby_assemblies
+    runtime_options = {
+      Profile: true,
+    }
+
+    IRPack::EntryPoint.compile(output_file, module_name, entry_file, references, runtime_options)
+    asm = System::Reflection::Assembly.load_from(output_file)
+    main = asm.get_type("#{module_name}.EntryPoint").get_method('Main')
+    assert_not_nil(main)
+    main_rb = <<-RB
+    begin
+      IronRuby::Clr.profile { 1 + 1 }
+      exit 0
+    rescue SystemCallError
+      exit 1
+    end
+    RB
+    create_package('main.rb' => main_rb) do |package|
+      res = main.invoke(nil, System::Array[System::Object].new([package, System::Array[System::String].new(0)]))
+      assert_equal(0, res)
+    end
+  end
+
+  def test_enable_tracing
+    output_file = tempfilename('.dll')
+    module_name = 'TestModule'
+    entry_file = 'main.rb'
+    references = ironruby_assemblies
+    runtime_options = {
+      EnableTracing: true,
+    }
+
+    IRPack::EntryPoint.compile(output_file, module_name, entry_file, references, runtime_options)
+    asm = System::Reflection::Assembly.load_from(output_file)
+    main = asm.get_type("#{module_name}.EntryPoint").get_method('Main')
+    assert_not_nil(main)
+    main_rb = <<-RB
+    begin
+      set_trace_func(proc { nil })
+      exit 0
+    rescue System::NotSupportedException
+      exit 1
+    end
+    RB
+    create_package('main.rb' => main_rb) do |package|
+      res = main.invoke(nil, System::Array[System::Object].new([package, System::Array[System::String].new(0)]))
+      assert_equal(0, res)
+    end
+  end
+
+  def test_pass_exceptions
+    output_file = tempfilename('.dll')
+    module_name = 'TestModule'
+    entry_file = 'main.rb'
+    references = ironruby_assemblies
+    runtime_options = {
+      PassExceptions: true,
+    }
+
+    IRPack::EntryPoint.compile(output_file, module_name, entry_file, references, runtime_options)
+    asm = System::Reflection::Assembly.load_from(output_file)
+    main = asm.get_type("#{module_name}.EntryPoint").get_method('Main')
+    assert_not_nil(main)
+    main_rb = <<-RB
+    raise System::ApplicationException, 'Exception Test'
+    RB
+    create_package('main.rb' => main_rb) do |package|
+      assert_raise(System::ApplicationException) do
+        begin
+          main.invoke(nil, System::Array[System::Object].new([package, System::Array[System::String].new(0)]))
+        rescue System::Reflection::TargetInvocationException => e
+          raise e.InnerException
+        end
+      end
+    end
+  end
 end
 

metadata

@@ -2,7 +2,7 @@
 name: irpack
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors: 
 - kumaryu
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-22 00:00:00 +09:00
+date: 2011-11-09 00:00:00 +09:00
 default_executable: 
 dependencies: []
 
@@ -23,8 +23,8 @@ executables:
 - irpack
 extensions: []
 
-extra_rdoc_files: []
-
+extra_rdoc_files: 
+- README.rdoc
 files: 
 - bin/irpack
 - lib/irpack/application.rb
@@ -42,13 +42,15 @@ files:
 - test/test_missing.rb
 - test/test_packager.rb
 - test/utils.rb
+- README.rdoc
 has_rdoc: true
 homepage: http://github.com/kumaryu/irpack
 licenses: []
 
 post_install_message: 
-rdoc_options: []
-
+rdoc_options: 
+- --main
+- README.rdoc
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -70,5 +72,12 @@ rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: Generate a standalone executable file from IronRuby scripts.
-test_files: []
-
+test_files: 
+- test/test_application.rb
+- test/test_bootloader.rb
+- test/test_cscompiler.rb
+- test/test_entrypoint.rb
+- test/test_irpack.rb
+- test/test_missing.rb
+- test/test_packager.rb
+- test/utils.rb