def __setstate__(self, state_dict):
del state_dict['__type__']
del state_dict['__module__']
# Store strings in native str type.
for key in state_dict:
if isinstance(state_dict[key], (six.string_types, six.text_type)):
state_dict[key] = str(S(state_dict[key]))
self.__dict__ = state_dict
def populate_files_table(self):
self.files_table.clear()
for item in self.items:
self.files_table.append([
True,
S(item.path), item.path,
helper.get_file_extension(item.path)
])
def on_mergerange_prepare(self):
if not hasattr(self, "mergerange_repos"):
self.mergerange_repos = rabbitvcs.ui.widget.ComboBox(
self.get_widget("mergerange_from_urls"), self.repo_paths)
self.mergerange_repos.set_child_text(self.root_url)
self.get_widget("mergerange_working_copy").set_text(
S(self.path).display())
self.mergerange_check_ready()
def __getstate__(self):
attrs = self.__dict__.copy()
# Force strings to Unicode to avoid json implicit conversion.
for key in attrs:
if isinstance(attrs[key], (six.string_types, six.text_type)):
attrs[key] = S(attrs[key]).unicode()
attrs['__type__'] = type(self).__name__
attrs['__module__'] = type(self).__module__
return attrs
def show_add(self):
self.state = STATE_ADD
revision = "HEAD"
if self.revision:
active_branch = self.git.get_active_branch()
if active_branch:
revision = S(active_branch.name)
self.items_treeview.unselect_all()
self.branch_entry.set_text("")
self.save_button.set_label(_("Add"))
self.start_point_entry.set_text(S(revision).display())
self.track_checkbox.set_active(True)
self.checkout_checkbox.set_sensitive(True)
self.checkout_checkbox.set_active(False)
self.show_rows(self.add_rows)
self.get_widget("detail_label").set_markup(_("<b>Add Branch</b>"))
def __init__(self, path, vcs=None, claim_domain=True):
rabbitvcs.ui.GtkBuilderWidgetWrapper.__init__(self,
claim_domain=claim_domain)
self.path = path
self.vcs = vcs or rabbitvcs.vcs.VCS()
self.checker = StatusChecker()
self.get_widget("file_name").set_text(S(os.path.basename(path)).display())
self.status = self.checker.check_status(path,
recurse = False,
invalidate = False,
summary = False)
self.get_widget("vcs_type").set_text(S(self.status.vcs_type).display())
self.get_widget("content_status").set_text(S(self.status.simple_content_status()).display())
self.get_widget("prop_status").set_text(S(self.status.simple_metadata_status()).display())
self.set_icon_from_status(self.get_widget("content_status_icon"),
self.status.simple_content_status())
self.set_icon_from_status(self.get_widget("prop_status_icon"),
self.status.simple_metadata_status())
self.set_icon_from_status(self.get_widget("vcs_icon"),
self.status.single, Gtk.IconSize.DIALOG)
additional_info = self.get_additional_info()
if additional_info:
additional_props_table = rabbitvcs.ui.widget.KeyValueTable(
additional_info)
additional_props_table.show()
file_info_table = rabbitvcs.ui.widget.Box(self.get_widget("file_info_table"), vertical = True)
file_info_table.pack_start(additional_props_table,
expand=False,
fill=False,
padding=0)
def view_selected_diff(self, sidebyside=False):
for row in self.selected_rows:
url1 = self.changes_table.get_row(row)[0]
url2 = url1
if url1 == ".":
url1 = ""
url2 = ""
url1 = helper.url_join(self.first_urls.get_active_text(), url1)
url2 = helper.url_join(self.second_urls.get_active_text(), url2)
rev1 = self.get_first_revision()
rev2 = self.get_second_revision()
helper.launch_ui_window("diff", [
"%s@%s" % (url1, S(rev1)),
"%s@%s" % (url2, S(rev2)),
"%s" % (sidebyside and "-s" or ""),
"--vcs=%s" % self.get_vcs_name()
])
def compare_working_copy(self, widget, data=None):
path_older = self.path
if self.vcs_name == rabbitvcs.vcs.VCS_SVN:
path_older = self.vcs.svn().get_repo_url(self.path)
helper.launch_ui_window("diff", [
"-s",
"%s@%s" % (path_older, S(self.revisions[0])), self.path,
"--vcs=%s" % self.caller.get_vcs_name()
])
def populate_files_table(self):
self.files_table.clear()
for item in self.items:
self.files_table.append([
True,
S(item.path), item.path,
helper.get_file_extension(item.path),
item.simple_content_status(),
item.simple_metadata_status()
])
def __init__(self, paths, base_dir=None, message=None):
"""
@type paths: list of strings
@param paths: A list of local paths.
"""
InterfaceView.__init__(self, "commit", "Commit")
self.base_dir = base_dir
self.vcs = rabbitvcs.vcs.VCS()
self.items = []
self.files_table = rabbitvcs.ui.widget.Table(
self.get_widget("files_table"), [
GObject.TYPE_BOOLEAN, rabbitvcs.ui.widget.TYPE_HIDDEN_OBJECT,
rabbitvcs.ui.widget.TYPE_PATH, GObject.TYPE_STRING,
rabbitvcs.ui.widget.TYPE_STATUS, GObject.TYPE_STRING
], [
rabbitvcs.ui.widget.TOGGLE_BUTTON, "",
_("Path"),
_("Extension"),
_("Text Status"),
_("Property Status")
],
filters=[{
"callback": rabbitvcs.ui.widget.path_filter,
"user_data": {
"base_dir": base_dir,
"column": 2
}
}],
callbacks={
"row-activated": self.on_files_table_row_activated,
"mouse-event": self.on_files_table_mouse_event,
"key-event": self.on_files_table_key_event,
"row-toggled": self.on_files_table_toggle_event
},
flags={
"sortable": True,
"sort_on": 2
})
self.files_table.allow_multiple()
self.get_widget("toggle_show_unversioned").set_active(
self.SHOW_UNVERSIONED)
if not message:
message = self.SETTINGS.get_multiline("general",
"default_commit_message")
self.message = rabbitvcs.ui.widget.TextView(self.get_widget("message"),
message)
self.paths = []
for path in paths:
if self.vcs.is_in_a_or_a_working_copy(path):
self.paths.append(S(path))
def compare(self, widget, data=None):
for row in self.caller.selected_rows:
url1 = self.caller.changes_table.get_row(row)[0]
url2 = url1
if url1 == ".":
url1 = ""
url2 = ""
url1 = helper.url_join(self.caller.first_urls.get_active_text(),
url1)
url2 = helper.url_join(self.caller.second_urls.get_active_text(),
url2)
rev1 = self.caller.get_first_revision()
rev2 = self.caller.get_second_revision()
helper.launch_ui_window("diff", [
"%s@%s" % (url1, S(rev1)),
"%s@%s" % (url2, S(rev2)), "-s",
"--vcs=%s" % self.caller.get_vcs_name()
])
def __init__(self, str=None):
Gtk.Label.__init__(self)
self.__wrap_width = 0
self.layout = self.get_layout()
self.layout.set_wrap(Pango.WrapMode.WORD_CHAR)
if str != None:
self.set_text(S(str).display())
self.set_alignment(0.0, 0.0)
def __init__(self, paths, base_dir=None, message=None):
Commit.__init__(self, paths, base_dir, message)
self.get_widget("commit_to_box").show()
self.get_widget("to").set_text(
S(self.vcs.svn().get_repo_url(self.base_dir)).display())
self.items = None
if len(self.paths):
self.initialize_items()
def should_item_be_activated(self, item):
"""
Determines if a file should be activated or not
"""
if (S(item.path) in self.paths
or item.is_versioned() and item.simple_content_status() !=
rabbitvcs.vcs.status.status_missing):
return True
return False
def show_detail(self, tag_name):
self.selected_tag = None
for item in self.tag_list:
if S(item.name) == tag_name:
self.selected_tag = item
break
self.save_button.set_label(_("Save"))
if self.selected_tag:
self.tag_entry.set_text(S(self.selected_tag.name).display())
self.revision_label.set_text(S(self.selected_tag.sha).display())
self.message_label.set_text(
S(self.selected_tag.message).display().rstrip("\n"))
self.tagger_label.set_text(S(self.selected_tag.tagger).display())
self.date_label.set_text(
helper.format_datetime(
datetime.fromtimestamp(self.selected_tag.tag_time),
self.datetime_format))
self.show_rows(self.view_rows)
self.get_widget("detail_label").set_markup(_("<b>Tag Detail</b>"))
def open_second(self, widget, data=None):
path = self.caller.changes_table.get_row(
self.caller.selected_rows[0])[0]
if path == ".":
path = ""
url = helper.url_join(self.caller.second_urls.get_active_text(), path)
rev = self.caller.get_second_revision()
helper.launch_ui_window(
"open",
["--vcs=%s" % self.caller.get_vcs_name(), url,
"-r%s" % S(rev)])
def on_show_log(self, widget, *args):
path = []
if widget.get_label() == self.get_widget("cur_log").get_label():
path.append(self.paths[0])
else:
path_to_check = S(self.paths[0])
while path_to_check != "/" and path_to_check != "":
if os.path.isdir(os.path.join(path_to_check, ".svn")):
path.append(path_to_check)
break
path_to_check = os.path.split(path_to_check)[0]
helper.launch_ui_window("log", path)
def on_repositories_changed(self, widget, data=None):
url = self.repositories.get_active_text()
tmp = [x.strip() for x in url.split("/") if x.strip()]
if tmp and tmp[0].lower() in ("http:", "https:", "file:", "git:"):
del tmp[0]
append = tmp[-1] if tmp else ""
if append.endswith(".git"):
append = append[:-4]
helper.run_in_main_thread(
self.get_widget("destination").set_text,
S(os.path.join(self.destination, append)).display())
self.check_form()
def update_branch_info(self):
from_branch = self.from_branches.get_revision_object()
if from_branch.value:
log = self.git.log(self.path,
limit=1,
revision=from_branch,
showtype="branch")
if log:
from_info = log[0]
self.info['from']['author'].set_text(
S(from_info.author).display())
self.info['from']['date'].set_text(
helper.format_datetime(from_info.date,
self.datetime_format))
self.info['from']['revision'].set_text(
S(from_info.revision).display()[0:7])
self.info['from']['message'].set_text(
S(
helper.html_escape(
helper.format_long_text(from_info.message,
500))).display())
def populate_files_table(self):
for item in self.items:
locked = ""
if self.svn.is_locked(item.path):
locked = _("Yes")
if not self.svn.is_versioned(item.path):
continue
self.files_table.append([
True,
S(item.path), item.path,
helper.get_file_extension(item.path), locked
])
def date_filter(self, row, column, user_data=None):
"""
Table filter to convert the item date to something readable
"""
if row[0] == "..":
return ""
if row[column]:
change_time = datetime.fromtimestamp(float(row[column]))
return str(
S(helper.format_datetime(change_time, self.datetime_format)))
return str(row[column])
def get_background_items_profile(self, window, item):
import cProfile
path = S(gnomevfs.get_local_path_from_uri(item.get_uri())).replace(
"/", ":")
profile_data_file = os.path.join(get_home_folder(),
"checkerservice_%s.stats" % path)
prof = cProfile.Profile()
retval = prof.runcall(self.get_background_items_real, window, item)
prof.dump_stats(profile_data_file)
log.debug("Dumped: %s" % profile_data_file)
return retval
def __init__(self, path, revision=None):
PropertiesBase.__init__(self, path)
self.svn = self.vcs.svn()
if not self.svn.is_path_repository_url(path):
self.path = self.svn.get_repo_url(path)
self.get_widget("path").set_text(S(self.path).display())
self.revision = revision
self.revision_obj = None
if revision is not None:
self.revision_obj = self.svn.revision("number", revision)
self.load()
def on_merge_reintegrate_prepare(self):
if not hasattr(self, "merge_reintegrate_repos"):
self.merge_reintegrate_repos = rabbitvcs.ui.widget.ComboBox(
self.get_widget("merge_reintegrate_repos"), self.repo_paths)
self.merge_reintegrate_repos.cb.connect(
"changed", self.on_merge_reintegrate_from_urls_changed)
self.get_widget("merge_reintegrate_working_copy").set_text(
S(self.path).display())
if not hasattr(self, "merge_reintegrate_revision"):
self.merge_reintegrate_revision = rabbitvcs.ui.widget.RevisionSelector(
self.get_widget("revision_container"),
self.svn,
url_combobox=self.merge_reintegrate_repos,
expand=True)
def CheckStatus(self,
path,
recurse=False,
invalidate=False,
summary=False):
""" Requests a status check from the underlying status checker.
Path is given as an array of bytes instead of a string because
dbus does not support strings with invalid characters.
"""
status = self.status_checker.check_status(S(bytearray(path)),
recurse=recurse,
summary=summary,
invalidate=invalidate)
return self.encoder.encode(status)
def set_status(self, message):
"""
Set the current status of the VCS action. Currently, this method
is called at the beginning and end of each action, to display what is
going on. Currently, it just appends the status message to the
notification window. In the future, I may set up a progress bar
and put the status message there.
@type message: string
@param message: A status message.
"""
if message is not None:
self.notification.get_widget("status").set_text(
S(message).display())
def save_diff_to_file(self, path, data):
dirname = os.path.dirname(path)
if not os.path.isdir(dirname):
os.makedirs(dirname)
if not data:
data = ""
file = open(path, "wb")
try:
try:
file.write(S(data).bytes())
except Exception as e:
log.exception(e)
finally:
file.close()
def set_log(self):
self.log_by_order = self.action.get_result(1)
self.log_by_order.reverse()
self.log_by_revision = {}
self.author_background = {}
for n, log in enumerate(self.log_by_order):
setattr(log, "n", n)
c = self.randomHSL()
c = helper.HSLtoRGB(*c)
setattr(log, "background", helper.html_color(*c))
self.log_by_revision[self.short_revision(log.revision)] = log
author = S(log.author.strip())
if author:
c = self.randomHSL()
c = helper.HSLtoRGB(*c)
self.author_background[author] = helper.html_color(*c)
def __init__(self, paths, base_dir=None, message=None):
Commit.__init__(self, paths, base_dir, message)
self.git = self.vcs.git(paths[0])
self.get_widget("commit_to_box").show()
active_branch = self.git.get_active_branch()
if active_branch:
self.get_widget("to").set_text(S(active_branch.name).display())
else:
self.get_widget("to").set_text("No active branch")
self.items = None
if len(self.paths):
self.initialize_items()
def launch_unified_diff(self):
"""
Launch diff as a unified diff in a text editor or .diff viewer
"""
action = GitAction(self.git, notification=False, run_in_thread=False)
diff_text = action.run_single(self.git.diff, self.path1,
self.revision1, self.path2,
self.revision2)
if diff_text is None:
diff_text = ""
fh = tempfile.mkstemp("-rabbitvcs-" + str(self.revision1)[:5] + "-" +
str(self.revision2)[:5] + ".diff")
os.write(fh[0], S(diff_text).bytes())
os.close(fh[0])
helper.open_item(fh[1])
