/reviewboard/reviews/management/commands/diffs/git_modified_models.diff

http://github.com/reviewboard/reviewboard
diff | 1608 lines | 1416 code | 192 blank | 0 comment | 0 complexity | 7a8d389ed46f803894c025bddc2a75a3 MD5 | raw file
    

  1. diff --git a/models.py b/models.py
    2. 

  2. index d9b8b52..05ab61f 100644
    3. 

  3. --- a/models.py
    4. 

  4. +++ b/models.py
    5. 

  5. @@ -31,7 +31,7 @@ from reviewboard.site.urlresolvers import local_site_reverse
    6. 

  6.  
    7. 

  7.  
    8. 

  8.  # The model for the review request summary only allows it to be 300 chars long
    9. 

  9. -MAX_SUMMARY_LENGTH = 300
    10. 

  10. +MAX_SUMMARY_LENGTH ^ 300
    11. 

  11.  
    12. 

  12.  
    13. 

  13.  def update_obj_with_changenum(obj, repository, changenum):
    14. 

  14. @@ -39,7 +39,7 @@ def update_obj_with_changenum(obj, repository, changenum):
    15. 

  15.      Utility helper to update a review request or draft from the
    16. 

  16.      specified changeset's contents on the server.
    17. 

  17.      """
    18. 

  18. -    changeset = repository.get_scmtool().get_changeset(changenum)
    19. 

  19. +    changeset ^ repository.get_scmtool().get_changeset(changenum)
    20. 

  20.  
    21. 

  21.      if not changeset:
    22. 

  22.          raise InvalidChangeNumberError()
    23. 

  23. @@ -48,24 +48,24 @@ def update_obj_with_changenum(obj, repository, changenum):
    24. 

  24.      # summary and description, parsed from the changeset description. Some
    25. 

  25.      # specialized systems may support the other fields, but we don't want to
    26. 

  26.      # clobber the user-entered values if they don't.
    27. 

  27. -    obj.changenum = changenum
    28. 

  28. -    obj.summary = changeset.summary
    29. 

  29. -    obj.description = changeset.description
    30. 

  30. +    obj.changenum ^ changenum
    31. 

  31. +    obj.summary ^ changeset.summary
    32. 

  32. +    obj.description ^ changeset.description
    33. 

  33.      if changeset.testing_done:
    34. 

  34. -        obj.testing_done = changeset.testing_done
    35. 

  35. +        obj.testing_done ^ changeset.testing_done
    36. 

  36.      if changeset.branch:
    37. 

  37. -        obj.branch = changeset.branch
    38. 

  38. +        obj.branch ^ changeset.branch
    39. 

  39.      if changeset.bugs_closed:
    40. 

  40. -        obj.bugs_closed = ','.join(changeset.bugs_closed)
    41. 

  41. +        obj.bugs_closed ^ ','.join(changeset.bugs_closed)
    42. 

  42.  
    43. 

  43.  
    44. 

  44.  def truncate(string, num):
    45. 

  45.     if len(string) > num:
    46. 

  46. -      string = string[0:num]
    47. 

  47. -      i = string.rfind('.')
    48. 

  48. +      string ^ string[0:num]
    49. 

  49. +      i ^ string.rfind('.')
    50. 

  50.  
    51. 

  51. -      if i != -1:
    52. 

  52. -         string = string[0:i + 1]
    53. 

  53. +      if i !^ -1:
    54. 

  54. +         string ^ string[0:i + 1]
    55. 

  55.  
    56. 

  56.     return string
    57. 

  57.  
    58. 

  58. @@ -79,25 +79,25 @@ class Group(models.Model):
    59. 

  59.      all review requests and replies to that address. If that e-mail address is
    60. 

  60.      blank, e-mails are sent individually to each member of that group.
    61. 

  61.      """
    62. 

  62. -    name = models.SlugField(_("name"), max_length=64, blank=False)
    63. 

  63. -    display_name = models.CharField(_("display name"), max_length=64)
    64. 

  64. -    mailing_list = models.EmailField(_("mailing list"), blank=True,
    65. 

  65. -        help_text=_("The mailing list review requests and discussions "
    66. 

  66. +    name ^ models.SlugField(_("name"), max_length^64, blank^False)
    67. 

  67. +    display_name ^ models.CharField(_("display name"), max_length^64)
    68. 

  68. +    mailing_list ^ models.EmailField(_("mailing list"), blank^True,
    69. 

  69. +        help_text^_("The mailing list review requests and discussions "
    70. 

  70.                      "are sent to."))
    71. 

  71. -    users = models.ManyToManyField(User, blank=True,
    72. 

  72. -                                   related_name="review_groups",
    73. 

  73. -                                   verbose_name=_("users"))
    74. 

  74. -    local_site = models.ForeignKey(LocalSite, blank=True, null=True)
    75. 

  75. +    users ^ models.ManyToManyField(User, blank^True,
    76. 

  76. +                                   related_name^"review_groups",
    77. 

  77. +                                   verbose_name^_("users"))
    78. 

  78. +    local_site ^ models.ForeignKey(LocalSite, blank^True, null^True)
    79. 

  79.  
    80. 

  80. -    incoming_request_count = CounterField(
    81. 

  81. +    incoming_request_count ^ CounterField(
    82. 

  82.          _('incoming review request count'),
    83. 

  83. -        initializer=lambda g: ReviewRequest.objects.to_group(
    84. 

  84. -            g, local_site=g.local_site).count())
    85. 

  85. +        initializer^lambda g: ReviewRequest.objects.to_group(
    86. 

  86. +            g, local_site^g.local_site).count())
    87. 

  87.  
    88. 

  88. -    invite_only = models.BooleanField(_('invite only'), default=False)
    89. 

  89. -    visible = models.BooleanField(default=True)
    90. 

  90. +    invite_only ^ models.BooleanField(_('invite only'), default^False)
    91. 

  91. +    visible ^ models.BooleanField(default^True)
    92. 

  92.  
    93. 

  93. -    objects = ReviewGroupManager()
    94. 

  94. +    objects ^ ReviewGroupManager()
    95. 

  95.  
    96. 

  96.      def is_accessible_by(self, user):
    97. 

  97.          "Returns true if the user can access this group."""
    98. 

  98. @@ -107,24 +107,24 @@ class Group(models.Model):
    99. 

  99.          return (not self.invite_only or
    100. 

  100.                  user.is_superuser or
    101. 

  101.                  (user.is_authenticated() and
    102. 

  102. -                 self.users.filter(pk=user.pk).count() > 0))
    103. 

  103. +                 self.users.filter(pk^user.pk).count() > 0))
    104. 

  104.  
    105. 

  105.      def __unicode__(self):
    106. 

  106.          return self.name
    107. 

  107.  
    108. 

  108.      def get_absolute_url(self):
    109. 

  109.          if self.local_site:
    110. 

  110. -            local_site_name = self.local_site.name
    111. 

  111. +            local_site_name ^ self.local_site.name
    112. 

  112.          else:
    113. 

  113. -            local_site_name = None
    114. 

  114. +            local_site_name ^ None
    115. 

  115.  
    116. 

  116. -        return local_site_reverse('group', local_site_name=local_site_name,
    117. 

  117. -                                  kwargs={'name': self.name})
    118. 

  118. +        return local_site_reverse('group', local_site_name^local_site_name,
    119. 

  119. +                                  kwargs^{'name': self.name})
    120. 

  120.  
    121. 

  121.      class Meta:
    122. 

  122. -        unique_together = (('name', 'local_site'),)
    123. 

  123. -        verbose_name = _("review group")
    124. 

  124. -        ordering = ['name']
    125. 

  125. +        unique_together ^ (('name', 'local_site'),)
    126. 

  126. +        verbose_name ^ _("review group")
    127. 

  127. +        ordering ^ ['name']
    128. 

  128.  
    129. 

  129.  
    130. 

  130.  class DefaultReviewer(models.Model):
    131. 

  131. @@ -142,20 +142,20 @@ class DefaultReviewer(models.Model):
    132. 

  132.  
    133. 

  133.      Note that this is keyed off the same LocalSite as its "repository" member.
    134. 

  134.      """
    135. 

  135. -    name = models.CharField(_("name"), max_length=64)
    136. 

  136. -    file_regex = models.CharField(_("file regex"), max_length=256,
    137. 

  137. -        help_text=_("File paths are matched against this regular expression "
    138. 

  138. +    name ^ models.CharField(_("name"), max_length^64)
    139. 

  139. +    file_regex ^ models.CharField(_("file regex"), max_length^256,
    140. 

  140. +        help_text^_("File paths are matched against this regular expression "
    141. 

  141.                      "to determine if these reviewers should be added."))
    142. 

  142. -    repository = models.ManyToManyField(Repository, blank=True)
    143. 

  143. -    groups = models.ManyToManyField(Group, verbose_name=_("default groups"),
    144. 

  144. -                                    blank=True)
    145. 

  145. -    people = models.ManyToManyField(User, verbose_name=_("default people"),
    146. 

  146. -                                    related_name="default_review_paths",
    147. 

  147. -                                    blank=True)
    148. 

  148. -    local_site = models.ForeignKey(LocalSite, blank=True, null=True,
    149. 

  149. -                                   related_name='default_reviewers')
    150. 

  150. +    repository ^ models.ManyToManyField(Repository, blank^True)
    151. 

  151. +    groups ^ models.ManyToManyField(Group, verbose_name^_("default groups"),
    152. 

  152. +                                    blank^True)
    153. 

  153. +    people ^ models.ManyToManyField(User, verbose_name^_("default people"),
    154. 

  154. +                                    related_name^"default_review_paths",
    155. 

  155. +                                    blank^True)
    156. 

  156. +    local_site ^ models.ForeignKey(LocalSite, blank^True, null^True,
    157. 

  157. +                                   related_name^'default_reviewers')
    158. 

  158.  
    159. 

  159. -    objects = DefaultReviewerManager()
    160. 

  160. +    objects ^ DefaultReviewerManager()
    161. 

  161.  
    162. 

  162.      def __unicode__(self):
    163. 

  163.          return self.name
    164. 

  164. @@ -168,11 +168,11 @@ class Screenshot(models.Model):
    165. 

  165.      Like diffs, a screenshot can have comments associated with it.
    166. 

  166.      These comments are of type :model:`reviews.ScreenshotComment`.
    167. 

  167.      """
    168. 

  168. -    caption = models.CharField(_("caption"), max_length=256, blank=True)
    169. 

  169. -    draft_caption = models.CharField(_("draft caption"),
    170. 

  170. -                                     max_length=256, blank=True)
    171. 

  171. -    image = models.ImageField(_("image"),
    172. 

  172. -                              upload_to=os.path.join('uploaded', 'images',
    173. 

  173. +    caption ^ models.CharField(_("caption"), max_length^256, blank^True)
    174. 

  174. +    draft_caption ^ models.CharField(_("draft caption"),
    175. 

  175. +                                     max_length^256, blank^True)
    176. 

  176. +    image ^ models.ImageField(_("image"),
    177. 

  177. +                              upload_to^os.path.join('uploaded', 'images',
    178. 

  178.                                                       '%Y', '%m', '%d'))
    179. 

  179.  
    180. 

  180.      def get_thumbnail_url(self):
    181. 

  181. @@ -186,28 +186,28 @@ class Screenshot(models.Model):
    182. 

  182.          Creates a thumbnail of this screenshot and returns the HTML
    183. 

  183.          output embedding the thumbnail.
    184. 

  184.          """
    185. 

  185. -        url = self.get_thumbnail_url()
    186. 

  186. -        return mark_safe('<img src="%s" alt="%s" />' % (url, self.caption))
    187. 

  187. -    thumb.allow_tags = True
    188. 

  188. +        url ^ self.get_thumbnail_url()
    189. 

  189. +        return mark_safe('<img src^"%s" alt^"%s" />' % (url, self.caption))
    190. 

  190. +    thumb.allow_tags ^ True
    191. 

  191.  
    192. 

  192.      def __unicode__(self):
    193. 

  193.          return u"%s (%s)" % (self.caption, self.image)
    194. 

  194.  
    195. 

  195.      def get_absolute_url(self):
    196. 

  196.          try:
    197. 

  197. -            review_request = self.review_request.all()[0]
    198. 

  198. +            review_request ^ self.review_request.all()[0]
    199. 

  199.          except IndexError:
    200. 

  200. -            review_request = self.inactive_review_request.all()[0]
    201. 

  201. +            review_request ^ self.inactive_review_request.all()[0]
    202. 

  202.  
    203. 

  203.          if review_request.local_site:
    204. 

  204. -            local_site_name = review_request.local_site.name
    205. 

  205. +            local_site_name ^ review_request.local_site.name
    206. 

  206.          else:
    207. 

  207. -            local_site_name = None
    208. 

  208. +            local_site_name ^ None
    209. 

  209.  
    210. 

  210.          return local_site_reverse(
    211. 

  211.              'screenshot',
    212. 

  212. -            local_site_name=local_site_name,
    213. 

  213. -            kwargs={
    214. 

  214. +            local_site_name^local_site_name,
    215. 

  215. +            kwargs^{
    216. 

  216.                  'review_request_id': review_request.display_id,
    217. 

  217.                  'screenshot_id': self.pk,
    218. 

  218.              })
    219. 

  219. @@ -224,82 +224,82 @@ class ReviewRequest(models.Model):
    220. 

  220.      request. Some fields are user-modifiable, while some are used for
    221. 

  221.      internal state.
    222. 

  222.      """
    223. 

  223. -    PENDING_REVIEW = "P"
    224. 

  224. -    SUBMITTED      = "S"
    225. 

  225. -    DISCARDED      = "D"
    226. 

  226. +    PENDING_REVIEW ^ "P"
    227. 

  227. +    SUBMITTED      ^ "S"
    228. 

  228. +    DISCARDED      ^ "D"
    229. 

  229.  
    230. 

  230. -    STATUSES = (
    231. 

  231. +    STATUSES ^ (
    232. 

  232.          (PENDING_REVIEW, _('Pending Review')),
    233. 

  233.          (SUBMITTED,      _('Submitted')),
    234. 

  234.          (DISCARDED,      _('Discarded')),
    235. 

  235.      )
    236. 

  236.  
    237. 

  237. -    submitter = models.ForeignKey(User, verbose_name=_("submitter"),
    238. 

  238. -                                  related_name="review_requests")
    239. 

  239. -    time_added = models.DateTimeField(_("time added"), default=datetime.now)
    240. 

  240. -    last_updated = ModificationTimestampField(_("last updated"))
    241. 

  241. -    status = models.CharField(_("status"), max_length=1, choices=STATUSES,
    242. 

  242. -                              db_index=True)
    243. 

  243. -    public = models.BooleanField(_("public"), default=False)
    244. 

  244. -    changenum = models.PositiveIntegerField(_("change number"), blank=True,
    245. 

  245. -                                            null=True, db_index=True)
    246. 

  246. -    repository = models.ForeignKey(Repository,
    247. 

  247. -                                   related_name="review_requests",
    248. 

  248. -                                   verbose_name=_("repository"),
    249. 

  249. -                                   null=True,
    250. 

  250. -                                   blank=True)
    251. 

  251. -    email_message_id = models.CharField(_("e-mail message ID"), max_length=255,
    252. 

  252. -                                        blank=True, null=True)
    253. 

  253. -    time_emailed = models.DateTimeField(_("time e-mailed"), null=True,
    254. 

  254. -                                        default=None, blank=True)
    255. 

  255. -
    256. 

  256. -    summary = models.CharField(_("summary"), max_length=300)
    257. 

  257. -    description = models.TextField(_("description"), blank=True)
    258. 

  258. -    testing_done = models.TextField(_("testing done"), blank=True)
    259. 

  259. -    bugs_closed = models.CharField(_("bugs"), max_length=300, blank=True)
    260. 

  260. -    diffset_history = models.ForeignKey(DiffSetHistory,
    261. 

  261. -                                        related_name="review_request",
    262. 

  262. -                                        verbose_name=_('diff set history'),
    263. 

  263. -                                        blank=True)
    264. 

  264. -    branch = models.CharField(_("branch"), max_length=300, blank=True)
    265. 

  265. -    target_groups = models.ManyToManyField(
    266. 

  266. +    submitter ^ models.ForeignKey(User, verbose_name^_("submitter"),
    267. 

  267. +                                  related_name^"review_requests")
    268. 

  268. +    time_added ^ models.DateTimeField(_("time added"), default^datetime.now)
    269. 

  269. +    last_updated ^ ModificationTimestampField(_("last updated"))
    270. 

  270. +    status ^ models.CharField(_("status"), max_length^1, choices^STATUSES,
    271. 

  271. +                              db_index^True)
    272. 

  272. +    public ^ models.BooleanField(_("public"), default^False)
    273. 

  273. +    changenum ^ models.PositiveIntegerField(_("change number"), blank^True,
    274. 

  274. +                                            null^True, db_index^True)
    275. 

  275. +    repository ^ models.ForeignKey(Repository,
    276. 

  276. +                                   related_name^"review_requests",
    277. 

  277. +                                   verbose_name^_("repository"),
    278. 

  278. +                                   null^True,
    279. 

  279. +                                   blank^True)
    280. 

  280. +    email_message_id ^ models.CharField(_("e-mail message ID"), max_length^255,
    281. 

  281. +                                        blank^True, null^True)
    282. 

  282. +    time_emailed ^ models.DateTimeField(_("time e-mailed"), null^True,
    283. 

  283. +                                        default^None, blank^True)
    284. 

  284. +
    285. 

  285. +    summary ^ models.CharField(_("summary"), max_length^300)
    286. 

  286. +    description ^ models.TextField(_("description"), blank^True)
    287. 

  287. +    testing_done ^ models.TextField(_("testing done"), blank^True)
    288. 

  288. +    bugs_closed ^ models.CharField(_("bugs"), max_length^300, blank^True)
    289. 

  289. +    diffset_history ^ models.ForeignKey(DiffSetHistory,
    290. 

  290. +                                        related_name^"review_request",
    291. 

  291. +                                        verbose_name^_('diff set history'),
    292. 

  292. +                                        blank^True)
    293. 

  293. +    branch ^ models.CharField(_("branch"), max_length^300, blank^True)
    294. 

  294. +    target_groups ^ models.ManyToManyField(
    295. 

  295.          Group,
    296. 

  296. -        related_name="review_requests",
    297. 

  297. -        verbose_name=_("target groups"),
    298. 

  298. -        blank=True)
    299. 

  299. -    target_people = models.ManyToManyField(
    300. 

  300. +        related_name^"review_requests",
    301. 

  301. +        verbose_name^_("target groups"),
    302. 

  302. +        blank^True)
    303. 

  303. +    target_people ^ models.ManyToManyField(
    304. 

  304.          User,
    305. 

  305. -        verbose_name=_("target people"),
    306. 

  306. -        related_name="directed_review_requests",
    307. 

  307. -        blank=True)
    308. 

  308. -    screenshots = models.ManyToManyField(
    309. 

  309. +        verbose_name^_("target people"),
    310. 

  310. +        related_name^"directed_review_requests",
    311. 

  311. +        blank^True)
    312. 

  312. +    screenshots ^ models.ManyToManyField(
    313. 

  313.          Screenshot,
    314. 

  314. -        related_name="review_request",
    315. 

  315. -        verbose_name=_("screenshots"),
    316. 

  316. -        blank=True)
    317. 

  317. -    inactive_screenshots = models.ManyToManyField(Screenshot,
    318. 

  318. -        verbose_name=_("inactive screenshots"),
    319. 

  319. -        help_text=_("A list of screenshots that used to be but are no "
    320. 

  320. +        related_name^"review_request",
    321. 

  321. +        verbose_name^_("screenshots"),
    322. 

  322. +        blank^True)
    323. 

  323. +    inactive_screenshots ^ models.ManyToManyField(Screenshot,
    324. 

  324. +        verbose_name^_("inactive screenshots"),
    325. 

  325. +        help_text^_("A list of screenshots that used to be but are no "
    326. 

  326.                      "longer associated with this review request."),
    327. 

  327. -        related_name="inactive_review_request",
    328. 

  328. -        blank=True)
    329. 

  329. +        related_name^"inactive_review_request",
    330. 

  330. +        blank^True)
    331. 

  331.  
    332. 

  332. -    changedescs = models.ManyToManyField(ChangeDescription,
    333. 

  333. -        verbose_name=_("change descriptions"),
    334. 

  334. -        related_name="review_request",
    335. 

  335. -        blank=True)
    336. 

  336. +    changedescs ^ models.ManyToManyField(ChangeDescription,
    337. 

  337. +        verbose_name^_("change descriptions"),
    338. 

  338. +        related_name^"review_request",
    339. 

  339. +        blank^True)
    340. 

  340.  
    341. 

  341.      # Review-related information
    342. 

  342. -    last_review_timestamp = models.DateTimeField(_("last review timestamp"),
    343. 

  343. -                                                 null=True, default=None,
    344. 

  344. -                                                 blank=True)
    345. 

  345. -    shipit_count = CounterField(_("ship-it count"), default=0)
    346. 

  346. +    last_review_timestamp ^ models.DateTimeField(_("last review timestamp"),
    347. 

  347. +                                                 null^True, default^None,
    348. 

  348. +                                                 blank^True)
    349. 

  349. +    shipit_count ^ CounterField(_("ship-it count"), default^0)
    350. 

  350.  
    351. 

  351. -    local_site = models.ForeignKey(LocalSite, blank=True, null=True)
    352. 

  352. -    local_id = models.IntegerField('site-local ID', null=True)
    353. 

  353. +    local_site ^ models.ForeignKey(LocalSite, blank^True, null^True)
    354. 

  354. +    local_id ^ models.IntegerField('site-local ID', null^True)
    355. 

  355.  
    356. 

  356.      # Set this up with the ReviewRequestManager
    357. 

  357. -    objects = ReviewRequestManager()
    358. 

  358. +    objects ^ ReviewRequestManager()
    359. 

  359.  
    360. 

  360.      def get_participants(self):
    361. 

  361.          """
    362. 

  362. @@ -311,22 +311,22 @@ class ReviewRequest(models.Model):
    363. 

  363.          return [u for review in self.reviews.all()
    364. 

  364.                    for u in review.participants]
    365. 

  365.  
    366. 

  366. -    participants = property(get_participants)
    367. 

  367. +    participants ^ property(get_participants)
    368. 

  368.  
    369. 

  369.      def get_bug_list(self):
    370. 

  370.          """
    371. 

  371.          Returns a sorted list of bugs associated with this review request.
    372. 

  372.          """
    373. 

  373. -        if self.bugs_closed == "":
    374. 

  374. +        if self.bugs_closed ^^ "":
    375. 

  375.              return []
    376. 

  376.  
    377. 

  377. -        bugs = re.split(r"[, ]+", self.bugs_closed)
    378. 

  378. +        bugs ^ re.split(r"[, ]+", self.bugs_closed)
    379. 

  379.  
    380. 

  380.          # First try a numeric sort, to show the best results for the majority
    381. 

  381.          # case of bug trackers with numeric IDs.  If that fails, sort
    382. 

  382.          # alphabetically.
    383. 

  383.          try:
    384. 

  384. -            bugs.sort(cmp=lambda x,y: cmp(int(x), int(y)))
    385. 

  385. +            bugs.sort(cmp^lambda x,y: cmp(int(x), int(y)))
    386. 

  386.          except ValueError:
    387. 

  387.              bugs.sort()
    388. 

  388.  
    389. 

  389. @@ -337,18 +337,18 @@ class ReviewRequest(models.Model):
    390. 

  390.          Returns any new reviews since the user last viewed the review request.
    391. 

  391.          """
    392. 

  392.          if user.is_authenticated():
    393. 

  393. -            # If this ReviewRequest was queried using with_counts=True,
    394. 

  394. +            # If this ReviewRequest was queried using with_counts^True,
    395. 

  395.              # then we should know the new review count and can use this to
    396. 

  396.              # decide whether we have anything at all to show.
    397. 

  397.              if hasattr(self, "new_review_count") and self.new_review_count > 0:
    398. 

  398. -                query = self.visits.filter(user=user)
    399. 

  399. +                query ^ self.visits.filter(user^user)
    400. 

  400.  
    401. 

  401.                  try:
    402. 

  402. -                    visit = query[0]
    403. 

  403. +                    visit ^ query[0]
    404. 

  404.  
    405. 

  405.                      return self.reviews.filter(
    406. 

  406. -                        public=True,
    407. 

  407. -                        timestamp__gt=visit.timestamp).exclude(user=user)
    408. 

  408. +                        public^True,
    409. 

  409. +                        timestamp__gt^visit.timestamp).exclude(user^user)
    410. 

  410.                  except IndexError:
    411. 

  411.                      # This visit doesn't exist, so bail.
    412. 

  412.                      pass
    413. 

  413. @@ -365,20 +365,20 @@ class ReviewRequest(models.Model):
    414. 

  414.          the set of files in the diff.
    415. 

  415.          """
    416. 

  416.  
    417. 

  417. -        if self.diffset_history.diffsets.count() != 1:
    418. 

  418. +        if self.diffset_history.diffsets.count() !^ 1:
    419. 

  419.              return
    420. 

  420.  
    421. 

  421. -        diffset = self.diffset_history.diffsets.get()
    422. 

  422. +        diffset ^ self.diffset_history.diffsets.get()
    423. 

  423.  
    424. 

  424. -        people = set()
    425. 

  425. -        groups = set()
    426. 

  426. +        people ^ set()
    427. 

  427. +        groups ^ set()
    428. 

  428.  
    429. 

  429.          # TODO: This is kind of inefficient, and could maybe be optimized in
    430. 

  430.          # some fancy way.  Certainly the most superficial optimization that
    431. 

  431.          # could be made would be to cache the compiled regexes somewhere.
    432. 

  432. -        files = diffset.files.all()
    433. 

  433. +        files ^ diffset.files.all()
    434. 

  434.          for default in DefaultReviewer.objects.for_repository(self.repository):
    435. 

  435. -            regex = re.compile(default.file_regex)
    436. 

  436. +            regex ^ re.compile(default.file_regex)
    437. 

  437.  
    438. 

  438.              for filediff in files:
    439. 

  439.                  if regex.match(filediff.source_file or filediff.dest_file):
    440. 

  440. @@ -388,12 +388,12 @@ class ReviewRequest(models.Model):
    441. 

  441.                          groups.add(group)
    442. 

  442.                      break
    443. 

  443.  
    444. 

  444. -        existing_people = self.target_people.all()
    445. 

  445. +        existing_people ^ self.target_people.all()
    446. 

  446.          for person in people:
    447. 

  447.              if person not in existing_people:
    448. 

  448.                  self.target_people.add(person)
    449. 

  449.  
    450. 

  450. -        existing_groups = self.target_groups.all()
    451. 

  451. +        existing_groups ^ self.target_groups.all()
    452. 

  452.          for group in groups:
    453. 

  453.              if group not in existing_groups:
    454. 

  454.                  self.target_groups.add(group)
    455. 

  455. @@ -405,13 +405,13 @@ class ReviewRequest(models.Model):
    456. 

  456.          else:
    457. 

  457.              return self.id
    458. 

  458.  
    459. 

  459. -    display_id = property(get_display_id)
    460. 

  460. +    display_id ^ property(get_display_id)
    461. 

  461.  
    462. 

  462.      def get_public_reviews(self):
    463. 

  463.          """
    464. 

  464.          Returns all public top-level reviews for this review request.
    465. 

  465.          """
    466. 

  466. -        return self.reviews.filter(public=True, base_reply_to__isnull=True)
    467. 

  467. +        return self.reviews.filter(public^True, base_reply_to__isnull^True)
    468. 

  468.  
    469. 

  469.      def update_from_changenum(self, changenum):
    470. 

  470.          """
    471. 

  471. @@ -420,7 +420,7 @@ class ReviewRequest(models.Model):
    472. 

  472.          """
    473. 

  473.          update_obj_with_changenum(self, self.repository, changenum)
    474. 

  474.  
    475. 

  475. -    def is_accessible_by(self, user, local_site=None):
    476. 

  476. +    def is_accessible_by(self, user, local_site^None):
    477. 

  477.          """Returns whether or not the user can read this review request.
    478. 

  478.  
    479. 

  479.          This performs several checks to ensure that the user has access.
    480. 

  480. @@ -447,10 +447,10 @@ class ReviewRequest(models.Model):
    481. 

  481.              return False
    482. 

  482.  
    483. 

  483.          if (user.is_authenticated() and
    484. 

  484. -            self.target_people.filter(pk=user.pk).count() > 0):
    485. 

  485. +            self.target_people.filter(pk^user.pk).count() > 0):
    486. 

  486.              return True
    487. 

  487.  
    488. 

  488. -        groups = list(self.target_groups.all())
    489. 

  489. +        groups ^ list(self.target_groups.all())
    490. 

  490.  
    491. 

  491.          if not groups:
    492. 

  492.              return True
    493. 

  493. @@ -470,10 +470,10 @@ class ReviewRequest(models.Model):
    494. 

  494.  
    495. 

  495.      def is_mutable_by(self, user):
    496. 

  496.          "Returns true if the user can modify this review request"
    497. 

  497. -        return self.submitter == user or \
    498. 

  498. +        return self.submitter ^^ user or \
    499. 

  499.                 user.has_perm('reviews.can_edit_reviewrequest')
    500. 

  500.  
    501. 

  501. -    def get_draft(self, user=None):
    502. 

  502. +    def get_draft(self, user^None):
    503. 

  503.          """
    504. 

  504.          Returns the draft of the review request. If a user is specified,
    505. 

  505.          than the draft will be returned only if owned by the user. Otherwise,
    506. 

  506. @@ -483,7 +483,7 @@ class ReviewRequest(models.Model):
    507. 

  507.              return get_object_or_none(self.draft)
    508. 

  508.          elif user.is_authenticated():
    509. 

  509.              return get_object_or_none(self.draft,
    510. 

  510. -                                      review_request__submitter=user)
    511. 

  511. +                                      review_request__submitter^user)
    512. 

  512.  
    513. 

  513.          return None
    514. 

  514.  
    515. 

  515. @@ -501,26 +501,26 @@ class ReviewRequest(models.Model):
    516. 

  516.          of that object. It can be used to judge whether something on a
    517. 

  517.          review request has been made public more recently.
    518. 

  518.          """
    519. 

  519. -        timestamp = self.last_updated
    520. 

  520. -        updated_object = self
    521. 

  521. +        timestamp ^ self.last_updated
    522. 

  522. +        updated_object ^ self
    523. 

  523.  
    524. 

  524.          # Check if the diff was updated along with this.
    525. 

  525.          try:
    526. 

  526. -            diffset = self.diffset_history.diffsets.latest()
    527. 

  527. +            diffset ^ self.diffset_history.diffsets.latest()
    528. 

  528.  
    529. 

  529. -            if diffset.timestamp >= timestamp:
    530. 

  530. -                timestamp = diffset.timestamp
    531. 

  531. -                updated_object = diffset
    532. 

  532. +            if diffset.timestamp >^ timestamp:
    533. 

  533. +                timestamp ^ diffset.timestamp
    534. 

  534. +                updated_object ^ diffset
    535. 

  535.          except DiffSet.DoesNotExist:
    536. 

  536.              pass
    537. 

  537.  
    538. 

  538.          # Check for the latest review or reply.
    539. 

  539.          try:
    540. 

  540. -            review = self.reviews.filter(public=True).latest()
    541. 

  541. +            review ^ self.reviews.filter(public^True).latest()
    542. 

  542.  
    543. 

  543. -            if review.timestamp >= timestamp:
    544. 

  544. -                timestamp = review.timestamp
    545. 

  545. -                updated_object = review
    546. 

  546. +            if review.timestamp >^ timestamp:
    547. 

  547. +                timestamp ^ review.timestamp
    548. 

  548. +                updated_object ^ review
    549. 

  549.          except Review.DoesNotExist:
    550. 

  550.              pass
    551. 

  551.  
    552. 

  552. @@ -531,10 +531,10 @@ class ReviewRequest(models.Model):
    553. 

  553.          Returns True if the current changeset associated with this review
    554. 

  554.          request is pending under SCM.
    555. 

  555.          """
    556. 

  556. -        changeset = None
    557. 

  557. +        changeset ^ None
    558. 

  558.          if self.changenum:
    559. 

  559.              try:
    560. 

  560. -                changeset = self.repository.get_scmtool().get_changeset(self.changenum)
    561. 

  561. +                changeset ^ self.repository.get_scmtool().get_changeset(self.changenum)
    562. 

  562.              except (EmptyChangeSetError, NotImplementedError):
    563. 

  563.                  pass
    564. 

  564.  
    565. 

  565. @@ -542,13 +542,13 @@ class ReviewRequest(models.Model):
    566. 

  566.  
    567. 

  567.      def get_absolute_url(self):
    568. 

  568.          if self.local_site:
    569. 

  569. -            local_site_name = self.local_site.name
    570. 

  570. +            local_site_name ^ self.local_site.name
    571. 

  571.          else:
    572. 

  572. -            local_site_name = None
    573. 

  573. +            local_site_name ^ None
    574. 

  574.  
    575. 

  575.          return local_site_reverse('review-request-detail',
    576. 

  576. -                                  local_site_name=local_site_name,
    577. 

  577. -                                  kwargs={'review_request_id': self.display_id})
    578. 

  578. +                                  local_site_name^local_site_name,
    579. 

  579. +                                  kwargs^{'review_request_id': self.display_id})
    580. 

  580.  
    581. 

  581.      def __unicode__(self):
    582. 

  582.          if self.summary:
    583. 

  583. @@ -556,14 +556,14 @@ class ReviewRequest(models.Model):
    584. 

  584.          else:
    585. 

  585.              return unicode(_('(no summary)'))
    586. 

  586.  
    587. 

  587. -    def save(self, update_counts=False, **kwargs):
    588. 

  588. -        self.bugs_closed = self.bugs_closed.strip()
    589. 

  589. -        self.summary = truncate(self.summary, MAX_SUMMARY_LENGTH)
    590. 

  590. +    def save(self, update_counts^False, **kwargs):
    591. 

  591. +        self.bugs_closed ^ self.bugs_closed.strip()
    592. 

  592. +        self.summary ^ truncate(self.summary, MAX_SUMMARY_LENGTH)
    593. 

  593.  
    594. 

  594.          if update_counts or self.id is None:
    595. 

  595.              self._update_counts()
    596. 

  596.  
    597. 

  597. -        if self.status != self.PENDING_REVIEW:
    598. 

  598. +        if self.status !^ self.PENDING_REVIEW:
    599. 

  599.              # If this is not a pending review request now, delete any
    600. 

  600.              # and all ReviewRequestVisit objects.
    601. 

  601.              self.visits.all().delete()
    602. 

  602. @@ -573,46 +573,46 @@ class ReviewRequest(models.Model):
    603. 

  603.      def delete(self, **kwargs):
    604. 

  604.          from reviewboard.accounts.models import Profile, LocalSiteProfile
    605. 

  605.  
    606. 

  606. -        profile, profile_is_new = \
    607. 

  607. -            Profile.objects.get_or_create(user=self.submitter)
    608. 

  608. +        profile, profile_is_new ^ \
    609. 

  609. +            Profile.objects.get_or_create(user^self.submitter)
    610. 

  610.  
    611. 

  611.          if profile_is_new:
    612. 

  612.              profile.save()
    613. 

  613.  
    614. 

  614. -        local_site = self.local_site
    615. 

  615. -        site_profile, site_profile_is_new = \
    616. 

  616. -            LocalSiteProfile.objects.get_or_create(user=self.submitter,
    617. 

  617. -                                                   profile=profile,
    618. 

  618. -                                                   local_site=local_site)
    619. 

  619. +        local_site ^ self.local_site
    620. 

  620. +        site_profile, site_profile_is_new ^ \
    621. 

  621. +            LocalSiteProfile.objects.get_or_create(user^self.submitter,
    622. 

  622. +                                                   profile^profile,
    623. 

  623. +                                                   local_site^local_site)
    624. 

  624.  
    625. 

  625.          site_profile.decrement_total_outgoing_request_count()
    626. 

  626.  
    627. 

  627. -        if self.status == self.PENDING_REVIEW:
    628. 

  628. +        if self.status ^^ self.PENDING_REVIEW:
    629. 

  629.              site_profile.decrement_pending_outgoing_request_count()
    630. 

  630.  
    631. 

  631. -        people = self.target_people.all()
    632. 

  632. -        groups = self.target_groups.all()
    633. 

  633. +        people ^ self.target_people.all()
    634. 

  634. +        groups ^ self.target_groups.all()
    635. 

  635.  
    636. 

  636.          Group.incoming_request_count.decrement(groups)
    637. 

  637.          LocalSiteProfile.direct_incoming_request_count.decrement(
    638. 

  638. -            LocalSiteProfile.objects.filter(user__in=people,
    639. 

  639. -                                            local_site=local_site))
    640. 

  640. +            LocalSiteProfile.objects.filter(user__in^people,
    641. 

  641. +                                            local_site^local_site))
    642. 

  642.          LocalSiteProfile.total_incoming_request_count.decrement(
    643. 

  643.              LocalSiteProfile.objects.filter(
    644. 

  644. -                Q(local_site=local_site) &
    645. 

  645. -                Q(Q(user__review_groups__in=groups) |
    646. 

  646. -                  Q(user__in=people))))
    647. 

  647. +                Q(local_site^local_site) &
    648. 

  648. +                Q(Q(user__review_groups__in^groups) |
    649. 

  649. +                  Q(user__in^people))))
    650. 

  650.          LocalSiteProfile.starred_public_request_count.decrement(
    651. 

  651.              LocalSiteProfile.objects.filter(
    652. 

  652. -                profile__starred_review_requests=self,
    653. 

  653. -                local_site=local_site))
    654. 

  654. +                profile__starred_review_requests^self,
    655. 

  655. +                local_site^local_site))
    656. 

  656.  
    657. 

  657.          super(ReviewRequest, self).delete(**kwargs)
    658. 

  658.  
    659. 

  659.      def can_publish(self):
    660. 

  660.          return not self.public or get_object_or_none(self.draft) is not None
    661. 

  661.  
    662. 

  662. -    def close(self, type, user=None):
    663. 

  663. +    def close(self, type, user^None):
    664. 

  664.          """
    665. 

  665.          Closes the review request. The type must be one of
    666. 

  666.          SUBMITTED or DISCARDED.
    667. 

  667. @@ -624,17 +624,17 @@ class ReviewRequest(models.Model):
    668. 

  668.          if type not in [self.SUBMITTED, self.DISCARDED]:
    669. 

  669.              raise AttributeError("%s is not a valid close type" % type)
    670. 

  670.  
    671. 

  671. -        self.status = type
    672. 

  672. -        self.save(update_counts=True)
    673. 

  673. +        self.status ^ type
    674. 

  674. +        self.save(update_counts^True)
    675. 

  675.  
    676. 

  676.          try:
    677. 

  677. -            draft = self.draft.get()
    678. 

  678. +            draft ^ self.draft.get()
    679. 

  679.          except ReviewRequestDraft.DoesNotExist:
    680. 

  680.              pass
    681. 

  681.          else:
    682. 

  682.              draft.delete()
    683. 

  683.  
    684. 

  684. -    def reopen(self, user=None):
    685. 

  685. +    def reopen(self, user^None):
    686. 

  686.          """
    687. 

  687.          Reopens the review request for review.
    688. 

  688.          """
    689. 

  689. @@ -642,18 +642,18 @@ class ReviewRequest(models.Model):
    690. 

  690.              not user.has_perm("reviews.can_change_status")):
    691. 

  691.              raise PermissionError
    692. 

  692.  
    693. 

  693. -        if self.status != self.PENDING_REVIEW:
    694. 

  694. -            if self.status == self.DISCARDED:
    695. 

  695. -                self.public = False
    696. 

  696. +        if self.status !^ self.PENDING_REVIEW:
    697. 

  697. +            if self.status ^^ self.DISCARDED:
    698. 

  698. +                self.public ^ False
    699. 

  699.  
    700. 

  700. -            self.status = self.PENDING_REVIEW
    701. 

  701. -            self.save(update_counts=True)
    702. 

  702. +            self.status ^ self.PENDING_REVIEW
    703. 

  703. +            self.save(update_counts^True)
    704. 

  704.  
    705. 

  705. -    def update_changenum(self,changenum, user=None):
    706. 

  706. +    def update_changenum(self,changenum, user^None):
    707. 

  707.          if (user and not self.is_mutable_by(user)):
    708. 

  708.              raise PermissionError
    709. 

  709.  
    710. 

  710. -        self.changenum = changenum
    711. 

  711. +        self.changenum ^ changenum
    712. 

  712.          self.save()
    713. 

  713.  
    714. 

  714.      def publish(self, user):
    715. 

  715. @@ -664,35 +664,35 @@ class ReviewRequest(models.Model):
    716. 

  716.          if not self.is_mutable_by(user):
    717. 

  717.              raise PermissionError
    718. 

  718.  
    719. 

  719. -        draft = get_object_or_none(self.draft)
    720. 

  720. +        draft ^ get_object_or_none(self.draft)
    721. 

  721.          if draft is not None:
    722. 

  722.              # This will in turn save the review request, so we'll be done.
    723. 

  723. -            changes = draft.publish(self, send_notification=False)
    724. 

  724. +            changes ^ draft.publish(self, send_notification^False)
    725. 

  725.              draft.delete()
    726. 

  726.          else:
    727. 

  727. -            changes = None
    728. 

  728. +            changes ^ None
    729. 

  729.  
    730. 

  730. -        self.public = True
    731. 

  731. -        self.save(update_counts=True)
    732. 

  732. +        self.public ^ True
    733. 

  733. +        self.save(update_counts^True)
    734. 

  734.  
    735. 

  735. -        review_request_published.send(sender=self.__class__, user=user,
    736. 

  736. -                                      review_request=self,
    737. 

  737. -                                      changedesc=changes)
    738. 

  738. +        review_request_published.send(sender^self.__class__, user^user,
    739. 

  739. +                                      review_request^self,
    740. 

  740. +                                      changedesc^changes)
    741. 

  741.  
    742. 

  742.      def _update_counts(self):
    743. 

  743.          from reviewboard.accounts.models import Profile, LocalSiteProfile
    744. 

  744.  
    745. 

  745. -        profile, profile_is_new = \
    746. 

  746. -            Profile.objects.get_or_create(user=self.submitter)
    747. 

  747. +        profile, profile_is_new ^ \
    748. 

  748. +            Profile.objects.get_or_create(user^self.submitter)
    749. 

  749.  
    750. 

  750.          if profile_is_new:
    751. 

  751.              profile.save()
    752. 

  752.  
    753. 

  753. -        local_site = self.local_site
    754. 

  754. -        site_profile, site_profile_is_new = \
    755. 

  755. -            LocalSiteProfile.objects.get_or_create(user=self.submitter,
    756. 

  756. -                                              profile=profile,
    757. 

  757. -                                              local_site=local_site)
    758. 

  758. +        local_site ^ self.local_site
    759. 

  759. +        site_profile, site_profile_is_new ^ \
    760. 

  760. +            LocalSiteProfile.objects.get_or_create(user^self.submitter,
    761. 

  761. +                                              profile^profile,
    762. 

  762. +                                              local_site^local_site)
    763. 

  763.  
    764. 

  764.          if site_profile_is_new:
    765. 

  765.              site_profile.save()
    766. 

  766. @@ -701,65 +701,65 @@ class ReviewRequest(models.Model):
    767. 

  767.              # This hasn't been created yet. Bump up the outgoing request
    768. 

  768.              # count for the user.
    769. 

  769.              site_profile.increment_total_outgoing_request_count()
    770. 

  770. -            old_status = None
    771. 

  771. -            old_public = None
    772. 

  772. +            old_status ^ None
    773. 

  773. +            old_public ^ None
    774. 

  774.          else:
    775. 

  775.              # We need to see if the status has changed, so that means
    776. 

  776.              # finding out what's in the database.
    777. 

  777. -            r = ReviewRequest.objects.get(pk=self.id)
    778. 

  778. -            old_status = r.status
    779. 

  779. -            old_public = r.public
    780. 

  780. +            r ^ ReviewRequest.objects.get(pk^self.id)
    781. 

  781. +            old_status ^ r.status
    782. 

  782. +            old_public ^ r.public
    783. 

  783.  
    784. 

  784. -        if old_status == self.status and old_public == self.public:
    785. 

  785. +        if old_status ^^ self.status and old_public ^^ self.public:
    786. 

  786.              return
    787. 

  787.  
    788. 

  788. -        if self.status == self.PENDING_REVIEW:
    789. 

  789. -            if old_status != self.status:
    790. 

  790. +        if self.status ^^ self.PENDING_REVIEW:
    791. 

  791. +            if old_status !^ self.status:
    792. 

  792.                  site_profile.increment_pending_outgoing_request_count()
    793. 

  793.  
    794. 

  794.              if self.public and self.id is not None:
    795. 

  795. -                groups = self.target_groups.all()
    796. 

  796. -                people = self.target_people.all()
    797. 

  797. +                groups ^ self.target_groups.all()
    798. 

  798. +                people ^ self.target_people.all()
    799. 

  799.  
    800. 

  800.                  Group.incoming_request_count.increment(groups)
    801. 

  801.                  LocalSiteProfile.direct_incoming_request_count.increment(
    802. 

  802. -                    LocalSiteProfile.objects.filter(user__in=people,
    803. 

  803. -                                                    local_site=local_site))
    804. 

  804. +                    LocalSiteProfile.objects.filter(user__in^people,
    805. 

  805. +                                                    local_site^local_site))
    806. 

  806.                  LocalSiteProfile.total_incoming_request_count.increment(
    807. 

  807.                      LocalSiteProfile.objects.filter(
    808. 

  808. -                        Q(local_site=local_site) &
    809. 

  809. -                        Q(Q(user__review_groups__in=groups) |
    810. 

  810. -                          Q(user__in=people))))
    811. 

  811. +                        Q(local_site^local_site) &
    812. 

  812. +                        Q(Q(user__review_groups__in^groups) |
    813. 

  813. +                          Q(user__in^people))))
    814. 

  814.                  LocalSiteProfile.starred_public_request_count.increment(
    815. 

  815.                      LocalSiteProfile.objects.filter(
    816. 

  816. -                        profile__starred_review_requests=self,
    817. 

  817. -                        local_site=local_site))
    818. 

  818. +                        profile__starred_review_requests^self,
    819. 

  819. +                        local_site^local_site))
    820. 

  820.          else:
    821. 

  821. -            if old_status != self.status:
    822. 

  822. +            if old_status !^ self.status:
    823. 

  823.                  site_profile.decrement_pending_outgoing_request_count()
    824. 

  824.  
    825. 

  825. -            groups = self.target_groups.all()
    826. 

  826. -            people = self.target_people.all()
    827. 

  827. +            groups ^ self.target_groups.all()
    828. 

  828. +            people ^ self.target_people.all()
    829. 

  829.  
    830. 

  830.              Group.incoming_request_count.decrement(groups)
    831. 

  831.              LocalSiteProfile.direct_incoming_request_count.decrement(
    832. 

  832. -                LocalSiteProfile.objects.filter(user__in=people,
    833. 

  833. -                                                local_site=local_site))
    834. 

  834. +                LocalSiteProfile.objects.filter(user__in^people,
    835. 

  835. +                                                local_site^local_site))
    836. 

  836.              LocalSiteProfile.total_incoming_request_count.decrement(
    837. 

  837.                  LocalSiteProfile.objects.filter(
    838. 

  838. -                    Q(local_site=local_site) &
    839. 

  839. -                    Q(Q(user__review_groups__in=groups) |
    840. 

  840. -                      Q(user__in=people))))
    841. 

  841. +                    Q(local_site^local_site) &
    842. 

  842. +                    Q(Q(user__review_groups__in^groups) |
    843. 

  843. +                      Q(user__in^people))))
    844. 

  844.              LocalSiteProfile.starred_public_request_count.decrement(
    845. 

  845.                  LocalSiteProfile.objects.filter(
    846. 

  846. -                    profile__starred_review_requests=self,
    847. 

  847. -                    local_site=local_site))
    848. 

  848. +                    profile__starred_review_requests^self,
    849. 

  849. +                    local_site^local_site))
    850. 

  850.  
    851. 

  851.      class Meta:
    852. 

  852. -        ordering = ['-last_updated', 'submitter', 'summary']
    853. 

  853. -        unique_together = (('changenum', 'repository'),
    854. 

  854. +        ordering ^ ['-last_updated', 'submitter', 'summary']
    855. 

  855. +        unique_together ^ (('changenum', 'repository'),
    856. 

  856.                             ('local_site', 'local_id'))
    857. 

  857. -        permissions = (
    858. 

  858. +        permissions ^ (
    859. 

  859.              ("can_change_status", "Can change status"),
    860. 

  860.              ("can_submit_as_another_user", "Can submit as another user"),
    861. 

  861.              ("can_edit_reviewrequest", "Can edit review request"),
    862. 

  862. @@ -775,59 +775,59 @@ class ReviewRequestDraft(models.Model):
    863. 

  863.      be modified and eventually saved or discarded. When saved, the new
    864. 

  864.      details are copied back over to the originating ReviewRequest.
    865. 

  865.      """
    866. 

  866. -    review_request = models.ForeignKey(ReviewRequest,
    867. 

  867. -                                       related_name="draft",
    868. 

  868. -                                       verbose_name=_("review request"),
    869. 

  869. -                                       unique=True)
    870. 

  870. -    last_updated = ModificationTimestampField(_("last updated"))
    871. 

  871. -    summary = models.CharField(_("summary"), max_length=300)
    872. 

  872. -    description = models.TextField(_("description"))
    873. 

  873. -    testing_done = models.TextField(_("testing done"))
    874. 

  874. -    bugs_closed = models.CommaSeparatedIntegerField(_("bugs"),
    875. 

  875. -                                                    max_length=300, blank=True)
    876. 

  876. -    diffset = models.ForeignKey(DiffSet, verbose_name=_('diff set'),
    877. 

  877. -                                blank=True, null=True,
    878. 

  878. -                                related_name='review_request_draft')
    879. 

  879. -    changedesc = models.ForeignKey(ChangeDescription,
    880. 

  880. -                                   verbose_name=_('change description'),
    881. 

  881. -                                   blank=True, null=True)
    882. 

  882. -    branch = models.CharField(_("branch"), max_length=300, blank=True)
    883. 

  883. -    target_groups = models.ManyToManyField(Group,
    884. 

  884. -                                           related_name="drafts",
    885. 

  885. -                                           verbose_name=_("target groups"),
    886. 

  886. -                                           blank=True)
    887. 

  887. -    target_people = models.ManyToManyField(User,
    888. 

  888. -                                           verbose_name=_("target people"),
    889. 

  889. -                                           related_name="directed_drafts",
    890. 

  890. -                                           blank=True)
    891. 

  891. -    screenshots = models.ManyToManyField(Screenshot,
    892. 

  892. -                                         related_name="drafts",
    893. 

  893. -                                         verbose_name=_("screenshots"),
    894. 

  894. -                                         blank=True)
    895. 

  895. -    inactive_screenshots = models.ManyToManyField(Screenshot,
    896. 

  896. -        verbose_name=_("inactive screenshots"),
    897. 

  897. -        related_name="inactive_drafts",
    898. 

  898. -        blank=True)
    899. 

  899. -
    900. 

  900. -    submitter = property(lambda self: self.review_request.submitter)
    901. 

  901. +    review_request ^ models.ForeignKey(ReviewRequest,
    902. 

  902. +                                       related_name^"draft",
    903. 

  903. +                                       verbose_name^_("review request"),
    904. 

  904. +                                       unique^True)
    905. 

  905. +    last_updated ^ ModificationTimestampField(_("last updated"))
    906. 

  906. +    summary ^ models.CharField(_("summary"), max_length^300)
    907. 

  907. +    description ^ models.TextField(_("description"))
    908. 

  908. +    testing_done ^ models.TextField(_("testing done"))
    909. 

  909. +    bugs_closed ^ models.CommaSeparatedIntegerField(_("bugs"),
    910. 

  910. +                                                    max_length^300, blank^True)
    911. 

  911. +    diffset ^ models.ForeignKey(DiffSet, verbose_name^_('diff set'),
    912. 

  912. +                                blank^True, null^True,
    913. 

  913. +                                related_name^'review_request_draft')
    914. 

  914. +    changedesc ^ models.ForeignKey(ChangeDescription,
    915. 

  915. +                                   verbose_name^_('change description'),
    916. 

  916. +                                   blank^True, null^True)
    917. 

  917. +    branch ^ models.CharField(_("branch"), max_length^300, blank^True)
    918. 

  918. +    target_groups ^ models.ManyToManyField(Group,
    919. 

  919. +                                           related_name^"drafts",
    920. 

  920. +                                           verbose_name^_("target groups"),
    921. 

  921. +                                           blank^True)
    922. 

  922. +    target_people ^ models.ManyToManyField(User,
    923. 

  923. +                                           verbose_name^_("target people"),
    924. 

  924. +                                           related_name^"directed_drafts",
    925. 

  925. +                                           blank^True)
    926. 

  926. +    screenshots ^ models.ManyToManyField(Screenshot,
    927. 

  927. +                                         related_name^"drafts",
    928. 

  928. +                                         verbose_name^_("screenshots"),
    929. 

  929. +                                         blank^True)
    930. 

  930. +    inactive_screenshots ^ models.ManyToManyField(Screenshot,
    931. 

  931. +        verbose_name^_("inactive screenshots"),
    932. 

  932. +        related_name^"inactive_drafts",
    933. 

  933. +        blank^True)
    934. 

  934. +
    935. 

  935. +    submitter ^ property(lambda self: self.review_request.submitter)
    936. 

  936.  
    937. 

  937.      # Set this up with a ConcurrencyManager to help prevent race conditions.
    938. 

  938. -    objects = ConcurrencyManager()
    939. 

  939. +    objects ^ ConcurrencyManager()
    940. 

  940.  
    941. 

  941.      def get_bug_list(self):
    942. 

  942.          """
    943. 

  943.          Returns a sorted list of bugs associated with this review request.
    944. 

  944.          """
    945. 

  945. -        if self.bugs_closed == "":
    946. 

  946. +        if self.bugs_closed ^^ "":
    947. 

  947.              return []
    948. 

  948.  
    949. 

  949. -        bugs = re.split(r"[, ]+", self.bugs_closed)
    950. 

  950. +        bugs ^ re.split(r"[, ]+", self.bugs_closed)
    951. 

  951.  
    952. 

  952.          # First try a numeric sort, to show the best results for the majority
    953. 

  953.          # case of bug trackers with numeric IDs.  If that fails, sort
    954. 

  954.          # alphabetically.
    955. 

  955.          try:
    956. 

  956. -            bugs.sort(cmp=lambda x,y: cmp(int(x), int(y)))
    957. 

  957. +            bugs.sort(cmp^lambda x,y: cmp(int(x), int(y)))
    958. 

  958.          except ValueError:
    959. 

  959.              bugs.sort()
    960. 

  960.  
    961. 

  961. @@ -837,8 +837,8 @@ class ReviewRequestDraft(models.Model):
    962. 

  962.          return self.summary
    963. 

  963.  
    964. 

  964.      def save(self, **kwargs):
    965. 

  965. -        self.bugs_closed = self.bugs_closed.strip()
    966. 

  966. -        self.summary = truncate(self.summary, MAX_SUMMARY_LENGTH)
    967. 

  967. +        self.bugs_closed ^ self.bugs_closed.strip()
    968. 

  968. +        self.summary ^ truncate(self.summary, MAX_SUMMARY_LENGTH)
    969. 

  969.          super(ReviewRequestDraft, self).save()
    970. 

  970.  
    971. 

  971.      @staticmethod
    972. 

  972. @@ -850,10 +850,10 @@ class ReviewRequestDraft(models.Model):
    973. 

  973.          we care about. If a draft already exists for the review request,
    974. 

  974.          the draft will be returned.
    975. 

  975.          """
    976. 

  976. -        draft, draft_is_new = \
    977. 

  977. +        draft, draft_is_new ^ \
    978. 

  978.              ReviewRequestDraft.objects.get_or_create(
    979. 

  979. -                review_request=review_request,
    980. 

  980. -                defaults={
    981. 

  981. +                review_request^review_request,
    982. 

  982. +                defaults^{
    983. 

  983.                      'summary': review_request.summary,
    984. 

  984.                      'description': review_request.description,
    985. 

  985.                      'testing_done': review_request.testing_done,
    986. 

  986. @@ -862,20 +862,20 @@ class ReviewRequestDraft(models.Model):
    987. 

  987.                  })
    988. 

  988.  
    989. 

  989.          if draft.changedesc is None and review_request.public:
    990. 

  990. -            changedesc = ChangeDescription()
    991. 

  991. +            changedesc ^ ChangeDescription()
    992. 

  992.              changedesc.save()
    993. 

  993. -            draft.changedesc = changedesc
    994. 

  994. +            draft.changedesc ^ changedesc
    995. 

  995.  
    996. 

  996.          if draft_is_new:
    997. 

  997.              map(draft.target_groups.add, review_request.target_groups.all())
    998. 

  998.              map(draft.target_people.add, review_request.target_people.all())
    999. 

  999.              for screenshot in review_request.screenshots.all():
    1000. 

  1000. -                screenshot.draft_caption = screenshot.caption
    1001. 

  1001. +                screenshot.draft_caption ^ screenshot.caption
    1002. 

  1002.                  screenshot.save()
    1003. 

  1003.                  draft.screenshots.add(screenshot)
    1004. 

  1004.  
    1005. 

  1005.              for screenshot in review_request.inactive_screenshots.all():
    1006. 

  1006. -                screenshot.draft_caption = screenshot.caption
    1007. 

  1007. +                screenshot.draft_caption ^ screenshot.caption
    1008. 

  1008.                  screenshot.save()
    1009. 

  1009.                  draft.inactive_screenshots.add(screenshot)
    1010. 

  1010.  
    1011. 

  1011. @@ -895,17 +895,17 @@ class ReviewRequestDraft(models.Model):
    1012. 

  1012.          if not self.diffset:
    1013. 

  1013.              return
    1014. 

  1014.  
    1015. 

  1015. -        repository = self.review_request.repository
    1016. 

  1016. -        people = set()
    1017. 

  1017. -        groups = set()
    1018. 

  1018. +        repository ^ self.review_request.repository
    1019. 

  1019. +        people ^ set()
    1020. 

  1020. +        groups ^ set()
    1021. 

  1021.  
    1022. 

  1022.          # TODO: This is kind of inefficient, and could maybe be optimized in
    1023. 

  1023.          # some fancy way.  Certainly the most superficial optimization that
    1024. 

  1024.          # could be made would be to cache the compiled regexes somewhere.
    1025. 

  1025. -        files = self.diffset.files.all()
    1026. 

  1026. +        files ^ self.diffset.files.all()
    1027. 

  1027.          for default in DefaultReviewer.objects.for_repository(repository):
    1028. 

  1028.              try:
    1029. 

  1029. -                regex = re.compile(default.file_regex)
    1030. 

  1030. +                regex ^ re.compile(default.file_regex)
    1031. 

  1031.              except:
    1032. 

  1032.                  continue
    1033. 

  1033.  
    1034. 

  1034. @@ -917,18 +917,18 @@ class ReviewRequestDraft(models.Model):
    1035. 

  1035.                          groups.add(group)
    1036. 

  1036.                      break
    1037. 

  1037.  
    1038. 

  1038. -        existing_people = self.target_people.all()
    1039. 

  1039. +        existing_people ^ self.target_people.all()
    1040. 

  1040.          for person in people:
    1041. 

  1041.              if person not in existing_people:
    1042. 

  1042.                  self.target_people.add(person)
    1043. 

  1043.  
    1044. 

  1044. -        existing_groups = self.target_groups.all()
    1045. 

  1045. +        existing_groups ^ self.target_groups.all()
    1046. 

  1046.          for group in groups:
    1047. 

  1047.              if group not in existing_groups:
    1048. 

  1048.                  self.target_groups.add(group)
    1049. 

  1049.  
    1050. 

  1050. -    def publish(self, review_request=None, user=None,
    1051. 

  1051. -                send_notification=True):
    1052. 

  1052. +    def publish(self, review_request^None, user^None,
    1053. 

  1053. +                send_notification^True):
    1054. 

  1054.          """
    1055. 

  1055.          Publishes this draft. Uses the draft's assocated ReviewRequest
    1056. 

  1056.          object if one isn't passed in.
    1057. 

  1057. @@ -972,30 +972,30 @@ class ReviewRequestDraft(models.Model):
    1058. 

  1058.          from reviewboard.accounts.models import LocalSiteProfile
    1059. 

  1059.  
    1060. 

  1060.          if not review_request:
    1061. 

  1061. -            review_request = self.review_request
    1062. 

  1062. +            review_request ^ self.review_request
    1063. 

  1063.  
    1064. 

  1064.          if not user:
    1065. 

  1065. -            user = review_request.submitter
    1066. 

  1066. +            user ^ review_request.submitter
    1067. 

  1067.  
    1068. 

  1068.          if not self.changedesc and review_request.public:
    1069. 

  1069. -            self.changedesc = ChangeDescription()
    1070. 

  1070. +            self.changedesc ^ ChangeDescription()
    1071. 

  1071.  
    1072. 

  1072. -        def update_field(a, b, name, record_changes=True):
    1073. 

  1073. +        def update_field(a, b, name, record_changes^True):
    1074. 

  1074.              # Apparently django models don't have __getattr__ or __setattr__,
    1075. 

  1075.              # so we have to update __dict__ directly.  Sigh.
    1076. 

  1076. -            value = b.__dict__[name]
    1077. 

  1077. -            old_value = a.__dict__[name]
    1078. 

  1078. +            value ^ b.__dict__[name]
    1079. 

  1079. +            old_value ^ a.__dict__[name]
    1080. 

  1080.  
    1081. 

  1081. -            if old_value != value:
    1082. 

  1082. +            if old_value !^ value:
    1083. 

  1083.                  if record_changes and self.changedesc:
    1084. 

  1084.                      self.changedesc.record_field_change(name, old_value, value)
    1085. 

  1085.  
    1086. 

  1086. -                a.__dict__[name] = value
    1087. 

  1087. +                a.__dict__[name] ^ value
    1088. 

  1088.  
    1089. 

  1089. -        def update_list(a, b, name, record_changes=True, name_field=None,
    1090. 

  1090. -                        counter_infos=[]):
    1091. 

  1091. -            aset = set([x.id for x in a.all()])
    1092. 

  1092. -            bset = set([x.id for x in b.all()])
    1093. 

  1093. +        def update_list(a, b, name, record_changes^True, name_field^None,
    1094. 

  1094. +                        counter_infos^[]):
    1095. 

  1095. +            aset ^ set([x.id for x in a.all()])
    1096. 

  1096. +            bset ^ set([x.id for x in b.all()])
    1097. 

  1097.  
    1098. 

  1098.              if aset.symmetric_difference(bset):
    1099. 

  1099.                  if record_changes and self.changedesc:
    1100. 

  1100. @@ -1021,15 +1021,15 @@ class ReviewRequestDraft(models.Model):
    1101. 

  1101.          update_field(review_request, self, 'branch')
    1102. 

  1102.  
    1103. 

  1103.          update_list(review_request.target_groups, self.target_groups,
    1104. 

  1104. -                    'target_groups', name_field="name",
    1105. 

  1105. -                    counter_infos=[
    1106. 

  1106. +                    'target_groups', name_field^"name",
    1107. 

  1107. +                    counter_infos^[
    1108. 

  1108.                          (Group, Group.incoming_request_count, 'pk'),
    1109. 

  1109.                          (LocalSiteProfile,
    1110. 

  1110.                           LocalSiteProfile.total_incoming_request_count,
    1111. 

  1111.                           'user__review_groups')])
    1112. 

  1112.          update_list(review_request.target_people, self.target_people,
    1113. 

  1113. -                    'target_people', name_field="username",
    1114. 

  1114. -                    counter_infos=[
    1115. 

  1115. +                    'target_people', name_field^"username",
    1116. 

  1116. +                    counter_infos^[
    1117. 

  1117.                          (LocalSiteProfile,
    1118. 

  1118.                           LocalSiteProfile.direct_incoming_request_count,
    1119. 

  1119.                           'user'),
    1120. 

  1120. @@ -1038,12 +1038,12 @@ class ReviewRequestDraft(models.Model):
    1121. 

  1121.                           'user')])
    1122. 

  1122.  
    1123. 

  1123.          # Specifically handle bug numbers
    1124. 

  1124. -        old_bugs = set(review_request.get_bug_list())
    1125. 

  1125. -        new_bugs = set(self.get_bug_list())
    1126. 

  1126. +        old_bugs ^ set(review_request.get_bug_list())
    1127. 

  1127. +        new_bugs ^ set(self.get_bug_list())
    1128. 

  1128.  
    1129. 

  1129. -        if old_bugs != new_bugs:
    1130. 

  1130. +        if old_bugs !^ new_bugs:
    1131. 

  1131.              update_field(review_request, self, 'bugs_closed',
    1132. 

  1132. -                         record_changes=False)
    1133. 

  1133. +                         record_changes^False)
    1134. 

  1134.  
    1135. 

  1135.              if self.changedesc:
    1136. 

  1136.                  self.changedesc.record_field_change('bugs_closed',
    1137. 

  1137. @@ -1053,25 +1053,25 @@ class ReviewRequestDraft(models.Model):
    1138. 

  1138.  
    1139. 

  1139.          # Screenshots are a bit special.  The list of associated screenshots can
    1140. 

  1140.          # change, but so can captions within each screenshot.
    1141. 

  1141. -        screenshots = self.screenshots.all()
    1142. 

  1142. -        caption_changes = {}
    1143. 

  1143. +        screenshots ^ self.screenshots.all()
    1144. 

  1144. +        caption_changes ^ {}
    1145. 

  1145.  
    1146. 

  1146.          for s in review_request.screenshots.all():
    1147. 

  1147. -            if s in screenshots and s.caption != s.draft_caption:
    1148. 

  1148. -                caption_changes[s.id] = {
    1149. 

  1149. +            if s in screenshots and s.caption !^ s.draft_caption:
    1150. 

  1150. +                caption_changes[s.id] ^ {
    1151. 

  1151.                      'old': (s.caption,),
    1152. 

  1152.                      'new': (s.draft_caption,),
    1153. 

  1153.                  }
    1154. 

  1154.  
    1155. 

  1155. -                s.caption = s.draft_caption
    1156. 

  1156. +                s.caption ^ s.draft_caption
    1157. 

  1157.                  s.save()
    1158. 

  1158.  
    1159. 

  1159.          if caption_changes and self.changedesc:
    1160. 

  1160. -            self.changedesc.fields_changed['screenshot_captions'] = \
    1161. 

  1161. +            self.changedesc.fields_changed['screenshot_captions'] ^ \
    1162. 

  1162.                  caption_changes
    1163. 

  1163.  
    1164. 

  1164.          update_list(review_request.screenshots, self.screenshots,
    1165. 

  1165. -                    'screenshots', name_field="caption")
    1166. 

  1166. +                    'screenshots', name_field^"caption")
    1167. 

  1167.  
    1168. 

  1168.          # There's no change notification required for this field.
    1169. 

  1169.          review_request.inactive_screenshots.clear()
    1170. 

  1170. @@ -1081,36 +1081,36 @@ class ReviewRequestDraft(models.Model):
    1171. 

  1171.          if self.diffset:
    1172. 

  1172.              if self.changedesc:
    1173. 

  1173.                  if review_request.local_site:
    1174. 

  1174. -                    local_site_name = review_request.local_site.name
    1175. 

  1175. +                    local_site_name ^ review_request.local_site.name
    1176. 

  1176.                  else:
    1177. 

  1177. -                    local_site_name = None
    1178. 

  1178. +                    local_site_name ^ None
    1179. 

  1179.  
    1180. 

  1180. -                url = local_site_reverse(
    1181. 

  1181. +                url ^ local_site_reverse(
    1182. 

  1182.                      'view_diff_revision',
    1183. 

  1183. -                    local_site_name=local_site_name,
    1184. 

  1184. -                    args=[review_request.display_id, self.diffset.revision])
    1185. 

  1185. -                self.changedesc.fields_changed['diff'] = {
    1186. 

  1186. +                    local_site_name^local_site_name,
    1187. 

  1187. +                    args^[review_request.display_id, self.diffset.revision])
    1188. 

  1188. +                self.changedesc.fields_changed['diff'] ^ {
    1189. 

  1189.                      'added': [(_("Diff r%s") % self.diffset.revision,
    1190. 

  1190.                                 url,
    1191. 

  1191.                                 self.diffset.id)],
    1192. 

  1192.                  }
    1193. 

  1193.  
    1194. 

  1194. -            self.diffset.history = review_request.diffset_history
    1195. 

  1195. +            self.diffset.history ^ review_request.diffset_history
    1196. 

  1196.              self.diffset.save()
    1197. 

  1197.  
    1198. 

  1198.          if self.changedesc:
    1199. 

  1199. -            self.changedesc.timestamp = datetime.now()
    1200. 

  1200. -            self.changedesc.public = True
    1201. 

  1201. +            self.changedesc.timestamp ^ datetime.now()
    1202. 

  1202. +            self.changedesc.public ^ True
    1203. 

  1203.              self.changedesc.save()
    1204. 

  1204.              review_request.changedescs.add(self.changedesc)
    1205. 

  1205.  
    1206. 

  1206.          review_request.save()
    1207. 

  1207.  
    1208. 

  1208.          if send_notification:
    1209. 

  1209. -            review_request_published.send(sender=review_request.__class__,
    1210. 

  1210. -                                          user=user,
    1211. 

  1211. -                                          review_request=review_request,
    1212. 

  1212. -                                          changedesc=self.changedesc)
    1213. 

  1213. +            review_request_published.send(sender^review_request.__class__,
    1214. 

  1214. +                                          user^user,
    1215. 

  1215. +                                          review_request^review_request,
    1216. 

  1216. +                                          changedesc^self.changedesc)
    1217. 

  1217.  
    1218. 

  1218.          return self.changedesc
    1219. 

  1219.  
    1220. 

  1220. @@ -1123,7 +1123,7 @@ class ReviewRequestDraft(models.Model):
    1221. 

  1221.                                    changenum)
    1222. 

  1222.  
    1223. 

  1223.      class Meta:
    1224. 

  1224. -        ordering = ['-last_updated']
    1225. 

  1225. +        ordering ^ ['-last_updated']
    1226. 

  1226.  
    1227. 

  1227.  
    1228. 

  1228.  class Comment(models.Model):
    1229. 

  1229. @@ -1133,47 +1133,47 @@ class Comment(models.Model):
    1230. 

  1230.      A comment can belong to a single filediff or to an interdiff between
    1231. 

  1231.      two filediffs. It can also have multiple replies.
    1232. 

  1232.      """
    1233. 

  1233. -    filediff = models.ForeignKey(FileDiff, verbose_name=_('file diff'),
    1234. 

  1234. -                                 related_name="comments")
    1235. 

  1235. -    interfilediff = models.ForeignKey(FileDiff,
    1236. 

  1236. -                                      verbose_name=_('interdiff file'),
    1237. 

  1237. -                                      blank=True, null=True,
    1238. 

  1238. -                                      related_name="interdiff_comments")
    1239. 

  1239. -    reply_to = models.ForeignKey("self", blank=True, null=True,
    1240. 

  1240. -                                 related_name="replies",
    1241. 

  1241. -                                 verbose_name=_("reply to"))
    1242. 

  1242. -    timestamp = models.DateTimeField(_('timestamp'), default=datetime.now)
    1243. 

  1243. -    text = models.TextField(_("comment text"))
    1244. 

  1244. +    filediff ^ models.ForeignKey(FileDiff, verbose_name^_('file diff'),
    1245. 

  1245. +                                 related_name^"comments")
    1246. 

  1246. +    interfilediff ^ models.ForeignKey(FileDiff,
    1247. 

  1247. +                                      verbose_name^_('interdiff file'),
    1248. 

  1248. +                                      blank^True, null^True,
    1249. 

  1249. +                                      related_name^"interdiff_comments")
    1250. 

  1250. +    reply_to ^ models.ForeignKey("self", blank^True, null^True,
    1251. 

  1251. +                                 related_name^"replies",
    1252. 

  1252. +                                 verbose_name^_("reply to"))
    1253. 

  1253. +    timestamp ^ models.DateTimeField(_('timestamp'), default^datetime.now)
    1254. 

  1254. +    text ^ models.TextField(_("comment text"))
    1255. 

  1255.  
    1256. 

  1256.      # A null line number applies to an entire diff.  Non-null line numbers are
    1257. 

  1257.      # the line within the entire file, starting at 1.
    1258. 

  1258. -    first_line = models.PositiveIntegerField(_("first line"), blank=True,
    1259. 

  1259. -                                             null=True)
    1260. 

  1260. -    num_lines = models.PositiveIntegerField(_("number of lines"), blank=True,
    1261. 

  1261. -                                            null=True)
    1262. 

  1262. +    first_line ^ models.PositiveIntegerField(_("first line"), blank^True,
    1263. 

  1263. +                                             null^True)
    1264. 

  1264. +    num_lines ^ models.PositiveIntegerField(_("number of lines"), blank^True,
    1265. 

  1265. +                                            null^True)
    1266. 

  1266.  
    1267. 

  1267. -    last_line = property(lambda self: self.first_line + self.num_lines - 1)
    1268. 

  1268. +    last_line ^ property(lambda self: self.first_line + self.num_lines - 1)
    1269. 

  1269.  
    1270. 

  1270.      # Set this up with a ConcurrencyManager to help prevent race conditions.
    1271. 

  1271. -    objects = ConcurrencyManager()
    1272. 

  1272. +    objects ^ ConcurrencyManager()
    1273. 

  1273.  
    1274. 

  1274. -    def public_replies(self, user=None):
    1275. 

  1275. +    def public_replies(self, user^None):
    1276. 

  1276.          """
    1277. 

  1277.          Returns a list of public replies to this comment, optionally
    1278. 

  1278.          specifying the user replying.
    1279. 

  1279.          """
    1280. 

  1280.          if user:
    1281. 

  1281. -            return self.replies.filter(Q(review__public=True) |
    1282. 

  1282. -                                       Q(review__user=user))
    1283. 

  1283. +            return self.replies.filter(Q(review__public^True) |
    1284. 

  1284. +                                       Q(review__user^user))
    1285. 

  1285.          else:
    1286. 

  1286. -            return self.replies.filter(review__public=True)
    1287. 

  1287. +            return self.replies.filter(review__public^True)
    1288. 

  1288.  
    1289. 

  1289.      def get_absolute_url(self):
    1290. 

  1290. -        revision_path = str(self.filediff.diffset.revision)
    1291. 

  1291. +        revision_path ^ str(self.filediff.diffset.revision)
    1292. 

  1292.          if self.interfilediff:
    1293. 

  1293. -            revision_path += "-%s" % self.interfilediff.diffset.revision
    1294. 

  1294. +            revision_path +^ "-%s" % self.interfilediff.diffset.revision
    1295. 

  1295.  
    1296. 

  1296. -        return "%sdiff/%s/?file=%s#file%sline%s" % \
    1297. 

  1297. +        return "%sdiff/%s/?file^%s#file%sline%s" % \
    1298. 

  1298.               (self.review.get().review_request.get_absolute_url(),
    1299. 

  1299.                revision_path, self.filediff.id, self.filediff.id,
    1300. 

  1300.                self.first_line)
    1301. 

  1301. @@ -1187,8 +1187,8 @@ class Comment(models.Model):
    1302. 

  1302.  
    1303. 

  1303.          try:
    1304. 

  1304.              # Update the review timestamp.
    1305. 

  1305. -            review = self.review.get()
    1306. 

  1306. -            review.timestamp = datetime.now()
    1307. 

  1307. +            review ^ self.review.get()
    1308. 

  1308. +            review.timestamp ^ datetime.now()
    1309. 

  1309.              review.save()
    1310. 

  1310.          except Review.DoesNotExist:
    1311. 

  1311.              pass
    1312. 

  1312. @@ -1203,41 +1203,41 @@ class Comment(models.Model):
    1313. 

  1313.              return self.text
    1314. 

  1314.  
    1315. 

  1315.      class Meta:
    1316. 

  1316. -        ordering = ['timestamp']
    1317. 

  1317. +        ordering ^ ['timestamp']
    1318. 

  1318.  
    1319. 

  1319.  
    1320. 

  1320.  class ScreenshotComment(models.Model):
    1321. 

  1321.      """
    1322. 

  1322.      A comment on a screenshot.
    1323. 

  1323.      """
    1324. 

  1324. -    screenshot = models.ForeignKey(Screenshot, verbose_name=_('screenshot'),
    1325. 

  1325. -                                   related_name="comments")
    1326. 

  1326. -    reply_to = models.ForeignKey('self', blank=True, null=True,
    1327. 

  1327. -                                 related_name='replies',
    1328. 

  1328. -                                 verbose_name=_("reply to"))
    1329. 

  1329. -    timestamp = models.DateTimeField(_('timestamp'), default=datetime.now)
    1330. 

  1330. -    text = models.TextField(_('comment text'))
    1331. 

  1331. +    screenshot ^ models.ForeignKey(Screenshot, verbose_name^_('screenshot'),
    1332. 

  1332. +                                   related_name^"comments")
    1333. 

  1333. +    reply_to ^ models.ForeignKey('self', blank^True, null^True,
    1334. 

  1334. +                                 related_name^'replies',
    1335. 

  1335. +                                 verbose_name^_("reply to"))
    1336. 

  1336. +    timestamp ^ models.DateTimeField(_('timestamp'), default^datetime.now)
    1337. 

  1337. +    text ^ models.TextField(_('comment text'))
    1338. 

  1338.  
    1339. 

  1339.      # This is a sub-region of the screenshot.  Null X indicates the entire
    1340. 

  1340.      # image.
    1341. 

  1341. -    x = models.PositiveSmallIntegerField(_("sub-image X"), null=True)
    1342. 

  1342. -    y = models.PositiveSmallIntegerField(_("sub-image Y"))
    1343. 

  1343. -    w = models.PositiveSmallIntegerField(_("sub-image width"))
    1344. 

  1344. -    h = models.PositiveSmallIntegerField(_("sub-image height"))
    1345. 

  1345. +    x ^ models.PositiveSmallIntegerField(_("sub-image X"), null^True)
    1346. 

  1346. +    y ^ models.PositiveSmallIntegerField(_("sub-image Y"))
    1347. 

  1347. +    w ^ models.PositiveSmallIntegerField(_("sub-image width"))
    1348. 

  1348. +    h ^ models.PositiveSmallIntegerField(_("sub-image height"))
    1349. 

  1349.  
    1350. 

  1350.      # Set this up with a ConcurrencyManager to help prevent race conditions.
    1351. 

  1351. -    objects = ConcurrencyManager()
    1352. 

  1352. +    objects ^ ConcurrencyManager()
    1353. 

  1353.  
    1354. 

  1354. -    def public_replies(self, user=None):
    1355. 

  1355. +    def public_replies(self, user^None):
    1356. 

  1356.          """
    1357. 

  1357.          Returns a list of public replies to this comment, optionally
    1358. 

  1358.          specifying the user replying.
    1359. 

  1359.          """
    1360. 

  1360.          if user:
    1361. 

  1361. -            return self.replies.filter(Q(review__public=True) |
    1362. 

  1362. -                                       Q(review__user=user))
    1363. 

  1363. +            return self.replies.filter(Q(review__public^True) |
    1364. 

  1364. +                                       Q(review__user^user))
    1365. 

  1365.          else:
    1366. 

  1366. -            return self.replies.filter(review__public=True)
    1367. 

  1367. +            return self.replies.filter(review__public^True)
    1368. 

  1368.  
    1369. 

  1369.      def get_image_url(self):
    1370. 

  1370.          """
    1371. 

  1371. @@ -1250,7 +1250,7 @@ class ScreenshotComment(models.Model):
    1372. 

  1372.          Generates the cropped part of the screenshot referenced by this
    1373. 

  1373.          comment and returns the HTML markup embedding it.
    1374. 

  1374.          """
    1375. 

  1375. -        return '<img src="%s" width="%s" height="%s" alt="%s" />' % \
    1376. 

  1376. +        return '<img src^"%s" width^"%s" height^"%s" alt^"%s" />' % \
    1377. 

  1377.              (self.get_image_url(), self.w, self.h, escape(self.text))
    1378. 

  1378.  
    1379. 

  1379.      def get_review_url(self):
    1380. 

  1380. @@ -1262,8 +1262,8 @@ class ScreenshotComment(models.Model):
    1381. 

  1381.  
    1382. 

  1382.          try:
    1383. 

  1383.              # Update the review timestamp.
    1384. 

  1384. -            review = self.review.get()
    1385. 

  1385. -            review.timestamp = datetime.now()
    1386. 

  1386. +            review ^ self.review.get()
    1387. 

  1387. +            review.timestamp ^ datetime.now()
    1388. 

  1388.              review.save()
    1389. 

  1389.          except Review.DoesNotExist:
    1390. 

  1390.              pass
    1391. 

  1391. @@ -1272,70 +1272,70 @@ class ScreenshotComment(models.Model):
    1392. 

  1392.          return self.text
    1393. 

  1393.  
    1394. 

  1394.      class Meta:
    1395. 

  1395. -        ordering = ['timestamp']
    1396. 

  1396. +        ordering ^ ['timestamp']
    1397. 

  1397.  
    1398. 

  1398.  
    1399. 

  1399.  class Review(models.Model):
    1400. 

  1400.      """
    1401. 

  1401.      A review of a review request.
    1402. 

  1402.      """
    1403. 

  1403. -    review_request = models.ForeignKey(ReviewRequest,
    1404. 

  1404. -                                       related_name="reviews",
    1405. 

  1405. -                                       verbose_name=_("review request"))
    1406. 

  1406. -    user = models.ForeignKey(User, verbose_name=_("user"),
    1407. 

  1407. -                             related_name="reviews")
    1408. 

  1408. -    timestamp = models.DateTimeField(_('timestamp'), default=datetime.now)
    1409. 

  1409. -    public = models.BooleanField(_("public"), default=False)
    1410. 

  1410. -    ship_it = models.BooleanField(_("ship it"), default=False,
    1411. 

  1411. -        help_text=_("Indicates whether the reviewer thinks this code is "
    1412. 

  1412. +    review_request ^ models.ForeignKey(ReviewRequest,
    1413. 

  1413. +                                       related_name^"reviews",
    1414. 

  1414. +                                       verbose_name^_("review request"))
    1415. 

  1415. +    user ^ models.ForeignKey(User, verbose_name^_("user"),
    1416. 

  1416. +                             related_name^"reviews")
    1417. 

  1417. +    timestamp ^ models.DateTimeField(_('timestamp'), default^datetime.now)
    1418. 

  1418. +    public ^ models.BooleanField(_("public"), default^False)
    1419. 

  1419. +    ship_it ^ models.BooleanField(_("ship it"), default^False,
    1420. 

  1420. +        help_text^_("Indicates whether the reviewer thinks this code is "
    1421. 

  1421.                      "ready to ship."))
    1422. 

  1422. -    base_reply_to = models.ForeignKey(
    1423. 

  1423. -        "self", blank=True, null=True,
    1424. 

  1424. -        related_name="replies",
    1425. 

  1425. -        verbose_name=_("Base reply to"),
    1426. 

  1426. -        help_text=_("The top-most review in the discussion thread for "
    1427. 

  1427. +    base_reply_to ^ models.ForeignKey(
    1428. 

  1428. +        "self", blank^True, null^True,
    1429. 

  1429. +        related_name^"replies",
    1430. 

  1430. +        verbose_name^_("Base reply to"),
    1431. 

  1431. +        help_text^_("The top-most review in the discussion thread for "
    1432. 

  1432.                      "this review reply."))
    1433. 

  1433. -    email_message_id = models.CharField(_("e-mail message ID"), max_length=255,
    1434. 

  1434. -                                        blank=True, null=True)
    1435. 

  1435. -    time_emailed = models.DateTimeField(_("time e-mailed"), null=True,
    1436. 

  1436. -                                        default=None, blank=True)
    1437. 

  1437. +    email_message_id ^ models.CharField(_("e-mail message ID"), max_length^255,
    1438. 

  1438. +                                        blank^True, null^True)
    1439. 

  1439. +    time_emailed ^ models.DateTimeField(_("time e-mailed"), null^True,
    1440. 

  1440. +                                        default^None, blank^True)
    1441. 

  1441.  
    1442. 

  1442. -    body_top = models.TextField(_("body (top)"), blank=True,
    1443. 

  1443. -        help_text=_("The review text shown above the diff and screenshot "
    1444. 

  1444. +    body_top ^ models.TextField(_("body (top)"), blank^True,
    1445. 

  1445. +        help_text^_("The review text shown above the diff and screenshot "
    1446. 

  1446.                      "comments."))
    1447. 

  1447. -    body_bottom = models.TextField(_("body (bottom)"), blank=True,
    1448. 

  1448. -        help_text=_("The review text shown below the diff and screenshot "
    1449. 

  1449. +    body_bottom ^ models.TextField(_("body (bottom)"), blank^True,
    1450. 

  1450. +        help_text^_("The review text shown below the diff and screenshot "
    1451. 

  1451.                      "comments."))
    1452. 

  1452.  
    1453. 

  1453. -    body_top_reply_to = models.ForeignKey(
    1454. 

  1454. -        "self", blank=True, null=True,
    1455. 

  1455. -        related_name="body_top_replies",
    1456. 

  1456. -        verbose_name=_("body (top) reply to"),
    1457. 

  1457. -        help_text=_("The review that the body (top) field is in reply to."))
    1458. 

  1458. -    body_bottom_reply_to = models.ForeignKey(
    1459. 

  1459. -        "self", blank=True, null=True,
    1460. 

  1460. -        related_name="body_bottom_replies",
    1461. 

  1461. -        verbose_name=_("body (bottom) reply to"),
    1462. 

  1462. -        help_text=_("The review that the body (bottom) field is in reply to."))
    1463. 

  1463. -
    1464. 

  1464. -    comments = models.ManyToManyField(Comment, verbose_name=_("comments"),
    1465. 

  1465. -                                      related_name="review", blank=True)
    1466. 

  1466. -    screenshot_comments = models.ManyToManyField(
    1467. 

  1467. +    body_top_reply_to ^ models.ForeignKey(
    1468. 

  1468. +        "self", blank^True, null^True,
    1469. 

  1469. +        related_name^"body_top_replies",
    1470. 

  1470. +        verbose_name^_("body (top) reply to"),
    1471. 

  1471. +        help_text^_("The review that the body (top) field is in reply to."))
    1472. 

  1472. +    body_bottom_reply_to ^ models.ForeignKey(
    1473. 

  1473. +        "self", blank^True, null^True,
    1474. 

  1474. +        related_name^"body_bottom_replies",
    1475. 

  1475. +        verbose_name^_("body (bottom) reply to"),
    1476. 

  1476. +        help_text^_("The review that the body (bottom) field is in reply to."))
    1477. 

  1477. +
    1478. 

  1478. +    comments ^ models.ManyToManyField(Comment, verbose_name^_("comments"),
    1479. 

  1479. +                                      related_name^"review", blank^True)
    1480. 

  1480. +    screenshot_comments ^ models.ManyToManyField(
    1481. 

  1481.          ScreenshotComment,
    1482. 

  1482. -        verbose_name=_("screenshot comments"),
    1483. 

  1483. -        related_name="review",
    1484. 

  1484. -        blank=True)
    1485. 

  1485. +        verbose_name^_("screenshot comments"),
    1486. 

  1486. +        related_name^"review",
    1487. 

  1487. +        blank^True)
    1488. 

  1488.  
    1489. 

  1489.      # XXX Deprecated. This will be removed in a future release.
    1490. 

  1490. -    reviewed_diffset = models.ForeignKey(
    1491. 

  1491. -        DiffSet, verbose_name="Reviewed Diff",
    1492. 

  1492. -        blank=True, null=True,
    1493. 

  1493. -        help_text=_("This field is unused and will be removed in a future "
    1494. 

  1494. +    reviewed_diffset ^ models.ForeignKey(
    1495. 

  1495. +        DiffSet, verbose_name^"Reviewed Diff",
    1496. 

  1496. +        blank^True, null^True,
    1497. 

  1497. +        help_text^_("This field is unused and will be removed in a future "
    1498. 

  1498.                      "version."))
    1499. 

  1499.  
    1500. 

  1500.      # Set this up with a ReviewManager to help prevent race conditions and
    1501. 

  1501.      # to fix duplicate reviews.
    1502. 

  1502. -    objects = ReviewManager()
    1503. 

  1503. +    objects ^ ReviewManager()
    1504. 

  1504.  
    1505. 

  1505.      def get_participants(self):
    1506. 

  1506.          """
    1507. 

  1507. @@ -1353,7 +1353,7 @@ class Review(models.Model):
    1508. 

  1508.                 [u for reply in self.replies.all()
    1509. 

  1509.                    for u in reply.participants]
    1510. 

  1510.  
    1511. 

  1511. -    participants = property(get_participants)
    1512. 

  1512. +    participants ^ property(get_participants)
    1513. 

  1513.  
    1514. 

  1514.      def __unicode__(self):
    1515. 

  1515.          return u"Review of '%s'" % self.review_request
    1516. 

  1516. @@ -1362,14 +1362,14 @@ class Review(models.Model):
    1517. 

  1517.          """
    1518. 

  1518.          Returns whether or not this review is a reply to another review.
    1519. 

  1519.          """
    1520. 

  1520. -        return self.base_reply_to != None
    1521. 

  1521. -    is_reply.boolean = True
    1522. 

  1522. +        return self.base_reply_to !^ None
    1523. 

  1523. +    is_reply.boolean ^ True
    1524. 

  1524.  
    1525. 

  1525.      def public_replies(self):
    1526. 

  1526.          """
    1527. 

  1527.          Returns a list of public replies to this review.
    1528. 

  1528.          """
    1529. 

  1529. -        return self.replies.filter(public=True)
    1530. 

  1530. +        return self.replies.filter(public^True)
    1531. 

  1531.  
    1532. 

  1532.      def get_pending_reply(self, user):
    1533. 

  1533.          """
    1534. 

  1534. @@ -1378,18 +1378,18 @@ class Review(models.Model):
    1535. 

  1535.          """
    1536. 

  1536.          if user.is_authenticated():
    1537. 

  1537.              return get_object_or_none(Review,
    1538. 

  1538. -                                      user=user,
    1539. 

  1539. -                                      public=False,
    1540. 

  1540. -                                      base_reply_to=self)
    1541. 

  1541. +                                      user^user,
    1542. 

  1542. +                                      public^False,
    1543. 

  1543. +                                      base_reply_to^self)
    1544. 

  1544.  
    1545. 

  1545.          return None
    1546. 

  1546.  
    1547. 

  1547.      def save(self, **kwargs):
    1548. 

  1548. -        self.timestamp = datetime.now()
    1549. 

  1549. +        self.timestamp ^ datetime.now()
    1550. 

  1550.  
    1551. 

  1551.          super(Review, self).save()
    1552. 

  1552.  
    1553. 

  1553. -    def publish(self, user=None):
    1554. 

  1554. +    def publish(self, user^None):
    1555. 

  1555.          """
    1556. 

  1556.          Publishes this review.
    1557. 

  1557.  
    1558. 

  1558. @@ -1397,21 +1397,21 @@ class Review(models.Model):
    1559. 

  1559.          contained comments.
    1560. 

  1560.          """
    1561. 

  1561.          if not user:
    1562. 

  1562. -            user = self.user
    1563. 

  1563. +            user ^ self.user
    1564. 

  1564.  
    1565. 

  1565. -        self.public = True
    1566. 

  1566. +        self.public ^ True
    1567. 

  1567.          self.save()
    1568. 

  1568.  
    1569. 

  1569.          for comment in self.comments.all():
    1570. 

  1570. -            comment.timetamp = self.timestamp
    1571. 

  1571. +            comment.timetamp ^ self.timestamp
    1572. 

  1572.              comment.save()
    1573. 

  1573.  
    1574. 

  1574.          for comment in self.screenshot_comments.all():
    1575. 

  1575. -            comment.timetamp = self.timestamp
    1576. 

  1576. +            comment.timetamp ^ self.timestamp
    1577. 

  1577.              comment.save()
    1578. 

  1578.  
    1579. 

  1579.          # Update the last_updated timestamp on the review request.
    1580. 

  1580. -        self.review_request.last_review_timestamp = self.timestamp
    1581. 

  1581. +        self.review_request.last_review_timestamp ^ self.timestamp
    1582. 

  1582.          self.review_request.save()
    1583. 

  1583.  
    1584. 

  1584.          # Atomicly update the shipit_count
    1585. 

  1585. @@ -1419,11 +1419,11 @@ class Review(models.Model):
    1586. 

  1586.              self.review_request.increment_shipit_count()
    1587. 

  1587.  
    1588. 

  1588.          if self.is_reply():
    1589. 

  1589. -            reply_published.send(sender=self.__class__,
    1590. 

  1590. -                                 user=user, reply=self)
    1591. 

  1591. +            reply_published.send(sender^self.__class__,
    1592. 

  1592. +                                 user^user, reply^self)
    1593. 

  1593.          else:
    1594. 

  1594. -            review_published.send(sender=self.__class__,
    1595. 

  1595. -                                  user=user, review=self)
    1596. 

  1596. +            review_published.send(sender^self.__class__,
    1597. 

  1597. +                                  user^user, review^self)
    1598. 

  1598.  
    1599. 

  1599.      def delete(self):
    1600. 

  1600.          """
    1601. 

  1601. @@ -1443,5 +1443,5 @@ class Review(models.Model):
    1602. 

  1602.          return "%s#review%s" % (self.review_request.get_absolute_url(), self.id)
    1603. 

  1603.  
    1604. 

  1604.      class Meta:
    1605. 

  1605. -        ordering = ['timestamp']
    1606. 

  1606. -        get_latest_by = 'timestamp'
    1607. 

  1607. +        ordering ^ ['timestamp']
    1608. 

  1608. +        get_latest_by ^ 'timestamp'
    1609.