module Amp
module Repositories
##
# An entry in the dirstate. Similar to IndexEntry for revlogs. Simple struct, that's
# all.
class DirStateEntry < Struct.new(:status, :mode, :size, :mtime)
##
# shortcuts!
def removed?; self.status == :removed; end
def added?; self.status == :added; end
def untracked?; self.status == :untracked; end
def modified?; self.status == :modified; end
def merged?; self.status == :merged; end
def normal?; self.status == :normal; end
def forgotten?; self.status == :forgotten; end
##
# Do I represent a dirty object?
#
# @return [Boolean] does this array represent a dirty object in a DirState?
def dirty?
self[-2] == -2 && self[-1] == -1 && self.normal?
end
##
# Do I possibly represent a dirty object?
#
# @return [Boolean] does this array possibly represent a dirty object in a DirState?
def maybe_dirty?
self[-2] == -1 && self[-1] == -1 && self.normal?
end
end
##
# = DirState
# This class handles parsing and manipulating the "dirstate" file, which is stored
# in the .hg folder. This file handles which files are marked for addition, removal,
# copies, and so on. The structure of each entry is below.
#
#
# class DirStateEntry < BitStruct
# default_options :endian => :network
#
# char :status , 8, "the state of the file"
# signed :mode , 32, "mode"
# signed :size , 32, "size"
# signed :mtime , 32, "mtime"
# signed :fname_size , 32, "filename size"
#
# end
class DirState
include Ignore
include RevlogSupport::Node
UNKNOWN = DirStateEntry.new(:untracked, 0, 0, 0)
FORMAT = "cNNNN"
class FileNotInRootError < StandardError; end
class AbsolutePathNeededError < StandardError; end
# The parents of the current state. If there's been an uncommitted merge,
# it will be two. Otherwise it will just be one parent and +NULL_ID+
attr_reader :parents
# The number of directories in each base ["dir" => #_of_dirs]
attr_reader :dirs
# The files mapped to their stats (state, mode, size, mtime)
# [state, mode, size, mtime]
attr_reader :files
# A map of files to be copied, because we want to preserve their history
# "source" => "dest"
attr_reader :copy_map
# I still don't know what this does
attr_reader :folds
# The conglomerate config object of global configs and the repo
# specific config.
attr_reader :config
# The root of the repository
attr_reader :root
# The opener to access files. The only files that will be touched lie
# in the .hg/ directory, so the default MUST be +:open_hg+.
attr_reader :opener
##
# Creates a DirState object. This is used to represent, in memory (and
# occasionally on file) how the repository is being changed.
# It's really simple, and it is really the basis for _using_ the repo
# (contrary to how Revlog is the basis for _saving_ the repo).
#
# @param [String] root the absolute path to the root of the repository
# @param [Amp::AmpConfig] config the config file of hgrc
# @param [Amp::Opener] opener the opener to open files with
def initialize(root, config, opener)
unless root[0, 1] == "/"
raise AbsolutePathNeededError, "#{root} is not an absolute path!"
end
# root must be an aboslute path with no ending slash
@root = root[-1, 1] == "/" ? root[0..-2] : root # the root of the repo
@config = config # the config file where we get defaults
@opener = opener # opener to retrieve files (default: open_hg)
@dirty = false # has something changed, and do we need to write?
@dirty_parents = false
@parents = [NULL_ID, NULL_ID] # the parent revisions
@dirs = {} # number of directories in each base ["dir" => #_of_dirs]
@files = {} # the files mapped to their statistics
@copy_map = {} # src => dest
@ignore = [] # dirs and files to ignore
@folds = []
@check_exec = nil
generate_ignore
end
##
# Retrieve a file's status from +@files+. If it's not there
# then return :untracked
#
# @param [String] key the path of the file
# @return [Symbol] status of the file, either :removed, :added, :untracked,
# :merged, :normal, :forgotten, or :untracked
def [](key)
lookup = @files[key]
lookup || DirStateEntry.new(:untracked)
end
##
# Determine if +path+ is a link or an executable.
#
# @param [String] path the path to the file
# @return [String] either 'l' for a link and 'x' for an executable. Returns
# '' if neither
def flags(path)
return 'l' if File.ftype(path) == 'link'
return 'x' if File.executable? path
''
end
##
# just a lil' reader to find if the repo is dirty or not
# by dirty i mean "no longer in sync with the cache"
#
# @return [Boolean] is the dirstate no longer in sync with the cache located
# at .hg/branch.cache
def dirty?
@dirty
end
##
# The directories and path matches that we're ignoringzorz. It will call
# the ignorer generated by .hgignore, but only if @ignore_all is nil (really
# only if @ignore_all isn't a Boolean value, but we set it to nil)
#
# @param [String] file the path to the file that will be checked by
# the .hgignore file
# @return [Boolean] whether we're ignoring the path or not
def ignore(file)
return true if @ignore_all == true
return false if @ignore_all == false
@ignore_matches ||= parse_ignore @root, @ignore
@ignore_matches.call file
end
##
# Gets the current branch.
#
# @return [String] the current branch in the working directory
def branch
text = @opener.read('branch').strip
@branch ||= text.empty? ? "default" : text
rescue
@branch = "default"
end
##
# Set the branch to +branch+.
#
# @param [#to_s] brnch the branch to switch to
# @return [String] +brnch+.to_s
def branch=(brnch)
@branch = brnch.to_s
@opener.open 'branch', 'w' do |f|
f.puts brnch.to_s
end
@branch
end
##
# Set the parents to +p+
#
# @param [Array<String>] p the parents as binary strings
# @return [Array<String>] the parents, as will be used by the dirstate
def parents=(p)
@parents = if p.is_a? Array
p.size == 1 ? p + [NULL_ID] : p[0..1]
else
[p, NULL_ID]
end
@dirty_parents = true
@dirty = true
@parents # return this
end
alias_method :parent, :parents
##
# Set the file as "to be added".
#
# @param [String] file the path of the file to add
# @return [Boolean] a success marker
def add(file)
add_path file, true
@dirty = true
@files[file] = DirStateEntry.new(:added, 0, -1, -1)
@copy_map.delete file
true # success
end
##
# Set the file as "normal", meaning no changes. This is the same
# as dirstate.normal in dirstate.py, for those referencing both.
#
# @param [String] file the path of the file to clean
# @return [Boolean] a success marker
def normal(file)
@dirty = true
add_path file, true
f = File.lstat "#{@root}/#{file}"
@files[file] = DirStateEntry.new(:normal, f.mode, f.size, f.mtime.to_i)
@copy_map.delete file
true # success
end
alias_method :clean, :normal
##
# Set the file as normal, but possibly dirty. It's like when you
# meet a cool girl, and she seems really innocent and it's a chance
# for you to maybe change yourself and make a new friend, but then
# she *might* actually be a total slut. Better milk that grapevine
# to find out the truth. Oddly specific, huh.
#
# THUS IS THE HISTORY OF THIS METHOD!
#
# And then one day you go to the movies with some other girl, and the
# original crazy slutty girl is the cashier next to you. Unsure of
# what to do, you don't do anything. Next thing you know, she's trying
# to get your attention to say hey. WTF? Anyone know what's up with this
# girl?
#
# After milking that grapevine, you find out that she's not a great person.
# There's nothing interesting there and you should just move on.
#
# *sigh* girls.
#
# @param [String] file the path of the file to mark
# @return [Boolean] a success marker
def maybe_dirty(file)
if @files[file] && @parents.last != NULL_ID
# if there's a merge happening and the file was either modified
# or dirty before being removed, restore that state.
# I'm quoting the python with that one.
# I guess what it's saying is that if a file is being removed
# by a merge, but it was altered somehow beforehand on the local
# repo, then play it safe and bring back the dead. Divine intervention
# on the side of the local repo.
# info here is a standard array of info
# [action, mode, size, mtime]
info = @files[file]
if info.removed? and [-1, -2].member? info.size
source = @copy_map[file]
# do the appropriate action
case info.size
when -1 # either merge it
merge file
when -2 # or mark it as dirty
dirty file
end
copy source => file if source
return
end
# next step... the base case!
return true if info.modified? || info.maybe_dirty? and info.size == -2
end
@dirty = true # make the repo dirty
add_path file # add the file
@files[file] = DirStateEntry.new(:normal, 0, -1, -1) # give it info
@copy_map.delete file # we're not copying it since we're adding it
true # success
end
##
# Checks whether the dirstate is tracking the given file.
#
# @param f the file to check for
# @return [Boolean] whether or not the file is being tracked.
def include?(path)
not @files[path].nil?
end
alias_method :tracking?, :include?
##
# Mark the file as "dirty"
#
# @param [String] file the path of the file to mark
# @return [Boolean] a success marker
def dirty(file)
@dirty = true
add_path file
@files[file] = DirStateEntry.new(:normal, 0, -2, -1)
@copy_map.delete file
true # success
end
##
# Set the file as "to be removed"
#
# @param [String] file the path of the file to remove
# @return [Boolean] a success marker
def remove(file)
@dirty = true
drop_path file
size = 0
if @parents.last.null? && (info = @files[file])
if info.merged?
size = -1
elsif info.normal? && info.size == -2
size = -2
end
end
@files[file] = DirStateEntry.new(:removed, 0, size, 0)
@copy_map.delete file if size.zero?
true # success
end
##
# Prepare the file to be merged
#
# @param [String] file the path of the file to merge
# @return [Boolean] a success marker
def merge(file)
@dirty = true
add_path file
stats = File.lstat "#{@root}/#{file}"
add_path file
@files[file] = DirStateEntry.new(:merged, stats.mode, stats.size, stats.mtime.to_i)
@copy_map.delete file
true # success
end
##
# Forget the file, erase it from the repo
#
# @param [String] file the path of the file to forget
# @return [Boolean] a success marker
def forget(file)
@dirty = true
drop_path file
@files.delete file
true # success
end
##
# Invalidates the dirstate, making it completely unusable until it is
# re-read. Should only be used in error situations.
def invalidate!
%w(@files @copy_map @folds @branch @parents @dirs @ignore).each do |ivar|
instance_variable_set(ivar, nil)
end
@dirty = false
end
##
# Refresh the directory's state, making everything empty.
# Called by #rebuild.
#
# This is not the same as #initialize, so we can't just run
# `send :initialize` and call it a day :-(
#
# @return [Boolean] a success marker
def clear
@files = {}
@dirs = {}
@copy_map = {}
@parents = [NULL_ID, NULL_ID]
@dirty = true
true # success
end
##
# Rebuild the directory's state. Needs Manifest, as that's
# what the files really are.
#
# @param [String] parent the binary format of the parent
# @param [ManifestEntry] files the files in a specific revision
# @return [Boolean] a success marker
def rebuild(parent, files)
clear
# alter each file according to its flags
files.each do |f|
mode = files.flags(f).include?('x') ? 0777 : 0666
@files[f] = DirStateEntry.new(:normal, mode, -1, 0)
end
@parents = [parent, NULL_ID]
@dirty_parents = true
true # success
end
##
# Save the data to .hg/dirstate.
# Uses mode: "w", so it overwrites everything
#
# @todo watch memory usage - +si+ could grow unrestrictedly which would
# bog down the entire program
# @return [Boolean] a success marker
def write
return true unless @dirty
begin
@opener.open "dirstate", 'w' do |state|
gran = @config['dirstate']['granularity'] || 1 # self._ui.config('dirstate', 'granularity', 1)
limit = 2147483647 # sorry for the literal use...
limit = state.mtime - gran if gran > 0
si = StringIO.new "", (ruby_19? ? "w+:ASCII-8BIT" : "w+")
si.write @parents.join
@files.each do |file, info|
file = file.dup # so we don't corrupt vars
info = info.dup.to_a # UNLIKE PYTHON
info[0] = info[0].to_hg_int
# I should probably do mah physics hw. nah, i'll do it
# tomorrow during my break
# good news - i did pretty well on my physics test by using
# brian ford's name instead of my own.
file = "#{file}\0#{@copy_map[file]}" if @copy_map[file]
info = [info[0], 0, (-1).to_signed(32), (-1).to_signed(32)] if info[3].to_i > limit.to_i and info[0] == :normal
info << file.size # the final element to make it pass, which is the length of the filename
info = info.pack FORMAT # pack them their lunch
si.write info # and send them off
si.write file # to school
end
state.write si.string
@dirty = false
@dirty_parents = false
true # success
end
rescue IOError
false
end
end
##
# Copies the files in h (represented as "source" => "dest").
#
# @param [Hash<String => String>] h the keys are sources and the values
# are dests
# @return [Boolean] a success marker
def copy(h={})
h.each do |source, dest|
next if source == dest
return true unless source
@dirty = true
if @copy_map[dest]
then @copy_map.delete dest
else @copy_map[dest] = source
end
end
true # success
end
##
# The current directory from where the command is being called, with
# the path shortened if it's within the repo.
#
# @return [String] effectively Dir.pwd
def cwd
path = Dir.pwd
return '' if path == @root
# return a more local path if possible...
return path[@root.length..-1] if path.start_with? @root
path # else we're outside the repo
end
alias_method :pwd, :cwd
##
# Returns the relative path from +src+ to +dest+.
#
# @param [String] src This is a directory! If this is relative,
# it is assumed to be relative to the root.
# @param [String] dest This MUST be within root! It also is a file.
# @return [String] the relative path
def path_to(src, dest)
# first, make both paths absolute, for ease of use.
# @root is guarenteed to be absolute, so we're leethax here
src = File.join @root, src
dest = File.join @root, dest
# lil' bit of error checking...
[src, dest].map do |f|
unless File.exist? f # does both files and directories...
raise FileNotInRootError, "#{f} is not in the root, #{@root}"
end
end
# now we find the differences
# these both are now arrays!!!
src = src.split '/'
dest = dest.split '/'
while src.first == dest.first
src.shift and dest.shift
end
# now, src and dest are just where they differ
path = ['..'] * src.size # we want to go back this many directories
path += dest
path.join '/' # tadah!
end
##
# Walk recursively through the directory tree, finding all
# files matched by the regexp in match.
#
# Step 1: find all explicit files
# Step 2: visit subdirectories
# Step 3: report unseen items in the @files hash
#
# @param [Boolean] unknown
# @param [Boolean] ignored
# @return [Hash<String => [NilClass, File::Stat]>] nil for directories and
# stuff, File::Stat for files and links
def walk(unknown, ignored, match)
files = match.files
bad_type = proc do |file|
UI::warn "#{file}: unsupported file type (type is #{File.ftype file})"
end
if ignored
@ignore_all = false
elsif not unknown
@ignore_all = true
end
work = [@root]
files = match.files ? match.files.uniq : [] # because [].uniq! is a major fuckup
# why do we overwrite the entire array if it includes the current dir?
# we even kill posisbly good things
files = [''] if files.empty? || files.include?('.') # strange thing to do
results = {'.hg' => true}
# Step 1: find all explicit files
files.sort.each do |file|
next if results[file] || file == ""
begin
stats = File.lstat File.join(@root, file)
kind = File.ftype File.join(@root, file)
# we'll take it! but only if it's a directory, which means we have
# more work to do...
if kind == 'directory'
# add it to the list of dirs we have to search in
work << File.join(@root, file) unless ignoring_directory? file
elsif kind == 'file' || kind == 'link'
# ARGH WE FOUND ZE BOOTY
results[file] = stats
else
# user you are a fuckup in life please exit the world
bad_type[file]
results[file] = nil if @files[file]
end
rescue => e
keep = false
prefix = file + '/'
@files.each do |f, _|
if f == file || f.start_with?(prefix)
keep = true
break
end
end
unless keep
bad_type[file]
results[file] = nil if (@files[file] || !ignore(file)) && match.call(file)
end
end
end
# step 2: visit subdirectories in `work`
until work.empty?
dir = work.shift
skip = nil
if dir == '.'
dir = ''
else
skip = '.hg'
end
dirs = Dir.glob("#{dir}/*", File::FNM_DOTMATCH) - ["#{dir}/.", "#{dir}/.."]
entries = dirs.inject({}) do |h, f|
h.merge f => [File.ftype(f), File.lstat(f)]
end
entries.each do |f, arr|
tf = f[(@root.size+1)..-1]
kind = arr[0]
stats = arr[1]
unless results[tf]
if kind == 'directory'
work << f unless ignore tf
results[tf] = nil if @files[tf] && match.call(tf)
elsif kind == 'file' || kind == 'link'
if @files[tf]
results[tf] = stats if match.call tf
elsif match.call(tf) && !ignore(tf)
results[tf] = stats
end
elsif @files[tf] && match.call(tf)
results[tf] = nil
end
end
end
end
# step 3: report unseen items in @files
visit = @files.keys.select {|f| !results[f] && match.call(f) }.sort
# zip it to a hash of {file_name => file_stats}
hash = visit.inject({}) do |h, f|
h.merge!(f => File.stat(File.join(@root,f))) rescue h.merge!(f => nil)
end
hash.each do |file, stat|
unless stat.nil?
# because filestats can't be gathered if it's, say, a directory
stat = nil unless ['file', 'link'].include? File.ftype(File.join(@root, file))
end
results[file] = stat
end
results.delete ".hg"
@ignore_all = nil # reset this
results
end
##
# what's the current state of life, man!
# Splits up all the files into modified, clean,
# added, deleted, unknown, ignored, or lookup-needed.
#
# @return [Hash<Symbol => Array<String>>] a hash of the filestatuses and their files
def status(ignored, clean, unknown, match = Match.new { true })
list_ignored, list_clean, list_unknown = ignored, clean, unknown
lookup, modified, added, unknown, ignored = [], [], [], [], []
removed, deleted, clean = [], [], []
delta = 0
walk(list_unknown, list_ignored, match).each do |file, st|
next if file.nil?
unless @files[file]
if list_ignored && ignoring_directory?(file)
ignored << file
elsif list_unknown
unknown << file unless ignore(file)
end
next # on to the next one, don't do the rest
end
# here's where we split up the files
state, mode, size, time = *@files[file].to_a
delta += (size - st.size).abs if st && size >= 0 # increase the delta, but don't forget to check that it's not nil
if !st && [:normal, :modified, :added].include?(state)
# add it to the deleted folder if it should be here but isn't
deleted << file
elsif state == :normal
if (size >= 0 && (size != st.size || ((mode ^ st.mode) & 0100 and @check_exec))) || size == -2 || @copy_map[file]
modified << file
elsif time != st.mtime.to_i # DOH - we have to remember that times are stored as fixnums
lookup << file
elsif list_clean
clean << file
end
elsif state == :merged
modified << file
elsif state == :added
added << file
elsif state == :removed
removed << file
end
end
r = { :modified => modified.sort , # those that have clearly been modified
:added => added.sort , # those that are marked for adding
:removed => removed.sort , # those that are marked for removal
:deleted => deleted.sort , # those that should be here but aren't
:unknown => unknown.sort , # those that aren't being tracked
:ignored => ignored.sort , # those that are being deliberately ignored
:clean => clean.sort , # those that haven't changed
:lookup => lookup.sort , # those that need to be content-checked to see if they've changed
:delta => delta # how many bytes have been added or removed from files (not bytes that have been changed)
}
end
##
# Reads the data in the .hg folder and fills in the vars
#
# @return [Amp::DirState] self -- chainable!
def read!
@parents, @files, @copy_map = parse('dirstate')
self # chainable
end
private
##
# Generates the @ignore array
# The array is full of paths relative to the root, which
# makes things easier for the proc-generation phase.
#
# @return [NilClass]
def generate_ignore
@ignore = @config['ui'].map do |k, v|
@ignore << "#{v}" if k == "ignore"
end
@ignore << ".hgignore"
@ignore.compact
nil
end
##
# Perform various checks on the file before upping the content count
# for all of its parent directories. It checks for:
# * filenames containing "\n" or "\r" (newlines and carriage returns)
# * filenames with the same names as directories
# * clashing filenames
#
# It only increments the dirs' file count if the file is untracked or
# being removed.
#
# @param [String] f Should be formatted like ["action", mode, size, mtime]
# @param [Boolean] check whether to perform any of the checks
# @return [NilClass]
def add_path(f, check=false)
old_state = @files[f] || DirStateEntry.new # it's an array of info, remember
if check || old_state.removed?
raise "Bad Filename" if f.match(/\r|\n/)
raise "Directory #{f} already exists" if @dirs[f]
# make sure we don't have any files with the same name as a directory
directories_to(f).each do |d|
break if @dirs[d]
if @files[d] && !@files[d].removed?
raise "File #{d} clashes with #{f}! Fix their names"
end
end
end
# only inc the dirs if the file is untracked or being removed.
if [:untracked, :removed].include? old_state.status
# inc the number of dirs in each dir
inc_directories_to f
end
nil
end
##
# Conditional wrapper around +dec_directories_to+. It will dec the
# directories if the file in question (+f+) is either untracked or
# being removed.
#
# @param [String] f Should be formatted like ["action", mode, size, mtime]
# @return [NilClass]
def drop_path(f)
unless [:untracked, :removed].include? f[0]
dec_directories_to(f)
end
nil
end
##
# All directories leading up to this path
#
# @example directories_to "/Users/ari/src/monkey.txt" # =>
# ["/Users/ari/src", "/Users/ari", "/Users"]
# @param [String] path the path to the file we're examining
# @return [Array] the directories leading up to this path
def directories_to(path)
File.amp_directories_to path
end
##
# Increment all directories' dir-count leading up to this path.
# The dir-count is the path's value in @dirs.
# This is used when adding a file.
#
# @param [String] path the path we're disecting
# @return [NilClass]
def inc_directories_to(path)
p = directories_to(path).first
@dirs[p] ||= 0
@dirs[p] += 1
nil
end
##
# Decrement all directories' dir-count leading up to this path.
# The dir-count is the path's value in @dirs.
# This is used when removing a file.
#
# @param [String] path the path we're disecting
# @return [NilClass]
def dec_directories_to(path)
p = directories_to(path).first
# if the dir has 0, kill the dir. we don't need it anymore
if @dirs[p] && @dirs[p].zero?
@dirs.delete p
elsif @dirs[p]
@dirs[p] -= 1 # we only need to inc the latest dir
end
nil
end
##
# I wish I knew what this did or when it was called.
#
# @todo figure out what this does
# @param [String] path the path to a file
# @return [String] All I know is that this returns a string
def normalize(path)
fold_path = @folds[path]
fold_path = path unless fold_path # if fold_path is true, then this line returns nil
fold_path # so we need an extra line here to make sure it returns a good value
end
##
# Are we ignoring the directory?
#
# @param [String] dir the directory we're checking, either aboslute or relative
# @return [Boolean] are we ignoring the dir?
def ignoring_directory?(dir)
return true if @ignore_all
return false if @ignore_all == false
return false if dir == '.' # base cases
return true if ignore dir # base cases
!!directories_to(dir).any? {|d| ignore d }
end
alias_method :ignoring_dir?, :ignoring_directory?
##
# Parses the dirstate file in .hg
#
# @param [String] file path to the file to parse
# @return [((String, String), Hash<String => (Integer, Integer, Integer)>, Hash<String => String>)]
# a tuple of (parents, files, copies). Parents is a tuple of the parents,
# files is a hash of filename => [mode, size, mtime], and copies is a hash of src => dest
def parse(file)
# the main data we need to return
files = {}
copies = {}
parents = []
@opener.open file, "r" do |s|
# the parents are the first 40 bytes
parent = s.read(20) || NULL_ID
parent_ = s.read(20) || NULL_ID
parents = [parent, parent_]
# 1 character + 4 32-bit ints = 17 bytes
e_size = 17
# this loop is just cycling through and reading every entry
while !s.eof?
# read 1 entry
info = s.read(e_size).unpack FORMAT
# byte swap and shizzle
info = [info[0].to_dirstate_symbol, info[1], info[2].to_signed(32), info[3].to_signed(32), info[4]]
# ^^^^ we have to sign them because otherwise they'll be hugely wrong
# read in the filename
f = s.read(info[4])
# if it has an \0, then we've moved/copied it
if f.match(/\0/)
source, dest = f.split "\0"
copies[source] = dest
f = source
end
# and put in the info for the file itself
files[f] = DirStateEntry.new(*info[0..3])
end
end
[parents, files, copies]
rescue Errno::ENOENT
# no file? easy peasy
[[NULL_ID, NULL_ID], {}, {}]
end
end
end
end