git-multirepo 1.0.0.beta45 → 1.0.0.beta46

data/lib/multirepo/commands/branch-command.rb

@@ -1,82 +1,82 @@
-require "multirepo/utility/console"
-require "multirepo/git/git"
-require "multirepo/files/config-file"
-require "multirepo/files/tracking-files"
-require "multirepo/logic/performer"
-
-module MultiRepo
-  class BranchCommand < Command
-    self.command = "branch"
-    self.summary = "Create and/or checkout a new branch for all repos."
-    
-    def self.options
-      [
-        ['<branch name>', 'The name of the branch to create and checkout.'],
-        ['[--force]', 'Force creating the branch even if the repos contain uncommmitted changes.'],
-        ['[--no-push]', 'Do not push the branch on creation.']
-      ].concat(super)
-    end
-    
-    def initialize(argv)
-      @branch_name = argv.shift_argument
-      @force = argv.flag?("force")
-      @remote_tracking = argv.flag?("push", true)
-      super
-    end
-    
-    def validate!
-      super
-      help! "You must specify a branch name" unless @branch_name
-      help! "Please provide a valid branch name" unless Git.valid_branch_name?(@branch_name)
-    end
-    
-    def run
-      ensure_in_work_tree
-      ensure_multirepo_enabled
-      
-      Console.log_step("Branching...")
-      
-      main_repo = Repo.new(".")
-      
-      # Ensure the main repo is clean
-      raise MultiRepoException, "Main repo is not clean; multi branch aborted" unless main_repo.clean?
-      
-      # Ensure dependencies are clean
-      config_entries = ConfigFile.new(".").load_entries
-      unless Utils.dependencies_clean?(config_entries)
-        raise MultiRepoException, "Dependencies are not clean; multi branch aborted"
-      end
-      
-      # Branch dependencies
-      Performer.dependencies.each do |dependency|
-        perform_branch(dependency.config_entry.repo)
-      end
-      
-      # Branch the main repo
-      perform_branch(main_repo)
-      
-      Console.log_step("Done!")
-    end
-    
-    def perform_branch(repo)
-      Console.log_substep("Branching '#{repo.path}' ...")
-      Console.log_info("Creating and checking out branch #{@branch_name} ...")
-      
-      branch = repo.branch(@branch_name)
-      branch.create unless branch.exists?
-      branch.checkout
-      
-      if Utils.is_multirepo_enabled(repo.path)
-        Console.log_info("Updating and committing tracking files")
-        tracking_files = TrackingFiles.new(repo.path)
-        tracking_files.update
-        tracking_files.commit("[multirepo] Post-branch tracking files update")
-      end
-      
-      if @remote_tracking
-        Console.log_info("Pushing #{@branch_name} to origin/#{@branch_name}")
-        repo.branch(@branch_name).push
-      end
-    end
-  end
+require "multirepo/utility/console"
+require "multirepo/git/git"
+require "multirepo/files/config-file"
+require "multirepo/files/tracking-files"
+require "multirepo/logic/performer"
+
+module MultiRepo
+  class BranchCommand < Command
+    self.command = "branch"
+    self.summary = "Create and/or checkout a new branch for all repos."
+    
+    def self.options
+      [
+        ['<branch name>', 'The name of the branch to create and checkout.'],
+        ['[--force]', 'Force creating the branch even if the repos contain uncommmitted changes.'],
+        ['[--no-push]', 'Do not push the branch on creation.']
+      ].concat(super)
+    end
+    
+    def initialize(argv)
+      @branch_name = argv.shift_argument
+      @force = argv.flag?("force")
+      @remote_tracking = argv.flag?("push", true)
+      super
+    end
+    
+    def validate!
+      super
+      help! "You must specify a branch name" unless @branch_name
+      help! "Please provide a valid branch name" unless Git.valid_branch_name?(@branch_name)
+    end
+    
+    def run
+      ensure_in_work_tree
+      ensure_multirepo_enabled
+      
+      Console.log_step("Branching...")
+      
+      main_repo = Repo.new(".")
+      
+      # Ensure the main repo is clean
+      raise MultiRepoException, "Main repo is not clean; multi branch aborted" unless main_repo.clean?
+      
+      # Ensure dependencies are clean
+      config_entries = ConfigFile.new(".").load_entries
+      unless Utils.dependencies_clean?(config_entries)
+        raise MultiRepoException, "Dependencies are not clean; multi branch aborted"
+      end
+      
+      # Branch dependencies
+      Performer.dependencies.each do |dependency|
+        perform_branch(dependency.config_entry.repo)
+      end
+      
+      # Branch the main repo
+      perform_branch(main_repo)
+      
+      Console.log_step("Done!")
+    end
+    
+    def perform_branch(repo)
+      Console.log_substep("Branching '#{repo.path}' ...")
+      Console.log_info("Creating and checking out branch #{@branch_name} ...")
+      
+      branch = repo.branch(@branch_name)
+      branch.create unless branch.exists?
+      branch.checkout
+      
+      if Utils.is_multirepo_enabled(repo.path)
+        Console.log_info("Updating and committing tracking files")
+        tracking_files = TrackingFiles.new(repo.path)
+        tracking_files.update
+        tracking_files.commit("[multirepo] Post-branch tracking files update")
+      end
+      
+      if @remote_tracking
+        Console.log_info("Pushing #{@branch_name} to origin/#{@branch_name}")
+        repo.branch(@branch_name).push
+      end
+    end
+  end
 end

data/lib/multirepo/commands/checkout-command.rb

@@ -1,120 +1,120 @@
-require "multirepo/utility/console"
-require "multirepo/logic/revision-selector"
-require "multirepo/logic/performer"
-
-module MultiRepo
-  class CheckoutCommand < Command
-    self.command = "checkout"
-    self.summary = "Checks out the specified commit or branch of the main repo and checks out matching versions of all dependencies."
-    
-    def self.options
-      [
-        ['<refname>', 'The main repo tag, branch or commit id to checkout.'],
-        ['[--latest]', 'Checkout the HEAD of each dependency branch (as recorded in the lock file) instead of the exact required commits.'],
-        ['[--exact]', 'Checkout the exact specified ref for each repo, regardless of what\'s stored in the lock file.']
-      ].concat(super)
-    end
-    
-    def initialize(argv)
-      @ref_name = argv.shift_argument
-      @checkout_latest = argv.flag?("latest")
-      @checkout_exact = argv.flag?("exact")
-      super
-    end
-    
-    def validate!
-      super
-      help! "You must specify a branch or commit id to checkout" unless @ref_name
-      unless validate_only_one_flag(@checkout_latest, @checkout_exact)
-        help! "You can't provide more than one operation modifier (--latest, --exact, etc.)"
-      end
-    end
-    
-    def run
-      ensure_in_work_tree
-      
-      # Find out the checkout mode based on command-line options
-      mode = RevisionSelector.mode_for_args(@checkout_latest, @checkout_exact)
-      
-      strategy_name = RevisionSelectionMode.name_for_mode(mode)
-      Console.log_step("Checking out #{@ref_name} and its dependencies using the '#{strategy_name}' strategy...")
-      
-      main_repo = Repo.new(".")
-      
-      unless proceed_if_merge_commit?(main_repo, @ref_name, mode)
-        raise MultiRepoException, "Aborting checkout"
-      end
-      
-      checkout_core(main_repo, mode)
-            
-      Console.log_step("Done!")
-    end
-    
-    def checkout_core(main_repo, mode)
-      initial_revision = main_repo.current_revision
-      begin
-        # Checkout first because the current ref might not be multirepo-enabled
-        checkout_main_repo_step(main_repo)
-        # Only then can we check for dependencies and make sure they are clean
-        ensure_dependencies_clean_step(main_repo)
-      rescue MultiRepoException => e
-        Console.log_warning("Restoring working copy to #{initial_revision}")
-        main_repo.checkout(initial_revision)
-        raise e
-      end
-      dependencies_checkout_step(mode, @ref_name)
-    end
-    
-    def checkout_main_repo_step(main_repo)
-      Performer.perform_main_repo_checkout(main_repo, @ref_name)
-    end
-    
-    def ensure_dependencies_clean_step(main_repo)
-      unless Utils.dependencies_clean?(ConfigFile.new(".").load_entries)
-        raise MultiRepoException, "Dependencies are not clean!"
-      end
-    end
-    
-    def dependencies_checkout_step(mode, ref_name = nil)
-      Performer.dependencies.each do |dependency|
-        # Find out the required dependency revision based on the checkout mode
-        revision = RevisionSelector.revision_for_mode(mode, ref_name, dependency.lock_entry)
-        perform_dependency_checkout(dependency.config_entry, revision)
-      end
-    end
-    
-    def proceed_if_merge_commit?(main_repo, ref_name, mode)
-      return true unless main_repo.ref(ref_name).is_merge?
-      
-      case mode
-      when RevisionSelectionMode::AS_LOCK
-        Console.log_error("The specified ref is a merge commit and an \"as-lock\" checkout was requested.")
-        Console.log_error("The resulting checkout would most probably not result in a valid project state.")
-        return false
-      when RevisionSelectionMode::LATEST
-        Console.log_warning("The specified ref is a merge commit and a \"latest\" checkout was requested.")
-        Console.log_warning("The work branches recorded in the branch from which the merge was performed will be checked out.")
-      end
-      
-      return true
-    end
-    
-    def perform_dependency_checkout(config_entry, revision)
-      dependency_name = config_entry.repo.basename
-      
-      # Make sure the repo exists on disk, and clone it if it doesn't
-      # (in case the checked-out revision had an additional dependency)
-      unless config_entry.repo.exists?
-        Console.log_substep("Cloning missing dependency '#{config_entry.path}' from #{config_entry.url}")
-        config_entry.repo.clone(config_entry.url)
-      end
-      
-      # Checkout!
-      if config_entry.repo.checkout(revision)
-        Console.log_substep("Checked out #{dependency_name} '#{revision}'")
-      else
-        raise MultiRepoException, "Couldn't check out the appropriate version of dependency #{dependency_name}"
-      end
-    end
-  end
+require "multirepo/utility/console"
+require "multirepo/logic/revision-selector"
+require "multirepo/logic/performer"
+
+module MultiRepo
+  class CheckoutCommand < Command
+    self.command = "checkout"
+    self.summary = "Checks out the specified commit or branch of the main repo and checks out matching versions of all dependencies."
+    
+    def self.options
+      [
+        ['<refname>', 'The main repo tag, branch or commit id to checkout.'],
+        ['[--latest]', 'Checkout the HEAD of each dependency branch (as recorded in the lock file) instead of the exact required commits.'],
+        ['[--exact]', 'Checkout the exact specified ref for each repo, regardless of what\'s stored in the lock file.']
+      ].concat(super)
+    end
+    
+    def initialize(argv)
+      @ref_name = argv.shift_argument
+      @checkout_latest = argv.flag?("latest")
+      @checkout_exact = argv.flag?("exact")
+      super
+    end
+    
+    def validate!
+      super
+      help! "You must specify a branch or commit id to checkout" unless @ref_name
+      unless validate_only_one_flag(@checkout_latest, @checkout_exact)
+        help! "You can't provide more than one operation modifier (--latest, --exact, etc.)"
+      end
+    end
+    
+    def run
+      ensure_in_work_tree
+      
+      # Find out the checkout mode based on command-line options
+      mode = RevisionSelector.mode_for_args(@checkout_latest, @checkout_exact)
+      
+      strategy_name = RevisionSelectionMode.name_for_mode(mode)
+      Console.log_step("Checking out #{@ref_name} and its dependencies using the '#{strategy_name}' strategy...")
+      
+      main_repo = Repo.new(".")
+      
+      unless proceed_if_merge_commit?(main_repo, @ref_name, mode)
+        raise MultiRepoException, "Aborting checkout"
+      end
+      
+      checkout_core(main_repo, mode)
+            
+      Console.log_step("Done!")
+    end
+    
+    def checkout_core(main_repo, mode)
+      initial_revision = main_repo.current_revision
+      begin
+        # Checkout first because the current ref might not be multirepo-enabled
+        checkout_main_repo_step(main_repo)
+        # Only then can we check for dependencies and make sure they are clean
+        ensure_dependencies_clean_step(main_repo)
+      rescue MultiRepoException => e
+        Console.log_warning("Restoring working copy to #{initial_revision}")
+        main_repo.checkout(initial_revision)
+        raise e
+      end
+      dependencies_checkout_step(mode, @ref_name)
+    end
+    
+    def checkout_main_repo_step(main_repo)
+      Performer.perform_main_repo_checkout(main_repo, @ref_name)
+    end
+    
+    def ensure_dependencies_clean_step(main_repo)
+      unless Utils.dependencies_clean?(ConfigFile.new(".").load_entries)
+        raise MultiRepoException, "Dependencies are not clean!"
+      end
+    end
+    
+    def dependencies_checkout_step(mode, ref_name = nil)
+      Performer.dependencies.each do |dependency|
+        # Find out the required dependency revision based on the checkout mode
+        revision = RevisionSelector.revision_for_mode(mode, ref_name, dependency.lock_entry)
+        perform_dependency_checkout(dependency.config_entry, revision)
+      end
+    end
+    
+    def proceed_if_merge_commit?(main_repo, ref_name, mode)
+      return true unless main_repo.ref(ref_name).is_merge?
+      
+      case mode
+      when RevisionSelectionMode::AS_LOCK
+        Console.log_error("The specified ref is a merge commit and an \"as-lock\" checkout was requested.")
+        Console.log_error("The resulting checkout would most probably not result in a valid project state.")
+        return false
+      when RevisionSelectionMode::LATEST
+        Console.log_warning("The specified ref is a merge commit and a \"latest\" checkout was requested.")
+        Console.log_warning("The work branches recorded in the branch from which the merge was performed will be checked out.")
+      end
+      
+      return true
+    end
+    
+    def perform_dependency_checkout(config_entry, revision)
+      dependency_name = config_entry.repo.basename
+      
+      # Make sure the repo exists on disk, and clone it if it doesn't
+      # (in case the checked-out revision had an additional dependency)
+      unless config_entry.repo.exists?
+        Console.log_substep("Cloning missing dependency '#{config_entry.path}' from #{config_entry.url}")
+        config_entry.repo.clone(config_entry.url)
+      end
+      
+      # Checkout!
+      if config_entry.repo.checkout(revision)
+        Console.log_substep("Checked out #{dependency_name} '#{revision}'")
+      else
+        raise MultiRepoException, "Couldn't check out the appropriate version of dependency #{dependency_name}"
+      end
+    end
+  end
 end

data/lib/multirepo/commands/clone-command.rb

@@ -1,68 +1,68 @@
-require "multirepo/utility/console"
-require "multirepo/utility/utils"
-require "multirepo/git/repo"
-require_relative "install-command"
-
-module MultiRepo
-  class CloneCommand < Command
-    self.command = "clone"
-    self.summary = "Clones the specified repository in a subfolder, then installs it."
-    
-    def self.options
-      [
-        ['<url>', 'The repository to clone.'],
-        ['<name>', 'The name of the containing folder that will be created.'],
-        ['[<refname>]', 'The branch, tag or commit id to checkout. Checkout will use "master" if unspecified.']
-      ].concat(super)
-    end
-    
-    def initialize(argv)
-      @url = argv.shift_argument
-      @name = argv.shift_argument
-      @ref_name = argv.shift_argument || "master"
-      super
-    end
-
-    def validate!
-      super
-      help! "You must specify a repository to clone" unless @url
-      help! "You must specify a containing folder name" unless @name
-    end
-
-    def run
-      Console.log_step("Cloning #{@url} ...")
-
-      raise MultiRepoException, "A directory named #{@name} already exists" if Dir.exists?(@name)
-
-      main_repo_path = "#{@name}/#{@name}"
-      main_repo = Repo.new(main_repo_path)
-      
-      # Recursively create the directory where we'll clone the main repo
-      FileUtils.mkpath(main_repo_path)
-      
-      # Clone the specified remote in the just-created directory
-      raise MultiRepoException, "Could not clone repo from #{@url}" unless main_repo.clone(@url)
-      
-      # Checkout the specified main repo ref so that install reads the proper config file
-      unless main_repo.checkout(@ref_name)
-        raise MultiRepoException, "Couldn't perform checkout of main repo #{@ref_name}!"
-      end
-      
-      Console.log_substep("Checked out main repo #{@ref_name}")
-      
-      # Make sure the ref we just checked out is tracked by multirepo
-      unless Utils.is_multirepo_tracked(main_repo_path)
-        raise MultiRepoException, "Ref #{@ref_name} is not tracked by multirepo"
-      end
-      
-      # Install
-      original_path = Dir.pwd
-      Dir.chdir(main_repo_path)
-      install_command = InstallCommand.new(CLAide::ARGV.new([]))
-      install_command.full_install
-      Dir.chdir(original_path)
-      
-      Console.log_step("Done!")
-    end
-  end
+require "multirepo/utility/console"
+require "multirepo/utility/utils"
+require "multirepo/git/repo"
+require_relative "install-command"
+
+module MultiRepo
+  class CloneCommand < Command
+    self.command = "clone"
+    self.summary = "Clones the specified repository in a subfolder, then installs it."
+    
+    def self.options
+      [
+        ['<url>', 'The repository to clone.'],
+        ['<name>', 'The name of the containing folder that will be created.'],
+        ['[<refname>]', 'The branch, tag or commit id to checkout. Checkout will use "master" if unspecified.']
+      ].concat(super)
+    end
+    
+    def initialize(argv)
+      @url = argv.shift_argument
+      @name = argv.shift_argument
+      @ref_name = argv.shift_argument || "master"
+      super
+    end
+
+    def validate!
+      super
+      help! "You must specify a repository to clone" unless @url
+      help! "You must specify a containing folder name" unless @name
+    end
+
+    def run
+      Console.log_step("Cloning #{@url} ...")
+
+      raise MultiRepoException, "A directory named #{@name} already exists" if Dir.exists?(@name)
+
+      main_repo_path = "#{@name}/#{@name}"
+      main_repo = Repo.new(main_repo_path)
+      
+      # Recursively create the directory where we'll clone the main repo
+      FileUtils.mkpath(main_repo_path)
+      
+      # Clone the specified remote in the just-created directory
+      raise MultiRepoException, "Could not clone repo from #{@url}" unless main_repo.clone(@url)
+      
+      # Checkout the specified main repo ref so that install reads the proper config file
+      unless main_repo.checkout(@ref_name)
+        raise MultiRepoException, "Couldn't perform checkout of main repo #{@ref_name}!"
+      end
+      
+      Console.log_substep("Checked out main repo #{@ref_name}")
+      
+      # Make sure the ref we just checked out is tracked by multirepo
+      unless Utils.is_multirepo_tracked(main_repo_path)
+        raise MultiRepoException, "Ref #{@ref_name} is not tracked by multirepo"
+      end
+      
+      # Install
+      original_path = Dir.pwd
+      Dir.chdir(main_repo_path)
+      install_command = InstallCommand.new(CLAide::ARGV.new([]))
+      install_command.full_install
+      Dir.chdir(original_path)
+      
+      Console.log_step("Done!")
+    end
+  end
 end