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