Made runfiles resolution consistent to other rules

Ported the wrapper script for Python into Ruby

Author: yugui

ruby/private/binary.bzl

@@ -5,11 +5,15 @@ load(
     _transitive_deps = "transitive_deps",
 )
 
+def _to_manifest_path(ctx, file):
+    if file.short_path.startswith("../"):
+        return file.short_path[3:]
+    else:
+        return ("%s/%s" % (ctx.workspace_name, file.short_path))
+
 def _ruby_binary_impl(ctx):
     sdk = ctx.toolchains[TOOLCHAIN_TYPE_NAME].ruby_runtime
     interpreter = sdk.interpreter[DefaultInfo].files_to_run.executable
-    init_files = [f for t in sdk.init_files for f in t.files.to_list()]
-    init_flags = " ".join(["-r${PATH_PREFIX}%s" % f.short_path for f in init_files])
 
     main = ctx.file.main
     if not main:
@@ -20,30 +24,28 @@ def _ruby_binary_impl(ctx):
                 break
     if not main:
         fail(
-            ("main must be present unless the name of the rule matches to one " +
-             "of the srcs"),
+            ("main must be present unless the name of the rule matches to " +
+             "one of the srcs"),
             "main",
         )
 
     executable = ctx.actions.declare_file(ctx.attr.name)
     deps = _transitive_deps(
         ctx,
-        extra_files = init_files + [interpreter, executable],
-        extra_deps = sdk.init_files + [sdk.interpreter],
+        extra_files = [interpreter, executable],
+        extra_deps = [sdk.interpreter],
     )
 
     rubyopt = reversed(deps.rubyopt.to_list())
-    rubyopt += ["-I${PATH_PREFIX}%s" % inc for inc in deps.incpaths.to_list()]
 
     ctx.actions.expand_template(
         template = ctx.file._wrapper_template,
         output = executable,
         substitutions = {
             "{interpreter}": interpreter.short_path,
-            "{init_flags}": init_flags,
-            "{rubyopt}": " ".join(rubyopt),
-            "{main}": main.short_path,
-            "{workspace_name}": ctx.label.workspace_name or ctx.workspace_name,
+            "{loadpaths}": repr(deps.incpaths.to_list()),
+            "{rubyopt}": repr(rubyopt),
+            "{main}": repr(_to_manifest_path(ctx, main)),
         },
         is_executable = True,
     )

ruby/private/binary_wrapper.tpl

@@ -1,14 +1,117 @@
-#!/bin/sh
-
-if [ -n "${RUNFILES_DIR+x}" ]; then
-  PATH_PREFIX=$RUNFILES_DIR/{workspace_name}/
-elif [ -s `dirname $0`/../../MANIFEST ]; then
-  PATH_PREFIX=`cd $(dirname $0); pwd`/
-elif [ -d $0.runfiles ]; then
-  PATH_PREFIX=`cd $0.runfiles; pwd`/{workspace_name}/
-else
-  echo "WARNING: it does not look to be at the .runfiles directory" >&2
-  exit 1
-fi
-
-$PATH_PREFIX{interpreter} --disable-gems {init_flags} {rubyopt} -I${PATH_PREFIX} {main} "$@"
+#!/usr/bin/env ruby
+
+# Ruby-port of the Bazel's wrapper script for Python
+
+# Copyright 2017 The Bazel Authors. All rights reserved.
+# Copyright 2019 BazelRuby Authors. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'rbconfig'
+
+def find_runfiles
+  stub_filename = File.absolute_path($0)
+  runfiles = "#{stub_filename}.runfiles"
+  loop do
+    case
+    when File.directory?(runfiles)
+      return runfiles
+    when %r!(.*\.runfiles)/.*!o =~ stub_filename
+      return $1
+    when File.symlink?(stub_filename)
+      target = File.readlink(stub_filename)
+      stub_filename = File.absolute_path(target, File.dirname(stub_filename))
+    else
+      break
+    end
+  end
+  raise "Cannot find .runfiles directory for #{$0}"
+end
+
+def create_loadpath_entries(custom, runfiles)
+  [runfiles] + custom.map {|path| File.join(runfiles, path) }
+end
+
+def get_repository_imports(runfiles)
+  Dir.children(runfiles).map {|d|
+    File.join(runfiles, d)
+  }.select {|d|
+    File.directory? d
+  }
+end
+
+# Finds the runfiles manifest or the runfiles directory.
+def runfiles_envvar(runfiles)
+  # If this binary is the data-dependency of another one, the other sets
+  # RUNFILES_MANIFEST_FILE or RUNFILES_DIR for our sake.
+  manifest = ENV['RUNFILES_MANIFEST_FILE']
+  if manifest
+    return ['RUNFILES_MANIFEST_FILE', manifest]
+  end
+
+  dir = ENV['RUNFILES_DIR']
+  if dir
+    return ['RUNFILES_DIR', dir]
+  end
+
+  # Look for the runfiles "output" manifest, argv[0] + ".runfiles_manifest"
+  manifest = runfiles + '_manifest'
+  if File.exists?(manifest)
+    return ['RUNFILES_MANIFEST_FILE', manifest]
+  end
+
+  # Look for the runfiles "input" manifest, argv[0] + ".runfiles/MANIFEST"
+  manifest = File.join(runfiles, 'MANIFEST')
+  if File.exists?(manifest)
+    return ['RUNFILES_DIR', manifest]
+  end
+
+  # If running in a sandbox and no environment variables are set, then
+  # Look for the runfiles  next to the binary.
+  if runfiles.end_with?('.runfiles') and File.directory?(runfiles)
+    return ['RUNFILES_DIR', runfiles]
+  end
+end
+
+def find_ruby_binary
+  File.join(
+    RbConfig::CONFIG['bindir'],
+    RbConfig::CONFIG['ruby_install_name'],
+  )
+end
+
+def main(args)
+  custom_loadpaths = {loadpaths}
+  runfiles = find_runfiles
+
+  loadpaths = create_loadpath_entries(custom_loadpaths, runfiles)
+  loadpaths += get_repository_imports(runfiles)
+  loadpaths += ENV['RUBYLIB'].split(':') if ENV.key?('RUBYLIB')
+  ENV['RUBYLIB'] = loadpaths.join(':')
+
+  runfiles_envkey, runfiles_envvalue = runfiles_envvar(runfiles)
+  ENV[runfiles_envkey] = runfiles_envvalue if runfiles_envkey
+
+  ruby_program = find_ruby_binary
+
+  main = {main}
+  main = File.join(runfiles, main)
+  rubyopt = {rubyopt}
+  exec(ruby_program, '--disable-gems', *rubyopt, main, *args)
+  # TODO(yugui) Support windows
+end
+
+if __FILE__ == $0
+  main(ARGV)
+end

ruby/private/tools/deps.bzl

@@ -38,8 +38,9 @@ def transitive_deps(ctx, extra_files = [], extra_deps = []):
         transitive_files = depset(transitive = deps.data_files),
         collect_data = True,
     )
+    workspace = ctx.label.workspace_name or ctx.workspace_name
     includes = [
-        paths.join(ctx.label.workspace_root, inc)
+        paths.join(workspace, inc)
         for inc in ctx.attr.includes
     ]
     return struct(