dreamcat4-braid 0.5.1

data/lib/braid/commands/setup.rb

@@ -0,0 +1,38 @@
+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 mirror.type == "git-clone"
+            return
+          end
+
+          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,107 @@
+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}."
+
+          if mirror.type == "git-clone"
+            mirror.rspec_git.update options["revision"]
+          else
+            
+            # 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
+        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,180 @@
+require 'rspec_git.rb'
+
+module Braid
+  class Mirror
+    TYPES = %w(git svn git-clone)
+    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, :rspec_git
+
+    def initialize(path, attributes = {})
+      @path = path.sub(/\/$/, '')
+      @attributes = attributes
+      @rspec_git = RSpec::Git.new File.basename(@path) @path attributes["url"]
+    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 = "vendor/plugins/#{path}"
+      end
+
+      if options["rails_gem"] && ! path =~ /vendor\/gems.*/
+        path = "vendor/gems/#{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"
+        git_cache.fetch(url) if cached?
+        git.fetch(remote)
+      else
+        git_svn.fetch(remote)
+      end
+    end
+
+    def cached?
+      git.remote_url(remote) == git_cache.path(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
+
+    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-clone" 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