Skip to content
Snippets Groups Projects
  1. Jul 06, 2012
    • Simon Heimberg's avatar
      hooks: print out more information when loading a python hook fails · 1b2b727a
      Simon Heimberg authored
      When loading a python hook with file syntax fails, there is no
      information that this happened while loading a hook. When the python
      file does not exist even the file name is not printed. (Only that a
      file is missing.)
      
      This patch adds this information and a test for loading a non existing file and
      a directory not being a python module.
      1b2b727a
  2. Jul 18, 2012
  3. Jul 17, 2012
  4. Jul 16, 2012
    • Pierre-Yves David's avatar
      obsolete: mark unreachable extinct changesets as hidden · 8018f234
      Pierre-Yves David authored
      The repo.hiddenrevs set is updated with all extinct() changesets which aren't
      descendants of either:
      
      - the current working copy,
      - a bookmark,
      - a tag.
      8018f234
    • Pierre-Yves David's avatar
      hidden: move hiddenrevs set on the repository · 62c56c94
      Pierre-Yves David authored
      This set is always accessed through the repo for now. Having this set
      carried by the changelog make it complicated to:
      
      - initialize it, computing hidden set may involve revset call
      - lazy compute it, (1) only the changelog can detect someone access it,
                         (2) only the repo have enought knowledge to compute it.
      
      In later version I expect he changelog to apply filtering itself and the set to
      be carried by changelog again.
      62c56c94
  5. Jul 13, 2012
    • Pierre-Yves David's avatar
      obsolete: do not exchange extinct changesets · 70ebb4bd
      Pierre-Yves David authored
      Extinct changesets are excluded from all exchange operations. This is a silent
      exclusion because the user should not need to be aware of them.
      
      There is no reason to strongly enforce this exclusion except implementation
      simplicity. User should be able to explicitly request an extinct changeset in
      the future.
      70ebb4bd
  6. Jul 16, 2012
    • Pierre-Yves David's avatar
      repo: move visibleheads and visiblebranchmap logic in discovery · 97eff000
      Pierre-Yves David authored
      They were previously inside the mercurial.phases module, but obsolete
      logic will need them to exclude `extinct` changesets from pull and
      push.
      
      The proper and planned way to implement such filtering is still to apply a
      changelog level filtering. But we are far to late in the cycle to implement and
      push such a critical piece of code (changelog filtering). With Matt Mackall
      approval I'm extending this quick and dirty mechanism for obsolete purpose.
      
      Changelog level filtering should come during the next release cycle.
      97eff000
    • Pierre-Yves David's avatar
      localpeer: return only visible heads and branchmap · 4feb55e6
      Pierre-Yves David authored
      Now that we have localpeer, we can apply filtering on heads and branchmap the
      same way it's done for wireprotocol peer.
      4feb55e6
  7. Jul 18, 2012
  8. Jul 08, 2012
    • wujek srujek's avatar
      hgweb: side-by-side comparison functionality · 1ae11926
      wujek srujek authored
      Adds new web command to the core, ``comparison``, which enables colorful
      side-by-side change display, which for some might be much easier to work with
      than the standard line diff output. The idea how to implement comes from the
      SonicHq extension.
      The web interface gets a new link to call the comparison functionality. It lets
      users configure the amount of context lines around change blocks, or to show
      full files - check help (also in this changeset) for details and defaults. The
      setting in hgrc can be overridden by adding ``context=<value>`` to the request
      query string. The comparison creates addressable lines, so as to enable sharing
      links to specific lines, just as standard diff does.
      Incorporates updates to all web related styles.
      
      Known limitations:
      * the column diff is done against the first parent, just as the standard diff
      * this change allows examining diffs for single files only (as I am not sure if
        examining the whole changeset in this way would be helpful)
      * syntax highlighting of the output changes is not performed (enabling the
        highlight extension has no influence on it)
      1ae11926
  9. Jul 06, 2012
  10. Jul 16, 2012
  11. Jul 15, 2012
  12. Jul 16, 2012
  13. Jul 03, 2012
  14. Jul 16, 2012
  15. Jul 13, 2012
    • Sune Foldager's avatar
    • Sune Foldager's avatar
      1d710fe5
    • Peter Arrenbrecht's avatar
      peer: introduce real peer classes · 1ac628cd
      Peter Arrenbrecht authored
      This change separates peer implementations from the repository implementation.
      localpeer currently is a simple pass-through to localrepository, except for
      legacy calls, which have already been removed from localpeer. This ensures that
      the local client code only uses the most modern peer API when talking to local
      repos.
      
      Peers have a .local() method which returns either None or the underlying
      localrepository (or descendant thereof). Repos have a .peer() method to return
      a freshly constructed localpeer. The latter is used by hg.peer(), and also to
      allow folks to pass either a peer or a repo to some generic helper methods.
      We might want to get rid of .peer() eventually.
      
      The only user of locallegacypeer is debugdiscovery, which uses it to pose as a
      pre-setdiscovery client. But we decided to leave the old API defined in
      locallegacypeer for clarity and maybe for other uses in the future.
      
      It might be nice to actually define the peer API directly in peer.py as stub
      methods. One problem there is, however, that localpeer implements
      lock/addchangegroup, whereas the true remote peers implement unbundle.
      It might be desireable to get rid of this distinction eventually.
      1ac628cd
    • Sune Foldager's avatar
      peer: introduce peer methods to prepare for peer classes · 58848126
      Sune Foldager authored
      This introduces a peer method into all repository classes, which currently
      simply returns self. It also changes hg.repository so it now raises an
      exception if the supplied paths does not resolve to a localrepo or descendant.
      
      Finally, all call sites are changed to use the peer and local methods as
      appropriate, where peer is used whenever the code is dealing with a remote
      repository (even if it's on local disk).
      58848126
  16. Jul 06, 2012
  17. Jul 11, 2012
  18. Jul 10, 2012
    • epriestley's avatar
      templatekw/help: document the {parents} keyword · 293dd81e
      epriestley authored
      The {parents} keyword does not appear in the generated documentation for
      templates because it is added by `changeset_templater` (and this is because
      its behavior depends on `ui`, so it can't be defined as a normal template
      keyword; see comments in `changeset_templater._show()`).
      
      Add it to the documentation synthetically by creating a stub documentation
      function.
      
      Test plan: built the docs and examined the man page to verify that this
      keyword is now documented. I'm not sure how to test the i18n extraction part,
      but assume it will just work given that this patch doesn't do anything too
      crazy.
      293dd81e
  19. Jul 07, 2012
    • Matt Harbison's avatar
      revset: add destination() predicate · a3da6f29
      Matt Harbison authored
      This predicate is used to find csets that were created because of a graft,
      transplant or rebase --keep.  An optional revset can be supplied, in which case
      the result will be limited to those copies which specified one of the revs as
      the source for the command.
      
          hg log -r destination()                 # csets copied from anywhere
          hg log -r destination(branch(default))  # all csets copied from default
      
          hg log -r origin(x) or destination(origin(x))  # all instances of x
      
      This predicate will follow a cset through different types of copies.  Given a
      repo with a cset 'S' that is grafted to create G(S), which itself is
      transplanted to become T(G(S)):
      
          o-S
         /
        o-o-G(S)
         \
          o-T(G(S))
      
          hg log -r destination( S )    # { G(S), T(G(S)) }
          hg log -r destination( G(S) ) # { T(G(S)) }
      
      The implementation differences between the three different copy commands (see
      the origin() predicate) are not intentionally exposed, however if the
      transplant was a graft instead:
      
      	hg log -r destination( G(S) )   # {}
      
      because the 'extra' field in G(G(S)) is S, not G(S).  The implementation cannot
      correct this by following sources before G(S) and then select the csets that
      reference those sources because the cset provided to the predicate would also
      end up selected.  If there were more than two copies, sources of the argument
      would also get selected.
      
      Note that the convert extension does not currently update the 'extra' map in its
      destination csets, and therefore copies made prior to the convert will be
      missing from the resulting set.
      
      Instead of the loop over 'subset', the following almost works, but does not
      select a transplant of a transplant.  That is, 'destination(S)' will only
      select T(S).
      
          dests = set([r for r in subset if _getrevsource(repo, r) in args])
      a3da6f29
    • Matt Harbison's avatar
      revset: add origin() predicate · 2c7c4824
      Matt Harbison authored
      This predicate is used to find the original source of csets created by a graft,
      transplant or rebase --keep.  If a copied cset is itself copied, only the
      source of the original copy is selected.
      
          hg log -r origin()                # all src csets, anywhere
          hg log -r origin(branch(default)) # all srcs of copies on default
      
      By following through different types of copy commands and only selecting the
      original cset, the implementation differences between the copy commands are
      hidden.  (A graft of a graft preserves the original source in its 'extra' map,
      while transplant and rebase use the immediate source specified for the
      command).
      
      Given a repo with a cset S that is grafted to create G(S), which itself is
      grafted to become G(G(S))
      
          o-S
         /
        o-o-G(S)
         \
          o-G(G(S))
      
          hg log -r origin( G(S) )      # { S }
          hg log -r origin( G(G(S)) )   # { S }, NOT { G(S) }
      
      Even if the last graft were a transplant
      
          hg log -r origin( T(G(S)) )   # { S }
      
      A rebase without --keep essentially strips the source, so providing the cset
      that results to this predicate will yield an empty set.
      
      Note that the convert extension does not currently update the 'extra' map in
      its destination csets, and therefore copies made prior to the convert will be
      unable to find their source.
      2c7c4824
  20. Jul 16, 2012
  21. Jul 12, 2012
  22. Jul 11, 2012
  23. Jul 14, 2012
  24. Jul 11, 2012
  25. Jun 24, 2012
Loading