Split (1)

train · 303k rows

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.

rem stringlengths 0 322k	add stringlengths 0 2.05M	context stringlengths 8 228k
if(cuser.user.nick == nick):	if(cuser.user.nick.lower() == nick.lower()):	def findCUser(self, nick): nick = nick.split("!")[0] for cuser in self.users: if(cuser.user.nick == nick): return cuser return None
if(user.nick == nick):	if(user.nick.lower() == nick.lower()):	def findUser(self, nick): log(self, "Looking for %s in %s" % (nick, self.users), 4) nick = nick.split("!")[0] for user in self.users: if(user.nick == nick): log(self, "Found user %s" % user, 4) return user log(self, "Didn't find user", 4) return None
if(channel.name == name):	if(channel.name.lower() == name.lower()):	def findChannel(self, name): log(self, "Looking for %s in %s" % (name, self.channels), 4) for channel in self.channels: if(channel.name == name): log(self, "Found channel %s" % channel, 4) return channel log(self, "Didn't find channel", 4) return None
userMsg.params = [channelNames[channel], str(channelModes[channel]), user.nick]	userMsg.params = [channelNames[channel], str(channelModes[channel])] for i in range(len(userMsg.params[1]) - 1): userMsg.params.append(user.nick)	def sendServerData(self, connection): # respond with our own PASS, SERVER combo passMsg = self.IRC_Message("PASS") passMsg.prefix = self.hostname passMsg.params = [self.prefs["server_password"]] connection.send(passMsg.toString()) servMsg = self.IRC_Message("SERVER") servMsg.params = [self.hostname, "1"] servMsg.trail = self.info connection.send(servMsg.toString()) # now we must synchronize all of our data with this new server for server in self.servers: servMsg = self.IRC_Message("SERVER") servMsg.params = [server.hostname, str(server.hopcount)] servMsg.trail = server.info servMsg.prefix = self.hostname connection.send(servMsg.toString()) for user in self.users: # NICK, USER, MODE, JOIN userMsg = self.IRC_Message("NICK") userMsg.params = [user.nick, "1"] connection.send(userMsg.toString()) userMsg = self.IRC_Message("USER") userMsg.prefix = user.nick userMsg.params = [user.username, user.hostname, user.servername] userMsg.trail = user.realname connection.send(userMsg.toString()) userMsg = self.IRC_Message("MODE") userMsg.prefix = self.hostname userMsg.params = [user.nick, str(user.flags)] connection.send(userMsg.toString()) userMsg = self.IRC_Message("JOIN") channelNames = list() channelKeys = list() channelModes = list() for channel in user.channels: if(channel.name.startswith("&")): # don't sync local channels continue channelNames.append(channel.name) channelKeys.append(channel.key) channelModes.append(channel.findCUser(user.nick).flags) userMsg.params = [','.join(channelNames), ','.join(channelKeys)] userMsg.prefix = user.nick connection.send(userMsg.toString()) for channel in range(len(channelModes)): userMsg = self.IRC_Message("MODE") userMsg.prefix = self.hostname userMsg.params = [channelNames[channel], str(channelModes[channel]), user.nick] connection.send(userMsg.toString()) for channel in self.channels: if(channel.name.startswith("&")): # don't sync local channels continue chanMsg = self.IRC_Message("MODE") chanMsg.prefix = self.hostname chanMsg.params = [channel.name, str(channel.flags)] if('k' in channel.flags): chanMsg.params.append(channel.key) for ban in channel.bans: chanMsg.params[1] += 'b' chanMsg.params.append(ban) connection.send(chanMsg.toString())
self.removeServer(connection.user)		def watchConnection(self, connection, sockThread): sockThread.join() if(not connection.closed): # send a quit message if(connection.type == self.IRC_Connection.CLIENT): msg = self.IRC_Message("QUIT :Lost connection") msg.prefix = connection.user.fullUser() self.localBroadcast(msg, connection.user, connection) # this method should never attempt to send messages to the dead connection self.broadcast(msg, connection, self.IRC_Connection.SERVER) self.removeUser(connection.user) elif(connection.type == self.IRC_Connection.SERVER): for user in self.users: if(user.connection == connection): # any user which was connected to us through the lost server must quit msg = self.IRC_Message("QUIT :Lost in netsplit") msg.prefix = user.fullUser() self.localBroadcast(msg, user, connection) self.broadcast(msg, connection, self.IRC_Connection.SERVER) self.removeUser(user) for server in self.servers: if(server.connection == connection): msg = self.IRC_Message("SQUIT :Lost in netsplit") msg.prefix = self.hostname msg.params = [server.hostname] self.broadcast(msg, connection, self.IRC_Connection.SERVER) self.removeServer(server) self.removeServer(connection.user) else: # that was fast :P connection.sock.close() self.connections.remove(connection)
print("hello {0} {1}".format(character, replacement), file=sys.stderr) print("text replaced with {0!r}".format(text.replace(character, replacement)), file=sys.stderr)		def xf_escape_character(text): print("hello {0} {1}".format(character, replacement), file=sys.stderr) print("text replaced with {0!r}".format(text.replace(character, replacement)), file=sys.stderr) return text.replace(character, replacement)
self.text = "%s%s" % (self.text, string)	self.text = "%s%s" % (self.label.get_text(), string)	def update_text(self, string=None): if not string is None: self.text = "%s%s" % (self.text, string) self.label.set_text(self.text) else: self.label.set_text("") self.label.emit("text-changed")
print "* received swapped protocol data, cowardly ignored"	self.logger.warning("* received swapped protocol data, cowardly ignored")	def key_press(self, reply): if reply.category != record.FromServer: return if reply.client_swapped: print "* received swapped protocol data, cowardly ignored" return if not len(reply.data) or ord(reply.data[0]) < 2: # not an event return data = reply.data key = '' mod = '' while len(data): event, data = rq.EventField(None).parse_binary_value(data, self.record_dpy.display, None, None) if event.type in [X.KeyPress, X.KeyRelease]: keysym = self.local_dpy.keycode_to_keysym(event.detail, 0)
print len(key) print "--%s--" % key		def key_press(self, reply): if reply.category != record.FromServer: return if reply.client_swapped: print "* received swapped protocol data, cowardly ignored" return if not len(reply.data) or ord(reply.data[0]) < 2: # not an event return data = reply.data key = '' mod = '' while len(data): event, data = rq.EventField(None).parse_binary_value(data, self.record_dpy.display, None, None) if event.type in [X.KeyPress, X.KeyRelease]: keysym = self.local_dpy.keycode_to_keysym(event.detail, 0)
self.text = self.text[:-1]	self.label.set_text(self.label.get_text()[:-1])	def key_press(self, event): code_num = event.codeMaps[event.type].toNumber(event.code) if code_num in self.keymap: key_normal, key_shift, key_dead, key_deadshift = self.keymap[code_num] else: print 'No mapping for scan_code %d' % code_num return
self.label.set_text(self.label.get_text()[:-1])	self.label.set_text(unicode(self.label.get_text(), 'utf-8')[:-1])	def key_press(self, reply): if reply.category != record.FromServer: return if reply.client_swapped: self.logger.warning("* received swapped protocol data, cowardly ignored") return if not len(reply.data) or ord(reply.data[0]) < 2: # not an event return data = reply.data key = '' mod = '' while len(data): event, data = rq.EventField(None).parse_binary_value(data, self.record_dpy.display, None, None) if event.type in [X.KeyPress, X.KeyRelease]: keysym = self.local_dpy.keycode_to_keysym(event.detail, 0)
new_keysyms.append(unichr(int(keysyms[0], 16)))	unicode_char = unichr(int(keysyms[0], 16))	def get_keymap_table(): keymap = {} keymap_table = cmd_keymap_table() re_line = re.compile(r'0x\w+') for line in keymap_table.split('\n')[1:]: if len(line) > 0: keycode = re.search(r'\s+(\d+).*', line) if keycode: new_keysyms = [] keycode = int(keycode.group(1)) keysyms = re_line.findall(line) # When you press only one key try: new_keysyms.append(unichr(int(keysyms[0], 16))) except: new_keysyms.append('') # When you press a key plus Shift key try: new_keysyms.append(unichr(int(keysyms[1], 16))) except: new_keysyms.append('') # When you press a key plus meta (dead keys) try: new_keysyms.append(unichr(int(keysyms[4], 16))) except: new_keysyms.append('') # When you press a key plus meta plus Shift key (dead keys) try: new_keysyms.append(unichr(int(keysyms[5], 16))) except: new_keysyms.append('') keymap[keycode-8] = new_keysyms return keymap
new_keysyms.append('')	unicode_char = '' if unicode_char == u'\x00': unicode_char = '' new_keysyms.append(unicode_char)	def get_keymap_table(): keymap = {} keymap_table = cmd_keymap_table() re_line = re.compile(r'0x\w+') for line in keymap_table.split('\n')[1:]: if len(line) > 0: keycode = re.search(r'\s+(\d+).*', line) if keycode: new_keysyms = [] keycode = int(keycode.group(1)) keysyms = re_line.findall(line) # When you press only one key try: new_keysyms.append(unichr(int(keysyms[0], 16))) except: new_keysyms.append('') # When you press a key plus Shift key try: new_keysyms.append(unichr(int(keysyms[1], 16))) except: new_keysyms.append('') # When you press a key plus meta (dead keys) try: new_keysyms.append(unichr(int(keysyms[4], 16))) except: new_keysyms.append('') # When you press a key plus meta plus Shift key (dead keys) try: new_keysyms.append(unichr(int(keysyms[5], 16))) except: new_keysyms.append('') keymap[keycode-8] = new_keysyms return keymap
new_keysyms.append(unichr(int(keysyms[1], 16)))	unicode_char = unichr(int(keysyms[1], 16))	def get_keymap_table(): keymap = {} keymap_table = cmd_keymap_table() re_line = re.compile(r'0x\w+') for line in keymap_table.split('\n')[1:]: if len(line) > 0: keycode = re.search(r'\s+(\d+).*', line) if keycode: new_keysyms = [] keycode = int(keycode.group(1)) keysyms = re_line.findall(line) # When you press only one key try: new_keysyms.append(unichr(int(keysyms[0], 16))) except: new_keysyms.append('') # When you press a key plus Shift key try: new_keysyms.append(unichr(int(keysyms[1], 16))) except: new_keysyms.append('') # When you press a key plus meta (dead keys) try: new_keysyms.append(unichr(int(keysyms[4], 16))) except: new_keysyms.append('') # When you press a key plus meta plus Shift key (dead keys) try: new_keysyms.append(unichr(int(keysyms[5], 16))) except: new_keysyms.append('') keymap[keycode-8] = new_keysyms return keymap
new_keysyms.append(unichr(int(keysyms[4], 16)))	unicode_char = unichr(int(keysyms[4], 16))	def get_keymap_table(): keymap = {} keymap_table = cmd_keymap_table() re_line = re.compile(r'0x\w+') for line in keymap_table.split('\n')[1:]: if len(line) > 0: keycode = re.search(r'\s+(\d+).*', line) if keycode: new_keysyms = [] keycode = int(keycode.group(1)) keysyms = re_line.findall(line) # When you press only one key try: new_keysyms.append(unichr(int(keysyms[0], 16))) except: new_keysyms.append('') # When you press a key plus Shift key try: new_keysyms.append(unichr(int(keysyms[1], 16))) except: new_keysyms.append('') # When you press a key plus meta (dead keys) try: new_keysyms.append(unichr(int(keysyms[4], 16))) except: new_keysyms.append('') # When you press a key plus meta plus Shift key (dead keys) try: new_keysyms.append(unichr(int(keysyms[5], 16))) except: new_keysyms.append('') keymap[keycode-8] = new_keysyms return keymap
new_keysyms.append(unichr(int(keysyms[5], 16)))	unicode_char = unichr(int(keysyms[5], 16))	def get_keymap_table(): keymap = {} keymap_table = cmd_keymap_table() re_line = re.compile(r'0x\w+') for line in keymap_table.split('\n')[1:]: if len(line) > 0: keycode = re.search(r'\s+(\d+).*', line) if keycode: new_keysyms = [] keycode = int(keycode.group(1)) keysyms = re_line.findall(line) # When you press only one key try: new_keysyms.append(unichr(int(keysyms[0], 16))) except: new_keysyms.append('') # When you press a key plus Shift key try: new_keysyms.append(unichr(int(keysyms[1], 16))) except: new_keysyms.append('') # When you press a key plus meta (dead keys) try: new_keysyms.append(unichr(int(keysyms[4], 16))) except: new_keysyms.append('') # When you press a key plus meta plus Shift key (dead keys) try: new_keysyms.append(unichr(int(keysyms[5], 16))) except: new_keysyms.append('') keymap[keycode-8] = new_keysyms return keymap
self.logger.error("file %s does not exists." % STATE_FILE)	self.logger.error("file %s does not exists." % self.STATE_FILE)	def load_state(self): """Load stored options""" options = None try: f = open(self.STATE_FILE, 'r') try: options = pickle.load(f) except: f.close() except IOError: self.logger.error("file %s does not exists." % STATE_FILE) return options
self.logger.error("Cannot open %s." % STATE_FILE)	self.logger.error("Cannot open %s." % self.STATE_FILE)	def store_state(self, options): """Store options""" try: f = open(self.STATE_FILE, 'w') try: pickle.dump(options, f) except: f.close() except IOError: self.logger.error("Cannot open %s." % STATE_FILE)
assert file.read(4) == "BSD0"	assert file.read(4) in ("BSD0", "COPY")	def __init__(self, file): # Parse the header file.seek(0) assert file.read(4) == "PTCH" # Magic ## # Sizes # - patchSize: Size of the entire patch data, not including the 'PTCH' signature itself # - sizeBefore: Size of the file before patching # - sizeAfter: Size of the file after patching self.patchSize, self.sizeBefore, self.sizeAfter = unpack("iii", file.read(12)) ## # MD5 block # - md5BlockSize: Size of the MD5 block, including the signature and size # - md5Before: MD5 digest of the original (unpatched) file # - md5After: MD5 digest of the patched file assert file.read(4) == "MD5_" self.md5BlockSize, = unpack("i", file.read(4)) self.md5Before, self.md5After = unpack("16s16s", file.read(32)) self.md5Before, self.md5After = hexlify(self.md5Before), hexlify(self.md5After) ## # XFRM block # - xfrmBlockSize: Size of the XFRM block + the packed data # - unpackedSize: Unpacked size of the patch data assert file.read(4) == "XFRM" self.xfrmBlockSize, = unpack("i", file.read(4)) assert file.read(4) == "BSD0" # patch type? self.unpackedSize, = unpack("i", file.read(4)) self.compressedDiff = file.read() file.close()
env['RENDER'] = 'tools/mako-render'	env['RENDER'] = 'tools/render'	def generate(env): """Add Builders and construction variables for render to an Environment.""" RenderAction = SCons.Action.Action('$RENDERCOM', '$RENDERCOMSTR') RenderTargetScanner = SCons.Scanner.Base(name = "renderTargetScanner", function = renderTargetScanner, skeys = ['.t2t']) env['BUILDERS']['RENDER'] = SCons.Builder.Builder(action = RenderAction, suffix = '.html', src_suffix = '.t2t', source_scanner = SCons.Tool.SourceFileScanner, target_scanner = RenderTargetScanner) env['RENDER'] = 'tools/mako-render' env['RENDERCOM'] = '$RENDER $SOURCE $TARGET' RenderSourceScanner = SCons.Scanner.Base(name = "renderSourceScanner", function = renderSourceScanner, skeys = ['.t2t'], recursive = True) SCons.Tool.SourceFileScanner.add_scanner('.t2t', RenderSourceScanner)
action = 'txt2tags -q -H -t html -i $SOURCE -o $TARGET'	action = '$T2TBHTML $SOURCE $TARGET'	def generate(env): """Add Builders and construction variables for t2tbhtml to an Environment.""" env['BUILDERS']['T2TBHTML'] = SCons.Builder.Builder(\ action = 'txt2tags -q -H -t html -i $SOURCE -o $TARGET' , suffix = '.bhtml' , src_suffix = '.t2t' , source_scanner = SCons.Tool.SourceFileScanner) T2tbhtmlSourceScanner = SCons.Scanner.Base(name = "t2tbhtmlSourceScanner", function = t2tbhtmlSourceScanner, skeys = ['.t2t'], recursive = True) SCons.Tool.SourceFileScanner.add_scanner('.t2t', T2tbhtmlSourceScanner)
, source_scanner = SCons.Tool.SourceFileScanner)	, source_scanner = SCons.Tool.SourceFileScanner , target_scanner = T2tbhtmlTargetScanner) env['T2TBHTML'] = 'tools/t2tbhtml'	def generate(env): """Add Builders and construction variables for t2tbhtml to an Environment.""" env['BUILDERS']['T2TBHTML'] = SCons.Builder.Builder(\ action = 'txt2tags -q -H -t html -i $SOURCE -o $TARGET' , suffix = '.bhtml' , src_suffix = '.t2t' , source_scanner = SCons.Tool.SourceFileScanner) T2tbhtmlSourceScanner = SCons.Scanner.Base(name = "t2tbhtmlSourceScanner", function = t2tbhtmlSourceScanner, skeys = ['.t2t'], recursive = True) SCons.Tool.SourceFileScanner.add_scanner('.t2t', T2tbhtmlSourceScanner)
return [os.path.join(env['TOP'], env['RENDER'])]	return [os.path.join(env['TOP'], env['RENDERTEMPLATE']), os.path.join(env['TOP'], env['RENDER'])]	def renderTargetScanner(node, env, path): return [os.path.join(env['TOP'], env['RENDER'])]
if main_re.findall(contents): target.append(base)		def haskellAutoEmitter(target, source, env): base = SCons.Util.splitext(str(source[0]))[0] contents = source[0].get_contents() target.append(base + '.o') if main_re.findall(contents): target.append(base) return target, source
yield kind, sorted(kinds[kind].iteritems())	try: yield kind, sorted(kinds[kind].iteritems()) except KeyError: pass	def _command_list(commands): kinds = {} for cmd, (mod, kind, help) in commands.iteritems(): kinds.setdefault(kind, {})[cmd] = help for kind in _kind_order: kind = _kinds[kind] yield kind, sorted(kinds[kind].iteritems())
self.__cache = {}	self.__cache = self.__defaults	def load(self): """Load the whole configuration in __cache unless it has been done already.""" if self.__cache is not None: return self.__cache = {} lines = Run('git', 'config', '--null', '--list' ).discard_exitcode().raw_output() for line in filter(None, lines.split('\0')): key, value = line.split('\n', 1) self.__cache.setdefault(key, []).append(value)
if name not in self.__cache: self.__cache[name] = [self.__defaults.get(name, None)] return self.__cache[name][-1]	try: return self.__cache[name][-1] except KeyError: return None	def get(self, name): self.load() if name not in self.__cache: self.__cache[name] = [self.__defaults.get(name, None)] return self.__cache[name][-1]
def __send_message(from_addr, to_addr_list, msg, options):	def __send_message(type, tmpl, options, *args):	def __send_message(from_addr, to_addr_list, msg, options): """Message sending dispatcher. """ smtpserver = options.smtp_server or config.get('stgit.smtpserver') if smtpserver.startswith('/'): # Use the sendmail tool __send_message_sendmail(smtpserver, msg) else: # Use the SMTP server (we have host and port information) __send_message_smtp(smtpserver, from_addr, to_addr_list, msg, options)
__send_message_sendmail(smtpserver, msg)	__send_message_sendmail(smtpserver, msg_str)	def __send_message(from_addr, to_addr_list, msg, options): """Message sending dispatcher. """ smtpserver = options.smtp_server or config.get('stgit.smtpserver') if smtpserver.startswith('/'): # Use the sendmail tool __send_message_sendmail(smtpserver, msg) else: # Use the SMTP server (we have host and port information) __send_message_smtp(smtpserver, from_addr, to_addr_list, msg, options)
__send_message_smtp(smtpserver, from_addr, to_addr_list, msg, options)	__send_message_smtp(smtpserver, from_addr, to_addrs, msg_str, options) if type == 'cover' or (type == 'patch' and patch_nr < total_nr): sleep = options.sleep or config.getint('stgit.smtpdelay') time.sleep(sleep) out.done() return msg_id	def __send_message(from_addr, to_addr_list, msg, options): """Message sending dispatcher. """ smtpserver = options.smtp_server or config.get('stgit.smtpserver') if smtpserver.startswith('/'): # Use the sendmail tool __send_message_sendmail(smtpserver, msg) else: # Use the SMTP server (we have host and port information) __send_message_smtp(smtpserver, from_addr, to_addr_list, msg, options)
subject = message.splitlines()[0]	lines = message.splitlines() subject = lines[0] body = '\n'.join(lines[2:])	def __pick_commit(commit_id, patchname, options): """Pick a commit id. """ commit = git.Commit(commit_id) if options.name: patchname = options.name elif patchname and options.revert: patchname = 'revert-' + patchname if patchname: patchname = find_patch_name(patchname, crt_series.patch_exists) if options.parent: parent = git_id(crt_series, options.parent) else: parent = commit.get_parent() if not options.revert: bottom = parent top = commit_id else: bottom = commit_id top = parent if options.fold: out.start('Folding commit %s' % commit_id) # try a direct git apply first if not git.apply_diff(bottom, top, files = options.file): if options.file: raise CmdException('Patch folding failed') else: git.merge_recursive(bottom, git.get_head(), top) out.done() elif options.update: rev1 = git_id(crt_series, 'HEAD^') rev2 = git_id(crt_series, 'HEAD') files = git.barefiles(rev1, rev2).split('\n') out.start('Updating with commit %s' % commit_id) if not git.apply_diff(bottom, top, files = files): raise CmdException, 'Patch updating failed' out.done() else: message = commit.get_log() if options.revert: if message: subject = message.splitlines()[0] else: subject = commit.get_id_hash() message = 'Revert "%s"\n\nThis reverts commit %s.\n' \ % (subject, commit.get_id_hash()) elif options.expose: message += '(imported from commit %s)\n' % commit.get_id_hash() author_name, author_email, author_date = \ name_email_date(commit.get_author()) out.start('Importing commit %s' % commit_id) newpatch = crt_series.new_patch(patchname, message = message, can_edit = False, unapplied = True, bottom = bottom, top = top, author_name = author_name, author_email = author_email, author_date = author_date) # in case the patch name was automatically generated patchname = newpatch.get_name() # find a patchlog to fork from refbranchname, refpatchname = parse_rev(patchname) if refpatchname: if refbranchname: # assume the refseries is OK, since we already resolved # commit_str to a git_id refseries = Series(refbranchname) else: refseries = crt_series patch = refseries.get_patch(refpatchname) if patch.get_log(): out.info("Log was %s" % newpatch.get_log()) out.info("Setting log to %s\n" % patch.get_log()) newpatch.set_log(patch.get_log()) out.info("Log is now %s" % newpatch.get_log()) else: out.info("No log for %s\n" % patchname) if not options.unapplied: modified = crt_series.push_patch(patchname) else: modified = False if crt_series.empty_patch(patchname): out.done('empty patch') elif modified: out.done('modified') else: out.done()
message = 'Revert "%s"\n\nThis reverts commit %s.\n' \ % (subject, commit.get_id_hash())	body = '' message = 'Revert "%s"\n\nThis reverts commit %s.\n\n%s\n' \ % (subject, commit.get_id_hash(), body)	def __pick_commit(commit_id, patchname, options): """Pick a commit id. """ commit = git.Commit(commit_id) if options.name: patchname = options.name elif patchname and options.revert: patchname = 'revert-' + patchname if patchname: patchname = find_patch_name(patchname, crt_series.patch_exists) if options.parent: parent = git_id(crt_series, options.parent) else: parent = commit.get_parent() if not options.revert: bottom = parent top = commit_id else: bottom = commit_id top = parent if options.fold: out.start('Folding commit %s' % commit_id) # try a direct git apply first if not git.apply_diff(bottom, top, files = options.file): if options.file: raise CmdException('Patch folding failed') else: git.merge_recursive(bottom, git.get_head(), top) out.done() elif options.update: rev1 = git_id(crt_series, 'HEAD^') rev2 = git_id(crt_series, 'HEAD') files = git.barefiles(rev1, rev2).split('\n') out.start('Updating with commit %s' % commit_id) if not git.apply_diff(bottom, top, files = files): raise CmdException, 'Patch updating failed' out.done() else: message = commit.get_log() if options.revert: if message: subject = message.splitlines()[0] else: subject = commit.get_id_hash() message = 'Revert "%s"\n\nThis reverts commit %s.\n' \ % (subject, commit.get_id_hash()) elif options.expose: message += '(imported from commit %s)\n' % commit.get_id_hash() author_name, author_email, author_date = \ name_email_date(commit.get_author()) out.start('Importing commit %s' % commit_id) newpatch = crt_series.new_patch(patchname, message = message, can_edit = False, unapplied = True, bottom = bottom, top = top, author_name = author_name, author_email = author_email, author_date = author_date) # in case the patch name was automatically generated patchname = newpatch.get_name() # find a patchlog to fork from refbranchname, refpatchname = parse_rev(patchname) if refpatchname: if refbranchname: # assume the refseries is OK, since we already resolved # commit_str to a git_id refseries = Series(refbranchname) else: refseries = crt_series patch = refseries.get_patch(refpatchname) if patch.get_log(): out.info("Log was %s" % newpatch.get_log()) out.info("Setting log to %s\n" % patch.get_log()) newpatch.set_log(patch.get_log()) out.info("Log is now %s" % newpatch.get_log()) else: out.info("No log for %s\n" % patchname) if not options.unapplied: modified = crt_series.push_patch(patchname) else: modified = False if crt_series.empty_patch(patchname): out.done('empty patch') elif modified: out.done('modified') else: out.done()
return re.sub('[\W]+', '-', subject_line).strip('-')[:name_len]	return re.sub('[\W]+', '-', subject_line)[:name_len].strip('-')	def patch_name_from_msg(msg): """Return a string to be used as a patch name. This is generated from the top line of the string passed as argument.""" if not msg: return None name_len = config.getint('stgit.namelength') if not name_len: name_len = 30 subject_line = msg.split('\n', 1)[0].lstrip().lower() return re.sub('[\W]+', '-', subject_line).strip('-')[:name_len]
self.__conflicting_push = None		def __init__(self, stack, msg, discard_changes = False, allow_conflicts = False, allow_bad_head = False, check_clean_iw = None): """Create a new L{StackTransaction}.
write(self.__msg) if self.__conflicting_push != None: self.__patches = _TransPatchMap(self.__stack) self.__conflicting_push()	if not self.__conflicts: write(self.__msg) else:	def write(msg): for pn, commit in self.__patches.iteritems(): if self.__stack.patches.exists(pn): p = self.__stack.patches.get(pn) if commit == None: p.delete() else: p.set_commit(commit, msg) else: self.__stack.patches.new(pn, commit, msg) self.__stack.patchorder.applied = self.__applied self.__stack.patchorder.unapplied = self.__unapplied self.__stack.patchorder.hidden = self.__hidden log.log_entry(self.__stack, msg)
def update(): if comm: self.patches[pn] = comm if pn in self.hidden: x = self.hidden else: x = self.unapplied del x[x.index(pn)] self.applied.append(pn)		def update(): if comm: self.patches[pn] = comm if pn in self.hidden: x = self.hidden else: x = self.unapplied del x[x.index(pn)] self.applied.append(pn)
self.__conflicting_push = update	self.__patches = _TransPatchMap(self.__stack) if comm: self.patches[pn] = comm if pn in self.hidden: x = self.hidden else: x = self.unapplied del x[x.index(pn)] self.applied.append(pn) if merge_conflict:	def update(): if comm: self.patches[pn] = comm if pn in self.hidden: x = self.hidden else: x = self.unapplied del x[x.index(pn)] self.applied.append(pn)
else: update()		def update(): if comm: self.patches[pn] = comm if pn in self.hidden: x = self.hidden else: x = self.unapplied del x[x.index(pn)] self.applied.append(pn)
to_push = trans.pop_patches( lambda pn: pn in stack.patchorder.applied[common_prefix:])	to_push = [pn for pn in stack.patchorder.applied[common_prefix:] if pn not in patches[common_prefix:]] trans.pop_patches(lambda pn: pn in to_push)	def allow_conflicts(trans): # As long as the topmost patch stays where it is, it's OK to # run "stg commit" with conflicts in the index. return len(trans.applied) >= 1
trans.push_patch(pn, iw, allow_interactive = True)	if options.set_tree: trans.push_tree(pn) else: trans.push_patch(pn, iw, allow_interactive = True)	def failed(): fn = '.stgit-failed.patch' f = file(fn, 'w') f.write(edit.patch_desc(stack.repository, cd, options.diff, options.diff_flags, failed_diff)) f.close() out.error('Edited patch did not apply.', 'It has been saved to "%s".' % fn) return utils.STGIT_COMMAND_ERROR