mlightner-braid 0.5.1

data/lib/braid/command.rb

@@ -0,0 +1,131 @@
+module Braid
+  class Command
+    class InvalidRevision < BraidError
+    end
+
+    extend Operations::VersionControl
+    include Operations::VersionControl
+
+    def self.run(command, *args)
+      verify_git_version!
+
+      klass = Commands.const_get(command.to_s.capitalize)
+      klass.new.run(*args)
+
+    rescue BraidError => error
+      case error
+      when Operations::ShellExecutionError
+        msg "Shell error: #{error.message}"
+      else
+        msg "Error: #{error.message}"
+      end
+      exit(1)
+    end
+
+    def self.msg(str)
+      puts "Braid: #{str}"
+    end
+
+    def msg(str)
+      self.class.msg(str)
+    end
+
+    def config
+      @config ||= load_and_migrate_config
+    end
+
+    def verbose?
+      Braid.verbose
+    end
+
+    private
+      def setup_remote(mirror)
+        Command.run(:setup, mirror.path)
+      end
+
+      def use_local_cache?
+        Braid.use_local_cache
+      end
+
+      def self.verify_git_version!
+        git.require_version!(REQUIRED_GIT_VERSION)
+      end
+
+      def bail_on_local_changes!
+        git.ensure_clean!
+      end
+
+      def with_reset_on_error
+        work_head = git.head
+
+        begin
+          yield
+        rescue => error
+          msg "Resetting to '#{work_head[0, 7]}'."
+          git.reset_hard(work_head)
+          raise error
+        end
+      end
+
+      def load_and_migrate_config
+        config = Config.new
+        unless config.valid?
+          msg "Configuration is outdated. Migrating."
+          bail_on_local_changes!
+          config.migrate!
+          git.commit("Upgrade .braids", "-- .braids")
+        end
+        config
+      end
+
+      def add_config_file
+        git.add(CONFIG_FILE)
+      end
+
+      def display_revision(mirror, revision = nil)
+        revision ||= mirror.revision
+        mirror.type == "svn" ? "r#{revision}" : "'#{revision[0, 7]}'"
+      end
+
+      def validate_new_revision(mirror, new_revision)
+        unless new_revision
+          unless mirror.type == "svn"
+            return git.rev_parse(mirror.remote)
+          else
+            return svn.head_revision(mirror.url)
+          end
+        end
+
+        unless mirror.type == "svn"
+          new_revision = git.rev_parse(new_revision)
+        else
+          new_revision = svn.clean_revision(new_revision)
+        end
+        old_revision = mirror.revision
+
+        if new_revision == old_revision
+          raise InvalidRevision, "mirror is already at requested revision"
+        end
+
+        if mirror.type == "svn"
+          if old_revision && new_revision < old_revision
+            raise InvalidRevision, "local revision is higher than request revision"
+          end
+
+          if svn.head_revision(mirror.url) < new_revision
+            raise InvalidRevision, "requested revision is higher than remote revision"
+          end
+        end
+
+        new_revision
+      end
+
+      def determine_target_revision(mirror, new_revision)
+        unless mirror.type == "svn"
+          git.rev_parse(new_revision)
+        else
+          git_svn.commit_hash(mirror.remote, new_revision)
+        end
+      end
+  end
+end

data/lib/braid/commands/add.rb

@@ -0,0 +1,42 @@
+module Braid
+  module Commands
+    class Add < Command
+      def run(url, options = {})
+        bail_on_local_changes!
+
+        with_reset_on_error do
+          mirror = config.add_from_options(url, options)
+
+          branch_message = (mirror.type == "svn" || mirror.branch == "master") ? "" : " branch '#{mirror.branch}'"
+          revision_message = options["revision"] ? " at #{display_revision(mirror, options["revision"])}" : ""
+          msg "Adding #{mirror.type} mirror of '#{mirror.url}'#{branch_message}#{revision_message}."
+
+          # these commands are explained in the subtree merge guide
+          # http://www.kernel.org/pub/software/scm/git/docs/howto/using-merge-subtree.html
+
+          setup_remote(mirror)
+          mirror.fetch
+
+          new_revision = validate_new_revision(mirror, options["revision"])
+          target_revision = determine_target_revision(mirror, new_revision)
+
+          unless mirror.squashed?
+            git.merge_ours(target_revision)
+          end
+          git.read_tree_prefix(target_revision, mirror.path)
+
+          mirror.revision = new_revision
+          mirror.lock = new_revision if options["revision"]
+          config.update(mirror)
+          add_config_file
+
+          commit_message = "Added mirror '#{mirror.path}' at #{display_revision(mirror)}"
+
+          git.commit(commit_message)
+          msg commit_message
+        end
+      end
+
+    end
+  end
+end

data/lib/braid/commands/diff.rb

@@ -0,0 +1,13 @@
+module Braid
+  module Commands
+    class Diff < Command
+      def run(path)
+        mirror = config.get!(path)
+        setup_remote(mirror)
+
+        diff = mirror.diff
+        puts diff unless diff.empty?
+      end
+    end
+  end
+end

data/lib/braid/commands/list.rb

@@ -0,0 +1,32 @@
+module Braid
+  module Commands
+    class List < Command
+      def run(path = nil, options = {})
+        with_reset_on_error do
+          path ? list_one(path, options) : list_all(options)
+        end
+      end
+
+      protected
+        def list_all(options = {})
+          options.reject! { |k,v| %w(revision head).include?(k) }
+          print "\n"
+          msg "Listing all mirrors.\n=======================================================\n"
+          config.mirrors.each_with_index do |path, i|
+             mirror = config.get!(path)
+             print " #{i + 1}) #{path.to_s}"
+             print " [LOCKED]" if mirror.locked?
+             setup_remote(mirror)
+             msg "Fetching new commits for '#{mirror.path}'." if verbose?
+             mirror.fetch
+             new_revision = validate_new_revision(mirror, options["revision"])
+             target_revision = determine_target_revision(mirror, new_revision)
+             print " !!! UPDATE AVAILABLE !!!" if new_revision.to_s != mirror.base_revision.to_s
+             print "\n"
+          end
+          print "\n"
+        end
+
+    end
+  end
+end

data/lib/braid/commands/remove.rb

@@ -0,0 +1,33 @@
+module Braid
+  module Commands
+    class Remove < Command
+      def run(path, options = {})
+        mirror = config.get!(path)
+
+        bail_on_local_changes!
+
+        with_reset_on_error do
+          msg "Removing mirror from '#{mirror.path}'."
+
+          git.rm_r(mirror.path)
+
+          config.remove(mirror)
+          add_config_file
+
+          if options[:keep]
+            msg "Not removing remote '#{mirror.remote}'" if verbose?
+          elsif git.remote_url(mirror.remote)
+            msg "Removed remote '#{mirror.path}'" if verbose?
+            git.remote_rm mirror.remote
+          else
+            msg "Remote '#{mirror.remote}' not found, nothing to cleanup" if verbose?
+          end
+
+          commit_message = "Removed mirror '#{mirror.path}'"
+          git.commit(commit_message)
+          msg commit_message
+        end
+      end
+    end
+  end
+end

data/lib/braid/commands/setup.rb

@@ -0,0 +1,34 @@
+module Braid
+  module Commands
+    class Setup < Command
+      def run(path = nil)
+        path ? setup_one(path) : setup_all
+      end
+
+      protected
+        def setup_all
+          msg "Setting up all mirrors."
+          config.mirrors.each do |path|
+            setup_one(path)
+          end
+        end
+
+        def setup_one(path)
+          mirror = config.get!(path)
+
+          if git.remote_url(mirror.remote)
+            msg "Setup: Mirror '#{mirror.path}' already has a remote. Reusing it." if verbose?
+            return
+          end
+
+          msg "Setup: Creating remote for '#{mirror.path}'."
+          unless mirror.type == "svn"
+            url = use_local_cache? ? git_cache.path(mirror.url) : mirror.url
+            git.remote_add(mirror.remote, url, mirror.branch)
+          else
+            git_svn.init(mirror.remote, mirror.url)
+          end
+        end
+    end
+  end
+end

data/lib/braid/commands/update.rb

@@ -0,0 +1,102 @@
+module Braid
+  module Commands
+    class Update < Command
+      def run(path, options = {})
+        bail_on_local_changes!
+
+        with_reset_on_error do
+          path ? update_one(path, options) : update_all(options)
+        end
+      end
+
+      protected
+        def update_all(options = {})
+          options.reject! { |k,v| %w(revision head).include?(k) }
+          msg "Updating all mirrors."
+          config.mirrors.each do |path|
+            update_one(path, options)
+          end
+        end
+
+        def update_one(path, options = {})
+          mirror = config.get!(path)
+
+          revision_message = options["revision"] ? " to #{display_revision(mirror, options["revision"])}" : ""
+          msg "Updating mirror '#{mirror.path}'#{revision_message}."
+
+          # check options for lock modification
+          if mirror.locked?
+            if options["head"]
+              msg "Unlocking mirror '#{mirror.path}'." if verbose?
+              mirror.lock = nil
+            elsif !options["revision"]
+              msg "Mirror '#{mirror.path}' is locked to #{display_revision(mirror, mirror.lock)}. Use --head to force."
+              return
+            end
+          end
+
+          setup_remote(mirror)
+          msg "Fetching new commits for '#{mirror.path}'." if verbose?
+          mirror.fetch
+
+          new_revision = validate_new_revision(mirror, options["revision"])
+          target_revision = determine_target_revision(mirror, new_revision)
+
+          if mirror.merged?(target_revision)
+            msg "Mirror '#{mirror.path}' is already up to date."
+            return
+          end
+
+          if mirror.squashed?
+            diff = mirror.diff
+            base_revision = mirror.base_revision
+          end
+
+          mirror.revision = new_revision
+          mirror.lock = new_revision if options["revision"]
+
+          msg "Merging in mirror '#{mirror.path}'." if verbose?
+          begin
+            if mirror.squashed?
+              local_hash = git.rev_parse("HEAD")
+              if diff
+                base_hash = generate_tree_hash(mirror, base_revision)
+              else
+                base_hash = local_hash
+              end
+              remote_hash = generate_tree_hash(mirror, target_revision)
+              ENV["GITHEAD_#{local_hash}"] = "HEAD"
+              ENV["GITHEAD_#{remote_hash}"] = target_revision
+              git.merge_recursive(base_hash, local_hash, remote_hash)
+            else
+              git.merge_subtree(target_revision)
+            end
+          rescue Operations::MergeError => error
+            msg "Caught merge error. Breaking."
+          end
+
+          config.update(mirror)
+          add_config_file
+
+          commit_message = "Updated mirror '#{mirror.path}' to #{display_revision(mirror)}"
+
+          if error
+            File.open(".git/MERGE_MSG", 'w') { |f| f.puts(commit_message) }
+            return
+          end
+
+          git.commit(commit_message)
+          msg commit_message
+        end
+
+        def generate_tree_hash(mirror, revision)
+          git.rm_r(mirror.path)
+          git.read_tree_prefix(revision, mirror.path)
+          success = git.commit("Temporary commit for mirror '#{mirror.path}'")
+          hash = git.rev_parse("HEAD")
+          git.reset_hard("HEAD^") if success
+          hash
+        end
+    end
+  end
+end

data/lib/braid/config.rb

@@ -0,0 +1,101 @@
+require 'yaml'
+require 'yaml/store'
+
+module Braid
+  class Config
+    class PathAlreadyInUse < BraidError
+      def message
+        "path already in use: #{super}"
+      end
+    end
+    class MirrorDoesNotExist < BraidError
+      def message
+        "mirror does not exist: #{super}"
+      end
+    end
+
+    def initialize(config_file = CONFIG_FILE)
+      @db = YAML::Store.new(config_file)
+    end
+
+    def add_from_options(url, options)
+      mirror = Mirror.new_from_options(url, options)
+
+      add(mirror)
+      mirror
+    end
+
+    def mirrors
+      @db.transaction(true) do
+        @db.roots
+      end
+    end
+
+    def get(path)
+      @db.transaction(true) do
+        if attributes = @db[path.to_s.sub(/\/$/, '')]
+          Mirror.new(path, attributes)
+        end
+      end
+    end
+
+    def get!(path)
+      mirror = get(path)
+      raise MirrorDoesNotExist, path unless mirror
+      mirror
+    end
+
+    def add(mirror)
+      @db.transaction do
+        raise PathAlreadyInUse, mirror.path if @db[mirror.path]
+        write_mirror(mirror)
+      end
+    end
+
+    def remove(mirror)
+      @db.transaction do
+        @db.delete(mirror.path)
+      end
+    end
+
+    def update(mirror)
+      @db.transaction do
+        raise MirrorDoesNotExist, mirror.path unless @db[mirror.path]
+        @db.delete(mirror.path)
+        write_mirror(mirror)
+      end
+    end
+
+    def valid?
+      @db.transaction(true) do
+        !@db.roots.any? do |path|
+          @db[path]["url"].nil?
+        end
+      end
+    end
+
+    def migrate!
+      @db.transaction do
+        @db.roots.each do |path|
+          attributes = @db[path]
+          if attributes["local_branch"]
+            attributes["url"] = attributes.delete("remote")
+            attributes["remote"] = attributes.delete("local_branch")
+            attributes["squashed"] = attributes.delete("squash")
+            attributes["lock"] = attributes["revision"] # so far this has always been true
+          end
+          @db[path] = clean_attributes(attributes)
+        end
+      end
+    end
+
+    private
+      def write_mirror(mirror)
+        @db[mirror.path] = clean_attributes(mirror.attributes)
+      end
+
+      def clean_attributes(hash)
+        hash.reject { |k,v| v.nil? }
+      end
+  end
+end