jit 0.0.0 → 1.0.0

data/lib/remotes.rb

@@ -0,0 +1,82 @@
+require_relative "./refs"
+require_relative "./remotes/refspec"
+require_relative "./remotes/remote"
+
+class Remotes
+  DEFAULT_REMOTE = "origin"
+
+  InvalidBranch = Class.new(StandardError)
+  InvalidRemote = Class.new(StandardError)
+
+  def initialize(config)
+    @config = config
+  end
+
+  def add(name, url, branches = [])
+    branches = ["*"] if branches.empty?
+    @config.open_for_update
+
+    if @config.get(["remote", name, "url"])
+      @config.save
+      raise InvalidRemote, "remote #{ name } already exists."
+    end
+
+    @config.set(["remote", name, "url"], url)
+
+    branches.each do |branch|
+      source  = Refs::HEADS_DIR.join(branch)
+      target  = Refs::REMOTES_DIR.join(name, branch)
+      refspec = Refspec.new(source, target, true)
+
+      @config.add(["remote", name, "fetch"], refspec.to_s)
+    end
+
+    @config.save
+  end
+
+  def remove(name)
+    @config.open_for_update
+
+    unless @config.remove_section(["remote", name])
+      raise InvalidRemote, "No such remote: #{ name }"
+    end
+  ensure
+    @config.save
+  end
+
+  def list_remotes
+    @config.open
+    @config.subsections("remote")
+  end
+
+  def get(name)
+    @config.open
+    return nil unless @config.section?(["remote", name])
+
+    Remote.new(@config, name)
+  end
+
+  def get_upstream(branch)
+    @config.open
+    name = @config.get(["branch", branch, "remote"])
+    get(name)&.get_upstream(branch)
+  end
+
+  def set_upstream(branch, upstream)
+    list_remotes.each do |name|
+      ref = get(name).set_upstream(branch, upstream)
+      return [name, ref] if ref
+    end
+
+    raise InvalidBranch,
+      "Cannot setup tracking information; " +
+      "starting point '#{ upstream }' is not a branch"
+  end
+
+  def unset_upstream(branch)
+    @config.open_for_update
+    @config.unset(["branch", branch, "remote"])
+    @config.unset(["branch", branch, "merge"])
+    @config.save
+  end
+end

data/lib/remotes/protocol.rb

@@ -0,0 +1,82 @@
+class Remotes
+  class Protocol
+
+    attr_reader :input, :output
+
+    def initialize(command, input, output, capabilities = [])
+      @command = command
+      @input   = input
+      @output  = output
+
+      @input.sync = @output.sync = true
+
+      @caps_local  = capabilities
+      @caps_remote = nil
+      @caps_sent   = false
+    end
+
+    def capable?(ability)
+      @caps_remote&.include?(ability)
+    end
+
+    def send_packet(line)
+      return @output.write("0000") if line == nil
+
+      line = append_caps(line)
+
+      size = line.bytesize + 5
+      @output.write(size.to_s(16).rjust(4, "0"))
+      @output.write(line)
+      @output.write("\n")
+    end
+
+    def recv_packet
+      head = @input.read(4)
+      return head unless /[0-9a-f]{4}/ =~ head
+
+      size = head.to_i(16)
+      return nil if size == 0
+
+      line = @input.read(size - 4).sub(/\n$/, "")
+      detect_caps(line)
+    end
+
+    def recv_until(terminator)
+      loop do
+        line = recv_packet
+        break if line == terminator
+        yield line
+      end
+    end
+
+    private
+
+    def append_caps(line)
+      return line if @caps_sent
+      @caps_sent = true
+
+      sep   = (@command == "fetch") ? " " : "\0"
+      caps  = @caps_local
+      caps &= @caps_remote if @caps_remote
+
+      line + sep + caps.join(" ")
+    end
+
+    def detect_caps(line)
+      return line if @caps_remote
+
+      if @command == "upload-pack"
+        sep, n = " ", 3
+      else
+        sep, n = "\0", 2
+      end
+
+      parts = line.split(sep, n)
+      caps  = (parts.size == n) ? parts.pop : ""
+
+      @caps_remote = caps.split(/ +/)
+      parts.join(" ")
+    end
+
+  end
+end

data/lib/remotes/refspec.rb

@@ -0,0 +1,70 @@
+require "pathname"
+
+require_relative "../refs"
+require_relative "../revision"
+
+class Remotes
+
+  REFSPEC_FORMAT = /^(\+?)([^:]*)(:([^:]*))?$/
+
+  Refspec = Struct.new(:source, :target, :forced) do
+    def self.parse(spec)
+      match  = REFSPEC_FORMAT.match(spec)
+      source = canonical(match[2])
+      target = canonical(match[4]) || source
+
+      Refspec.new(source, target, match[1] == "+")
+    end
+
+    def self.canonical(name)
+      return nil if name.to_s == ""
+      return name unless Revision.valid_ref?(name)
+
+      first  = Pathname.new(name).each_filename.first
+      dirs   = [Refs::REFS_DIR, Refs::HEADS_DIR, Refs::REMOTES_DIR]
+      prefix = dirs.find { |dir| first == dir.basename.to_s }
+
+      (prefix&.dirname || Refs::HEADS_DIR).join(name).to_s
+    end
+
+    def self.expand(specs, refs)
+      specs = specs.map { |spec| parse(spec) }
+
+      specs.reduce({}) do |mappings, spec|
+        mappings.merge(spec.match_refs(refs))
+      end
+    end
+
+    def self.invert(specs, ref)
+      specs = specs.map { |spec| parse(spec) }
+
+      map = specs.reduce({}) do |mappings, spec|
+        spec.source, spec.target = spec.target, spec.source
+        mappings.merge(spec.match_refs([ref]))
+      end
+
+      map.keys.first
+    end
+
+    def match_refs(refs)
+      return { target => [source, forced] } unless source.to_s.include?("*")
+
+      pattern  = /^#{ source.sub("*", "(.*)") }$/
+      mappings = {}
+
+      refs.each do |ref|
+        next unless match = pattern.match(ref)
+        dst = match[1] ? target.sub("*", match[1]) : target
+        mappings[dst] = [ref, forced]
+      end
+
+      mappings
+    end
+
+    def to_s
+      spec = forced ? "+" : ""
+      spec + [source, target].join(":")
+    end
+  end
+
+end

data/lib/remotes/remote.rb

@@ -0,0 +1,57 @@
+require_relative "./refspec"
+
+class Remotes
+  class Remote
+
+    def initialize(config, name)
+      @config = config
+      @name   = name
+
+      @config.open
+    end
+
+    def fetch_url
+      @config.get(["remote", @name, "url"])
+    end
+
+    def fetch_specs
+      @config.get_all(["remote", @name, "fetch"])
+    end
+
+    def push_url
+      @config.get(["remote", @name, "pushurl"]) || fetch_url
+    end
+
+    def push_specs
+      @config.get_all(["remote", @name, "push"])
+    end
+
+    def uploader
+      @config.get(["remote", @name, "uploadpack"])
+    end
+
+    def receiver
+      @config.get(["remote", @name, "receivepack"])
+    end
+
+    def get_upstream(branch)
+      merge   = @config.get(["branch", branch, "merge"])
+      targets = Refspec.expand(fetch_specs, [merge])
+
+      targets.keys.first
+    end
+
+    def set_upstream(branch, upstream)
+      ref_name = Refspec.invert(fetch_specs, upstream)
+      return nil unless ref_name
+
+      @config.open_for_update
+      @config.set(["branch", branch, "remote"], @name)
+      @config.set(["branch", branch, "merge"], ref_name)
+      @config.save
+
+      ref_name
+    end
+
+  end
+end

data/lib/repository.rb

@@ -0,0 +1,64 @@
+require_relative "./config/stack"
+require_relative "./database"
+require_relative "./index"
+require_relative "./refs"
+require_relative "./remotes"
+require_relative "./workspace"
+
+require_relative "./repository/divergence"
+require_relative "./repository/hard_reset"
+require_relative "./repository/migration"
+require_relative "./repository/pending_commit"
+require_relative "./repository/status"
+
+class Repository
+  attr_reader :git_path
+
+  def initialize(git_path)
+    @git_path = git_path
+  end
+
+  def config
+    @config ||= Config::Stack.new(@git_path)
+  end
+
+  def database
+    @database ||= Database.new(@git_path.join("objects"))
+  end
+
+  def divergence(ref)
+    Divergence.new(self, ref)
+  end
+
+  def hard_reset(oid)
+    HardReset.new(self, oid).execute
+  end
+
+  def index
+    @index ||= Index.new(@git_path.join("index"))
+  end
+
+  def migration(tree_diff)
+    Migration.new(self, tree_diff)
+  end
+
+  def pending_commit
+    PendingCommit.new(@git_path)
+  end
+
+  def refs
+    @refs ||= Refs.new(@git_path)
+  end
+
+  def remotes
+    @remotes ||= Remotes.new(config.file(:local))
+  end
+
+  def status(commit_oid = nil)
+    Status.new(self, commit_oid)
+  end
+
+  def workspace
+    @workspace ||= Workspace.new(@git_path.dirname)
+  end
+end

data/lib/repository/divergence.rb

@@ -0,0 +1,21 @@
+require_relative "../merge/common_ancestors"
+
+class Repository
+  class Divergence
+
+    attr_reader :upstream, :ahead, :behind
+
+    def initialize(repo, ref)
+      @upstream = repo.remotes.get_upstream(ref.short_name)
+      return unless @upstream
+
+      left   = ref.read_oid
+      right  = repo.refs.read_ref(@upstream)
+      common = Merge::CommonAncestors.new(repo.database, left, [right])
+
+      common.find
+      @ahead, @behind = common.counts
+    end
+
+  end
+end

data/lib/repository/hard_reset.rb

@@ -0,0 +1,35 @@
+require "pathname"
+
+class Repository
+  class HardReset
+
+    def initialize(repo, oid)
+      @repo = repo
+      @oid  = oid
+    end
+
+    def execute
+      @status = @repo.status(@oid)
+      changed = @status.changed.map { |path| Pathname.new(path) }
+
+      changed.each { |path| reset_path(path) }
+    end
+
+    private
+
+    def reset_path(path)
+      @repo.index.remove(path)
+      @repo.workspace.remove(path)
+
+      entry = @status.head_tree[path.to_s]
+      return unless entry
+
+      blob = @repo.database.load(entry.oid)
+      @repo.workspace.write_file(path, blob.data, entry.mode, true)
+
+      stat = @repo.workspace.stat_file(path)
+      @repo.index.add(path, entry.oid, stat)
+    end
+
+  end
+end

data/lib/repository/inspector.rb

@@ -0,0 +1,49 @@
+class Repository
+  class Inspector
+
+    def initialize(repository)
+      @repo = repository
+    end
+
+    def trackable_file?(path, stat)
+      return false unless stat
+
+      return !@repo.index.tracked_file?(path) if stat.file?
+      return false unless stat.directory?
+
+      items = @repo.workspace.list_dir(path)
+      files = items.select { |_, item_stat| item_stat.file? }
+      dirs  = items.select { |_, item_stat| item_stat.directory? }
+
+      [files, dirs].any? do |list|
+        list.any? { |item_path, item_stat| trackable_file?(item_path, item_stat) }
+      end
+    end
+
+    def compare_index_to_workspace(entry, stat)
+      return :untracked unless entry
+      return :deleted unless stat
+      return :modified unless entry.stat_match?(stat)
+      return nil if entry.times_match?(stat)
+
+      data = @repo.workspace.read_file(entry.path)
+      blob = Database::Blob.new(data)
+      oid  = @repo.database.hash_object(blob)
+
+      unless entry.oid == oid
+        :modified
+      end
+    end
+
+    def compare_tree_to_index(item, entry)
+      return nil unless item or entry
+      return :added unless item
+      return :deleted unless entry
+
+      unless entry.mode == item.mode and entry.oid == item.oid
+        :modified
+      end
+    end
+
+  end
+end