Пример #1
0
 def test_internal_symlinks_only(self):
     """
     The resulting ``virtualenv`` only contains symlinks to files inside the
     virtualenv and to /usr on the host OS.
     """
     target_path = FilePath(self.mktemp())
     create_virtualenv(root=target_path)
     allowed_targets = (target_path, FilePath('/usr'),)
     bad_links = []
     for path in target_path.walk():
         if path.islink():
             realpath = path.realpath()
             for allowed_target in allowed_targets:
                 try:
                     realpath.segmentsFrom(allowed_target)
                 except ValueError:
                     pass
                 else:
                     # The target is a descendent of an allowed_target.
                     break
             else:
                 bad_links.append(path)
     if bad_links:
         self.fail(
             "Symlinks outside of virtualenv detected:" +
             '\n'.join(
                 '/'.join(
                     path.segmentsFrom(target_path)
                 ) + ' -> ' + path.realpath().path
                 for path in bad_links
             )
         )
Пример #2
0
def findSounds(words):
    # incomplete, no user filtering
    top = FilePath('sounds/incoming/13EubbAsOYgy3eZX4LAHsB5Hzq72/will')
    for p in sorted(top.walk()):
        if p.isfile():
            word = soundFields(p.path)['word']
            yield p.path
Пример #3
0
 def test_internal_symlinks_only(self):
     """
     The resulting ``virtualenv`` only contains symlinks to files inside the
     virtualenv and to /usr on the host OS.
     """
     target_path = FilePath(self.mktemp())
     create_virtualenv(root=target_path)
     allowed_targets = (
         target_path,
         FilePath('/usr'),
     )
     bad_links = []
     for path in target_path.walk():
         if path.islink():
             realpath = path.realpath()
             for allowed_target in allowed_targets:
                 try:
                     realpath.segmentsFrom(allowed_target)
                 except ValueError:
                     pass
                 else:
                     # The target is a descendent of an allowed_target.
                     break
             else:
                 bad_links.append(path)
     if bad_links:
         self.fail("Symlinks outside of virtualenv detected:" +
                   '\n'.join('/'.join(path.segmentsFrom(target_path)) +
                             ' -> ' + path.realpath().path
                             for path in bad_links))
Пример #4
0
def findSounds(words):
    # incomplete, no user filtering
    top = FilePath('sounds/incoming/')
    for p in sorted(top.walk()):
        if p.isfile():
            word = soundFields(p)['word']
            if word not in words:
                continue
            yield p.path
Пример #5
0
 def get(self):
     top = FilePath('sounds')
     self.write({
         'sounds': [{
             'path': '/'.join(p.segmentsFrom(top)),
             'fields': soundFields('/'.join(p.segmentsFrom(top))),
         } for p in sorted(top.walk()) if p.isfile()],
         'hostname':
         socket.gethostname(),
     })
Пример #6
0
    def addDirectory(self, path):
        """Include `path` in test discovery.

        This scans all child directories of `path` and also all `parents`;
        `wantDirectory()` can then do an exact match.
        """
        start = FilePath(path)
        self.dirs = self.dirs.union(
            (fp.path for fp in start.parents()),
            (fp.path for fp in start.walk() if fp.isdir()),
        )
Пример #7
0
def run(path):

    fp = FilePath(path)
    children = [x for x in fp.walk() if x.splitext()[1] == ".py"]

    with click.progressbar(children) as c:
        for f in c:

            inp = f.getContent().decode('utf8')
            out = process_from_epydoc_to_sphinx(f, inp)

            f.setContent(u'\n'.join(out).encode('utf8'))
Пример #8
0
def main():
    existing = set(md.key for v, md in etcd.get_prefix(prefix))
    written = set()
    root = FilePath('config')
    print 'reading at %s' % root
    for f in root.walk():
        if f.isfile() and f.path.endswith('.n3'):
            n3 = f.getContent()
            key = prefix + b'/'.join(f.segmentsFrom(root))
            etcd.put(key, n3)
            written.add(key)
            print 'wrote %s' % key
    for k in existing - written:
        etcd.delete(k)
        print 'removed %s' % k
Пример #9
0
def main():
    existing = set(md.key for v, md in etcd.get_prefix(prefix))
    written = set()
    root = FilePath('config')
    print 'reading at %s' % root
    for f in root.walk():
        if f.isfile() and f.path.endswith('.n3'):
            n3 = f.getContent()
            key = prefix + b'/'.join(f.segmentsFrom(root))
            etcd.put(key, n3)
            written.add(key)
            print 'wrote %s' % key
    for k in existing - written:
        etcd.delete(k)
        print 'removed %s' % k
Пример #10
0
def assert_deb_content(test_case, expected_paths, package_path):
    """
    Fail unless the ``deb`` file at ``package_path`` contains all the
    ``expected_paths``.

    :param test_case: The ``TestCase`` whose assert methods will be called.
    :param set expected_paths: A set of ``FilePath`` s
    :param FilePath package_path: The path to the package under test.
    """
    output_dir = FilePath(test_case.mktemp())
    output_dir.makedirs()
    check_output(['dpkg', '--extract', package_path.path, output_dir.path])

    actual_paths = set()
    for f in output_dir.walk():
        if f.isdir():
            continue
        actual_paths.add(FilePath('/').descendant(f.segmentsFrom(output_dir)))

    test_case.assertEqual(expected_paths, actual_paths)
Пример #11
0
def assert_deb_content(test_case, expected_paths, package_path):
    """
    Fail unless the ``deb`` file at ``package_path`` contains all the
    ``expected_paths``.

    :param test_case: The ``TestCase`` whose assert methods will be called.
    :param set expected_paths: A set of ``FilePath`` s
    :param FilePath package_path: The path to the package under test.
    """
    output_dir = FilePath(test_case.mktemp())
    output_dir.makedirs()
    check_output(['dpkg', '--extract', package_path.path, output_dir.path])

    actual_paths = set()
    for f in output_dir.walk():
        if f.isdir():
            continue
        actual_paths.add(FilePath('/').descendant(f.segmentsFrom(output_dir)))

    test_case.assertEqual(expected_paths, actual_paths)
Пример #12
0
def _run(package,
         path,
         newversion,
         patch,
         rc,
         post,
         dev,
         create,
         _date=None,
         _getcwd=None,
         _print=print):

    if not _getcwd:
        _getcwd = os.getcwd

    if not _date:
        _date = datetime.date.today()

    if type(package) != str:
        package = package.encode('utf8')

    if not path:
        path = _findPath(_getcwd(), package)
    else:
        path = FilePath(path)

    if newversion and patch or newversion and dev or newversion and rc or \
       newversion and post:
        raise ValueError("Only give --newversion")

    if dev and patch or dev and rc or dev and post:
        raise ValueError("Only give --dev")

    if create and dev or create and patch or create and rc or \
       create and post or create and newversion:
        raise ValueError("Only give --create")

    if newversion:
        from pkg_resources import parse_version
        existing = _existing_version(path)
        st_version = parse_version(newversion)._version

        release = list(st_version.release)

        if len(release) == 1:
            release.append(0)
        if len(release) == 2:
            release.append(0)

        v = Version(
            package,
            *release,
            release_candidate=st_version.pre[1] if st_version.pre else None,
            post=st_version.post[1] if st_version.post else None,
            dev=st_version.dev[1] if st_version.dev else None)

    elif create:
        v = Version(package, _date.year - _YEAR_START, _date.month, 0)
        existing = v

    elif rc and not patch:
        existing = _existing_version(path)

        if existing.release_candidate:
            v = Version(package, existing.major, existing.minor,
                        existing.micro, existing.release_candidate + 1)
        else:
            v = Version(package, _date.year - _YEAR_START, _date.month, 0, 1)

    elif patch:
        if rc:
            rc = 1
        else:
            rc = None

        existing = _existing_version(path)
        v = Version(package, existing.major, existing.minor,
                    existing.micro + 1, rc)

    elif post:
        existing = _existing_version(path)

        if existing.post is None:
            _post = 0
        else:
            _post = existing.post + 1

        v = Version(package,
                    existing.major,
                    existing.minor,
                    existing.micro,
                    post=_post)

    elif dev:
        existing = _existing_version(path)

        if existing.dev is None:
            _dev = 0
        else:
            _dev = existing.dev + 1

        v = Version(package,
                    existing.major,
                    existing.minor,
                    existing.micro,
                    existing.release_candidate,
                    dev=_dev)

    else:
        existing = _existing_version(path)

        if existing.release_candidate:
            v = Version(package, existing.major, existing.minor,
                        existing.micro)
        else:
            raise ValueError(
                "You need to issue a rc before updating the major/minor")

    NEXT_repr = repr(Version(package, "NEXT", 0, 0)).split("#")[0]
    NEXT_repr_bytes = NEXT_repr.encode('utf8')

    version_repr = repr(v).split("#")[0]
    version_repr_bytes = version_repr.encode('utf8')

    existing_version_repr = repr(existing).split("#")[0]
    existing_version_repr_bytes = existing_version_repr.encode('utf8')

    _print("Updating codebase to %s" % (v.public()))

    for x in path.walk():

        if not x.isfile():
            continue

        original_content = x.getContent()
        content = original_content

        # Replace previous release_candidate calls to the new one
        if existing.release_candidate:
            content = content.replace(existing_version_repr_bytes,
                                      version_repr_bytes)
            content = content.replace(
                (package.encode('utf8') + b" " +
                 existing.public().encode('utf8')),
                (package.encode('utf8') + b" " + v.public().encode('utf8')))

        # Replace NEXT Version calls with the new one
        content = content.replace(NEXT_repr_bytes, version_repr_bytes)
        content = content.replace(NEXT_repr_bytes.replace(b"'", b'"'),
                                  version_repr_bytes)

        # Replace <package> NEXT with <package> <public>
        content = content.replace(
            package.encode('utf8') + b" NEXT",
            (package.encode('utf8') + b" " + v.public().encode('utf8')))

        if content != original_content:
            _print("Updating %s" % (x.path, ))
            with x.open('w') as f:
                f.write(content)

    _print("Updating %s/_version.py" % (path.path))
    with path.child("_version.py").open('w') as f:
        f.write((_VERSIONPY_TEMPLATE %
                 (package, package, version_repr)).encode('utf8'))
Пример #13
0
def _run(
        package,  # type: str
        path,  # type: Optional[str]
        newversion,  # type: Optional[str]
        patch,  # type: bool
        rc,  # type: bool
        post,  # type: bool
        dev,  # type: bool
        create,  # type: bool
        _date=None,  # type: Optional[datetime.date]
        _getcwd=None,  # type: Optional[Callable[[], str]]
        _print=print,  # type: Callable[[object], object]
):  # type: (...) -> None

    if not _getcwd:
        _getcwd = os.getcwd

    if not _date:
        _date = datetime.date.today()

    if type(package) != str:
        package = package.encode("utf8")  # type: ignore[assignment]

    _path = FilePath(path) if path else _findPath(_getcwd(), package)

    if (newversion and patch or newversion and dev or newversion and rc
            or newversion and post):
        raise ValueError("Only give --newversion")

    if dev and patch or dev and rc or dev and post:
        raise ValueError("Only give --dev")

    if (create and dev or create and patch or create and rc or create and post
            or create and newversion):
        raise ValueError("Only give --create")

    if newversion:
        from pkg_resources import parse_version

        existing = _existing_version(_path)
        st_version = parse_version(
            newversion)._version  # type: ignore[attr-defined]

        release = list(st_version.release)

        minor = 0
        micro = 0
        if len(release) == 1:
            (major, ) = release
        elif len(release) == 2:
            major, minor = release
        else:
            major, minor, micro = release

        v = Version(
            package,
            major,
            minor,
            micro,
            release_candidate=st_version.pre[1] if st_version.pre else None,
            post=st_version.post[1] if st_version.post else None,
            dev=st_version.dev[1] if st_version.dev else None,
        )

    elif create:
        v = Version(package, _date.year - _YEAR_START, _date.month, 0)
        existing = v

    elif rc and not patch:
        existing = _existing_version(_path)

        if existing.release_candidate:
            v = Version(
                package,
                existing.major,
                existing.minor,
                existing.micro,
                existing.release_candidate + 1,
            )
        else:
            v = Version(package, _date.year - _YEAR_START, _date.month, 0, 1)

    elif patch:
        existing = _existing_version(_path)
        v = Version(
            package,
            existing.major,
            existing.minor,
            existing.micro + 1,
            1 if rc else None,
        )

    elif post:
        existing = _existing_version(_path)

        if existing.post is None:
            _post = 0
        else:
            _post = existing.post + 1

        v = Version(package,
                    existing.major,
                    existing.minor,
                    existing.micro,
                    post=_post)

    elif dev:
        existing = _existing_version(_path)

        if existing.dev is None:
            _dev = 0
        else:
            _dev = existing.dev + 1

        v = Version(
            package,
            existing.major,
            existing.minor,
            existing.micro,
            existing.release_candidate,
            dev=_dev,
        )

    else:
        existing = _existing_version(_path)

        if existing.release_candidate:
            v = Version(package, existing.major, existing.minor,
                        existing.micro)
        else:
            raise ValueError(
                "You need to issue a rc before updating the major/minor")

    NEXT_repr = repr(Version(package, "NEXT", 0,
                             0)).split("#")[0].replace("'", '"')
    NEXT_repr_bytes = NEXT_repr.encode("utf8")

    version_repr = repr(v).split("#")[0].replace("'", '"')
    version_repr_bytes = version_repr.encode("utf8")

    existing_version_repr = repr(existing).split("#")[0].replace("'", '"')
    existing_version_repr_bytes = existing_version_repr.encode("utf8")

    _print("Updating codebase to %s" % (v.public()))

    for x in _path.walk():

        if not x.isfile():
            continue

        original_content = x.getContent()
        content = original_content

        # Replace previous release_candidate calls to the new one
        if existing.release_candidate:
            content = content.replace(existing_version_repr_bytes,
                                      version_repr_bytes)
            content = content.replace(
                (package.encode("utf8") + b" " +
                 existing.public().encode("utf8")),
                (package.encode("utf8") + b" " + v.public().encode("utf8")),
            )

        # Replace NEXT Version calls with the new one
        content = content.replace(NEXT_repr_bytes, version_repr_bytes)
        content = content.replace(NEXT_repr_bytes.replace(b"'", b'"'),
                                  version_repr_bytes)

        # Replace <package> NEXT with <package> <public>
        content = content.replace(
            package.encode("utf8") + b" NEXT",
            (package.encode("utf8") + b" " + v.public().encode("utf8")),
        )

        if content != original_content:
            _print("Updating %s" % (x.path, ))
            with x.open("w") as f:
                f.write(content)

    _print("Updating %s/_version.py" % (_path.path))
    with _path.child("_version.py").open("w") as f:
        f.write((_VERSIONPY_TEMPLATE.format(
            package=package, version_repr=version_repr)).encode("utf8"))
Пример #14
0
def _run(package, path, newversion, patch, rc, dev, create,
         _date=None, _getcwd=None, _print=print):

    if not _getcwd:
        _getcwd = os.getcwd

    if not _date:
        _date = datetime.date.today()

    if type(package) != str:
        package = package.encode('utf8')

    if not path:
        path = _findPath(_getcwd(), package)
    else:
        path = FilePath(path)

    if newversion and patch or newversion and dev or newversion and rc:
        raise ValueError("Only give --newversion")

    if dev and patch or dev and rc:
        raise ValueError("Only give --dev")

    if create and dev or create and patch or create and rc or \
       create and newversion:
        raise ValueError("Only give --create")

    if newversion:
        from pkg_resources import parse_version
        existing = _existing_version(path)
        st_version = parse_version(newversion)._version

        release = list(st_version.release)

        if len(release) == 1:
            release.append(0)
        if len(release) == 2:
            release.append(0)

        v = Version(
            package, *release,
            release_candidate=st_version.pre[1] if st_version.pre else None,
            dev=st_version.dev[1] if st_version.dev else None)

    elif create:
        v = Version(package, _date.year - _YEAR_START, _date.month, 0)
        existing = v

    elif rc and not patch:
        existing = _existing_version(path)

        if existing.release_candidate:
            v = Version(package, existing.major, existing.minor,
                        existing.micro, existing.release_candidate + 1)
        else:
            v = Version(package, _date.year - _YEAR_START, _date.month, 0, 1)

    elif patch:
        if rc:
            rc = 1
        else:
            rc = None

        existing = _existing_version(path)
        v = Version(package, existing.major, existing.minor,
                    existing.micro + 1, rc)

    elif dev:
        existing = _existing_version(path)

        if existing.dev is None:
            _dev = 0
        else:
            _dev = existing.dev + 1

        v = Version(package, existing.major, existing.minor,
                    existing.micro, existing.release_candidate, dev=_dev)

    else:
        existing = _existing_version(path)

        if existing.release_candidate:
            v = Version(package,
                        existing.major, existing.minor, existing.micro)
        else:
            raise ValueError(
                "You need to issue a rc before updating the major/minor")

    NEXT_repr = repr(Version(package, "NEXT", 0, 0)).split("#")[0]
    NEXT_repr_bytes = NEXT_repr.encode('utf8')

    version_repr = repr(v).split("#")[0]
    version_repr_bytes = version_repr.encode('utf8')

    existing_version_repr = repr(existing).split("#")[0]
    existing_version_repr_bytes = existing_version_repr.encode('utf8')

    _print("Updating codebase to %s" % (v.public()))

    for x in path.walk():

        if not x.isfile():
            continue

        original_content = x.getContent()
        content = original_content

        # Replace previous release_candidate calls to the new one
        if existing.release_candidate:
            content = content.replace(existing_version_repr_bytes,
                                      version_repr_bytes)
            content = content.replace(
                (package.encode('utf8') + b" " +
                 existing.public().encode('utf8')),
                (package.encode('utf8') + b" " +
                 v.public().encode('utf8')))

        # Replace NEXT Version calls with the new one
        content = content.replace(NEXT_repr_bytes,
                                  version_repr_bytes)
        content = content.replace(NEXT_repr_bytes.replace(b"'", b'"'),
                                  version_repr_bytes)

        # Replace <package> NEXT with <package> <public>
        content = content.replace(package.encode('utf8') + b" NEXT",
                                  (package.encode('utf8') + b" " +
                                   v.public().encode('utf8')))

        if content != original_content:
            _print("Updating %s" % (x.path,))
            with x.open('w') as f:
                f.write(content)

    _print("Updating %s/_version.py" % (path.path))
    with path.child("_version.py").open('w') as f:
        f.write(
            (_VERSIONPY_TEMPLATE % (
                package, package, version_repr)).encode('utf8'))