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

Question

Utilizamos el maravilloso paradigma semantic versioning al versionar nuestra aplicación de rieles. Una pregunta que tuve fue dónde es mejor guardar este número. Lo he visto almacenado en /lib, environment.rb, etc.

¿Solo me preguntaba qué pensaban las personas acerca de las mejores prácticas?

Answer 1

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

En algunos lugares el número de versión se puede colocar Estas en:

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

añadiendo:

VERSION = '1.0.0' 

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

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

La carpeta lib suena un poco extraña, ya que esta carpeta está destinada a almacenar módulos reutilizables.

Answer 2

Mi preferencia es crear una tarea rake que genera

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

Fwiw, mi tarea 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 3

Mi estrategia es dejar que las etiquetas de control de versiones que lo haga por usted (GIT muestra aquí)

Agregue esto a su 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') 

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

Answer 4

Uso tarea rastrillo para el control de automatización a través de rastrillo, para exampe: https://gist.github.com/muxcmux/1805946

Y luego en config/initializers/version.rb: módulo SiteInfo clase Aplicación

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 5

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 6

En los carriles 4, tarea rastrillo de @ fearless_fool anterior tiene que tener este aspecto:

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 venir antes la línea task :create... con el fin de rastrillo para reconocer eso.

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