Changeset ferringb@gmail.com-20080624174036-q45fk4fxguj9kjlv


Ignore:
Timestamp:
06/24/08 17:40:36 (2 years ago)
Author:
Brian Harring <ferringb@…>
branch-nick:
pkgcore-checks
Message:

punt trailing whitespace

Files:
29 edited

Legend:

Unmodified
Added
Removed

  • NEWS

    rferringb@gmail.com-20080318235545-ige2dsuh3lvmfp9m rferringb@gmail.com-20080624174036-q45fk4fxguj9kjlv  
    64640.3.3: 
    6565 
    66 * drop digest specific checks; portage now prunes digests on sync regardless  
     66* drop digest specific checks; portage now prunes digests on sync regardless 
    6767  of whether or not the repo is m2 pure; thus, no way to detect if a missing 
    6868  digest is actually a screwup in the repo, or if it's portage being 'special'. 
    … …  
    102102* new PickleStream reporter; used to serialize check results, and flush the 
    103103  stream out stdout.  If you need to get at the data generated, this is the 
    104   sanest way to do it (alternatives require trying to deserialize what a  
     104  sanest way to do it (alternatives require trying to deserialize what a 
    105105  reporter does, thus losing data). 
    106106* added new tool replay-pcheck-stream; used to replay a pickle stream through 

  • TODO

    rmarienz@gentoo.org-20061121201623-5bcc0f402b293d88 rferringb@gmail.com-20080624174036-q45fk4fxguj9kjlv  
    55- rework filter-env so it dumps a struct representing the parsing instead of 
    66  doing it inline; add python bindings, use that for source flow analysis 
    7 - look into trying to identify unused functions in an ebuild; eclasses, and  
     7- look into trying to identify unused functions in an ebuild; eclasses, and 
    88  bash support for f() { echo "monkeys"; };x=f;${!x}; makes this potentially 
    99  likely to be a major false positive source. 
    … …  
    1414- parallelize the bugger (potentially hard).  can probably thread it splitting 
    1515  it such that check x handles checks using globals x (cache mainly), other 
    16   checks being bits that don't; gain may not be much since the major time  
     16  checks being bits that don't; gain may not be much since the major time 
    1717  consumers are visibility and unported_mod_x 

  • pkgcore_checks/addons.py

    rferringb@gmail.com-20080624173954-nab8ouii8xngsv25 rferringb@gmail.com-20080624174036-q45fk4fxguj9kjlv  
    1313from pkgcore_checks import base, util 
    1414 
    15 from snakeoil import (demandload, currying, containers, mappings, iterables,  
     15from snakeoil import (demandload, currying, containers, mappings, iterables, 
    1616    lists) 
    1717demandload.demandload(globals(), 
    … …  
    176176 
    177177        disabled = set(norm_name(x) for x in options.profiles_disabled) 
    178         enabled = set(x for x in  
     178        enabled = set(x for x in 
    179179            (norm_name(y) for y in options.profiles_enabled) 
    180180            if x not in disabled) 
    … …  
    185185                util.get_profiles_desc(options.profile_base_dir, 
    186186                    ignore_dev=options.profile_ignore_dev) 
    187              
     187 
    188188            for k, v in d.iteritems(): 
    189189                l = [x for x in map(norm_name, v) 
    190190                    if not x in disabled] 
    191                  
    192                 # wipe any enableds that are here already so we don't  
     191 
     192                # wipe any enableds that are here already so we don't 
    193193                # get a profile twice 
    194194                enabled.difference_update(l) 
    … …  
    203203                    "profile %s lacks arch settings, unable to use it" % x) 
    204204            arch_profiles.setdefault(p.arch, []).append((x, p)) 
    205              
     205 
    206206        for x in options.profiles_enabled: 
    207207            options.profile_func(x) 
    … …  
    219219        self.keywords_filter = {} 
    220220        ignore_deprecated = self.options.profile_ignore_deprecated 
    221          
     221 
    222222        # we hold onto the profiles as we're going, due to the fact 
    223223        # profilenodes are weakly cached; hold onto all for this loop, 
    … …  
    231231            stable_key = k.lstrip("~") 
    232232            unstable_key = "~"+ stable_key 
    233             stable_r = packages.PackageRestriction("keywords",  
     233            stable_r = packages.PackageRestriction("keywords", 
    234234                values.ContainmentMatch(stable_key)) 
    235             unstable_r = packages.PackageRestriction("keywords",  
     235            unstable_r = packages.PackageRestriction("keywords", 
    236236                values.ContainmentMatch(stable_key, unstable_key)) 
    237              
     237 
    238238            default_masked_use = [(packages.AlwaysTrue, (x,)) for x in 
    239239                self.official_arches if x != stable_key] 
    240              
     240 
    241241            profile_filters.update({stable_key:[], unstable_key:[]}) 
    242242            for profile_name in arch_profiles.get(k, []): 
    … …  
    258258                    [(packages.AlwaysTrue, (stable_key,))], 
    259259                    profile.forced_use.iteritems()) 
    260                  
    261                 # used to interlink stable/unstable lookups so that if  
     260 
     261                # used to interlink stable/unstable lookups so that if 
    262262                # unstable says it's not visible, stable doesn't try 
    263263                # if stable says something is visible, unstable doesn't try. 
    … …  
    290290            self.keywords_filter[stable_key] = stable_r 
    291291            self.keywords_filter[unstable_key] = packages.PackageRestriction( 
    292                 "keywords",  
     292                "keywords", 
    293293                values.ContainmentMatch(unstable_key)) 
    294294 
    … …  
    407407 
    408408    threshold = base.versioned_feed 
    409      
     409 
    410410    def __init__(self, pkg, attr, flags): 
    411411        base.Result.__init__(self) 
    412412        self._store_cpv(pkg) 
    413413        self.attr, self.flags = attr, tuple(flags) 
    414      
     414 
    415415    @property 
    416416    def short_desc(self): 
    … …  
    459459                    try: 
    460460                        estr = entry.rsplit(".", 1)[0].lower()+ "_" 
    461                         unstated_iuse.update(estr + usef.strip() for usef in  
     461                        unstated_iuse.update(estr + usef.strip() for usef in 
    462462                            read_dict(osutils.join(use_expand_base, entry), 
    463463                                None).iterkeys()) 
    … …  
    472472        self.specific_iuse = tuple((x[0], tuple(x[1])) for x in specific_iuse) 
    473473        self.collapsed_iuse = misc.non_incremental_collapsed_restrict_to_data( 
    474             ((packages.AlwaysTrue, known_iuse),),  
     474            ((packages.AlwaysTrue, known_iuse),), 
    475475            ((packages.AlwaysTrue, unstated_iuse),), 
    476476            self.specific_iuse) 
    … …  
    493493            return currying.partial(self.use_validate, attr=attr_name) 
    494494        return self.use_validate 
    495          
     495 
    496496    @staticmethod 
    497497    def fake_use_validate(klasses, pkg, seq, reporter, attr=None): 
    … …  
    508508        skip_filter = (packages.Conditional,) + klasses 
    509509        unstated = set() 
    510      
     510 
    511511        stated = self.iuse_strip(pkg.iuse) 
    512512        i = iterables.expandable_chain(lists.iflatten_instance(seq, 

  • pkgcore_checks/base.py

    rferringb@gmail.com-20070408202649-jgels0n569r8my90 rferringb@gmail.com-20080624174036-q45fk4fxguj9kjlv  
    175175        except NotImplementedError: 
    176176            return "result from %s" % self.__class__.__name__ 
    177      
     177 
    178178    @property 
    179179    def short_desc(self): 
    … …  
    183183    def long_desc(self): 
    184184        return self.short_desc 
    185      
     185 
    186186    def _store_cp(self, pkg): 
    187187        self.category = pkg.category 
    188188        self.package = pkg.package 
    189      
     189 
    190190    def _store_cpv(self, pkg): 
    191191        self._store_cp(pkg) 
    … …  
    201201                raise AttributeError(self.__class__, str(a)) 
    202202        return object.__getstate__(self) 
    203      
     203 
    204204    def __setstate__(self, data): 
    205205        attrs = set(getattr(self, '__attrs__', getattr(self, '__slots__', []))) 
    … …  
    221221    def start_check(self, source, target): 
    222222        pass 
    223      
     223 
    224224    def end_check(self): 
    225225        pass 

  • pkgcore_checks/cleanup.py

    rferringb@gmail.com-20070408202649-jgels0n569r8my90 rferringb@gmail.com-20080624174036-q45fk4fxguj9kjlv  
    2929class RedundantVersionReport(Template): 
    3030    """ 
    31     scan for versions that are likely shadowed by later versions from a  
     31    scan for versions that are likely shadowed by later versions from a 
    3232    keywords standpoint (ignoring -9999 versioned packages) 
    33      
    34     Example: pkga-1 is keyworded amd64, pkga-2 is amd64.   
     33 
     34    Example: pkga-1 is keyworded amd64, pkga-2 is amd64. 
    3535    pkga-1 can potentially be removed. 
    3636    """ 
    … …  
    4242        if len(pkgset) == 1: 
    4343            return 
    44          
     44 
    4545        # algo is roughly thus; spot stable versions, hunt for subset 
    4646        # keyworded pkgs that are less then the max version; 

  • pkgcore_checks/deprecated.py

    rferringb@gmail.com-20070213122704-diaydvzzeptt2vel rferringb@gmail.com-20080624174036-q45fk4fxguj9kjlv  
    77class DeprecatedEclass(Result): 
    88    """pkg uses an eclass that is deprecated/abandoned""" 
    9      
     9 
    1010    __slots__ = ("category", "package", "version", "eclasses") 
    1111    threshold = versioned_feed 
    12      
     12 
    1313    def __init__(self, pkg, eclasses): 
    1414        Result.__init__(self) 

  • pkgcore_checks/dropped_keywords.py

    rjokey@gentoo.org-20071214152518-f29y8pyqvxilpohs rferringb@gmail.com-20080624174036-q45fk4fxguj9kjlv  
    5757            state = oldstate 
    5858            lastpkg = pkg 
    59   
     59 
    6060        for key, pkg in dropped: 
    6161            reporter.add_report(DroppedKeywordWarning(key, pkg)) 

  • pkgcore_checks/glsa_scan.py

    rferringb@gmail.com-20070405184154-1nqu8pvp0wnm7zi3 rferringb@gmail.com-20080624174036-q45fk4fxguj9kjlv  
    66from pkgcore_checks import base 
    77from snakeoil.demandload import demandload 
    8 demandload(globals(),  
     8demandload(globals(), 
    99    'pkgcore.pkgsets.glsa:GlsaDirSet', 
    1010    'pkgcore.restrictions:packages,values', 
    … …  
    3030                arches.update(x.lstrip("~") for x in v.restriction.vals) 
    3131            else: 
    32                 raise Exception("unexpected restriction sequence- %s in %s" %  
     32                raise Exception("unexpected restriction sequence- %s in %s" % 
    3333                    (v.restriction, glsa)) 
    3434        keys = set(x.lstrip("~") for x in pkg.keywords if not x.startswith("-")) 
    … …  
    3939            self.arch = tuple(sorted(keys)) 
    4040        self.glsa = str(glsa) 
    41      
     41 
    4242    @property 
    4343    def short_desc(self): 
    … …  
    4848    """ 
    4949    Scan for vulnerabile ebuilds in the tree 
    50      
     50 
    5151    requires a GLSA directory for vuln. info 
    5252    """ 
    … …  
    113113        for r in GlsaDirSet(self.glsa_dir): 
    114114            if len(r) > 2: 
    115                 self.vulns.setdefault(r[0].key,  
     115                self.vulns.setdefault(r[0].key, 
    116116                    []).append(packages.AndRestriction(*r[1:])) 
    117117            else: 

  • pkgcore_checks/imlate.py

    rferringb@gmail.com-20070207174621-yb3eqrqc6jtmdgse rferringb@gmail.com-20080624174036-q45fk4fxguj9kjlv  
    99 
    1010    """Arch that is behind another from a stabling standpoint""" 
    11      
     11 
    1212    __slots__ = ("category", "package", "version", "keywords", 
    1313        "stable") 
    1414    threshold = base.versioned_feed 
    15      
     15 
    1616    def __init__(self, pkg, keywords): 
    1717        base.Result.__init__(self) 
    … …  
    2020        self.stable = tuple(str(x) for x in pkg.keywords 
    2121            if not x[0] in ("~", "-")) 
    22      
     22 
    2323    @property 
    2424    def short_desc(self): 
    … …  
    3030 
    3131    """ 
    32     scan for ebuilds that can be stabled based upon stabling status for  
     32    scan for ebuilds that can be stabled based upon stabling status for 
    3333    other arches 
    3434    """ 
    … …  
    5151        base.Template.__init__(self, options) 
    5252        arches = frozenset(x.strip().lstrip("~") for x in options.arches) 
    53         self.target_arches = frozenset("~%s" % x.strip().lstrip("~")  
     53        self.target_arches = frozenset("~%s" % x.strip().lstrip("~") 
    5454            for x in arches) 
    55         self.source_arches = frozenset(x.lstrip("~")  
     55        self.source_arches = frozenset(x.lstrip("~") 
    5656            for x in options.reference_arches) 
    5757        self.source_filter = packages.PackageRestriction("keywords", 

  • pkgcore_checks/metadata_checks.py

    rjokey@gentoo.org-20071230125611-5bk03uu70wtw86bk rferringb@gmail.com-20080624174036-q45fk4fxguj9kjlv  
    2222    __slots__ = ("category", "package", "version", "attr", "msg") 
    2323    threshold = base.versioned_feed 
    24      
     24 
    2525    def __init__(self, pkg, attr, msg): 
    2626        base.Result.__init__(self) 
    2727        self._store_cpv(pkg) 
    2828        self.attr, self.msg = attr, str(msg) 
    29      
     29 
    3030    @property 
    3131    def short_desc(self): 
    … …  
    3838    __slots__ = ("category", "package", "version", "licenses") 
    3939    threshold = base.versioned_feed 
    40      
     40 
    4141    def __init__(self, pkg, licenses): 
    4242        self._store_cpv(pkg) 
    4343        self.licenses = tuple(sorted(licenses)) 
    44      
     44 
    4545    @property 
    4646    def short_desc(self): 
    … …  
    5757 
    5858    required_addons = (addons.UseAddon, addons.ProfileAddon, 
    59         addons.LicenseAddon)  
     59        addons.LicenseAddon) 
    6060 
    6161    def __init__(self, options, iuse_handler, profiles, licenses): 
    … …  
    7676            raise 
    7777        except (MetadataException, MalformedAtom, ValueError), e: 
    78             reporter.add_report(MetadataError(pkg, 'license',  
     78            reporter.add_report(MetadataError(pkg, 'license', 
    7979                "error- %s" % e)) 
    8080            del e 
    … …  
    8282            logging.exception("unknown exception caught for pkg(%s) attr(%s): " 
    8383                "type(%s), %s" % (pkg, 'license', type(e), e)) 
    84             reporter.add_report(MetadataError(pkg, 'license',  
     84            reporter.add_report(MetadataError(pkg, 'license', 
    8585                "exception- %s" % e)) 
    8686            del e 
    … …  
    120120                self.iuse_handler.allowed_iuse(pkg)) 
    121121            if iuse: 
    122                 reporter.add_report(MetadataError(pkg, "iuse",  
     122                reporter.add_report(MetadataError(pkg, "iuse", 
    123123                    "iuse unknown flags- [ %s ]" % ", ".join(iuse))) 
    124124 
    … …  
    156156                raise 
    157157            except (MetadataException, MalformedAtom, ValueError), e: 
    158                 reporter.add_report(MetadataError(pkg, attr_name,  
     158                reporter.add_report(MetadataError(pkg, attr_name, 
    159159                    "error- %s" % e)) 
    160160                del e 
    … …  
    163163                    "unknown exception caught for pkg(%s) attr(%s): " 
    164164                    "type(%s), %s" % (pkg, attr_name, type(e), e)) 
    165                 reporter.add_report(MetadataError(pkg, attr_name,  
     165                reporter.add_report(MetadataError(pkg, attr_name, 
    166166                    "exception- %s" % e)) 
    167167                del e 
    … …  
    177177        base.Result.__init__(self) 
    178178        self._store_cpv(pkg) 
    179      
     179 
    180180    short_desc = ("keywords contain -*; use package.mask or empty keywords " 
    181181        "instead") 
    182          
     182 
    183183 
    184184class KeywordsReport(base.Template): 
    185      
     185 
    186186    """ 
    187187    check pkgs keywords for sanity; empty keywords, and -* are flagged 
    188188    """ 
    189      
     189 
    190190    feed_type = base.versioned_feed 
    191191    known_results = (StupidKeywords, MetadataError) 
    192      
     192 
    193193    def feed(self, pkg, reporter): 
    194194        if "-*" in pkg.keywords and len(pkg.keywords) == 1: 
    … …  
    205205        self._store_cpv(pkg) 
    206206        self.filename = filename 
    207      
     207 
    208208    @property 
    209209    def short_desc(self): 
    210210        return "file %s is unfetchable- no URI available, and RESTRICT=fetch " \ 
    211211            "isn't set" % self.filename 
    212      
     212 
    213213 
    214214class BadProto(base.Result): 
    … …  
    222222        self.filename = filename 
    223223        self.bad_uri = tuple(sorted(bad_uri)) 
    224      
     224 
    225225    @property 
    226226    def short_desc(self): 
    227227        return "file %s: bad protocol/uri: %r " % (self.filename, self.bad_uri) 
    228      
     228 
    229229 
    230230class SrcUriReport(base.Template): 
    … …  
    285285 
    286286class CrappyDescription(base.Result): 
    287      
     287 
    288288    """pkg's description sucks in some fashion""" 
    289289 
    … …  
    295295        self._store_cpv(pkg) 
    296296        self.msg = msg 
    297      
     297 
    298298    @property 
    299299    def short_desc(self): 
    300300        return "description needs improvement: %s" % self.msg 
    301      
     301 
    302302 
    303303class DescriptionReport(base.Template): 
    … …  
    307307    just using the pkgs name 
    308308    """ 
    309      
     309 
    310310    feed_type = base.versioned_feed 
    311311    known_results = (CrappyDescription,) 
    … …  
    337337class BadRestricts(base.Result): 
    338338    """pkg's restrict metadata has unknown/deprecated entries""" 
    339      
     339 
    340340    __slots__ = ("category", "package", "version", "restricts", "deprecated") 
    341341    threshold = base.versioned_feed 
    342      
     342 
    343343    def __init__(self, pkg, restricts, deprecated=None): 
    344344        base.Result.__init__(self) 
    … …  
    348348        if not restricts and not deprecated: 
    349349            raise TypeError("deprecated or restricts must not be empty") 
    350      
     350 
    351351    @property 
    352352    def short_desc(self): 
    … …  
    360360                self.deprecated) 
    361361        return s 
    362          
     362 
    363363 
    364364class RestrictsReport(base.Template): 
    365365    feed_type = base.versioned_feed 
    366     known_restricts = frozenset(("confcache", "stricter", "mirror", "fetch",  
     366    known_restricts = frozenset(("confcache", "stricter", "mirror", "fetch", 
    367367        "test", "sandbox", "userpriv", "primaryuri", "binchecks", "strip", 
    368368        "multilib-strict")) 
    369369 
    370370    known_results = (BadRestricts,) + addons.UseAddon.known_results 
    371     required_addons = (addons.UseAddon,)  
     371    required_addons = (addons.UseAddon,) 
    372372 
    373373    __doc__ = "check over RESTRICT, looking for unknown restricts\nvalid " \ 

  • pkgcore_checks/metadata_xml.py

    rferringb@gmail.com-20071026032833-rscc1s9ni1lnqgvf rferringb@gmail.com-20080624174036-q45fk4fxguj9kjlv  
    1818    __slots__ = ('category', 'package', 'filename') 
    1919    __attrs__ = __slots__ 
    20      
     20 
    2121    def __init__(self, filename, category, package=None): 
    2222        base.Result.__init__(self) 
    … …  
    4141    __slots__ = ("category", "package", "filename") 
    4242    __attrs__ = __slots__ 
    43      
     43 
    4444    def __init__(self, filename, category, package=None): 
    4545        base.Result.__init__(self) 
    … …  
    4747        self.package = package 
    4848        self.filename = filename 
    49      
     49 
    5050    @property 
    5151    def _label(self): 
    … …  
    5757    def short_desc(self): 
    5858        return "%s %s is not well formed xml" % (self._label, os.path.basename(self.filename)) 
    59      
     59 
    6060 
    6161class base_InvalidXml(base.Result): 
    … …  
    6464    __slots__ = ("category", "package", "filename") 
    6565    __attrs__ = __slots__ 
    66      
     66 
    6767    def __init__(self, filename, category, package=None): 
    6868        base.Result.__init__(self, filename, category, package=None) 
    … …  
    243243        self.parsed_dtd = self.libxml2.parseDTD(None, loc) 
    244244        self.validator = self.libxml2.newValidCtxt() 
    245      
     245 
    246246    def validate(self, loc): 
    247247        """ 
    … …  
    265265        self.dtd_loc = loc 
    266266        self.bin_loc = find_binary("xmllint") 
    267      
     267 
    268268    def validate(self, loc): 
    269269        """ 

  • pkgcore_checks/pcheck.py

    rferringb@gmail.com-20070405184154-1nqu8pvp0wnm7zi3 rferringb@gmail.com-20080624174036-q45fk4fxguj9kjlv  
    347347            out.first_prefix.pop() 
    348348            out.later_prefix.pop() 
    349      
     349 
    350350@decorate_forced_wrapping() 
    351351def display_checks(out, checks): 
    … …  
    358358        out.write() 
    359359        return 
    360          
     360 
    361361    for module_name in sorted(d): 
    362362        out.write(out.bold, "%s:" % module_name) 
    … …  
    396396            out.first_prefix.pop() 
    397397            out.later_prefix.pop() 
    398      
     398 
    399399    if plugin_reporters: 
    400400        if config_reporters: 
    … …  
    429429            options.config.pcheck_reporter_factory.values(), 
    430430            list(get_plugins('reporter', plugins))) 
    431         return 0     
     431        return 0 
    432432 
    433433    if not options.repo_bases: 

  • pkgcore_checks/pkgdir_checks.py

    rferringb@gmail.com-20070405184154-1nqu8pvp0wnm7zi3 rferringb@gmail.com-20080624174036-q45fk4fxguj9kjlv  
    2828 
    2929    threshold = package_feed 
    30      
     30 
    3131    def __init__(self, pkg, filename): 
    3232        Result.__init__(self) 
    … …  
    3737    def short_desc(self): 
    3838        return "required file %s doesn't exist" % self.filename 
    39      
     39 
    4040 
    4141class ExecutableFile(Result): 
    … …  
    4545 
    4646    threshold = package_feed 
    47      
     47 
    4848    def __init__(self, pkg, filename): 
    4949        Result.__init__(self) 
    5050        self._store_cp(pkg) 
    5151        self.filename = filename 
    52      
     52 
    5353    @property 
    5454    def short_desc(self): 
    5555        return "file %s has unecessary executable bit" % self.filename 
    56      
     56 
    5757 
    5858class SizeViolation(Result): 
    … …  
    6262 
    6363    threshold = package_feed 
    64      
     64 
    6565    def __init__(self, pkg, size): 
    6666        Result.__init__(self) 
    6767        self._store_cp(pkg) 
    6868        self.size = size 
    69      
     69 
    7070    @property 
    7171    def short_desc(self): 
    … …  
    7676 
    7777    """file doesn't abide by glep31 requirements""" 
    78      
     78 
    7979    __slots__ = ("category", "package", "filename") 
    8080 
    8181    threshold = package_feed 
    82      
     82 
    8383    def __init__(self, pkg, filename): 
    8484        Result.__init__(self) 
    8585        self._store_cp(pkg) 
    8686        self.filename = filename 
    87      
     87 
    8888    @property 
    8989    def short_desc(self): 
    … …  
    9595 
    9696    """file isn't utf8 compliant""" 
    97      
     97 
    9898    __slots__ = ("category", "package", "filename", "err") 
    9999 
    100100    threshold = package_feed 
    101      
     101 
    102102    def __init__(self, pkg, filename, err): 
    103103        Result.__init__(self) 
    … …  
    105105        self.filename = filename 
    106106        self.err = err 
    107      
     107 
    108108    @property 
    109109    def short_desc(self): 
    … …  
    113113def utf8_check(pkg, base, filename, reporter): 
    114114    try: 
    115         codecs.open(pjoin(base, filename), mode="rb",  
     115        codecs.open(pjoin(base, filename), mode="rb", 
    116116            encoding="utf8", buffering=8192).read() 
    117117    except UnicodeDecodeError, e: 
    … …  
    124124 
    125125    feed_type = package_feed 
    126      
     126 
    127127    ignore_dirs = set(["cvs", ".svn", ".bzr"]) 
    128128    known_results = (MissingFile, ExecutableFile, SizeViolation, 
    … …  
    137137            # handed to any, it's a frame switch each 
    138138            # char, which adds up. 
    139              
    140             if any(True for x in filename if  
     139 
     140            if any(True for x in filename if 
    141141                x not in allowed_filename_chars_set): 
    142142                reporter.add_report(Glep31Violation(pkgset[0], filename)) 
    143              
     143 
    144144            if filename.endswith(".ebuild") or filename in \ 
    145145                ("Manifest", "ChangeLog", "metadata.xml"): 
    146146                if os.stat(pjoin(base, filename)).st_mode & 0111: 
    147147                    reporter.add_report(ExecutableFile(pkgset[0], filename)) 
    148              
     148 
    149149            if filename.endswith(".ebuild"): 
    150150                utf8_check(pkgset[0], base, filename, reporter) 
    … …  
    157157            del e 
    158158            reporter.add_report(MissingFile(pkgset[0], "ChangeLog")) 
    159                  
     159 
    160160        if not os.path.exists(pjoin(base, "files")): 
    161161            if pkgset[0].manifest.version == 1: 
    162162                reporter.add_report(MissingFile(pkgset[0], "files")) 
    163163            return 
    164                              
     164 
    165165        size = 0 
    166166        unprocessed_dirs = deque(["files"]) 
    … …  
    181181                    if not fn.startswith("digest-"): 
    182182                        size += st.st_size 
    183                         if any(True for x in fn if  
     183                        if any(True for x in fn if 
    184184                            x not in allowed_filename_chars_set): 
    185185                            reporter.add_report(Glep31Violation(pkgset[0], 

  • pkgcore_checks/repo_metadata.py

    rferringb@gmail.com-20080318043726-spb05yn0xqhsbp8k rferringb@gmail.com-20080624174036-q45fk4fxguj9kjlv  
    2020 
    2121class UnusedLocalFlagsResult(base.Result): 
    22      
     22 
    2323    """ 
    2424    unused use.local.desc flag(s) 
    2525    """ 
    26      
     26 
    2727    __slots__ = ("category", "package", "flags") 
    2828 
    … …  
    3434        self._store_cp(pkg) 
    3535        self.flags = tuple(sorted(flags)) 
    36      
     36 
    3737    @property 
    3838    def short_desc(self): 
    … …  
    6969 
    7070class UnusedGlobalFlagsResult(base.Result): 
    71      
     71 
    7272    """ 
    7373    unused use.desc flag(s) 
    7474    """ 
    75      
     75 
    7676    __slots__ = ("flags",) 
    7777 
    … …  
    8282        # tricky, but it works; atoms have the same attrs 
    8383        self.flags = tuple(sorted(flags)) 
    84      
     84 
    8585    @property 
    8686    def short_desc(self): 
    … …  
    121121    unused license(s) detected 
    122122    """ 
    123      
     123 
    124124    __slots__ = ("licenses",) 
    125      
     125 
    126126    threshold = base.repository_feed 
    127      
     127 
    128128    def __init__(self, licenses): 
    129129        base.Result.__init__(self) 
    … …  
    173173        else: 
    174174            yield chf, "%x" % val1, "%x" % val2 
    175      
     175 
    176176 
    177177class ConflictingChksums(base.Result): 
    … …  
    183183    __slots__ = ("category", "package", "version", 
    184184        "filename", "chksums", "others") 
    185      
     185 
    186186    threshold = base.versioned_feed 
    187      
     187 
    188188    _sorter = staticmethod(operator.itemgetter(0)) 
    189      
     189 
    190190    def __init__(self, pkg, filename, chksums, others): 
    191191        base.Result.__init__(self) 
    … …  
    206206    manifest2 has a checksum entry digest lacks 
    207207    """ 
    208      
     208 
    209209    __slots__ = ("category", "package", "files") 
    210210 
    … …  
    215215        self._store_cp(pkg) 
    216216        self.files = tuple(sorted(files)) 
    217      
     217 
    218218    @property 
    219219    def short_desc(self): 
    … …  
    244244    a package's checksum data still is manifest1, instead of manifest2 
    245245    """ 
    246      
     246 
    247247    threshold = base.package_feed 
    248248    __slots__ = ("category", "package") 
    249      
     249 
    250250    def __init__(self, pkg): 
    251251        self._store_cp(pkg) 
    252      
     252 
    253253    short_desc = "still is using manifest1 format, should be using manifest2" 
    254254 
    … …  
    276276                reporter.add_report(DeprecatedManifest1(pkgset[0])) 
    277277                continue 
    278              
     278 
    279279            seen = set() 
    280280            for pkg in pkgset: 

  • pkgcore_checks/report_stream.py

    rferringb@gmail.com-20070405184154-1nqu8pvp0wnm7zi3 rferringb@gmail.com-20080624174036-q45fk4fxguj9kjlv  
    55reporter. 
    66 
    7 Useful if you need to delay acting on results until it can be done in  
     7Useful if you need to delay acting on results until it can be done in 
    88one minimal window (say updating a database), or want to generate 
    99several different reports without using a config defined multiplex reporter. 
    … …  
    3030        for x in checks: 
    3131            self.known_results.update(x.known_results) 
    32          
     32 
    3333        self.known_results = tuple(sorted(self.known_results)) 
    3434        self.criteria = str(criteria) 
    35          
     35 
    3636 
    3737class PickleStream(base.Reporter): 
    … …  
    3939    Generate a stream of pickled objects. 
    4040    For each specific target for checks, a header is pickled 
    41     detailing the checks used, possible results, and search  
     41    detailing the checks used, possible results, and search 
    4242    criteria. 
    43      
     43 
    4444    """ 
    4545    priority = -1001 
    4646    protocol = 0 
    47      
     47 
    4848    def __init__(self, out): 
    4949        """Initialize. 
    … …  
    6767        except TypeError, t: 
    6868            raise TypeError(result, str(t)) 
    69      
     69 
    7070 
    7171class BinaryPickleStream(PickleStream): 
    … …  
    8181 
    8282    def __init__(self, **kwargs): 
    83         commandline.OptionParser.__init__(self, description=__doc__,  
     83        commandline.OptionParser.__init__(self, description=__doc__, 
    8484            usage="replay_report_stream <pickle-file> <python namespace path" 
    8585            "reporter to replay it into>", 
    … …  
    9292    def check_values(self, values, args): 
    9393        vals, args = commandline.OptionParser.check_values(self, values, args) 
    94          
     94 
    9595        if len(args) < 2: 
    9696            self.error("need at least two args, pickle file, and reporter") 
    … …  
    102102        values.reporter = load_attribute(args[1]) 
    103103        values.stream_path = args[0] 
    104          
     104 
    105105        return values, [] 
    106106 
    … …  
    113113            if debug: 
    114114                if headers: 
    115                     debug.write("finished processing %i results for %s" %  
     115                    debug.write("finished processing %i results for %s" % 
    116116                        (count - last_count, headers[-1].criteria)) 
    117117                last_count = count 
    … …  
    127127        reporter.end_check() 
    128128        if debug: 
    129             debug.write("finished processing %i results for %s" %  
     129            debug.write("finished processing %i results for %s" % 
    130130                (count - last_count, headers[-1].criteria)) 
    131131 

  • pkgcore_checks/reporters.py

    rferringb@gmail.com-20070405184154-1nqu8pvp0wnm7zi3 rferringb@gmail.com-20080624174036-q45fk4fxguj9kjlv  
    4444            self.first_report = False 
    4545        if result.threshold == base.versioned_feed: 
    46             self.out.write("%s/%s-%s: %s" % (result.category, result.package,  
     46            self.out.write("%s/%s-%s: %s" % (result.category, result.package, 
    4747                result.version, result.short_desc)) 
    4848        elif result.threshold == base.package_feed: 
    … …  
    6363    """ 
    6464    groupped colored output, example: 
    65      
     65 
    6666    sys-apps/portage 
    6767      WrongIndentFound: sys-apps/portage-2.1-r2.ebuild has whitespace in indentation on line 169 
    … …  
    141141 
    142142    def add_report(self, result): 
    143         d = dict((k, getattr(result, k, '')) for k in  
     143        d = dict((k, getattr(result, k, '')) for k in 
    144144            ("category", "package", "version")) 
    145145        d["msg"] = xml.escape(result.short_desc) 

  • pkgcore_checks/stale_unstable.py

    rferringb@gmail.com-20070215055854-o62wwq2te9476hzj rferringb@gmail.com-20080624174036-q45fk4fxguj9kjlv  
    1414    month 
    1515    """ 
    16      
     16 
    1717    __slots__ = ("category", "package", "version", "keywords", "period") 
    1818 
    1919    threshold = versioned_feed 
    20      
     20 
    2121    def __init__(self, pkg, keywords, period): 
    2222        Result.__init__(self) 
    … …  
    2929        return "no change in %i days for unstable keywords [ %s ]" % ( 
    3030            self.period, ', '.join(self.keywords)) 
    31      
     31 
    3232 
    3333class StaleUnstableReport(Template): 

  • pkgcore_checks/test/misc.py

    rferringb@gmail.com-20070522173125-afguloxkw2ic7664 rferringb@gmail.com-20080624174036-q45fk4fxguj9kjlv  
    2222        for x in ("DEPEND", "RDEPEND", "PDEPEND", "IUSE", "LICENSE"): 
    2323            data.setdefault(x, "") 
    24          
     24 
    2525        cpv = CPV(cpvstr) 
    2626        package.__init__(self, shared, parent, cpv.category, cpv.package, 
    … …  
    3131class FakeTimedPkg(package): 
    3232    __slots__ = "_mtime_" 
    33      
     33 
    3434    def __init__(self, cpvstr, mtime, data=None, shared=None, repo=None): 
    3535        if data is None: 
    … …  
    7373            self.assertTrue(attrs, msg="unknown threshold on %r" % (report.__class__,)) 
    7474            for x in attrs: 
    75                 self.assertTrue(hasattr(report, x), msg="threshold %s, missing attr %s: %r %s" %  
     75                self.assertTrue(hasattr(report, x), msg="threshold %s, missing attr %s: %r %s" % 
    7676                    (report.threshold, x, report.__class__, report)) 
    7777 
    … …  
    8181        check.feed(data, r) 
    8282        self.assert_known_results(*l) 
    83         self.assertTrue(l, msg="must get a report from %r %r, got none" %  
     83        self.assertTrue(l, msg="must get a report from %r %r, got none" % 
    8484            (check, data)) 
    8585        self.assertReportSanity(*l) 
    … …  
    8787 
    8888    def assertIsInstance(self, obj, kls): 
    89         self.assertTrue(isinstance(obj, kls),  
     89        self.assertTrue(isinstance(obj, kls), 
    9090            msg="%r must be %r" % (obj, kls)) 
    9191        return obj 
    … …  
    130130            [(AlwaysTrue, default_arches)], 
    131131            self.masked_use.iteritems()) 
    132              
     132 
    133133    def make_virtuals_repo(self, repo): 
    134134        return self.virtuals 

  • pkgcore_checks/test/test_addons.py

    rferringb@gmail.com-20070413063232-hw1qtxyy73lt5360 rferringb@gmail.com-20080624174036-q45fk4fxguj9kjlv  
    2626 
    2727    addon_kls = None 
    28      
     28 
    2929    def process_check(self, args, silence=False, preset_values={}, **settings): 
    3030        p = parser() 
    3131        self.addon_kls.mangle_option_parser(p) 
    3232        options, ret_args = p.parse_args(args) 
    33         self.assertFalse(ret_args, msg="%r args were left after processing %r" %  
     33        self.assertFalse(ret_args, msg="%r args were left after processing %r" % 
    3434            (ret_args, args)) 
    3535        orig_out, orig_err = None, None 
    … …  
    5959 
    6060    addon_kls = addons.ArchesAddon 
    61      
     61 
    6262    def test_opts(self): 
    6363        for arg in ('-a', '--arches'): 
    … …  
    7070 
    7171class TestQueryCacheAddon(base_test): 
    72      
     72 
    7373    addon_kls = addons.QueryCacheAddon 
    7474    default_feed = base.package_feed 
    … …  
    8484        self.process_check([], silence=True, 
    8585            query_caching_freq=self.default_feed) 
    86      
     86 
    8787    def test_feed(self): 
    8888        options = self.process_check([], silence=True) 
    … …  
    9696 
    9797class Test_profile_data(TestCase): 
    98      
     98 
    9999    def assertResults(self, profile, known_flags, required_immutable, 
    100100        required_forced, cpv="dev-util/diffball-0.1", key_override=None): 
    … …  
    109109        self.assertEqual(immutable, set(required_immutable)) 
    110110        self.assertEqual(enabled, set(required_forced)) 
    111      
     111 
    112112    def test_identify_use(self): 
    113113        profile = FakeProfile() 
    … …  
    191191        self.assertEqual(sorted(check.profile_evaluate_dict), ['x86', '~x86']) 
    192192        self.assertProfiles(check, 'x86', 'profile1', 'profile1/2') 
    193      
     193 
    194194    def test_profile_base(self): 
    195195        self.mk_profiles({"default-linux":["x86", True], 
    … …  
    203203            "default-linux/x86":["x86"]}, base='foo') 
    204204        options = self.process_check(['--profile-base', pjoin(self.dir, 'foo'), 
    205             '--profile-disable-dev'],  
     205            '--profile-disable-dev'], 
    206206            profile_ignore_dev=True) 
    207207        check = self.addon_kls(options) 
    … …  
    259259        self.assertEqual(len(l[0]), 2, msg="checking for proper # of profiles: " 
    260260            "%r" % l[0]) 
    261         self.assertEqual(sorted(x.name for x in l[0]),  
     261        self.assertEqual(sorted(x.name for x in l[0]), 
    262262            sorted(['default-linux', 'default-linux/x86'])) 
    263          
     263 
    264264        # check keyword collapsing 
    265265        l = check.identify_profiles(FakePkg("d-b/ab-2", data={'KEYWORDS':'ppc'})) 
    … …  
    273273        self.assertEqual(len(l), 0, msg="checking for profile collapsing: %r" % 
    274274            l) 
    275          
     275 
    276276 
    277277        # test collapsing reusing existing profile layout 
    … …  
    356356        # sorted(x.name for x in blah); reasoning is that it will catch 
    357357        # if duplicates come through, *and* ensure proper profile collapsing 
    358          
     358 
    359359        # shouldn't return anything due to no profiles matching the keywords. 
    360360        self.assertEqual(get_rets("0.0.1", "depends", KEYWORDS="foon"), []) 
    … …  
    384384 
    385385        self.assertEqual(set(str(l1[0]).split()), 
    386             set(['dev-util/confcache', 'dev-util/bar', 'dev-util/nobar',  
     386            set(['dev-util/confcache', 'dev-util/bar', 'dev-util/nobar', 
    387387                'x11-libs/xserver'])) 
    388388 
    389389        self.assertEqual(set(str(l2[0]).split()), 
    390             set(['dev-util/confcache', 'dev-util/foo', 'dev-util/bar',  
     390            set(['dev-util/confcache', 'dev-util/foo', 'dev-util/bar', 
    391391                'x11-libs/xserver'])) 
    392392 
    … …  
    400400 
    401401        check.feed(None, None) 
    402          
     402 
    403403        # ensure it handles arch right. 
    404404        l = get_rets("0", "depends", KEYWORDS="ppc x86") 
    … …  
    414414        self.assertEqual(sorted(x.name for x in l[0][1]), ['1', '2', '3'], 
    415415            msg="should have 3 profiles, got %r\nthis indicates it's " 
    416             "re-identifying profiles every invocation, which is unwarranted "  
     416            "re-identifying profiles every invocation, which is unwarranted " 
    417417            % l[0][1]) 
    418          
     418 
    419419        l = get_rets("1", "depends", KEYWORDS="ppc x86", 
    420420            DEPEND="ppc? ( dev-util/ppc ) !ppc? ( dev-util/x86 )") 
    … …  
    424424        l1 = [x[1] for x in l if str(x[0]).strip() == "dev-util/ppc"][0] 
    425425        l2 = [x[1] for x in l if str(x[0]).strip() == "dev-util/x86"][0] 
    426          
     426 
    427427        self.assertEqual(sorted(x.name for x in l1), ["3"]) 
    428428        self.assertEqual(sorted(x.name for x in l2), ["1", "2"]) 
    … …  
    432432 
    433433    addon_kls = addons.LicenseAddon 
    434      
     434 
    435435    def test_defaults(self): 
    436436        r1 = pjoin(self.dir, "repo1") 
    … …  
    459459 
    460460class TestUseAddon(mixins.TempDirMixin, base_test): 
    461      
     461 
    462462    addon_kls = addons.UseAddon 
    463463 

  • pkgcore_checks/test/test_cleanup.py

    rferringb@gmail.com-20070408202649-jgels0n569r8my90 rferringb@gmail.com-20080624174036-q45fk4fxguj9kjlv  
    1212        return misc.FakePkg("dev-util/diffball-%s" % ver, 
    1313            data={"KEYWORDS":' '.join(keywords), "SLOT":slot}) 
    14      
     14 
    1515    def test_it(self): 
    1616        # single version, shouldn't yield. 
    1717        check = redundant_ver(None, None) 
    1818        self.assertNoReport(check, [self.mk_pkg("0.7.1")]) 
    19         reports = self.assertReports(check,  
     19        reports = self.assertReports(check, 
    2020                [self.mk_pkg(x) for x in "0.7", "0.8", "0.9"]) 
    21         self.assertEqual([list(x.later_versions) for x in  reports],  
     21        self.assertEqual([list(x.later_versions) for x in  reports], 
    2222            [["0.9", "0.8"], ["0.9"]]) 
    23          
     23 
    2424        # check slots. 
    25         l = [self.mk_pkg("0.7"), self.mk_pkg("0.8", slot="1"),  
     25        l = [self.mk_pkg("0.7"), self.mk_pkg("0.8", slot="1"), 
    2626            self.mk_pkg("0.9")] 
    2727        reports = self.assertReports(check, l) 

  • pkgcore_checks/test/test_codingstyle.py

    rjokey@gentoo.org-20070609214646-diso84llm9pen9qh rferringb@gmail.com-20080624174036-q45fk4fxguj9kjlv  
    2929 
    3030        bad = ("/etc/env.d", "/etc/conf.d", "/etc/init.d", "/etc/pam.d", 
    31             "/usr/share/applications", "/usr/share/applications",  
     31            "/usr/share/applications", "/usr/share/applications", 
    3232            "//usr/share//applications", "/etc/cron.d", "/etc/cron.hourly", 
    3333            "/etc/cron.daily", "/etc/cron.weekly") 

  • pkgcore_checks/test/test_deprecated.py

    rferringb@gmail.com-20070211042219-nhmex9beszcf9ool rferringb@gmail.com-20080624174036-q45fk4fxguj9kjlv  
    1212        return misc.FakePkg("dev-util/diffball-%s" % ver, 
    1313            data={"_eclasses_":{}.fromkeys(eclasses)}) 
    14      
     14 
    1515    def test_it(self): 
    1616        # single version, shouldn't yield. 

  • pkgcore_checks/test/test_dropped_keywords.py

    rferringb@gmail.com-20070211042219-nhmex9beszcf9ool rferringb@gmail.com-20080624174036-q45fk4fxguj9kjlv  
    1717        check = drop_keys(misc.Options((("arches", ["x86", "amd64"]),))) 
    1818        self.assertNoReport(check, [self.mk_pkg('1')]) 
    19         reports = self.assertReports(check,  
     19        reports = self.assertReports(check, 
    2020            [self.mk_pkg("1", "x86 amd64"), self.mk_pkg("2")]) 
    2121        self.assertEqual(set(x.arch for x in reports), set(["x86", "amd64"])) 
    … …  
    2828                self.mk_pkg("2", "~amd64 x86"), 
    2929                self.mk_pkg("3", "-amd64 x86")]) 
    30          
     30 

  • pkgcore_checks/test/test_glsa.py

    rferringb@gmail.com-20070413063232-hw1qtxyy73lt5360 rferringb@gmail.com-20080624174036-q45fk4fxguj9kjlv  
    1818    def test_it(self): 
    1919        # single version, shouldn't yield. 
    20         check = vuln_report(misc.Options(glsa_location=self.dir,  
     20        check = vuln_report(misc.Options(glsa_location=self.dir, 
    2121            glsa_enabled=True)) 
    2222        open(pjoin(self.dir, "glsa-200611-01.xml"), "w").write( 

  • pkgcore_checks/test/test_imlate.py

    rferringb@gmail.com-20070211042219-nhmex9beszcf9ool rferringb@gmail.com-20080624174036-q45fk4fxguj9kjlv  
    1919            reference_arches=("x86", "ppc", "amd64"), 
    2020            target_arches=("x86", "ppc")),  None) 
    21          
     21 
    2222        self.assertNoReport(check, 
    2323            [mk_pkg(str(x), "~x86 ~amd64") for x in xrange(10)]) 
    … …  
    3333        # insert a 0.7 in; it should not show. 
    3434        # additionally, insert an arch we don't care about... 
    35          
     35 
    3636        report = self.assertReports(check, [mk_pkg("0.7", "~x86"), 
    3737            mk_pkg("0.8", "~x86 ~foo"), mk_pkg("0.9","~x86 amd64"), 

  • pkgcore_checks/test/test_metadata_checks.py

    rjokey@gentoo.org-20071230130147-ka247psyvw83tzqf rferringb@gmail.com-20080624174036-q45fk4fxguj9kjlv  
    4343 
    4444    check_kls = metadata_checks.KeywordsReport 
    45      
     45 
    4646    def mk_pkg(self, keywords=""): 
    4747        return misc.FakePkg("dev-util/diffball-0.7.1", 
    … …  
    6363        open(pjoin(repo_base, "profiles", "arch.list"), "w").write( 
    6464            "\n".join(kwds.pop("arches", ("x86", "ppc", "amd64")))) 
    65          
     65 
    6666        open(pjoin(repo_base, "profiles", "use.desc"), "w").write( 
    6767            "\n".join(kwds.pop("use_desc", ("foo", "bar")))) 
    6868 
    6969        open(pjoin(repo_base, "profiles", "use.local.desc"), "w").write( 
    70             "\n".join("dev-util/diffball:%s - blah" % x for x in  
     70            "\n".join("dev-util/diffball:%s - blah" % x for x in 
    7171                kwds.pop("use_local_desc", ("lfoo", "lbar")))) 
    72          
     72 
    7373        kwds["repo_bases"] = (repo_base,) 
    74         return misc.Options(**kwds)         
     74        return misc.Options(**kwds) 
    7575 
    7676 
    … …  
    220220                        set(os.path.basename(x) for x in src_uri.split()), 
    221221                        default_chksums) 
    222              
     222 
    223223            def _get_digests(self, pkg): 
    224224                return self.chksums 
    … …  
    242242        chk = self.mk_check() 
    243243        # ensure it pukes about RESTRICT!=fetch, and no uri 
    244          
     244 
    245245        r = self.assertIsInstance(self.assertReport(chk, 
    246246            self.mk_pkg("foon")), 
    … …  
    255255            self.assertNoReport(chk, self.mk_pkg("%s://dar.com/foon" % x), 
    256256                msg="testing valid proto %s" % x) 
    257          
     257 
    258258        # grab a proto, and mangle it. 
    259259        bad_proto = list(self.check_kls.valid_protos)[0] 
    260260        while bad_proto in self.check_kls.valid_protos: 
    261261            bad_proto += "s" 
    262          
     262 
    263263        r = self.assertIsInstance(self.assertReport(chk, 
    264264            self.mk_pkg("%s://foon.com/foon" % bad_proto)), 
    … …  
    267267        self.assertEqual(r.filename, 'foon'); 
    268268        self.assertEqual(list(r.bad_uri), ['%s://foon.com/foon' % bad_proto]) 
    269          
     269 
    270270        # check collapsing. 
    271271 
    272272        r = self.assertIsInstance(self.assertReport(chk, 
    273             self.mk_pkg("%s://foon.com/foon %s://dar.com/foon" %  
     273            self.mk_pkg("%s://foon.com/foon %s://dar.com/foon" % 
    274274                (bad_proto, bad_proto))), 
    275275            metadata_checks.BadProto) 

  • pkgcore_checks/test/test_stale_unstable.py

    rferringb@gmail.com-20080624173954-nab8ouii8xngsv25 rferringb@gmail.com-20080624174036-q45fk4fxguj9kjlv  
    2424        check.start() 
    2525 
    26         old = now - (30 * 24 * 3600)         
     26        old = now - (30 * 24 * 3600) 
    2727 
    2828        # a current one 
    … …  
    3939 
    4040        # ensure it reports only specified arches. 
    41         report = self.assertReport(check,  
     41        report = self.assertReport(check, 
    4242            mk_pkg("1.0", "~amd64 ~x86 ~asdfasdfasdf", old)) 
    4343        self.assertEqual(report.keywords, tuple(sorted(["~amd64", "~x86"]))) 

  • pkgcore_checks/unstable_only.py

    rferringb@gmail.com-20070207174621-yb3eqrqc6jtmdgse rferringb@gmail.com-20080624174036-q45fk4fxguj9kjlv  
    1212 
    1313    __slots__ = ("category", "package", "version", "arch") 
    14      
     14 
    1515    threshold = package_feed 
    1616 
    … …  
    2525        return "for arch %s, all versions are unstable: [ %s ]" % ( 
    2626            self.arch, ', '.join(self.version)) 
    27      
     27 
    2828 
    2929class UnstableOnlyReport(Template): 

  • pkgcore_checks/visibility.py

    rferringb@gmail.com-20070708170012-mwbfsn3oy4df1i22 rferringb@gmail.com-20080624174036-q45fk4fxguj9kjlv  
    2323        self.arch = arch.lstrip("~") 
    2424        self.profile = profile 
    25      
     25 
    2626    @property 
    2727    def short_desc(self): 
    … …  
    3636 
    3737    threshold = base.versioned_feed 
    38      
     38 
    3939    def __init__(self, pkg, attr, nonexistant_atoms): 
    4040        base.Result.__init__(self) 
    … …  
    4242        self.attr = attr 
    4343        self.atoms = tuple(str(x) for x in nonexistant_atoms) 
    44      
     44 
    4545    @property 
    4646    def short_desc(self): 
    4747        return "depset %s: nonexistant atoms [ %s ]" % ( 
    4848            self.attr, ', '.join(self.atoms)) 
    49      
     49 
    5050 
    5151class NonsolvableDeps(base.Result): 
    … …  
    5656 
    5757    threshold = base.versioned_feed 
    58      
     58 
    5959    def __init__(self, pkg, attr, keyword, profile, horked): 
    6060        base.Result.__init__(self) 
    … …  
    6464        self.keyword = keyword 
    6565        self.potentials = tuple(str(x) for x in stable_unique(horked)) 
    66          
     66 
    6767    @property 
    6868    def short_desc(self): 
Note: See TracChangeset for help on using the changeset viewer.