realityforge-braid 0.7.2

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, "+refs/heads/#{mirror.branch}")
+          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,40 @@
+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)
+          if force?
+            msg "Setup: Mirror '#{mirror.path}' already has a remote. Replacing it (force)" if verbose?
+            git.remote_rm(mirror.remote)
+          else
+            msg "Setup: Mirror '#{mirror.path}' already has a remote. Reusing it." if verbose?
+            return
+          end
+        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.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,106 @@
+require 'yaml'
+
+# psych throws such wonderful errors as: 
+#  `@vendor/rails' is not allowed as an instance variable name (NameError)
+YAML::ENGINE.yamler = 'syck' if RUBY_VERSION >= '1.9.1'
+
+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,186 @@
+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   = "#{branch}/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
+
+    def remote
+      if (attributes["remote"] && attributes["remote"] =~ /^braid\//)
+        attributes["remote"] = "#{branch}/#{attributes["remote"]}"
+      else
+        attributes["remote"]
+      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" 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