Ruby: require vs require_relative - рекомендуется использовать обходные пути для Ruby <1.9.2 и> = 1.9.2

Какова лучшая практика, если я хочу requireотносительный файл в Ruby, и я хочу, чтобы он работал как в 1.8.x, так и> = 1.9.2?

Я вижу несколько вариантов:

• просто сделай $LOAD_PATH << '.'и забудь все
• делать $LOAD_PATH << File.dirname(__FILE__)
• require './path/to/file'
• проверьте, если RUBY_VERSION<1.9.2, то определите require_relativeкак require, затем используйте require_relativeвезде, где это необходимо
• проверьте, require_relativeсуществует ли уже, если это так, попробуйте продолжить, как в предыдущем случае
• используйте странные конструкции, такие как - увы, они не работают должным образом в Ruby 1.9, потому что, например:

  require File.join(File.dirname(__FILE__), 'path/to/file')

  $ cat caller.rb
  require File.join(File.dirname(__FILE__), 'path/to/file')
  $ cat path/to/file.rb
  puts 'Some testing'
  $ ruby caller
  Some testing
  $ pwd
  /tmp
  $ ruby /tmp/caller
  Some testing
  $ ruby tmp/caller
  tmp/caller.rb:1:in 'require': no such file to load -- tmp/path/to/file (LoadError)
      from tmp/caller.rb:1:in '<main>'

• Даже более странная конструкция: кажется, работает, но это странно и не совсем хорошо выглядит.

  require File.join(File.expand_path(File.dirname(__FILE__)), 'path/to/file')

• Используйте гем backports - он довольно тяжелый, требует инфраструктуры rubygems и включает в себя множество других обходных путей, а я просто хочу requireработать с относительными файлами.

В StackOverflow есть тесно связанный вопрос, который дает еще несколько примеров, но он не дает четкого ответа - что является лучшей практикой.

Есть ли какое-нибудь приемлемое, общепризнанное универсальное решение для запуска моего приложения на Ruby <1.9.2 и> = 1.9.2?

ОБНОВИТЬ

Пояснение: я не хочу просто отвечать, как «вы можете сделать X» - на самом деле, я уже упомянул большинство рассматриваемых вариантов. Я хочу обоснование , то есть, почему это лучшая практика, каковы ее плюсы и минусы и почему ее следует выбирать среди других.

Обходной путь для этого был только что добавлен к жемчужине 'aws', так что я подумала, что поделюсь этим, поскольку это было вдохновлено этим постом.

https://github.com/appoxy/aws/blob/master/lib/awsbase/require_relative.rb

unless Kernel.respond_to?(:require_relative)
  module Kernel
    def require_relative(path)
      require File.join(File.dirname(caller[0]), path.to_str)
    end
  end
end

Это позволяет вам использовать require_relativeкак в ruby ​​1.9.2 в ruby ​​1.8 и 1.9.1.

Прежде чем перейти к 1.9.2, я использовал следующее для относительных потребностей:

require File.expand_path('../relative/path', __FILE__)

Это немного странно в первый раз, когда вы видите это, потому что похоже, что в начале есть лишняя «...». Причина в том, что expand_pathбудет развернут путь относительно второго аргумента, а второй аргумент будет интерпретирован, как если бы это был каталог. __FILE__Очевидно, это не каталог, но это не имеет значения, поскольку expand_pathне имеет значения, существуют файлы или нет, он просто применяет некоторые правила для расширения таких вещей, как .., .и ~. Если вы можете преодолеть первоначальное "waitaminute, там нет лишнего ..?" Я думаю, что строка выше работает довольно хорошо.

Если предположить, что __FILE__это так /absolute/path/to/file.rb, то получится, что expand_pathсоздаст строку /absolute/path/to/file.rb/../relative/path, а затем применит правило, которое говорит, что ..следует удалить компонент пути перед ним ( file.rbв данном случае), возвращая /absolute/path/to/relative/path.

Это лучшая практика? Зависит от того, что вы подразумеваете под этим, но кажется, что это все в базе кода Rails, поэтому я бы сказал, что это, по крайней мере, достаточно распространенная идиома.

У Кирки есть фрагмент для этого для 1.8. Вот:

def require_relative(relative_feature)
  c = caller.first
  fail "Can't parse #{c}" unless c.rindex(/:\d+(:in `.*')?$/)
  file = $`
  if /\A\((.*)\)/ =~ file # eval, etc.
    raise LoadError, "require_relative is called in #{$1}"
  end
  absolute = File.expand_path(relative_feature, File.dirname(file))
  require absolute
end

Он просто использует ответы Тео, но вы все равно можете их использовать require_relative.

$LOAD_PATH << '.'

$LOAD_PATH << File.dirname(__FILE__)

Это не очень хорошая привычка безопасности: зачем открывать весь каталог?

require './path/to/file'

Это не работает, если RUBY_VERSION <1.9.2

использовать странные конструкции, такие как

require File.join(File.dirname(__FILE__), 'path/to/file')

Еще более странная конструкция:

require File.join(File.expand_path(File.dirname(__FILE__)), 'path/to/file')

Используйте гем backports - он довольно тяжелый, требует инфраструктуры rubygems и включает в себя множество других обходных путей, а я просто хочу работать с относительными файлами.

Вы уже ответили, почему это не лучшие варианты.

проверьте, если RUBY_VERSION <1.9.2, затем определите require_relative как require, используйте require_relative везде, где это необходимо впоследствии

проверьте, если require_relative уже существует, если это так, попробуйте продолжить, как в предыдущем случае

Это может работать, но есть более безопасный и быстрый способ: справиться с исключением LoadError:

begin
  # require statements for 1.9.2 and above, such as:
  require "./path/to/file"
  # or
  require_local "path/to/file"
rescue LoadError
  # require statements other versions:
  require "path/to/file"
end

Я фанат использования гема rbx-require -lative ( источник ). Первоначально он был написан для Rubinius, но он также поддерживает MRI 1.8.7 и ничего не делает в 1.9.2. Требовать драгоценный камень просто, и мне не нужно бросать фрагменты кода в мой проект.

Добавьте его в свой Gemfile:

gem "rbx-require-relative"

Тогда require 'require_relative'перед тобой require_relative.

Например, один из моих тестовых файлов выглядит так:

require 'rubygems'
require 'bundler/setup'
require 'minitest/autorun'
require 'require_relative'
require_relative '../lib/foo'

Это самое чистое решение из всех этих IMO, и камень не такой тяжелый, как бэкпорт.

backportsКамень теперь позволяет загружать отдельные Backports.

Вы могли бы тогда просто:

require 'backports/1.9.1/kernel/require_relative'
# => Now require_relative works for all versions of Ruby

Это requireне повлияет на более новые версии и не обновит другие встроенные методы.

Другой вариант - сообщить интерпретатору, какие пути искать

ruby -I /path/to/my/project caller.rb

Одна проблема, на которую я не обращал внимания в решениях на основе __FILE__, заключается в том, что они ломаются в отношении символических ссылок. Например, у меня есть:

~/Projects/MyProject/foo.rb
~/Projects/MyProject/lib/someinclude.rb

Основной скрипт, точка входа, приложение foo.rb. Этот файл связан с ~ / Scripts / foo, который находится в моем $ PATH. Это требование require нарушается, когда я выполняю 'foo':

require File.join(File.dirname(__FILE__), "lib/someinclude")

Поскольку __FILE__ - это ~ / Scripts / foo, поэтому приведенный выше оператор require ищет ~ / Scripts / foo / lib / someinclude.rb, которого, очевидно, не существует. Решение простое. Если __FILE__ является символической ссылкой, на нее необходимо разыменовать ссылку. Pathname # realpath поможет нам в этой ситуации:

требует "путь"
require File.join (File.dirname (Pathname.new (__ FILE __). realpath), "lib / someinclude")

Если бы вы строили драгоценный камень, вы бы не хотели загрязнять путь загрузки.

Но в случае автономного приложения очень удобно просто добавить текущий каталог в путь загрузки, как вы это делали в первых 2 примерах.

Мой голос идет по первому варианту в списке.

Я хотел бы видеть некоторую основательную литературу по лучшим практикам Ruby.

Я бы определил свой собственный, relative_requireесли он не существует (то есть под 1.8), а затем использовал бы один и тот же синтаксис везде.

Ruby on Rails способом:

config_path = File.expand_path("../config.yml", __FILE__)