vershunt 2.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+--- 
+SHA512: 
+  data.tar.gz: 489aaa7a9417ff0c038fc4bc149ecfc1dd465cc18ea3ecc99384f4e63fe51b70ee7bf918937cd7a569e1715edfc000d4ee88392e67d37bd772b4e255291348b8
+  metadata.gz: 41ad772239c464ba17b89dd070a1b8df7801edcd93511ac3db554f6a5b84ac08b13e57082542f8624041e4c4951da6c33f944ca992a2c270c9c80763108fa2eb
+SHA1: 
+  data.tar.gz: d86f32da8656675a8ad473d55466d4ef551ad276
+  metadata.gz: a60005aa2a2a9bab6c5c31801ce8379ce1a43aac

data/bin/vershunt

@@ -0,0 +1,19 @@
+#! /usr/bin/env ruby
+
+INSTALL_DIR='/usr/lib/vershunt'
+INSTALL_BIN='/usr/bin/vershunt'
+
+lib_dir =
+  if __FILE__ == INSTALL_BIN
+    # smells like debian, rely on fixed installation locations
+    INSTALL_DIR + '/lib'
+  else
+    # local dev copy, or installed via rubygems
+    require 'rubygems'
+    File.expand_path(File.join(File.dirname(__FILE__), "../lib"))
+  end
+
+$LOAD_PATH.unshift(lib_dir)
+
+require 'msp_release'
+MSPRelease::CLI.run(ARGV)

data/lib/msp_release.rb

@@ -0,0 +1,153 @@
+require 'yaml'
+
+module MSPRelease
+
+  require 'climate'
+  require 'msp_release/exec'
+
+  include Exec::Helpers
+
+  module Helpers
+
+    PROJECT_FILE = ".msp_project"
+
+    # Slush bucket for stuff :)
+
+    def msp_version
+      project.version
+    end
+
+    def git_version
+      (m = /release-(.+)/.match(git.cur_branch)) && m[1]
+    end
+
+    def time; @time ||= Time.now; end
+
+    def timestamp
+      @timestamp ||= time.strftime("%Y%m%d%H%M%S")
+    end
+
+    def time_rfc
+      offset = time.gmt_offset / (60 * 60)
+      gmt_offset = "#{offset < 0 ? '-' : '+'}#{offset.abs.to_s.rjust(2, "0")}00"
+      time.strftime("%a, %d %b %Y %H:%M:%S #{gmt_offset}")
+    end
+
+    def author
+      @author ||=
+        begin
+          name, email = ['name', 'email'].map {|f| `git config --get user.#{f}`.strip}
+          Author.new(name, email)
+        end
+    end
+
+    def changelog
+      @changelog ||= begin
+        project.respond_to?(:changelog) && project.changelog
+      end
+    end
+
+    def on_release_branch?
+      !!/release/.match(git.cur_branch)
+    end
+
+    def data
+      @data ||= {}
+    end
+
+    def data=(data_hash)
+      @data = data_hash
+    end
+
+    def data_exists?
+      File.exists?(DATAFILE)
+    end
+
+    def load_data
+      @data = File.open(DATAFILE, 'r') {|f| YAML.load(f) }
+    end
+
+    def save_data
+      File.open(DATAFILE, 'w') {|f| YAML.dump(@data, f) }
+    end
+
+    def remove_data
+      File.delete(DATAFILE) if File.exists?(DATAFILE)
+    end
+
+    def fail_if_modified_wc
+      annoying_files = git.modified_files + git.added_files
+      if annoying_files.length > 0
+        $stderr.puts("You have modified files in your working copy, and that just won't do")
+      annoying_files.each {|f|$stderr.puts("  " + f)}
+        exit 1
+      end
+    end
+
+    def fail_if_push_pending
+      if data_exists?
+        $stderr.puts("You have a release commit pending to be pushed")
+        $stderr.puts("Please push, or reset the operation")
+        exit 1
+      end
+    end
+  end
+
+  include Helpers
+
+  require 'msp_release/log'
+  require 'msp_release/debian'
+  require 'msp_release/git'
+  require 'msp_release/options'
+  require 'msp_release/project'
+  require 'msp_release/build'
+  require 'msp_release/make_branch'
+  require 'msp_release/cli'
+
+  MSP_VERSION_FILE = "lib/msp/version.rb"
+  DATAFILE = ".msp_release"
+
+  LOG = Log.new
+
+  VERSION_SEGMENTS = [:major, :minor, :bugfix]
+  Version = Struct.new(*VERSION_SEGMENTS)
+  Version.module_eval do
+
+    def format(opts={})
+      opts[:without_bugfix] ? "#{major}.#{minor}" : "#{major}.#{minor}.#{bugfix}"
+    end
+
+    alias :to_s :format
+
+    def self.from_string(str)
+      match = /([0-9]+)\.([0-9]+)\.([0-9]+)/.match(str)
+      match && new(*(1..3).map{|i|match[i]})
+    end
+
+    def bump(segment)
+
+      raise ArgumentError, "no such segment: #{segment}" unless VERSION_SEGMENTS.include?(segment)
+
+      reset = false
+      new_segments = VERSION_SEGMENTS.map do |cur_seg|
+        part = self.send(cur_seg)
+        if cur_seg == segment
+          reset = true
+          part.to_i + 1
+        else
+          reset ? 0 : part
+        end.to_s
+      end
+
+      "new_segments: #{new_segments}"
+
+      self.class.new(*new_segments)
+    end
+  end
+
+  Author = Struct.new(:name, :email)
+
+  extend self
+
+end
+

data/lib/msp_release/build.rb

@@ -0,0 +1,64 @@
+module MSPRelease
+  class Build
+
+    class NoChangesFileError < StandardError ; end
+
+    include Exec::Helpers
+
+    def initialize(basedir, project, options={})
+      @basedir = basedir
+      @project = project
+      @options = options
+
+      @sign = options.fetch(:sign, true)
+    end
+
+    def perform_from_cli!
+      LOG.debug("Building package...")
+
+      result =
+        begin
+          self.perform!
+        rescue Exec::UnexpectedExitStatus => e
+          raise CLI::Exit, "build failed:\n#{e.stderr}"
+        rescue Build::NoChangesFileError => e
+          raise CLI::Exit, "Unable to find changes file with version: " +
+            "#{e.message}\nAvailable: \n" +
+            self.available_changes_files.map { |f| "  #{f}" }.join("\n")
+        end
+
+      result.tap do
+        LOG.debug("Package built: #{result.package}")
+      end
+    end
+
+    def perform!
+      dir = File.expand_path(@basedir)
+      raise "directory does not exist: #{dir}" unless
+        File.directory?(dir)
+
+      e = Exec.new(:name => 'build', :quiet => false, :status => :any)
+      Dir.chdir(@project.dir) do
+        e.exec(build_command)
+      end
+
+      if e.last_exitstatus != 0
+        LOG.warn("Warning: #{build_command} exited with #{e.last_exitstatus}")
+      end
+
+      @project.build_result(output_directory)
+    end
+
+    def output_directory
+      File.expand_path(@project.config[:deb_output_directory] ||
+        File.join(@basedir, '..'))
+    end
+
+    private
+
+    def build_command
+      @project.build_command
+    end
+
+  end
+end

data/lib/msp_release/cli.rb

@@ -0,0 +1,90 @@
+module MSPRelease
+  module CLI
+
+    # Base class for command line operations
+    class Command < Climate::Command
+      include Exec::Helpers
+    end
+
+    # alias this class for shorter lines
+    Exit = Climate::ExitException
+
+    # root of the command hierarchy
+    class Root < Climate::Command('vershunt')
+
+      description """
+Manipulate your git repository by creating commits and performing
+branch management to create a consistent log of commits to be used
+as part of a repeatable build system, as well as encouraging
+semantic versioning (see http://semver.org).
+
+Projects must include a .msp_project, which is a yaml file that must at least
+not be empty.  If the project file has a ruby_version_file key, then this
+file will be considered as well as the debian changelog when updating version
+information.
+"""
+
+    end
+
+    # Commands that require a git working copy can include this module
+    module WorkingCopyCommand
+
+      include Helpers
+
+      attr_accessor :project, :git
+
+      def initialize(options, leftovers)
+        super
+
+        if File.exists?(PROJECT_FILE)
+          @project = MSPRelease::Project.new_from_project_file(PROJECT_FILE)
+        else
+          raise Climate::ExitException.
+            new("No #{PROJECT_FILE} present in current directory")
+        end
+
+        @git = Git.new(@project, @options)
+      end
+
+    end
+
+    # hardcoded list of commands
+    COMMANDS = ['help', 'new', 'push', 'branch', 'status', 'reset', 'bump', 'checkout', 'build']
+
+    # These are available on the CLI module
+    module ClassMethods
+
+      attr_reader :commands
+
+      def run(args)
+        init_commands
+
+        Climate.with_standard_exception_handling do
+          begin
+            Root.run(args)
+          rescue Exec::UnexpectedExitStatus => e
+            $stderr.puts(e.message)
+            $stderr.puts(e.stderr)
+            exit 1
+          end
+        end
+      end
+
+      def init_commands
+        @commands = {}
+        COMMANDS.each do |name|
+          require "msp_release/cli/#{name}"
+          camel_name =
+            name.split(/[^a-z0-9]/i).map{|w| w.capitalize}.join
+
+          command = MSPRelease::CLI.const_get(camel_name)
+          @commands[name] = command
+          command.set_name(name)
+          command.subcommand_of(Root)
+        end
+      end
+    end
+
+    self.extend(ClassMethods)
+  end
+end

data/lib/msp_release/cli/branch.rb

@@ -0,0 +1,97 @@
+module MSPRelease
+  class CLI::Branch < CLI::Command
+    include CLI::WorkingCopyCommand
+
+    description """
+Create and switch to a release branch for the version on HEAD
+
+The release branch will be named after the project version returned by
+`vershunt status`, excluding the bugfix version.  If the version is
+1.2.3, a branch of release-1.2 will be created.
+
+The minor version on master is bumped after the branch is created, although this can be disabled.
+"""
+
+    opt :allow_non_master_branch, "Allow release branch to be created " +
+      "even if you are not on master.  Normally you would not want to do" +
+      " this, so this is here to prevent branches from mistakenly being " +
+      "created from branches other than master",
+    {
+      :short => 'a',
+      :default => false
+    }
+
+
+    opt :no_bump_master, "Do not bump the minor version of master " +
+      "as part of creating the release branch.  Typically after creating a " +
+      "release branch, the minor version being stabilised now lives on the " +
+      "branch and master is now a new version",
+    {
+      :short => 'n',
+      :default => false
+    }
+
+    def run
+      fail_if_push_pending
+
+      # take the version before we do any bumping
+      version = project.version
+
+      branch_from =
+        if git.on_master?
+          bump_and_push_master
+        else
+          check_branching_ok!
+        end
+
+      branch_name = project.branch_name(version)
+
+      begin
+        MSPRelease::MakeBranch.new(git, branch_name, :start_point => branch_from).
+          perform!
+      rescue MSPRelease::MakeBranch::BranchExistsError => e
+        raise CLI::Exit, "A branch already exists for #{version}"
+      end
+
+      $stdout.puts("Switched to release branch '#{branch_name}'")
+    end
+
+    def check_branching_ok!
+      if options[:allow_non_master_branch]
+        $stderr.puts("Creating a non-master release branch, --allow-non-master-branch supplied")
+        "HEAD@{0}"
+      else
+        raise CLI::Exit, "You must be on master to create " +
+          "release branches, or pass --allow-non-master-branch"
+      end
+    end
+
+    def bump_and_push_master
+
+      return "HEAD@{0}" if options[:no_bump_master]
+
+      # don't let this happen with a dirty working copy, because we reset the
+      # master branch, which will kill all your changes
+      fail_if_modified_wc
+
+      new_version, *changed_files = project.bump_version('minor')
+      exec "git add -- #{changed_files.join(' ')}"
+
+      # FIXME dry this part up, perhaps using a bump operation class
+      exec "git commit -m 'BUMPED VERSION TO #{new_version}'"
+
+      begin
+        $stdout.puts "Bumping master to #{new_version}, pushing to origin..."
+        exec "git push origin master"
+      rescue
+        $stderr.puts "error pushing bump commit to master, undoing bump..."
+        exec "git reset --hard HEAD@{1}"
+        raise CLI::Exit, 'could not push bump commit to master, if you do ' +
+          'not want to bump the minor version of master, try again with ' +
+          '--no-bump-master'
+      end
+
+      "HEAD@{1}"
+    end
+  end
+end

data/lib/msp_release/cli/build.rb

@@ -0,0 +1,99 @@
+module MSPRelease
+  class CLI::Build < CLI::Command
+    include Debian::Versions
+
+    # When cloning repositories, limit to this many commits from each head
+    CLONE_DEPTH = 5
+
+    description """Build debian packages suitable for deployment fresh from
+source control using a build commit or a development version.
+
+When no BRANCH_NAME is given, or that branch is not a release branch, the
+latest commit from that branch is checked out and the changelog version is
+adjusted to show this is a development build.
+
+If BRANCH_NAME denotes a release branch (i.e release-1.1) then the latest
+/release/ commit is checked out, even if there are commits after it.
+The changelog remains unaltered in this case - the source tree should have
+the correct version information in it.
+"""
+
+    arg :git_url, "URL used to clone the git repository"
+
+    arg :branch_name, "Name of a branch to build from, defaults to ${default}",
+    :default => "master"
+
+    opt :sign, "Pass options to dpkg-buildpackage to tell it whether or not to sign the build products",
+    {
+      :short => 'S',
+      :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 => true
+    }
+
+    opt :distribution, "Specify the debian distribution to put in the " +
+      "changelog when checking out a development version",
+    {
+      :short => 'd',
+      :long  => 'debian-distribution',
+      :type  => :string
+    }
+
+    opt :verbose, "Print some useful debugging output to stdout",
+    {
+      :long => 'verbose',
+      :short => 'v', :default => false
+    }
+
+    opt :noisy, "Output dpkg-buildpackage output to stderr",
+    {
+      :short => 'n', :default => false
+    }
+
+    opt :silent, "Do not print out build products to stdout", {
+      :default => false
+    }
+
+    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.silent if options[:silent]
+      LOG.verbose if options[:verbose]
+      LOG.noisy if options[:noisy]
+
+      branch_name = release_spec_arg || 'master'
+
+      shallow_output = clone_depth.nil?? '' : ' (shallow)'
+
+      options[:shallow_output] = shallow_output
+
+      # checkout project
+      tmp_dir = "vershunt-#{Time.now.to_i}.tmp"
+      Git.clone(git_url, {:depth => clone_depth, :out_to => tmp_dir,
+                          :branch => branch_name, :no_single_branch => true,
+                          :exec => {:quiet => true}})
+
+      project = Project.new_from_project_file(tmp_dir + "/" + Helpers::PROJECT_FILE)
+
+      project.prepare_for_build(branch_name, options)
+
+      if project.respond_to?(:build)
+        project.build(options)
+      else
+        raise "I don't know how to build this project"
+      end
+
+    end
+
+  end
+end