honkster-braid 0.6.2

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/push.rb

@@ -0,0 +1,48 @@
+require 'fileutils'
+require 'tmpdir'
+
+module Braid
+  module Commands
+    class Push < Command
+      def run(path, options = {})
+        mirror = config.get!(path)
+
+        #mirror.fetch
+
+        base_revision = git.rev_parse(mirror.remote)
+        unless mirror.merged?(base_revision)
+          msg "Mirror is not up to date. Stopping."
+          return
+        end
+
+        diff = mirror.diff
+        if diff.empty?
+          msg "No local changes found. Stopping."
+          return
+        end
+
+        clone_dir = Dir.tmpdir + "/braid_push.#{$$}"
+        Dir.mkdir(clone_dir)
+        source_dir = Dir.pwd
+        remote_url = git.remote_url(mirror.remote)
+        if remote_url == mirror.cached_url
+          remote_url = mirror.url
+        elsif File.directory?(remote_url)
+          remote_url = File.expand_path(remote_url)
+        end
+        Dir.chdir(clone_dir) do
+          msg "Cloning mirror with local changes."
+          git.init
+          git.fetch(source_dir)
+          git.fetch(remote_url)
+          git.checkout(base_revision)
+          git.apply(diff)
+          system("git commit -v")
+          msg "Pushing changes to remote."
+          git.push(remote_url, "HEAD:#{mirror.branch}")
+        end
+        FileUtils.rm_r(clone_dir)
+      end
+    end
+  end
+end

data/lib/braid/commands/remove.rb

@@ -0,0 +1,32 @@
+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
+
+          git.commit("Remove mirror '#{mirror.path}'")
+          msg "Removed mirror." if verbose?
+        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,101 @@
+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.empty?
+                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 = "Update 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 "Updated mirror to #{display_revision(mirror)}."
+        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

data/lib/braid/mirror.rb

@@ -0,0 +1,177 @@
+module Braid
+  class Mirror
+    TYPES = %w(git svn)
+    ATTRIBUTES = %w(url remote type branch squashed revision lock)
+
+    class UnknownType < BraidError
+      def message
+        "unknown type: #{super}"
+      end
+    end
+    class CannotGuessType < BraidError
+      def message
+        "cannot guess type: #{super}"
+      end
+    end
+    class PathRequired < BraidError
+      def message
+        "path is required"
+      end
+    end
+
+    include Operations::VersionControl
+
+    attr_reader :path, :attributes
+
+    def initialize(path, attributes = {})
+      @path = path.sub(/\/$/, '')
+      @attributes = attributes
+    end
+
+    def self.new_from_options(url, options = {})
+      url = url.sub(/\/$/, '')
+
+      branch = options["branch"] || "master"
+
+      if type = options["type"] || extract_type_from_url(url)
+        raise UnknownType, type unless TYPES.include?(type)
+      else
+        raise CannotGuessType, url
+      end
+
+      unless path = options["path"] || extract_path_from_url(url)
+        raise PathRequired
+      end
+
+      if options["rails_plugin"]
+        path = "vendor/plugins/#{path}"
+      end
+
+      remote = "braid/#{path}".gsub("_", '-') # stupid git svn changes all _ to ., weird
+      squashed = !options["full"]
+      branch = nil if type == "svn"
+
+      attributes = { "url" => url, "remote" => remote, "type" => type, "branch" => branch, "squashed" => squashed }
+      self.new(path, attributes)
+    end
+
+    def ==(comparison)
+      path == comparison.path && attributes == comparison.attributes
+    end
+
+    def type
+      # override Object#type
+      attributes["type"]
+    end
+
+    def locked?
+      !!lock
+    end
+
+    def squashed?
+      !!squashed
+    end
+
+    def merged?(commit)
+      # tip from spearce in #git:
+      # `test z$(git merge-base A B) = z$(git rev-parse --verify A)`
+      commit = git.rev_parse(commit)
+      if squashed?
+        !!base_revision && git.merge_base(commit, base_revision) == commit
+      else
+        git.merge_base(commit, "HEAD") == commit
+      end
+    end
+
+    def diff
+      remote_hash = git.rev_parse("#{base_revision}:")
+      local_hash = git.tree_hash(path)
+      remote_hash != local_hash ? git.diff_tree(remote_hash, local_hash) : ""
+    end
+
+    def fetch
+      unless type == "svn"
+        git_cache.fetch(url) if cached?
+        git.fetch(remote)
+      else
+        git_svn.fetch(remote)
+      end
+    end
+
+    def cached?
+      git.remote_url(remote) == cached_url
+    end
+
+    def base_revision
+      if revision
+        unless type == "svn"
+          git.rev_parse(revision)
+        else
+          git_svn.commit_hash(remote, revision)
+        end
+      else
+        inferred_revision
+      end
+    end
+
+    def cached_url
+      git_cache.path(url)
+    end
+
+    private
+      def method_missing(name, *args)
+        if ATTRIBUTES.find { |attribute| name.to_s =~ /^(#{attribute})(=)?$/ }
+          unless $2
+            attributes[$1]
+          else
+            attributes[$1] = args[0]
+          end
+        else
+          raise NameError, "unknown attribute `#{name}'"
+        end
+      end
+
+      def inferred_revision
+        local_commits = git.rev_list("HEAD", "-- #{path}").split("\n")
+        remote_hashes = git.rev_list("--pretty=format:\"%T\"", remote).split("commit ").map do |chunk|
+          chunk.split("\n", 2).map { |value| value.strip }
+        end
+        hash = nil
+        local_commits.each do |local_commit|
+          local_tree = git.tree_hash(path, local_commit)
+          if match = remote_hashes.find { |_, remote_tree| local_tree == remote_tree }
+            hash = match[0]
+            break
+          end
+        end
+        hash
+      end
+
+      def self.extract_type_from_url(url)
+        return nil unless url
+        url.sub!(/\/$/, '')
+
+        # check for git:// and svn:// URLs
+        url_scheme = url.split(":").first
+        return url_scheme if TYPES.include?(url_scheme)
+
+        return "svn" if url[-6..-1] == "/trunk"
+        return "git" if url[-4..-1] == ".git"
+      end
+
+      def self.extract_path_from_url(url)
+        return nil unless url
+        name = File.basename(url)
+
+        if File.extname(name) == ".git"
+          # strip .git
+          name[0..-5]
+        elsif name == "trunk"
+          # use parent
+          File.basename(File.dirname(url))
+        else
+          name
+        end
+      end
+  end
+end