esr-rim 1.1.5

data/lib/rim/dirty_check.rb

@@ -0,0 +1,111 @@
+require 'digest'
+require 'pathname'
+require 'rim/rim_info'
+require 'rim/file_helper'
+
+module RIM
+
+# Module dirty state checker.
+# 
+# Provides means to mark modules as "clean" and check if they become "dirty" later on. 
+#
+# Once a module has been marked as being clean, it will become dirty if
+# any of the following is true:
+#
+# * Number of contained files has changed
+# * File names or location have changed
+# * File contents have changed
+# * One of the RIM info attributes listed in ChecksumAttributes has changed
+# * The RIM info file is missing or became invalid
+#
+# Ignored files are not considered by this check.
+# 
+class DirtyCheck
+
+  # raised when there is not enough info for checksum calculation
+  class MissingInfoException < Exception
+  end
+
+  # attributes to be included into checksum calculation
+  # checksum calculation fails if those attributes are not present 
+  ChecksumAttributes = [
+    :remote_url,
+    :revision_sha1
+  ]
+
+  # rim info must exist in dir and must be valid
+  # it also must contain attributes listed in ChecksumAttributes
+  # otherwise a MissingInfoException is raised
+  def self.mark_clean(dir)
+    mi = RimInfo.from_dir(dir)
+    cs = self.new.calc_checksum(mi, dir)
+    raise MissingInfoException unless cs
+    mi.checksum = cs
+    mi.to_dir(dir)
+  end
+
+  def self.dirty?(dir)
+    mi = RimInfo.from_dir(dir)
+    # always fails if there is no checksum
+    !mi.checksum || mi.checksum != self.new.calc_checksum(mi, dir)
+  end
+
+  # returns nil if checksum can't be calculated due to missing info
+  def calc_checksum(mi, dir)
+    if check_required_attributes(mi)
+      sha1 = Digest::SHA1.new
+      # all files and directories within dir
+      files = FileHelper.find_matching_files(dir, false, "/**/*", File::FNM_DOTMATCH)
+      # Dir.glob with FNM_DOTMATCH might return . and ..
+      files.delete(".")
+      files.delete("..")
+      # ignore the info file itself
+      files.delete(RimInfo::InfoFileName)
+      # ignores defined by user
+      files -= FileHelper.find_matching_files(dir, false, mi.ignores)
+      # order of files makes a difference
+      # sort to eliminate platform specific glob behavior
+      files.sort!
+      files.each do |fn|
+        update_file(sha1, dir, fn)
+      end
+      ChecksumAttributes.each do |a|
+        sha1.update(mi.send(a))
+      end
+      sha1.hexdigest
+    else
+      # can't calc checksum
+      nil
+    end
+  end 
+
+  private 
+
+  def ignored_files(mi, dir)
+    find_matching_files(dir, mi.ignores)
+  end
+
+  def update_file(sha1, dir, filename)
+    fn = dir+"/"+filename
+    if File.directory?(fn)
+      if Dir.entries(fn).size > 2 # 2 for . and ..
+        # add directory names but only for non-empty directories
+        sha1.update(filename)
+      end
+    else
+      # file name
+      sha1.update(filename)
+      # file contents
+      File.open(fn, "rb") do |f|
+        sha1.update(f.read.gsub("\r\n", "\n"))
+      end
+    end
+  end
+
+  def check_required_attributes(mi)
+    ChecksumAttributes.all?{|a| mi.send(a)}
+  end
+
+end
+
+end

data/lib/rim/file_helper.rb

@@ -0,0 +1,58 @@
+require 'pathname'
+require 'fileutils'
+
+module RIM
+
+class FileHelper
+
+  def self.get_relative_path(path, base)
+    Pathname.new(get_absolute_path(path)).relative_path_from(Pathname.new(base)).to_s    
+  end
+  
+  def self.get_absolute_path(path)
+    File.expand_path(path)
+  end
+
+  def self.find_matching_files(dir, absolute = true, patterns = "**/*", flags = 0)
+    files = []
+    dirpath = Pathname.new(dir)
+    normalize_patterns(patterns).each do |i|
+      Dir.glob(File.join(dir, i), flags) do |f|
+        if absolute
+          files.push(f)
+        else
+          files.push(Pathname.new(f).relative_path_from(dirpath).to_s)
+        end
+      end
+    end
+    files.sort.uniq
+  end
+  
+  def self.remove_empty_dirs(dir, exclude = ".")
+    exclude = File.join(File.expand_path(exclude), "") if exclude
+    Dir.glob(File.join(dir, "/*/**/")).reverse_each do |d|
+      Dir.rmdir d if Dir.entries(d).size == 2 && (!exclude || !exclude.start_with?(d))
+    end
+  end
+  
+  def self.make_empty_dir(dir)
+    FileUtils.rm_rf dir
+    FileUtils.mkdir_p(dir)
+  end
+  
+private
+  
+  def self.normalize_patterns(patterns = [])
+    if patterns.is_a?(String)
+      return patterns.split(",").each do |p|
+        p.strip!       
+      end
+    elsif !patterns
+      patterns = []
+    end
+    patterns
+  end
+
+end
+
+end

data/lib/rim/file_logger.rb

@@ -0,0 +1,21 @@
+require 'logger'
+
+module RIM
+
+class FileLogger < Logger
+
+  def initialize(name, file)
+    super(name)
+    FileUtils.mkdir_p(File.dirname(file))
+    @file_logger = Logger.new(file)
+    @file_logger.level = Logger::DEBUG
+  end
+
+  def add(severity, message = nil, progname = nil, &block)
+    @file_logger.add(severity, message, progname)
+    super(severity, message, progname)    
+  end
+
+end
+
+end

data/lib/rim/git.rb

@@ -0,0 +1,339 @@
+require 'tmpdir'
+require 'logger'
+
+module RIM
+
+# raised when there is an error emitted by git call
+class GitException < Exception
+  attr_reader :cmd, :exitstatus, :out
+  def initialize(cmd, exitstatus, out)
+    super("git \"#{cmd}\" => #{exitstatus}\n#{out}")
+    @cmd = cmd
+    @exitstatus = exitstatus
+    @out = out
+  end
+end
+
+class GitSession
+
+  attr_reader :execute_dir
+
+  def initialize(logger, execute_dir, arg = {})
+    @execute_dir = execute_dir
+    if arg.is_a?(Hash)
+      @work_dir = arg.has_key?(:work_dir) ? arg[:work_dir] : ""
+      @git_dir = arg.has_key?(:git_dir) ? arg[:git_dir] : ""
+    end
+    @logger = logger
+  end
+
+  def self.logger=(logger)
+    @logger = logger
+  end
+
+  def self.open(execute_dir, options = {})
+    log = @logger || Logger.new($stdout)
+    self.new(log, execute_dir, options)
+  end
+
+  def self.next_invocation_id
+    @invocation_id ||= 0
+    @invocation_id += 1
+  end
+
+  class Status
+    attr_accessor :lines
+
+    # X          Y     Meaning
+    # -------------------------------------------------
+    #           [MD]   not updated
+    # M        [ MD]   updated in index
+    # A        [ MD]   added to index
+    # D         [ M]   deleted from index
+    # R        [ MD]   renamed in index
+    # C        [ MD]   copied in index
+    # [MARC]           index and work tree matches
+    # [ MARC]     M    work tree changed since index
+    # [ MARC]     D    deleted in work tree
+    # -------------------------------------------------
+    # D           D    unmerged, both deleted
+    # A           U    unmerged, added by us
+    # U           D    unmerged, deleted by them
+    # U           A    unmerged, added by them
+    # D           U    unmerged, deleted by us
+    # A           A    unmerged, both added
+    # U           U    unmerged, both modified
+    # -------------------------------------------------
+    # ?           ?    untracked
+    # !           !    ignored
+    # -------------------------------------------------
+    class Line
+      attr_accessor :istat, :wstat, :file, :rename
+
+      def untracked?
+        istat == "?" && wstat == "?"
+      end
+
+      def ignored?
+        istat == "!" && wstat == "!"
+      end
+
+      def unmerged?
+        istat == "D" && wstat == "D" ||
+        istat == "A" && wstat == "A" ||
+        istat == "U" ||
+        wstat == "U"
+      end
+
+    end
+  end
+
+  # returns the current branch
+  def current_branch
+    out = execute "git branch"
+    out.split("\n").each do |l| 
+      if l =~ /^\*\s+(\S+)/
+        return $1
+      end
+    end
+    nil
+  end
+  
+  # check whether branch exists
+  def has_branch?(branch)
+    execute("git show-ref refs/heads/#{branch}") do |b, e|
+      return !e
+    end
+  end
+  
+  # check whether remote branch exists
+  def has_remote_branch?(branch)
+    out = execute("git ls-remote --heads")
+    out.split("\n").each do |l|
+      return true if l.split(/\s+/)[1] == "refs/heads/#{branch}"
+    end
+    false
+  end 
+  
+  # check whether remote repository is valid
+  def has_valid_remote_repository?()
+    execute("git ls-remote") do |b, e|
+      return !e
+    end
+  end 
+
+  # checks whether the first (ancestor) revision is is ancestor of the second (child) revision
+  def is_ancestor?(ancestor, child)
+    execute("git merge-base --is-ancestor #{ancestor} #{child}") do |b, e|
+      return !e
+    end
+  end
+
+  # returns the parent commits of rev as SHA-1s 
+  # returns an empty array if there are no parents (e.g. orphan or initial)
+  def parent_revs(rev)
+    out = execute "git rev-list -n 1 --parents #{rev} --"
+    out.strip.split[1..-1]
+  end
+
+  # returns the SHA-1 representation of rev
+  def rev_sha1(rev)
+    sha1 = nil
+    execute "git rev-list -n 1 #{rev} --" do |out, e|
+      sha1 = out.strip if !e
+    end
+    sha1
+  end
+  
+  # returns the SHA-1 representations of the heads of all remote branches
+  def remote_branch_revs
+    out = execute "git show-ref"
+    out.split("\n").collect { |l|
+      if l =~ /refs\/remotes\//
+        l.split[0]
+      else
+        nil
+      end
+    }.compact
+  end
+
+  # all commits reachable from rev which are not ancestors of remote branches
+  def all_reachable_non_remote_revs(rev)
+    out = execute "git rev-list #{rev} --not --remotes --"
+    out.split("\n")
+  end
+
+  # export file contents of rev to dir
+  # if +paths+ is given and non-empty, checks out only those parts of the filesystem tree
+  # does not remove any files from dir which existed before
+  def export_rev(rev, dir, paths=[])
+    paths = paths.dup
+    loop do
+      path_args = ""
+      # max command line length on Windows XP and higher is 8191
+      # consider the following extra characters which will be added:
+      # up to 3 paths in execute, 1 path for tar, max path length 260 = 1040
+      # plus some "glue" characters, plus the last path item with 260 max;
+      # use 6000 to be on the safe side
+      while !paths.empty? && path_args.size < 6000
+        path_args << " "
+        path_args << paths.shift
+      end
+      execute "git archive --format tar #{rev} #{path_args} | tar -x -C #{dir}"
+      break if paths.empty?
+    end
+  end
+
+  # checks out rev to a temporary directory and yields this directory to the given block
+  # if +paths+ is given and non-empty, checks out only those parts of the filesystem tree
+  # returns the value returned by the block
+  def within_exported_rev(rev, paths=[])
+    Dir.mktmpdir("rim") do |d|
+      c = File.join(d, "content")
+      FileUtils.mkdir(c)
+      export_rev(rev, c, paths)
+      # return contents of yielded block
+      # mktmpdir returns value return by our block
+      yield c
+      FileUtils.rm_rf(c)
+      # retry to delete if it hasn't been deleted yet
+      # this could be due to Windows keeping the files locked for some time
+      # this is especially a problem if the machine is at its limits
+      retries = 600
+      while File.exist?(c) && retries > 0
+        sleep(0.1)
+        FileUtils.rm_rf(c)
+        retries -= 1
+      end
+      if File.exist?(c)
+        @logger.warn "could not delete temp dir: #{c}"
+      end
+    end
+  end
+    
+  def uncommited_changes?
+    # either no status lines are all of them due to ignored items
+    !status.lines.all?{|l| l.ignored?}
+  end
+
+  def current_branch_name
+    out = execute "git rev-parse --abbrev-ref HEAD"
+    out.strip
+  end
+
+  ChangedFile = Struct.new(:path, :kind)
+
+  # returns a list of all files which changed in commit +rev+
+  # together with the kind of the change (:modified, :deleted, :added)
+  #
+  # if +from_rev+ is given, lists changes between +from_rev and +rev+
+  # with one argument only, no changes will be returned for merge commits
+  # use the two argument variant for merge commits and decide for one parent
+  def changed_files(rev, rev_from=nil)
+    out = execute "git diff-tree -r --no-commit-id #{rev_from} #{rev}"
+    out.split("\n").collect do |l|
+      cols = l.split
+      path = cols[5]
+      kind = case cols[4]
+        when "M"
+          :modified
+        when "A"
+          :added
+        when "D"
+          :deleted
+        else
+          nil
+        end
+      ChangedFile.new(path, kind)
+    end
+  end
+
+  # 3 most significant numbers of git version of nil if it can't be determined
+  def git_version
+    out = execute("git --version")
+    if out =~ /^git version (\d+\.\d+\.\d+)/
+      $1
+    else
+      nil
+    end
+  end
+
+  def status(dir = nil)
+    # -s            short format
+    # --ignored     show ignored
+    out = execute "git status -s --ignored #{dir}"
+    parse_status(out)
+  end
+
+  def execute(cmd)
+    raise "git command has to start with 'git'" unless cmd.start_with? "git "
+    cmd.slice!("git ")
+    # remove any newlines as they will cause the command line to end prematurely
+    cmd.gsub!("\n", "")
+    options = ((!@execute_dir || @execute_dir == ".") ? "" : " -C #{@execute_dir}") \
+        + (@work_dir.empty? ? "" : " --work-tree=#{File.expand_path(@work_dir)}") \
+        + (@git_dir.empty? ? "" : " --git-dir=#{File.expand_path(@git_dir)}") 
+    cmd = "git#{options} #{cmd} 2>&1"
+
+    out = `#{cmd}`
+    # make sure we don't run into any encoding misinterpretation issues
+    out.force_encoding("binary")
+
+    exitstatus = $?.exitstatus
+
+    invid = self.class.next_invocation_id.to_s.ljust(4)
+    @logger.debug "git##{invid} \"#{cmd}\" => #{exitstatus}" 
+
+    out.split(/\r?\n/).each do |ol|
+      @logger.debug "git##{invid} out : #{ol}"
+    end
+
+    exception = exitstatus != 0 ? GitException.new(cmd, exitstatus, out) : nil
+    
+    if block_given?
+      yield out, exception  
+    elsif exception
+      raise exception
+    end
+
+    out
+  end
+
+  private
+
+  def parse_status(out)
+    status = Status.new
+    status.lines = []
+    out.split(/\r?\n/).each do |l|
+      sl = Status::Line.new
+      sl.istat, sl.wstat = l[0], l[1]
+      f1, f2 = l[3..-1].split(" -> ")
+      f1 = unquote(f1)
+      f2 = unquote(f2) if f2
+      sl.file = f1
+      sl.rename = f2
+      status.lines << sl
+    end
+    status
+  end
+
+  def unquote(s)
+    if s[0] == "\"" && s[-1] == "\""
+      s = s[1..-2]
+      s.gsub!("\\\\", "\\")
+      s.gsub!("\\\"", "\"")
+      s.gsub!("\\t", "\t")
+      s.gsub!("\\r", "\r")
+      s.gsub!("\\n", "\n")
+    end
+    s
+  end
+
+end
+
+def RIM.git_session(execute_dir, options = {})
+  s = GitSession.open(execute_dir, options)
+  yield s
+end
+
+end