Ruby: require vs require_relative: práctica recomendada para solucionar el problema en Ruby <1.9.2 y> = 1.9.2

¿Cuál es la mejor práctica si quiero requireun archivo relativo en Ruby y quiero que funcione tanto en 1.8.xy> = 1.9.2?

Veo algunas opciones:

• solo hazlo $LOAD_PATH << '.'y olvídalo todo
• hacer $LOAD_PATH << File.dirname(__FILE__)
• require './path/to/file'
• verifique si RUBY_VERSION<1.9.2, luego defina require_relativecomo require, use en require_relativetodas partes donde sea necesario después
• compruebe si require_relativeya existe, si es así, intente continuar como en el caso anterior
• use construcciones extrañas como , por desgracia, no parecen funcionar completamente en Ruby 1.9 porque, por ejemplo:

  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>'

• Construcción aún más extraña: parece funcionar, pero es raro y no del todo bien parecido.

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

• Use gemas de backports : es un poco pesado, requiere infraestructura de rubygems e incluye toneladas de otras soluciones, mientras que solo quiero requiretrabajar con archivos relativos.

Hay una pregunta estrechamente relacionada en StackOverflow que da algunos ejemplos más, pero no da una respuesta clara, que es una práctica recomendada.

¿Existe alguna solución universal aceptable y aceptada por todos para hacer que mi aplicación se ejecute en Ruby <1.9.2 y> = 1.9.2?

ACTUALIZAR

Aclaración: no quiero solo respuestas como "puedes hacer X"; de hecho, ya he mencionado la mayoría de las opciones en cuestión. Quiero justificación , es decir, por qué es una mejor práctica, cuáles son sus pros y sus contras y por qué debería elegirse entre los demás.

Se acaba de agregar una solución alternativa a la gema 'aws', así que pensé en compartirla, ya que se inspiró en esta publicación.

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

Esto le permite usar require_relativecomo lo haría en ruby ​​1.9.2 en ruby ​​1.8 y 1.9.1.

Antes de dar el salto a 1.9.2 usé lo siguiente para los requisitos relativos:

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

Es un poco extraño la primera vez que lo ves, porque parece que hay un '...' extra al comienzo. La razón es que expand_pathexpandirá una ruta relativa al segundo argumento, y el segundo argumento se interpretará como si fuera un directorio. __FILE__obviamente no es un directorio, pero eso no importa ya expand_pathque no importa si los archivos existen o no, solo aplicará algunas reglas para expandir cosas como .., .y ~. Si puede superar el "valor de espera inicial, ¿no hay un extra ..allí?" Creo que la línea de arriba funciona bastante bien.

Suponiendo que __FILE__es así /absolute/path/to/file.rb, lo que sucede es que expand_pathconstruirá la cadena /absolute/path/to/file.rb/../relative/pathy luego aplicará una regla que dice que ..debería eliminar el componente de ruta antes ( file.rben este caso), regresando /absolute/path/to/relative/path.

¿Es esta la mejor práctica? Depende de lo que quieras decir con eso, pero parece que está en toda la base de código de Rails, por lo que diría que es al menos un idioma bastante común.

El pico tiene un fragmento para esto para 1.8. Aquí está:

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

Básicamente solo usa lo que Theo respondió, pero aún así puedes usarlo require_relative.

$LOAD_PATH << '.'

$LOAD_PATH << File.dirname(__FILE__)

No es un buen hábito de seguridad: ¿por qué debería exponer todo su directorio?

require './path/to/file'

Esto no funciona si RUBY_VERSION <1.9.2

usar construcciones extrañas como

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

Construcción aún más extraña:

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

Use gemas de backports: es un poco pesado, requiere infraestructura de rubygems e incluye toneladas de otras soluciones, mientras que solo quiero requerir trabajar con archivos relativos.

Ya ha respondido por qué estas no son las mejores opciones.

compruebe si RUBY_VERSION <1.9.2, luego defina require_relative como require, use require_relative en todas partes donde sea necesario

verifique si require_relative ya existe, si es así, intente continuar como en el caso anterior

Esto puede funcionar, pero hay una forma más segura y rápida: lidiar con la excepción 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

Soy fanático de usar la gema ( fuente ) rbx-require-relative . Originalmente fue escrito para Rubinius, pero también es compatible con MRI 1.8.7 y no hace nada en 1.9.2. Requerir una gema es simple, y no tengo que tirar fragmentos de código en mi proyecto.

Agréguelo a su Gemfile:

gem "rbx-require-relative"

Entonces require 'require_relative'ante ti require_relative.

Por ejemplo, uno de mis archivos de prueba se ve así:

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

Esta es la solución más limpia de cualquiera de estos IMO, y la gema no es tan pesada como los backports.

La backportsgema ahora permite la carga individual de backports.

Entonces podrías simplemente:

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

Esto requireno afectará a las versiones más nuevas, ni actualizará ningún otro método incorporado.

Otra opción es decirle al intérprete qué rutas buscar

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

Un problema que no he visto señalado con las soluciones basadas en __FILE__ es que se rompen con respecto a los enlaces simbólicos. Por ejemplo, decir que tengo:

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

El script principal, el punto de entrada, la aplicación es foo.rb. Este archivo está vinculado a ~ / Scripts / foo que está en mi $ PATH. Esta declaración de requerimiento se rompe cuando ejecuto 'foo':

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

Debido a que __FILE__ es ~ / Scripts / foo, la declaración require anterior busca ~ / Scripts / foo / lib / someinclude.rb que obviamente no existe. La solución es simple. Si __FILE__ es un enlace simbólico, debe ser desreferenciado. Pathname # realpath nos ayudará con esta situación:

requiere "ruta"
require File.join (File.dirname (Pathname.new (__ FILE __). realpath), "lib / someinclude")

Si estuviera construyendo una gema, no querría contaminar la ruta de carga.

Pero, en el caso de una aplicación independiente, es muy conveniente simplemente agregar el directorio actual a la ruta de carga como lo hace en los primeros 2 ejemplos.

Mi voto va a la primera opción en la lista.

Me encantaría ver un poco de literatura sólida sobre las mejores prácticas de Ruby.

Definiría el mío relative_requiresi no existe (es decir, bajo 1.8) y luego usaría la misma sintaxis en todas partes.

Ruby on Rails:

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