git-multirepo 1.0.0.beta19 → 1.0.0.beta20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0f47b8911b32d25d5daa1fe087296860ff278b04
-  data.tar.gz: 2a9aea7aadbfa5e2ba7ebd20f41048eae806180a
+  metadata.gz: 292c05d1335e888a82eeaea12ca7170378669a90
+  data.tar.gz: d8c27f7671954a3aeab46ddb9ad55461dfbac529
 SHA512:
-  metadata.gz: dc2f4849e897410cda0164e1d3e14dbaf1c821a3777f599e6569c24e43492a1dca53f6260ea5623d64a8f1b561b868db940d17b26650b51eb4b7a16cb244f692
-  data.tar.gz: b8d457f08acceb627267ac30d6c33efa454989457d7e69d337735016a1619d050684c2dc448afe367a5dfee13083b41a147bbafd2fb9c01272f30b1b6faf4a6d
+  metadata.gz: 088543b1a14197625ed68c3aed17bbd8a6b959f638cad894da37f94bca89896249c8152914b9a265727aaf3daee0761a986d213826591ff41ea91ac35e74af59
+  data.tar.gz: d98eb47bc0c08028b255f4f229981d2d2608c2ddfc96710706249e4198a7470e17d4c3415f8b906ed987e500630878ccccadab5070e28c34b642f2d9413dc12d

data/README.md

@@ -1,6 +1,8 @@
 # git-multirepo
 
 [![Gem Version](https://badge.fury.io/rb/git-multirepo.svg)](http://badge.fury.io/rb/git-multirepo)
+[![Code Climate](https://codeclimate.com/github/fortinmike/git-multirepo/badges/gpa.svg)](https://codeclimate.com/github/fortinmike/git-multirepo)
+[![License](http://img.shields.io/:license-mit-blue.svg)](https://github.com/fortinmike/git-multirepo/blob/master/LICENSE)
 
 Track multiple Git repositories side-by-side.
 
@@ -64,9 +66,9 @@ Say you want to track an existing project with git-multirepo:
 2. `cd` into the *AwesomeApp* directory (aka the "main repo").
 3. Run `multi init`.
 4. You will get prompted to add *Dependency1* and *Dependency2* to multirepo; do so.
-5. git-multirepo reads all required information from dependency repos and initializes itself, storing its metadata files in the main repo, under version control.
+5. git-multirepo reads all required information from dependency repos and initializes itself, storing its metadata in the main repo, under version control.
 
-From now on, each time you commit the main repo git-multirepo tracks — using a pre-commit hook — which revision of each dependency is required for that main repo revision, and where to get them. The pre-commit hook also ensures that you won't commit the main repo before its dependencies so that you always get a valid state stored under version control.
+From now on, each time you commit the main repo git-multirepo tracks — using local git hooks — which revision of each dependency is required for that main repo revision, and where to get them. The hooks also ensure that you won't commit the main repo before its dependencies so that you always get a valid state stored under version control.
 
 If you want to add another dependency later on, you can run `multi add ../NewDependency` and you can do the opposite with `multi remove ../SomeOtherDependency`.
 
@@ -78,13 +80,14 @@ If you want to stop using git-multirepo, run `multi uninit`. This will remove al
 
 ## Advantages
 
-- Makes setting up the project on a new machine a breeze.
-- Works really well for multiple projects that share a common set of constantly evolving dependencies.
+- Makes setting up a project on a new machine a breeze.
+- Really effective when working on multiple projects that share a common set of constantly evolving dependencies.
 - Each dependency's repository is totally independent from the main repository, which simplifies a lot of things (merges, contributing upstream, etc.) and works well with git GUIs.
 - While the repositories are independent, git-multirepo makes sure to track everything that's required to bring back a previous version of your project in a valid state.
+- It supports sub-dependencies (e.g. dependencies that have dependencies of their own) so that you can bring back any subset of your project in a valid state at will.
 - Much more approachable to novice developers than submodules or subtrees.
 - Once setup, there is little need for git-multirepo commands, so you are free to use whatever tools you like to work with your git repos.
-- Low possibility of human error (such as forgetting to contribute dependency changes back to the appropriate remotes, forgetting to commit dependencies before committing the main project, etc.)
+- Low possibility of human error (such as forgetting to contribute changes to dependencies back to the appropriate remotes, forgetting to commit dependencies in the proper order, etc.)
 - You're not stuck with git-multirepo. It stores its metadata as [YAML](http://www.yaml.org) in the main repo. You can clone and checkout appropriate revisions of your dependencies by hand without git-multirepo if you need to. The information is there, in human-readable form.
 
 | How It Handles... | git-multirepo | git submodules | git subtrees |
@@ -100,8 +103,8 @@ If you want to stop using git-multirepo, run `multi uninit`. This will remove al
 
 ## Limitations
 
-- git-multirepo should be considered beta at the moment. All of the core features work as described, though. Suggestions and contributions are welcome.
-- The project and its dependencies must live beside each other on disk (for now).
+- git-multirepo should be considered beta at the moment. Suggestions and contributions are welcome.
+- The project and its dependencies must live beside each other on disk.
 - Some more commands need to be implemented to facilitate branch-heavy workflows.
 - You must (ideally) install the tool on your CI server: `gem install git-multirepo`
 
@@ -116,7 +119,6 @@ Here is a quick rundown of commands available to you in git-multirepo:
 | branch | Create and/or checkout a new branch for all repos. |
 | checkout | Checks out the specified commit or branch of the main repo and checks out matching versions of all dependencies. |
 | clone | Clones the specified repository in a subfolder, then installs it. |
-| edit | Opens the .multirepo file in the default text editor. |
 | fetch | Performs a git fetch on all dependencies. |
 | install | Clones and checks out dependencies as defined in the version-controlled multirepo metadata files and installs git-multirepo's local git hooks. |
 | open | Opens all dependencies in the current OS's file explorer. |

data/bin/multi

@@ -3,4 +3,9 @@
 require "claide"
 require "commands"
 
+trap("INT") do
+  puts "\rAbort, abort!!" # \r hides the interrupt control characters
+  exit
+end
+
 MultiRepo::Command.run(ARGV)

data/lib/commands.rb

@@ -3,7 +3,6 @@ require_relative "multirepo/commands/add-command"
 require_relative "multirepo/commands/branch-command"
 require_relative "multirepo/commands/checkout-command"
 require_relative "multirepo/commands/clone-command"
-require_relative "multirepo/commands/edit-command"
 require_relative "multirepo/commands/fetch-command"
 require_relative "multirepo/commands/init-command"
 require_relative "multirepo/commands/install-command"

data/lib/info.rb

@@ -1,5 +1,5 @@
 module MultiRepo
   NAME = "git-multirepo"
-  VERSION = "1.0.0.beta19"
+  VERSION = "1.0.0.beta20"
   DESCRIPTION = "Track multiple Git repositories side-by-side."
 end

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

@@ -47,61 +47,73 @@ module MultiRepo
         CheckoutMode::AS_LOCK
       end
       
-      checkout_core(@ref, mode)
+      main_repo = Repo.new(".")
+      initial_revision = main_repo.current_branch || main_repo.head_hash
+      
+      main_repo_checkout_step(main_repo, initial_revision, @ref)
+      ensure_dependencies_clean_step(initial_revision)
+      dependencies_checkout_step(mode, @ref)
       
       Console.log_step("Done!")
     rescue MultiRepoException => e
       Console.log_error(e.message)
     end
-    
-    def checkout_core(ref, mode)
-      main_repo = Repo.new(".")
-      initial_revision = main_repo.current_branch || main_repo.head_hash
-      
+            
+    def main_repo_checkout_step(main_repo, initial_revision, ref)
+      # Make sure the main repo is clean before attempting a checkout
       unless main_repo.is_clean?
         raise MultiRepoException, "Can't checkout #{ref} because the main repo contains uncommitted changes"
       end
       
+      # Checkout the specified ref
       unless main_repo.checkout(ref)
         raise MultiRepoException, "Couldn't perform checkout of main repo #{ref}!"
       end
       
       Console.log_substep("Checked out main repo #{ref}")
       
-      unless LockFile.exists?
+      # After checkout, make sure we're working with a multirepo-enabled ref
+      unless Utils.is_multirepo_enabled(".")
         main_repo.checkout(initial_revision)
-        raise MultiRepoException, "The specified revision was not managed by multirepo. Checkout reverted."
+        raise MultiRepoException, "This revision is not managed by multirepo. Checkout reverted."
       end
-      
+    end
+    
+    def ensure_dependencies_clean_step(initial_revision)
       unless Utils.ensure_dependencies_clean(ConfigFile.load)
         main_repo.checkout(initial_revision)
-        raise MultiRepoException, "'#{e.path}' contains uncommitted changes. Checkout reverted."
+        raise MultiRepoException, "Checkout reverted."
       end
+    end
+    
+    def dependencies_checkout_step(mode, ref = nil)
+      config_entries = ConfigFile.load # Post-main-repo checkout config entries might be different than pre-checkout
+      LockFile.load.each { |lock_entry| perform_dependency_checkout(config_entries, lock_entry, ref, mode) }
+    end
+    
+    def perform_dependency_checkout(config_entries, lock_entry, ref, mode)
+      # Find the config entry that matches the given lock entry
+      config_entry = config_entries.select{ |config_entry| config_entry.id == lock_entry.id }.first
       
-      config_entries = ConfigFile.load # Load the post-checkout config entries, which might be different than pre-checkout
-      LockFile.load.each do |lock_entry|
-        config_entry = config_entries.select{ |config_entry| config_entry.id == lock_entry.id }.first
-        
-        # First, 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
-        
-        # Find out the proper revision to checkout based on the checkout mode
-        revision = case mode
-        when CheckoutMode::AS_LOCK; lock_entry.head
-        when CheckoutMode::LATEST; lock_entry.branch
-        when CheckoutMode::EXACT; ref
-        end
-        
-        # Checkout!
-        if config_entry.repo.checkout(revision)
-          Console.log_substep("Checked out #{lock_entry.name} #{revision}")
-        else
-          raise MultiRepoException, "Couldn't check out the appropriate version of dependency #{lock_entry.name}"
-        end
+      # 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
+      
+      # Find out the proper revision to checkout based on the checkout mode
+      revision = case mode
+      when CheckoutMode::AS_LOCK; lock_entry.head
+      when CheckoutMode::LATEST; lock_entry.branch
+      when CheckoutMode::EXACT; ref
+      end
+      
+      # Checkout!
+      if config_entry.repo.checkout(revision)
+        Console.log_substep("Checked out #{lock_entry.name} #{revision}")
+      else
+        raise MultiRepoException, "Couldn't check out the appropriate version of dependency #{lock_entry.name}"
       end
     end
   end

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

@@ -19,7 +19,7 @@ module MultiRepo
     def initialize(argv)
       @url = argv.shift_argument
       @name = argv.shift_argument
-      @ref = argv.shift_argument
+      @ref = argv.shift_argument || "master"
       super
     end
 
@@ -35,20 +35,33 @@ module MultiRepo
       raise MultiRepoException, "A directory named #{@name} already exists" if Dir.exists?(@name)
 
       main_repo_path = "#{@name}/#{@name}"
-
-      FileUtils.mkpath(main_repo_path)
-
       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)
+        raise MultiRepoException, "Couldn't perform checkout of main repo #{@ref}!"
+      end
+      
+      Console.log_substep("Checked out main repo #{@ref}")
+      
+      # Make sure the ref we just checked out is multirepo-enabled
+      unless Utils.is_multirepo_enabled(main_repo_path)
+        raise MultiRepoException, "Ref #{@ref} is not multirepo-enabled"
+      end
+      
+      # Install
       original_path = Dir.pwd
       Dir.chdir(main_repo_path)
-      
       install_command = InstallCommand.new(CLAide::ARGV.new([]))
-      install_command.install_core(@ref)
-      
+      install_command.install_dependencies_step
       Dir.chdir(original_path)
-            
+      
       Console.log_step("Done!")
     rescue MultiRepoException => e
       Console.log_error(e.message)

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

@@ -9,11 +9,11 @@ module MultiRepo
     self.summary = "Clones and checks out dependencies as defined in the version-controlled multirepo metadata files and installs git-multirepo's local git hooks."
     
     def self.options
-      [['[ref]', 'The branch, tag or commit id to checkout. Checkout will use "master" if unspecified.']].concat(super)
+      [['-hooks', 'Only install local git hooks.']].concat(super)
     end
     
     def initialize(argv)
-      @ref = argv.shift_argument
+      @hooks = argv.flag?("hooks")
       super
     end
         
@@ -21,27 +21,35 @@ module MultiRepo
       validate_in_work_tree
       ensure_multirepo_initialized
       
-      Console.log_step("Cloning dependencies and installing hook...")
-      
-      install_core(@ref)
+      if @hooks
+        Console.log_step("Installing hooks in main repo and all dependencies...")
+        install_hooks_step
+      else
+        Console.log_step("Cloning dependencies and installing hooks...")
+        install_dependencies_step
+      end
       
       Console.log_step("Done!")
     rescue MultiRepoException => e
       Console.log_error(e.message)
     end
     
-    def install_core(ref)
+    def install_dependencies_step
+      # Read config entries as-is on disk, without prior checkout
       config_entries = ConfigFile.load
-
       Console.log_substep("Installing #{config_entries.count} dependencies...");
       
-      # Clone or fetch all configured dependencies
+      # Clone or fetch all configured dependencies to make sure nothing is missing locally
       config_entries.each { |entry| clone_or_fetch(entry) }
       
       # Checkout the appropriate branches as specified in the lock file
       checkout_command = CheckoutCommand.new(CLAide::ARGV.new([]))
-      checkout_command.checkout_core(ref || "master", CheckoutCommand::CheckoutMode::LATEST)
+      checkout_command.dependencies_checkout_step(CheckoutCommand::CheckoutMode::LATEST)
       
+      install_hooks_step
+    end
+    
+    def install_hooks_step
       install_hooks
       Console.log_substep("Installed git hooks in main repo")
       
@@ -69,12 +77,6 @@ module MultiRepo
       raise MultiRepoException, "Could not clone remote #{entry.url}" unless entry.repo.clone(entry.url)
     end
     
-    def checkout_branch(entry)
-      branch = entry.repo.branch(entry.branch);
-      raise MultiRepoException, "Could not checkout branch #{branch.name}" unless branch.checkout
-      Console.log_substep("Checked out branch #{branch.name} -> origin/#{branch.name}")
-    end
-    
     # Validation
     
     def check_repo_validity(entry)

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

@@ -24,11 +24,6 @@ module MultiRepo
       
       Console.log_step("Updating...")
       
-      install_hooks
-      Console.log_substep("Installed git hooks in main repo")
-      
-      install_hooks_in_multirepo_enabled_dependencies
-      
       dependencies_clean = Utils.ensure_dependencies_clean(ConfigFile.load)
       if dependencies_clean
         LockFile.update

data/lib/multirepo/utility/utils.rb

@@ -8,7 +8,8 @@ module MultiRepo
     end
     
     def self.is_multirepo_enabled(path)
-      File.exists?(File.join(path, ".multirepo"))
+      File.exists?(File.join(path, ".multirepo")) &&
+      File.exists?(File.join(path, ".multirepo.lock"))
     end
     
     def self.install_hook(name, path)
@@ -22,21 +23,25 @@ module MultiRepo
     end
     
     def self.ensure_dependencies_clean(config_entries)
-      config_entries.all? do |e|
-        next true unless e.repo.exists?
-        clean = e.repo.is_clean?
-        Console.log_info("Dependency '#{e.repo.path}' is clean") if clean
-        Console.log_warning("Dependency '#{e.repo.path}' contains uncommitted changes") unless clean
-        next clean
+      clean = true
+      config_entries.each do |e|
+        next unless e.repo.exists?
+        dependency_clean = e.repo.is_clean?
+        clean &= dependency_clean
+        Console.log_info("Dependency '#{e.repo.path}' is clean") if dependency_clean
+        Console.log_warning("Dependency '#{e.repo.path}' contains uncommitted changes") unless dependency_clean
       end
+      return clean
     end
     
     def self.ensure_working_copies_clean(repos)
-      repos.all? do |repo|
-        clean = repo.is_clean?
-        Console.log_warning("Repo '#{repo.path}' contains uncommitted changes") unless clean
-        next clean
+      clean = true
+      repos.each do |repo|
+        dependency_clean = e.repo.is_clean?
+        clean &= dependency_clean
+        Console.log_warning("Repo '#{repo.path}' contains uncommitted changes") unless dependency_clean
       end
+      return clean
     end
 
     def self.convert_to_windows_path(unix_path)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: git-multirepo
 version: !ruby/object:Gem::Version
-  version: 1.0.0.beta19
+  version: 1.0.0.beta20
 platform: ruby
 authors:
 - Michaël Fortin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-01 00:00:00.000000000 Z
+date: 2015-04-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -127,7 +127,6 @@ files:
 - lib/multirepo/commands/checkout-command.rb
 - lib/multirepo/commands/clone-command.rb
 - lib/multirepo/commands/command.rb
-- lib/multirepo/commands/edit-command.rb
 - lib/multirepo/commands/fetch-command.rb
 - lib/multirepo/commands/init-command.rb
 - lib/multirepo/commands/install-command.rb

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

@@ -1,22 +0,0 @@
-require "os"
-
-module MultiRepo
-  class EditCommand < Command
-    self.command = "edit"
-    self.summary = "Opens the .multirepo file in the default text editor."
-    
-    def run
-      validate_in_work_tree
-      ensure_multirepo_initialized
-      
-      if OS.posix?
-        editor = `echo ${FCEDIT:-${VISUAL:-${EDITOR:-vi}}}`.strip
-        system(editor, ".multirepo")
-      elsif OS.windows?
-        raise MultiRepoException, "The edit command is not implemented on Window yet."
-      end
-    rescue MultiRepoException => e
-      Console.log_error(e.message)
-    end
-  end
-end