esr-rim 1.4.0 → 1.4.2

data/lib/rim/sync_helper.rb

@@ -1,150 +1,150 @@
-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, rebase = nil, split = true)
-    # 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
-      changed_modules = 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 = "refs/heads/#{branch}"
-        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}")
-          branch_sha1 = s.rev_sha1(rim_branch)
-        end
-        remote_url = "file://" + @ws_root
-        @logger.debug("Folder for temporary git repositories: #{@rim_path}")
-        tmpdir = clone_or_fetch_repository(remote_url, module_tmp_git_path(".ws"), "Cloning workspace git...")
-        RIM::git_session(tmpdir) do |tmp_session|
-          tmp_session.execute("git reset --hard")
-          tmp_session.execute("git clean -xdf")
-          # use -f here to prevent git checkout from checking for untracked files which might be overwritten. 
-          # this is safe since we removed any untracked files before.
-          # this is a workaround for a name case problem on windows:
-          # if a file's name changes case between the current head and the checkout target,
-          # git checkout will report the file with the new name as untracked and will fail
-          tmp_session.execute("git checkout -B #{rim_branch} -f remotes/origin/#{rim_branch}")
-          changed_modules = sync_modules(tmp_session, message)
-          if !split
-            tmp_session.execute("git reset --soft #{branch_sha1}")
-            commit(tmp_session, message ? message : get_commit_message(changed_modules)) if tmp_session.uncommited_changes?
-          end
-          tmp_session.execute("git push #{remote_url} #{rim_branch}:#{rim_branch}")
-        end
-      end
-      if !changed_modules.empty?
-        if rebase
-          s.execute("git rebase #{rim_branch}")
-          @logger.info("Changes have been commited to branch #{rim_branch} and workspace has been rebased successfully.")
-        else
-          @logger.info("Changes have been commited to branch #{rim_branch}. Rebase to apply changes to workspace.")
-        end
-      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
-    changed_modules = []
-    module_helpers.each do |m|
-      @logger.info("Synchronizing #{m.module_info.local_path}...")
-      if m.sync(message)
-        changed_modules << m.module_info
-      end
-    end
-    changed_modules
-  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  
-
-  #create default commit message from array of changed modules
-  def get_commit_message(changed_modules)
-    StringIO.open do |s|
-      s.puts "rim sync."
-      s.puts
-      changed_modules.each do |m|
-        s.puts m.local_path
-      end
-      s.string
-    end
-  end
-
-end
-
-end
+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, rebase = nil, split = true)
+    # 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
+      changed_modules = 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 = "refs/heads/#{branch}"
+        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}")
+          branch_sha1 = s.rev_sha1(rim_branch)
+        end
+        remote_url = "file://" + @ws_root
+        @logger.debug("Folder for temporary git repositories: #{@rim_path}")
+        tmpdir = clone_or_fetch_repository(remote_url, module_tmp_git_path(".ws"), "Cloning workspace git...")
+        RIM::git_session(tmpdir) do |tmp_session|
+          tmp_session.execute("git reset --hard")
+          tmp_session.execute("git clean -xdf")
+          # use -f here to prevent git checkout from checking for untracked files which might be overwritten. 
+          # this is safe since we removed any untracked files before.
+          # this is a workaround for a name case problem on windows:
+          # if a file's name changes case between the current head and the checkout target,
+          # git checkout will report the file with the new name as untracked and will fail
+          tmp_session.execute("git checkout -B #{rim_branch} -f remotes/origin/#{rim_branch}")
+          changed_modules = sync_modules(tmp_session, message)
+          if !split
+            tmp_session.execute("git reset --soft #{branch_sha1}")
+            commit(tmp_session, message ? message : get_commit_message(changed_modules)) if tmp_session.uncommited_changes?
+          end
+          tmp_session.execute("git push #{remote_url} #{rim_branch}:#{rim_branch}")
+        end
+      end
+      if !changed_modules.empty?
+        if rebase
+          s.execute("git rebase #{rim_branch}")
+          @logger.info("Changes have been commited to branch #{rim_branch} and workspace has been rebased successfully.")
+        else
+          @logger.info("Changes have been commited to branch #{rim_branch}. Rebase to apply changes to workspace.")
+        end
+      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
+    changed_modules = []
+    module_helpers.each do |m|
+      @logger.info("Synchronizing #{m.module_info.local_path}...")
+      if m.sync(message)
+        changed_modules << m.module_info
+      end
+    end
+    changed_modules
+  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  
+
+  #create default commit message from array of changed modules
+  def get_commit_message(changed_modules)
+    StringIO.open do |s|
+      s.puts "rim sync."
+      s.puts
+      changed_modules.each do |m|
+        s.puts m.local_path
+      end
+      s.string
+    end
+  end
+
+end
+
+end

data/lib/rim/sync_module_helper.rb

@@ -1,107 +1,107 @@
-require 'rim/module_helper'
-require 'rim/rim_info'
-require 'rim/file_helper'
-require 'rim/dirty_check'
-require 'tempfile'
-require 'pathname'
-
-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)
-      changes = false
-      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?
-          strip = ""
-          if @module_info.subdir
-              depth = Pathname(@module_info.subdir).each_filename.count()
-              strip = "--strip-components=#{depth}"
-          end
-          s.execute("git archive --format tar #{@module_info.target_revision} #{@module_info.subdir} | tar #{strip} -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.subdir = @module_info.subdir
-          @rim_info.infos = s.rev_infos(@module_info.target_revision, RimInfo.git_infos)
-          @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}")
-        changes = d.uncommited_changes?
-        commit(d, message || "rim sync: module #{@module_info.local_path}") if changes
-      end
-      changes
-    end
-
-    def needs_commit?(session)
-      # do we need to commit something?
-      stat = session.status(@module_info.local_path)
-      # no files should be ignored due to --force option. Anyway we will check for ignored files
-      ignored = []
-      session.execute("git add --all --force #{@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
-      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
+require 'rim/module_helper'
+require 'rim/rim_info'
+require 'rim/file_helper'
+require 'rim/dirty_check'
+require 'tempfile'
+require 'pathname'
+
+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)
+      changes = false
+      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?
+          strip = ""
+          if @module_info.subdir
+              depth = Pathname(@module_info.subdir).each_filename.count()
+              strip = "--strip-components=#{depth}"
+          end
+          s.execute("git archive --format tar #{@module_info.target_revision} #{@module_info.subdir} | tar #{strip} -C #{local_path} -xf -")
+          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.subdir = @module_info.subdir
+          @rim_info.infos = s.rev_infos(@module_info.target_revision, RimInfo.git_infos)
+          @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}")
+        changes = d.uncommited_changes?
+        commit(d, message || "rim sync: module #{@module_info.local_path}") if changes
+      end
+      changes
+    end
+
+    def needs_commit?(session)
+      # do we need to commit something?
+      stat = session.status(@module_info.local_path)
+      # no files should be ignored due to --force option. Anyway we will check for ignored files
+      ignored = []
+      session.execute("git add --all --force #{@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
+      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