esr-rim 1.1.5

data/lib/rim/sync_helper.rb

@@ -0,0 +1,121 @@
+require 'rim/command_helper'
+require 'rim/sync_module_helper'
+require 'rim/status_builder'
+require 'tempfile'
+require 'fileutils'
+
+module RIM
+
+class SyncHelper < CommandHelper
+
+  def initialize(workspace_root, logger, module_infos = nil)
+    @module_infos = []
+    super(workspace_root, logger, module_infos)
+  end
+
+  # called to add a module info
+  def add_module_info(module_info)
+    @module_infos.push(module_info)
+  end
+
+  # sync all module changes into rim branch
+  def sync(message = nil)
+    # get the name of the current workspace branch
+    RIM::git_session(@ws_root) do |s|
+      branch = s.current_branch
+      rim_branch = "rim/" + branch
+      branch_sha1 = nil
+      if branch.empty?
+        raise RimException.new("Not on a git branch.")
+      elsif branch.start_with?("rim/")
+        raise RimException.new("The current git branch '#{branch}' is a rim integration branch. Please switch to a non rim branch to proceed.")
+      else
+        branch_sha1 = s.rev_sha1(rim_branch)
+        remote_rev = get_latest_remote_revision(s, branch)
+        rev = get_latest_clean_path_revision(s, branch, remote_rev)
+        if !s.has_branch?(rim_branch) || has_ancestor?(s, branch, s.rev_sha1(rim_branch)) || !has_ancestor?(s, rim_branch, remote_rev)
+          s.execute("git branch -f #{rim_branch} #{rev}")
+        end
+        remote_url = "file://" + @ws_root
+        tmpdir = clone_or_fetch_repository(remote_url, module_tmp_git_path(".ws"), "Cloning workspace git...")
+        RIM::git_session(tmpdir) do |tmp_session|
+          if tmp_session.current_branch() == rim_branch
+            tmp_session.execute("git reset --hard remotes/origin/#{rim_branch}")
+            tmp_session.execute("git clean -xdf")
+          else 
+            tmp_session.execute("git reset --hard")
+            tmp_session.execute("git clean -xdf")
+            tmp_session.execute("git checkout #{rim_branch}")
+          end
+          @logger.info("Synchronizing modules...")
+          sync_modules(tmp_session, message)
+          tmp_session.execute("git push #{remote_url} #{rim_branch}:#{rim_branch}")
+        end
+      end
+      if s.rev_sha1(rim_branch) != branch_sha1
+        @logger.info("Changes have been commited to branch #{rim_branch}. Rebase to apply changes to workspace.")
+      else
+        @logger.info("No changes.")
+      end
+    end
+  end
+
+private
+  # sync all modules
+  def sync_modules(session, message)
+    module_helpers = []
+    @module_infos.each do |module_info|
+      module_helpers.push(SyncModuleHelper.new(session.execute_dir, @ws_root, module_info, @logger))
+    end
+    module_helpers.each do |m|
+      m.sync(message)
+    end
+  end
+
+  # get latest revision from which all parent revisions are clean 
+  def get_latest_clean_path_revision(session, rev, remote_rev)
+    # make sure we deal only with sha1s
+    rev = session.rev_sha1(rev)
+    # get history status (up to last remote revision)
+    status = StatusBuilder.new().rev_history_status(session, rev, :fast => true)
+    clean_rev = rev;
+    while status
+      dirty = status.dirty?
+      status = !status.parents.empty? ? status.parents[0] : nil  
+      clean_rev = status ? status.git_rev : remote_rev if dirty
+    end
+    clean_rev
+  end
+
+  # get latest remote revision
+  def get_latest_remote_revision(session, rev)
+    # remote revs are where we stop traversal
+    non_remote_revs = {}
+    session.all_reachable_non_remote_revs(rev).each do |r| 
+      non_remote_revs[r] = true
+    end
+    # make sure we deal only with sha1s
+    rev = session.rev_sha1(rev)
+    start_rev = rev;
+    while rev && non_remote_revs[rev]
+      rev = get_parent(session, rev)
+    end
+    rev
+  end
+
+  # check whether revision has a given ancestor
+  def has_ancestor?(session, rev, ancestor)
+    # make sure we deal only with sha1s
+    rev = session.rev_sha1(rev)
+    return rev == ancestor || session.is_ancestor?(ancestor, rev)
+  end
+  
+  # get first parent node
+  def get_parent(session, rev)
+    parents = session.parent_revs(rev)
+    !parents.empty? ? parents.first : nil 
+  end  
+
+end
+
+end

data/lib/rim/sync_module_helper.rb

@@ -0,0 +1,115 @@
+require 'rim/module_helper'
+require 'rim/rim_info'
+require 'rim/file_helper'
+require 'rim/dirty_check'
+require 'tempfile'
+
+module RIM
+  class SyncModuleHelper < ModuleHelper
+    def initialize(dest_root, workspace_root, module_info, logger)
+      super(workspace_root, module_info, logger)
+      @dest_root = dest_root
+    end
+
+    # do the local sync without committing
+    def sync(message = nil)
+      fetch_module
+      export_module(message)
+    end
+
+    private
+
+    # export +revision+ of +mod+ into working copy
+    # BEWARE: any changes to the working copy target dir will be lost!
+    def export_module(message)
+      RIM::git_session(@dest_root) do |d|
+        start_sha1 = d.rev_sha1("HEAD")
+        git_path = module_git_path(@remote_path)
+        RIM::git_session(git_path) do |s|
+          if !s.rev_sha1(@module_info.target_revision)
+            raise RimException.new("Unknown target revision '#{@module_info.target_revision}' for module '#{@module_info.local_path}'.")
+          end
+          local_path = File.join(@dest_root, @module_info.local_path)
+          prepare_empty_folder(local_path, @module_info.ignores)
+          temp_commit(d, "clear directory") if d.uncommited_changes?
+          s.execute("git archive --format tar #{@module_info.target_revision} | tar -x -C #{local_path}")
+          sha1 = s.execute("git rev-parse #{@module_info.target_revision}").strip
+          @rim_info = RimInfo.new
+          @rim_info.remote_url = @module_info.remote_url
+          @rim_info.target_revision = @module_info.target_revision
+          @rim_info.revision_sha1 = sha1
+          @rim_info.ignores = @module_info.ignores.join(",")
+          @rim_info.to_dir(local_path)
+          DirtyCheck.mark_clean(local_path)
+        end
+        temp_commit(d, "commit changes") if needs_commit?(d)
+        d.execute("git reset --soft #{start_sha1}")
+        commit(message) if d.uncommited_changes?
+      end
+    end
+
+    def commit(message)
+      RIM::git_session(@dest_root) do |s|
+        msg_file = Tempfile.new('message')
+        begin
+          if message
+            msg_file << message
+          else
+            msg_file << "rim sync: module #{@module_info.local_path}"
+          end
+          msg_file.close
+          s.execute("git add --all")
+          s.execute("git commit -F #{msg_file.path}")
+        ensure
+          msg_file.close(true)
+        end
+      end
+    end
+
+    def needs_commit?(session)
+      # do we need to commit something?
+      stat = session.status(@module_info.local_path)
+      ignored = stat.lines.select{ |l| l.ignored? }
+      if ignored.empty?
+        session.execute("git add --all #{@module_info.local_path}") do |out, e|
+          ignored = parse_ignored_files(session, out, e)
+        end
+        if ignored.empty?
+          stat = session.status(@module_info.local_path)
+          ignored = stat.lines.select{ |l| l.ignored? }
+        end
+      end
+      if !ignored.empty?
+        messages = ["Sync failed due to files/dirs of #{@module_info.local_path} which are ignored by workspace's .gitignore:"]
+        ignored.each do |l|
+          messages.push(l.file)
+        end
+        raise RimException.new(messages)
+      end
+      stat.lines.any?
+    end
+
+    def temp_commit(session, message)
+      session.execute("git add --all")
+      session.execute("git commit -m \"#{message}\" --")
+    end
+
+    def parse_ignored_files(session, out, e)
+      first_line = true
+      ignored = []
+      out.gsub(/warning:.*will be replaced.*\r?\n.*\r?\n/, '').split(/\r?\n/).each do |l|
+        raise e || RimException.new("Cannot parse ignored files after git add:\n#{out}") if first_line && !l.include?(".gitignore")
+        if File.exist?(File.expand_path(l, session.execute_dir))
+          ignored_line = GitSession::Status::Line.new
+          ignored_line.file = l
+          ignored_line.istat = "!"
+          ignored.push(ignored_line)
+        end
+        first_line = false
+      end
+      ignored
+    end
+
+  end
+
+end

data/lib/rim/upload_helper.rb

@@ -0,0 +1,67 @@
+require 'rim/command_helper'
+require 'rim/upload_module_helper'
+
+module RIM
+
+class UploadHelper < CommandHelper
+
+  def initialize(workspace_root, review, logger, module_infos = nil)
+    @module_helpers = []
+    @review = review
+    super(workspace_root, logger, module_infos)
+  end
+
+  # upload all module changes into corresponding remote repositories
+  def upload
+    # get the name of the current workspace branch
+    RIM::git_session(@ws_root) do |s|
+      branch = s.current_branch
+      if !branch.start_with?("rim/")
+        begin
+          sha1 = s.rev_sha1(branch)
+          @logger.info("Uploading modules...")
+          upload_modules(get_upload_revisions(s, sha1))
+        ensure
+          s.execute("git checkout #{branch}")
+        end
+      else
+        raise RimException.new("The current git branch '#{branch}' is a rim integration branch. Please switch to a non rim branch to proceed.")
+      end
+    end
+  end
+
+  # called to add a module info
+  def add_module_info(module_info)
+    @module_helpers.push(UploadModuleHelper.new(@ws_root, module_info, @review, @logger))
+  end
+  
+private
+  # upload all modules
+  def upload_modules(info)
+    each_module_parallel("uploading", @module_helpers) do |m|
+      m.upload(info.parent, info.sha1s)
+    end
+  end
+
+  # get revisions to upload i.e. the revisions up to the last remote revision
+  # the function returns the revisions in order of appearal i.e. the oldest first 
+  def get_upload_revisions(session, rev)
+    # remote revs are where we stop traversal
+    non_remote_revs = {}
+    session.all_reachable_non_remote_revs(rev).each do |r| 
+      non_remote_revs[r] = true
+    end
+    revisions = []
+    # make sure we deal only with sha1s
+    rev = session.rev_sha1(rev)
+    while rev && non_remote_revs[rev]
+      revisions.push(rev)
+      parents = session.parent_revs(rev)
+      rev = parents.size > 0 ? parents.first : nil
+    end
+    Struct.new(:parent, :sha1s).new(rev, revisions.reverse!)
+  end
+
+end
+
+end

data/lib/rim/upload_module_helper.rb

@@ -0,0 +1,152 @@
+require 'rim/module_helper'
+require 'rim/rim_info'
+require 'rim/file_helper'
+require 'rim/dirty_check'
+require 'rim/status_builder'
+require 'tempfile'
+
+module RIM
+
+class UploadModuleHelper < ModuleHelper
+
+  def initialize(workspace_root, module_info, review, logger)
+    super(workspace_root, module_info, logger)
+    @review = review
+  end
+
+  # do the module uploads for revisions given by sha
+  def upload(parent, sha1s)
+    upload_module_changes(parent, sha1s)      
+  end
+  
+private
+
+  # upload the content of the module
+  def upload_module_changes(parent_sha1, sha1s)
+    remote_path = fetch_module
+    # search for the first revision that is not 
+    tmp_git_path = clone_or_fetch_repository(remote_path, module_tmp_git_path(@remote_path))
+    RIM::git_session(tmp_git_path) do |dest|
+      local_branch = nil
+      remote_branch = nil
+      infos = nil
+      RIM::git_session(@ws_root) do |src|
+        infos = get_branches_and_revision_infos(src, dest, parent_sha1, sha1s)
+        if infos.branches.size == 1
+          remote_branch = infos.branches[0]
+          if dest.has_remote_branch?(remote_branch)
+            infos.rev_infos.each do |rev_info|
+              local_branch = create_update_branch(dest, infos.parent_sha1, rev_info.src_sha1) if !local_branch
+              copy_revision_files(src, rev_info.src_sha1, tmp_git_path, rev_info.rim_info.ignores)
+              commit_changes(dest, local_branch, rev_info.src_sha1, rev_info.message)
+            end
+          else
+            raise RimException.new("The target revision '#{@module_info.target_revision}' of module #{@module_info.local_path} is not a branch. No push can be performed.")
+          end
+        elsif infos.branches.size > 1
+          raise RimException.new("There are commits for module #{@module_info.local_path} on multiple target revisions (#{infos.branches.join(", ")}).")
+        end
+      end
+      # Finally we're done. Push the changes
+      if local_branch && dest.rev_sha1(local_branch) != infos.parent_sha1  
+        push_branch = @review && @module_info.remote_branch_format && !@module_info.remote_branch_format.empty? \
+            ? @module_info.remote_branch_format % remote_branch : remote_branch
+        dest.execute("git push #{@remote_url} #{local_branch}:#{push_branch}")
+        dest.execute("git checkout --detach #{local_branch}")
+        dest.execute("git branch -D #{local_branch}")
+        @logger.info("Commited changes for module #{@module_info.local_path} to remote branch #{push_branch}.")
+      else
+        @logger.info("No changes to module #{@module_info.local_path}.")
+      end                              
+    end
+  end
+
+  # search backwards for all revision infos
+  def get_branches_and_revision_infos(src_session, dest_session, parent_sha1, sha1s)
+    infos = []
+    branches = []
+    dest_parent_sha1 = nil
+    (sha1s.size() - 1).step(0, -1) do |i|
+      info = get_revision_info(src_session, dest_session, sha1s[i])
+      if !info.dest_sha1 && info.rim_info.target_revision
+        infos.unshift(info)
+        branches.push(info.rim_info.target_revision) if !branches.include?(info.rim_info.target_revision)
+      else
+        dest_parent_sha1 = info.dest_sha1
+        break
+      end
+    end
+    dest_parent_sha1 = get_riminfo_for_revision(src_session, parent_sha1).revision_sha1 if !dest_parent_sha1
+    dest_parent_sha1 = infos.first.rim_info.revision_sha1 if !dest_parent_sha1 && !infos.empty?
+    return Struct.new(:branches, :parent_sha1, :rev_infos).new(branches, dest_parent_sha1, infos)      
+  end
+  
+  RevisionInfo = Struct.new(:dest_sha1, :src_sha1, :rim_info, :message)
+
+  # collect infos for a revision
+  def get_revision_info(src_session, dest_session, src_sha1)
+    module_status = StatusBuilder.new.rev_module_status(src_session, src_sha1, @module_info.local_path)
+    rim_info = get_riminfo_for_revision(src_session, src_sha1)
+    dest_sha1 = dest_session.rev_sha1("rim-#{src_sha1}")
+    msg = src_session.execute("git show -s --format=%B #{src_sha1}") 
+    RevisionInfo.new(module_status && module_status.dirty? ? dest_sha1 : rim_info.revision_sha1, src_sha1, rim_info, msg)
+  end
+  
+  # commit changes to session
+  def commit_changes(session, branch, sha1, msg)
+    if session.status.lines.any?
+      # add before commit because the path can be below a not yet added path
+      session.execute("git add --all")
+      msg_file = Tempfile.new('message')
+      begin
+        msg_file << msg
+        msg_file.close
+        session.execute("git commit -F #{msg_file.path}")
+      ensure
+        msg_file.close(true)
+      end
+      # create tag
+      session.execute("git tag rim-#{sha1} refs/heads/#{branch}")
+    end
+  end
+
+  # get target revision for this module for workspace revision
+  def get_riminfo_for_revision(session, sha1)
+    session.execute("git show #{sha1}:#{File.join(@module_info.local_path, RimInfo::InfoFileName)}") do |out, e|
+      return RimInfo.from_s(!e ? out : "")
+    end
+  end 
+  
+  # create update branch for given revision
+  def create_update_branch(session, dest_sha1, src_sha1)
+    branch = "rim/#{src_sha1}" 
+    session.execute("git checkout -B #{branch} #{dest_sha1}")
+    branch
+  end
+
+  # copy files from given source revision into destination dir
+  def copy_revision_files(src_session, src_sha1, dest_dir, ignores)
+    Dir.mktmpdir do |tmp_dir|
+      src_session.execute("git archive --format tar #{src_sha1} #{@module_info.local_path} | tar -x -C #{tmp_dir}")
+      tmp_module_dir = File.join(tmp_dir, @module_info.local_path)
+      files = FileHelper.find_matching_files(tmp_module_dir, false, "/**/*", File::FNM_DOTMATCH)
+      files.delete(".")
+      files.delete("..")
+      files.delete(RimInfo::InfoFileName)
+      files -= FileHelper.find_matching_files(tmp_module_dir, false, ignores)
+      # have source files now. Now clear destination folder and copy
+      prepare_empty_folder(dest_dir, ".git/**/*")
+      files.each do |f|
+        src_path = File.join(tmp_module_dir, f)
+        if File.file?(src_path)
+          path = File.join(dest_dir, f)
+          FileUtils.mkdir_p(File.dirname(path))
+          FileUtils.cp(src_path, path)
+        end        
+      end
+    end 
+  end 
+
+end
+
+end