ocra 1.1.5.pre2 → 1.1.5.pre3

data/History.txt

@@ -17,6 +17,16 @@
   include all files listed in the Gem specification (Thanks to Jorge
   L. Cangas for patch & ideas).
 
+* NameErrors are now rescued when attempting to load autoloadable
+  constants. Hopefully resolves issues with ActiveRecord [#28488].
+
+* Now works if the script changes environment or working directory
+  while running.
+
+* Fixed a regression in 1.1.4 when resource files are specified;
+  directory layout would not be maintained, e.g. when running "ocra
+  bin/script share/data.dat".
+
 === 1.1.4
 
 * The tempdir marker is now pretty-printed as "<tempdir>" in the

data/README.txt

@@ -23,11 +23,6 @@ the tracker on the RubyForge project page
 http://rubyforge.org/projects/ocra/. You are welcome to ask questions
 in the forums there aswell.
 
-== TODO:
-
-* Support for packaging gems that need extra non-ruby files
-  (e.g. mime-types, prawn).
-
 == SYNOPSIS:
 
   ocra [option] script.rb
@@ -80,7 +75,6 @@ in the forums there aswell.
 
 * Avoid absolute paths in your code and when invoking OCRA.
 
-
 == REQUIREMENTS:
 
 * Windows
@@ -119,7 +113,18 @@ your application will be put in the 'src' subdirectory.
 
 === Libraries
 
-Rubygems will be automatically included in the OCRA executable.
+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.
+
+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.
 
 Libraries found in non-standard path (for example, if you invoke OCRA
 with "ruby -I some/path") will be placed into the site dir
@@ -128,13 +133,13 @@ with "ruby -I some/path") will be placed into the site dir
 tree, since OCRA may place the files elsewhere when extracted into the
 temporary directory.
 
-Autoloaded libraries (Kernel#autoload) will be attempted loaded when
-building the executable. Modules that doesn't exist will be ignore
-(but a warning will be logged).
+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).
 
-Conditionally loaded code will not be loaded and included in the
-executable unless the code is actually run when OCRA invokes your
-script.
+Dynamic link libraries (.dll files, for example WxWidgets, or other
+source files) will be detected and included by OCRA.
 
 === Environment variables
 
@@ -154,13 +159,16 @@ executable, for example
 
 === Working directory
 
+The OCRA executable does not change the working directory when it is
+launched.
+
 You should not assume that the current working directory when invoking
 an executable built with .exe is the location of the source script. It
 can be the directory where the executable is placed (when invoked
 through the Windows Explorer), the users' current working directory
-(when invoking from the Command Prompt), or even <tt>C:\\WINDOWS\\SYSTEM32</tt>
-when the executable is invoked through a file association. You can
-optionally change the directory yourself:
+(when invoking from the Command Prompt), or even
+<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)
 
@@ -214,6 +222,9 @@ of files, for example
 
 === Window/Console
 
+By default, OCRA builds console application from .rb-files and
+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.

data/bin/ocra

@@ -11,7 +11,7 @@ module Ocra
   OP_SETENV = 5
   OP_POST_CREATE_PROCESS = 6
 
-  VERSION = "1.1.5.pre2"
+  VERSION = "1.1.5.pre3"
 
   IGNORE_MODULES = /^enumerator.so$/
 
@@ -32,63 +32,76 @@ module Ocra
 
   TEMPDIR_MARKER = "\xFF"
 
+  @options = {
+    :lzma_mode => true,
+    :extra_dlls => [],
+    :files => [],
+    :load_autoload => true,
+    :force_windows => false,
+    :force_console => false,
+    :icon_filename => nil,
+    :quiet => false,
+    :autodll => true,
+    :show_warnings => true,
+    :gem_filter => true
+  }
+
+  @options.each_key { |opt| eval("def self.#{opt}; @options[:#{opt}]; end") }
+
   class << self
-    attr_accessor :lzma_mode
-    attr_accessor :extra_dlls
-    attr_accessor :files
-    attr_accessor :load_autoload
-    attr_accessor :force_windows
-    attr_accessor :force_console
-    attr_accessor :icon_filename
-    attr_accessor :quiet
-    attr_accessor :autodll
-    attr_accessor :show_warnings
-    attr_accessor :gem_filter
-    
     attr_reader :lzmapath
     attr_reader :ediconpath
     attr_reader :stubimage
     attr_reader :stubwimage
-    
-    def get_next_embedded_image
-      DATA.read(DATA.readline.to_i).unpack("m")[0]
-    end
   end
 
-  def Ocra.initialize_ocra
+  # Returns a binary blob store embedded in the current Ruby script.
+  def get_next_embedded_image
+    DATA.read(DATA.readline.to_i).unpack("m")[0]
+  end
+
+  def Ocra.dospath(path)
+    path.tr('/','\\')
+  end
+
+  def Ocra.posixpath(path)
+    path.tr('\\','/')
+  end
+
+  def Ocra.save_environment
     @load_path_before = $LOAD_PATH.dup
-    
+    @pwd_before = Dir.pwd
+    @env_before = {}; ENV.each { |key, value| @env_before[key] = value }
+  end
+
+  def Ocra.restore_environment
+    @env_before.each { |key, value| ENV[key] = value }
+    ENV.each_key { |key| ENV.delete(key) unless @env_before.has_key?(key) }
+    Dir.chdir @pwd_before
+  end
+
+  def Ocra.find_stubs
     if defined?(DATA)
       @stubimage = get_next_embedded_image
       @stubwimage = get_next_embedded_image
       lzmaimage = get_next_embedded_image
-      @lzmapath = File.join(ENV['TEMP'], 'lzma.exe').tr('/','\\')
+      @lzmapath = File.join(ENV['TEMP'], 'lzma.exe')
       File.open(@lzmapath, "wb") { |file| file << lzmaimage }
       ediconimage = get_next_embedded_image
-      @ediconpath = File.join(ENV['TEMP'], 'edicon.exe').tr('/','\\')
+      @ediconpath = File.join(ENV['TEMP'], '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).tr('/','\\')
-      @ediconpath = File.expand_path('../share/ocra/edicon.exe', ocrapath).tr('/','\\')
+      @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)
   end
 
   def Ocra.parseargs(argv)
-    lzma_mode = true
-    extra_dlls = []
-    files = []
-    load_autoload = true
-    force_windows = false
-    force_console = false
-    icon_filename = nil
-    quiet = false
-    autodll = true
-    show_warnings = true
-    gem_filter = true
-    
     usage = <<EOF
 ocra [options] script.rb
 
@@ -107,34 +120,34 @@ EOF
     while arg = argv.shift
       case arg
       when /\A--(no-)?lzma\z/
-        lzma_mode = !$1
+        @options[:lzma_mode] = !$1
       when /\A--dll\z/
-        extra_dlls << argv.shift
+        @options[:extra_dlls] << argv.shift
       when /\A--quiet\z/
-        quiet = true
+        @options[:quiet] = true
       when /\A--windows\z/
-        force_windows = true
+        @options[:force_windows] = true
       when /\A--console\z/
-        force_console = true
+        @options[:force_console] = true
       when /\A--no-autoload\z/
-        load_autoload = false
+        @options[:load_autoload] = false
       when /\A--icon\z/
-        icon_filename = argv.shift
+        @options[:icon_filename] = argv.shift
         raise "Icon file #{icon_filename} not found.\n" unless File.exist?(icon_filename)
       when /\A--no-autodll\z/
-        autodll = false
+        @options[:autodll] = false
       when /\A--version\z/
         puts "Ocra #{VERSION}"
         exit
       when /\A--no-warnings\z/
-        show_warnings = false
+        @options[:show_warnings] = false
       when /\A--no-gem-filter\z/
-        gem_filter = false
+        @options[:gem_filter] = false
       when /\A--help\z/, /\A--/
         puts usage
         exit
       else
-        files << arg
+        @options[:files] << arg
       end
     end
 
@@ -142,23 +155,12 @@ EOF
       puts usage
       exit
     end
-
-    @lzma_mode = lzma_mode
-    @extra_dlls = extra_dlls
-    @quiet = quiet
-    @force_windows = force_windows
-    @force_console = force_console
-    @load_autoload = load_autoload
-    @icon_filename = icon_filename
-    @autodll = autodll
-    @files = files
-    @show_warnings = show_warnings
-    @gem_filter = gem_filter
   end
 
   def Ocra.init(argv)
+    save_environment
     parseargs(argv)
-    initialize_ocra
+    find_stubs
   end
 
   # Force loading autoloaded constants. Searches through all modules
@@ -178,6 +180,8 @@ EOF
           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
             rescue LoadError
               puts "=== WARNING: #{mod}::#{const} was not loadable" if Ocra.show_warnings
             end
@@ -187,6 +191,9 @@ 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 = src.split('/')
     b = tgt.split('/')
@@ -202,11 +209,14 @@ EOF
   # 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 = src.tr('/','\\')
-    tgt_normalized = tgt.tr('/','\\')
+    src_normalized = Ocra.dospath(src).downcase
+    tgt_normalized = Ocra.dospath(tgt).downcase
     src_normalized =~ /^#{Regexp.escape tgt_normalized}[\/\\]/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 path[1,1] == ":"
       rps = paths.map {|p| relative_path(File.expand_path(p), path) }
@@ -219,6 +229,8 @@ EOF
   
   def Ocra.build_exe
     @added_load_paths = $LOAD_PATH - @load_path_before
+
+    restore_environment
     
     # Attempt to autoload libraries before doing anything else.
     attempt_load_autoload if Ocra.load_autoload
@@ -236,12 +248,38 @@ EOF
 
     require 'rbconfig'
     exec_prefix = RbConfig::CONFIG['exec_prefix']
-    src_prefix = File.expand_path(File.dirname(Ocra.files[0]))
+    src_prefix = Dir.pwd
     sitelibdir = RbConfig::CONFIG['sitelibdir']
     bindir = RbConfig::CONFIG['bindir']
     libruby_so = RbConfig::CONFIG['LIBRUBY_SO']
 
-    instsitelibdir = sitelibdir[exec_prefix.size+1..-1]
+    # Find the root of all files specified on the command line and use
+    # it as the "src" of the output. Adjust 'Ocra.files' to be
+    # relative to the resulting root.
+    files = Ocra.files.map { |file| Dir[Ocra.posixpath(file)] }.flatten
+    files = files.map { |file| File.expand_path(file) }
+    src_prefix = files.inject(File.dirname(files[0])) do |srcroot, path|
+      if subpath?(path, exec_prefix)
+        srcroot
+      else
+        loop do
+          relpath = relative_path(srcroot, path)
+          if relpath =~ /^[A-Z]:$/i
+            puts "ERROR: No common directory contains all specified files"
+          end
+          if relpath =~ /^\.\.\//
+            srcroot = File.dirname(srcroot)
+          else
+            break
+          end
+        end
+        srcroot
+      end
+    end
+    files = files.map { |file| relative_path(src_prefix, file) }
+    Ocra.files.replace(files)
+
+    instsitelibdir = relative_path(exec_prefix, sitelibdir)
 
     load_path = []
 
@@ -260,7 +298,7 @@ EOF
         Gem.path.each do |gempath|
           geminstallpath = File.join(gempath, "gems")
           if subpath?(filename, geminstallpath)
-            gemlocalpath = filename[geminstallpath.size+1..-1]
+            gemlocalpath = relative_path(geminstallpath, filename)
             fullgemname = gemlocalpath.split('/')[0]
             gems << [gempath, fullgemname]
             features_from_gems << filename
@@ -304,9 +342,9 @@ EOF
         end
         fullpath = File.expand_path(filename, path)
         if subpath?(fullpath, exec_prefix)
-          libs << [ fullpath, fullpath[exec_prefix.size+1..-1] ]
+          libs << [ fullpath, relative_path(exec_prefix, fullpath) ]
         elsif subpath?(fullpath, src_prefix)
-          targetpath = "src/" + fullpath[src_prefix.size+1..-1]
+          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))
@@ -344,8 +382,8 @@ EOF
     puts "=== Building #{executable}" unless Ocra.quiet
     OcraBuilder.new(executable, windowed) do |sb|
       # Add explicitly mentioned files
-      Ocra.files.each do |file|
-        file = File.expand_path(file)
+      files.each do |file|
+        file = File.join(src_prefix, file)
 
         if subpath?(file, exec_prefix)
           target = relative_path(exec_prefix, file)
@@ -355,8 +393,6 @@ EOF
           target = File.join('src', File.basename(file))
         end
 
-        target.tr!('/','\\')
-        
         if File.directory?(file)
           sb.ensuremkdir(target)
         else
@@ -370,15 +406,15 @@ EOF
       else
         rubyexe = (RbConfig::CONFIG['ruby_install_name'] || "ruby") + ".exe"
       end
-      sb.createfile(File.join(bindir, rubyexe), "bin\\" + rubyexe)
+      sb.createfile(File.join(bindir, rubyexe), File.join("bin", rubyexe))
       if libruby_so
-        sb.createfile(File.join(bindir, libruby_so), "bin\\#{libruby_so}")
+        sb.createfile(File.join(bindir, libruby_so), File.join("bin", libruby_so))
       end
 
       # Add detected DLLs
       dlls.each do |dll|
-        if subpath?(dll.tr('\\','/'), exec_prefix)
-          target = dll[exec_prefix.size+1..-1]
+        if subpath?(dll, exec_prefix)
+          target = relative_path(exec_prefix, dll)
         else
           target = File.join('bin', File.basename(dll))
         end
@@ -387,17 +423,17 @@ EOF
       
       # Add extra DLLs
       Ocra.extra_dlls.each do |dll|
-        sb.createfile(File.join(bindir, dll), File.join("bin", dll).tr('/','\\'))
+        sb.createfile(File.join(bindir, dll), File.join("bin", dll))
       end
       
       # Add gemspec files
       gemspecs.each do |gemspec|
         if subpath?(gemspec, exec_prefix)
-          path = gemspec[exec_prefix.size+1..-1]
-          sb.createfile(gemspec, path.tr('/','\\'))
+          path = relative_path(exec_prefix, gemspec)
+          sb.createfile(gemspec, path)
         elsif defined?(Gem) and gemhome = Gem.path.find { |pth| subpath?(gemspec, pth) }
           path = File.join('gemhome', relative_path(gemhome, gemspec))
-          sb.createfile(gemspec, path.tr('/','\\'))
+          sb.createfile(gemspec, path)
         else
           raise "#{gemspec} does not exist in the Ruby installation. Don't know where to put it."
         end
@@ -405,7 +441,7 @@ EOF
 
       # Add loaded libraries
       libs.each do |path, target|
-        sb.createfile(path, target.tr('/', '\\'))
+        sb.createfile(path, target)
       end
 
       # Set environment variable
@@ -414,7 +450,7 @@ EOF
       sb.setenv('GEM_PATH', "#{TEMPDIR_MARKER}\\gemhome")
 
       # Launch the script
-      sb.postcreateprocess(TEMPDIR_MARKER + "\\bin\\" + rubyexe, "#{rubyexe} \"\xff\\src\\" + File.basename(Ocra.files[0]) + "\"")
+      sb.postcreateprocess(TEMPDIR_MARKER + "\\bin\\" + rubyexe, "#{rubyexe} \"\xff\\src\\" + Ocra.dospath(Ocra.files[0]) + "\"")
       
       puts "=== Compressing" unless Ocra.quiet or not Ocra.lzma_mode
     end
@@ -452,13 +488,16 @@ EOF
       loaded = loaded_dlls
       exec_prefix = RbConfig::CONFIG['exec_prefix']
       loaded.select do |path|
-        Ocra.subpath?(path.tr('\\','/'), exec_prefix) and
+        Ocra.subpath?(path, exec_prefix) and
           File.basename(path) =~ /\.dll$/i and
           File.basename(path).downcase != RbConfig::CONFIG['LIBRUBY_SO'].downcase
       end
     end
   end
-  
+
+  # Utility class that produces the actual executable. Opcodes
+  # (createfile, mkdir etc) are added by invoking methods on an
+  # instance of OcraBuilder.
   class OcraBuilder
     def initialize(path, windowed)
       @paths = {}
@@ -507,36 +546,43 @@ EOF
         ocrafile.write(Signature.pack("C*"))
       end
     end
+
     def mkdir(path)
       @paths[path.downcase] = true
       puts "m #{showtempdir path}" unless Ocra.quiet
-      @of << [OP_CREATE_DIRECTORY, path].pack("VZ*")
+      @of << [OP_CREATE_DIRECTORY, Ocra.dospath(path)].pack("VZ*")
     end
+
     def ensuremkdir(tgt)
       return if tgt == "."
-      if not @paths[tgt.downcase]
+      if not @paths[Ocra.posixpath(tgt.downcase)]
         ensuremkdir(File.dirname(tgt))
         mkdir(tgt)
       end
     end
+
     def createfile(src, tgt)
       ensuremkdir(File.dirname(tgt))
       str = File.open(src, "rb") { |file| file.read }
       puts "a #{showtempdir tgt}" unless Ocra.quiet
-      @of << [OP_CREATE_FILE, tgt, str.size, str].pack("VZ*VA*")
+      @of << [OP_CREATE_FILE, Ocra.dospath(tgt), str.size, str].pack("VZ*VA*")
     end
+
     def createprocess(image, cmdline)
       puts "l #{showtempdir image} #{showtempdir cmdline}" unless Ocra.quiet
-      @of << [OP_CREATE_PROCESS, image, cmdline].pack("VZ*Z*")
+      @of << [OP_CREATE_PROCESS, Ocra.dospath(image), cmdline].pack("VZ*Z*")
     end
+
     def postcreateprocess(image, cmdline)
       puts "p #{showtempdir image} #{showtempdir cmdline}" unless Ocra.quiet
-      @of << [OP_POST_CREATE_PROCESS, image, cmdline].pack("VZ*Z*")
+      @of << [OP_POST_CREATE_PROCESS, Ocra.dospath(image), cmdline].pack("VZ*Z*")
     end
+
     def setenv(name, value)
       puts "e #{name} #{showtempdir value}" unless Ocra.quiet
       @of << [OP_SETENV, name, value].pack("VZ*Z*")
     end
+
     def close
       @of.close
     end
@@ -552,6 +598,11 @@ end # module Ocra
 if File.basename(__FILE__) == File.basename($0)
   Ocra.init(ARGV)
   ARGV.clear
+
+  if !File.exist?(Ocra.files[0])
+    puts "ERROR: #{Ocra.files[0]} was not found!"
+    exit
+  end
   
   at_exit do
     if $!.nil? or $!.kind_of?(SystemExit)

data/lib/ocra.rb

@@ -1,3 +1,3 @@
 class Ocra
-  VERSION = '1.1.5.pre2'
+  VERSION = '1.1.5.pre3'
 end

data/test/test_ocra.rb

@@ -34,6 +34,17 @@ class TestOcra < Test::Unit::TestCase
   # Path to test fixtures.
   FixturePath = File.expand_path(File.join(File.dirname(__FILE__), 'fixtures'))
 
+  # Create a pristine environment to test built executables. Files are
+  # copied and the PATH environment is set to the minimal. Yields to
+  # the block, then cleans up.
+  def pristine_env(*files)
+    with_tmpdir files do
+      with_env "PATH" => ENV["SystemRoot"] + ";" + ENV["SystemRoot"] + "\\SYSTEM32" do
+        yield
+      end
+    end
+  end
+
   attr_reader :ocra
 
   def initialize(*args)
@@ -48,13 +59,11 @@ class TestOcra < Test::Unit::TestCase
   # files located in test/fixtures.
   def with_fixture(name)
     path = File.join(FixturePath, name)
-    cp_r path, '.'
-    begin
+    with_tmpdir do
+      cp_r path, '.'
       cd name do
         yield
       end
-    ensure
-      rm_rf name
     end
   end
 
@@ -76,10 +85,11 @@ class TestOcra < Test::Unit::TestCase
     end
   end
 
-  def with_tmpdir
+  def with_tmpdir(files = [])
     tempdirname = File.join(ENV['TEMP'], ".ocratest-#{$$}-#{rand 2**32}").tr('\\','/')
     Dir.mkdir tempdirname
     begin
+      cp files, tempdirname
       FileUtils.cd tempdirname do
         yield
       end
@@ -88,35 +98,14 @@ class TestOcra < Test::Unit::TestCase
     end
   end
 
-  def with_exe(name)
-    orig_exe = File.expand_path(name)
-    with_tmpdir do
-      cp orig_exe, File.join('.', File.basename(name))
-      yield
-    end
-  end
-  
-  # Test setup method. Creates a tempory directory to work in and
-  # changes to it. 
-  def setup
-    @testnum += 1
-    @tempdirname = ".ocratest-#{$$}-#{@testnum}"
-    Dir.mkdir @tempdirname
-    Dir.chdir @tempdirname
-  end
-
-  # Test cleanup method. Exits the temporary directory and deletes it.
-  def teardown
-    Dir.chdir '..'
-    FileUtils.rm_rf @tempdirname
-  end
-
   # Hello world test. Test that we can build and run executables.
   def test_helloworld
     with_fixture 'helloworld' do
       assert system("ruby", ocra, "helloworld.rb", *DefaultArgs)
       assert File.exist?("helloworld.exe")
-      assert system("helloworld.exe")
+      pristine_env "helloworld.exe" do
+        assert system("helloworld.exe")
+      end
     end
   end
 
@@ -125,7 +114,9 @@ class TestOcra < Test::Unit::TestCase
     with_fixture 'helloworld' do
       assert system("ruby", ocra, "helloworld.rb", "--quiet", "--lzma")
       assert File.exist?("helloworld.exe")
-      assert system("helloworld.exe")
+      pristine_env "helloworld.exe" do
+        assert system("helloworld.exe")
+      end
     end
   end
   
@@ -134,10 +125,12 @@ class TestOcra < Test::Unit::TestCase
   def test_writefile
     with_fixture 'writefile' do
       assert system("ruby", ocra, "writefile.rb", *DefaultArgs)
-      assert File.exist?("writefile.exe")
-      assert system("writefile.exe")
-      assert File.exist?("output.txt")
-      assert "output", File.read("output.txt")
+      pristine_env "writefile.exe" do
+        assert File.exist?("writefile.exe")
+        assert system("writefile.exe")
+        assert File.exist?("output.txt")
+        assert "output", File.read("output.txt")
+      end
     end
   end
 
@@ -145,8 +138,10 @@ class TestOcra < Test::Unit::TestCase
   def test_exitstatus
     with_fixture 'exitstatus' do
       assert system("ruby", ocra, "exitstatus.rb", *DefaultArgs)
-      system("exitstatus.exe")
-      assert_equal 167, $?.exitstatus
+      pristine_env "exitstatus.exe" do
+        system("exitstatus.exe")
+        assert_equal 167, $?.exitstatus
+      end
     end
   end
 
@@ -155,8 +150,10 @@ class TestOcra < Test::Unit::TestCase
     with_fixture 'arguments' do
       assert system("ruby", ocra, "arguments.rb", *DefaultArgs)
       assert File.exist?("arguments.exe")
-      system("arguments.exe foo \"bar baz\"")
-      assert_equal 5, $?.exitstatus
+      pristine_env "arguments.exe" do
+        system("arguments.exe foo \"bar baz\"")
+        assert_equal 5, $?.exitstatus
+      end
     end
   end
 
@@ -166,9 +163,11 @@ class TestOcra < Test::Unit::TestCase
     with_fixture 'stdoutredir' do
       assert system("ruby", ocra, "stdoutredir.rb", *DefaultArgs)
       assert File.exist?("stdoutredir.exe")
-      system("stdoutredir.exe > output.txt")
-      assert File.exist?("output.txt")
-      assert_equal "Hello, World!\n", File.read("output.txt")
+      pristine_env "stdoutredir.exe" do
+        system("stdoutredir.exe > output.txt")
+        assert File.exist?("output.txt")
+        assert_equal "Hello, World!\n", File.read("output.txt")
+      end
     end
   end
 
@@ -178,8 +177,11 @@ class TestOcra < Test::Unit::TestCase
     with_fixture 'stdinredir' do
       assert system("ruby", ocra, "stdinredir.rb", *DefaultArgs)
       assert File.exist?("stdinredir.exe")
-      system("stdinredir.exe < input.txt")
-      assert 104, $?.exitstatus
+      # Kernel.system("ruby -e \"system 'stdinredir.exe<input.txt';p $?\"")
+      pristine_env "stdinredir.exe", "input.txt" do
+        system("stdinredir.exe < input.txt")
+      end
+      assert_equal 104, $?.exitstatus
     end
   end
 
@@ -197,8 +199,10 @@ class TestOcra < Test::Unit::TestCase
     with_fixture 'gdbmdll' do
       assert system("ruby", ocra, "gdbmdll.rb", *args)
       with_env 'PATH' => '.' do
-        system("gdbmdll.exe")
-        assert_equal 104, $?.exitstatus
+        pristine_env "gdbmdll.exe" do
+          system("gdbmdll.exe")
+          assert_equal 104, $?.exitstatus
+        end
       end
     end
   end
@@ -210,8 +214,10 @@ class TestOcra < Test::Unit::TestCase
     with_fixture 'relativerequire' do
       assert system("ruby", ocra, "relativerequire.rb", *DefaultArgs)
       assert File.exist?("relativerequire.exe")
-      system("relativerequire.exe")
-      assert_equal 160, $?.exitstatus
+      pristine_env "relativerequire.exe" do
+        system("relativerequire.exe")
+        assert_equal 160, $?.exitstatus
+      end
     end
   end
 
@@ -222,8 +228,9 @@ class TestOcra < Test::Unit::TestCase
     with_fixture 'autoload' do
       assert system("ruby", ocra, "autoload.rb", *DefaultArgs)
       assert File.exist?("autoload.exe")
-      File.unlink('foo.rb')
-      assert system("autoload.exe")
+      pristine_env "autoload.exe" do
+        assert system("autoload.exe")
+      end
     end
   end
 
@@ -235,7 +242,9 @@ class TestOcra < Test::Unit::TestCase
       args.push '--no-warnings'
       assert system("ruby", ocra, "autoloadmissing.rb", *args)
       assert File.exist?("autoloadmissing.exe")
-      assert system("autoloadmissing.exe")
+      pristine_env "autoloadmissing.exe" do
+        assert system("autoloadmissing.exe")
+      end
     end
   end
 
@@ -244,8 +253,9 @@ class TestOcra < Test::Unit::TestCase
     with_fixture 'autoloadnested' do
       assert system("ruby", ocra, "autoloadnested.rb", *DefaultArgs)
       assert File.exist?("autoloadnested.exe")
-      File.unlink('foo.rb')
-      assert system("autoloadnested.exe")
+      pristine_env "autoloadnested.exe" do
+        assert system("autoloadnested.exe")
+      end
     end
   end
 
@@ -256,7 +266,9 @@ class TestOcra < Test::Unit::TestCase
     with_fixture 'relloadpath1' do
       assert system('ruby', '-I', 'lib', ocra, 'relloadpath1.rb', *DefaultArgs)
       assert File.exist?('relloadpath1.exe')
-      assert system('relloadpath1.exe')
+      pristine_env "relloadpath1.exe" do
+        assert system('relloadpath1.exe')
+      end
     end
   end
 
@@ -265,7 +277,9 @@ class TestOcra < Test::Unit::TestCase
     with_fixture 'relloadpath1' do
       assert system('ruby', '-I', './lib', ocra, 'relloadpath1.rb', *DefaultArgs)
       assert File.exist?('relloadpath1.exe')
-      assert system('relloadpath1.exe')
+      pristine_env "relloadpath1.exe" do
+        assert system('relloadpath1.exe')
+      end
     end
   end
 
@@ -277,7 +291,9 @@ class TestOcra < Test::Unit::TestCase
       with_env 'RUBYLIB' => 'lib' do
         assert system('ruby', ocra, 'relloadpath1.rb', *DefaultArgs)
         assert File.exist?('relloadpath1.exe')
-        assert system('relloadpath1.exe')
+        pristine_env "relloadpath1.exe" do
+          assert system('relloadpath1.exe')
+        end
       end
     end
   end
@@ -288,7 +304,9 @@ class TestOcra < Test::Unit::TestCase
       with_env 'RUBYLIB' => './lib' do
         assert system('ruby', ocra, 'relloadpath1.rb', *DefaultArgs)
         assert File.exist?('relloadpath1.exe')
-        assert system('relloadpath1.exe')
+        pristine_env "relloadpath1.exe" do
+          assert system('relloadpath1.exe')
+        end
       end
     end
   end
@@ -299,7 +317,9 @@ class TestOcra < Test::Unit::TestCase
       cd 'src' do
         assert system('ruby', '-I', '../lib', ocra, 'relloadpath2.rb', *DefaultArgs)
         assert File.exist?('relloadpath2.exe')
-        assert system('relloadpath2.exe')
+        pristine_env "relloadpath2.exe" do
+          assert system('relloadpath2.exe')
+        end
       end
     end
   end
@@ -310,7 +330,9 @@ class TestOcra < Test::Unit::TestCase
     with_fixture 'relloadpath3' do
       assert system('ruby', ocra, 'relloadpath3.rb', *DefaultArgs)
       assert File.exist?('relloadpath3.exe')
-      assert system('relloadpath3.exe')
+      pristine_env "relloadpath3.exe" do
+        assert system('relloadpath3.exe')
+      end
     end
   end
 
@@ -321,14 +343,16 @@ class TestOcra < Test::Unit::TestCase
       cd 'src' do
         assert system('ruby', ocra, 'relloadpath4.rb', *DefaultArgs)
         assert File.exist?('relloadpath4.exe')
-        assert system('relloadpath4.exe')
+        pristine_env "relloadpath4.exe" do
+          assert system('relloadpath4.exe')
+        end
       end
     end
   end
 
   # Test that ocra.rb accepts --version and outputs the version number.
   def test_version
-    assert_match(/^Ocra \d+(\.\d)+$/, `ruby \"#{ocra}\" --version`)
+    assert_match(/^Ocra \d+(\.\d)+(.pre\d+)?$/, `ruby \"#{ocra}\" --version`)
   end
 
   # Test that ocra.rb accepts --icon.
@@ -337,7 +361,9 @@ class TestOcra < Test::Unit::TestCase
       icofile = File.join(OcraRoot, 'src', 'vit-ruby.ico')
       assert system("ruby", ocra, '--icon', icofile, "helloworld.rb", *DefaultArgs)
       assert File.exist?("helloworld.exe")
-      assert system("helloworld.exe")
+      pristine_env "helloworld.exe" do
+        assert system("helloworld.exe")
+      end
     end
   end
 
@@ -347,7 +373,9 @@ class TestOcra < Test::Unit::TestCase
     with_fixture 'resource' do
       assert system("ruby", ocra, "resource.rb", "resource.txt", "res/resource.txt", *DefaultArgs)
       assert File.exist?("resource.exe")
-      assert system("resource.exe")
+      pristine_env "resource.exe" do
+        assert system("resource.exe")
+      end
     end
   end
 
@@ -365,9 +393,11 @@ class TestOcra < Test::Unit::TestCase
     with_fixture 'environment' do
       with_env "RUBYOPT" => "-rtime" do
         assert system("ruby", ocra, "environment.rb", *DefaultArgs)
-        assert system("environment.exe")
-        env = Marshal.load(File.open("environment", "rb") { |f| f.read })
-        assert_equal "-rtime", env['RUBYOPT']
+        pristine_env "environment.exe" do
+          assert system("environment.exe")
+          env = Marshal.load(File.open("environment", "rb") { |f| f.read })
+          assert_equal "-rtime", env['RUBYOPT']
+        end
       end
     end
   end
@@ -375,25 +405,29 @@ class TestOcra < Test::Unit::TestCase
   def test_exit
     with_fixture 'exit' do
       assert system("ruby", ocra, "exit.rb", *DefaultArgs)
-      assert File.exist?("exit.exe")
-      assert system("exit.exe")
+      pristine_env "exit.exe" do
+        assert File.exist?("exit.exe")
+        assert system("exit.exe")
+      end
     end
   end
 
   def test_ocra_executable_env
     with_fixture 'environment' do
       assert system("ruby", ocra, "environment.rb", *DefaultArgs)
-      assert system("environment.exe")
-      env = Marshal.load(File.open("environment", "rb") { |f| f.read })
-      expected_path = File.expand_path("environment.exe").tr('/','\\')
-      assert_equal expected_path, env['OCRA_EXECUTABLE']
+      pristine_env "environment.exe" do
+        assert system("environment.exe")
+        env = Marshal.load(File.open("environment", "rb") { |f| f.read })
+        expected_path = File.expand_path("environment.exe").tr('/','\\')
+        assert_equal expected_path, env['OCRA_EXECUTABLE']
+      end
     end
   end
 
   def test_hierarchy
     with_fixture 'hierarchy' do
       assert system("ruby", ocra, "hierarchy.rb", "assets/**/*", *DefaultArgs)
-      with_exe "hierarchy.exe" do
+      pristine_env "hierarchy.exe" do
         assert system("hierarchy.exe")
       end
     end
@@ -404,7 +438,7 @@ class TestOcra < Test::Unit::TestCase
       assert system("ruby", ocra, "helloworld.rb", *DefaultArgs)
       tempdir = File.expand_path("temporary directory")
       mkdir_p tempdir
-      with_exe "helloworld.exe" do
+      pristine_env "helloworld.exe" do
         with_env "TMP" => tempdir.tr('/','\\') do
           assert system("helloworld.exe")
         end
@@ -412,11 +446,18 @@ class TestOcra < Test::Unit::TestCase
     end
   end
 
+  # Should be able to build executable when specifying absolute path
+  # to the script from somewhere else.
   def test_abspath
     with_fixture "helloworld" do
-      assert system("ruby", ocra, File.expand_path("helloworld.rb"), *DefaultArgs)
-      assert File.exist?("helloworld.exe")
-      assert system("helloworld.exe")
+      script_path = File.expand_path("helloworld.rb")
+      with_tmpdir do
+        assert system("ruby", ocra, script_path, *DefaultArgs)
+        assert File.exist?("helloworld.exe")
+        pristine_env "helloworld.exe" do
+          assert system("helloworld.exe")
+        end
+      end
     end
   end
 
@@ -426,7 +467,9 @@ class TestOcra < Test::Unit::TestCase
       cd "build" do
         assert system("ruby", ocra, File.expand_path("../helloworld.rb"), *DefaultArgs)
         assert File.exist?("helloworld.exe")
-        assert system("helloworld.exe")
+        pristine_env "helloworld.exe" do
+          assert system("helloworld.exe")
+        end
       end
     end
   end
@@ -435,7 +478,9 @@ class TestOcra < Test::Unit::TestCase
     with_fixture "helloworld" do
       assert system("ruby", ocra, "./helloworld.rb", *DefaultArgs)
       assert File.exist?("helloworld.exe")
-      assert system("helloworld.exe")
+      pristine_env "helloworld.exe" do
+        assert system("helloworld.exe")
+      end
     end
   end
 
@@ -445,10 +490,39 @@ class TestOcra < Test::Unit::TestCase
       cd "build" do
         assert system("ruby", ocra, "../helloworld.rb", *DefaultArgs)
         assert File.exist?("helloworld.exe")
-        assert system("helloworld.exe")
+        pristine_env "helloworld.exe" do
+          assert system("helloworld.exe")
+        end
       end
     end
   end
 
+  # Should accept hierachical source code layout
+  def test_srcroot
+    with_fixture "srcroot" do
+      assert system("ruby", ocra, "bin/srcroot.rb", "share/data.txt", *DefaultArgs)
+      assert File.exist?("srcroot.exe")
+      pristine_env "srcroot.exe" do
+        exe = File.expand_path("srcroot.exe")
+        cd ENV["SystemRoot"] do
+          assert system(exe)
+        end
+      end
+    end
+  end
+
+  # Should be able to build executables when script changes directory.
+  def test_chdir
+    with_fixture "chdir" do
+      assert system("ruby", ocra, "chdir.rb", *DefaultArgs)
+      assert File.exist?("chdir.exe")
+      pristine_env "chdir.exe" do
+        exe = File.expand_path("chdir.exe")
+        cd ENV["SystemRoot"] do
+          assert system(exe)
+        end
+      end
+    end
+  end
   
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: ocra
 version: !ruby/object:Gem::Version 
-  hash: 270495469
+  hash: -671420158
   prerelease: true
   segments: 
   - 1
   - 1
   - 5
-  - pre2
-  version: 1.1.5.pre2
+  - pre3
+  version: 1.1.5.pre3
 platform: ruby
 authors: 
 - Lars Christensen
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-17 00:00:00 +02:00
+date: 2010-08-20 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency