ocra 1.2.0 → 1.3.0.rc1

data/History.txt

@@ -1,3 +1,20 @@
+=== 1.3.0.rc1
+
+* Fixed some additional corner cases with absolute and relative
+  require & load paths. Extended test suite to cover a lot more
+  cases.
+
+* Now provides a meaningful exit status code (1 on error, 0 on
+  success). (DavidMikeSimon)
+
+* New option to _not_ run the script to detect dependencies
+  (--no-dep-run). (DavidMikeSimon)
+
+* Bundler support using the --gemfile option. (DavidMikeSimon)
+
+* Debug mode support in the stub (--debug). Also --debug-extract to
+  keep extracted files from executable. (DavidMikeSimon)
+  
 === 1.2.0
 
 * Ignore console events (Ctrl-C, Ctrl-Break). Ruby process handles

data/Manifest.txt

@@ -1,6 +1,6 @@
 History.txt
 Manifest.txt
-README.txt
+README.rdoc
 Rakefile
 bin/ocra
 share/ocra/lzma.exe

data/{README.txt → README.rdoc}

@@ -13,30 +13,62 @@ source code. The executable is a self-extracting, self-running
 executable that contains the Ruby interpreter, your source code and
 any additionally needed ruby libraries or DLL.
 
-== FEATURES/PROBLEMS:
+== FEATURES
 
 * LZMA Compression (optional, default on)
-* Windows support only
 * Ruby 1.9 support
 * Both windowed/console mode supported
+* Includes gems based on usage, or from a Bundler Gemfile
 
-If you experience problems with OCRA or have found a bug, please use
-the issue tracker on GitHub
-(http://github.com/larsch/ocra/issues). You can also join the Google
-Group discussion forum to ask questions and get help
-(http://groups.google.com/group/ruby-ocra).
+== PROBLEMS & BUG REPORTING:
 
-== SYNOPSIS:
+* Windows support only
 
-  ocra [option] script.rb
+If you experience problems with OCRA or have found a bug, please use
+the issue tracker on GitHub (http://github.com/larsch/ocra/issues).
+You can also join the Google Group discussion forum to ask questions
+and get help (http://groups.google.com/group/ruby-ocra).
 
-* Will package "script.rb", the Ruby interpreter and all dependencies
-  (gems and DLLs) into an executable named "script.exe".
+== SYNOPSIS:
 
+=== Building an executable:
+
+  ocra script.rb
+
+Will package "<tt>script.rb</tt>", the Ruby interpreter and all
+dependencies (gems and DLLs) into an executable named
+"<tt>script.exe</tt>".
+
+=== Command line:
+  
+  ocra [options] script.rb [<other files> ...] [-- <script arguments> ...]
+
+=== Options:
+
+  ocra --help
+
+  --dll dllname    Include additional DLLs from the Ruby bindir.
+  --no-lzma        Disable LZMA compression of the executable.
+  --no-dep-run     Don't run script.rb to check for dependencies.
+  --add-all-core   Add all core ruby libraries to the executable.
+  --output <file>  Name the exe to generate. Defaults to ./<scriptname>.exe.
+  --gemfile <file> Add all gems and dependencies listed in a Bundler Gemfile.
+  --quiet          Suppress output while building executable.
+  --verbose        Show extra output while building executable.
+  --debug          Executable will be verbose.
+  --debug-extract  Executable will unpack to local dir and not delete after.
+  --help           Display this information.
+  --windows        Force Windows application (rubyw.exe)
+  --console        Force console application (ruby.exe)
+  --no-autoload    Don't load/include script.rb's autoloads.
+  --icon <ico>     Replace icon with a custom one.
+  --version        Display version number and exit.
+  --no-gem-filter  Don't filter readme's, doc, C-source, etc. from gems.
+  
 === Compilation:
 
-* OCRA will load your script (using Kernel#load) and build the
-  executable when it exits.
+* OCRA will load your script (using <tt>Kernel#load</tt>) and build
+  the executable when it exits.
 
 * Your program should 'require' all necessary files when invoked without
   arguments, so OCRA can detect all dependencies.
@@ -46,8 +78,8 @@ Group discussion forum to ask questions and get help
 
 * .rb files will become console applications. .rbw files will become
   windowed application (without a console window popping
-  up). Alternatively, use the <tt>--console</tt> or <tt>--windows</tt>
-  options.
+  up). Alternatively, use the "<tt>--console</tt>" or
+  "<tt>--windows</tt>" options.
 
 === Running your application:
 
@@ -83,20 +115,26 @@ Group discussion forum to ask questions and get help
 * Windows
 
 * Working Ruby installation, tested with:
-    * One-Click Installer (187_27_rc2)
-    * RubyInstaller (1.8.7p299, 1.9.1p249, 1.9.2p0)
+  * One-Click Installer (187_27_rc2)
+  * RubyInstaller (1.8.7p299, 1.9.1p249, 1.9.2p0)
 
 * MinGW Installation (when working with the source code only)
 
 == INSTALL:
 
-=== Gem
+=== Gem Package
+
+Install by running:
 
   gem install ocra
 
-Can also be downloaded from http://rubyforge.org/frs/?group_id=8185
+=== Alternate Gem download:
+
+* http://rubyforge.org/frs/?group_id=8185
+
+* http://rubygems.org/gems/ocra
 
-=== Stand-alone
+=== Stand-alone version
 
 Get ocrasa.rb from http://rubyforge.org/frs/?group_id=8185. Requires
 nothing but a working Ruby installation on Windows.
@@ -104,7 +142,8 @@ nothing but a working Ruby installation on Windows.
 == TECHNICAL DETAILS
 
 OCRA first runs the target script in order to detect any files that
-are loaded and used at runtime (Using Kernel#require and Kernel#load).
+are loaded and used at runtime (Using <tt>Kernel#require</tt> and
+<tt>Kernel#load</tt>).
 
 OCRA embeds everything needed to run a Ruby script into a single
 executable file. The file contains the .exe stub which is compiled
@@ -120,18 +159,19 @@ your application will be put in the 'src' subdirectory.
 
 === Libraries
 
-Any code that is loaded through Kernel#require when your script is
-executed will be included in the OCRA executable. Conditionally loaded
-code will not be loaded and included in the executable unless the code
-is actually run when OCRA invokes your script. Otherwise, OCRA won't
-know about it and will not include the source files.
+Any code that is loaded through <tt>Kernel#require</tt> when your
+script is executed will be included in the OCRA
+executable. Conditionally loaded code will not be loaded and included
+in the executable unless the code is actually run when OCRA invokes
+your script. Otherwise, OCRA won't know about it and will not include
+the source files.
 
 RubyGems are handled specially. Whenever a file from a Gem is
 detected, OCRA will attempt to include all the files from that
 specific Gem (all files listed in the manifest), expect some unlikely
-needed files such as readme's and other documentation. This can be
-overruled using the '--no-gem-filter' which will make OCRA include
-every file that is listed in the Gem's manifest.
+needed files such as readme's and other documentation. This latter can
+be overruled using the "<tt>--no-gem-filter</tt>" which will make OCRA
+include every file that is listed in the Gem's manifest.
 
 Libraries found in non-standard path (for example, if you invoke OCRA
 with "ruby -I some/path") will be placed into the site dir
@@ -141,13 +181,45 @@ tree, since OCRA may place the files elsewhere when extracted into the
 temporary directory.
 
 In case your script (or any of its dependencies) sets up autoloaded
-module using Kernel#autoload, OCRA will automatically try to load them
-to ensure that they are all included in the executable. Modules that
-doesn't exist will be ignored (a warning will be logged).
+module using <tt>Kernel#autoload</tt>, OCRA will automatically try to
+load them to ensure that they are all included in the
+executable. Modules that doesn't exist will be ignored (a warning will
+be logged).
 
 Dynamic link libraries (.dll files, for example WxWidgets, or other
 source files) will be detected and included by OCRA.
 
+=== Including libraries non-automatically
+
+If an application or framework is complicated enough that it tends
+to confuse Ocra's automatic dependency resolution, then you can
+use other means to specify what needs to be packaged with your app.
+
+To disable automatic dependency resolution, use the --no-dep-run
+option; with it, Ocra will skip executing your program during the
+build process. You will also probably need to use the --add-all-core
+option to include the Ruby core libraries.
+
+If your app uses gems, then you can specify them in a
+Bundler (http://gembundler.com/) Gemfile, then use the --gemfile
+option to supply it to Ocra. Ocra will automatically include all
+gems specified, and all their dependencies.
+
+(Note: This assumes that the gems are installed in your system,
+*not* locally packaged inside the app directory by "bundle package")
+
+These options are particularly useful for packaging Rails
+applications.  For example, to package a Rails 3 app in the
+directory "someapp" and create an exe named "someapp.exe", without
+actually running the app during the build, you could use the
+following command:
+
+  ocra someapp/script/server someapp --no-dep-run --add-all-core --gemfile someapp/Gemfile
+
+Rails 2 apps can be packaged similarly, though you will have to
+integrate them with Bundler (http://gembundler.com/rails23.html)
+first.
+
 === Environment variables
 
 OCRA executables clear the RUBYLIB environment variable before your
@@ -177,13 +249,13 @@ through the Windows Explorer), the users' current working directory
 <tt>C:\\WINDOWS\\SYSTEM32</tt> when the executable is invoked through
 a file association. You can optionally change the directory yourself:
 
-   Dir.chdir File.dirname($0)
+  Dir.chdir File.dirname($0)
 
 If you wish to maintain the user's working directory, but need to
 'require' additional Ruby scripts from the source directory, you can
 add the following line to your script:
 
-   $LOAD_PATH.unshift File.dirname($0)
+  $LOAD_PATH.unshift File.dirname($0)
 
 === Load path mangling
 
@@ -193,7 +265,7 @@ directory being the same as where the script is located (See
 above). If you have additional library files in directories below the
 directory containing your source script you can use this idiom:
 
-   $LOAD_PATH.unshift File.join(File.dirname($0), 'path/to/script')
+  $LOAD_PATH.unshift File.join(File.dirname($0), 'path/to/script')
 
 === Detecting OCRA
 
@@ -202,10 +274,10 @@ looking for the 'Ocra' constant. If it is defined, OCRA is currenly
 building the executable from your script. For example, you can use
 this to avoid opening a GUI window when compiling executables:
 
-   app = MyApp.new
-   if not defined?(Ocra)
-     app.main_loop
-   end
+  app = MyApp.new
+  if not defined?(Ocra)
+    app.main_loop
+  end
 
 === Additional files and resources
 
@@ -213,32 +285,35 @@ You can add additional files to the OCRA executable (for example
 images) by appending them to the command line. They should be placed
 in the source directory with your main script (or a subdirectory).
 
-   ocra mainscript.rb someimage.jpeg docs/document.txt
+  ocra mainscript.rb someimage.jpeg docs/document.txt
 
 This will create the following layout in the temporary directory when
 your program is executed:
 
-   src/mainscript.rb
-   src/someimage.jpeg
-   src/docs/document.txt
+  src/mainscript.rb
+  src/someimage.jpeg
+  src/docs/document.txt
 
-Paths on the command line can include ** globs to include a hierachy
-of files, for example
+Both files, directoriess and glob patterns can be specified on the
+command line. Files will be added as-is. If a directory is specified,
+OCRA will include all files found below that directory. Glob patterns
+(See Dir.glob) can be used to specify a specific set of files, for
+example:
 
-   ocra script.rb assets/**/*.png
+  ocra script.rb assets/**/*.png
 
 === Command Line Arguments
 
 To pass command line argument to your script (both while building and
-when run from the resulting executable), specify them after a "--"
-marker. For example:
+when run from the resulting executable), specify them after a
+"<tt>--</tt>" marker. For example:
 
-   ocra script.rb -- --some-options=value
+  ocra script.rb -- --some-options=value
 
-This will pass "--some-options=value" to the script when build and
-when running the executable. Any extra argument specified by the user
-when invoking the executable will be appended after the compile-time
-arguments.
+This will pass "<tt>--some-options=value</tt>" to the script when
+build and when running the executable. Any extra argument specified by
+the user when invoking the executable will be appended after the
+compile-time arguments.
 
 === Window/Console
 
@@ -248,10 +323,10 @@ windowed applications (without console window) from .rbw-files.
 Ruby on Windows provides two executables: ruby.exe is a console mode
 application and rubyw.exe is a windowed application which does not
 bring up a console window when launched using the Windows Explorer.
-By default, or if the <tt>--console</tt> option is used, OCRA will use
+By default, or if the "<tt>--console</tt>" option is used, OCRA will use
 the console runtime (rubyw.exe). OCRA will automatically select the
 windowed runtime when your script has the ".rbw" extension, or if you
-specify the <tt>--windows</tt> command line option.
+specify the "<tt>--windows</tt>" command line option.
 
 If your application works in console mode but not in windowed mode,
 first check if your script works without OCRA using rubyw.exe. A
@@ -262,14 +337,14 @@ buffers run full).
 You can also try wrapping your script in an exception handler that
 logs any errors to a file:
 
-   begin
-     # your script here
-   rescue Exception => e
-     File.open("except.log") do |f|
-       f.puts e.inspect
-       f.puts e.backtrace
-     end
-   end
+  begin
+    # your script here
+  rescue Exception => e
+    File.open("except.log") do |f|
+      f.puts e.inspect
+      f.puts e.backtrace
+    end
+  end
 
 == CREDITS:
 

data/Rakefile

@@ -8,6 +8,7 @@ Hoe.spec 'ocra' do |spec|
   spec.email = "larsch@belunktum.dk"
   spec.url = "http://ocra.rubyforge.org/"
   spec.readme_file = 'README.rdoc'
+  spec.extra_rdoc_files = ['README.rdoc']
 end
 
 task :build_stub do
@@ -19,10 +20,6 @@ end
 
 file 'share/ocra/stub.exe' => :build_stub
 
-file 'README.txt' => 'README.rdoc' do
-  cp 'README.rdoc', 'README.txt'
-end
-
 task :test => :build_stub
 
 task :standalone => [ 'bin/ocrasa.rb' ]

data/bin/ocra

@@ -2,47 +2,190 @@
 # -*- ruby -*-
 
 module Ocra
-  Signature = [0x41, 0xb6, 0xba, 0x4e]
-  OP_END = 0
-  OP_CREATE_DIRECTORY = 1
-  OP_CREATE_FILE = 2
-  OP_CREATE_PROCESS = 3
-  OP_DECOMPRESS_LZMA = 4
-  OP_SETENV = 5
-  OP_POST_CREATE_PROCESS = 6
+  # Path handling class. Ruby's Pathname class is not used because it
+  # is case sensitive and doesn't handle paths with mixed path
+  # separators.
+  class Pathname
+    def Pathname.pwd
+      Pathname.new(Dir.pwd)
+    end
+
+    def Pathname.pathequal(a, b)
+      a.downcase == b.downcase
+    end
+
+    attr_reader :path
+    SEPARATOR_PAT = /[#{Regexp.quote File::ALT_SEPARATOR}#{Regexp.quote File::SEPARATOR}]/ # }
+    ABSOLUTE_PAT = /\A([A-Z]:)?#{SEPARATOR_PAT}/i
+    
+    def initialize(path)
+      @path = path
+    end
+    
+    def to_native
+      @path.tr File::SEPARATOR, File::ALT_SEPARATOR
+    end
+    
+    def to_posix
+      @path.tr File::ALT_SEPARATOR, File::SEPARATOR
+    end
+
+    # Compute the relative path from the 'src' path (directory) to 'tgt'
+    # (directory or file). Return the absolute path to 'tgt' if it can't
+    # be reached from 'src'.
+    def relative_path_from(other)
+      a = @path.split(SEPARATOR_PAT)
+      b = other.path.split(SEPARATOR_PAT)
+      while a.first && b.first && Pathname.pathequal(a.first, b.first)
+        a.shift
+        b.shift
+      end
+      return other if Pathname.new(b.first).absolute?
+      b.size.times { a.unshift '..' }
+      return Pathname.new(a.join('/'))
+    end
+
+    # Determines if 'src' is contained in 'tgt' (i.e. it is a subpath of
+    # 'tgt'). Both must be absolute paths and not contain '..'
+    def subpath?(other)
+      other = Ocra.Pathname(other)
+      src_normalized = to_posix.downcase
+      tgt_normalized = other.to_posix.downcase
+      src_normalized =~ /^#{Regexp.escape tgt_normalized}#{SEPARATOR_PAT}/i
+    end
 
-  VERSION = "1.2.0"
+    def /(other)
+      Ocra.Pathname(@path + '/' + Ocra.Pathname(other).path)
+    end
+    
+    def append_to_filename!(s)
+      @path.sub!(/(\.[^.]*?|)$/) { s.to_s + $1 }
+    end
+
+    def ext(new_ext = nil)
+      if new_ext
+        Pathname.new(@path.sub(/(\.[^.]*?)?$/) { new_ext })
+      else
+        File.extname(@path)
+      end
+    end
+
+    def ext?(expected_ext)
+      Pathname.pathequal(ext, expected_ext)
+    end
+
+    def ==(other); to_posix.downcase == other.to_posix.downcase; end
+    def =~(o); @path =~ o; end
+    def <=>(other); @path.casecmp(other.path); end
+    def exist?; File.exist?(@path); end
+    def file?; File.file?(@path); end
+    def directory?; File.directory?(@path); end
+    def absolute?; @path =~ ABSOLUTE_PAT; end
+    def dirname; Pathname.new(File.dirname(@path)); end
+    def basename; Pathname.new(File.basename(@path)); end
+    def expand(dir = nil); Pathname.new(File.expand_path(@path, dir && Ocra.Pathname(dir))); end
+
+    alias to_s to_posix
+    alias to_str to_posix
+  end
+
+  # Type conversion for the Pathname class. Works with Pathname,
+  # String, NilClass and arrays of any of these.
+  def self.Pathname(obj)
+    case obj
+    when Pathname
+      obj
+    when Array
+      obj.map { |x| Pathname(x) }
+    when String
+      Pathname.new(obj)
+    when NilClass
+      nil
+    else
+      raise ArgumentError, obj
+    end
+  end
+  
+  # Variables describing the host's build environment.
+  module Host
+    class << self
+      def exec_prefix
+        @exec_prefix ||= Ocra.Pathname(RbConfig::CONFIG['exec_prefix'])
+      end
+      def sitelibdir
+        @sitelibdir ||= Ocra.Pathname(RbConfig::CONFIG['sitelibdir'])
+      end
+      def bindir
+        @bindir ||= Ocra.Pathname(RbConfig::CONFIG['bindir'])
+      end
+      def libruby_so
+        @libruby_so ||= Ocra.Pathname(RbConfig::CONFIG['LIBRUBY_SO'])
+      end
+      def exeext
+        RbConfig::CONFIG['EXEEXT'] || ".exe"
+      end
+      def rubyw_exe
+        @rubyw_exe ||= (RbConfig::CONFIG['rubyw_install_name'] || "rubyw") + exeext
+      end
+      def ruby_exe
+        @ruby_exe ||= (RbConfig::CONFIG['ruby_install_name'] || "ruby") + exeext     
+      end
+      def tempdir
+        @tempdir ||= Ocra.Pathname(ENV['TEMP'])
+      end
+    end
+  end
+
+  # Sorts and returns an array without duplicates. Works with complex
+  # objects (such as Pathname), in contrast to Array#uniq.
+  def self.sort_uniq(a)
+    a.sort.inject([]) { |r, e| r.last == e ? r : r << e }
+  end
+  
+  VERSION = "1.3.0.rc1"
 
   IGNORE_MODULES = /^enumerator.so$/
 
   IGNORE_GEMFILES = %r{(
     # Auxiliary files in the root of the gem
-    ^(History|Install|Manifest|README|Licen[sc]e).(txt|rdoc)$ |
+    ^(\.\/)?(History|Install|Manifest|README|Licen[sc]e|Contributors|ChangeLog|BSD|GPL).*$ |
     # Installation files in the root of the gem
-    ^(Rakefile|setup.rb|extconf.rb)$ |
+    ^(\.\/)?(Rakefile|setup.rb|extconf.rb)$ |
     # Documentation/test directories in the root of the gem
-    ^(doc|ext|examples|test|tests|benchmarks)\/ |
+    ^(\.\/)?(doc|ext|examples|test|tests|benchmarks)\/ |
     # Directories anywhere
-    (^|\/)(\.autotest|\.svn\.cvs)(\/|$) |
+    (^|\/)(\.autotest|\.svn|\.cvs|\.git)(\/|$) |
     # Unlikely extensions
     \.(rdoc)$/
   )}xi
 
-  PATH_SEPARATOR = /[\/\\]/
-
-  TEMPDIR_MARKER = "\xFF"
+  # Alias for the temporary directory where files are extracted.
+  TEMPDIR_ROOT = Pathname.new("\xFF")
+  # Directory for source files in temporary directory.
+  SRCDIR = Pathname.new('src')
+  # Directory for Ruby binaries in temporary directory.
+  BINDIR = Pathname.new('bin')
+  # Directory for GEMHOME files in temporary directory.
+  GEMHOMEDIR = Pathname.new('gemhome')
 
   @options = {
     :lzma_mode => true,
     :extra_dlls => [],
     :files => [],
+    :run_script => true,
+    :add_all_core => false,
+    :output_override => nil,
     :load_autoload => true,
     :force_windows => false,
     :force_console => false,
     :icon_filename => nil,
+    :gemfile => nil,
     :quiet => false,
+    :verbose => false,
     :autodll => true,
     :show_warnings => true,
+    :debug => false,
+    :debug_extract => false,
     :gem_filter => true,
     :arg => []
   }
@@ -56,17 +199,26 @@ module Ocra
     attr_reader :stubwimage
   end
 
-  # Returns a binary blob store embedded in the current Ruby script.
-  def Ocra.get_next_embedded_image
-    DATA.read(DATA.readline.to_i).unpack("m")[0]
+  def Ocra.msg(s)
+    puts "=== #{s}" unless Ocra.quiet
+  end
+
+  def Ocra.verbose_msg(s)
+    puts s if Ocra.verbose and not Ocra.quiet
+  end
+
+  def Ocra.warn(s)
+    msg "WARNING: #{s}" if Ocra.show_warnings
   end
 
-  def Ocra.dospath(path)
-    path.tr('/','\\')
+  def Ocra.fatal_error(s)
+    puts "ERROR: #{s}"
+    exit 1
   end
 
-  def Ocra.posixpath(path)
-    path.tr('\\','/')
+  # Returns a binary blob store embedded in the current Ruby script.
+  def Ocra.get_next_embedded_image
+    DATA.read(DATA.readline.to_i).unpack("m")[0]
   end
 
   def Ocra.save_environment
@@ -86,20 +238,18 @@ module Ocra
       @stubimage = get_next_embedded_image
       @stubwimage = get_next_embedded_image
       lzmaimage = get_next_embedded_image
-      @lzmapath = File.join(ENV['TEMP'], 'lzma.exe')
+      @lzmapath = Host.tempdir / 'lzma.exe'
       File.open(@lzmapath, "wb") { |file| file << lzmaimage }
       ediconimage = get_next_embedded_image
-      @ediconpath = File.join(ENV['TEMP'], 'edicon.exe')
+      @ediconpath = Host.tempdir / 'edicon.exe'
       File.open(@ediconpath, "wb") { |file| file << ediconimage }
     else
-      ocrapath = File.dirname(__FILE__)
-      @stubimage = File.open(File.join(ocrapath, '../share/ocra/stub.exe'), "rb") { |file| file.read }
-      @stubwimage = File.open(File.join(ocrapath, '../share/ocra/stubw.exe'), "rb") { |file| file.read }
-      @lzmapath = File.expand_path('../share/ocra/lzma.exe', ocrapath)
-      @ediconpath = File.expand_path('../share/ocra/edicon.exe', ocrapath)
-    end
-    @lzmapath = Ocra.dospath(@lzmapath)
-    @ediconpath = Ocra.dospath(@ediconpath)
+      ocrapath = Pathname(File.dirname(__FILE__))
+      @stubimage = File.open(ocrapath / '../share/ocra/stub.exe', "rb") { |file| file.read }
+      @stubwimage = File.open(ocrapath / '../share/ocra/stubw.exe', "rb") { |file| file.read }
+      @lzmapath = (ocrapath / '../share/ocra/lzma.exe').expand
+      @ediconpath = (ocrapath / '../share/ocra/edicon.exe').expand
+    end
   end
 
   def Ocra.parseargs(argv)
@@ -108,24 +258,39 @@ ocra [options] script.rb
 
 --dll dllname    Include additional DLLs from the Ruby bindir.
 --no-lzma        Disable LZMA compression of the executable.
---quiet          Suppress output.
+--no-dep-run     Don't run script.rb to check for dependencies.
+--add-all-core   Add all core ruby libraries to the executable.
+--output <file>  Name the exe to generate. Defaults to ./<scriptname>.exe.
+--gemfile <file> Add all gems and dependencies listed in a Bundler Gemfile.
+--quiet          Suppress output while building executable.
+--verbose        Show extra output while building executable.
+--debug          Executable will be verbose.
+--debug-extract  Executable will unpack to local dir and not delete after.
 --help           Display this information.
 --windows        Force Windows application (rubyw.exe)
 --console        Force console application (ruby.exe)
---no-autoload    Don't load/include script.rb's autoloads
---icon <ico>     Replace icon with a custom one
---version        Display version number
---no-gem-filter  Don't filter readme's, doc, C-source, etc. from gems
+--no-autoload    Don't load/include script.rb's autoloads.
+--icon <ico>     Replace icon with a custom one.
+--version        Display version number and exit.
+--no-gem-filter  Don't filter readme's, doc, C-source, etc. from gems.
 EOF
 
     while arg = argv.shift
       case arg
       when /\A--(no-)?lzma\z/
         @options[:lzma_mode] = !$1
+      when /\A--no-dep-run\z/
+        @options[:run_script] = false
+      when /\A--add-all-core\z/
+        @options[:add_all_core] = true
+      when /\A--output\z/
+        @options[:output_override] = Pathname(argv.shift)
       when /\A--dll\z/
         @options[:extra_dlls] << argv.shift
       when /\A--quiet\z/
         @options[:quiet] = true
+      when /\A--verbose\z/
+        @options[:verbose] = true
       when /\A--windows\z/
         @options[:force_windows] = true
       when /\A--console\z/
@@ -133,15 +298,22 @@ EOF
       when /\A--no-autoload\z/
         @options[:load_autoload] = false
       when /\A--icon\z/
-        @options[:icon_filename] = argv.shift
-        raise "Icon file #{icon_filename} not found.\n" unless File.exist?(icon_filename)
+        @options[:icon_filename] = Pathname(argv.shift)
+        Ocra.fatal_error "Icon file #{icon_filename} not found.\n" unless icon_filename.exist?
+      when /\A--gemfile\z/
+        @options[:gemfile] = Pathname(argv.shift)
+        Ocra.fatal_error "Gemfile #{gemfile} not found.\n" unless gemfile.exist?
       when /\A--no-autodll\z/
         @options[:autodll] = false
       when /\A--version\z/
         puts "Ocra #{VERSION}"
-        exit
+        exit 0
       when /\A--no-warnings\z/
         @options[:show_warnings] = false
+      when /\A--debug\z/
+        @options[:debug] = true
+      when /\A--debug-extract\z/
+        @options[:debug_extract] = true
       when /\A--no-gem-filter\z/
         @options[:gem_filter] = false
       when /\A--\z/
@@ -149,7 +321,7 @@ EOF
         ARGV.clear
       when /\A--help\z/, /\A--./
         puts usage
-        exit
+        exit 0
       else
         @options[:files] << arg
       end
@@ -157,8 +329,19 @@ EOF
 
     if files.empty?
       puts usage
-      exit
+      exit 1
     end
+
+    @options[:files].map! { |path|
+      path = path.tr('\\','/')
+      if File.directory?(path)
+        # If a directory is passed, we want all files under that directory
+        path = "#{path}/**/*"
+      end
+      files = Dir[path]
+      Ocra.fatal_error "#{path} not found!" if files.empty?
+      files.map { |path| Pathname(path).expand }
+    }.flatten!
   end
 
   def Ocra.init(argv)
@@ -171,7 +354,7 @@ EOF
   # (and hence classes), and checks their constants for autoloaded
   # ones, then attempts to load them.
   def Ocra.attempt_load_autoload
-    modules_checked = []
+    modules_checked = {}
     loop do
       modules_to_check = []
       ObjectSpace.each_object(Module) do |mod|
@@ -179,15 +362,15 @@ EOF
       end
       break if modules_to_check.empty?
       modules_to_check.each do |mod|
-        modules_checked << mod
+        modules_checked[mod] = true
         mod.constants.each do |const|
           if mod.autoload?(const)
             begin
               mod.const_get(const)
             rescue NameError
-              puts "=== WARNING: #{mod}::#{const} was defined autoloadable, but caused NameError" if Ocra.show_warnings
+              Ocra.warn "#{mod}::#{const} was defined autoloadable, but caused NameError"
             rescue LoadError
-              puts "=== WARNING: #{mod}::#{const} was not loadable" if Ocra.show_warnings
+              Ocra.warn "#{mod}::#{const} was not loadable"
             end
           end
         end
@@ -195,65 +378,43 @@ EOF
     end
   end
 
-  # Compute the relative path from the 'src' path (directory) to 'tgt'
-  # (directory or file). Return the absolute path to 'tgt' if it can't
-  # be reached from 'src'.
-  def Ocra.relative_path(src, tgt)
-    a = posixpath(src).split('/')
-    b = posixpath(tgt).split('/')
-    while a.first && a.first.downcase == b.first.downcase
-      a.shift
-      b.shift
-    end
-    return tgt if abspath?(b.first)
-    a.size.times { b.unshift '..' }
-    return b.join('/')
-  end
-
-  # Determines if 'src' is contained in 'tgt' (i.e. it is a subpath of
-  # 'tgt'). Both must be absolute paths and not contain '..'
-  def Ocra.subpath?(src, tgt)
-    src_normalized = Ocra.dospath(src).downcase
-    tgt_normalized = Ocra.dospath(tgt).downcase
-    src_normalized =~ /^#{Regexp.escape tgt_normalized}[\/\\]/i
-  end
-
-  # Returns true if 'path' is absolute, false otherwise.
-  def Ocra.abspath?(path)
-    path =~ /\A[A-Z]:/i
-  end
-
   # Guess the load path (from 'paths') that was used to load
   # 'path'. This is primarily relevant on Ruby 1.8 which stores
   # "unqualified" paths in $LOADED_FEATURES.
-  def Ocra.find_load_path(paths, path)
-    if abspath?(path)
-      # Find the shortest path in 'paths' that contain 'path'
-      rps = paths.map {|p| relative_path(File.expand_path(p), path) }
-      rps.zip(paths).sort_by {|x| x[0].size }.first[1]
+  def Ocra.find_load_path(loadpaths, feature)
+    if feature.absolute?
+      # Choose those loadpaths which contain the feature
+      candidate_loadpaths = loadpaths.select { |loadpath| feature.subpath?(loadpath.expand) }
+      # Guess the require'd feature
+      feature_pairs = candidate_loadpaths.map { |loadpath| [loadpath, feature.relative_path_from(loadpath.expand)] }
+      # Select the shortest possible require-path (longest load-path)
+      if feature_pairs.empty?
+        nil
+      else
+        feature_pairs.sort_by { |loadpath, feature| feature.path.size }.first[0]
+      end
     else
-      # Select the paths that contain 'path' and select the shortest
-      candidates = paths.select { |p| File.exist?(File.expand_path(path, p)) }
-      candidates.sort_by {|p| p.size}.last
+      # Select the loadpaths that contain 'feature' and select the shortest
+      candidates = loadpaths.select { |loadpath| feature.expand(loadpath).exist? }
+      candidates.sort_by { |loadpath| loadpath.path.size }.last
     end
   end
-
+  
   # Find the root of all files specified on the command line and use
   # it as the "src" of the output.
   def Ocra.find_src_root(files)
-    src_files = files.map { |file| Dir[posixpath(file)] }.flatten
-    src_files = src_files.map { |file| File.expand_path(file) }
-    src_prefix = src_files.inject(File.dirname(src_files[0])) do |srcroot, path|
-      if subpath?(path, @ruby_exec_prefix)
+    src_files = files.map { |file| file.expand }
+    src_prefix = src_files.inject(src_files.first.dirname) do |srcroot, path|
+      if path.subpath?(Host.exec_prefix)
         srcroot
       else
         loop do
-          relpath = relative_path(srcroot, path)
-          if abspath?(relpath)
-            puts "ERROR: No common directory contains all specified files"
+          relpath = path.relative_path_from(srcroot)
+          if relpath.absolute?
+            Ocra.fatal_error "No common directory contains all specified files"
           end
-          if relpath =~ /^\.\.\//
-            srcroot = File.dirname(srcroot)
+          if relpath.to_s =~ /^\.\.\//
+            srcroot = srcroot.dirname
           else
             break
           end
@@ -261,7 +422,7 @@ EOF
         srcroot
       end
     end
-    src_files = src_files.map { |file| relative_path(src_prefix, file) }
+    src_files = src_files.map { |file| file.relative_path_from(src_prefix) }
     return src_prefix, src_files
   end
 
@@ -273,43 +434,65 @@ EOF
   # file from a gem path.
   def Ocra.find_gem_files(features)
     features_from_gems = []
+    gems = []
+
+    # If a Bundler Gemfile was provided, add all gems it specifies
+    if Ocra.gemfile
+      Ocra.msg "Scanning Gemfile"
+      # Load Rubygems and Bundler so we can scan the Gemfile
+      ['rubygems', 'bundler'].each do |lib|
+        begin
+          require lib
+        rescue LoadError
+          Ocra.fatal_error "Couldn't scan Gemfile, unable to load #{lib}"
+        end
+      end
+
+      ENV['BUNDLE_GEMFILE'] = Ocra.gemfile
+      Bundler.load.specs.each do |spec|
+        gems << [Pathname(spec.installation_path), spec.full_name]
+      end
+    end
+
     if defined?(Gem)
-      gems = []
-      features.each do |filename|
-        if filename !~ /^[a-z]:/i
-          filename = find_load_path($:, filename)
-          next if filename.nil? # Could be enumerator.so
+      features.each do |feature|
+        if not feature.absolute?
+          feature = find_load_path(Pathname($:), feature)
+          next if feature.nil? # Could be enumerator.so
         end
-        Gem.path.each do |gempath|
-          geminstallpath = File.join(gempath, "gems")
-          if subpath?(filename, geminstallpath)
-            gemlocalpath = relative_path(geminstallpath, filename)
-            fullgemname = gemlocalpath.split('/')[0]
+        gempaths = Pathname(Gem.path)
+        gempaths.each do |gempath|
+          geminstallpath = Pathname(gempath) / "gems"
+          if feature.subpath?(geminstallpath)
+            gemlocalpath = feature.relative_path_from(geminstallpath)
+            fullgemname = gemlocalpath.path.split('/').first
             gems << [gempath, fullgemname]
-            features_from_gems << filename
+            features_from_gems << feature
           end
         end
       end
-      gems.sort!.uniq!
+
+      gems = sort_uniq(gems)
       gem_files = []
       gems.each do |gempath, fullgemname|
-        gemspecpath = File.join(gempath, "specifications", fullgemname + ".gemspec")
+        gemspecpath = gempath / 'specifications' / "#{fullgemname}.gemspec"
         @gemspecs << gemspecpath
         spec = Gem::Specification.load(gemspecpath)
+        Ocra.msg "Will include gem #{spec.full_name}"
 
         # Get list of files
-        files = spec.files
+        files = Pathname(spec.files)
         # Filter out some unlikely files (Readme, etc.)
         files = files.select { |filename| filename !~ IGNORE_GEMFILES } if Ocra.gem_filter
         # Find the full path
-        files = files.map { |file| File.join(gempath, "gems", fullgemname, file) }
+        files = files.map { |file| (gempath / "gems" / fullgemname / file).expand }
         # Filter out non-files
-        files = files.select { |file| File.file?(file) }
+        files = files.select { |file| file.file? }
         
         gem_files += files
       end
-      gem_files.sort!.uniq!
-      features -= features_from_gems
+      gem_files = sort_uniq(gem_files)
+      features -= features_from_gems # FIXME Isn't this duplicated by caller?
     else
       gem_files = []
     end
@@ -317,112 +500,158 @@ EOF
   end
   
   def Ocra.build_exe
-    @added_load_paths = $LOAD_PATH - @load_path_before
+    all_load_paths = $LOAD_PATH.map { |loadpath| Pathname(loadpath).expand }
+    @added_load_paths = ($LOAD_PATH - @load_path_before).map { |loadpath| Pathname(loadpath).expand }
+    working_directory = Pathname.pwd.expand
 
     restore_environment
-    
-    # Attempt to autoload libraries before doing anything else.
-    attempt_load_autoload if Ocra.load_autoload
-
-    # Store the currently loaded files (before we require rbconfig for
-    # our own use).
-    features = $LOADED_FEATURES.dup
+      
+    features = []
+    # If the script was ran, then detect the features it used 
+    if Ocra.run_script
+      # Attempt to autoload libraries before doing anything else.
+      attempt_load_autoload if Ocra.load_autoload
+
+      # Store the currently loaded files (before we require rbconfig for
+      # our own use).
+      features = $LOADED_FEATURES.map { |feature| Pathname(feature) }
+      features.delete_if { |feature| feature =~ IGNORE_MODULES }
+    end
 
     # Find gemspecs to include
     if defined?(Gem)
-      @gemspecs = Gem.loaded_specs.map { |name,info| info.loaded_from }
+      @gemspecs = Gem.loaded_specs.map { |name,info| Pathname(info.loaded_from) }
     else
       @gemspecs = []
     end
 
     require 'rbconfig'
-    @ruby_exec_prefix = RbConfig::CONFIG['exec_prefix']
-    src_prefix = Dir.pwd
-    sitelibdir = RbConfig::CONFIG['sitelibdir']
-    bindir = RbConfig::CONFIG['bindir']
-    libruby_so = RbConfig::CONFIG['LIBRUBY_SO']
-    instsitelibdir = relative_path(@ruby_exec_prefix, sitelibdir)
+    instsitelibdir = Host.sitelibdir.relative_path_from(Host.exec_prefix)
 
     load_path = []
-
-    # Find the source root and adjust paths
-    src_prefix, src_files = find_src_root(Ocra.files)
-    Ocra.files.replace(src_files)
+    src_load_path = []
 
     # Find gems files and remove them from features
     gem_files, features_from_gems = find_gem_files(features)
     features -= features_from_gems
 
+    # Find the source root and adjust paths
+    src_prefix, src_files = find_src_root(Ocra.files)
+
     # Find features and decide where to put them in the temporary
     # directory layout.
     libs = []
-    features.each do |filename|
-      path = find_load_path($:, filename)
-      if path
-        if abspath?(filename)
-          filename = relative_path(File.expand_path(path), filename)
-        end
-        if filename =~ /^\.\.\//
-          puts "=== WARNING: Detected a relative require (#{filename}). This is not recommended." if Ocra.show_warnings
+    features.each do |feature|
+      path = find_load_path(all_load_paths, feature)
+      if path.nil? || path.expand == Pathname.pwd
+        Ocra.files << feature
+      else
+        if feature.absolute?
+          feature = feature.relative_path_from(path.expand)
         end
-        fullpath = File.expand_path(filename, path)
-        if subpath?(fullpath, @ruby_exec_prefix)
-          libs << [ fullpath, relative_path(@ruby_exec_prefix, fullpath) ]
-        elsif subpath?(fullpath, src_prefix)
-          targetpath = File.join("src", relative_path(src_prefix, fullpath))
-          libs << [ fullpath, targetpath ]
-          if not @added_load_paths.include?(path) and not load_path.include?(path)
-            load_path << File.join(TEMPDIR_MARKER, File.dirname(targetpath))
-          end
-        elsif defined?(Gem) and gemhome = Gem.path.find { |pth| subpath?(fullpath, pth) }
-          targetpath = File.join("gemhome", relative_path(gemhome, fullpath))
+        fullpath = feature.expand(path)
+        
+        if fullpath.subpath?(Host.exec_prefix)
+          # Features found in the Ruby installation are put in the
+          # temporary Ruby installation.
+          libs << [ fullpath, fullpath.relative_path_from(Host.exec_prefix) ]
+        elsif defined?(Gem) and gemhome = Gem.path.find { |pth| fullpath.subpath?(pth) }
+          # Features found in any other Gem path (e.g. ~/.gems) is put
+          # in a special 'gemhome' folder.
+          targetpath = GEMHOMEDIR / fullpath.relative_path_from(gemhome)
           libs << [ fullpath, targetpath ]
+        elsif fullpath.subpath?(src_prefix) || path == working_directory
+          # Any feature found inside the src_prefix automatically gets
+          # added as a source file (to go in 'src').
+          Ocra.files << fullpath
+          # Add the load path unless it was added by the script while
+          # running (or we assume that the script can also set it up
+          # correctly when running from the resulting executable).
+          src_load_path << path unless @added_load_paths.include?(path)
+        elsif @added_load_paths.include?(path)
+          # Any feature that exist in a load path added by the script
+          # itself is added as a file to go into the 'src' (src_prefix
+          # will be adjusted below to point to the common parent).
+          Ocra.files << fullpath
         else
-          libs << [ fullpath, File.join(instsitelibdir, filename) ]
+          # All other feature that can not be resolved go in the the
+          # Ruby sitelibdir. This is automatically in the load path
+          # when Ruby starts.
+          libs << [ fullpath, instsitelibdir / feature ]
         end
-      else
-        puts "=== WARNING: Couldn't find #{filename}" unless filename =~ IGNORE_MODULES if Ocra.show_warnings
       end
     end
 
+    # Recompute the src_prefix. Files may have been added implicitly
+    # while scanning through features.
+    src_prefix, src_files = find_src_root(Ocra.files)
+    Ocra.files.replace(src_files)
+
+    # Add the load path that are required with the correct path after
+    # src_prefix was adjusted.
+    load_path += src_load_path.map { |loadpath| TEMPDIR_ROOT / SRCDIR / loadpath.relative_path_from(src_prefix) }
+
     # Decide where to put gem files, either the system gem folder, or
     # GEMHOME.
     gem_files.each do |gemfile|
-      if subpath?(gemfile, @ruby_exec_prefix)
-        libs << [ gemfile, relative_path(@ruby_exec_prefix, gemfile) ]
-      elsif defined?(Gem) and gemhome = Gem.path.find { |pth| subpath?(gemfile, pth) }
-        targetpath = File.join("gemhome", relative_path(gemhome, fullpath))
+      if gemfile.subpath?(Host.exec_prefix)
+        libs << [ gemfile, gemfile.relative_path_from(Host.exec_prefix) ]
+      elsif defined?(Gem) and gemhome = Gem.path.find { |pth| gemfile.subpath?(pth) }
+        targetpath = GEMHOMEDIR / fullpath.relative_path_from(gemhome)
         libs << [ gemfile, targetpath ]
       else
-        raise "Don't know where to put #{gemfile}"
+        Ocra.fatal_error "Don't know where to put gemfile #{gemfile}"
+      end
+    end
+
+    # If requested, add all ruby standard libraries
+    if Ocra.add_all_core
+      Ocra.msg "Will include all ruby core libraries"
+      @load_path_before.each do |lp|
+        path = Pathname.new(lp)
+        next unless path.to_posix =~
+          /\/(ruby\/(?:site_ruby\/|vendor_ruby\/)?[0-9.]+)\/?$/i
+        subdir = $1
+        Dir["#{lp}/**/*"].each do |f|
+          fpath = Pathname.new(f)
+          next if fpath.directory?
+          tgt = "lib/#{subdir}/#{fpath.relative_path_from(path).to_posix}"
+          libs << [f, tgt]
+        end
       end
     end
 
     # Detect additional DLLs
     dlls = Ocra.autodll ? LibraryDetector.detect_dlls : []
 
-    executable = File.basename(Ocra.files[0].sub(/(\.rbw?)?$/, '.exe'))
+    executable = nil
+    if Ocra.output_override
+      executable = Ocra.output_override
+    else
+      executable = Ocra.files.first.basename.ext('.exe')
+      executable.append_to_filename!("-debug") if Ocra.debug
+    end
 
-    windowed = (Ocra.files[0] =~ /\.rbw$/ || Ocra.force_windows) && !Ocra.force_console
+    windowed = (Ocra.files.first.ext?('.rbw') || Ocra.force_windows) && !Ocra.force_console
 
-    puts "=== Building #{executable}" unless Ocra.quiet
+    Ocra.msg "Building #{executable}"
     target_script = nil
     OcraBuilder.new(executable, windowed) do |sb|
       # Add explicitly mentioned files
+      Ocra.msg "Adding user-supplied source files"
       Ocra.files.each do |file|
-        file = File.join(src_prefix, file)
-
-        if subpath?(file, @ruby_exec_prefix)
-          target = relative_path(@ruby_exec_prefix, file)
-        elsif subpath?(file, src_prefix)
-          target = File.join('src', relative_path(src_prefix, file))
+        file = src_prefix / file
+        if file.subpath?(Host.exec_prefix)
+          target = file.relative_path_from(Host.exec_prefix)
+        elsif file.subpath?(src_prefix)
+          target = SRCDIR / file.relative_path_from(src_prefix)
         else
-          target = File.join('src', File.basename(file))
+          target = SRCDIR / file.basename
         end
 
         target_script ||= target
 
-        if File.directory?(file)
+        if file.directory?
           sb.ensuremkdir(target)
         else
           sb.createfile(file, target)
@@ -431,61 +660,68 @@ EOF
 
       # Add the ruby executable and DLL
       if windowed
-        rubyexe = (RbConfig::CONFIG['rubyw_install_name'] || "rubyw") + ".exe"
+        rubyexe = Host.rubyw_exe
       else
-        rubyexe = (RbConfig::CONFIG['ruby_install_name'] || "ruby") + ".exe"
+        rubyexe = Host.ruby_exe
       end
-      sb.createfile(File.join(bindir, rubyexe), File.join("bin", rubyexe))
-      if libruby_so
-        sb.createfile(File.join(bindir, libruby_so), File.join("bin", libruby_so))
+      Ocra.msg "Adding ruby executable #{rubyexe}"
+      sb.createfile(Host.bindir / rubyexe, BINDIR / rubyexe)
+      if Host.libruby_so
+        sb.createfile(Host.bindir / Host.libruby_so, BINDIR / Host.libruby_so)
       end
 
       # Add detected DLLs
       dlls.each do |dll|
-        if subpath?(dll, @ruby_exec_prefix)
-          target = relative_path(@ruby_exec_prefix, dll)
+        Ocra.msg "Adding detected DLL #{dll}"
+        if dll.subpath?(Host.exec_prefix)
+          target = dll.relative_path_from(Host.exec_prefix)
         else
-          target = File.join('bin', File.basename(dll))
+          target = BINDIR / File.basename(dll)
         end
         sb.createfile(dll, target)
       end
       
       # Add extra DLLs specified on the command line
       Ocra.extra_dlls.each do |dll|
-        sb.createfile(File.join(bindir, dll), File.join("bin", dll))
+        Ocra.msg "Adding supplied DLL #{dll}"
+        sb.createfile(Host.bindir / dll, BINDIR / dll)
       end
       
       # Add gemspec files
+      @gemspecs = sort_uniq(@gemspecs)
       @gemspecs.each do |gemspec|
-        if subpath?(gemspec, @ruby_exec_prefix)
-          path = relative_path(@ruby_exec_prefix, gemspec)
+        if gemspec.subpath?(Host.exec_prefix)
+          path = gemspec.relative_path_from(Host.exec_prefix)
           sb.createfile(gemspec, path)
-        elsif defined?(Gem) and gemhome = Gem.path.find { |pth| subpath?(gemspec, pth) }
-          path = File.join('gemhome', relative_path(gemhome, gemspec))
+        elsif defined?(Gem) and gemhome = Gem.path.find { |pth| gemspec.subpath?(pth) }
+          path = GEMHOMEDIR / gemspec.relative_path_from(gemhome)
           sb.createfile(gemspec, path)
         else
-          raise "#{gemspec} does not exist in the Ruby installation. Don't know where to put it."
+          Ocra.fatal_error "Gem spec #{gemspec} does not exist in the Ruby installation. Don't know where to put it."
         end
       end
 
       # Add loaded libraries (features, gems)
+      Ocra.msg "Adding library files"
       libs.each do |path, target|
         sb.createfile(path, target)
       end
 
       # Set environment variable
       sb.setenv('RUBYOPT', ENV['RUBYOPT'] || '')
-      sb.setenv('RUBYLIB', load_path.map{|path| dospath(path)}.uniq.join(';'))
-      sb.setenv('GEM_PATH', "#{TEMPDIR_MARKER}\\gemhome")
-
-      # Launch the script
-      extra_arg = Ocra.arg.map { |a| ' "' + a.gsub(/\"/,'\\"') + '"' }.join
-      sb.postcreateprocess(TEMPDIR_MARKER + "\\bin\\" + rubyexe,
-        "#{rubyexe} \"\xff\\" + Ocra.dospath(target_script) + "\"#{extra_arg}")
+      sb.setenv('RUBYLIB', load_path.map{|path| path.to_native}.uniq.join(';'))
+      sb.setenv('GEM_PATH', (TEMPDIR_ROOT / GEMHOMEDIR).to_native)
+
+      # Add the opcode to launch the script
+      extra_arg = Ocra.arg.map { |arg| ' "' + arg.gsub(/\"/,'\\"') + '"' }.join
+      installed_ruby_exe = TEMPDIR_ROOT / BINDIR / rubyexe
+      launch_script = (TEMPDIR_ROOT / target_script).to_native
+      sb.postcreateprocess(installed_ruby_exe,
+        "#{rubyexe} \"#{launch_script}\"#{extra_arg}")
       
-      puts "=== Compressing" unless Ocra.quiet or not Ocra.lzma_mode
+      Ocra.msg "Compressing" unless not Ocra.lzma_mode
     end
-    puts "=== Finished building #{executable} (#{File.size(executable)} bytes)" unless Ocra.quiet
+    Ocra.msg "Finished building #{executable} (#{File.size(executable)} bytes)"
   end
 
   module LibraryDetector
@@ -508,21 +744,17 @@ EOF
       end
       
       handles = module_handle_buffer.unpack("I*")
-      handles.select{|x|x>0}.map do |h|
+      handles.select { |handle| handle > 0 }.map do |handle|
         str = "\x00" * 256
-        r = getmodulefilename.call(h, str, str.size)
-        str[0,r]
+        modulefilename_length = getmodulefilename.call(handle, str, str.size)
+        Ocra.Pathname(str[0,modulefilename_length])
       end
     end
 
     def LibraryDetector.detect_dlls
       loaded = loaded_dlls
-      exec_prefix = RbConfig::CONFIG['exec_prefix']
-      loaded.select do |path|
-        Ocra.subpath?(path, exec_prefix) and
-          File.basename(path) =~ /\.dll$/i and
-          File.basename(path).downcase != RbConfig::CONFIG['LIBRUBY_SO'].downcase
-      end
+      exec_prefix = Host.exec_prefix
+      loaded.select { |path| path.subpath?(exec_prefix) && path.basename.ext?('.dll') && path.basename != Host.libruby_so }
     end
   end
 
@@ -530,15 +762,32 @@ EOF
   # (createfile, mkdir etc) are added by invoking methods on an
   # instance of OcraBuilder.
   class OcraBuilder
+    Signature = [0x41, 0xb6, 0xba, 0x4e]
+    OP_END = 0
+    OP_CREATE_DIRECTORY = 1
+    OP_CREATE_FILE = 2
+    OP_CREATE_PROCESS = 3
+    OP_DECOMPRESS_LZMA = 4
+    OP_SETENV = 5
+    OP_POST_CREATE_PROCESS = 6
+    OP_ENABLE_DEBUG_MODE = 7
+    OP_CREATE_INST_DIRECTORY = 8
+
     def initialize(path, windowed)
       @paths = {}
+      @files = {}
       File.open(path, "wb") do |ocrafile|
-
+        image = nil
         if windowed
-          ocrafile.write(Ocra.stubwimage)
+          image = Ocra.stubwimage
         else
-          ocrafile.write(Ocra.stubimage)
+          image = Ocra.stubimage
         end
+
+        unless image
+          Ocra.fatal_error "Stub image not available"
+        end
+        ocrafile.write(image)
       end
 
       if Ocra.icon_filename
@@ -555,6 +804,12 @@ EOF
           @of = ocrafile
         end
 
+        if Ocra.debug
+          ocrafile.write([OP_ENABLE_DEBUG_MODE].pack("V"))
+        end
+
+        createinstdir Ocra.debug_extract, !Ocra.debug_extract
+
         yield(self)
 
         if Ocra.lzma_mode
@@ -563,7 +818,6 @@ EOF
             system("\"#{Ocra.lzmapath}\" e tmpin tmpout 2>NUL") or fail
             compressed_data = File.open("tmpout", "rb") { |tmp| tmp.read }
             ocrafile.write([OP_DECOMPRESS_LZMA, compressed_data.size, compressed_data].pack("VVA*"))
-            ocrafile.write([OP_END].pack("V"))
           ensure
             File.unlink("tmpin") if File.exist?("tmpin")
             File.unlink("tmpout") if File.exist?("tmpout")
@@ -579,38 +833,47 @@ EOF
     end
 
     def mkdir(path)
-      @paths[path.downcase] = true
-      puts "m #{showtempdir path}" unless Ocra.quiet
-      @of << [OP_CREATE_DIRECTORY, Ocra.dospath(path)].pack("VZ*")
+      return if @paths[path.path.downcase]
+      @paths[path.path.downcase] = true
+      Ocra.verbose_msg "m #{showtempdir path}"
+      @of << [OP_CREATE_DIRECTORY, path.to_native].pack("VZ*")
     end
 
     def ensuremkdir(tgt)
-      return if tgt == "."
-      if not @paths[Ocra.posixpath(tgt.downcase)]
-        ensuremkdir(File.dirname(tgt))
+      tgt = Ocra.Pathname(tgt)
+      return if tgt.path == "."
+      if not @paths[tgt.to_posix.downcase]
+        ensuremkdir(tgt.dirname)
         mkdir(tgt)
       end
     end
 
+    def createinstdir(next_to_exe = false, delete_after = false)
+      @of << [OP_CREATE_INST_DIRECTORY, next_to_exe ? 1 : 0, delete_after ? 1 : 0].pack("VVV")
+    end
+
     def createfile(src, tgt)
-      ensuremkdir(File.dirname(tgt))
+      return if @files[tgt]
+      @files[tgt] = true
+      src, tgt = Ocra.Pathname(src), Ocra.Pathname(tgt)
+      ensuremkdir(tgt.dirname)
       str = File.open(src, "rb") { |file| file.read }
-      puts "a #{showtempdir tgt}" unless Ocra.quiet
-      @of << [OP_CREATE_FILE, Ocra.dospath(tgt), str.size, str].pack("VZ*VA*")
+      Ocra.verbose_msg "a #{showtempdir tgt}"
+      @of << [OP_CREATE_FILE, tgt.to_native, str.size, str].pack("VZ*VA*")
     end
 
     def createprocess(image, cmdline)
-      puts "l #{showtempdir image} #{showtempdir cmdline}" unless Ocra.quiet
-      @of << [OP_CREATE_PROCESS, Ocra.dospath(image), cmdline].pack("VZ*Z*")
+      Ocra.verbose_msg "l #{showtempdir image} #{showtempdir cmdline}"
+      @of << [OP_CREATE_PROCESS, image.to_native, cmdline].pack("VZ*Z*")
     end
 
     def postcreateprocess(image, cmdline)
-      puts "p #{showtempdir image} #{showtempdir cmdline}" unless Ocra.quiet
-      @of << [OP_POST_CREATE_PROCESS, Ocra.dospath(image), cmdline].pack("VZ*Z*")
+      Ocra.verbose_msg "p #{showtempdir image} #{showtempdir cmdline}"
+      @of << [OP_POST_CREATE_PROCESS, image.to_native, cmdline].pack("VZ*Z*")
     end
 
     def setenv(name, value)
-      puts "e #{name} #{showtempdir value}" unless Ocra.quiet
+      Ocra.verbose_msg "e #{name} #{showtempdir value}"
       @of << [OP_SETENV, name, value].pack("VZ*Z*")
     end
 
@@ -619,9 +882,9 @@ EOF
     end
 
     def showtempdir(x)
-      x.gsub(TEMPDIR_MARKER, "<tempdir>")
+      x.to_s.gsub(TEMPDIR_ROOT, "<tempdir>")
     end
-      
+    
   end # class OcraBuilder
   
 end # module Ocra
@@ -630,19 +893,20 @@ if File.basename(__FILE__) == File.basename($0)
   Ocra.init(ARGV)
   ARGV.replace(Ocra.arg)
 
-  if !File.exist?(Ocra.files[0])
-    puts "ERROR: #{Ocra.files[0]} was not found!"
-    exit
+  if not Ocra.files.first.exist?
+    Ocra.fatal_error "#{Ocra.files[0]} was not found!"
   end
   
   at_exit do
     if $!.nil? or $!.kind_of?(SystemExit)
       Ocra.build_exe
-      exit(0)
+      exit 0
     end
   end
 
-  puts "=== Loading script to check dependencies" unless Ocra.quiet
-  $0 = Ocra.files[0]
-  load Ocra.files[0]
+  if Ocra.run_script
+    Ocra.msg "Loading script to check dependencies"
+    $0 = Ocra.files.first
+    load Ocra.files.first
+  end
 end