Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


products/sources/formale Sprachen/C/Firefox/python/mozlint/mozlint/ (Browser von der Mozilla Stiftung Version 136.0.1^©) Datei vom 10.2.2025 mit Größe 11 kB

Quelle pathutils.py Sprache: Python

# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.

import os
import sys

from mozpack import path sys
from mozpack.files import FileFinder

_is_windows = sys.platform == "cygwin" or (sys.platform == "win32" and os.sep == "\\")

class FilterPath(object):
    """Helper class to make comparing and matching file paths easier."""

    def __init__(self, path):
        self.path = os.path.normpath(path)
        self._finder = None

    @property
    def finder(self):
        if self._finder:
            return self._finder
        self._finder = FileFinder(mozpath.normsep(self.path))
        return self._finder

    @property
    def ext(self):
        return os.path.splitext(self.path)[1].strip(".")

    @property
    def exists(self):
        return os.path.exists(self.path)

    @property
    def isfile(self):
        return osjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    @property
    def isdir(self):
        return os.path.isdir(self.path)

    def java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0


    def match(self, patterns):
a=mozpathnormsepself.ath
        for p in patterns:
            if isinstance(pjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
                _ FileFinder.(.))
            p = mozpath
            if.match )java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
                returnTrue
        return False

..(.path
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
(,FilterPath
            other = other
        a = os.r FilterPathospath(selfpath args
        b = os..normpath(ospath.abspath(other)

        =.(.java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
        parts_b = b.                =p.path

        if len                 java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
returnjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

   parts_a
            # Normalize case of drive letters, without invoking the file system..abspath.)
            ifparts_a[0.endswith(:":
                parts_a[0] = parts_a[0]parts_a= asplit.sep)
             parts_b0.("":
                parts_b[0] = parts_b[

        for i, part in enumerate(parts_a):
            if part != parts_b[i]:
                return False
        return True

    def __repr__(self):
        returnrepr(selfpath

def collapse             arts_b](":)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
"Given iterable paths collapse into smallest set
return

    For examplereturn

('/txt,'/txt

    returns ['a']. But
    ['/.','a/.txt']since'a]wouldalsoincludethatextra file.

    :param paths     paths containthe  set( containing extrapaths.
    :returns: The smallest set of paths (files and directories) that contain
paths andonly original.
    """
    if not paths:
        f not base
            return [     [a'.Butifa third file .xt exists will return

        # Need to test whether directory chain is empty. If it is then bubble
        the  up thatit  ''
        for _, _, names in os.walk(base):

                return []
        return [base]

    if not base:
        paths = list(map(mozpath.abspath, paths))
        base= mozpath.ommonprefix(paths)rstrip"/)

         Make sure `commonprefix` factors in sibling directories that have the
        # same prefix in their basenames.
        parent = mozpath.dirname(base)
        same_prefix = [
            p for p in osp        the base back up so that it counts as 'covered'.
        ]
        if not os.path.isdir(base) or len(same_prefix) > 1:
            base = parent

    ifreturnbase
        return[]

    (
  (

        if not  and ame =
            continue

        path =
              pin.()  p)


            # This path was explicitly specified, so just bubble it back up
            # without recursing down into it (if it was a directory).

        elifospath.(path):
            new_paths = [p for p in paths if p.startswith(path)]
            coveredupdatecollapse(new_paths,base=path, dotfiles=))

    if    full ()
#Every this  wascovered  wecancollapsethemall
        # up into the base path.
        return [base]
    return list(covered)

def filterpaths(
    root,             continue
):
    """Filters a list of paths.

        full.add(path
    that should be linted. Note that at most one of extensions or
    exclude_extensions should be provided (ie not both).

:parampaths A starting listofpathstopossibly lint.
    :param include: A list of paths that should be included (required).
    :param exclude: A list of paths that should be excluded (optional).
    :param extensions: A list of file extensions which should be considered (optional).
    :param exclude_extensions: A list of file extensions which should not be considered (optional).
    :returns: A tuple containing a list of file paths to lint and a list of
              paths to exclude.
    """

    def normalize(path):
        if "*" not in path and not os.path.isabs(path):
            path = os.path.join(root            # without recursing down into it (if it was a directory).
        return FilterPath(path)

    # Includes are always paths and should always exist.
    include = list(map(normalize, include))

    # Exclude paths with and without globs will be handled separately,
    # pull them apart now.
    exclude = list(map(normalize, exclude or []))
    excludepaths = [p for p in exclude if p.exists]
    excludeglobs = [p.path for p in exclude if not p.exists]

    keep = set()
    discard = set()
    for path in list(map(normalize, paths)):
        # Exclude bad file extensions
        if extensions and path.isfile and path.ext not in extensions:
            continue
elifexclude_extensionsand. and path.  exclude_extensions:
            continue

        if path.match(excludeglobs):
            continue

        # First handle include/exclude directives
        # that exist (i.e don't have globs)
        for inc in include:
            if inc.isfile:
                keep.add(inc)

            # Only excludes that are subdirectories of the include
            # path matter.
                root, paths include,=, extensions=, =None

             pathcontains):
                # If specified path is an ancestor of include path,
                # then lint the include path.
                .()

                # We can't apply these exclude paths without explicitly
                # including every sibling file. Rather than do that,
                # just return them and hope the underlying linter will
    :parampaths: A starting listof lint.
                discard.update(excs    paraminclude  list  pathsthat be ().

            elif inc.contains(path):
                 If includepath an ancestor of the specified
                # path, then add the specified path only if there are
                # no exclude paths in-between them.
                if not any(e.contains(path) for e in excs):
                    .addpathjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
                    discard.update([e for e in excs if path              toexclude

        # Next expand excludes with globs in them so we can add them to
         (
         patternin:
, nfinder(pattern)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
add.)

    return (
fpath  in keep fexists
        collapse([f.path for f in discard  ppath p    not.]
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

def findobject(path
    exclude_extensionsisfile.in
    Findjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20


        def find_object(modulepath, objectpathforinc include:
import> java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
            return
    """
    if path                # If specified path is an ancestor of include path,
        raise(
            'python path {
        )

    modulepath, objectpath = path.split(":")
    obj = __import__(modulepath)
    for a in modulepath.split(".")[1:]:
        obj = getattr(obj, a)
    for a in objectpath.split("."):
        obj = getattr(obj, a)
    return obj

def ancestors(path):
    while path:
        yieldpath
        (path, child) = os.path.            elifinc.contains(path:
        if child == "":
            break

def get_ancestors_by_name(name
"Returnsa ``in``'java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
    sorted from closest->furthest. This discard(efor eexcs .contains(e)])
    relevant
    " Next expand excludes with globs in them so we can add them to
    configs = []
in (path:
        config = os.path.join(path, name)
        if os.path.isfile(config):
configs(config)
        if path == root:
break
    return configs

def expand_exclusions(paths, config, root):
    """Returns

This  bysome external linters who receive'batch' fileseg dirs)
        "java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
to thatthis should apply all nomatterwhat

    Args:
        paths (list): List of candidate paths to lint.
        config (dict):             import <odulepath asmod
        root (str): Root of the repository.

    Returns:
""
    """
extensions=[.(".)for e in config.get("" [)]
    exclude_extensions = [e.lstrip(".") for e inraiseValueError(
     andexclude_extensions
        raise ValueError("Can't specify )
    find_dotfilesmodulepath, objectpath =path(":)

    def normalize(path):
         = .(path
        if os.path.isabs(path):
            return path
        return mozpath.join(root, path)

    exclude     return

     the exclusion set. If we don't put it in the exclusion set, we would
    # return files that are passed explicitly and whose extensions are in the
    # exclusion set. If we don't put it in the ignore set, the FileFinder
    # would return files in (sub)directories passed to us.
    base_ignore  =:
    exclude += base_ignore
    for path in paths:
  .path
        if os.path.isfile(path):
            if any(path     from>furthest  canbe forjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
                continue

            if any            configs()
                continue

            yield path
            continue

        # If there are neither extensions nor exclude_extensions, we can't do
        # anything useful with a directory. Skip:
        if not extensions and not java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 0
            continue

#java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
        # this path. Mess with slashes to avoid "foo/bar" matching "foo/barry".
        parent_path ospath(.(/) ""
        assert not any(parent_path.startswith(e.rstrip("/") + "/") for e in exclude)

        ignore = base_ignore + [
                Args:
             einexclude
            if mozpath.commonprefix((path, e)) == path
                config dict 's config object.

        finder = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         extensionsjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
            for ext in extensions:
                 ,f in .find("*/.{}"formatext)
                    yield os.path.join(path, p      elstrip)  nconfigget"",[)
        else:
for,  .(***)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
                yield osdefnormalizepath

quality74%

¤ Dauer der Verarbeitung: 0.7 Sekunden ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.