tebako 0.9.2 → 0.10.0

data/common.env

@@ -1,5 +1,5 @@
 BUILD_TYPE=Release
 DEPS=deps
 INCBIN_TAG=348e36b
-DWARFS_WR_TAG=v0.7.1
+DWARFS_WR_TAG=v0.8.3
 RUBY_VER=3.2.5

data/exe/tebako-packager

@@ -27,6 +27,7 @@
 # POSSIBILITY OF SUCH DAMAGE.
 
 require_relative "../lib/tebako/packager"
+require_relative "../lib/tebako/ruby_version"
 require_relative "../lib/tebako/stripper"
 require_relative "../lib/tebako/build_helpers"
 
@@ -73,31 +74,6 @@ begin
     ruby_ver = Tebako::RubyVersion.new(ARGV[6])
     Tebako::Packager.stash(ARGV[4], ARGV[5])
     Tebako::Packager.pass2(ARGV[1], ARGV[2], ARGV[3], ruby_ver)
-  when "deploy"
-    #       ARGV[0] -- command
-    #       ARGV[1] -- OSTYPE
-    #       ARGV[2] -- RUBY_SOURCE_DIR
-    #       ARGV[3] -- FS_STASH_DIR
-    #       ARGV[4] -- DATA_SRC_DIR
-    #       ARGV[5] -- DATA_PRE_DIR
-    #       ARGV[6] -- DATA_BIN_DIR
-    #       ARGV[7] -- FS_ROOT
-    #       ARGV[8] -- FS_ENTRANCE
-    #       ARGV[9] -- FS_MOUNT_POINT
-    #       ARGV[10] -- APP_NAME
-    #       ARGV[11] -- RUBY_VER
-    #       ARGV[12] -- CWD
-    unless ARGV.length == 13 || ARGV.length == 12
-      raise Tebako::Error,
-            "tebako-packager deploy command expects 12 or 13 arguments, #{ARGV.length} has been provided."
-    end
-    ruby_ver = Tebako::RubyVersion.new(ARGV[11])
-    Tebako::Packager.init(ARGV[3], ARGV[4], ARGV[5], ARGV[6])
-    Tebako::Packager.create_implib(ARGV[2], ARGV[4], File.basename(ARGV[10]), ruby_ver) if ARGV[1] =~ /msys/
-    # Assume that "<TARGET_BIN_DIR (TBD)>" is <DATA_SRC_DIR>/bin"
-    # That shall match CMakeLists.txt settings
-    Tebako::Packager.deploy(ARGV[1], ARGV[4], ARGV[5], ruby_ver, ARGV[7], ARGV[8], ARGV[9],
-                            ARGV.length == 13 ? ARGV[12] : nil)
 
   when "finalize"
     #       ARGV[0] -- command

data/lib/tebako/build_helpers.rb

@@ -81,43 +81,4 @@ module Tebako
       end
     end
   end
-
-  # Ruby version checks
-  class RubyVersion
-    def initialize(ruby_ver)
-      unless ruby_ver =~ /^\d+\.\d+\.\d+$/
-        raise Tebako::Error, "Invalid Ruby version format '#{ruby_ver}'. Expected format: x.y.z"
-      end
-
-      @ruby_ver = ruby_ver
-    end
-
-    def ruby3x?
-      @ruby3x ||= @ruby_ver[0] == "3"
-    end
-
-    def ruby31?
-      @ruby31 ||= ruby3x? && @ruby_ver[2].to_i >= 1
-    end
-
-    def ruby32?
-      @ruby32 ||= ruby3x? && @ruby_ver[2].to_i >= 2
-    end
-
-    def ruby32only?
-      @ruby32only ||= ruby3x? && @ruby_ver[2] == "2"
-    end
-
-    def ruby33?
-      @ruby33 ||= ruby3x? && @ruby_ver[2].to_i >= 3
-    end
-
-    def api_version
-      @api_version ||= "#{@ruby_ver.split(".")[0..1].join(".")}.0"
-    end
-
-    def lib_version
-      @lib_version ||= "#{@ruby_ver.split(".")[0..1].join}0"
-    end
-  end
 end

data/lib/tebako/cache_manager.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+# Copyright (c) 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 "fileutils"
+require_relative "version"
+
+# Tebako - an executable packager
+module Tebako
+  # Cache management
+  class CacheManager
+    E_VERSION_FILE = ".environment.version"
+
+    def initialize(deps, src_dir, out_dir)
+      @deps = deps
+      @src_dir = src_dir
+      @out_dir = out_dir
+    end
+
+    def clean_cache
+      puts "Cleaning tebako packaging environment"
+      # Using File.join(deps, "") to ensure that the slashes are appropriate
+      FileUtils.rm_rf([File.join(@deps, ""), File.join(@out_dir, "")], secure: true)
+    end
+
+    def clean_output
+      puts "Cleaning CMake cache and Ruby build files"
+
+      nmr = "src/_ruby_*"
+      nms = "stash_*"
+      FileUtils.rm_rf(Dir.glob(File.join(@deps, nmr)), secure: true)
+      FileUtils.rm_rf(Dir.glob(File.join(@deps, nms)), secure: true)
+
+      # Using File.join(output_folder, "") to ensure that the slashes are appropriate
+      FileUtils.rm_rf(File.join(@out_dir, ""), secure: true)
+    end
+
+    def ensure_version_file
+      version_file_path = File.join(@deps, E_VERSION_FILE)
+
+      begin
+        File.write(version_file_path, version_key)
+        # puts "Set version information for tebako packaging environment to #{Tebako::VERSION}"
+      rescue StandardError => e
+        puts "#{Tebako::PACKAGING_ERRORS[201]} #{E_VERSION_FILE}: #{e.message}"
+      end
+    end
+
+    def version_key
+      @version_key ||= "#{Tebako::VERSION} at #{@src_dir}"
+    end
+
+    def version_cache
+      version_file_path = File.join(@deps, E_VERSION_FILE)
+      file_version = File.open(version_file_path, &:readline).strip
+      file_version.match(/(?<version>.+) at (?<source>.+)/)
+    end
+
+    def version_cache_check
+      match_data = version_cache
+      return version_unknown unless match_data
+
+      if match_data[:version] != Tebako::VERSION
+        version_mismatch(match_data[:version])
+      elsif match_data[:source] != @src_dir
+        version_source_mismatch(match_data[:source])
+      end
+    rescue StandardError
+      version_unknown
+    end
+
+    def version_mismatch(cached_version)
+      puts "Tebako cache was created by a gem version #{cached_version} " \
+           "and cannot be used for gem version #{Tebako::VERSION}"
+      clean_cache
+    end
+
+    def version_source_mismatch(cached_source)
+      puts "CMake cache was created for a different source directory '#{cached_source}' " \
+           "and cannot be used for '#{@src_dir}'"
+      clean_output
+    end
+
+    def version_unknown
+      puts "CMake cache version was not recognized, cleaning up"
+      clean_cache
+    end
+  end
+end

data/lib/tebako/cli.rb

@@ -32,9 +32,10 @@ require "open3"
 require "thor"
 require "yaml"
 
+require_relative "cache_manager"
 require_relative "cli_helpers"
-require_relative "cli_rubies"
 require_relative "error"
+require_relative "ruby_version"
 require_relative "version"
 
 # Tebako - an executable packager
@@ -52,20 +53,23 @@ module Tebako
                             desc: "tebako configuration file 'tebafile', '$PWD/.tebako.yml' by default"
     desc "clean", "Clean tebako packaging environment"
     def clean
-      clean_cache
+      (_, cm) = bootstrap
+      cm.clean_cache
     end
 
     desc "clean_ruby", "Clean Ruby source from tebako packaging environment"
     method_option :Ruby, type: :string, aliases: "-R", required: false,
-                         enum: Tebako::CliRubies::RUBY_VERSIONS.keys,
+                         enum: Tebako::RubyVersion::RUBY_VERSIONS.keys,
                          desc: "Ruby version to clean, all available versions by default"
     def clean_ruby
       puts "Cleaning Ruby sources from tebako packaging environment"
+      (om,) = bootstrap
+
       suffix = options["Ruby"].nil? ? "" : "_#{options["Ruby"]}"
       nmr = "src/_ruby#{suffix}*"
       nms = "stash#{suffix}*"
-      FileUtils.rm_rf(Dir.glob(File.join(deps, nmr)), secure: true)
-      FileUtils.rm_rf(Dir.glob(File.join(deps, nms)), secure: true)
+      FileUtils.rm_rf(Dir.glob(File.join(om.deps, nmr)), secure: true)
+      FileUtils.rm_rf(Dir.glob(File.join(om.deps, nms)), secure: true)
     end
 
     desc "hash", "Print build script hash (ci cache key)"
@@ -95,16 +99,15 @@ module Tebako
                            desc: "Tebako package file name, entry point base file name in the current folder by default"
     method_option :root, type: :string, aliases: "-r", required: true, desc: "Root folder of the Ruby application"
     method_option :Ruby, type: :string, aliases: "-R", required: false,
-                         enum: Tebako::CliRubies::RUBY_VERSIONS.keys,
-                         desc: "Tebako package Ruby version, #{Tebako::CliRubies::DEFAULT_RUBY_VERSION} by default"
+                         enum: Tebako::RubyVersion::RUBY_VERSIONS.keys,
+                         desc: "Tebako package Ruby version, #{Tebako::RubyVersion::DEFAULT_RUBY_VERSION} by default"
     method_option :patchelf, aliases: "-P", type: :boolean,
                              desc: RGP_DESCRIPTION
     def press
-      version_cache_check unless options[:devmode]
+      (om, cm) = bootstrap
 
-      puts press_announce
-      do_press
-      ensure_version_file
+      do_press(om)
+      cm.ensure_version_file
     rescue Tebako::Error => e
       puts "Tebako script failed: #{e.message} [#{e.error_code}]"
       exit e.error_code
@@ -112,14 +115,13 @@ module Tebako
 
     desc "setup", "Set up tebako packaging environment"
     method_option :Ruby, type: :string, aliases: "-R", required: false,
-                         enum: Tebako::CliRubies::RUBY_VERSIONS.keys,
-                         desc: "Tebako package Ruby version, #{Tebako::CliRubies::DEFAULT_RUBY_VERSION} by default."
+                         enum: Tebako::RubyVersion::RUBY_VERSIONS.keys,
+                         desc: "Tebako package Ruby version, #{Tebako::RubyVersion::DEFAULT_RUBY_VERSION} by default."
     def setup
-      version_cache_check unless options[:devmode]
+      (om, cm) = bootstrap
 
-      puts "Setting up tebako packaging environment"
-      do_setup
-      ensure_version_file
+      do_setup(om)
+      cm.ensure_version_file
     rescue Tebako::Error => e
       puts "Tebako script failed: #{e.message} [#{e.error_code}]"
       exit e.error_code
@@ -130,6 +132,14 @@ module Tebako
     end
 
     no_commands do
+      def bootstrap
+        options_manager = Tebako::OptionsManager.new(options)
+        cache_manager = Tebako::CacheManager.new(options_manager.deps, options_manager.source,
+                                                 options_manager.output_folder)
+        cache_manager.version_cache_check unless options[:devmode]
+        [options_manager, cache_manager]
+      end
+
       def initialize(*args)
         super
         return if args[2][:current_command].name.include?("hash")
@@ -151,7 +161,6 @@ module Tebako
 
     no_commands do
       include Tebako::CliHelpers
-      include Tebako::CliRubies
     end
   end
 end

data/lib/tebako/cli_helpers.rb

@@ -30,123 +30,56 @@ require "fileutils"
 require "pathname"
 require "rbconfig"
 
-require_relative "cli_rubies"
+require_relative "codegen"
 require_relative "error"
-require_relative "version"
+require_relative "options_manager"
+require_relative "scenario_manager"
 
 # Tebako - an executable packager
 # Command-line interface methods
 module Tebako
-  E_VERSION_FILE = ".environment.version"
   # Cli helpers
   module CliHelpers
-    def b_env
-      u_flags = if RbConfig::CONFIG["host_os"] =~ /darwin/
-                  "-DTARGET_OS_SIMULATOR=0 -DTARGET_OS_IPHONE=0  #{ENV.fetch("CXXFLAGS", nil)}"
-                else
-                  ENV.fetch("CXXFLAGS", nil)
-                end
-      @b_env ||= { "CXXFLAGS" => u_flags }
-    end
-
-    def cfg_options
-      ruby_ver, ruby_hash = extend_ruby_version
-      # Cannot use 'xxx' as parameters because it does not work in Windows shells
-      # So we have to use \"xxx\"
-      @cfg_options ||=
-        "-DCMAKE_BUILD_TYPE=Release -DRUBY_VER:STRING=\"#{ruby_ver}\" -DRUBY_HASH:STRING=\"#{ruby_hash}\" " \
-        "-DDEPS:STRING=\"#{deps}\" -G \"#{m_files}\" -B \"#{output_folder}\" -S \"#{source}\" " \
-        "#{remove_glibc_private} -DTEBAKO_VERSION:STRING=\"#{Tebako::VERSION}\""
-    end
+    def do_press(options_manager)
+      puts options_manager.press_announce
 
-    def clean_cache
-      puts "Cleaning tebako packaging environment"
-      # Using File.join(deps, "") to ensure that the slashes are appropriate
-      FileUtils.rm_rf([File.join(deps, ""), File.join(output_folder, "")], secure: true)
-    end
+      generate_files(options_manager)
 
-    def clean_output
-      puts "Cleaning CMake cache and Ruby build files"
-
-      nmr = "src/_ruby_*"
-      nms = "stash_*"
-      FileUtils.rm_rf(Dir.glob(File.join(deps, nmr)), secure: true)
-      FileUtils.rm_rf(Dir.glob(File.join(deps, nms)), secure: true)
-
-      # Using File.join(output_folder, "") to ensure that the slashes are appropriate
-      FileUtils.rm_rf(File.join(output_folder, ""), secure: true)
-    end
-
-    def deps
-      @deps ||= File.join(prefix, "deps")
-    end
-
-    def do_press
-      cfg_cmd = "cmake -DSETUP_MODE:BOOLEAN=OFF #{cfg_options} #{press_options}"
-      build_cmd = "cmake --build #{output_folder} --target tebako --parallel #{Etc.nprocessors}"
-      merged_env = ENV.to_h.merge(b_env)
+      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)
       Tebako.packaging_error(103) unless system(merged_env, cfg_cmd)
       Tebako.packaging_error(104) unless system(merged_env, build_cmd)
       true
     end
 
-    def do_setup
-      cfg_cmd = "cmake -DSETUP_MODE:BOOLEAN=ON #{cfg_options}"
-      build_cmd = "cmake --build \"#{output_folder}\" --target setup --parallel #{Etc.nprocessors}"
-      merged_env = ENV.to_h.merge(b_env)
+    def do_setup(options_manager)
+      puts "Setting up tebako packaging environment"
+
+      cfg_cmd = "cmake -DSETUP_MODE:BOOLEAN=ON #{options_manager.cfg_options}"
+      build_cmd = "cmake --build \"#{options_manager.output_folder}\" --target setup --parallel #{Etc.nprocessors}"
+      merged_env = ENV.to_h.merge(options_manager.b_env)
       Tebako.packaging_error(101) unless system(merged_env, cfg_cmd)
       Tebako.packaging_error(102) unless system(merged_env, build_cmd)
       true
     end
 
-    def ensure_version_file
-      version_file_path = File.join(deps, E_VERSION_FILE)
+    def generate_files(options_manager)
+      puts "-- Generating files"
+      scenario_manager = Tebako::ScenarioManager.new(options_manager.root, options_manager.fs_entrance)
+      scenario_manager.configure_scenario
 
-      begin
-        File.write(version_file_path, version_key)
-        # puts "Set version information for tebako packaging environment to #{Tebako::VERSION}"
-      rescue StandardError => e
-        puts "An error occurred while creating or updating #{E_VERSION_FILE}: #{e.message}"
-      end
-    end
+      puts "   ... tebako-version.h"
+      v_parts = Tebako::VERSION.split(".")
+      Tebako::Codegen.generate_tebako_version_h(options_manager, v_parts)
 
-    def fs_current
-      fs_current = Dir.pwd
-      if RUBY_PLATFORM =~ /msys|mingw|cygwin/
-        fs_current, cygpath_res = Open3.capture2e("cygpath", "-w", fs_current)
-        Tebako.packaging_error(101) unless cygpath_res.success?
-        fs_current.strip!
-      end
-      @fs_current ||= fs_current
-    end
+      puts "   ... tebako-fs.cpp"
+      Tebako::Codegen.generate_tebako_fs_cpp(options_manager, scenario_manager)
 
-    def l_level
-      @l_level ||= if options["log-level"].nil?
-                     "error"
-                   else
-                     options["log-level"]
-                   end
+      puts "   ... deploy.rb"
+      Tebako::Codegen.generate_deploy_rb(options_manager, scenario_manager)
     end
 
-    # rubocop:disable Metrics/MethodLength
-    def m_files
-      # [TODO]
-      # Ninja generates incorrect script fot tebako press target -- gets lost in a chain custom targets
-      # Using makefiles has negative performance impact so it needs to be fixed
-      @m_files ||= case RUBY_PLATFORM
-                   when /linux/, /darwin/
-                     "Unix Makefiles"
-                   when /msys|mingw|cygwin/
-                     "MinGW Makefiles"
-                   else
-                     raise Tebako::Error.new(
-                       "#{RUBY_PLATFORM} is not supported, exiting",
-                       254
-                     )
-                   end
-    end
-    # rubocop:enable Metrics/MethodLength
-
     def options_from_tebafile(tebafile)
       ::YAML.load_file(tebafile)["options"] || {}
     rescue Psych::SyntaxError => e
@@ -158,134 +91,5 @@ module Tebako
       puts e.message
       {}
     end
-
-    def output_folder
-      @output_folder ||= File.join(prefix, "o")
-    end
-
-    def package
-      package = if options["output"].nil?
-                  File.join(Dir.pwd, File.basename(options["entry-point"], ".*"))
-                else
-                  options["output"]
-                end
-      @package ||= if relative?(package)
-                     File.join(fs_current, package)
-                   else
-                     package
-                   end
-    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"}"
-                                else
-                                  ""
-                                end
-    end
-
-    def handle_nil_prefix
-      env_prefix = ENV.fetch("TEBAKO_PREFIX", nil)
-      if env_prefix.nil?
-        puts "No prefix specified, using ~/.tebako"
-        File.expand_path("~/.tebako")
-      else
-        puts "Using TEBAKO_PREFIX environment variable as prefix"
-        File.expand_path(env_prefix)
-      end
-    end
-
-    def prefix
-      @prefix ||= if options["prefix"].nil?
-                    handle_nil_prefix
-                  elsif options["prefix"] == "PWD"
-                    Dir.pwd
-                  else
-                    File.expand_path(options["prefix"])
-                  end
-    end
-
-    def press_announce
-      cwd_announce = options["cwd"].nil? ? "<Host current directory>" : options["cwd"]
-      @press_announce ||= <<~ANN
-        Running tebako press at #{prefix}
-           Ruby version:              '#{extend_ruby_version[0]}'
-           Project root:              '#{root}'
-           Application entry point:   '#{options["entry-point"]}'
-           Package file name:         '#{package}'
-           Loging level:              '#{l_level}'
-           Package working directory: '#{cwd_announce}'
-      ANN
-    end
-
-    def press_options
-      cwd_option = if options["cwd"].nil?
-                     "-DPACKAGE_NEEDS_CWD:BOOL=OFF"
-                   else
-                     "-DPACKAGE_NEEDS_CWD:BOOL=ON -DPACKAGE_CWD:STRING='#{options["cwd"]}'"
-                   end
-      @press_options ||=
-        "-DROOT:STRING='#{root}' -DENTRANCE:STRING='#{options["entry-point"]}' " \
-        "-DPCKG:STRING='#{package}' -DLOG_LEVEL:STRING='#{options["log-level"]}' " \
-        "#{cwd_option}"
-    end
-
-    def relative?(path)
-      Pathname.new(path).relative?
-    end
-
-    def root
-      @root ||= if relative?(options["root"])
-                  File.join(fs_current, options["root"])
-                else
-                  File.join(options["root"], "")
-                end
-    end
-
-    def source
-      c_path = Pathname.new(__FILE__).realpath
-      @source ||= File.expand_path("../../..", c_path)
-    end
-
-    def version_key
-      @version_key ||= "#{Tebako::VERSION} at #{source}"
-    end
-
-    def version_cache
-      version_file_path = File.join(deps, E_VERSION_FILE)
-      file_version = File.open(version_file_path, &:readline).strip
-      file_version.match(/(?<version>.+) at (?<source>.+)/)
-    end
-
-    def version_cache_check
-      match_data = version_cache
-
-      return version_unknown unless match_data
-
-      if match_data[:version] != Tebako::VERSION
-        version_mismatch(match_data[:version])
-      elsif match_data[:source] != source
-        version_source_mismatch(match_data[:source])
-      end
-    rescue StandardError
-      version_unknown
-    end
-
-    def version_mismatch(cached_version)
-      puts "Tebako cache was created by a gem version #{cached_version} " \
-           "and cannot be used for gem version #{Tebako::VERSION}"
-      clean_cache
-    end
-
-    def version_source_mismatch(cached_source)
-      puts "CMake cache was created for a different source directory '#{cached_source}' " \
-           "and cannot be used for '#{source}'"
-      clean_output
-    end
-
-    def version_unknown
-      puts "CMake cache version was not recognized, cleaning up"
-      clean_cache
-    end
   end
 end