tebako 0.10.0 → 0.11.0

data/lib/tebako/cli_helpers.rb

@@ -34,6 +34,7 @@ require_relative "codegen"
 require_relative "error"
 require_relative "options_manager"
 require_relative "scenario_manager"
+require_relative "packager_lite"
 
 # Tebako - an executable packager
 # Command-line interface methods
@@ -41,10 +42,27 @@ module Tebako
   # Cli helpers
   module CliHelpers
     def do_press(options_manager)
-      puts options_manager.press_announce
+      scenario_manager = Tebako::ScenarioManager.new(options_manager.root, options_manager.fs_entrance)
+      puts options_manager.press_announce(scenario_manager.msys?)
+
+      if options_manager.mode == "both" || options_manager.mode == "runtime" || options_manager.mode == "bundle"
+        do_press_runtime(options_manager, scenario_manager)
+      end
+
+      if options_manager.mode == "both" || options_manager.mode == "application"
+        do_press_application(options_manager, scenario_manager)
+      end
+
+      true
+    end
 
-      generate_files(options_manager)
+    def do_press_application(options_manager, scenario_manager)
+      packager = Tebako::PackagerLite.new(options_manager, scenario_manager)
+      packager.create_package
+    end
 
+    def do_press_runtime(options_manager, scenario_manager)
+      generate_files(options_manager, scenario_manager)
       cfg_cmd = "cmake -DSETUP_MODE:BOOLEAN=OFF #{options_manager.cfg_options} #{options_manager.press_options}"
       build_cmd = "cmake --build #{options_manager.output_folder} --target tebako --parallel #{Etc.nprocessors}"
       merged_env = ENV.to_h.merge(options_manager.b_env)
@@ -64,20 +82,18 @@ module Tebako
       true
     end
 
-    def generate_files(options_manager)
+    def generate_files(options_manager, scenario_manager)
       puts "-- Generating files"
-      scenario_manager = Tebako::ScenarioManager.new(options_manager.root, options_manager.fs_entrance)
       scenario_manager.configure_scenario
 
-      puts "   ... tebako-version.h"
       v_parts = Tebako::VERSION.split(".")
       Tebako::Codegen.generate_tebako_version_h(options_manager, v_parts)
-
-      puts "   ... tebako-fs.cpp"
       Tebako::Codegen.generate_tebako_fs_cpp(options_manager, scenario_manager)
-
-      puts "   ... deploy.rb"
       Tebako::Codegen.generate_deploy_rb(options_manager, scenario_manager)
+
+      return unless options_manager.mode == "both" || options_manager.mode == "runtime"
+
+      Tebako::Codegen.generate_stub_rb(options_manager)
     end
 
     def options_from_tebafile(tebafile)

data/lib/tebako/codegen.rb

@@ -28,6 +28,8 @@
 require "pathname"
 require "fileutils"
 
+require_relative "package_descriptor"
+
 # Tebako - an executable packager
 module Tebako
   # Code geberation
@@ -47,20 +49,42 @@ module Tebako
 
     SUBST
 
-    class << self
+    class << self # rubocop:disable Metrics/ClassLength
       def deploy_crt_implib(opt, scm)
         crt = ""
         if scm.msys?
           crt = <<~SUBST
             Tebako::Packager.create_implib("#{opt.ruby_src_dir}", "#{opt.data_src_dir}",
-                                           "#{File.basename(opt.package)}", rv)
+                                           "#{opt.package}", rv)
           SUBST
         end
         crt
       end
 
-      def deploy_cwd(opt)
-        opt.cwd.nil? ? "nil" : "\"#{opt.cwd}\""
+      def deploy_mk(opt, scm)
+        case opt.mode
+        when "bundle"
+          deploy_mk_bundle(opt, scm)
+        when /runtime|both/
+          deploy_mk_stub(opt)
+        end
+      end
+
+      def deploy_mk_bundle(opt, scm)
+        <<~SUBST
+          Tebako::Packager.deploy("#{opt.data_src_dir}", "#{opt.data_pre_dir}",
+                                  rv , "#{opt.root}", "#{scm.fs_entrance}", "#{opt.cwd}")
+          Tebako::Packager.mkdwarfs("#{opt.deps_bin_dir}", "#{opt.data_bundle_file}",
+                                    "#{opt.data_src_dir}")
+        SUBST
+      end
+
+      def deploy_mk_stub(opt)
+        <<~SUBST
+          Tebako::Packager.deploy("#{opt.data_src_dir}", "#{opt.data_pre_dir}",
+                                  rv, "#{File.join(opt.deps, "src", "tebako", "local")}", "stub.rb", nil)
+          Tebako::Packager.mkdwarfs("#{opt.deps_bin_dir}", "#{opt.data_stub_file}", "#{opt.data_src_dir}")
+        SUBST
       end
 
       def deploy_rb(opt, scm)
@@ -71,22 +95,41 @@ module Tebako
           Tebako::Packager::init("#{opt.stash_dir}", "#{opt.data_src_dir}",
                                "#{opt.data_pre_dir}", "#{opt.data_bin_dir}")
           #{deploy_crt_implib(opt, scm)}
-          Tebako::Packager.deploy("#{opt.data_src_dir}", "#{opt.data_pre_dir}",
-                                  rv , "#{opt.root}",
-                                  "#{scm.fs_entrance}", #{deploy_cwd(opt)})
-          Tebako::Packager.mkdwarfs("#{opt.deps_bin_dir}", "#{opt.data_bin_file}",
-                                    "#{opt.data_src_dir}")
+          #{deploy_mk(opt, scm)}
         SUBST
       end
 
       def deploy_rq
         <<~SUBST
+          require "#{File.join(__dir__, "package_descriptor.rb")}"
           require "#{File.join(__dir__, "packager.rb")}"
           require "#{File.join(__dir__, "ruby_version.rb")}"
         SUBST
       end
 
+      def stub_rb(opt)
+        <<~SUBST
+          puts "Copyright (c) 2024 Ribose Inc (https://www.ribose.com)"
+          puts "Tebako runtime stub v#{Tebako::VERSION}"
+          puts "To run your application please call #{File.basename(opt.package)} --tebako-run <your tebako package>"
+        SUBST
+      end
+
+      def generate_stub_rb(options_manager)
+        puts "   ... stub.rb"
+
+        fname = File.join(options_manager.deps, "src", "tebako", "local", "stub.rb")
+        FileUtils.mkdir_p(File.dirname(fname))
+
+        File.open(fname, "w") do |file|
+          file.write(COMMON_RUBY_HEADER)
+          file.write(stub_rb(options_manager))
+        end
+      end
+
       def generate_deploy_rb(options_manager, scenario_manager)
+        puts "   ... deploy.rb"
+
         fname = File.join(options_manager.deps, "bin", "deploy.rb")
         FileUtils.mkdir_p(File.dirname(fname))
 
@@ -96,7 +139,20 @@ module Tebako
         end
       end
 
+      def generate_package_descriptor(options_manager, scenario_manager)
+        puts "   ... package_descriptor"
+        fname = File.join(options_manager.deps, "src", "tebako", "package_descriptor")
+        FileUtils.mkdir_p(File.dirname(fname))
+        descriptor = Tebako::PackageDescriptor.new(options_manager.ruby_ver, Tebako::VERSION,
+                                                   scenario_manager.fs_mount_point, scenario_manager.fs_entry_point,
+                                                   options_manager.cwd)
+        File.binwrite(fname, descriptor.serialize)
+        fname
+      end
+
       def generate_tebako_fs_cpp(options_manager, scenario_manager)
+        puts "   ... tebako-fs.cpp"
+
         fname = File.join(options_manager.deps, "src", "tebako", "tebako-fs.cpp")
         FileUtils.mkdir_p(File.dirname(fname))
 
@@ -107,6 +163,8 @@ module Tebako
       end
 
       def generate_tebako_version_h(options_manager, v_parts)
+        puts "   ... tebako-version.h"
+
         fname = File.join(options_manager.deps, "include", "tebako", "tebako-version.h")
         FileUtils.mkdir_p(File.dirname(fname))
 
@@ -125,7 +183,17 @@ module Tebako
       end
 
       def tebako_fs_cpp(options_manager, scenario_manager)
+        case options_manager.mode
+        when "bundle"
+          tebako_fs_cpp_bundle(options_manager, scenario_manager)
+        when /runtime|both/
+          tebako_fs_cpp_stub(options_manager, scenario_manager)
+        end
+      end
+
+      def tebako_fs_cpp_bundle(options_manager, scenario_manager)
         <<~SUBST
+          #include <limits.h>
           #include <incbin/incbin.h>
 
           namespace tebako {
@@ -135,7 +203,24 @@ module Tebako
             const  char * package_cwd 	 = #{package_cwd(options_manager, scenario_manager)};
             char   original_cwd[PATH_MAX];
 
-            INCBIN(fs, "#{options_manager.output_folder}/p/fs.bin");
+            INCBIN(fs, "#{options_manager.data_bundle_file}");
+          }
+        SUBST
+      end
+
+      def tebako_fs_cpp_stub(options_manager, scenario_manager)
+        <<~SUBST
+          #include <limits.h>
+          #include <incbin/incbin.h>
+
+          namespace tebako {
+            const  char * fs_log_level   = "#{options_manager.l_level}";
+            const  char * fs_mount_point = "#{scenario_manager.fs_mount_point}";
+            const  char * fs_entry_point = "/local/stub.rb";
+            const  char * package_cwd 	 = nullptr;
+            char   original_cwd[PATH_MAX];
+
+            INCBIN(fs, "#{options_manager.data_stub_file}");
           }
         SUBST
       end

data/lib/tebako/deploy_helper.rb

@@ -70,7 +70,7 @@ module Tebako
     def deploy
       BuildHelpers.with_env(deploy_env) do
         update_rubygems
-        system("#{gem_command} env")
+        system("#{gem_command} env") if @verbose
         install_gem("tebako-runtime")
         install_gem("bundler", BUNDLER_VERSION) if needs_bundler?
         deploy_solution

data/lib/tebako/options_manager.rb

@@ -73,16 +73,32 @@ module Tebako
       @cwd ||= f_cwd
     end
 
+    def cwd_announce
+      @cwd_announce ||= cwd.nil? ? "<Host current directory>" : cwd
+    end
+
     # DATA_BIN_DIR folder is used to create packaged filesystem
     # set(DATA_BIN_DIR  ${CMAKE_CURRENT_BINARY_DIR}/p)
     def data_bin_dir
       @data_bin_dir ||= File.join(output_folder, "p")
     end
 
-    # DATA_BIN_FILE is packaged filesystem itself
-    # set(DATA_BIN_FILE ${DATA_BIN_DIR}/fs.bin)
-    def data_bin_file
-      @data_bin_file ||= File.join(data_bin_dir, "fs.bin")
+    #  Mode       File(s)                       Content
+    #  bundle     fs.bin                      Application
+    #  both       fs.bin, fs2.bin     Stub, application respectively
+    #  runtime    fs.bin                         Stub
+    #  app        fs2.bin                     Application
+
+    def data_bundle_file
+      @data_bundle_file ||= File.join(data_bin_dir, "fs.bin")
+    end
+
+    def data_stub_file
+      @data_stub_file ||= File.join(data_bin_dir, "fs.bin")
+    end
+
+    def data_app_file
+      @data_app_file ||= File.join(data_bin_dir, "fs2.bin")
     end
 
     # DATA_PRE_DIR folder is used to build gems  that need to be packaged
@@ -131,11 +147,11 @@ module Tebako
     end
 
     def l_level
-      @l_level ||= if @options["log-level"].nil?
-                     "error"
-                   else
-                     @options["log-level"]
-                   end
+      @l_level ||= @options["log-level"].nil? ? "error" : @options["log-level"]
+    end
+
+    def mode
+      @mode ||= @options["mode"].nil? ? "bundle" : @options["mode"]
     end
 
     def m_files
@@ -179,10 +195,57 @@ module Tebako
                   end
     end
 
-    def press_announce
-      cwd_announce = cwd.nil? ? "<Host current directory>" : cwd
-      @press_announce ||= <<~ANN
+    def press_announce(is_msys)
+      case mode
+      when "application"
+        press_announce_application(is_msys)
+      when "both"
+        press_announce_both
+      when "bundle"
+        press_announce_bundle
+      when "runtime"
+        press_announce_runtime
+      end
+    end
+
+    def press_announce_ref(is_msys)
+      if is_msys
+        " referencing runtime at '#{ref}'"
+      else
+        ""
+      end
+    end
+
+    def press_announce_application(is_msys)
+      <<~ANN
         Running tebako press at #{prefix}
+           Mode:                      'application'
+           Ruby version:              '#{@ruby_ver}'
+           Project root:              '#{root}'
+           Application entry point:   '#{fs_entrance}'
+           Package file name:         '#{package}.tebako'#{press_announce_ref(is_msys)}
+           Package working directory: '#{cwd_announce}'
+      ANN
+    end
+
+    def press_announce_both
+      <<~ANN
+        Running tebako press at #{prefix}
+           Mode:                      'both'
+           Ruby version:              '#{@ruby_ver}'
+           Project root:              '#{root}'
+           Application entry point:   '#{fs_entrance}'
+           Runtime file name:         '#{package}'
+           Package file name:         '#{package}.tebako'
+           Loging level:              '#{l_level}'
+           Package working directory: '#{cwd_announce}'
+      ANN
+    end
+
+    def press_announce_bundle
+      <<~ANN
+        Running tebako press at #{prefix}
+           Mode:                      'bundle'
            Ruby version:              '#{@ruby_ver}'
            Project root:              '#{root}'
            Application entry point:   '#{fs_entrance}'
@@ -192,6 +255,16 @@ module Tebako
       ANN
     end
 
+    def press_announce_runtime
+      <<~ANN
+        Running tebako press at #{prefix}
+           Mode:                      'runtime'
+           Ruby version:              '#{@ruby_ver}'
+           Runtime file name:         '#{package}'
+           Loging level:              '#{l_level}'
+      ANN
+    end
+
     def press_options
       @press_options ||= "-DPCKG:STRING='#{package}' -DLOG_LEVEL:STRING='#{l_level}' " \
     end
@@ -200,6 +273,10 @@ module Tebako
       Pathname.new(path).relative?
     end
 
+    def ref
+      @ref ||= @options["ref"].nil? ? "tebako-runtime" : @options["ref"].gsub("\\", "/")
+    end
+
     def remove_glibc_private
       @remove_glibc_private ||= if RUBY_PLATFORM.end_with?("linux") || RUBY_PLATFORM.end_with?("linux-gnu")
                                   "-DREMOVE_GLIBC_PRIVATE=#{@options["patchelf"] ? "ON" : "OFF"}"

data/lib/tebako/package_descriptor.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2023-2024 [Ribose Inc](https://www.ribose.com).
+# All rights reserved.
+# This file is a part of tebako
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+# TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
+# BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+require "stringio"
+
+module Tebako
+  # Tebako application package descriptor
+  class PackageDescriptor
+    SIGNATURE = "TAMATEBAKO"
+
+    attr_reader :ruby_version_major, :ruby_version_minor, :ruby_version_patch, :tebako_version_major,
+                :tebako_version_minor, :tebako_version_patch, :mount_point, :entry_point, :cwd
+
+    def initialize(*args)
+      if args.size == 1 && args[0].is_a?(Array)
+        deserialize(args[0])
+      elsif args.size == 5
+        construct_from_params(*args)
+      else
+        raise ArgumentError, "Invalid arguments"
+      end
+    end
+
+    def serialize
+      buffer = StringIO.new
+
+      buffer.write(SIGNATURE)
+      serialize_versions(buffer)
+
+      write_string(buffer, @mount_point)
+      write_string(buffer, @entry_point)
+
+      serialize_cwd(buffer)
+      buffer.string
+    end
+
+    private
+
+    def deserialize(buffer)
+      stream = StringIO.new(buffer.pack("C*"))
+
+      signature = stream.read(SIGNATURE.size)
+      raise ArgumentError, "Invalid or missing signature" if signature != SIGNATURE
+
+      deserialize_versions(stream)
+      @mount_point = read_string(stream)
+      @entry_point = read_string(stream)
+
+      cwd_present = stream.read(1).unpack1("C")
+      @cwd = cwd_present == 1 ? read_string(stream) : nil
+    end
+
+    def construct_from_params(ruby_version, tebako_version, mount_point, entry_point, cwd)
+      parse_version(ruby_version, :@ruby_version_major, :@ruby_version_minor, :@ruby_version_patch)
+      parse_version(tebako_version, :@tebako_version_major, :@tebako_version_minor, :@tebako_version_patch)
+
+      @mount_point = mount_point
+      @entry_point = entry_point
+      @cwd = cwd
+    end
+
+    def deserialize_versions(stream)
+      @ruby_version_major = read_uint16(stream)
+      @ruby_version_minor = read_uint16(stream)
+      @ruby_version_patch = read_uint16(stream)
+      @tebako_version_major = read_uint16(stream)
+      @tebako_version_minor = read_uint16(stream)
+      @tebako_version_patch = read_uint16(stream)
+    end
+
+    def parse_version(version, major_sym, minor_sym, patch_sym)
+      major, minor, patch = version.split(".").map(&:to_i)
+      raise ArgumentError, "Invalid version format" unless major && minor && patch
+
+      instance_variable_set(major_sym, major)
+      instance_variable_set(minor_sym, minor)
+      instance_variable_set(patch_sym, patch)
+    end
+
+    def write_uint16(buffer, value)
+      buffer.write([value].pack("v"))
+    end
+
+    def read_uint16(stream)
+      data = stream.read(2)
+      raise ArgumentError, "Unexpected end of stream" if data.nil?
+
+      data.unpack1("v")
+    end
+
+    def serialize_cwd(buffer)
+      if @cwd
+        buffer.write([1].pack("C"))
+        write_string(buffer, @cwd)
+      else
+        buffer.write([0].pack("C"))
+      end
+    end
+
+    def serialize_versions(buffer)
+      write_uint16(buffer, @ruby_version_major)
+      write_uint16(buffer, @ruby_version_minor)
+      write_uint16(buffer, @ruby_version_patch)
+      write_uint16(buffer, @tebako_version_major)
+      write_uint16(buffer, @tebako_version_minor)
+      write_uint16(buffer, @tebako_version_patch)
+    end
+
+    def write_string(buffer, str)
+      write_uint16(buffer, str.size)
+      buffer.write(str)
+    end
+
+    def read_string(stream)
+      size = read_uint16(stream)
+      stream.read(size)
+    end
+  end
+end

data/lib/tebako/packager.rb

@@ -67,9 +67,10 @@ module Tebako
     class << self
       # Create implib
       def create_implib(src_dir, package_src_dir, app_name, ruby_ver)
-        create_def(src_dir, app_name)
+        a_name = File.basename(app_name, ".*")
+        create_def(src_dir, a_name)
         puts "   ... creating Windows import library"
-        params = ["dlltool", "-d", def_fname(src_dir, app_name), "-D", out_fname(app_name), "--output-lib",
+        params = ["dlltool", "-d", def_fname(src_dir, a_name), "-D", out_fname(a_name), "--output-lib",
                   lib_fname(package_src_dir, ruby_ver)]
         BuildHelpers.run_with_capture(params)
       end
@@ -85,13 +86,12 @@ module Tebako
       end
 
       def finalize(os_type, src_dir, app_name, ruby_ver, patchelf)
+        puts "-- Running finalize script"
+
         RubyBuilder.new(ruby_ver, src_dir).final_build
         exe_suffix = Packager::PatchHelpers.exe_suffix(os_type)
         src_name = File.join(src_dir, "ruby#{exe_suffix}")
-        unless patchelf.nil?
-          params = [patchelf, "--remove-needed-version", "libpthread.so.0", "GLIBC_PRIVATE", src_name]
-          BuildHelpers.run_with_capture(params)
-        end
+        patchelf(src_name, patchelf)
         package_name = "#{app_name}#{exe_suffix}"
         strip_or_copy(os_type, src_name, package_name)
         puts "Created tebako package at \"#{package_name}\""
@@ -106,9 +106,10 @@ module Tebako
         FileUtils.cp_r "#{stash_dir}/.", src_dir
       end
 
-      def mkdwarfs(deps_bin_dir, data_bin_file, data_src_dir)
+      def mkdwarfs(deps_bin_dir, data_bin_file, data_src_dir, descriptor = nil)
         puts "-- Running mkdwarfs script"
         params = [File.join(deps_bin_dir, "mkdwarfs"), "-o", data_bin_file, "-i", data_src_dir, "--no-progress"]
+        params << "--header" << descriptor if descriptor
         BuildHelpers.run_with_capture_v(params)
       end
 
@@ -189,18 +190,11 @@ module Tebako
         patch_map.each { |fname, mapping| PatchHelpers.patch_file("#{root}/#{fname}", mapping) }
       end
 
-      def ruby_version(tbd)
-        ruby_version = nil
-        PatchHelpers.with_env(DEPLOY_ENV) do
-          out, st = Open3.capture2e("#{tbd}/ruby", "--version")
-          raise Tebako::Error, "Failed to run ruby --version" unless st.exitstatus.zero?
-
-          match = out.match(/ruby (\d+\.\d+\.\d+)/)
-          raise Tebako::Error, "Failed to parse Ruby version from #{out}" unless match
+      def patchelf(src_name, patchelf)
+        return if patchelf.nil?
 
-          ruby_version = match[1]
-        end
-        ruby_version
+        params = [patchelf, "--remove-needed-version", "libpthread.so.0", "GLIBC_PRIVATE", src_name]
+        BuildHelpers.run_with_capture(params)
       end
 
       def strip_or_copy(os_type, src_name, package_name)

data/lib/tebako/packager_lite.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2023-2024 [Ribose Inc](https://www.ribose.com).
+# All rights reserved.
+# This file is a part of tebako
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+# TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
+# BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+require "pathname"
+require "fileutils"
+
+require_relative "options_manager"
+require_relative "scenario_manager"
+require_relative "package_descriptor"
+require_relative "packager"
+
+module Tebako
+  # Tebako application package descriptor
+  class PackagerLite
+    def initialize(options_manager, scenario_manager)
+      @opts = options_manager
+      @scm = scenario_manager
+      @scm.configure_scenario
+    end
+
+    def codegen
+      puts "-- Generating files"
+      Tebako::Codegen.generate_package_descriptor(@opts, @scm)
+    end
+
+    def create_implib
+      rv = Tebako::RubyVersion.new(@opts.ruby_ver)
+      bname = if @opts.mode == "application"
+                @opts.ref
+              else # @opts.mode == "both"
+                @opts.package
+              end
+      Tebako::Packager.create_implib(@opts.ruby_src_dir, @opts.data_src_dir, bname, rv)
+    end
+
+    def create_package
+      deploy
+      FileUtils.rm_f(name)
+      Tebako::Packager.mkdwarfs(@opts.deps_bin_dir, name, @opts.data_src_dir, codegen)
+      puts "Created tebako package at \"#{name}\""
+    end
+
+    def deploy
+      Tebako::Packager.init(@opts.stash_dir, @opts.data_src_dir, @opts.data_pre_dir, @opts.data_bin_dir)
+      create_implib if @scm.msys?
+      Tebako::Packager.deploy(@opts.data_src_dir, @opts.data_pre_dir, @opts.rv, @opts.root, @scm.fs_entrance, @opts.cwd)
+    end
+
+    def name
+      bname = Pathname.new(@opts.package).cleanpath.to_s
+      @name ||= "#{bname}.tebako"
+    end
+  end
+end

data/lib/tebako/scenario_manager.rb

@@ -35,7 +35,7 @@ module Tebako
   class ScenarioManager
     def initialize(fs_root, fs_entrance)
       initialize_root(fs_root)
-      initialize_entry_point(fs_entrance)
+      initialize_entry_point(fs_entrance || "stub.rb")
     end
 
     attr_reader :fs_entry_point, :fs_mount_point, :fs_entrance