evilchelu-braid 0.4.0 → 0.4.10

data/lib/braid/commands/diff.rb

@@ -1,9 +1,10 @@
 module Braid
   module Commands
     class Diff < Command
-      def run(mirror)
-        # easiest call, liek, evar.
-        system("git diff #{WORK_BRANCH} HEAD #{mirror}")
+      def run(path)
+        mirror = config.get!(path)
+        diff = mirror.diff
+        puts diff unless diff.empty?
       end
     end
   end

data/lib/braid/commands/remove.rb

@@ -1,25 +1,21 @@
 module Braid
   module Commands
     class Remove < Command
-      def run(mirror)
-        raise Braid::Git::LocalChangesPresent if invoke(:local_changes?)
+      def run(path)
+        mirror = config.get!(path)
 
-        in_work_branch do
-          params = config.get(mirror)
-          unless params
-            msg "Mirror '#{mirror}/' does not exist."
-            return
-          end
+        bail_on_local_changes!
 
-          msg "Removing #{params["type"]} mirror from '#{mirror}/'."
+        with_reset_on_error do
+          msg "Removing mirror from '#{mirror.path}/'."
 
-          invoke(:git_rm_r, mirror)
+          git.rm_r(mirror.path)
 
           config.remove(mirror)
           add_config_file
 
-          commit_message = "Remove mirror '#{mirror}/'."
-          invoke(:git_commit, commit_message)
+          commit_message = "Remove mirror '#{mirror.path}/'"
+          git.commit(commit_message)
         end
       end
     end

data/lib/braid/commands/setup.rb

@@ -1,36 +1,31 @@
 module Braid
   module Commands
     class Setup < Command
-      def run(mirror)
-        mirror ? setup_one(mirror) : setup_all
+      def run(path = nil)
+        path ? setup_one(path) : setup_all
       end
 
       protected
         def setup_all
           msg "Setting up all mirrors."
-          config.mirrors.each do |mirror|
-            setup_one(mirror)
+          config.mirrors.each do |path|
+            setup_one(path)
           end
         end
 
-        def setup_one(mirror)
-          params = config.get(mirror)
-          unless params
-            msg "Mirror '#{mirror}/' does not exist. Skipping."
-            return
-          end
+        def setup_one(path)
+          mirror = config.get!(path)
 
-          if find_remote(params["local_branch"])
-            msg "Mirror '#{mirror}/' already has a remote. Skipping."
+          if git.remote_exists?(mirror.remote)
+            msg "Mirror '#{mirror.path}/' already has a remote. Skipping."
             return
           end
 
-          msg "Setting up remote for '#{mirror}/'."
-          case params["type"]
-          when "git"
-            invoke(:git_remote_add, params["local_branch"], params["remote"], params["branch"])
-          when "svn"
-            invoke(:git_svn_init, params["local_branch"], params["remote"])
+          msg "Setting up remote for '#{mirror.path}/'."
+          unless mirror.type == "svn"
+            git.remote_add(mirror.remote, mirror.cached_url, mirror.branch)
+          else
+            git_svn.init(mirror.remote, mirror.url)
           end
         end
     end

data/lib/braid/commands/update.rb

@@ -1,78 +1,77 @@
 module Braid
   module Commands
     class Update < Command
-      def run(mirror, options = {})
-        raise Braid::Git::LocalChangesPresent if invoke(:local_changes?)
+      def run(path, options = {})
+        bail_on_local_changes!
 
-        in_work_branch do
-          mirror ? update_one(mirror, options) : update_all
+        with_reset_on_error do
+          path ? update_one(path, options) : update_all(options)
         end
       end
 
       protected
-        def update_all
+        def update_all(options = {})
+          options.reject! { |k,v| %w(revision head).include?(k) }
           msg "Updating all mirrors."
-          config.mirrors.each do |mirror|
-            update_one(mirror)
+          config.mirrors.each do |path|
+            update_one(path, options)
           end
         end
 
-        def update_one(mirror, options = {})
-          params = config.get(mirror)
-          unless params
-            msg "Mirror '#{mirror}/' does not exist. Skipping."
-            return
-          end
-          local_branch = params["local_branch"]
-
-          if check_for_lock(params, options)
-            msg "Mirror '#{mirror}/' is locked to #{display_revision(params["type"], params["revision"])}. Skipping."
-            return
-          end
+        def update_one(path, options = {})
+          mirror = config.get!(path)
 
-          # unlock
-          if params["revision"] && options["head"]
-            msg "Unlocking mirror '#{mirror}/'."
-            options["revision"] = nil 
+          # check options for lock modification
+          if mirror.locked?
+            if options["head"]
+              msg "Unlocking mirror '#{mirror.path}/'."
+              mirror.lock = nil
+            elsif !options["revision"]
+              msg "Mirror '#{mirror.path}/' is locked to #{display_revision(mirror, mirror.lock)}. Skipping."
+              return
+            end
           end
 
-          begin
-            fetch_remote(params["type"], local_branch)
+          mirror.fetch
 
-            validate_revision_option(params, options)
-            target = determine_target_commit(params, options)
+          new_revision = validate_new_revision(mirror, options["revision"])
+          target_hash = determine_target_commit(mirror, new_revision)
 
-            check_merge_status(target)
-          rescue Braid::Commands::MirrorAlreadyUpToDate
-            msg "Mirror '#{mirror}/' is already up to date. Skipping."
-            update_revision(mirror, options["revision"])
+          if mirror.merged?(target_hash)
+            msg "Mirror '#{mirror.path}/' is already up to date. Skipping."
             return
           end
 
-          msg "Updating #{params["type"]} mirror '#{mirror}/'."
+          diff = mirror.diff if mirror.squashed? # get diff before setting revision
+
+          mirror.revision = new_revision
+          mirror.lock = new_revision if options["revision"]
+          config.update(mirror)
 
-          if params["squash"]
-            invoke(:git_rm_r, mirror)
-            invoke(:git_read_tree, target, mirror)
+          msg "Updating mirror '#{mirror.path}/'."
+          if mirror.squashed?
+            git.rm_r(mirror.path)
+            git.read_tree(target_hash, mirror.path)
+            unless diff.empty?
+              git.apply(diff, *(options["safe"] ? ["--reject"] : []))
+            end
           else
-            invoke(:git_merge_subtree, target)
+            git.merge_subtree(target_hash)
           end
 
-          update_revision(mirror, options["revision"])
           add_config_file
 
-          revision_message = " to " + (options["revision"] ? display_revision(params["type"], options["revision"]) : "HEAD")
-          commit_message = "Update mirror '#{mirror}/'#{revision_message}."
-          invoke(:git_commit, commit_message)
-        end
-
-      private
-        def check_for_lock(params, options)
-          params["revision"] && !options["revision"] && !options["head"]
-        end
+          revision_message = " to " + (options["revision"] ? display_revision(mirror) : "HEAD")
+          commit_message = "Update mirror '#{mirror.path}/'#{revision_message}"
+          git.commit(commit_message)
 
-        def update_revision(mirror, revision)
-          config.update(mirror, { "revision" => revision })
+        rescue Operations::ShellExecutionError => error
+          if options["safe"]
+            msg "Caught shell error. Breaking."
+            exit(0)
+          else
+            raise error
+          end
         end
     end
   end

data/lib/braid/config.rb

@@ -3,26 +3,26 @@ require 'yaml/store'
 
 module Braid
   class Config
-    attr_accessor :db
-    
-    def initialize(config_file = nil)
-      config_file ||= CONFIG_FILE
-      @db = YAML::Store.new(config_file)
+    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 add_from_options(remote, options)
-      mirror, params = self.class.options_to_mirror(remote, options)
+    def initialize(config_file = CONFIG_FILE)
+      @db = YAML::Store.new(config_file)
+    end
 
-      raise Braid::Config::RemoteIsRequired unless params["remote"]
-      raise Braid::Config::MirrorTypeIsRequired unless params["type"]
-      raise Braid::Config::BranchIsRequired unless params["type"] == "svn" || params["branch"]
-      raise Braid::Config::MirrorNameIsRequired unless mirror
-      raise Braid::Config::UnknownMirrorType unless MIRROR_TYPES.include?(params["type"])
+    def add_from_options(url, options)
+      mirror = Mirror.new_from_options(url, options)
 
-      params.delete("rails_plugin")
-      params.delete("branch") if params["type"] == "svn"
-      add(mirror, params)
-      [mirror, get(mirror)]
+      add(mirror)
+      mirror
     end
 
     def mirrors
@@ -31,118 +31,71 @@ module Braid
       end
     end
 
-    def add(mirror, params)
-      mirror = remove_trailing_slash(mirror)
-      @db.transaction do
-        raise Braid::Config::MirrorNameAlreadyInUse if @db[mirror]
-        @db[mirror] = params.merge("remote" => remove_trailing_slash(params["remote"]))
-      end
-    end
-
-    def get(mirror)
-      mirror = remove_trailing_slash(mirror)
+    def get(path)
       @db.transaction(true) do
-        @db[mirror]
+        if attributes = @db[path.to_s.sub(/\/$/, '')]
+          Mirror.new(path, attributes)
+        end
       end
     end
 
-    def get!(mirror)
-      params = get(mirror)
-      raise Braid::Config::MirrorDoesNotExist unless params
-      params
+    def get!(path)
+      mirror = get(path)
+      raise MirrorDoesNotExist, path unless mirror
+      mirror
     end
 
-    def get_by_remote(remote)
-      remote = remove_trailing_slash(remote)
-      mirror = nil
-      @db.transaction(true) do
-        mirror = @db.roots.detect { |mirror| @db[mirror]["remote"] == remote }
+    def add(mirror)
+      @db.transaction do
+        raise PathAlreadyInUse, mirror.path if @db[mirror.path]
+        write_mirror(mirror)
       end
-      [mirror, get(mirror)]
     end
 
     def remove(mirror)
-      mirror = remove_trailing_slash(mirror)
       @db.transaction do
-        @db.delete(mirror)
+        @db.delete(mirror.path)
       end
     end
 
-    def update(mirror, params)
-      mirror = remove_trailing_slash(mirror)
+    def update(mirror)
       @db.transaction do
-        raise Braid::Config::MirrorDoesNotExist unless @db[mirror]
-        tmp = @db[mirror].merge(params)
-        @db[mirror] = tmp.merge("remote" => remove_trailing_slash(tmp["remote"]))
+        raise MirrorDoesNotExist, mirror.path unless @db[mirror.path]
+        @db.delete(mirror.path)
+        write_mirror(mirror)
       end
     end
 
-    def replace(mirror, params)
-      mirror = remove_trailing_slash(mirror)
-      @db.transaction do
-        raise Braid::Config::MirrorDoesNotExist unless @db[mirror]
-        params["remote"] = remove_trailing_slash(params["remote"]) if params["remote"]
-        @db[mirror] = params
+    def valid?
+      @db.transaction(true) do
+        !@db.roots.any? do |path|
+          @db[path]["url"].nil?
+        end
       end
     end
 
-    def self.options_to_mirror(remote, options = {})
-      remote = remove_trailing_slash(remote)
-      branch = options["branch"] || "master"
-
-      if options["type"]
-        type = options["type"]
-      else
-        type = extract_type_from_path(remote)
-        raise Braid::Config::CannotGuessMirrorType unless type
-      end
-
-      mirror = options["mirror"] || extract_mirror_from_path(remote)
-
-      if options["rails_plugin"]
-        mirror = "vendor/plugins/#{mirror}"
+    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
-
-      squash = !options["full"]
-
-      [remove_trailing_slash(mirror), { "type" => type, "remote" => remote, "branch" => branch, "squash" => squash }]
     end
 
     private
-      def remove_trailing_slash(path)
-        self.class.send(:remove_trailing_slash, path)
+      def write_mirror(mirror)
+        @db[mirror.path] = clean_attributes(mirror.attributes)
       end
 
-      def self.remove_trailing_slash(path)
-        # bluh.
-        path.sub(/\/$/, '')
-      end
-
-      def self.extract_type_from_path(path)
-        return nil unless path
-        path = remove_trailing_slash(path)
-
-        # check for git:// and svn:// URLs
-        path_scheme = path.split(":").first
-        return path_scheme if %w[git svn].include?(path_scheme)
-
-        return "svn" if path[-6..-1] == "/trunk"
-        return "git" if path[-4..-1] == ".git"
-      end
-
-      def self.extract_mirror_from_path(path)
-        return nil unless path
-        name = File.basename(path)
-
-        if File.extname(name) == ".git"
-          # strip .git
-          name[0..-5]
-        elsif name == "trunk"
-          # use parent
-          File.basename(File.dirname(path))
-        else
-          name
-        end
+      def clean_attributes(hash)
+        hash.reject { |k,v| v.nil? }
       end
   end
 end

data/lib/braid/mirror.rb

@@ -0,0 +1,181 @@
+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.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, path) : ""
+    end
+
+    def fetch
+      unless type == "svn"
+        init_or_fetch_local_cache
+        git.fetch(remote)
+      else
+        git_svn.fetch(remote)
+      end
+    end
+
+    def cached_url
+      if Braid::USE_LOCAL_CACHE
+        File.join(Braid::LOCAL_CACHE_DIR, url.gsub(/[\/:@]/, "_"))
+      else
+        url
+      end
+    end
+
+    def init_or_fetch_local_cache
+      git_cache.init_or_fetch(url, cached_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 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 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