incubator-allura-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From john...@apache.org
Subject [12/25] git commit: [#3060] Removed unused repo models
Date Mon, 08 Jul 2013 19:28:24 GMT
[#3060] Removed unused repo models

These models are from a previous implementation of repo indexing and
haven't been used in some time.  With this, the following collections
can also be removed:

    * project-data.last_commit_for
    * pyforge.repo_object

Signed-off-by: Cory Johns <cjohns@slashdotmedia.com>


Project: http://git-wip-us.apache.org/repos/asf/incubator-allura/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-allura/commit/33e7fea7
Tree: http://git-wip-us.apache.org/repos/asf/incubator-allura/tree/33e7fea7
Diff: http://git-wip-us.apache.org/repos/asf/incubator-allura/diff/33e7fea7

Branch: refs/heads/cj/4656
Commit: 33e7fea7547e901a28d9cf45b26821b5feca43e5
Parents: 7fc9b7d
Author: Cory Johns <cjohns@slashdotmedia.com>
Authored: Tue Jul 2 20:18:56 2013 +0000
Committer: Tim Van Steenburgh <tvansteenburgh@gmail.com>
Committed: Sun Jul 7 05:24:21 2013 +0000

----------------------------------------------------------------------
 Allura/allura/model/repository.py | 586 +--------------------------------
 1 file changed, 1 insertion(+), 585 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-allura/blob/33e7fea7/Allura/allura/model/repository.py
----------------------------------------------------------------------
diff --git a/Allura/allura/model/repository.py b/Allura/allura/model/repository.py
index 32cea30..2904a39 100644
--- a/Allura/allura/model/repository.py
+++ b/Allura/allura/model/repository.py
@@ -533,8 +533,7 @@ class Repository(Artifact, ActivityObject):
             log.info('... %r analyzing', self)
             self.status = 'analyzing'
             session(self).flush(self)
-            if asbool(tg.config.get('scm.new_refresh')):
-                refresh_repo(self, all_commits, notify, new_clone)
+            refresh_repo(self, all_commits, notify, new_clone)
         finally:
             log.info('... %s ready', self)
             self.status = 'ready'
@@ -654,589 +653,6 @@ class MergeRequest(VersionedArtifact, ActivityObject):
                 self.request_number, self.project.name, self.app.repo.name))
         return result
 
-class LastCommitFor(MappedClass):
-    class __mongometa__:
-        session = project_orm_session
-        name='last_commit_for'
-        unique_indexes = [ ('repo_id', 'object_id') ]
-
-    _id = FieldProperty(S.ObjectId)
-    repo_id = FieldProperty(S.ObjectId)
-    object_id = FieldProperty(str)
-    last_commit = FieldProperty(dict(
-        date=datetime,
-        author=str,
-        author_email=str,
-        author_url=str,
-        id=str,
-        href=str,
-        shortlink=str,
-        summary=str))
-
-    @classmethod
-    def upsert(cls, repo_id, object_id):
-        isnew = False
-        r = cls.query.get(repo_id=repo_id, object_id=object_id)
-        if r is not None: return r, isnew
-        try:
-            r = cls(repo_id=repo_id, object_id=object_id)
-            session(r).flush(r)
-            isnew = True
-        except pymongo.errors.DuplicateKeyError: # pragma no cover
-            session(r).expunge(r)
-            r = cls.query.get(repo_id=repo_id, object_id=object_id)
-        return r, isnew
-
-class RepoObject(MappedClass):
-    class __mongometa__:
-        session = repository_orm_session
-        name='repo_object'
-        polymorphic_on = 'type'
-        polymorphic_identity=None
-        indexes = [
-            ('parent_ids',),
-            ('repo_id','type'),
-            ('type', 'object_ids.object_id'),
-            ('type', 'tree_id'),
-            ]
-        unique_indexes = [ 'object_id' ]
-
-    # ID Fields
-    _id = FieldProperty(S.ObjectId)
-    type = FieldProperty(str)
-    repo_id = FieldProperty(S.Deprecated)
-    object_id = FieldProperty(str)
-    last_commit=FieldProperty(S.Deprecated)
-
-    @classmethod
-    def upsert(cls, object_id):
-        isnew = False
-        r = cls.query.get(object_id=object_id)
-        if r is not None:
-            return r, isnew
-        try:
-            r = cls(
-                type=cls.__mongometa__.polymorphic_identity,
-                object_id=object_id)
-            session(r).flush(r)
-            isnew = True
-        except pymongo.errors.DuplicateKeyError: # pragma no cover
-            session(r).expunge(r)
-            r = cls.query.get(object_id=object_id)
-        return r, isnew
-
-    def set_last_commit(self, ci, repo=None):
-        '''Update the last_commit_for object based on the passed in commit &
-        repo'''
-        if repo is None: repo = c.app.repo
-        lc, isnew = LastCommitFor.upsert(repo_id=repo._id, object_id=self.object_id)
-        if not ci.authored.date:
-            repo._impl.refresh_commit(ci)
-        if isnew:
-            lc.last_commit.author = ci.authored.name
-            lc.last_commit.author_email = ci.authored.email
-            lc.last_commit.author_url = ci.author_url
-            lc.last_commit.date = ci.authored.date
-            lc.last_commit.id = ci.object_id
-            lc.last_commit.href = ci.url()
-            lc.last_commit.shortlink = ci.shorthand_id()
-            lc.last_commit.summary = ci.summary
-            assert lc.last_commit.date
-        return lc, isnew
-
-    def get_last_commit(self, repo=None):
-        if repo is None: repo = c.app.repo
-        return repo.get_last_commit(self)
-
-    def __repr__(self):
-        return '<%s %s>' % (
-            self.__class__.__name__, self.object_id)
-
-    def index_id(self):
-        app_config = self.repo.app_config
-        return '%s %s in %s %s' % (
-            self.type, self.object_id,
-            app_config.project.name,
-            app_config.options.mount_label)
-
-    def set_context(self, context): # pragma no cover
-        '''Set ephemeral (unsaved) attributes based on a context object'''
-        raise NotImplementedError, 'set_context'
-
-    def primary(self): return self
-
-class LogCache(RepoObject):
-    '''Class to store nothing but lists of commit IDs in topo sort order'''
-    class __mongometa__:
-        polymorphic_identity='log_cache'
-    type_s = 'LogCache'
-
-    type = FieldProperty(str, if_missing='log_cache')
-    object_ids = FieldProperty([str])
-    candidates = FieldProperty([str])
-
-    @classmethod
-    def get(cls, repo, object_id):
-        lc, new = cls.upsert('$' + object_id)
-        if not lc.object_ids:
-            lc.object_ids, lc.candidates = repo._impl.log(object_id, 0, 50)
-        return lc
-
-class Commit(RepoObject):
-    class __mongometa__:
-        polymorphic_identity='commit'
-    type_s = 'Commit'
-
-    # File data
-    type = FieldProperty(str, if_missing='commit')
-    tree_id = FieldProperty(str)
-    diffs = FieldProperty(dict(
-            added=[str],
-            removed=[str],
-            changed=[str],
-            copied=[dict(old=str, new=str)]))
-    # Commit metadata
-    committed = FieldProperty(
-        dict(name=str,
-             email=str,
-             date=datetime))
-    authored = FieldProperty(
-        dict(name=str,
-             email=str,
-             date=datetime))
-    message = FieldProperty(str)
-    parent_ids = FieldProperty([str])
-    extra = FieldProperty([dict(name=str, value=str)])
-     # All repos that potentially reference this commit
-    repositories=FieldProperty([S.ObjectId])
-
-    # Ephemeral attrs
-    repo=None
-
-    def set_context(self, repo):
-        self.repo = repo
-
-    @property
-    def diffs_computed(self):
-        if self.diffs.added: return True
-        if self.diffs.removed: return True
-        if self.diffs.changed: return True
-        if self.diffs.copied: return True
-
-    @LazyProperty
-    def author_url(self):
-        u = User.by_email_address(self.authored.email)
-        if u: return u.url()
-
-    @LazyProperty
-    def committer_url(self):
-        u = User.by_email_address(self.committed.email)
-        if u: return u.url()
-
-    @LazyProperty
-    def tree(self):
-        if self.tree_id is None:
-            self.tree_id = self.repo.compute_tree(self)
-        if self.tree_id is None:
-            return None
-        t = Tree.query.get(object_id=self.tree_id)
-        if t is None:
-            self.tree_id = self.repo.compute_tree(self)
-            t = Tree.query.get(object_id=self.tree_id)
-        if t is not None: t.set_context(self)
-        return t
-
-    @LazyProperty
-    def summary(self):
-        message = h.really_unicode(self.message)
-        first_line = message.split('\n')[0]
-        return h.text.truncate(first_line, 50)
-
-    def get_path(self, path):
-        '''Return the blob on the given path'''
-        if path.startswith('/'): path = path[1:]
-        path_parts = path.split('/')
-        return self.tree.get_blob(path_parts[-1], path_parts[:-1])
-
-    def shorthand_id(self):
-        return self.repo.shorthand_for_commit(self.object_id)
-
-    @LazyProperty
-    def symbolic_ids(self):
-        return self.repo.symbolics_for_commit(self)
-
-    def url(self):
-        return self.repo.url_for_commit(self)
-
-    def log(self, skip, count):
-        oids = list(self.log_iter(skip, count))
-        commits = self.query.find(dict(
-                type='commit',
-                object_id={'$in':oids}))
-        commits_by_oid = {}
-        for ci in commits:
-            ci.set_context(self.repo)
-            commits_by_oid[ci.object_id] = ci
-        return [ commits_by_oid[oid] for oid in oids ]
-
-    def log_iter(self, skip, count):
-        seen_oids = set()
-        candidates = [ self.object_id ]
-        while candidates and count:
-            candidate = candidates.pop()
-            if candidate in seen_oids: continue
-            lc = LogCache.get(self.repo, candidate)
-            oids = lc.object_ids
-            candidates += lc.candidates
-            for oid in oids:
-                if oid in seen_oids: continue
-                seen_oids.add(oid)
-                if count == 0:
-                    break
-                elif skip == 0:
-                    yield oid
-                    count -= 1
-                else:
-                    skip -= 1
-
-    def compute_diffs(self):
-        self.diffs.added = []
-        self.diffs.removed = []
-        self.diffs.changed = []
-        self.diffs.copied = []
-        if self.parent_ids:
-            parent = self.repo.commit(self.parent_ids[0])
-            for diff in Tree.diff(parent.tree, self.tree):
-                if diff.is_new:
-                    self.diffs.added.append(diff.b_path)
-                    obj = RepoObject.query.get(object_id=diff.b_object_id)
-                    obj.set_last_commit(self, self.repo)
-                elif diff.is_delete:
-                    self.diffs.removed.append(diff.a_path)
-                else:
-                    self.diffs.changed.append(diff.a_path)
-                    obj = RepoObject.query.get(object_id=diff.b_object_id)
-                    obj.set_last_commit(self, self.repo)
-        else:
-            # Parent-less, so the whole tree is additions
-            tree = self.tree
-            for x in tree.object_ids:
-                self.diffs.added.append('/'+x.name)
-                obj = RepoObject.query.get(object_id=x.object_id)
-                obj.set_last_commit(self, self.repo)
-
-    def context(self):
-        return self.repo.commit_context(self)
-
-class Tree(RepoObject):
-    '''
-    A representation of files & directories.  E.g. what is present at a single commit
-
-    :var object_ids: dict(object_id: name)  Set by refresh_tree in the scm implementation
-    '''
-    class __mongometa__:
-        polymorphic_identity='tree'
-    type_s = 'Tree'
-
-    type = FieldProperty(str, if_missing='tree')
-    object_ids = FieldProperty([dict(object_id=str,name=str)])
-
-    # Ephemeral attrs
-    repo=None
-    commit=None
-    parent=None
-    name=None
-
-    def compute_hash(self):
-        '''Compute a hash based on the contents of the tree.  Note that this
-        hash does not necessarily correspond to any actual DVCS hash.
-        '''
-        lines = []
-        for x in self.object_ids:
-            obj = RepoObject.query.get(x.object_id)
-            lines.append(obj.type[0] + x.object_id + x.name)
-        sha_obj = sha1()
-        for line in sorted(lines):
-            sha_obj.update(line)
-        return sha_obj.hexdigest()
-
-    def set_last_commit(self, ci, repo=None):
-        lc, isnew = super(Tree, self).set_last_commit(ci, repo)
-        if isnew:
-            for x in self.object_ids:
-                obj = RepoObject.query.get(object_id=x.object_id)
-                obj.set_last_commit(ci, repo)
-        return lc, isnew
-
-    @LazyProperty
-    def object_id_index(self):
-        return dict((x.name, x.object_id) for x in self.object_ids)
-
-    @LazyProperty
-    def object_name_index(self):
-        result = defaultdict(list)
-        for x in self.object_ids:
-            result[x.object_id].append(x.name)
-        return result
-
-    def get(self, name, default=None):
-        try:
-            return self[name]
-        except KeyError:
-            return default
-
-    def __getitem__(self, name):
-        oid = self.object_id_index[name]
-        obj = RepoObject.query.get(object_id=oid)
-        if obj is None:
-            oid = self.repo.compute_tree(self.commit, self.path() + name + '/')
-            obj = RepoObject.query.get(object_id=oid)
-        if obj is None: raise KeyError, name
-        obj.set_context(self, name)
-        return obj
-
-    @classmethod
-    def diff(cls, a, b):
-        '''Recursive diff of two tree objects, yielding DiffObjects'''
-        if not isinstance(a, Tree) or not isinstance(b, Tree):
-            yield DiffObject(a, b)
-        else:
-            for a_x in a.object_ids:
-                b_oid = b.object_id_index.get(a_x.name)
-                if a_x.object_id == b_oid: continue
-                a_obj = a.get(a_x.name)
-                b_obj = b.get(a_x.name)
-                if b_obj is None:
-                    yield DiffObject(a_obj, None)
-                else:
-                    for x in cls.diff(a_obj, b_obj): yield x
-            for b_x in b.object_ids:
-                if b_x.name in a.object_id_index: continue
-                b_obj = b.get(b_x.name)
-                yield DiffObject(None, b_obj)
-
-    def set_context(self, commit_or_tree, name=None):
-        assert commit_or_tree is not self
-        self.repo = commit_or_tree.repo
-        if name:
-            self.commit = commit_or_tree.commit
-            self.parent = commit_or_tree
-            self.name = name
-        else:
-            self.commit = commit_or_tree
-
-    def readme(self):
-        'returns (filename, unicode text) if a readme file is found'
-        for x in self.object_ids:
-            if README_RE.match(x.name):
-                obj = self[x.name]
-                if isinstance(obj, Blob):
-                    return (x.name, h.really_unicode(obj.text))
-        return (None, '')
-
-    def ls(self):
-        results = []
-        for x in self.object_ids:
-            obj = self[x.name]
-            ci = obj.get_last_commit()
-            d = dict(last_commit=ci, name=x.name)
-            if isinstance(obj, Tree):
-                results.append(dict(d, kind='DIR', href=x.name + '/'))
-            else:
-                results.append(dict(d, kind='FILE', href=x.name))
-        results.sort(key=lambda d:(d['kind'], d['name']))
-        return results
-
-    def index_id(self):
-        return repr(self)
-
-    def path(self):
-        if self.parent:
-            assert self.parent is not self
-            return self.parent.path() + self.name + '/'
-        else:
-            return '/'
-
-    def url(self):
-        return self.commit.url() + 'tree' + self.path()
-
-    def is_blob(self, name):
-        obj = RepoObject.query.get(
-            object_id=self.object_id_index[name])
-        return isinstance(obj, Blob)
-
-    def get_tree(self, name):
-        t = self.get(name)
-        if isinstance(t, Tree): return t
-        return None
-
-    def get_blob(self, name, path_parts=None):
-        if not path_parts:
-            t = self
-        else:
-            t = self.get_object(*path_parts)
-        if t is None: return None
-        b = t.get(name)
-        if isinstance(b, Blob): return b
-        return None
-
-    def get_object(self, *path_parts):
-        cur = self
-        for part in path_parts:
-            if not isinstance(cur, Tree): return None
-            cur = cur.get(part)
-        return cur
-
-class Blob(RepoObject):
-    class __mongometa__:
-        polymorphic_identity='blob'
-    type_s = 'Blob'
-
-    type = FieldProperty(str, if_missing='blob')
-
-    # Ephemeral attrs
-    repo=None
-    commit=None
-    tree=None
-    name=None
-
-    def set_context(self, tree, name):
-        self.repo = tree.repo
-        self.commit = tree.commit
-        self.tree = tree
-        self.name = name
-        fn, ext = os.path.splitext(self.name)
-        self.extension = ext or fn
-
-    @LazyProperty
-    def _content_type_encoding(self):
-        return self.repo.guess_type(self.name)
-
-    @LazyProperty
-    def content_type(self):
-        return self._content_type_encoding[0]
-
-    @LazyProperty
-    def content_encoding(self):
-        return self._content_type_encoding[1]
-
-    @LazyProperty
-    def next_commit(self):
-        try:
-            path = self.path()
-            cur = self.commit
-            next = cur.context()['next']
-            while next:
-                cur = next[0]
-                next = cur.context()['next']
-                other_blob = cur.get_path(path)
-                if other_blob is None or other_blob.object_id != self.object_id:
-                    return cur
-        except:
-            log.exception('Lookup prev_commit')
-            return None
-
-    @LazyProperty
-    def prev_commit(self):
-        lc = self.get_last_commit()
-        if lc['id']:
-            last_commit = self.repo.commit(lc.id)
-            if last_commit.parent_ids:
-                return self.repo.commit(last_commit.parent_ids[0])
-        return None
-
-    def url(self):
-        return self.tree.url() + h.really_unicode(self.name)
-
-    def path(self):
-        return self.tree.path() + h.really_unicode(self.name)
-
-    @property
-    def has_pypeline_view(self):
-        if README_RE.match(self.name) or self.extension in ['.md', '.rst']:
-            return True
-        return False
-
-    @property
-    def has_html_view(self):
-        if (self.content_type.startswith('text/') or
-            self.extension in VIEWABLE_EXTENSIONS or
-            self.extension in self.repo._additional_viewable_extensions or
-            utils.is_text_file(self.text)):
-            return True
-        return False
-
-    @property
-    def has_image_view(self):
-        return self.content_type.startswith('image/')
-
-    def context(self):
-        path = self.path()[1:]
-        prev = self.prev_commit
-        next = self.next_commit
-        if prev is not None: prev = prev.get_path(path)
-        if next is not None: next = next.get_path(path)
-        return dict(
-            prev=prev,
-            next=next)
-
-    def compute_hash(self):
-        '''Compute a hash based on the contents of the blob.  Note that this
-        hash does not necessarily correspond to any actual DVCS hash.
-        '''
-        fp = self.open()
-        sha_obj = sha1()
-        while True:
-            buffer = fp.read(4096)
-            if not buffer: break
-            sha_obj.update(buffer)
-        return sha_obj.hexdigest()
-
-    def open(self):
-        return self.repo.open_blob(self)
-
-    def __iter__(self):
-        return iter(self.open())
-
-    @LazyProperty
-    def size(self):
-        return self.repo.blob_size(self)
-
-    @LazyProperty
-    def text(self):
-        return self.open().read()
-
-    @classmethod
-    def diff(cls, v0, v1):
-        differ = SequenceMatcher(v0, v1)
-        return differ.get_opcodes()
-
-class DiffObject(object):
-    a_path = b_path = None
-    a_object_id = b_object_id = None
-    is_new = False
-    is_delete = False
-
-    def __init__(self, a, b):
-        if a:
-            self.a_path = a.path()
-            self.a_object_id = a.object_id
-        else:
-            self.is_new = True
-        if b:
-            self.b_path = b.path()
-            self.b_object_id = b.object_id
-        else:
-            self.is_delete = True
-
-    def __repr__(self):
-        if self.is_new:
-            return '<new %s>' % self.b_path
-        elif self.is_delete:
-            return '<remove %s>' % self.a_path
-        else:
-            return '<change %s>' % (self.a_path)
-
 
 class GitLikeTree(object):
     '''


Mime
View raw message