# Distributed under the terms of the GNU General Public License v2
# $Id$
+import codecs
import os, re, sys
here_doc_re = re.compile(r'.*\s<<[-]?(\w+)$')
parser.error("Missing required PATTERN argument.")
file_in = sys.stdin
file_out = sys.stdout
+ if sys.hexversion >= 0x3000000:
+ file_in = codecs.iterdecode(sys.stdin.buffer.raw,
+ 'utf_8', errors='replace')
+ import io
+ file_out = io.TextIOWrapper(sys.stdout.buffer,
+ 'utf_8', errors='backslashreplace')
+
var_pattern = args[0].split()
# Filter invalid variable names that are not supported by bash.
return 0
continue
for d in dirs:
+ try:
+ d = _unicode_decode(d,
+ encoding=_encodings['fs'], errors='strict')
+ except UnicodeDecodeError:
+ d = _unicode_decode(d,
+ encoding=_encodings['fs'], errors='replace')
+ writemsg(_("!!! Path contains invalid "
+ "character(s) for encoding '%s': '%s'") \
+ % (_encodings['fs'], os.path.join(parent, d)),
+ noiselevel=-1)
+ if strict:
+ return 0
+ dirs.remove(d)
+ continue
if d.startswith(".") or d == "CVS":
dirs.remove(d)
for f in files:
m = _cpv_key_re.match(mycpv)
if m is not None:
return m.group(2)
+
+ warnings.warn("portage.cpv_getkey() called with invalid cpv: '%s'" \
+ % (mycpv,), DeprecationWarning)
+
myslash = mycpv.split("/", 1)
mysplit=pkgsplit(myslash[-1])
if mysplit is None:
import errno
import stat
import sys
+import os as _os
from portage import os
from portage import _encodings
from portage import _unicode_encode
self._ensure_dirs()
def _getitem(self, cpv):
- fp = os.path.join(self.location, cpv)
+ # Don't use os.path.join, for better performance.
+ fp = self.location + _os.sep + cpv
try:
myf = codecs.open(_unicode_encode(fp,
encoding=_encodings['fs'], errors='strict'),
mode='r', encoding=_encodings['repo.content'],
errors='replace')
try:
- d = self._parse_data(myf.readlines(), cpv)
+ d = self._parse_data(myf.read().split("\n"), cpv)
if '_mtime_' not in d:
# Backward compatibility with old cache
# that uses mtime mangling.
- d['_mtime_'] = long(os.fstat(myf.fileno()).st_mtime)
+ d['_mtime_'] = long(_os.fstat(myf.fileno()).st_mtime)
return d
finally:
myf.close()
except (IOError, OSError) as e:
if e.errno != errno.ENOENT:
raise cache_errors.CacheCorruption(cpv, e)
- raise KeyError(cpv)
+ raise KeyError(cpv, e)
def _parse_data(self, data, cpv):
try:
- d = dict(map(lambda x:x.rstrip("\n").split("=", 1), data))
+ return dict( x.split("=", 1) for x in data )
except ValueError as e:
# If a line is missing an "=", the split length is 1 instead of 2.
raise cache_errors.CacheCorruption(cpv, e)
- return d
def _setitem(self, cpv, values):
# import pdb;pdb.set_trace()
os.remove(fp)
raise cache_errors.CacheCorruption(cpv, e)
-
def _delitem(self, cpv):
# import pdb;pdb.set_trace()
try:
else:
raise cache_errors.CacheCorruption(cpv, e)
-
def __contains__(self, cpv):
return os.path.exists(os.path.join(self.location, cpv))
-
def __iter__(self):
"""generator for walking the dir struct"""
dirs = [self.location]
continue
yield p[len_base+1:]
dirs.pop(0)
-
d.clear()
try:
for i, key in enumerate(self.auxdbkey_order):
- d[key] = data[i].rstrip("\n")
+ d[key] = data[i]
except IndexError:
pass
break
"PDEPEND", "PROPERTIES", "PROVIDE", "RDEPEND", "repository",
"RESTRICT", "SLOT"])
- # Repoman modifies _aux_cache_keys, so delay _aux_cache_slot_dict
- # initialization until the first aux_get call.
- self._aux_cache_slot_dict = None
self._aux_cache = {}
self._broken_ebuilds = set()
return metadata
def _pull_valid_cache(self, cpv, ebuild_path, repo_path):
-
try:
- st = os.stat(ebuild_path)
+ # Don't use unicode-wrapped os module, for better performance.
+ st = _os.stat(_unicode_encode(ebuild_path,
+ encoding=_encodings['fs'], errors='strict'))
emtime = st[stat.ST_MTIME]
except OSError:
writemsg(_("!!! aux_get(): ebuild for " \
mydata["_eclasses_"] = {}
# do we have a origin repository name for the current package
- mydata["repository"] = self._repository_map.get(
- os.path.sep.join(myebuild.split(os.path.sep)[:-3]), "")
+ mydata["repository"] = self._repository_map.get(mylocation, "")
mydata["INHERITED"] = ' '.join(mydata.get("_eclasses_", []))
mydata["_mtime_"] = long(st.st_mtime)
returnme = [mydata.get(x, "") for x in mylist]
if cache_me:
- if self._aux_cache_slot_dict is None:
- self._aux_cache_slot_dict = \
- slot_dict_class(self._aux_cache_keys)
- aux_cache = self._aux_cache_slot_dict()
+ aux_cache = {}
for x in self._aux_cache_keys:
aux_cache[x] = mydata.get(x, "")
self._aux_cache[mycpv] = aux_cache
False, ["a"], False ),
( [ { "a":"b" }, None ], { "a":"b" },
False, [], True ),
- ( [ None ], None, False, [], False ),
+ ( [ None ], {}, False, [], False ),
( [ None, {}], {}, False, [], True ) ]
projects / portage.git / commitdiff