vershunt 2.0.4

data/lib/msp_release/exec.rb

@@ -0,0 +1,120 @@
+require 'thread'
+require 'popen4'
+
+module MSPRelease
+  class Exec
+
+    class UnexpectedExitStatus < StandardError
+      def initialize(expected, actual, cmd, output, stdout, stderr)
+        @expected = expected
+        @actual = actual
+        @command = cmd
+        @stdout = stdout
+        @stderr = stderr
+        super("command '#{command}' exited with #{actual}, expected #{expected}")
+      end
+
+      attr_reader :expect, :actual, :command, :output, :stdout, :stderr
+      # this marries up with what popen et al return
+      alias :exitstatus :actual
+    end
+
+    module Helpers
+      def exec(command, options={})
+        # use the options we were constructed with if they exist
+        if respond_to?(:options)
+          options[:quiet] = !self.options.verbose? unless options.has_key? :quiet
+        end
+
+        if respond_to? :exec_name
+          options[:name] = exec_name unless options.has_key? :name
+        end
+
+        MSPRelease::Exec.exec(command, options)
+      end
+    end
+
+    def self.exec(command, options={})
+      new(options).exec(command, options)
+    end
+
+    attr_reader :name
+
+    def initialize(options={})
+      @name   = options.fetch(:name,   nil)
+    end
+
+    def last_stdout
+      @last_stdout
+    end
+
+    def last_stderr
+      @last_stderr
+    end
+
+    def last_output
+      @last_output
+    end
+
+    def last_exitstatus
+      @last_exitstatus
+    end
+
+    def exec(command, options={})
+
+      expected = to_expected_array(options.fetch(:status, 0))
+
+      @last_stdout = ""
+      @last_stderr = ""
+      @last_output = ""
+
+      output = options[:output]
+
+      output_semaphore = Mutex.new
+
+      start = name.nil? ? '' : "#{name}: "
+
+      status = POpen4::popen4(command) do |stdout, stderr, stdin, pid|
+        t1 = Thread.new do
+          stdout.each_line do |line|
+            @last_stdout += line
+            output_semaphore.synchronize { @last_output += line }
+            msg = "#{start}#{line}"
+            (output && !options[:quiet]) ? output.puts(msg) : LOG.debug(msg)
+          end
+        end
+
+        t2 = Thread.new do
+          stderr.each_line do |line|
+            @last_stderr += line
+            output_semaphore.synchronize { @last_output += line }
+            msg = "#{start}#{line}"
+            (output && !options[:quiet]) ? output.puts(msg) : LOG.error(msg)
+          end
+        end
+
+        t1.join
+        t2.join
+      end
+
+      @last_exitstatus = status.exitstatus
+
+      unless expected.nil? || expected.include?(status.exitstatus)
+        raise UnexpectedExitStatus.new(expected, status.exitstatus, command, @last_output, @last_stdout, @last_stderr)
+      end
+
+      @last_stdout
+    end
+
+    private
+
+    def to_expected_array(value)
+      case value
+      when :any   then nil
+      when Array  then value
+      when Numeric then [value]
+      else raise ArgumentError, "#{value} is not an acceptable exit status"
+      end
+    end
+  end
+end

data/lib/msp_release/git.rb

@@ -0,0 +1,145 @@
+class MSPRelease::Git
+
+  # methods that don't require a local clone
+  module ClassMethods
+    def version()
+      MSPRelease::Exec.exec("git version", :output => StringIO.new)
+    end
+
+    def version_gte(maj, min=0, bug=0)
+      match = version.match(/(\d+)\.(\d+)\.(\d+)\..*/)
+      match[1].to_i >= maj &&
+        match[2].to_i >= min &&
+        match[3].to_i >= bug
+    end
+
+    def clone(git_url, options={})
+      out_to = options[:out_to]
+      exec_options = options[:exec] || {}
+      depth_arg = options[:depth].nil?? '' : "--depth #{options[:depth]}"
+      branch = options[:branch].nil?? '' : "--branch #{options[:branch]}"
+
+      heads = StringIO.new
+      MSPRelease::Exec.exec("git ls-remote --heads #{git_url}", :output => heads)
+
+      unless heads.string.match(/#{options[:branch]}/)
+        raise MSPRelease::CLI::Exit, "Git pathspec 'origin/#{options[:branch]}' does not exist"
+      end
+
+      single_branch = if version_gte(1, 7, 10)
+        options[:no_single_branch] ? '--no-single-branch' :
+          options[:single_branch] ? '--single-branch' :
+          ''
+      end
+
+      MSPRelease::Exec.
+        exec("git clone #{depth_arg} #{single_branch} #{branch} #{git_url} #{out_to.nil?? '' : out_to}", exec_options)
+    end
+  end
+
+  class << self
+    include ClassMethods
+  end
+
+  class Commit
+    include MSPRelease::Exec::Helpers
+    attr_reader :message
+    attr_reader :author
+    attr_reader :hash
+
+    def initialize(project, attributes)
+      @project = project
+      attributes.each do |k, v|
+        instance_variable_set(:"@#{k}", v)
+      end
+    end
+
+    def release_commit?
+      !! (release_name || tag)
+    end
+
+    def tag
+      tag = exec "git tag --contains #{hash}"
+      (m = /^release-([0-9.]*)$/.match(tag)) && m[1]
+    end
+
+    def release_name
+      @project.release_name_from_message(message) || tag
+    end
+  end
+
+  include MSPRelease::Exec::Helpers
+
+  def initialize(project, options)
+    @project = project
+    @options = options
+  end
+
+  def exec_name; 'git'; end
+
+  attr_reader :options
+
+  def on_master?
+    cur_branch == 'master'
+  end
+
+  def cur_branch
+    /^\* (.+)$/.match(exec "git branch")[1]
+  end
+
+  def last_release_tag
+    a = exec "git describe --tags --match 'release-*'"
+  end
+
+  def branch_exists?(branch_name)
+    # use backticks, we don't want an error
+    `git show-branch origin/#{branch_name}`
+    $? == 0
+  end
+
+  def create_and_switch(branch_name, options={})
+    start_point = options[:start_point]
+    exec "git branch #{branch_name} #{start_point}"
+    exec "git push origin #{branch_name}"
+    exec "git checkout #{branch_name}"
+  end
+
+  def added_files
+    status_files("new file")
+  end
+
+  def modified_files
+    status_files("modified")
+  end
+
+  def status_files(status)
+    output = exec "git status", :status => :any
+    pattern = /#{status}: +(.+)$/
+    output.split("\n").map {|l| pattern.match(l) }.compact.map{|m|m[1]}
+  end
+
+  def latest_commit(project)
+    commit_output =
+      exec("git --no-pager log -1 --no-color --full-index --pretty=short").split("\n")
+
+    commit_pattern = /^commit ([a-z0-9]+)$/
+    author_pattern = /^Author: (.+)$/
+    message_pattern = /^    (.+)$/
+
+    hash = commit_output.grep(commit_pattern) {|m| commit_pattern.match(m)[1] }.first
+    author = commit_output.grep(author_pattern) {|m| author_pattern.match(m)[1] }.first
+    message = commit_output.grep(message_pattern).
+      map {|row| message_pattern.match(row)[1] }.
+      join(" ")
+
+    Commit.new(project, {:hash => hash, :author => author, :message => message})
+  end
+
+  def remote_is_ahead?
+    raise NotImplementedError
+    branch_name = cur_branch
+    exec "git fetch"
+    exec "git --no-pager log origin/#{branch_name} --no-color --oneline -1".split("")
+  end
+
+end

data/lib/msp_release/log.rb

@@ -0,0 +1,48 @@
+# simple class for keeping output in one place
+module MSPRelease
+  class Log
+    @@log_levels = {
+      :error => $stderr,
+      :warn => $stderr,
+      :info => $stdout,
+      :debug => StringIO.new,
+      :trace => StringIO.new
+    }
+
+    def initialize
+    end
+
+    def verbose
+      @@log_levels[:debug] = $stdout
+    end
+
+    def noisy
+      @@log_levels[:debug] = $stderr
+    end
+
+    def silent
+      @@log_levels.keys.each do |level|
+        @@log_levels[level] = StringIO.new
+      end
+    end
+
+    @@log_levels.keys.each do |level|
+      define_method level do |msg|
+        @@log_levels[level].puts(msg)
+      end
+
+      define_method "set_#{level}" do
+        @@log_levels[level] = $stdout
+      end
+
+      define_method "set_#{level}_err" do
+        @@log_levels[level] = $stderr
+      end
+
+      define_method "unset_#{level}" do
+        @@log_levels[level] = self.nil_log
+      end
+    end
+
+  end
+end

data/lib/msp_release/make_branch.rb

@@ -0,0 +1,29 @@
+module MSPRelease
+  class MakeBranch
+
+    class BranchExistsError < StandardError ; end
+
+    include Exec::Helpers
+
+    attr_reader :branch_name
+    attr_reader :git
+    attr_reader :options
+
+    def initialize(git, branch_name, options={})
+      @git = git
+      @branch_name = branch_name
+      @options = options
+    end
+
+    def perform!
+      if git.branch_exists?(branch_name)
+        raise BranchExistsError, branch_name
+      end
+
+      git.create_and_switch(branch_name,
+        :start_point => options[:start_point])
+    end
+  end
+
+
+end

data/lib/msp_release/options.rb

@@ -0,0 +1,35 @@
+require 'optparse'
+
+class MSPRelease::Options
+
+  def self.get(given_args)
+    args = given_args.clone
+    opt = new(args)
+    [opt, args]
+  end
+
+  def initialize(args)
+    @store = {
+      :verbose => false
+    }
+    opts = OptionParser.new do |opts|
+      opts.on("-v", "--[no-]verbose", "Run with verbose output") do |v|
+        @store[:verbose] = v
+      end
+    end.parse!(args)
+  end
+
+  def [](key)
+    @store.fetch(key)
+  end
+
+  def []=(key, value)
+    $stderr.puts("Warning, overiding config key #{key}") if @store[key]
+    @store[key] = value
+  end
+
+  def verbose?
+    self[:verbose]
+  end
+
+end

data/lib/msp_release/project.rb

@@ -0,0 +1,41 @@
+module MSPRelease::Project
+
+  def self.new_from_project_file(filename)
+    config = YAML.load_file(filename)
+    dirname = File.expand_path(File.dirname(filename))
+
+    project = Base.new(filename, dirname)
+
+    # TODO: make it so that this doesn't have to know about all the possible
+    # mixins.
+
+    # If the directory has a debian folder, treat it as a debian project.
+    if File.directory?(File.join(dirname, 'debian'))
+      project.extend(Debian)
+    elsif Dir.glob("#{dirname}/*.gemspec").count > 0
+      project.extend(Gem)
+      # If its a gem project, it must also be a ruby project.
+      project.extend(Ruby)
+    end
+
+    # If there is a ruby version file, we treat it as a
+    if config[:ruby_version_file]
+      project.extend(Ruby)
+    end
+
+    # Git project
+    if File.directory?(File.join(dirname, '.git'))
+      project.extend(Git)
+    end
+
+    project
+  end
+
+end
+
+require 'msp_release/project/base'
+require 'msp_release/project/ruby'
+require 'msp_release/project/debian'
+require 'msp_release/project/gem'
+require 'msp_release/project/git'
+

data/lib/msp_release/project/base.rb

@@ -0,0 +1,63 @@
+module MSPRelease
+  class Project::Base
+
+    include MSPRelease::Exec::Helpers
+
+    RELEASE_COMMIT_PREFIX = "RELEASE COMMIT - "
+
+    attr_reader :config, :config_file, :dir
+
+    def initialize(filename, dir='.')
+      @config_file = filename
+      @dir = dir
+      @config = YAML.load_file(@config_file)
+      config.each do |key, value|
+        instance_variable_set("@#{key}", value)
+      end
+    end
+
+    def release_name_from_message(commit_message)
+      idx = commit_message.index(RELEASE_COMMIT_PREFIX)
+      return nil unless idx == 0
+
+      commit_message[RELEASE_COMMIT_PREFIX.length..-1]
+    end
+
+    # Returns the commit message that should be used for a given release
+    def release_commit_message(release_name)
+      "#{RELEASE_COMMIT_PREFIX}#{release_name}"
+    end
+
+    def branch_name(version=self.version)
+      "release-#{version.format(:without_bugfix => true)}"
+    end
+
+    def at_version?(rhs_version)
+      any_version == rhs_version
+    end
+
+    def bump_version(segment)
+      new_version = version.bump(segment.to_sym)
+      written_files = write_version(new_version)
+      [new_version, *written_files]
+    end
+
+    def build(options={})
+      unless self.respond_to?(:build_command)
+        raise "Don't know how to build this project"
+      end
+
+      build_opts(options) if self.respond_to?(:build_opts)
+
+      LOG.debug("Checked out to #{@dir}")
+
+      LOG.debug("Building...")
+      build = Build.new(@dir, self, options)
+
+      result = build.perform_from_cli!
+      LOG.debug("Build products:")
+      result.files.each {|f| LOG.info(f) }
+    end
+
+  end
+end