ruby-on-rails - framework - tutorial django

¿Dónde almacena el número de versión de su aplicación Rails?

Question

Usamos el maravilloso paradigma de versionamiento semántico cuando versionamos nuestra aplicación Rails. Una pregunta que tuve fue dónde es mejor almacenar este número? Lo he visto almacenado en /lib , environment.rb , etc.

¿Solo me preguntaba qué pensaba la gente sobre las mejores prácticas?

Answer 1

En Rails 4, la tarea de rastrillo de @ fearless_fool anterior debe verse así:

desc "create VERSION. Use MAJOR_VERSION, MINOR_VERSION, BUILD_VERSION to override defaults"
task :create_version do
version_file = "#{Rails.root}/config/initializers/version.rb"
major = ENV["MAJOR_VERSION"] || 1
minor = ENV["MINOR_VERSION"] || 0
build = ENV["BUILD_VERSION"] || `git describe --always --tags`
version_string = "VERSION = #{[major.to_s, minor.to_s, build.strip]}/n"
File.open(version_file, "w") {|f| f.print(version_string)}
$stderr.print(version_string)
end

La línea desc debe estar presente y debe estar antes de la task :create... línea para que rake la reconozca.

Answer 2

Mi estrategia es dejar que las etiquetas VCS lo hagan por usted (git se muestra aquí).

Agrega esto a tu application.rb :

# Only attempt update on local machine
if Rails.env.development?
# Update version file from latest git tag
File.open(''config/version'', ''w'') do |file|
file.write `git describe --tags --always` # or equivalent
end
end
config.version = File.read(''config/version'')

Luego puede acceder a la versión en cualquier lugar de su aplicación con Rails.configuration.version

Answer 3

Mi preferencia es crear una tarea de rake que genere

# config/initializers/version.rb
VERSION = ["1", "0", "f3d9da7"]

FWIW, mi tarea de rake:

task :create_version do
desc "create VERSION. Use MAJOR_VERSION, MINOR_VERSION, BUILD_VERSION to override defaults"
version_file = "#{Rails.root}/config/initializers/version.rb"
major = ENV["MAJOR_VERSION"] || 1
minor = ENV["MINOR_VERSION"] || 0
build = ENV["BUILD_VERSION"] || `git describe --always --tags`
version_string = "VERSION = #{[major.to_s, minor.to_s, build.strip]}/n"
File.open(version_file, "w") {|f| f.print(version_string)}
$stderr.print(version_string)
end

Answer 4

Personalmente prefiero agregar una constante a la clase de aplicación.

# file: config/initializers/version.rb
class SomeApp::Application
Version = ''1.0.0''
end

Answer 5

Realmente no creo que haya ninguna convención para esto. Supongo que se trata de lo que te parece natural.

Algunos lugares donde se puede colocar el número de versión son:

• config/environment.rb
• config/application.rb
• config/initializers/version.rb

añadiendo:

VERSION = ''1.0.0''

Independientemente de la opción que elija (de arriba), la constante VERSIÓN se establecerá en la inicialización de la aplicación.

Para mi blog acabo de actualizar el pie de página de mi diseño, ya que el número de versión no se usa en ningún otro lugar.

Sin embargo, la carpeta lib suena un poco extraña, ya que esta carpeta está diseñada para almacenar módulos reutilizables.

Answer 6

Utilice la tarea de rake para el control de automatización a través de rake, por ejemplo: https://gist.github.com/muxcmux/1805946

Y luego en config / initializers / version.rb: módulo SiteInfo class Application

def self.version
"v#{self.read_version}"
end
def self.read_version
begin
File.read ''VERSION''
rescue
raise "VERSION file not found or unreadable."
end
end

Answer 7

version.rake

def valid? version
pattern = /^/d+/./d+/./d+(/-(dev|beta|rc/d+))?$/
raise "Tried to set invalid version: #{version}".red unless version =~ pattern
end
def correct_version version
ver, flag = version.split ''-''
v = ver.split ''.''
(0..2).each do |n|
v[n] = v[n].to_i
end
[v.join(''.''), flag].compact.join ''-''
end
def read_version
begin
File.read ''VERSION''
rescue
raise "VERSION file not found or unreadable.".red
end
end
def write_version version
valid? version
begin
File.open ''VERSION'', ''w'' do |file|
file.write correct_version(version)
end
rescue
raise "VERSION file not found or unwritable.".red
end
end
def reset current, which
version, flag = current.split ''-''
v = version.split ''.''
which.each do |part|
v[part] = 0
end
[v.join(''.''), flag].compact.join ''-''
end
def increment current, which
version, flag = current.split ''-''
v = version.split ''.''
v[which] = v[which].to_i + 1
[v.join(''.''), flag].compact.join ''-''
end
desc "Prints the current application version"
version = read_version
task :version do
puts <<HELP
Available commands are:
-----------------------
rake version:write[version] # set custom version in the x.x.x-? format
rake version:patch # increment the patch x.x.x+1 (keeps any flags on)
rake version:minor # increment minor and reset patch x.x+1.0 (keeps any flags on)
rake version:major # increment major and reset others x+1.0.0 (keeps any flags on)
rake version:dev # set the dev flag on x.x.x-dev
rake version:beta # set the beta flag on x.x.x-beta
rake version:rc # set or increment the rc flag x.x.x-rcX
rake version:release # removes any flags from the current version
HELP
puts "Current version is: #{version.green}"
end
namespace :version do
desc "Write version explicitly by specifying version number as a parameter"
task :write, [:version] do |task, args|
write_version args[:version].strip
puts "Version explicitly written: #{read_version.green}"
end
desc "Increments the patch version"
task :patch do
new_version = increment read_version, 2
write_version new_version
puts "Application patched: #{new_version.green}"
end
desc "Increments the minor version and resets the patch"
task :minor do
incremented = increment read_version, 1
new_version = reset incremented, [2]
write_version new_version
puts "New version released: #{new_version.green}"
end
desc "Increments the major version and resets both minor and patch"
task :major do
incremented = increment read_version, 0
new_version = reset incremented, [1, 2]
write_version new_version
puts "Major application version change: #{new_version.green}. Congratulations!"
end
desc "Sets the development flag on"
task :dev do
version, flag = read_version.split ''-''
new_version = [version, ''dev''].join ''-''
write_version new_version
puts "Version in development: #{new_version.green}"
end
desc "Sets the beta flag on"
task :beta do
version, flag = read_version.split ''-''
new_version = [version, ''beta''].join ''-''
write_version new_version
puts "Version in beta: #{new_version.green}"
end
desc "Sets or increments the rc flag"
task :rc do
version, flag = read_version.split ''-''
rc = /^rc(/d+)$/.match flag
if rc
new_version = [version, "rc#{rc[1].to_i+1}"].join ''-''
else
new_version = [version, ''rc1''].join ''-''
end
write_version new_version
puts "New version release candidate: #{new_version.green}"
end
desc "Removes any version flags"
task :release do
version, flag = read_version.split ''-''
write_version version
puts "Released stable version: #{version.green}"
end
end