irpack 0.2.5 → 0.2.6

data/lib/irpack/specification.rb

@@ -0,0 +1,182 @@
+=begin
+Copyright (c) 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.
+=end
+
+require 'pathname'
+
+module IRPack
+  class Specification
+    # Generated exe file path (default is entry_file replaced extention by '.exe').
+    attr_accessor :output_file
+    # Path of entry script.
+    attr_accessor :entry_file
+    # Array of files to embed, or Hash maps runtime paths to real files.
+    attr_accessor :files
+    # Base paths stripped from files and entry_file.
+    attr_accessor :base_paths
+    # Type of generated executable. :exe for console app, :winexe for window app (default is :exe).
+    attr_accessor :target
+    # True if compress embeded files (default is false).
+    attr_accessor :compress
+    # True if embed IronRuby assemblies (default is true).
+    attr_accessor :embed_assemblies
+    # True if embed standard libraries (default is true).
+    attr_accessor :embed_stdlibs
+    alias complete  embed_stdlibs
+    alias complete= embed_stdlibs=
+    # Namespace of entry point. 
+    attr_accessor :module_name
+    # RuntimeOptions passed to script engine.
+    attr_reader :runtime_options
+
+    # Options to script engine passed in runtime.
+    class RuntimeOptions
+      # True if emit debugging information (PDBs) for Visual Studio debugger (default is false).
+      attr_accessor :debug_mode
+      # True if disable adaptive compilation (default is false).
+      attr_accessor :no_adaptive_compilation
+      # The number of iterations before the interpreter starts compiling (default is 32).
+      attr_accessor :compilation_threshold
+      # True if enable ExceptionDetail mode (default is false).
+      attr_accessor :exception_detail
+      # True if display CLS Exception information (default is false).
+      attr_accessor :show_clr_exceptions
+      # Warning level; 0=silence, 1=medium (default), 2=verbose.
+      attr_accessor :warning_level
+      # Debugging flags ($DEBUG) (default is false).
+      attr_accessor :debug_variable
+      # True if enable support for IronRuby::Clr.profile (default is false).
+      attr_accessor :profile
+      # True if enable support for set_trace_func (default is false).
+      attr_accessor :trace
+      # Required libraries before executing entry_file.
+      attr_accessor :required_paths
+      # $LOAD_PATH directories.
+      attr_accessor :search_paths
+      # True if do not catch exceptions that are unhandled by script code.
+      attr_accessor :pass_exceptions
+      # True if enable binding to private members.
+      attr_accessor :private_binding
+      alias d  debug_variable
+      alias d= debug_variable=
+      alias r  required_paths
+      alias r= required_paths=
+      alias I  search_paths
+      alias I= search_paths=
+      alias D  debug_mode
+      alias D= debug_mode=
+      alias W  warning_level
+      alias W= warning_level=
+      def initialize
+        @debug_mode = false
+        @no_adaptive_compilation = false
+        @compilation_threshold = -1
+        @exception_detail = false
+        @show_clr_exceptions = false
+        @warning_level = 1
+        @debug_variable = false
+        @profile = false
+        @trace = false
+        @required_paths = []
+        @search_paths = []
+        @pass_exceptions = false
+        @private_binding = false
+      end
+
+      def to_hash
+        {
+          DebugMode:             @debug_mode,
+          PrivateBinding:        @private_binding,
+          NoAdaptiveCompilation: @no_adaptive_compilation,
+          CompilationThreshold:  @compilation_threshold,
+          ExceptionDetail:       @exception_detail,
+          ShowClrExceptions:     @show_clr_exceptions,
+          PassExceptions:        @pass_exceptions,
+          Profile:               @profile,
+          Verbosity:             @warning_level,
+          DebugVariable:         @debug_variable,
+          EnableTracing:         @trace,
+          RequiredPaths:         @required_paths,
+          SearchPaths:           @search_paths,
+        }
+      end
+    end
+
+    def initialize
+      @output_file = nil
+      @entry_file  = nil
+      @module_name = nil
+      @files       = []
+      @base_paths  = []
+      @compress    = false
+      @target      = :exe
+      @embed_assemblies = true
+      @embed_stdlibs    = false
+      @runtime_options = RuntimeOptions.new
+      yield self if block_given?
+    end
+
+    # Return entry file path at runtime.
+    def map_entry
+      raise ArgumentError, "No entry file specified" unless @entry_file
+      base_paths = @base_paths.collect {|path| Pathname.new(path).expand_path }
+      (strip_path(base_paths, @entry_file) || @entry_file).to_s
+    end
+    
+    # Map runtime file path to real files.  
+    def map_files
+      file_map = {}
+      entry_file = Pathname.new(map_entry)
+      entry_found = false
+      case @files
+      when Hash
+        @files.each do |path, file|
+          file_map[path.to_s] = File.expand_path(file.to_s)
+          entry_found = true if path.to_s==entry_file.to_s
+        end
+      else
+        base_paths = @base_paths.collect {|path| Pathname.new(path).expand_path }
+        @files.each do |fn|
+          next unless fn
+          relpath = strip_path(base_paths, fn) || fn
+          file_map[relpath.to_s] = File.expand_path(fn.to_s)
+          entry_found = true if relpath==entry_file
+        end
+      end
+      file_map[entry_file.to_s] = File.expand_path(@entry_file.to_s) unless entry_found
+      file_map
+    end
+
+    def strip_path(base_paths, path)
+      fullpath = Pathname.new(path).expand_path
+      base_paths.collect {|base|
+        if /\A#{Regexp.escape(base.to_s)}/=~fullpath.to_s then
+          fullpath.relative_path_from(base)
+        else
+          nil
+        end
+      }.compact.sort_by {|path| path.to_s.size }.first
+    end
+    private :strip_path
+  end
+end
+

data/test/fixtures/foo.rb

@@ -0,0 +1,3 @@
+
+puts 'Hello World!'
+

data/test/test_application.rb

@@ -26,73 +26,89 @@ require 'irpack/application'
 require 'utils'
 require 'stringio'
 
-class TC_ApplicationArguments < Test::Unit::TestCase
+class TC_Application < Test::Unit::TestCase
   include Utils
-  def test_parse_without_args
+  def test_parse_without_spec
     argv = []
     $stderr = StringIO.new
-    assert_nil(IRPack::Application::Arguments.parse!(argv))
+    assert_nil(IRPack::Application.parse!(argv))
     assert_not_equal('', $stderr.to_s)
+    $stderr = STDERR
   end
 
   def test_parse
     argv = ['entry.rb']
-    args = IRPack::Application::Arguments.parse!(argv)
-    assert(!args.compress)
-    assert(!args.complete)
-    assert(args.embed_references)
-    assert_equal(:exe, args.target)
-    assert_equal(File.expand_path('entry.exe'), File.expand_path(args.output_file))
-    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])
+    spec = IRPack::Application.parse!(argv)
+    assert(!spec.compress)
+    assert(!spec.complete)
+    assert(spec.embed_assemblies)
+    assert_equal(:exe, spec.target)
+    assert_nil(spec.output_file)
+    assert_equal('entry.rb', spec.entry_file)
+    assert_equal('entry.rb', spec.map_entry)
+    assert_equal(0, spec.files.size)
+    pack_files = spec.map_files
+    assert_equal(1, pack_files.size)
+    assert_equal(File.expand_path('entry.rb'), pack_files['entry.rb'])
+    assert(!spec.runtime_options.debug_variable)
+    assert(!spec.runtime_options.debug_mode)
+    assert_equal(1, spec.runtime_options.warning_level)
+    assert(!spec.runtime_options.trace)
+    assert(!spec.runtime_options.profile)
+    assert(!spec.runtime_options.exception_detail)
+    assert(!spec.runtime_options.no_adaptive_compilation)
+    assert_equal(-1, spec.runtime_options.compilation_threshold)
+    assert(!spec.runtime_options.pass_exceptions)
+    assert(!spec.runtime_options.private_binding)
+    assert(!spec.runtime_options.show_clr_exceptions)
   end
 
   def test_parse_output_file
     argv = ['-o', 'foo.exe', 'entry.rb']
-    args = IRPack::Application::Arguments.parse!(argv)
-    assert_equal(File.expand_path('foo.exe'), File.expand_path(args.output_file))
+    spec = IRPack::Application.parse!(argv)
+    assert_equal(File.expand_path('foo.exe'), File.expand_path(spec.output_file))
   end
 
   def test_parse_window_app
     argv = ['--window', 'entry.rb']
-    args = IRPack::Application::Arguments.parse!(argv)
-    assert_equal(:winexe, args.target)
+    spec = IRPack::Application.parse!(argv)
+    assert_equal(:winexe, spec.target)
   end
 
   def test_parse_console_app
     argv = ['--console', 'entry.rb']
-    args = IRPack::Application::Arguments.parse!(argv)
-    assert_equal(:exe, args.target)
+    spec = IRPack::Application.parse!(argv)
+    assert_equal(:exe, spec.target)
   end
 
-  def test_parse_no_embed_references
+  def test_parse_no_embed
     argv = ['--no-embed', 'entry.rb']
-    args = IRPack::Application::Arguments.parse!(argv)
-    assert(!args.embed_references)
+    spec = IRPack::Application.parse!(argv)
+    assert(!spec.embed_assemblies)
+  end
+
+  def test_parse_no_embed_assemblies
+    argv = ['--no-embed-assemblies', 'entry.rb']
+    spec = IRPack::Application.parse!(argv)
+    assert(!spec.embed_assemblies)
   end
 
   def test_parse_compress
     argv = ['--compress', 'entry.rb']
-    args = IRPack::Application::Arguments.parse!(argv)
-    assert(args.compress)
+    spec = IRPack::Application.parse!(argv)
+    assert(spec.compress)
   end
 
   def test_parse_complete
     argv = ['--complete', 'entry.rb']
-    args = IRPack::Application::Arguments.parse!(argv)
-    assert(args.complete)
+    spec = IRPack::Application.parse!(argv)
+    assert(spec.complete)
+  end
+
+  def test_parse_embed_stdlibs
+    argv = ['--embed-stdlibs', 'entry.rb']
+    spec = IRPack::Application.parse!(argv)
+    assert(spec.embed_stdlibs)
   end
 
   def test_parse_basedir
@@ -103,98 +119,100 @@ class TC_ApplicationArguments < Test::Unit::TestCase
       File.expand_path('foo/bar/hoge.rb'),
       'foo/bar/hoge/fuga.rb',
     ]
-    args = IRPack::Application::Arguments.parse!(argv)
-    assert_equal(File.expand_path('entry.exe'), File.expand_path(args.output_file))
-    assert_equal('../../entry.rb', args.entry_file)
-    assert_equal(4, args.files.size)
-    assert_equal('../../entry.rb', args.files[File.expand_path('entry.rb')])
-    assert_equal('baz.rb', args.files[File.expand_path('foo/bar/baz.rb')])
-    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')])
+    spec = IRPack::Application.parse!(argv)
+    assert_nil(spec.output_file)
+    assert_equal('entry.rb', spec.entry_file)
+    assert_equal('entry.rb', spec.map_entry)
+    pack_files = spec.map_files
+    assert_equal(4, pack_files.size)
+    assert_equal(File.expand_path('entry.rb'),             pack_files['entry.rb'])
+    assert_equal(File.expand_path('foo/bar/baz.rb'),       pack_files['baz.rb'])
+    assert_equal(File.expand_path('foo/bar/hoge.rb'),      pack_files['hoge.rb'])
+    assert_equal(File.expand_path('foo/bar/hoge/fuga.rb'), pack_files['hoge/fuga.rb'])
   end
 
   def test_parse_debug_variable
     argv = ['-d', 'entry.rb']
-    args = IRPack::Application::Arguments.parse!(argv)
-    assert(args.runtime_options[:DebugVariable])
+    spec = IRPack::Application.parse!(argv)
+    assert(spec.runtime_options.debug_variable)
   end
 
   def test_parse_debug_mode
     argv = ['-D', 'entry.rb']
-    args = IRPack::Application::Arguments.parse!(argv)
-    assert(args.runtime_options[:DebugMode])
+    spec = IRPack::Application.parse!(argv)
+    assert(spec.runtime_options.debug_mode)
   end
 
   def test_parse_verbose
     argv = ['-v', 'entry.rb']
-    args = IRPack::Application::Arguments.parse!(argv)
-    assert_equal(2, args.runtime_options[:Verbosity])
+    spec = IRPack::Application.parse!(argv)
+    assert_equal(2, spec.runtime_options.warning_level)
   end
 
   def test_parse_warn
     argv = ['-w', 'entry.rb']
-    args = IRPack::Application::Arguments.parse!(argv)
-    assert_equal(2, args.runtime_options[:Verbosity])
+    spec = IRPack::Application.parse!(argv)
+    assert_equal(2, spec.runtime_options.warning_level)
   end
 
   def test_parse_warning
     argv = ['-W', 'entry.rb']
-    args = IRPack::Application::Arguments.parse!(argv)
-    assert_equal(2, args.runtime_options[:Verbosity])
+    spec = IRPack::Application.parse!(argv)
+    assert_equal(2, spec.runtime_options.warning_level)
   end
 
   def test_parse_warning0
     argv = ['-W0', 'entry.rb']
-    args = IRPack::Application::Arguments.parse!(argv)
-    assert_equal(0, args.runtime_options[:Verbosity])
+    spec = IRPack::Application.parse!(argv)
+    assert_equal(0, spec.runtime_options.warning_level)
   end
 
   def test_parse_trace
     argv = ['--trace', 'entry.rb']
-    args = IRPack::Application::Arguments.parse!(argv)
-    assert(args.runtime_options[:EnableTracing])
+    spec = IRPack::Application.parse!(argv)
+    assert(spec.runtime_options.trace)
   end
 
   def test_parse_profile
     argv = ['--profile', 'entry.rb']
-    args = IRPack::Application::Arguments.parse!(argv)
-    assert(args.runtime_options[:Profile])
+    spec = IRPack::Application.parse!(argv)
+    assert(spec.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])
+    spec = IRPack::Application.parse!(argv)
+    assert(spec.runtime_options.exception_detail)
   end
 
   def test_parse_no_adaptive_compilation
     argv = ['--no-adaptive-compilation', 'entry.rb']
-    args = IRPack::Application::Arguments.parse!(argv)
-    assert(args.runtime_options[:NoAdaptiveCompilation])
+    spec = IRPack::Application.parse!(argv)
+    assert(spec.runtime_options.no_adaptive_compilation)
   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])
+    spec = IRPack::Application.parse!(argv)
+    assert_equal(8192, spec.runtime_options.compilation_threshold)
   end
 
   def test_parse_pass_exceptions
     argv = ['--pass-exceptions', 'entry.rb']
-    args = IRPack::Application::Arguments.parse!(argv)
-    assert(args.runtime_options[:PassExceptions])
+    spec = IRPack::Application.parse!(argv)
+    assert(spec.runtime_options.pass_exceptions)
   end
 
   def test_parse_private_binding
     argv = ['--private-binding', 'entry.rb']
-    args = IRPack::Application::Arguments.parse!(argv)
-    assert(args.runtime_options[:PrivateBinding])
+    spec = IRPack::Application.parse!(argv)
+    assert(spec.runtime_options.private_binding)
   end
 
   def test_parse_show_clr_exceptions
     argv = ['--show-clr-exceptions', 'entry.rb']
-    args = IRPack::Application::Arguments.parse!(argv)
-    assert(args.runtime_options[:ShowClrExceptions])
+    spec = IRPack::Application.parse!(argv)
+    assert(spec.runtime_options.show_clr_exceptions)
   end
 end
 

data/test/test_generateexetask.rb

@@ -0,0 +1,152 @@
+=begin
+Copyright (c) 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.
+=end
+
+require 'test/unit'
+require 'irpack/rake/generateexetask'
+
+class TC_GenerateExeTask < Test::Unit::TestCase
+  def teardown
+    Rake::Task.clear
+  end
+
+  def test_construct
+    spec = IRPack::Specification.new
+    task = IRPack::Rake::GenerateExeTask.new(spec)
+    assert_equal(spec, task.exe_spec)
+    assert_equal(:exe, task.name)
+    assert(!Rake::Task.task_defined?(task.name))
+  end
+
+  def test_construct_with_block
+    spec = IRPack::Specification.new {|s|
+      s.output_file = 'main.exe'
+      s.entry_file  = 'main.rb'
+    }
+    task_in_block = nil
+    task = IRPack::Rake::GenerateExeTask.new(spec) {|t|
+      task_in_block = t
+      assert_equal(spec, t.exe_spec)
+      assert_equal(:exe, t.name)
+    }
+    assert_same(task, task_in_block)
+    assert(Rake::Task.task_defined?(task.name))
+  end
+
+  def test_define_no_entry_file
+    spec = IRPack::Specification.new
+    task = IRPack::Rake::GenerateExeTask.new(spec)
+    assert_raise(ArgumentError) do
+      task.define
+    end
+  end
+
+  def test_define_no_output_file
+    spec = IRPack::Specification.new {|s|
+      s.entry_file = 'main.rb'
+    }
+    task = IRPack::Rake::GenerateExeTask.new(spec)
+    assert_raise(ArgumentError) do
+      task.define
+    end
+  end
+
+  def test_define_only_entry_file
+    spec = IRPack::Specification.new {|s|
+      s.output_file = 'output/main.exe'
+      s.entry_file = 'bin/main.rb'
+    }
+    IRPack::Rake::GenerateExeTask.new(spec) do
+    end
+    assert(Rake::Task.task_defined?(:exe))
+    task = Rake::Task[:exe]
+    assert_equal([spec.output_file], task.prerequisites)
+    assert(task.actions.empty?)
+    assert(Rake::Task.task_defined?(spec.output_file))
+    task = Rake::Task[spec.output_file]
+    assert_equal([File.expand_path('bin/main.rb')], task.prerequisites.sort)
+    assert(!task.actions.empty?)
+  end
+
+  def test_define_with_files
+    spec = IRPack::Specification.new {|s|
+      s.output_file = 'output/main.exe'
+      s.entry_file  = 'bin/main.rb'
+      s.files << 'bin/main.rb'
+      s.files << 'lib/foo.rb'
+      s.files << 'lib/bar.rb'
+      s.files << '../hoge/../fuga/../piyo.rb'
+      s.files << 'c:/foo/bar/baz.rb'
+    }
+    IRPack::Rake::GenerateExeTask.new(spec) do
+    end
+    task = Rake::Task[spec.output_file]
+    assert_equal([
+      'bin/main.rb',
+      'lib/foo.rb',
+      'lib/bar.rb',
+      '../hoge/../fuga/../piyo.rb',
+      'c:/foo/bar/baz.rb',
+    ].collect {|fn| File.expand_path(fn) }.sort, task.prerequisites.sort)
+  end
+
+  def test_define_with_files_hash
+    spec = IRPack::Specification.new {|s|
+      s.output_file = 'output/main.exe'
+      s.entry_file  = 'main.rb'
+      s.files = {
+        'main.rb'        => 'bin/main.rb',
+        'foo.rb'         => 'lib/foo.rb',
+        'bar.rb'         => 'lib/bar.rb',
+        '../piyo.rb'     => '../hoge/../fuga/../piyo.rb',
+        'foo/bar/baz.rb' => 'c:/foo/bar/baz.rb',
+      }
+    }
+    IRPack::Rake::GenerateExeTask.new(spec) do
+    end
+    task = Rake::Task[spec.output_file]
+    assert_equal([
+      'bin/main.rb',
+      'lib/foo.rb',
+      'lib/bar.rb',
+      '../hoge/../fuga/../piyo.rb',
+      'c:/foo/bar/baz.rb',
+    ].collect {|fn| File.expand_path(fn) }.sort, task.prerequisites.sort)
+  end
+
+  def test_execute
+    FileUtils.mkpath('test/tmp')
+    spec = IRPack::Specification.new {|s|
+      s.output_file = 'test/tmp/foo.exe'
+      s.entry_file  = 'test/fixtures/foo.rb'
+    }
+    IRPack::Rake::GenerateExeTask.new(spec) do
+    end
+    task = Rake::Task[spec.output_file]
+    task.execute
+    assert(File.exist?(spec.output_file))
+    assert('Hello World!', `#{spec.output_file}`)
+  ensure
+    FileUtils.rm_rf('test/tmp')
+  end
+end
+