git-multirepo 1.0.0.beta40 → 1.0.0.beta42

data/lib/multirepo/hooks/pre-commit-hook.rb

@@ -1,32 +1,35 @@
-require "multirepo/files/config-file"
-require "multirepo/files/tracking-files"
-require "multirepo/utility/utils"
-require "multirepo/utility/console"
-
-module MultiRepo
-  class PreCommitHook
-    def self.run
-      Config.instance.running_git_hook = true
-      
-      Console.log_step("Performing pre-commit operations...")
-      
-      dependencies_clean = Utils.ensure_dependencies_clean(ConfigFile.new(".").load_entries)
-      
-      if !dependencies_clean
-        Console.log_error("You must commit changes to your dependencies before you can commit this repo")
-        exit 1
-      end
-      
-      tracking_files = TrackingFiles.new(".")
-      tracking_files.update
-      tracking_files.stage
-      
-      Console.log_info("Updated and staged tracking files")
-      
-      exit 0 # Success!
-    rescue StandardError => e
-      Console.log_error("Pre-commit hook failed to execute! #{e.message}")
-      exit 1 # Something went wrong!
-    end
-  end
+require "multirepo/files/config-file"
+require "multirepo/files/tracking-files"
+require "multirepo/utility/utils"
+require "multirepo/utility/console"
+
+module MultiRepo
+  class PreCommitHook
+    def self.run
+      Config.instance.running_git_hook = true
+      
+      Console.log_step("Performing pre-commit operations...")
+      
+      dependencies_clean = Utils.dependencies_clean?(ConfigFile.new(".").load_entries)
+      
+      unless dependencies_clean
+        Console.log_error("You must commit changes to your dependencies before you can commit this repo")
+        exit 1
+      end
+      
+      tracking_files = TrackingFiles.new(".")
+      tracking_files.update
+      tracking_files.stage
+      
+      Console.log_info("Updated and staged tracking files")
+      
+      exit 0
+    rescue MultiRepoException => e
+      Console.log_error("Can't perform commit. #{e.message}")
+      exit 1
+    rescue StandardError => e
+      Console.log_error("Pre-commit hook failed to execute! #{e.message}")
+      exit 1
+    end
+  end
 end

data/lib/multirepo/logic/dependency.rb

@@ -0,0 +1,6 @@
+module MultiRepo
+  class Dependency
+    attr_accessor :config_entry
+    attr_accessor :lock_entry
+  end
+end

data/lib/multirepo/logic/merge-descriptor.rb

@@ -1,13 +1,95 @@
-module MultiRepo
-  class MergeDescriptor
-    attr_accessor :name
-    attr_accessor :path
-    attr_accessor :revision
-    
-    def initialize(name, path, revision)
-      @name = name
-      @path = path
-      @revision = revision
-    end
-  end
+require "colored"
+require "multirepo/git/repo"
+
+module MultiRepo
+  class TheirState
+    NON_EXISTENT = 0
+    EXACT_REF = 1
+    LOCAL_NO_UPSTREAM = 2
+    UPSTREAM_NO_LOCAL = 3
+    LOCAL_UP_TO_DATE = 4
+    LOCAL_OUTDATED = 5
+    LOCAL_UPSTREAM_DIVERGED = 6
+  end
+  
+  class MergeDescriptor
+    attr_accessor :name
+    attr_accessor :repo
+    attr_accessor :our_revision
+    attr_accessor :their_revision
+    attr_accessor :state
+
+    def initialize(name, repo, our_revision, their_revision)
+      @name = name
+      @repo = repo
+      @our_revision = our_revision
+      @their_revision = their_revision
+      
+      # Revisions can be anything: "feature1", "origin/feature1", "b51f3c0", ...
+      their_ref = repo.ref(their_revision)
+      
+      @short_commit_id = their_ref.short_commit_id
+      
+      @state = determine_merge_state(repo, their_ref)
+    end
+    
+    def merge_description
+      case @state
+      when TheirState::NON_EXISTENT; "No revision named #{@their_revision}".red
+      else; "Merge '#{@state == TheirState::EXACT_REF ? @short_commit_id : @their_revision}' into '#{@our_revision}'"
+      end
+    end
+
+    def upstream_description
+      case @state
+      when TheirState::NON_EXISTENT; "--"
+      when TheirState::EXACT_REF; "Exact ref".yellow
+      when TheirState::LOCAL_NO_UPSTREAM; "Not remote-tracking".yellow
+      when TheirState::UPSTREAM_NO_LOCAL; "Branch is upstream".green
+      when TheirState::LOCAL_UP_TO_DATE; "Local up-to-date with upstream".green
+      when TheirState::LOCAL_OUTDATED; "Local outdated compared to upstream".yellow
+      when TheirState::LOCAL_UPSTREAM_DIVERGED; "Local and upstream have diverged!".red
+      end
+    end
+    
+    private
+    
+    def determine_merge_state(repo, their_ref)
+      return TheirState::NON_EXISTENT unless their_ref.exists?
+      
+      remote_branch = repo.remote_branches.select{ |b| b.name == their_ref.name }.first
+      local_branch = repo.local_branches.select{ |b| b.name == their_ref.name }.first
+      
+      # If no local branch nor remote branch exist for their_ref, this is an exact ref
+      return TheirState::EXACT_REF unless remote_branch || local_branch
+      
+      # If remote exists but local does not, return UPSTREAM_NO_LOCAL
+      return TheirState::UPSTREAM_NO_LOCAL if remote_branch && !local_branch
+      
+      # If there is no upstream, no need to check for differences between local and remote
+      return TheirState::LOCAL_NO_UPSTREAM unless local_branch.upstream_branch
+      
+      # Else check local vs upstream state
+      return determine_local_upstream_merge_state(repo, their_ref)
+    end
+    
+    def determine_local_upstream_merge_state(repo, their_ref)
+      # We can assume we're working with a branch at this point
+      their_branch = repo.branch(their_ref.name)
+      
+      their_upstream_branch = their_branch.upstream_branch
+      local_as_upstream = their_branch.commit_id == their_upstream_branch.commit_id
+      can_fast_forward_local_to_upstream = their_branch.can_fast_forward_to?(their_upstream_branch)
+      
+      state = if local_as_upstream
+        TheirState::LOCAL_UP_TO_DATE
+      elsif !local_as_upstream && can_fast_forward_local_to_upstream
+        TheirState::LOCAL_OUTDATED
+      else
+        TheirState::LOCAL_UPSTREAM_DIVERGED
+      end
+      
+      return state
+    end
+  end
 end

data/lib/multirepo/logic/node.rb

@@ -1,45 +1,72 @@
-require "multirepo/files/config-file"
-
-module MultiRepo
-  class Node
-    attr_accessor :path
-    attr_accessor :depth
-    
-    def initialize(path, depth = 0)
-      @path = path
-      @depth = depth
-    end
-    
-    def name
-      Pathname.new(File.expand_path(@path)).basename.to_s
-    end
-    
-    def children
-      return [] unless Utils.is_multirepo_enabled(@path)
-      config_entries = ConfigFile.new(@path).load_entries
-      return config_entries.map { |e| Node.new(e.path, @depth + 1) }
-    end
-    
-    def ordered_descendants_including_self
-      return ordered_descendants.push(self)
-    end
-    
-    def ordered_descendants
-      descendants = find_descendants_recursive(self)
-      
-      unique_paths = descendants.map{ |d| d.path }.uniq
-      unique_nodes = unique_paths.collect do |path|
-        nodes_for_path = descendants.select { |d| d.path == path }
-        next nodes_for_path.sort{ |n| n.depth }.first
-      end
-      
-      return unique_nodes.sort_by{ |d| d.depth }.reverse
-    end
-    
-    def find_descendants_recursive(node)
-      descendants = node.children
-      descendants.each { |d| descendants.push(*find_descendants_recursive(d)) }
-      return descendants
-    end
-  end
+require "multirepo/files/config-file"
+
+module MultiRepo
+  class Node
+    attr_accessor :path
+    attr_accessor :depth
+    attr_accessor :parent
+    
+    def initialize(path, parent = nil, depth = 0)
+      @path = path
+      @depth = depth
+      @parent = parent
+    end
+    
+    def name
+      Pathname.new(File.expand_path(@path)).basename.to_s
+    end
+    
+    def children
+      return [] unless Utils.is_multirepo_enabled(@path)
+      config_entries = ConfigFile.new(@path).load_entries
+      return config_entries.map { |e| Node.new(e.path, self, @depth + 1) }
+    end
+    
+    def ordered_descendants_including_self
+      return ordered_descendants.push(self)
+    end
+    
+    def ordered_descendants
+      descendants = find_descendants_recursive(self)
+      
+      unique_paths = descendants.map{ |d| d.path }.uniq
+      unique_nodes = unique_paths.collect do |path|
+        nodes_for_path = descendants.select { |d| d.path == path }
+        next nodes_for_path.sort{ |n| n.depth }.first
+      end
+      
+      return unique_nodes.sort_by{ |d| d.depth }.reverse
+    end
+    
+    def find_descendants_recursive(node)
+      ensure_no_dependency_cycle(node)
+      
+      descendants = node.children
+      descendants.each { |d| descendants.push(*find_descendants_recursive(d)) }
+      return descendants
+    end
+    
+    def ensure_no_dependency_cycle(node)
+      parent = node.parent
+      visited = []
+      while parent
+        visited.push(parent)
+        if parent == node
+          Console.log_warning("Dependency cycle detected:")
+          visited.reverse.each_with_index do |n, i|
+            description = "[first]" if i == visited.count - 1
+            description = "itself" if visited.count == 1
+            Console.log_warning("'#{n.path}' depends on #{description}")
+          end
+          raise MultiRepoException, "Dependency cycles are not supported by multirepo."
+        end
+        parent = parent.parent # Will eventually be nil (root node), which will break out of the loop
+      end
+    end
+    
+    def ==(object)
+      object.class == self.class &&
+      object.path == @path
+    end
+  end
 end

data/lib/multirepo/logic/performer.rb

@@ -1,63 +1,57 @@
-require "ostruct"
-
-require "multirepo/files/config-file"
-require "multirepo/files/lock-file"
-
-module MultiRepo
-  class Performer
-    def self.perform_main_repo_checkout(main_repo, ref)
-      # Make sure the main repo is clean before attempting a checkout
-      unless main_repo.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}")
-      
-      # After checkout, make sure we're working with a multirepo-enabled ref
-      unless Utils.is_multirepo_tracked(".")
-        raise MultiRepoException, "Revision #{ref} is not tracked by multirepo!"
-      end
-    end
-    
-    def self.perform_on_dependencies(&operation)
-      config_entries = ConfigFile.new(".").load_entries
-      lock_entries = LockFile.new(".").load_entries
-      
-      config_lock_pairs = build_config_lock_pairs(config_entries, lock_entries)
-      dependency_ordered_nodes = Node.new(".").ordered_descendants
-      
-      ordered_pairs = dependency_ordered_nodes.map do |node|
-        pair = config_lock_pairs.find { |pair| pair.config_entry.path == node.path }
-      end
-      
-      ordered_pairs.each { |pair| operation.call(pair.config_entry, pair.lock_entry) }
-    end
-    
-    def self.dependencies
-      
-    end
-    
-    private
-    
-    def self.build_config_lock_pairs(config_entries, lock_entries)
-      lock_entries.map do |lock_entry|
-        config_entry = config_entry_for_lock_entry(config_entries, lock_entry)
-        
-        pair = OpenStruct.new
-        pair.config_entry = config_entry
-        pair.lock_entry = lock_entry
-        
-        next pair
-      end
-    end
-    
-    def self.config_entry_for_lock_entry(config_entries, lock_entry)
-      config_entries.find { |config_entry| config_entry.id == lock_entry.id }
-    end
-  end
+require "multirepo/files/config-file"
+require "multirepo/files/lock-file"
+
+require_relative "dependency"
+
+module MultiRepo
+  class Performer
+    def self.perform_main_repo_checkout(main_repo, ref_name, message = nil)
+      # Make sure the main repo is clean before attempting a checkout
+      unless main_repo.clean?
+        raise MultiRepoException, "Can't checkout #{ref_name} because the main repo contains uncommitted changes"
+      end
+      
+      # Checkout the specified ref
+      unless main_repo.checkout(ref_name)
+        raise MultiRepoException, "Couldn't perform checkout of main repo #{ref_name}!"
+      end
+      
+      Console.log_substep(message || "Checked out main repo #{ref_name}")
+      
+      # After checkout, make sure we're working with a multirepo-enabled ref
+      unless Utils.is_multirepo_tracked(".")
+        raise MultiRepoException, "Revision #{ref_name} is not tracked by multirepo!"
+      end
+    end
+    
+    def self.dependencies
+      config_entries = ConfigFile.new(".").load_entries
+      lock_entries = LockFile.new(".").load_entries
+      
+      dependencies = build_dependencies(config_entries, lock_entries)
+      dependency_ordered_nodes = Node.new(".").ordered_descendants
+      
+      return dependency_ordered_nodes.map do |node|
+        pair = dependencies.find { |d| d.config_entry.path == node.path }
+      end
+    end
+    
+    private
+    
+    def self.build_dependencies(config_entries, lock_entries)
+      lock_entries.map do |lock_entry|
+        config_entry = config_entry_for_lock_entry(config_entries, lock_entry)
+        
+        dependency = Dependency.new
+        dependency.config_entry = config_entry
+        dependency.lock_entry = lock_entry
+        
+        next dependency
+      end
+    end
+    
+    def self.config_entry_for_lock_entry(config_entries, lock_entry)
+      config_entries.find { |config_entry| config_entry.id == lock_entry.id }
+    end
+  end
 end

data/lib/multirepo/logic/revision-selector.rb

@@ -1,35 +1,35 @@
-module MultiRepo
-  class RevisionSelectionMode
-    AS_LOCK = 0
-    LATEST = 1
-    EXACT = 2
-    
-    def self.name_for_mode(mode)
-      case mode
-      when AS_LOCK; "as-lock"
-      when LATEST; "latest"
-      when EXACT; "exact"
-      end
-    end
-  end
-  
-  class RevisionSelector
-    def self.mode_for_args(checkout_latest, checkout_exact)
-      if checkout_latest then
-        RevisionSelectionMode::LATEST
-      elsif checkout_exact then
-        RevisionSelectionMode::EXACT
-      else
-        RevisionSelectionMode::AS_LOCK
-      end
-    end
-    
-    def self.revision_for_mode(mode, ref, lock_entry)
-      case mode
-      when RevisionSelectionMode::AS_LOCK; lock_entry.head
-      when RevisionSelectionMode::LATEST; lock_entry.branch
-      when RevisionSelectionMode::EXACT; ref
-      end
-    end
-  end
+module MultiRepo
+  class RevisionSelectionMode
+    AS_LOCK = 0
+    LATEST = 1
+    EXACT = 2
+    
+    def self.name_for_mode(mode)
+      case mode
+      when AS_LOCK; "as-lock"
+      when LATEST; "latest"
+      when EXACT; "exact"
+      end
+    end
+  end
+  
+  class RevisionSelector
+    def self.mode_for_args(checkout_latest, checkout_exact)
+      if checkout_latest then
+        RevisionSelectionMode::LATEST
+      elsif checkout_exact then
+        RevisionSelectionMode::EXACT
+      else
+        RevisionSelectionMode::AS_LOCK
+      end
+    end
+    
+    def self.revision_for_mode(mode, ref_name, lock_entry)
+      case mode
+      when RevisionSelectionMode::AS_LOCK; lock_entry.head
+      when RevisionSelectionMode::LATEST; lock_entry.branch
+      when RevisionSelectionMode::EXACT; ref_name
+      end
+    end
+  end
 end