vershunt 2.0.4

data/lib/msp_release/cli/bump.rb

@@ -0,0 +1,49 @@
+module MSPRelease
+  class CLI::Bump < CLI::Command
+
+    include CLI::WorkingCopyCommand
+
+    description "Increase the version number of the project"
+
+    arg :segment, "One of major, minor or bugfix"
+
+    opt :force, "Force bumping of version segments other than bugfix " +
+      "if you are not on master.  By default, you bump minor and major from" +
+      " master, and you bump the bugfix version while on a branch.",
+    {
+      :short => 'f',
+      :default => false
+    }
+
+    def run
+      segment = arguments[:segment]
+
+      check_bump_allowed!(segment)
+
+      new_version, *changed_files = project.bump_version(segment)
+
+      files = [project.config_file, *changed_files].compact
+
+      files.each do |file|
+        exec "git add #{file}"
+      end
+      exec "git commit -m 'BUMPED VERSION TO #{new_version}'"
+      puts "New version: #{new_version}"
+    end
+
+    def check_bump_allowed!(segment)
+      force = options[:force]
+      not_on_master = !git.on_master?
+
+      if not_on_master && segment != 'bugfix' && ! force
+        raise CLI::Exit, "You must be on master to bump the #{segment} version" +
+          ", or pass --force if you are sure this is what you want to do"
+      end
+    end
+
+    def revert_bump(changed_files)
+      exec "git checkout -- #{project.config_file} #{changed_files.join(' ')}"
+    end
+
+  end
+end

data/lib/msp_release/cli/checkout.rb

@@ -0,0 +1,196 @@
+require 'fileutils'
+
+module MSPRelease
+  class CLI::Checkout < CLI::Command
+    include Debian::Versions
+
+    # When cloning repositories, limit to this many commits from each head
+    CLONE_DEPTH = 5
+
+    description """Checkout a specific commit from a git repository suitable
+for building.
+
+When no BRANCH_NAME is given, or that branch is not a release branch, the
+latest commit is checked out and the changelog version is adjusted to signify
+this will be a development build.
+
+If BRANCH_NAME denotes a release branch (i.e release-1.0.2) then the latest
+/release/ commit is checked out, even if there are commits after it.
+The changelog remains unaltered in this case - the release commit would have
+updated all version information.
+"""
+
+    arg :git_url, "URL used to clone the git repository"
+    arg :branch_name, "Name of a branch on master to switch to once checked out",
+      :required => false
+
+    opt :build, "Build a debian package immediately after checking " +
+      "out, using the dpkg-buildpackage command",
+    {
+      :short   => 'b',
+      :default => false
+    }
+
+    opt :noise, "Print output to stdout",
+    {
+      :short => 'n',
+      :default => true
+    }
+
+    opt :print_files, "Print out built files to stdout",
+    {
+      :short => 'p',
+      :default => false
+    }
+
+    opt :sign, "Pass options to dpkg-buildpackage to tell it whether or not to sign the build products",
+    {
+      :short => 'S',
+      :default => false
+    }
+
+    opt :tar, "Create a tarfile containing all the debian build " +
+      "products when using --build",
+    {
+      :short   => 't',
+      :default => false
+    }
+
+    opt :shallow, "Only perform a shallow checkout to a depth of five" +
+      "commits from each head.  See git documentation for more details",
+    {
+      :short   => 's',
+      :default => false
+    }
+
+    opt :distribution, "Specify the debian distribution to put in the " +
+      "changelog when checking out a development version",
+    {
+      :short => 'd',
+      :long  => 'debian-distribution',
+      :type  => :string
+    }
+
+    def run
+      git_url          = arguments[:git_url]
+      release_spec_arg = arguments[:branch_name]
+
+      do_build         = options[:build]
+      tar_it           = options[:tar]
+      clone_depth      = options[:shallow] ? CLONE_DEPTH : nil
+
+      LOG.verbose if options[:noise]
+
+      branch_name = release_spec_arg || 'master'
+      pathspec = "origin/#{branch_name}"
+      branch_is_release_branch = !! /^release-.+$/.match(branch_name)
+
+      shallow_output = clone_depth.nil?? '' : ' (shallow)'
+      if release_spec_arg && branch_is_release_branch
+        LOG.debug("Checking out latest release commit from #{pathspec}#{shallow_output}")
+      else
+        LOG.debug("Checking out latest commit from #{pathspec}#{shallow_output}")
+      end
+
+      tmp_dir = "vershunt-#{Time.now.to_i}.tmp"
+      Git.clone(git_url, {:depth => clone_depth, :out_to => tmp_dir,
+          :exec => {:quiet => true}})
+
+      project = Project.new_from_project_file(tmp_dir + "/" + Helpers::PROJECT_FILE)
+      distribution = options[:distribution] || project.changelog.distribution
+
+      src_dir = Dir.chdir(tmp_dir) do
+
+        if pathspec != "origin/master"
+          move_to(pathspec)
+        end
+
+        if branch_is_release_branch
+          first_commit_hash, commit_message =
+            find_first_release_commit(project)
+
+          if first_commit_hash.nil?
+            raise CLI::Exit, "Could not find a release commit on #{pathspec}"
+          end
+
+          exec "git reset --hard #{first_commit_hash}"
+        else
+          dev_version = Development.
+            new_from_working_directory(branch_name, latest_commit_hash)
+
+          project.changelog.amend(dev_version, distribution)
+        end
+        src_dir = project.source_package_name + "-" + project.changelog.version.to_s
+      end
+
+      FileUtils.mv(tmp_dir, src_dir)
+      project = Project.new_from_project_file(src_dir + "/" + Helpers::PROJECT_FILE)
+      LOG.debug("Checked out to #{src_dir}")
+
+      if do_build
+        LOG.debug("Building package...")
+        build = Build.new(src_dir, project, :sign => options[:sign])
+
+        result = build.perform_from_cli!
+        if print_files?
+          result.files.each {|f| stdout.puts(f) }
+        end
+        tar_it_up(project, result) if tar_it
+      end
+    end
+
+    private
+
+    def tar_it_up(project, result)
+      files = result.files
+      tarfile = "#{project.source_package_name}-#{project.changelog.version}.tar"
+      exec("tar -cf #{tarfile} #{files.join(' ')}")
+      LOG.debug("Build products archived in to #{tarfile}")
+      stdout.puts(tarfile) if print_files?
+    end
+
+    def print_files?
+      options[:print_files]
+    end
+
+    def oneline_pattern
+      /^([a-z0-9]+) (.+)$/i
+    end
+
+    def log_command
+      "git --no-pager log --no-color --full-index"
+    end
+
+    def latest_commit_hash
+      output = exec(log_command + " --pretty=oneline -1").split("\n").first
+      oneline_pattern.match(output)[1]
+    end
+
+    def find_first_release_commit(project)
+      all_commits = exec(log_command +  " --pretty=oneline").
+        split("\n")
+
+      all_commits.map { |commit_line|
+        match = oneline_pattern.match(commit_line)
+        [match[1], match[2]]
+      }.find {|hash, message|
+        project.release_name_from_message(message)
+      }
+    end
+
+    def move_to(pathspec)
+      begin
+        exec("git show #{pathspec} --")
+      rescue Exec::UnexpectedExitStatus => e
+        if /^fatal: bad revision/.match(e.stderr)
+          raise CLI::Exit, "Git pathspec '#{pathspec}' does not exist"
+        else
+          raise
+        end
+      end
+
+      exec("git checkout --track #{pathspec}")
+    end
+  end
+
+end

data/lib/msp_release/cli/distrib.rb

@@ -0,0 +1,7 @@
+
+
+class MSPRelease::CLI::Distrib < MSPRelease::CLI::Command
+  def self.description
+    "Distribute a built debian package"
+  end
+end

data/lib/msp_release/cli/help.rb

@@ -0,0 +1,14 @@
+module MSPRelease
+  class CLI::Help < CLI::Command
+
+    description "Show help for vershunt and its sub-commands"
+
+    arg :command_name, "Name of command to see help for", :required => false
+
+    def run
+      command_name = arguments[:command_name]
+      command_class = MSPRelease::CLI.commands[command_name]
+      raise Climate::HelpNeeded.new(command_class || self)
+    end
+  end
+end

data/lib/msp_release/cli/new.rb

@@ -0,0 +1,62 @@
+module MSPRelease
+  class CLI::New < CLI::Command
+
+    include CLI::WorkingCopyCommand
+
+    description "Prepare master or a release branch for a release push"
+
+    opt :distribution, "Specify a new debian distribution to put in the " +
+      "changelog for this new version",
+    {
+      :short => 'd',
+      :long  => 'debian-distribution',
+      :type  => :string
+    }
+
+    opt :force, "Force creation of a release commit from a non-release branch", {
+      :short   => 'f',
+      :long    => 'force',
+      :default => false
+    }
+
+    def run
+      fail_if_push_pending
+      fail_if_modified_wc
+      fail_unless_on_release_branch
+
+      LOG.verbose
+
+      new_version = project.next_version_for_release(options)
+
+      self.data = {:version => new_version}
+      save_data
+    end
+
+    def not_on_release_branch_msg
+      "You must be on a release branch to create " +
+      "release commits, or use --force.\nSwitch to a release branch, or build " +
+      "from any branch without creating a release commit for development builds"
+    end
+
+    def fail_unless_on_release_branch
+      if git.cur_branch != project.branch_name
+        if options[:force]
+          LOG.error("Not on a release branch, forcing creation of release " +
+            "commit.  #{git.cur_branch} != #{project.branch_name}")
+        else
+          raise CLI::Exit, not_on_release_branch_msg
+        end
+      end
+    end
+
+    def get_next_release_number(suffix)
+      suffix_pattern = /([0-9]+)/
+      if suffix.nil? || suffix_pattern.match(suffix)
+        suffix.to_i + 1
+      else
+        raise CLI::Exit, "malformed suffix: #{suffix}\n" +
+          "Fix the changelog and try again"
+      end
+    end
+  end
+end

data/lib/msp_release/cli/push.rb

@@ -0,0 +1,29 @@
+module MSPRelease
+  class CLI::Push < CLI::Command
+
+    include CLI::WorkingCopyCommand
+
+    description "Push a new release to origin"
+
+    def run
+      unless data_exists?
+        raise CLI::Exit, "You need to stage a new release before you can push it"
+      end
+
+      load_data
+      release_name = "#{data[:version]}"
+      tagname = "release-#{release_name}"
+
+      if project.respond_to?(:project_specific_push)
+        project.project_specific_push(release_name)
+      end
+
+      exec "git tag #{tagname}"
+      exec "git push origin #{git.cur_branch}"
+      stdout.puts "Pushing new release tag: #{tagname}"
+      exec "git push origin #{tagname}"
+
+      remove_data
+    end
+  end
+end

data/lib/msp_release/cli/reset.rb

@@ -0,0 +1,17 @@
+module MSPRelease
+  class CLI::Reset < CLI::Command
+
+    include CLI::WorkingCopyCommand
+
+    description "Reset changes made by vershunt new"
+
+    def run
+
+      raise CLI::Exit, "No waiting changes" unless data_exists?
+
+      exec "git checkout #{project.changelog_path}"
+      remove_data
+      puts "Reset"
+    end
+  end
+end

data/lib/msp_release/cli/status.rb

@@ -0,0 +1,46 @@
+module MSPRelease
+  class CLI::Status < CLI::Command
+
+    include CLI::WorkingCopyCommand
+
+    description "Print out discovered release state"
+
+    def run
+      bits = []
+
+      if data_exists?
+        load_data
+        puts "Awaiting push.  Please update the changelog, then run vershunt push "
+        bits.push(["Pending", data[:version]])
+      else
+        bits.push(["Project says", msp_version]) if msp_version
+        bits.push(["Release branch", on_release_branch?? git_version : nil])
+
+        if changelog
+          changelog_version = changelog.version
+          bits.push(["Changelog says", changelog_version])
+        end
+
+      end
+
+      bits.push(["Release commit", release_name_for_output])
+
+      format_bits(bits)
+    end
+
+    private
+
+    def format_bits(bits)
+      bits = bits.map {|header, value| [header, value.nil?? '<none>' : value.to_s ]}
+      widths = bits.transpose.map { |column| column.map {|v| v.length }.max }
+      bits.each do |row|
+        puts row.zip(widths).map {|val, width| val.ljust(width) }.join(" : ").strip
+      end
+    end
+
+    def release_name_for_output
+      commit = git.latest_commit(project)
+      commit.release_commit? && commit.release_name || nil
+    end
+  end
+end

data/lib/msp_release/debian.rb

@@ -0,0 +1,229 @@
+class Debian
+
+  module Versions
+
+    module Versionable
+      def to_version
+        MSPRelease::Version.new(@major, @minor, @bugfix)
+      end
+    end
+
+    class Base
+
+      def self.new_if_matches(string)
+        pattern.match(string) && new_from_string(string)
+      end
+
+      def self.new_from_string(string)
+        match = pattern.match(string)
+        parts = (1...match.length).map {|idx| match[idx] }
+        begin
+          new(*parts)
+        rescue => e
+          raise "Unable to construct #{self} from #{string}\n#{e.to_s}"
+        end
+      end
+
+    end
+
+    class Unreleased < Base
+
+      include Versionable
+
+      def self.pattern
+        /^([0-9]+)\.([0-9]+)\.([0-9]+)$/
+      end
+
+      def self.new_from_version(version)
+        new(version.major, version.minor, version.bugfix)
+      end
+
+      def initialize(major, minor, bugfix)
+        @major  = major
+        @minor  = minor
+        @bugfix = bugfix
+      end
+
+      def bump
+        Stable.new(@major, @minor, @bugfix, "1")
+      end
+
+      def to_s
+        [@major, @minor, @bugfix].join(".")
+      end
+    end
+
+    class Stable < Base
+
+      include Versionable
+
+      def self.pattern
+        /^([0-9]+)\.([0-9]+)\.([0-9]+)-([0-9]+)$/
+      end
+
+      def initialize(major, minor, bugfix, revision)
+        @major    = major
+        @minor    = minor
+        @bugfix   = bugfix
+        @revision = revision
+      end
+
+      def bump
+        self.class.new(@major, @minor, @bugfix, @revision.to_i + 1).to_s
+      end
+
+      def to_s
+        [@major, @minor, @bugfix].join(".") + "-#{@revision}"
+      end
+
+    end
+
+    class Development < Base
+
+      class << self
+        include MSPRelease::Helpers
+
+        def pattern
+          /^([0-9]+)-git\+([a-f0-9]+)~([a-z0-9\+\.]+)$/
+        end
+
+        def new_from_working_directory(branch_name, commit_hash)
+          safe_branch_name = branch_name.gsub(/[^a-z0-9]/i, ".")
+          new(timestamp, commit_hash[0...6], safe_branch_name)
+        end
+      end
+
+      def initialize(timestamp, hash, branch_name)
+        @timestamp   = timestamp
+        @hash        = hash
+        @branch_name = branch_name
+      end
+
+      def to_s
+        "#{@timestamp}-git+#{@hash}~#{@branch_name}"
+      end
+
+      def bump
+        Stable.new(@major, @minor, @bugfix, "1")
+      end
+    end
+
+    class Unrecognized < Base
+
+      def self.pattern
+        /^(.+)$/
+      end
+
+      def initialize(chunk)
+        @chunk = chunk
+      end
+
+      def to_s       ; @chunk ; end
+      def to_version ; nil    ; end
+    end
+
+
+  end
+
+  def default_distribution ; "msp" ; end
+
+  def initialize(basedir, fname)
+    @fname = File.join(basedir, fname)
+  end
+
+  attr_reader :fname
+
+  def read_top_line
+    File.open(@fname, 'r') {|f|f.readline}
+  end
+
+  def version_classes
+    [Versions::Unreleased, Versions::Stable, Versions::Development]
+  end
+
+  def version
+    version_classes.each do |c|
+      v = c.new_if_matches(version_string_from_top_line) and
+        return v
+    end
+    Versions::Unrecognized.new(version_string_from_top_line)
+  end
+
+  def distribution_pattern
+    /([^ ]+ [^ ]+ )([^;]+)/
+  end
+
+  def distribution
+    (m = distribution_pattern.match(read_top_line)) && m[2]
+  end
+
+  def package_name
+    /[a-z0-9\-]+/.match(read_top_line)
+  end
+
+  def version_string_from_top_line
+    tline = read_top_line
+    match = /[a-z\-]+ \(([^\)]+)\)/.match(tline)
+
+    match && match[1] or
+      raise "could not parse version info from #{tline}"
+  end
+
+  def matches(version)
+    self.version == version
+  end
+
+  def amend(version, distribution=self.distribution)
+    # replace the first line
+    tline, *all = File.open(@fname, 'r') {|f|f.readlines}
+    cur_version = /^[^\(]+\(([^\)]+).+/.match(tline)[1]
+    tline = tline.gsub(cur_version, "#{version}").
+      gsub(distribution_pattern) {|m|"#{$1}#{distribution}" }
+
+    all.unshift(tline)
+
+    signoff_idx = all.index {|l| /^ -- .+$/.match(l) }
+    all[signoff_idx] = create_signoff
+
+    File.open(@fname, 'w') { |f| all.each {|l|f.puts(l) } }
+
+    version
+  end
+
+  def add(version, stub, distribution=self.distribution)
+    tline = create_top_line(version, distribution)
+    all = File.open(@fname, 'r') {|f| f.readlines }
+    new =
+      [
+       tline,
+       "",
+       "  * #{stub}",
+       "",
+       create_signoff + "\n",
+       ""
+      ]
+
+    File.open(@fname, 'w') {|f| f.write(new.join("\n")); f.write(all.join) }
+
+    version
+  end
+
+  def reset_at(project_version)
+    Versions::Unreleased.new_from_version(project_version).bump
+  end
+
+  def create_signoff
+    date = MSPRelease.time_rfc
+    author = MSPRelease.author
+    " -- #{author.name} <#{author.email}>  #{date}"
+  end
+
+  def create_top_line(v, distribution)
+    tline = "#{package_name} (#{v})"
+
+    # FIXME, un-hardcode this?
+    tline + " #{distribution}; urgency=low"
+  end
+
+
+end