Gdzie przechowujesz numer wersji aplikacji Rails?

Question

Używamy wspaniałego modelu semantic versioning podczas wersjonowania naszej aplikacji szyn. Jedno pytanie, jakie miałem, to gdzie najlepiej przechowywać ten numer? Widziałem go przechowywany w /lib, environment.rb, itp.

Zastanawiasz się, co ludzie pomyśleli o najlepszych praktykach?

Answer 1

Nie sądzę, że istnieje jakaś konwencja. Domyślam się, że to wszystko, co wydaje ci się naturalne.

niektórych miejscach numer wersji mogą być umieszczane są w:

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

dodając:

VERSION = '1.0.0' 

Bez względu na wybraną opcję (z góry) - stała VERSION zostanie ustawiona podczas inicjowania aplikacji.

Na moim blogu właśnie aktualizuję stopkę mojego układu - ponieważ numer wersji nie jest używany nigdzie indziej.

- Folder lib brzmi trochę dziwnie, ponieważ ten folder jest przeznaczony do przechowywania modułów wielokrotnego użytku.

Answer 2

skłaniam się utworzyć zadanie nachylenia, który generuje

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

FWIW, moim zadaniem natarcia:

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

Moja strategia jest pozwolić tagi VCS zrobi to za ciebie (pokazane git tutaj).

Dodaj to do swojej 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') 

Następnie można uzyskać dostęp do wersji w dowolnym miejscu aplikacji z Rails.configuration.version

Answer 4

Korzystanie zadaniem natarcia do sterowania automatyką poprzez prowizji, za exampe: https://gist.github.com/muxcmux/1805946

A następnie w config/initializers/version.rb: moduł SiteInfo klasa Zastosowanie

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

Osobiście wolę dodawać stałą do klasy aplikacji.

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

Answer 6

W Rails 4, zadanie natarcia @ fearless_fool za powyżej musi wyglądać następująco:

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 

Linia desc musi być obecny i musi pochodzić przed linię task :create... w celu grabie do rozpoznania to.

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