ocran 1.4.3 → 1.4.5

data/src/inst_dir.c

@@ -98,8 +98,50 @@ const char *CreateInstDir(bool is_extract_to_exe_dir)
         return NULL;
     }
 
-    InstDir = inst_dir;
-    return inst_dir;
+    /* Normalize 8.3 short names (e.g. a TEMP under C:\Users\RUNNER~1) so all
+       paths derived from the extraction dir use one consistent spelling. */
+    char *long_dir = ToLongPath(inst_dir);
+    free(inst_dir);
+    if (!long_dir) {
+        return NULL;
+    }
+
+    InstDir = long_dir;
+    return InstDir;
+}
+
+// Sets the installation directory to the executable's own directory
+// (installer/wrapper mode, RUN_IN_EXE_DIR). No directory is created and
+// the directory must never be deleted by the stub.
+const char *SetInstDirToExeDir(void)
+{
+    if (InstDir != NULL) {
+        APP_ERROR("Installation directory has already been set");
+        return NULL;
+    }
+
+    char *image_path = GetImagePath();
+    if (!image_path) {
+        APP_ERROR("Failed to get executable name");
+        return NULL;
+    }
+
+    char *image_dir = GetParentPath(image_path);
+    free(image_path);
+    if (!image_dir) {
+        APP_ERROR("Failed to obtain the directory path of the executable file");
+        return NULL;
+    }
+
+    /* Normalize 8.3 short names for a consistent spelling (see CreateInstDir) */
+    char *long_dir = ToLongPath(image_dir);
+    free(image_dir);
+    if (!long_dir) {
+        return NULL;
+    }
+
+    InstDir = long_dir;
+    return InstDir;
 }
 
 // Frees the allocated memory for the installation directory path.

data/src/inst_dir.h

@@ -20,6 +20,20 @@
  */
 const char *CreateInstDir(bool is_extract_to_exe_dir);
 
+/**
+ * @brief Sets the installation directory to the executable's own directory.
+ *
+ * Unlike CreateInstDir, no new directory is created: the stub runs the
+ * application directly from the directory the executable resides in
+ * (installer/wrapper mode, RUN_IN_EXE_DIR). The directory must never be
+ * deleted by the stub.
+ *
+ * @return
+ *   A pointer to the directory path if successful, NULL if an error
+ *   occurred. The returned path should not be freed by the caller.
+ */
+const char *SetInstDirToExeDir(void);
+
 /**
  * @brief Free the allocated installation directory path
  *        and reset the internal pointer to NULL.

data/src/script_info.c

@@ -163,7 +163,8 @@ static char **shallow_merge_argv(char *argv1[], char *argv2[])
     return outv;
 }
 
-bool RunScript(char *argv[], bool is_chdir_to_script_dir, int *exit_code)
+bool RunScript(char *argv[], bool is_chdir_to_script_dir,
+               const char *chdir_dir, int *exit_code)
 {
     if (!IsScriptInfoSet()) {
         APP_ERROR("Script info is not initialized");
@@ -202,6 +203,7 @@ bool RunScript(char *argv[], bool is_chdir_to_script_dir, int *exit_code)
         goto cleanup;
     }
 
+    const char *target_dir = NULL;
     if (is_chdir_to_script_dir) {
         script_dir = GetParentPath(script_name);
         if (!script_dir) {
@@ -213,8 +215,19 @@ bool RunScript(char *argv[], bool is_chdir_to_script_dir, int *exit_code)
             "Changing working directory to script directory '%s'",
             script_dir
         );
+        target_dir = script_dir;
+    } else if (chdir_dir) {
+        DEBUG(
+            "Changing working directory to '%s'",
+            chdir_dir
+        );
+        target_dir = chdir_dir;
+    }
 
-        char *ruby_optv[5] = { script_info[0], "-C", script_dir, "--", NULL };
+    if (target_dir) {
+        char *ruby_optv[5] = {
+            script_info[0], "-C", (char *)target_dir, "--", NULL
+        };
         char **new_argv = shallow_merge_argv(ruby_optv, merged_argv + 1);
         if (!new_argv) {
             APP_ERROR("Failed to merge script arguments with extra arguments");

data/src/script_info.h

@@ -4,4 +4,18 @@
 char **GetScriptInfo(void);
 bool SetScriptInfo(const char *info, size_t info_size);
 void FreeScriptInfo(void);
-bool RunScript(char *argv[], bool is_chdir_to_script_dir, int *exit_code);
+/**
+ * Launches the packaged script.
+ *
+ * @param argv                    Original argv of the stub; elements after
+ *                                argv[0] are appended to the script arguments.
+ * @param is_chdir_to_script_dir  When true, the script starts with its working
+ *                                directory set to the extracted script's
+ *                                directory (--chdir-first).
+ * @param chdir_dir               When non-NULL (and is_chdir_to_script_dir is
+ *                                false), the script starts with its working
+ *                                directory set to this path (--chdir-exe-dir).
+ * @param exit_code               Receives the script's exit code.
+ */
+bool RunScript(char *argv[], bool is_chdir_to_script_dir,
+               const char *chdir_dir, int *exit_code);

data/src/stub.c

@@ -8,6 +8,10 @@
 #include <stdio.h>
 #include <stdbool.h>
 #include <stdlib.h>
+#ifdef __COSMOPOLITAN__
+#include <cosmo.h>           /* IsWindows() */
+#include <libc/nt/runtime.h> /* ExitProcess() */
+#endif
 #include "error.h"
 #include "system_utils.h"
 #include "inst_dir.h"
@@ -21,6 +25,7 @@ int main(int argc, char *argv[])
     OperationModes op_modes = 0;
     const char *extract_dir = NULL;
     char *image_path = NULL;
+    char *exe_dir = NULL;
 
     /*
        Initialize signal and control handling so the parent process remains
@@ -57,15 +62,24 @@ int main(int argc, char *argv[])
         DEBUG("Ocran stub running in debug mode");
     }
 
-    /* Create extraction directory */
-    extract_dir = CreateInstDir(IsExtractToExeDir(op_modes));
-    if (!extract_dir) {
-        FATAL("Failed to create extraction directory");
-        goto cleanup;
+    /* Create extraction directory, or run in place next to the executable
+       (installer/wrapper mode, see RUN_IN_EXE_DIR) */
+    if (IsRunInExeDir(op_modes)) {
+        extract_dir = SetInstDirToExeDir();
+        if (!extract_dir) {
+            FATAL("Failed to resolve the executable directory");
+            goto cleanup;
+        }
+        DEBUG("Running in executable directory: %s", extract_dir);
+    } else {
+        extract_dir = CreateInstDir(IsExtractToExeDir(op_modes));
+        if (!extract_dir) {
+            FATAL("Failed to create extraction directory");
+            goto cleanup;
+        }
+        DEBUG("Created extraction directory: %s", extract_dir);
     }
 
-    DEBUG("Created extraction directory: %s", extract_dir);
-
     /* Unpacking process */
     if (!ProcessImage(unpack_ctx)) {
         FATAL("Failed to unpack image due to invalid or corrupted data");
@@ -87,12 +101,41 @@ int main(int argc, char *argv[])
         goto cleanup;
     }
 
+    /* Resolve the executable's directory when the script should start
+       with its working directory next to the .exe (--chdir-exe-dir). */
+    if (IsChdirToExeDir(op_modes)) {
+        exe_dir = GetParentPath(image_path);
+        if (!exe_dir) {
+            FATAL("Failed to resolve the executable directory");
+            goto cleanup;
+        }
+        DEBUG("Will start script in executable directory: %s", exe_dir);
+    }
+#ifdef __COSMOPOLITAN__
+    /*
+       This stub is itself an APE.  It fork/execs the payload interpreter and
+       reads the result with WEXITSTATUS() (system_utils_posix.c), so on
+       Windows the child must keep Cosmopolitan's wait-status exit encoding
+       (status << 8) -- otherwise `exit 3` would come back looking like death
+       by signal 3.  CosmoRuby reports the plain status by default now, which
+       is right for a native parent but wrong for this one; the variable asks
+       it for the old encoding.  Harmless for interpreters that do not know
+       the variable, and a no-op off Windows.  This process still reports the
+       plain status to ITS native parent, at the end of main().
+    */
+    DEBUG("Set 'COSMORUBY_WAIT_STATUS_EXIT' so the payload's status survives waitpid()");
+    if (!SetEnvVar("COSMORUBY_WAIT_STATUS_EXIT", "1")) {
+        FATAL("The script cannot be launched due to a configuration error");
+        goto cleanup;
+    }
+#endif
+
     /*
        RunScript uses the current value of status as its initial value
        and then overwrites it with the external script’s return code.
     */
     DEBUG("Run application script");
-    if (!RunScript(argv, IsChdirBeforeScript(op_modes), &status)) {
+    if (!RunScript(argv, IsChdirBeforeScript(op_modes), exe_dir, &status)) {
         FATAL("Failed to run script");
         goto cleanup;
     }
@@ -110,6 +153,10 @@ cleanup:
         free(image_path);
     }
 
+    if (exe_dir) {
+        free(exe_dir);
+    }
+
     if (unpack_ctx) {
         ClosePackFile(unpack_ctx);
         unpack_ctx = NULL;
@@ -120,7 +167,9 @@ cleanup:
     /*
        If AUTO_CLEAN_INST_DIR is set, delete the extraction directory.
     */
-    if (IsAutoCleanInstDir(op_modes)) {
+    /* Never delete in RUN_IN_EXE_DIR mode: the "installation directory"
+       is the real application directory, not a temporary extraction dir. */
+    if (IsAutoCleanInstDir(op_modes) && !IsRunInExeDir(op_modes)) {
         DEBUG("Deleting extraction directory: %s", extract_dir);
         if (!DeleteInstDir()) {
             DEBUG("Failed to delete extraction directory");
@@ -129,5 +178,17 @@ cleanup:
 
     FreeInstDir();
     extract_dir = NULL;
+
+#ifdef __COSMOPOLITAN__
+    /* On Windows, Cosmopolitan Libc's exit path encodes the full wait
+       status into the process exit code (code << 8) so that cosmo
+       parents can reconstruct it. Native Windows parents (cmd,
+       PowerShell, CI runners) expect the plain code, so bypass the
+       libc exit path and report the code as-is. */
+    if (IsWindows()) {
+        fflush(NULL);
+        ExitProcess(status);
+    }
+#endif
     return status;
 }

data/src/system_utils.c

@@ -96,6 +96,32 @@ char *JoinPath(const char *p1, const char *p2)
     return joined_path;
 }
 
+char *ToLongPath(const char *path)
+{
+    if (!path) {
+        return NULL;
+    }
+
+    DWORD required = GetLongPathName(path, NULL, 0);
+    if (required == 0) {
+        return _strdup(path); /* e.g. path does not exist - keep as is */
+    }
+
+    char *buf = malloc(required);
+    if (!buf) {
+        APP_ERROR("Memory allocation failed for long path");
+        return NULL;
+    }
+
+    DWORD written = GetLongPathName(path, buf, required);
+    if (written == 0 || written >= required) {
+        free(buf);
+        return _strdup(path);
+    }
+
+    return buf;
+}
+
 char *GetParentPath(const char *path)
 {
     if (!path) {

data/src/system_utils.h

@@ -102,6 +102,20 @@ char *GetImagePath(void);
  */
 char *GetTempDirectoryPath(void);
 
+/**
+ * @brief Normalizes a path to its long form.
+ *
+ * On Windows, converts 8.3 short names (e.g. "C:\\Users\\RUNNER~1") to the
+ * full long path via GetLongPathName. Two spellings of the same directory
+ * would otherwise defeat Ruby's $LOADED_FEATURES deduplication, causing
+ * files to be loaded twice ("already initialized constant" warnings).
+ * On POSIX this simply returns a copy of the given path.
+ *
+ * @return A newly allocated string (caller frees), or NULL on allocation
+ *         failure. Falls back to a copy of the input if conversion fails.
+ */
+char *ToLongPath(const char *path);
+
 /**
  * @brief Writes the contents of a buffer to the specified file path.
  *        Creates any missing parent directories and overwrites existing files.

data/src/system_utils_posix.c

@@ -1,6 +1,9 @@
 #ifdef __APPLE__
 #include <mach-o/dyld.h>
 #endif
+#ifdef __COSMOPOLITAN__
+#include <cosmo.h>  /* GetProgramExecutableName() */
+#endif
 #include <unistd.h>
 #include <fcntl.h>
 #include <sys/stat.h>
@@ -360,6 +363,23 @@ bool ExportFile(const char *path, const void *buffer, size_t buffer_size) {
 /* ===== Path utilities ===== */
 
 char *GetImagePath(void) {
+#ifdef __COSMOPOLITAN__
+    /* Cosmopolitan Libc defines neither __linux__ nor __APPLE__; it resolves
+       the executable path itself on every OS the APE binary runs on. */
+    const char *exe = GetProgramExecutableName();
+    if (!exe || !*exe) {
+        FATAL("GetImagePath: GetProgramExecutableName failed");
+        return NULL;
+    }
+
+    char *result = strdup(exe);
+    if (!result) {
+        FATAL("GetImagePath: strdup failed");
+        return NULL;
+    }
+
+    return result;
+#else
     static char path_buffer[4096];
 #ifdef __APPLE__
     uint32_t size = sizeof(path_buffer);
@@ -388,10 +408,30 @@ char *GetImagePath(void) {
 
     strcpy(result, path_buffer);
     return result;
+#endif /* __COSMOPOLITAN__ */
 }
 
 char *GetTempDirectoryPath(void) {
     const char *tmpdir = getenv("TMPDIR");
+#ifdef __COSMOPOLITAN__
+    /* On Windows, Cosmopolitan Libc translates the magic "/tmp" prefix to
+       a real directory, but WHERE it points differs between cosmo
+       releases (%TMP% in some, C:\tmp in others). This stub and the
+       packed cosmopolitan Ruby may be built against different cosmo
+       versions, so a literal "/tmp/..." extraction path handed to the
+       child can resolve to a DIFFERENT directory than the one the stub
+       extracted into. TMP/TEMP, by contrast, are presented by cosmo in
+       its unambiguous drive-letter form (e.g. /C/Users/x/AppData/Local/
+       Temp) that every cosmo runtime resolves identically, so prefer
+       them. On POSIX hosts they are normally unset and the usual
+       TMPDIR -> /tmp behavior is preserved. */
+    if (!tmpdir || !*tmpdir) {
+        tmpdir = getenv("TMP");
+    }
+    if (!tmpdir || !*tmpdir) {
+        tmpdir = getenv("TEMP");
+    }
+#endif
     if (!tmpdir || !*tmpdir) {
         tmpdir = "/tmp";
     }
@@ -498,3 +538,9 @@ bool CreateAndWaitForProcess(const char *app_name, char *argv[], int *exit_code)
 
     return true;
 }
+
+/* POSIX has no short-path aliases - return a plain copy. */
+char *ToLongPath(const char *path)
+{
+    return path ? strdup(path) : NULL;
+}

data/src/unpack.c

@@ -536,6 +536,14 @@ bool IsDataCompressed(OperationModes modes) {
     return IsMode(modes, DATA_COMPRESSED);
 }
 
+bool IsRunInExeDir(OperationModes modes) {
+    return IsMode(modes, RUN_IN_EXE_DIR);
+}
+
+bool IsChdirToExeDir(OperationModes modes) {
+    return IsMode(modes, CHDIR_TO_EXE_DIR);
+}
+
 bool ProcessImage(const UnpackContext *context)
 {
     if (!context) {

data/src/unpack.h

@@ -66,6 +66,23 @@ typedef enum {
      * required before using the data.
      */
     DATA_COMPRESSED     = 0x10,
+
+    /**
+     * Runs the application directly from the executable's own directory
+     * instead of creating an extraction directory. Used by installer builds
+     * (e.g. Inno Setup) where the application files are installed next to
+     * the stub executable. Restores the pre-1.4 (OCRA) wrapper behavior.
+     */
+    RUN_IN_EXE_DIR      = 0x20,
+
+    /**
+     * Change the current directory to the directory containing the
+     * executable before running the script. This makes relative file
+     * access resolve next to the .exe, regardless of how it was invoked
+     * (Explorer, command prompt, file association). Opt-in via the
+     * --chdir-exe-dir build option.
+     */
+    CHDIR_TO_EXE_DIR    = 0x40,
 } OperationModes;
 
 bool IsDebugMode(OperationModes modes);
@@ -73,6 +90,8 @@ bool IsExtractToExeDir(OperationModes modes);
 bool IsAutoCleanInstDir(OperationModes modes);
 bool IsChdirBeforeScript(OperationModes modes);
 bool IsDataCompressed(OperationModes modes);
+bool IsRunInExeDir(OperationModes modes);
+bool IsChdirToExeDir(OperationModes modes);
 
 typedef struct UnpackContext UnpackContext;
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ocran
 version: !ruby/object:Gem::Version
-  version: 1.4.3
+  version: 1.4.5
 platform: ruby
 authors:
 - Andi Idogawa
@@ -25,27 +25,13 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-description: |
-  OCRAN (One-Click Ruby Application Next) packages Ruby applications for
-  distribution. It bundles your script, the Ruby interpreter, gems, and native
-  libraries into a self-contained artifact that runs without requiring Ruby to
-  be installed on the target machine.
-
-  Three output formats are supported on all platforms:
-  - Self-extracting executable (.exe on Windows, native binary on Linux/macOS)
-  - Directory with a launch script (--output-dir)
-  - Zip archive with a launch script (--output-zip)
-
-  This is a fork of OCRA maintained for Ruby 3.2+ compatibility.
-  Migration guide: replace OCRA_EXECUTABLE with OCRAN_EXECUTABLE in your code.
-
-  Usage:
-    ocran helloworld.rb          # builds helloworld.exe / helloworld
-    ocran --output-dir out/ app.rb
-    ocran --output-zip app.zip app.rb
-
-  See readme at https://github.com/largo/ocran
-  Report problems at https://github.com/largo/ocran/issues
+description: 'OCRAN (One-Click Ruby Application Next) packages Ruby applications for
+  distribution on Windows, Linux, and macOS. It bundles your script, the Ruby interpreter,
+  gems, and native libraries into a self-contained artifact that runs without Ruby
+  installed on the target machine: a self-extracting executable (default), a directory
+  (--output-dir), a zip archive (--output-zip), or a macOS .app bundle (--macosx-bundle).
+  Fork of OCRA maintained for Ruby 3.2+; migrating code should replace OCRA_EXECUTABLE
+  with OCRAN_EXECUTABLE.'
 email:
 - andi@idogawa.com
 executables:
@@ -64,6 +50,7 @@ files:
 - lib/ocran/build_facade.rb
 - lib/ocran/build_helper.rb
 - lib/ocran/command_output.rb
+- lib/ocran/cosmo_toolchain.rb
 - lib/ocran/dir_builder.rb
 - lib/ocran/direction.rb
 - lib/ocran/ed_icon.rb
@@ -73,15 +60,19 @@ files:
 - lib/ocran/host_config_helper.rb
 - lib/ocran/inno_setup_script_builder.rb
 - lib/ocran/launcher_batch_builder.rb
+- lib/ocran/launcher_event_recorder.rb
 - lib/ocran/library_detector.rb
 - lib/ocran/library_detector_posix.rb
 - lib/ocran/option.rb
 - lib/ocran/refine_pathname.rb
+- lib/ocran/rubyopt_processor.rb
 - lib/ocran/runner.rb
 - lib/ocran/runtime_environment.rb
 - lib/ocran/stub_builder.rb
 - lib/ocran/version.rb
 - lib/ocran/windows_command_escaping.rb
+- lib/ocran/zip_payload_builder.rb
+- lib/ocran/zip_writer.rb
 - share/ocran/lzma.exe
 - src/Makefile
 - src/error.c
@@ -110,7 +101,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/largo/ocran
   source_code_uri: https://github.com/largo/ocran
-  changelog_uri: https://github.com/largo/ocran/CHANGELOG.txt
+  changelog_uri: https://github.com/largo/ocran/blob/master/CHANGELOG.txt
 rdoc_options: []
 require_paths:
 - lib
@@ -125,7 +116,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.16
 specification_version: 4
 summary: OCRAN (One-Click Ruby Application Next) packages Ruby applications for distribution
   on Windows, Linux, and macOS.