jit 0.0.0 → 1.0.0

data/lib/pack/xdelta.rb

@@ -0,0 +1,118 @@
+module Pack
+  class XDelta
+
+    BLOCK_SIZE = 16
+
+    def self.create_index(source)
+      blocks = source.bytesize / BLOCK_SIZE
+      index  = {}
+
+      (0 ... blocks).each do |i|
+        offset = i * BLOCK_SIZE
+        slice  = source.byteslice(offset, BLOCK_SIZE)
+
+        index[slice] ||= []
+        index[slice].push(offset)
+      end
+
+      new(source, index)
+    end
+
+    def initialize(source, index)
+      @source = source
+      @index  = index
+    end
+
+    def compress(target)
+      @target = target
+      @offset = 0
+      @insert = []
+      @ops    = []
+
+      generate_ops while @offset < @target.bytesize
+      flush_insert
+
+      @ops
+    end
+
+    private
+
+    def generate_ops
+      m_offset, m_size = longest_match
+      return push_insert if m_size == 0
+
+      m_offset, m_size = expand_match(m_offset, m_size)
+
+      flush_insert
+      @ops.push(Delta::Copy.new(m_offset, m_size))
+    end
+
+    def longest_match
+      slice = @target.byteslice(@offset, BLOCK_SIZE)
+      return [0, 0] unless @index.has_key?(slice)
+
+      m_offset = m_size = 0
+
+      @index[slice].each do |pos|
+        remaining = remaining_bytes(pos)
+        break if remaining <= m_size
+
+        s = match_from(pos, remaining)
+        next if m_size >= s - pos
+
+        m_offset = pos
+        m_size   = s - pos
+      end
+
+      [m_offset, m_size]
+    end
+
+    def remaining_bytes(pos)
+      source_remaining = @source.bytesize - pos
+      target_remaining = @target.bytesize - @offset
+
+      [source_remaining, target_remaining, MAX_COPY_SIZE].min
+    end
+
+    def match_from(pos, remaining)
+      s, t = pos, @offset
+
+      while remaining > 0 and @source.getbyte(s) == @target.getbyte(t)
+        s, t  = s + 1, t + 1
+        remaining -= 1
+      end
+
+      s
+    end
+
+    def expand_match(m_offset, m_size)
+      while m_offset > 0 and @source.getbyte(m_offset - 1) == @insert.last
+        break if m_size == MAX_COPY_SIZE
+
+        @offset  -= 1
+        m_offset -= 1
+        m_size   += 1
+
+        @insert.pop
+      end
+
+      @offset += m_size
+      [m_offset, m_size]
+    end
+
+    def push_insert
+      @insert.push(@target.getbyte(@offset))
+      @offset += 1
+      flush_insert(MAX_INSERT_SIZE)
+    end
+
+    def flush_insert(size = nil)
+      return if size and @insert.size < size
+      return if @insert.empty?
+
+      @ops.push(Delta::Insert.new(@insert.pack("C*")))
+      @insert = []
+    end
+
+  end
+end

data/lib/pager.rb

@@ -0,0 +1,24 @@
+class Pager
+  PAGER_CMD = "less"
+  PAGER_ENV = { "LESS" => "FRX", "LV" => "-c" }
+
+  attr_reader :input
+
+  def initialize(env = {}, stdout = $stdout, stderr = $stderr)
+    env = PAGER_ENV.merge(env)
+    cmd = env["GIT_PAGER"] || env["PAGER"] || PAGER_CMD
+
+    reader, writer = IO.pipe
+    options = { :in => reader, :out => stdout, :err => stderr }
+
+    @pid   = Process.spawn(env, cmd, options)
+    @input = writer
+
+    reader.close
+  end
+
+  def wait
+    Process.waitpid(@pid) if @pid
+    @pid = nil
+  end
+end

data/lib/progress.rb

@@ -0,0 +1,78 @@
+class Progress
+  UNITS = ["B", "KiB", "MiB", "GiB"]
+  SCALE = 1024.0
+
+  def initialize(output)
+    @output  = output
+    @message = nil
+  end
+
+  def start(message, total = nil)
+    return if ENV["NO_PROGRESS"] or not @output.isatty
+
+    @message  = message
+    @total    = total
+    @count    = 0
+    @bytes    = 0
+    @write_at = get_time
+  end
+
+  def tick(bytes = 0)
+    return unless @message
+
+    @count += 1
+    @bytes  = bytes
+
+    current_time = get_time
+    return if current_time < @write_at + 0.05
+    @write_at = current_time
+
+    clear_line
+    @output.write(status_line)
+  end
+
+  def stop
+    return unless @message
+
+    @total = @count
+
+    clear_line
+    @output.puts(status_line)
+    @message = nil
+  end
+
+  private
+
+  def get_time
+    Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+
+  def clear_line
+    @output.write("\e[G\e[K")
+  end
+
+  def status_line
+    line = "#{ @message }: #{ format_count }"
+
+    line.concat(", #{ format_bytes }") if @bytes > 0
+    line.concat(", done.") if @count == @total
+
+    line
+  end
+
+  def format_count
+    if @total
+      percent = (@total == 0) ? 100 : 100 * @count / @total
+      "#{ percent }% (#{ @count }/#{ @total })"
+    else
+      "(#{ @count })"
+    end
+  end
+
+  def format_bytes
+    power  = Math.log(@bytes, SCALE).floor
+    scaled = @bytes / (SCALE ** power)
+
+    format("%.2f #{ UNITS[power] }", scaled)
+  end
+end

data/lib/refs.rb

@@ -0,0 +1,260 @@
+require "fileutils"
+require "pathname"
+
+require_relative "./lockfile"
+require_relative "./revision"
+
+class Refs
+  InvalidBranch = Class.new(StandardError)
+  StaleValue    = Class.new(StandardError)
+
+  SymRef = Struct.new(:refs, :path) do
+    def read_oid
+      refs.read_ref(path)
+    end
+
+    def head?
+      path == HEAD
+    end
+
+    def branch?
+      path.start_with?("refs/heads/")
+    end
+
+    def remote?
+      path.start_with?("refs/remotes/")
+    end
+
+    def short_name
+      refs.short_name(path)
+    end
+  end
+
+  Ref = Struct.new(:oid) do
+    def read_oid
+      oid
+    end
+  end
+
+  HEAD      = "HEAD"
+  ORIG_HEAD = "ORIG_HEAD"
+  SYMREF    = /^ref: (.+)$/
+
+  REFS_DIR    = Pathname.new("refs")
+  HEADS_DIR   = REFS_DIR.join("heads")
+  REMOTES_DIR = REFS_DIR.join("remotes")
+
+  def initialize(pathname)
+    @pathname     = pathname
+    @refs_path    = @pathname.join(REFS_DIR)
+    @heads_path   = @pathname.join(HEADS_DIR)
+    @remotes_path = @pathname.join(REMOTES_DIR)
+  end
+
+  def read_head
+    read_symref(@pathname.join(HEAD))
+  end
+
+  def update_head(oid)
+    update_symref(@pathname.join(HEAD), oid)
+  end
+
+  def set_head(revision, oid)
+    head = @pathname.join(HEAD)
+    path = @heads_path.join(revision)
+
+    if File.file?(path)
+      relative = path.relative_path_from(@pathname)
+      update_ref_file(head, "ref: #{ relative }")
+    else
+      update_ref_file(head, oid)
+    end
+  end
+
+  def read_ref(name)
+    path = path_for_name(name)
+    path ? read_symref(path) : nil
+  end
+
+  def update_ref(name, oid)
+    update_ref_file(@pathname.join(name), oid)
+  end
+
+  def compare_and_swap(name, old_oid, new_oid)
+    path = @pathname.join(name)
+
+    update_ref_file(path, new_oid) do
+      unless old_oid == read_symref(path)
+        raise StaleValue, "value of #{ name } changed since last read"
+      end
+    end
+  end
+
+  def create_branch(branch_name, start_oid)
+    path = @heads_path.join(branch_name)
+
+    unless Revision.valid_ref?(branch_name)
+      raise InvalidBranch, "'#{ branch_name }' is not a valid branch name."
+    end
+
+    if File.file?(path)
+      raise InvalidBranch, "A branch named '#{ branch_name }' already exists."
+    end
+
+    FileUtils.mkdir_p(path.dirname)
+    update_ref_file(path, start_oid)
+  end
+
+  def delete_branch(branch_name)
+    path = @heads_path.join(branch_name)
+
+    lockfile = Lockfile.new(path)
+    lockfile.hold_for_update
+
+    oid = read_symref(path)
+    raise InvalidBranch, "branch '#{ branch_name }' not found." unless oid
+
+    File.unlink(path)
+    oid
+  ensure
+    lockfile.rollback
+  end
+
+  def current_ref(source = HEAD)
+    ref = read_oid_or_symref(@pathname.join(source))
+
+    case ref
+    when SymRef   then current_ref(ref.path)
+    when Ref, nil then SymRef.new(self, source)
+    end
+  end
+
+  def list_all_refs
+    [SymRef.new(self, HEAD)] + list_refs(@refs_path)
+  end
+
+  def list_branches
+    list_refs(@heads_path)
+  end
+
+  def list_remotes
+    list_refs(@remotes_path)
+  end
+
+  def reverse_refs
+    table = Hash.new { |hash, key| hash[key] = [] }
+
+    list_all_refs.each do |ref|
+      oid = ref.read_oid
+      table[oid].push(ref) if oid
+    end
+
+    table
+  end
+
+  def short_name(path)
+    path = @pathname.join(path)
+
+    prefix = [@remotes_path, @heads_path, @pathname].find do |dir|
+      path.dirname.ascend.any? { |parent| parent == dir }
+    end
+
+    path.relative_path_from(prefix).to_s
+  end
+
+  def long_name(ref)
+    path = path_for_name(ref)
+    return path.relative_path_from(@pathname).to_s if path
+
+    raise InvalidBranch,
+      "the requested upstream branch '#{ ref }' does not exist"
+  end
+
+  private
+
+  def list_refs(dirname)
+    names = Dir.entries(dirname) - [".", ".."]
+
+    names.map { |name| dirname.join(name) }.flat_map do |path|
+      if File.directory?(path)
+        list_refs(path)
+      else
+        path = path.relative_path_from(@pathname)
+        SymRef.new(self, path.to_s)
+      end
+    end
+
+  rescue Errno::ENOENT
+    []
+  end
+
+  def path_for_name(name)
+    prefixes = [@pathname, @refs_path, @heads_path, @remotes_path]
+    prefix   = prefixes.find { |path| File.file? path.join(name) }
+
+    prefix ? prefix.join(name) : nil
+  end
+
+  def read_oid_or_symref(path)
+    data  = File.read(path).strip
+    match = SYMREF.match(data)
+
+    match ? SymRef.new(self, match[1]) : Ref.new(data)
+  rescue Errno::ENOENT
+    nil
+  end
+
+  def read_symref(path)
+    ref = read_oid_or_symref(path)
+
+    case ref
+    when SymRef then read_symref(@pathname.join(ref.path))
+    when Ref    then ref.oid
+    end
+  end
+
+  def update_ref_file(path, oid)
+    lockfile = Lockfile.new(path)
+
+    lockfile.hold_for_update
+    yield if block_given?
+
+    if oid
+      write_lockfile(lockfile, oid)
+    else
+      File.unlink(path) rescue Errno::ENOENT
+      lockfile.rollback
+    end
+
+  rescue Lockfile::MissingParent
+    FileUtils.mkdir_p(path.dirname)
+    retry
+  rescue => error
+    lockfile.rollback
+    raise error
+  end
+
+  def update_symref(path, oid)
+    lockfile = Lockfile.new(path)
+    lockfile.hold_for_update
+
+    ref = read_oid_or_symref(path)
+
+    unless ref.is_a?(SymRef)
+      write_lockfile(lockfile, oid)
+      return ref&.oid
+    end
+
+    begin
+      update_symref(@pathname.join(ref.path), oid)
+    ensure
+      lockfile.rollback
+    end
+  end
+
+  def write_lockfile(lockfile, oid)
+    lockfile.write(oid)
+    lockfile.write("\n")
+    lockfile.commit
+  end
+end