tebako 0.12.9 → 0.12.10

data/lib/tebako/packager/pass2_patch.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2021-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_relative "patch_literals"
+require_relative "patch_main"
+require_relative "patch_libraries"
+require_relative "patch_helpers"
+require_relative "patch_buildsystem"
+
+# Tebako - an executable packager
+module Tebako
+  module Packager
+    # Ruby patching definitions (pass2)
+    class Pass2Patch < Patch
+      def initialize(ostype, deps_lib_dir, ruby_ver)
+        super()
+        @ostype = ostype
+        @scmb = ScenarioManagerBase.new(@ostype)
+        @deps_lib_dir = deps_lib_dir
+        @ruby_ver = ruby_ver
+      end
+
+      def patch_map
+        patch_map = patch_map_base
+        patch_map.store("thread_pthread.c", LINUX_MUSL_THREAD_PTHREAD_PATCH) if @scmb.musl?
+        if @scmb.msys?
+          patch_map.merge!(msys_patches)
+        elsif @ruby_ver.ruby3x?
+          patch_map.store("common.mk", COMMON_MK_PATCH)
+        end
+        extend_patch_map_r33(patch_map)
+        patch_map.store("prism_compile.c", PRISM_PATCHES) if @ruby_ver.ruby34?
+        patch_map
+      end
+
+      private
+
+      include Tebako::Packager::PatchBuildsystem
+      include Tebako::Packager::PatchLiterals
+      def extend_patch_map_r33(patch_map)
+        if @ruby_ver.ruby33? || @scmb.msys?
+          patch_map.store("config.status",
+                          get_config_status_patch(@ostype, @deps_lib_dir, @ruby_ver))
+        end
+        patch_map
+      end
+
+      def dir_c_patch
+        pattern = ScenarioManagerBase.new.msys? ? "/* define system APIs */" : "#ifdef HAVE_GETATTRLIST"
+        patch = PatchHelpers.patch_c_file_pre(pattern)
+        patch.merge!(DIR_C_BASE_PATCH)
+        patch
+      end
+
+      def dln_c_patch
+        pattern = "#ifndef dln_loaderror"
+        # Not using substitutions of dlxxx functions on Windows
+        patch = {
+          pattern => "#{@scmb.msys? ? C_FILE_SUBST_LESS : C_FILE_SUBST}\n#{pattern}\n"
+        }
+
+        if @scmb.msys?
+          patch.merge!(@ruby_ver.ruby32? ? DLN_C_MSYS_PATCH : DLN_C_MSYS_PATCH_PRE32)
+        end
+
+        patch
+      end
+
+      def io_c_msys_patch
+        patch = @ruby_ver.ruby32? ? IO_C_MSYS_PATCH : IO_C_MSYS_PATCH_PRE_32
+        patch.merge(IO_C_MSYS_BASE_PATCH)
+      end
+
+      def io_c_patch
+        patch = PatchHelpers.patch_c_file_pre("/* define system APIs */")
+        patch.merge!(io_c_msys_patch) if @scmb.msys?
+        patch
+      end
+
+      def util_c_patch
+        if @ruby_ver.ruby31?
+          PatchHelpers.patch_c_file_post("#endif /* !HAVE_GNU_QSORT_R */")
+        else
+          PatchHelpers.patch_c_file_pre("#ifndef S_ISDIR")
+        end
+      end
+
+      def tool_mkconfig_rb_patch
+        subst = @scmb.msys? ? TOOL_MKCONFIG_RB_SUBST_MSYS : TOOL_MKCONFIG_RB_SUBST
+        {
+          "    if fast[name]" => subst
+        }
+      end
+
+      def msys_patches
+        {
+          "cygwin/GNUmakefile.in" => get_gnumakefile_in_patch_p2(@ruby_ver),
+          "ruby.c" => RUBY_C_MSYS_PATCHES,
+          "win32/file.c" => WIN32_FILE_C_MSYS_PATCHES,
+          "win32/win32.c" => WIN32_WIN32_C_MSYS_PATCHES
+        }
+      end
+
+      def patch_map_base
+        {
+          "template/Makefile.in" => template_makefile_in_patch,
+          "tool/mkconfig.rb" => tool_mkconfig_rb_patch,
+          "dir.c" => dir_c_patch, "dln.c" => dln_c_patch,
+          "io.c" => io_c_patch, "main.c" => PatchMain.get_main_c_patch(@ruby_ver),
+          "file.c" => PatchHelpers.patch_c_file_pre("/* define system APIs */"),
+          "util.c" => util_c_patch
+        }
+      end
+
+      def mlibs_subst
+        yjit_libs = @ruby_ver.ruby32only? ? "$(YJIT_LIBS) " : ""
+        {
+          "MAINLIBS = #{yjit_libs}@MAINLIBS@" =>
+            "# -- Start of tebako patch -- \n" \
+            "MAINLIBS = #{yjit_libs}#{PatchLibraries.mlibs(@ostype, @deps_lib_dir, @ruby_ver, true)}\n" \
+            "# -- End of tebako patch -- \n"
+        }
+      end
+
+      def template_makefile_in_patch
+        template_makefile_in_patch_two(@ruby_ver).merge(mlibs_subst)
+      end
+    end
+  end
+end

data/lib/tebako/packager/patch_buildsystem.rb

@@ -77,8 +77,8 @@ module Tebako
         "$(EXTOBJS) $(LIBRUBYARG_STATIC) $(OUTFLAG)$@\n" \
         "# -- End of tebako patch --"
 
-      def template_makefile_in_subst(ostype, ruby_ver)
-        if PatchHelpers.msys?(ostype)
+      def template_makefile_in_subst(ruby_ver)
+        if ScenarioManagerBase.new.msys?
           TEMPLATE_MAKEFILE_IN_BASE_PATCH_MSYS
         elsif !ruby_ver.ruby31?
           TEMPLATE_MAKEFILE_IN_BASE_PATCH_PRE_3_1
@@ -87,16 +87,20 @@ module Tebako
         end
       end
 
-      def template_makefile_in_patch_two(ostype, ruby_ver)
+      def template_makefile_in_patch_two(ruby_ver)
         if !ruby_ver.ruby31?
-          { TEMPLATE_MAKEFILE_IN_BASE_PATTERN_PRE_3_1 => template_makefile_in_subst(ostype, ruby_ver) }
+          { TEMPLATE_MAKEFILE_IN_BASE_PATTERN_PRE_3_1 => template_makefile_in_subst(ruby_ver) }
         elsif !ruby_ver.ruby33?
-          { TEMPLATE_MAKEFILE_IN_BASE_PATTERN_PRE_3_3 => template_makefile_in_subst(ostype, ruby_ver) }
+          { TEMPLATE_MAKEFILE_IN_BASE_PATTERN_PRE_3_3 => template_makefile_in_subst(ruby_ver) }
         else
-          { TEMPLATE_MAKEFILE_IN_BASE_PATTERN => template_makefile_in_subst(ostype, ruby_ver) }
+          { TEMPLATE_MAKEFILE_IN_BASE_PATTERN => template_makefile_in_subst(ruby_ver) }
         end
       end
 
+      GNUMAKEFILE_IN_DLLTOOL_SUBST = <<~SUBST
+        $(Q) dlltool --output-lib=$(LIBRUBY) --output-def=tebako.def --export-all $(LIBRUBY_A) --output-exp=$(RUBY_EXP)   # tebako patched
+      SUBST
+
       # This MSYS specific thing ensure compilation of winmain.c
       # Did try to understand why it did not work out of the box
       GNUMAKEFILE_IN_WINMAIN_SUBST = <<~SUBST

data/lib/tebako/packager/patch_helpers.rb

@@ -62,18 +62,6 @@ module Tebako
           out
         end
 
-        def exe_suffix(ostype)
-          msys?(ostype) ? ".exe" : ""
-        end
-
-        def msys?(ostype)
-          ostype =~ /msys|cygwin|mingw/
-        end
-
-        def macos?(ostype)
-          ostype =~ /darwin/
-        end
-
         def patch_c_file_pre(pattern)
           {
             pattern => "#{PatchLiterals::C_FILE_SUBST}\n#{pattern}"

data/lib/tebako/packager/rubygems_patch.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2024-2025 [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_relative "patch"
+# Tebako - an executable packager
+module Tebako
+  module Packager
+    # Shared accross Pass1Patch and RybugemsUpdatePatch
+    class RubygemsPatch < Patch
+      RUBYGEMS_OPENSSL_RB_SUBST = <<~SUBST
+        # Start of tebako patch
+        require "openssl"
+        # End of tebako patch
+        autoload :OpenSSL, "openssl"
+      SUBST
+
+      RUBYGEMS_OPENSSL_RB_PATCH = {
+        'autoload :OpenSSL, "openssl"' => RUBYGEMS_OPENSSL_RB_SUBST
+      }.freeze
+
+      def initialize(mount_point)
+        super()
+        @mount_point = mount_point
+      end
+
+      protected
+
+      def rubygems_path_support_patch(mount_point)
+        patch = <<~SUBST
+          # -- Start of tebako patch --
+              @home = Gem.default_dir unless @home.index("#{mount_point}") == 0 unless env["TEBAKO_PASS_THROUGH"]
+          # -- End of tebako patch --
+              @path = split_gem_path env["GEM_PATH"], @home
+          # -- Start of tebako patch --
+              @path.keep_if do |xpath|
+                xpath.index("#{mount_point}") == 0
+              end unless env["TEBAKO_PASS_THROUGH"]
+          # -- End of tebako patch --
+        SUBST
+
+        {
+          '  @path = split_gem_path env["GEM_PATH"], @home' => patch
+        }
+      end
+    end
+
+    # Rubygems patch after update
+    class RubygemsUpdatePatch < RubygemsPatch
+      def patch_map
+        pm = {
+          "rubygems/openssl.rb" => RUBYGEMS_OPENSSL_RB_PATCH,
+          "rubygems/path_support.rb" => rubygems_path_support_patch(@mount_point)
+        }
+        pm.merge!(super)
+        pm.freeze
+      end
+    end
+  end
+end

data/lib/tebako/packager.rb

@@ -35,7 +35,7 @@ require_relative "ruby_builder"
 require_relative "stripper"
 require_relative "packager/pass1_patch"
 require_relative "packager/pass1a_patch"
-require_relative "packager/pass2"
+require_relative "packager/pass2_patch"
 require_relative "packager/patch_helpers"
 
 # Tebako - an executable packager
@@ -89,15 +89,20 @@ module Tebako
         Tebako::Stripper.strip(deploy_helper, target_dir)
       end
 
-      def finalize(os_type, src_dir, app_name, ruby_ver, patchelf)
+      def do_patch(patch_map, root)
+        patch_map.each { |fname, mapping| PatchHelpers.patch_file("#{root}/#{fname}", mapping) }
+      end
+
+      def finalize(src_dir, app_name, ruby_ver, patchelf)
         puts "-- Running finalize script"
 
         RubyBuilder.new(ruby_ver, src_dir).target_build
-        exe_suffix = Packager::PatchHelpers.exe_suffix(os_type)
+        exe_suffix = ScenarioManagerBase.new.exe_suffix
         src_name = File.join(src_dir, "ruby#{exe_suffix}")
         patchelf(src_name, patchelf)
         package_name = "#{app_name}#{exe_suffix}"
-        strip_or_copy(os_type, src_name, package_name)
+        # strip_or_copy(os_type, src_name, package_name)
+        Tebako::Stripper.strip_file(src_name, package_name)
         puts "Created tebako package at \"#{package_name}\""
       end
 
@@ -145,7 +150,8 @@ module Tebako
       def pass2(ostype, ruby_source_dir, deps_lib_dir, ruby_ver)
         puts "-- Running pass2 script"
 
-        do_patch(Pass2.get_patch_map(ostype, deps_lib_dir, ruby_ver), ruby_source_dir)
+        patch = Pass2Patch.new(ostype, deps_lib_dir, ruby_ver).patch_map
+        do_patch(patch, ruby_source_dir)
       end
 
       # Stash
@@ -183,10 +189,6 @@ module Tebako
         File.join(src_dir, "lib", "libx64-ucrt-ruby#{ruby_ver.lib_version}.a")
       end
 
-      def do_patch(patch_map, root)
-        patch_map.each { |fname, mapping| PatchHelpers.patch_file("#{root}/#{fname}", mapping) }
-      end
-
       def patchelf(src_name, patchelf)
         return if patchelf.nil?
 
@@ -194,15 +196,15 @@ module Tebako
         BuildHelpers.run_with_capture(params)
       end
 
-      def strip_or_copy(os_type, src_name, package_name)
-        # [TODO] On MSys strip sometimes creates a broken executable
-        # https://github.com/tamatebako/tebako/issues/172
-        if Packager::PatchHelpers.msys?(os_type)
-          FileUtils.cp(src_name, package_name)
-        else
-          Tebako::Stripper.strip_file(src_name, package_name)
-        end
-      end
+      # def strip_or_copy(_os_type, src_name, package_name)
+      # [TODO] On MSys strip sometimes creates a broken executable
+      # https://github.com/tamatebako/tebako/issues/172
+      # if Packager::PatchHelpers.msys?(os_type)
+      # FileUtils.cp(src_name, package_name)
+      # else
+      # Tebako::Stripper.strip_file(src_name, package_name)
+      # end
+      # end
     end
   end
 end

data/lib/tebako/ruby_builder.rb

@@ -37,7 +37,7 @@ module Tebako
     def initialize(ruby_ver, src_dir)
       @ruby_ver = ruby_ver
       @src_dir = src_dir
-      @ncores = BuildHelpers.ncores
+      @ncores = ScenarioManagerBase.new.ncores
     end
 
     # Final build of tebako package

data/lib/tebako/ruby_version.rb

@@ -120,8 +120,7 @@ module Tebako
     end
 
     def version_check_msys
-      if Gem::Version.new(@ruby_version) < Gem::Version.new(MIN_RUBY_VERSION_WINDOWS) &&
-         RUBY_PLATFORM =~ /msys|mingw|cygwin/
+      if Gem::Version.new(@ruby_version) < Gem::Version.new(MIN_RUBY_VERSION_WINDOWS) && ScenarioManagerBase.new.msys?
         raise Tebako::Error.new("Ruby version #{@ruby_version} is not supported on Windows", 111)
       end
     end
@@ -132,14 +131,14 @@ module Tebako
     def initialize(ruby_version, gemfile_path)
       # Assuming that it does not attempt to load any gems or resolve dependencies
       # this can be done with any bundler version
-      gemfile = Bundler::Definition.build(gemfile_path, nil, nil)
-      ruby_v = gemfile.ruby_version&.versions
+      ruby_v = Bundler::Definition.build(gemfile_path, nil, nil).ruby_version&.versions
       if ruby_v.nil?
         super(ruby_version)
       else
         process_gemfile_ruby_version(ruby_version, ruby_v)
-        run_checks
       end
+    rescue Tebako::Error
+      raise
     rescue StandardError => e
       Tebako.packaging_error(115, e.message)
     end
@@ -153,12 +152,13 @@ module Tebako
       else
         process_gemfile_ruby_version_d(ruby_version, requirement)
       end
+      run_checks
     end
 
     def process_gemfile_ruby_version_d(ruby_version, requirement)
       current_version = Gem::Version.new(ruby_version)
       unless requirement.satisfied_by?(current_version)
-        raise Tebako::Error.new("Ruby version #{ruby_version} does not satisfy requirement #{ruby_v}", 116)
+        raise Tebako::Error.new("Ruby version #{ruby_version} does not satisfy requirement '#{requirement}'", 116)
       end
 
       @ruby_version = ruby_version

data/lib/tebako/scenario_manager.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright (c) 2024 [Ribose Inc](https://www.ribose.com).
+# Copyright (c) 2024-2025 [Ribose Inc](https://www.ribose.com).
 # All rights reserved.
 # This file is a part of tebako
 #
@@ -32,64 +32,99 @@ require_relative "error"
 
 # Tebako - an executable packager
 module Tebako
-  # Manages packaging scenario based on input files (gemfile, gemspec, etc)
-  class ScenarioManager
-    def initialize(fs_root, fs_entrance)
-      @with_gemfile = false
-      initialize_root(fs_root)
-      initialize_entry_point(fs_entrance || "stub.rb")
+  # Magic version numbers used to ensure compatibility for Ruby 2.7.x, 3.0.x
+  # These are the minimal versions required to provide linux-gnu / linux-musl differentiation by bundler
+  # Ruby 3.1+ default rubygems versions work correctly out of the box
+  BUNDLER_VERSION = "2.4.22"
+  RUBYGEMS_VERSION = "3.4.22"
+
+  # A couple of static Scenario definitions
+  class ScenarioManagerBase
+    def initialize(ostype = RUBY_PLATFORM)
+      @ostype = ostype
+      @linux = @ostype =~ /linux/ ? true : false
+      @musl = @ostype =~ /linux-musl/ ? true : false
+      @macos = @ostype =~ /darwin/ ? true : false
+      @msys  = @ostype =~ /msys|mingw|cygwin/ ? true : false
+
+      @fs_mount_point = @msys ? "A:/__tebako_memfs__" : "/__tebako_memfs__"
+      @exe_suffix = @msys ? ".exe" : ""
     end
 
-    attr_reader :fs_entry_point, :fs_mount_point, :fs_entrance, :gemfile_path, :with_gemfile
+    attr_reader :fs_mount_point, :exe_suffix
 
-    def configure_scenario
-      @fs_mount_point = if msys?
-                          "A:/__tebako_memfs__"
-                        else
-                          "/__tebako_memfs__"
-                        end
+    def b_env
+      u_flags = if @macos
+                  "-DTARGET_OS_SIMULATOR=0 -DTARGET_OS_IPHONE=0  #{ENV.fetch("CXXFLAGS", nil)}"
+                else
+                  ENV.fetch("CXXFLAGS", nil)
+                end
+      @b_env ||= { "CXXFLAGS" => u_flags }
+    end
 
-      lookup_files
-      configure_scenario_inner
+    def linux?
+      @linux
     end
 
-    def exe_suffix
-      @exe_suffix ||= msys? ? ".exe" : ""
+    def m_files
+      # [TODO]
+      # Ninja generates incorrect script for tebako press target -- gets lost in a chain custom targets
+      # Using makefiles has negative performance impact so it needs to be fixed
+
+      @m_files ||= if @linux || @macos
+                     "Unix Makefiles"
+                   elsif @msys
+                     "MinGW Makefiles"
+                   else
+                     raise Tebako::Error.new("#{RUBY_PLATFORM} is not supported.", 112)
+                   end
     end
 
     def macos?
-      @macos ||= RUBY_PLATFORM =~ /darwin/ ? true : false
+      @macos
     end
 
     def msys?
-      @msys ||= RUBY_PLATFORM =~ /msys|mingw|cygwin/ ? true : false
+      @msys
     end
 
-    private
-
-    def initialize_entry_point(fs_entrance)
-      @fs_entrance = Pathname.new(fs_entrance).cleanpath.to_s
+    def musl?
+      @musl
+    end
 
-      if Pathname.new(@fs_entrance).absolute?
-        Tebako.packaging_error 114 unless @fs_entrance.start_with?(@fs_root)
+    def ncores
+      if @ncores.nil?
+        if @macos
+          out, st = Open3.capture2e("sysctl", "-n", "hw.ncpu")
+        else
+          out, st = Open3.capture2e("nproc", "--all")
+        end
 
-        fetmp = @fs_entrance
-        @fs_entrance = Pathname.new(@fs_entrance).relative_path_from(Pathname.new(@fs_root)).to_s
-        puts "-- Absolute path to entry point '#{fetmp}' will be reduced to '#{@fs_entrance}' relative to '#{@fs_root}'"
+        @ncores = !st.signaled? && st.exitstatus.zero? ? out.strip.to_i : 4
       end
-      # Can check after deploy, because entry point can be generated during bundle install or gem install
-      # Tebako.packaging_error 106 unless File.file?(File.join(@fs_root, @fs_entrance))
-      @fs_entry_point = "/bin/#{@fs_entrance}"
+      @ncores
     end
+  end
 
-    def initialize_root(fs_root)
-      Tebako.packaging_error 107 unless Dir.exist?(fs_root)
-      p_root = Pathname.new(fs_root).cleanpath
-      Tebako.packaging_error 113 unless p_root.absolute?
-      @fs_root = p_root.realpath.to_s
+  # Manages packaging scenario based on input files (gemfile, gemspec, etc)
+  class ScenarioManager < ScenarioManagerBase
+    def initialize(fs_root, fs_entrance)
+      super()
+      @with_gemfile = @with_lockfile = @needs_bundler = false
+      @bundler_version = BUNDLER_VERSION
+      initialize_root(fs_root)
+      initialize_entry_point(fs_entrance || "stub.rb")
+    end
+
+    attr_reader :fs_entry_point, :fs_entrance, :gemfile_path, :needs_bundler, :with_gemfile
+
+    def bundler_reference
+      @needs_bundler ? "_#{@bundler_version}_" : nil
     end
 
-    def configure_scenario_inner
+    def configure_scenario
+      lookup_files
+
       case @gs_length
       when 0
         configure_scenario_no_gemspec
@@ -100,6 +135,8 @@ module Tebako
       end
     end
 
+    private
+
     def configure_scenario_no_gemspec
       @fs_entry_point = "/local/#{@fs_entrance}" if @with_gemfile || @g_length.zero?
 
@@ -112,11 +149,93 @@ module Tebako
                   end
     end
 
+    def initialize_entry_point(fs_entrance)
+      @fs_entrance = Pathname.new(fs_entrance).cleanpath.to_s
+
+      if Pathname.new(@fs_entrance).absolute?
+        Tebako.packaging_error 114 unless @fs_entrance.start_with?(@fs_root)
+
+        fetmp = @fs_entrance
+        @fs_entrance = Pathname.new(@fs_entrance).relative_path_from(Pathname.new(@fs_root)).to_s
+        puts "-- Absolute path to entry point '#{fetmp}' will be reduced to '#{@fs_entrance}' relative to '#{@fs_root}'"
+      end
+      # Can check after deploy, because entry point can be generated during bundle install or gem install
+      # Tebako.packaging_error 106 unless File.file?(File.join(@fs_root, @fs_entrance))
+      @fs_entry_point = "/bin/#{@fs_entrance}"
+    end
+
+    def initialize_root(fs_root)
+      Tebako.packaging_error 107 unless Dir.exist?(fs_root)
+      p_root = Pathname.new(fs_root).cleanpath
+      Tebako.packaging_error 113 unless p_root.absolute?
+      @fs_root = p_root.realpath.to_s
+    end
+
     def lookup_files
-      @gemfile_path = File.join(@fs_root, "Gemfile")
       @gs_length = Dir.glob(File.join(@fs_root, "*.gemspec")).length
-      @with_gemfile = File.exist?(@gemfile_path)
       @g_length = Dir.glob(File.join(@fs_root, "*.gem")).length
+      @with_gemfile = File.exist?(@gemfile_path = File.join(@fs_root, "Gemfile"))
+      @with_lockfile = File.exist?(@lockfile_path = File.join(@fs_root, "Gemfile.lock"))
+    end
+  end
+
+  # Configure scenraio and do bundler resolution
+  class ScenarioManagerWithBundler < ScenarioManager
+    protected
+
+    def lookup_files
+      super
+      if @with_lockfile
+        update_bundler_version_from_lockfile(@lockfile_path)
+      elsif @with_gemfile
+        update_bundler_version_from_gemfile(@gemfile_path)
+      end
+    end
+
+    private
+
+    def store_compatible_bundler_version(requirement)
+      fetcher = Gem::SpecFetcher.fetcher
+      tuples = fetcher.detect(:released) do |name_tuple|
+        name_tuple.name == "bundler" && requirement.satisfied_by?(name_tuple.version)
+      end
+
+      Tebako.packaging_error 119 if tuples.empty?
+
+      # Get latest compatible version
+      @bundler_version = tuples.map { |tuple, _| tuple.version }.max.to_s
+    end
+
+    def update_bundler_version_from_gemfile(gemfile_path)
+      # Build definition without lockfile
+      definition = Bundler::Definition.build(gemfile_path, nil, nil)
+
+      # Get bundler dependency from Gemfile
+      bundler_dep = definition.dependencies.find { |d| d.name == "bundler" }
+
+      return unless bundler_dep
+
+      @needs_bundler = true
+      min_requirement = Gem::Requirement.create(">= #{Tebako::BUNDLER_VERSION}")
+      requirement = Gem::Requirement.create(bundler_dep.requirement, min_requirement)
+
+      store_compatible_bundler_version(requirement)
+    end
+
+    def update_bundler_version_from_lockfile(lockfile_path)
+      puts "   ... using lockfile at #{@lockfile_path}"
+      Tebako.packaging_error 117 unless File.exist?(lockfile_path)
+
+      lockfile_content = File.read(lockfile_path)
+      Tebako.packaging_error 117 unless lockfile_content =~ /BUNDLED WITH\n\s+(#{Gem::Version::VERSION_PATTERN})\n/
+
+      @bundler_version = ::Regexp.last_match(1)
+      @needs_bundler = true
+
+      bundler_requirement = Gem::Requirement.new(">= #{BUNDLER_VERSION}")
+      return if bundler_requirement.satisfied_by?(Gem::Version.new(@bundler_version))
+
+      Tebako.packaging_error 118, " : #{@bundler_version} requested, #{BUNDLER_VERSION} minimum required"
     end
   end
 end

data/lib/tebako/version.rb

@@ -26,5 +26,5 @@
 # POSSIBILITY OF SUCH DAMAGE.
 
 module Tebako
-  VERSION = "0.12.9"
+  VERSION = "0.12.10"
 end