misaka-braid 0.4.0.1

data/lib/braid/commands/update.rb

@@ -0,0 +1,79 @@
+module Braid
+  module Commands
+    class Update < Command
+      def run(mirror, options = {})
+        raise Braid::Git::LocalChangesPresent if invoke(:local_changes?)
+
+        in_work_branch do
+          mirror ? update_one(mirror, options) : update_all
+        end
+      end
+
+      protected
+        def update_all
+          msg "Updating all mirrors."
+          config.mirrors.each do |mirror|
+            update_one(mirror)
+          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
+
+          # unlock
+          if params["revision"] && options["head"]
+            msg "Unlocking mirror '#{mirror}/'."
+            options["revision"] = nil 
+          end
+
+          begin
+            fetch_remote(params["type"], local_branch)
+
+            validate_revision_option(params, options)
+            target = determine_target_commit(params, options)
+
+            check_merge_status(target)
+          rescue Braid::Commands::MirrorAlreadyUpToDate
+            msg "Mirror '#{mirror}/' is already up to date. Skipping."
+            update_revision(mirror, options["revision"])
+            return
+          end
+
+          msg "Updating #{params["type"]} mirror '#{mirror}/'."
+
+          if params["squash"]
+            invoke(:git_rm_r, mirror)
+            invoke(:git_read_tree, target, mirror)
+          else
+            invoke(:git_merge_subtree, target)
+          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
+
+        def update_revision(mirror, revision)
+          config.update(mirror, { "revision" => revision })
+        end
+    end
+  end
+end

data/lib/braid/config.rb

@@ -0,0 +1,148 @@
+require 'yaml'
+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)
+    end
+
+    def add_from_options(remote, options)
+      mirror, params = self.class.options_to_mirror(remote, options)
+
+      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"])
+
+      params.delete("rails_plugin")
+      params.delete("branch") if params["type"] == "svn"
+      add(mirror, params)
+      [mirror, get(mirror)]
+    end
+
+    def mirrors
+      @db.transaction(true) do
+        @db.roots
+      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)
+      @db.transaction(true) do
+        @db[mirror]
+      end
+    end
+
+    def get!(mirror)
+      params = get(mirror)
+      raise Braid::Config::MirrorDoesNotExist unless params
+      params
+    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 }
+      end
+      [mirror, get(mirror)]
+    end
+
+    def remove(mirror)
+      mirror = remove_trailing_slash(mirror)
+      @db.transaction do
+        @db.delete(mirror)
+      end
+    end
+
+    def update(mirror, params)
+      mirror = remove_trailing_slash(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"]))
+      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
+      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}"
+      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)
+      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
+      end
+  end
+end

data/lib/braid/exceptions.rb

@@ -0,0 +1,34 @@
+module Braid
+  class Exception < StandardError
+  end
+
+  module Commands
+    class ShellExecutionError < Braid::Exception; end
+    class LocalRevisionIsHigherThanRequestedRevision < Braid::Exception; end
+    class MirrorAlreadyUpToDate < Braid::Exception; end
+    class RequestedRevisionIsHigherThanRemoteRevision < Braid::Exception; end
+  end
+
+  class Config
+    class UnknownMirrorType < Braid::Exception; end
+    class MirrorNameAlreadyInUse < Braid::Exception; end
+    class MirrorDoesNotExist < Braid::Exception; end
+    class CannotGuessMirrorType < Braid::Exception; end
+
+    class RemoteIsRequired < Braid::Exception; end
+    class MirrorTypeIsRequired < Braid::Exception; end
+    class BranchIsRequired < Braid::Exception; end
+    class MirrorNameIsRequired < Braid::Exception; end
+  end
+
+  class Git
+    class UnknownRevision < Braid::Exception; end
+    class GitVersionTooLow < Braid::Exception; end
+    class GitSvnVersionTooLow < Braid::Exception; end
+    class LocalChangesPresent < Braid::Exception; end
+  end
+
+  class Svn
+    class UnknownRevision < Braid::Exception; end
+  end
+end

data/lib/braid/operations.rb

@@ -0,0 +1,297 @@
+module Braid
+  module Operations
+    module Git
+      def git_commit(message)
+        status, out, err = exec("git commit -m #{message.inspect} --no-verify")
+
+        if status == 0
+          true
+        elsif out.match(/nothing.* to commit/)
+          false
+        else
+          raise Braid::Commands::ShellExecutionError, err
+        end
+      end
+
+      def git_fetch(remote)
+        # open4 messes with the pipes of index-pack
+        system("git fetch -n #{remote} 2>&1 > /dev/null")
+        raise Braid::Commands::ShellExecutionError unless $? == 0
+        true
+      end
+
+      def git_checkout(treeish)
+        # TODO debug
+        msg "Checking out '#{treeish}'."
+        exec!("git checkout #{treeish}")
+        true
+      end
+
+      # Returns the base commit or nil.
+      def git_merge_base(target, source)
+        status, out, err = exec!("git merge-base #{target} #{source}")
+        out.strip
+      rescue Braid::Commands::ShellExecutionError
+        nil
+      end
+
+      def git_rev_parse(commit)
+        status, out, err = exec!("git rev-parse #{commit}")
+        out.strip
+      end
+
+      # Implies tracking.
+      def git_remote_add(remote, path, branch)
+        exec!("git remote add -t #{branch} -m #{branch} #{remote} #{path}")
+        true
+      end
+
+      def git_reset_hard(target)
+        exec!("git reset --hard #{target}")
+        true
+      end
+
+      # Implies no commit.
+      def git_merge_ours(commit)
+        exec!("git merge -s ours --no-commit #{commit}")
+        true
+      end
+
+      # Implies no commit.
+      def git_merge_subtree(commit)
+        # TODO which options are needed?
+        exec!("git merge -s subtree --no-commit --no-ff #{commit}")
+        true
+      end
+
+      def git_read_tree(treeish, prefix)
+        exec!("git read-tree --prefix=#{prefix}/ -u #{treeish}")
+        true
+      end
+
+      def git_rm_r(path)
+        exec!("git rm -r #{path}")
+        true
+      end
+
+      def local_changes?
+        status, out, err = exec("git status")
+        out.split("\n").grep(/nothing to commit \(working directory clean\)/).empty?
+      end
+    end
+
+    module Svn
+      # FIXME move
+      def svn_remote_head_revision(path)
+        # not using svn info because it's retarded and doesn't show the actual last changed rev for the url
+        # git svn has no clue on how to get the actual HEAD revision number on it's own
+        status, out, err = exec!("svn log -q --limit 1 #{path}")
+        out.split(/\n/).find { |x| x.match /^r\d+/ }.split(" | ")[0][1..-1].to_i
+      end
+
+      # FIXME move
+      def svn_git_commit_hash(remote, revision)
+        status, out, err = exec!("git svn log --show-commit --oneline -r #{revision} #{remote}")
+        part = out.split(" | ")[1]
+        raise Braid::Svn::UnknownRevision, "unknown revision: #{revision}" unless part
+        invoke(:git_rev_parse, part)
+      end
+
+      def git_svn_fetch(remote)
+        # open4 messes with the pipes of index-pack
+        system("git svn fetch #{remote} 2>&1 > /dev/null")
+        true
+      end
+
+      def git_svn_init(remote, path)
+        exec!("git svn init -R #{remote} --id=#{remote} #{path}")
+        true
+      end
+    end
+
+    module Helpers
+      [:invoke, :exec, :exec!].each do |method|
+        define_method(method) do |*args|
+          Braid::Operations.send(method, *args)
+        end
+      end
+
+      def extract_version(cmd)
+        status, out, err = exec!("#{cmd} --version")
+        return out.sub(/^.* version/, "").strip
+      end
+
+      def verify_version(cmd, required)
+        required_version = required.split(".")
+        actual_version   = extract_version(cmd).split(".")
+        actual_version.each_with_index do |actual_piece, idx|
+          required_piece = required_version[idx]
+
+          return true unless required_piece
+
+          case (actual_piece <=> required_piece)
+            when -1
+              return false
+            when 1
+              return true
+            when 0
+              next
+          end
+        end
+
+        return actual_version.length >= required_version.length
+      end
+
+      def find_git_revision(commit)
+        invoke(:git_rev_parse, commit)
+      rescue Braid::Commands::ShellExecutionError
+        raise Braid::Git::UnknownRevision, "unknown revision: #{commit}"
+      end
+
+      def clean_svn_revision(revision)
+        if revision
+          revision.to_i
+        else
+          nil
+        end
+      end
+
+      def validate_svn_revision(old_revision, new_revision, path)
+        return unless new_revision = clean_svn_revision(new_revision)
+        old_revision = clean_svn_revision(old_revision)
+
+        # TODO add checks for unlocked mirrors
+        if old_revision
+          if new_revision < old_revision
+            raise Braid::Commands::LocalRevisionIsHigherThanRequestedRevision
+          elsif new_revision == old_revision
+            raise Braid::Commands::MirrorAlreadyUpToDate
+          end
+        end
+
+        if path && invoke(:svn_remote_head_revision, path) < new_revision
+          raise Braid::Commands::RequestedRevisionIsHigherThanRemoteRevision
+        end
+
+        true
+      end
+
+      # Make sure the revision is valid, then clean it.
+      def validate_revision_option(params, options)
+        if options["revision"]
+          case params["type"]
+          when "git"
+            options["revision"] = find_git_revision(options["revision"])
+          when "svn"
+            validate_svn_revision(params["revision"], options["revision"], params["remote"])
+            options["revision"] = clean_svn_revision(options["revision"])
+          end
+        end
+
+        true
+      end
+
+      def determine_target_commit(params, options)
+        if options["revision"]
+          if params["type"] == "svn"
+            invoke(:svn_git_commit_hash, params["local_branch"], options["revision"])
+          else
+            invoke(:git_rev_parse, options["revision"])
+          end
+        else
+          invoke(:git_rev_parse, params["local_branch"])
+        end
+      end
+
+      def display_revision(type, revision)
+        type == "svn" ? "r#{revision}" : "'#{revision[0, 7]}'"
+      end
+    end
+
+    module Mirror
+      def get_current_branch
+        status, out, err = exec!("git branch | grep '*'")
+        out[2..-1]
+      end
+
+      def create_work_branch
+        # check if branch exists
+        status, out, err = exec("git branch | grep '#{WORK_BRANCH}'")
+        if status != 0
+          # then create it
+          msg "Creating work branch '#{WORK_BRANCH}'."
+          exec!("git branch #{WORK_BRANCH}")
+        end
+
+        true
+      end
+
+      def get_work_head
+        find_git_revision(WORK_BRANCH)
+      end
+
+      def add_config_file
+        exec!("git add #{CONFIG_FILE}")
+        true
+      end
+
+      def check_merge_status(commit)
+        commit = find_git_revision(commit)
+        # tip from spearce in #git:
+        # `test z$(git merge-base A B) = z$(git rev-parse --verify A)`
+        if invoke(:git_merge_base, commit, "HEAD") == commit
+          raise Braid::Commands::MirrorAlreadyUpToDate
+        end
+
+        true
+      end
+
+      def fetch_remote(type, remote)
+        msg "Fetching data from '#{remote}'."
+        case type
+        when "git"
+          invoke(:git_fetch, remote)
+        when "svn"
+          invoke(:git_svn_fetch, remote)
+        end
+      end
+
+      def find_remote(remote)
+        # TODO clean up and maybe return more information
+        !!File.readlines(".git/config").find { |line| line =~ /^\[(svn-)?remote "#{remote}"\]/ }
+      end
+    end
+
+    extend Git
+    extend Svn
+
+    def self.invoke(*args)
+      send(*args)
+    end
+
+    def self.exec(cmd)
+      #puts cmd
+      out = ""
+      err = ""
+      cmd.strip!
+
+      ENV['LANG'] = 'C' unless ENV['LANG'] == 'C'
+      status = Open4::popen4(cmd) do |pid, stdin, stdout, stderr|
+        out = stdout.read.strip
+        err = stderr.read.strip
+      end
+      [status.exitstatus, out, err]
+    end
+
+    def self.exec!(cmd)
+      status, out, err = exec(cmd)
+      raise Braid::Commands::ShellExecutionError, err unless status == 0
+      return status, out, err
+    end
+
+    private
+      def self.msg(str)
+        Braid::Command.msg(str)
+      end
+  end
+end

data/lib/braid/version.rb

@@ -0,0 +1,9 @@
+module Braid #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 4
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/braid.rb

@@ -0,0 +1,29 @@
+$:.unshift dir = File.dirname(__FILE__)
+
+begin
+  require 'rubygems'
+rescue LoadError
+end
+
+require 'open4'
+require 'yaml'
+require 'yaml/store'
+
+module Braid
+  MIRROR_TYPES = %w[git svn]
+  WORK_BRANCH = "braid/track"
+  CONFIG_FILE = ".braids"
+  REQUIRED_GIT_VERSION = "1.5.4.5"
+  REQUIRED_GIT_SVN_VERSION = "1.5.4.5"
+end
+
+require 'braid/version'
+require 'braid/exceptions'
+
+require 'braid/config'
+require 'braid/operations'
+
+require 'braid/command'
+Dir["#{dir}/braid/commands/*"].each do |file|
+  require file
+end

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.join(File.dirname(__FILE__), '..')
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! :rubygems
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.join(File.dirname(__FILE__), '..')
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! :rubygems, :newgem
+RubiGen::Scripts::Generate.new.run(ARGV)