def node(self, data, tags):
capture_tags = {}
keys = tags.keys()
err = []
# *[name=~/ي/][language("fa")]
# *[name:fa=~/ي/]
if (u'name' in keys) or (u'name:fa' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_5eeade1c), mapcss._tag_capture(capture_tags, 0, tags, u'name')) and mapcss.language(self.father.config.options, u'fa'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_5eeade1c), mapcss._tag_capture(capture_tags, 0, tags, u'name:fa')))
except mapcss.RuleAbort: pass
if match:
# group:tr("Arabic letter detected in Farsi name")
# -osmoseItemClassLevel:"5010/50109001/2"
# throwError:tr("In Farsi, the Arabic letter '{0}' should be replaced by '{1}'","ي","ی")
# fixAdd:concat("{0.key}=",replace("{0.value}","ي","ی"))
# assertMatchWithContext:list('node name="روابط عمومي مجتمع مس شهربابك"','language=fa')
# assertMatch:'node name:fa="روابط عمومي مجتمع مس شهربابك"'
# assertNoMatch:'node name="روابط عمومي مجتمع مس شهربابك"'
err.append({'class': 50109001, 'subclass': 0, 'text': mapcss.tr(u'In Farsi, the Arabic letter \'{0}\' should be replaced by \'{1}\'', u'ي', u'ی'), 'allow_fix_override': True, 'fix': {
'+': dict([
(mapcss.concat(mapcss._tag_uncapture(capture_tags, u'{0.key}='), mapcss.replace(mapcss._tag_uncapture(capture_tags, u'{0.value}'), u'ي', u'ی'))).split('=', 1)])
}})
# *[name=~/ك/][language("fa")]
# *[name:fa=~/ك/]
if (u'name' in keys) or (u'name:fa' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_4234bf3b), mapcss._tag_capture(capture_tags, 0, tags, u'name')) and mapcss.language(self.father.config.options, u'fa'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_4234bf3b), mapcss._tag_capture(capture_tags, 0, tags, u'name:fa')))
except mapcss.RuleAbort: pass
if match:
# group:tr("Arabic letter detected in Farsi name")
# -osmoseItemClassLevel:"5010/50109001/2"
# throwError:tr("In Farsi, the Arabic letter '{0}' should be replaced by '{1}'","ك","ک")
# fixAdd:concat("{0.key}=",replace("{0.value}","ك","ک"))
# assertMatchWithContext:list('node name="روابط عمومي مجتمع مس شهربابك"','language=fa')
# assertMatch:'node name:fa="روابط عمومي مجتمع مس شهربابك"'
# assertNoMatch:'node name="روابط عمومي مجتمع مس شهربابك"'
err.append({'class': 50109001, 'subclass': 0, 'text': mapcss.tr(u'In Farsi, the Arabic letter \'{0}\' should be replaced by \'{1}\'', u'ك', u'ک'), 'allow_fix_override': True, 'fix': {
'+': dict([
(mapcss.concat(mapcss._tag_uncapture(capture_tags, u'{0.key}='), mapcss.replace(mapcss._tag_uncapture(capture_tags, u'{0.value}'), u'ك', u'ک'))).split('=', 1)])
}})
return err
def way(self, data, tags, nds):
capture_tags = {}
keys = tags.keys()
err = []
# *[operator=ERDF][inside("FR")]
if (u'operator' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'operator') == mapcss._value_capture(capture_tags, 0, u'ERDF') and mapcss.inside(self.father.config.options, u'FR'))
except mapcss.RuleAbort: pass
if match:
# group:tr("deprecated tagging")
# throwWarning:tr("{0} is deprecated","{0.tag}")
# suggestAlternative:"operator=Enedis"
# fixAdd:"operator=Enedis"
err.append({'class': 9009001, 'subclass': 262422756, 'text': mapcss.tr(u'{0} is deprecated', mapcss._tag_uncapture(capture_tags, u'{0.tag}')), 'allow_fix_override': True, 'fix': {
'+': dict([
[u'operator',u'Enedis']])
}})
# *[addr:street=~/(?i).*Strasse.*/][addr:street!~/(?i).*Strasser.*/][inside("DE,AT")]
# *[name=~/(?i).*Strasse.*/][name!~/(?i).*Strasser.*/][inside("DE,AT")]
if (u'addr:street' in keys) or (u'name' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_5b84a257), mapcss._tag_capture(capture_tags, 0, tags, u'addr:street')) and not mapcss.regexp_test_(mapcss._value_capture(capture_tags, 1, self.re_559797c8), mapcss._tag_capture(capture_tags, 1, tags, u'addr:street')) and mapcss.inside(self.father.config.options, u'DE,AT'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_5b84a257), mapcss._tag_capture(capture_tags, 0, tags, u'name')) and not mapcss.regexp_test_(mapcss._value_capture(capture_tags, 1, self.re_559797c8), mapcss._tag_capture(capture_tags, 1, tags, u'name')) and mapcss.inside(self.father.config.options, u'DE,AT'))
except mapcss.RuleAbort: pass
if match:
# throwError:tr("street name contains ss")
err.append({'class': 9009002, 'subclass': 821908491, 'text': mapcss.tr(u'street name contains ss')})
# *[addr:street=~/(?i).*Straße.*/][inside("LI,CH")]
# *[name=~/(?i).*Straße.*/][inside("LI,CH")]
if (u'addr:street' in keys) or (u'name' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_3d3faeb5), mapcss._tag_capture(capture_tags, 0, tags, u'addr:street')) and mapcss.inside(self.father.config.options, u'LI,CH'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_3d3faeb5), mapcss._tag_capture(capture_tags, 0, tags, u'name')) and mapcss.inside(self.father.config.options, u'LI,CH'))
except mapcss.RuleAbort: pass
if match:
# throwError:tr("street name contains ß")
err.append({'class': 9009003, 'subclass': 610086334, 'text': mapcss.tr(u'street name contains ß')})
return err
def node(self, data, tags):
capture_tags = {}
keys = tags.keys()
err = []
# node[place=locality][name=~/.+([Nn]ord|[Ss]ud$|[Ee]st|[Oo]uest|[Cc]entre)$/][inside("FR")]
# node[place=hamlet][name=~/.+([Nn]ord|[Ss]ud$|[Ee]st|[Oo]uest|[Cc]entre)$/][inside("FR")]
if (u'name' in keys and u'place' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (
mapcss._tag_capture(capture_tags, 0, tags, u'place')
== mapcss._value_capture(capture_tags, 0, u'locality')
and mapcss.regexp_test_(
mapcss._value_capture(capture_tags, 1,
self.re_422a87ff),
mapcss._tag_capture(capture_tags, 1, tags,
u'name'))
and mapcss.inside(self.father.config.options, u'FR'))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (
mapcss._tag_capture(capture_tags, 0, tags, u'place')
== mapcss._value_capture(capture_tags, 0, u'hamlet')
and mapcss.regexp_test_(
mapcss._value_capture(capture_tags, 1,
self.re_422a87ff),
mapcss._tag_capture(capture_tags, 1, tags,
u'name'))
and mapcss.inside(self.father.config.options, u'FR'))
except mapcss.RuleAbort:
pass
if match:
# -osmoseItemClassLevel:"5080/50801/1"
# throwError:tr("Hamlet or Locality name suffix Nord, Sud, Est, Ouest, Centre should be removed from Cadastre name. Place should be integrated only once.")
# assertNoMatchWithContext:list('node place=hamlet name="ZA Sud Loire"',"inside=FR")
# assertMatchWithContext:list('node place=hamlet name=Montdésert-Sud',"inside=FR")
err.append({
'class':
50801,
'subclass':
0,
'text':
mapcss.
tr(u'Hamlet or Locality name suffix Nord, Sud, Est, Ouest, Centre should be removed from Cadastre name. Place should be integrated only once.'
)
})
return err
def relation(self, data, tags, *args):
capture_tags = {}
keys = tags.keys()
err = []
# *[addr:housenumber][addr:housenumber!~/^((?:вл)?[0-9]+[А-Я]?(?:\/[0-9]+[А-Я]?)?(?: к[0-9А-Я]+)?(?: с[0-9А-Я]+)?(?: соор[0-9А-Я]+)?(?: лит[0-9А-Я]+)?(?: фл[0-9А-Я]+)?|[0-9]+-[0-9]+|[0-9]+[А-Я]?[\/-][0-9]+[А-Я]?[\/-][0-9]+[А-Я]?|(([0-9]+[А-Я]?[IXV]*)|[IXV]*)[\/-]([0-9]+[А-Я]?|[IXV]*)|ЗЯБ-[0-9]+|С-([0-9]+[А-Я]?(?:\/[0-9]+[А-Я]?)?|[IXV]*)|к[0-9А-Я]+)$/]
if u'addr:housenumber' in keys:
match = False
try:
match = match or ((mapcss._tag_capture(
capture_tags, 0, tags,
u'addr:housenumber') and not mapcss.regexp_test_(
mapcss._value_capture(capture_tags, 1,
self.re_62d22c1b),
mapcss._tag_capture(capture_tags, 1, tags,
u'addr:housenumber'))))
except mapcss.RuleAbort:
pass
if match:
# throwWarning:tr("Номера домов не соответствующие принятому соглашению")
err.append({
'class':
9017001,
'subclass':
774061168,
'text':
mapcss.
tr(u'Номера домов не соответствующие принятому соглашению',
capture_tags)
})
return err
def way(self, data, tags, *args):
capture_tags = {}
keys = tags.keys()
err = []
# way[place=locality][name=~/.+([Nn]ord|[Ss]ud$|[Ee]st|[Oo]uest|[Cc]entre)$/][inside("FR")]
# way[place=hamlet][name=~/.+([Nn]ord|[Ss]ud$|[Ee]st|[Oo]uest|[Cc]entre)$/][inside("FR")]
if u'place' in keys:
match = False
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'place')
== mapcss._value_capture(capture_tags, 0, u'locality')
and mapcss.regexp_test_(
mapcss._value_capture(capture_tags, 1,
self.re_422a87ff),
mapcss._tag_capture(capture_tags, 1, tags, u'name'))
and mapcss.inside(self.father.config.options, u'FR')))
except mapcss.RuleAbort:
pass
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'place')
== mapcss._value_capture(capture_tags, 0, u'hamlet')
and mapcss.regexp_test_(
mapcss._value_capture(capture_tags, 1,
self.re_422a87ff),
mapcss._tag_capture(capture_tags, 1, tags, u'name'))
and mapcss.inside(self.father.config.options, u'FR')))
except mapcss.RuleAbort:
pass
if match:
# osmoseTags:list("name")
# osmoseItemClassLevel:"5080/50801/1"
# throwError:tr("Hamlet or Locality name suffix Nord, Sud, Est, Ouest, Centre should be removed from Cadastre name. Place should be integrated only once.")
err.append({
'class':
50801,
'subclass':
0,
'text':
mapcss.tr(
u'Hamlet or Locality name suffix Nord, Sud, Est, Ouest, Centre should be removed from Cadastre name. Place should be integrated only once.',
capture_tags)
})
return err
def node(self, data, tags, *args):
capture_tags = {}
keys = tags.keys()
err = []
set_fixable_footway = set_link_road = set_major_road = set_minor_road = set_not_fixable_footway = False
# node[highway=~/motorway|trunk|primary|secondary|tertiary|unclassified|residential|service|living_street|pedestrian|track|path|footway|cycleway|bus_guideway|bridleway/][highway!=motorway_junction][highway!=services]
if u'highway' in keys:
match = False
try:
match = match or (
(mapcss.regexp_test_(
mapcss._value_capture(capture_tags, 0,
self.re_3dc5dd7c),
mapcss._tag_capture(capture_tags, 0, tags, u'highway'))
and mapcss._tag_capture(capture_tags, 1, tags, u'highway')
!= mapcss._value_capture(capture_tags, 1,
u'motorway_junction')
and mapcss._tag_capture(capture_tags, 2, tags, u'highway')
!= mapcss._value_capture(capture_tags, 2, u'services')))
except mapcss.RuleAbort:
pass
if match:
# throwWarning:tr("wrong highway tag on a node")
# assertNoMatch:"node highway=bus_stop"
# assertNoMatch:"node highway=crossing"
# assertNoMatch:"node highway=emergency_access_point"
# assertNoMatch:"node highway=give_way"
# assertNoMatch:"node highway=mini_roundabout"
# assertNoMatch:"node highway=motorway_junction"
# assertNoMatch:"node highway=passing_place"
# assertMatch:"node highway=primary"
# assertMatch:"node highway=primary_link"
# assertNoMatch:"node highway=rest_area"
# assertNoMatch:"node highway=services"
# assertNoMatch:"node highway=speed_camera"
# assertNoMatch:"node highway=stop"
# assertNoMatch:"node highway=street_lamp"
# assertNoMatch:"node highway=traffic_calming"
# assertNoMatch:"node highway=traffic_signals"
# assertNoMatch:"node highway=turning_circle"
err.append({
'class':
9004008,
'subclass':
325492196,
'text':
mapcss.tr(u'wrong highway tag on a node', capture_tags)
})
# node[railway!=crossing].is_in_railway.is_in_minor_road!.is_in_major_road
# Use undeclared class is_in_major_road, is_in_minor_road, is_in_railway
# node[railway!=level_crossing].is_in_railway.is_in_major_road!.is_in_minor_road
# Use undeclared class is_in_major_road, is_in_minor_road, is_in_railway
return err
def way(self, data, tags, *args):
capture_tags = {}
keys = tags.keys()
err = []
set_fixable_footway = set_link_road = set_major_road = set_minor_road = set_not_fixable_footway = False
# way[highway=~/^(motorway|trunk|primary|secondary|tertiary)$/]
if u'highway' in keys:
match = False
try:
match = match or ((mapcss.regexp_test_(
mapcss._value_capture(capture_tags, 0, self.re_55ee32ac),
mapcss._tag_capture(capture_tags, 0, tags, u'highway'))))
except mapcss.RuleAbort:
pass
if match:
# setmajor_road
set_major_road = True
# way[highway=~/^.*_link$/]
if u'highway' in keys:
match = False
try:
match = match or ((mapcss.regexp_test_(
mapcss._value_capture(capture_tags, 0, self.re_3092b7ac),
mapcss._tag_capture(capture_tags, 0, tags, u'highway'))))
except mapcss.RuleAbort:
pass
if match:
# setlink_road
set_link_road = True
# way[highway=~/^(unclassified|residential|living_street|service)$/]
if u'highway' in keys:
match = False
try:
match = match or ((mapcss.regexp_test_(
mapcss._value_capture(capture_tags, 0, self.re_015aabd5),
mapcss._tag_capture(capture_tags, 0, tags, u'highway'))))
except mapcss.RuleAbort:
pass
if match:
# setminor_road
set_minor_road = True
# way[highway][name=~/(?i).* (Ave|Blvd|Br|Brg|Cct|Cir|Cl|Cr|Crct|Cres|Crt|Ct|Dr|Drv|Esp|Espl|Hwy|Ln|Mw|Mwy|Pky|Pkwy|Pl|Rd|Qy|Qys|Sq|St|Str|Ter|Tce|Tr|Wy)[.]?$/]
if u'highway' in keys:
match = False
try:
match = match or ((mapcss._tag_capture(
capture_tags, 0, tags, u'highway') and mapcss.regexp_test_(
mapcss._value_capture(capture_tags, 1,
self.re_776f2c1a),
mapcss._tag_capture(capture_tags, 1, tags, u'name'))))
except mapcss.RuleAbort:
pass
if match:
# throwWarning:tr("abbreviated street name")
# assertMatch:"way highway=unclassified name=\"Bou Blvd.\""
# assertMatch:"way highway=unclassified name=\"Bou blvd.\""
# assertMatch:"way highway=unclassified name=\"Foo Ave\""
# assertMatch:"way highway=unclassified name=\"Foo Ave.\""
err.append({
'class':
9004001,
'subclass':
544432044,
'text':
mapcss.tr(u'abbreviated street name', capture_tags)
})
# way[highway=crossing]
# way[railway=crossing]
# way[railway=level_crossing]
if u'highway' in keys or u'railway' in keys:
match = False
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'highway')
== mapcss._value_capture(capture_tags, 0, u'crossing')))
except mapcss.RuleAbort:
pass
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'railway')
== mapcss._value_capture(capture_tags, 0, u'crossing')))
except mapcss.RuleAbort:
pass
try:
match = match or ((mapcss._tag_capture(capture_tags, 0, tags,
u'railway')
== mapcss._value_capture(
capture_tags, 0, u'level_crossing')))
except mapcss.RuleAbort:
pass
if match:
# throwWarning:tr("wrong crossing tag on a way")
# assertMatch:"way highway=crossing"
err.append({
'class':
9004002,
'subclass':
1549110307,
'text':
mapcss.tr(u'wrong crossing tag on a way', capture_tags)
})
# way[highway=road]
if u'highway' in keys:
match = False
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'highway')
== mapcss._value_capture(capture_tags, 0, u'road')))
except mapcss.RuleAbort:
pass
if match:
# throwWarning:tr("Unspecific highway type")
# assertNoMatch:"way highway=residential"
# assertMatch:"way highway=road"
err.append({
'class':
9004004,
'subclass':
1856552890,
'text':
mapcss.tr(u'Unspecific highway type', capture_tags)
})
# way[highway=footway][maxspeed]
# way[highway=steps][maxspeed]
# way[highway=cycleway][bicycle=no]
# way[highway=footway][foot=no]
# way[highway=cycleway][cycleway=lane]
if u'highway' in keys:
match = False
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'highway')
== mapcss._value_capture(capture_tags, 0, u'footway') and
mapcss._tag_capture(capture_tags, 1, tags, u'maxspeed')))
except mapcss.RuleAbort:
pass
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'highway')
== mapcss._value_capture(capture_tags, 0, u'steps') and
mapcss._tag_capture(capture_tags, 1, tags, u'maxspeed')))
except mapcss.RuleAbort:
pass
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'highway')
== mapcss._value_capture(capture_tags, 0, u'cycleway')
and mapcss._tag_capture(capture_tags, 1, tags, u'bicycle')
== mapcss._value_capture(capture_tags, 1, u'no')))
except mapcss.RuleAbort:
pass
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'highway')
== mapcss._value_capture(capture_tags, 0, u'footway')
and mapcss._tag_capture(capture_tags, 1, tags, u'foot')
== mapcss._value_capture(capture_tags, 1, u'no')))
except mapcss.RuleAbort:
pass
try:
match = match or ((
mapcss._tag_capture(capture_tags, 0, tags, u'highway')
== mapcss._value_capture(capture_tags, 0, u'cycleway')
and mapcss._tag_capture(capture_tags, 1, tags, u'cycleway')
== mapcss._value_capture(capture_tags, 1, u'lane')))
except mapcss.RuleAbort:
pass
if match:
# throwWarning:tr("{0} used with {1}","{0.value}","{1.tag}")
# assertNoMatch:"way highway=cycleway bicycle=yes"
# assertMatch:"way highway=cycleway cycleway=lane"
# assertNoMatch:"way highway=cycleway"
# assertNoMatch:"way highway=cycleway"
# assertNoMatch:"way highway=footway foot=yes"
# assertMatch:"way highway=footway maxspeed=20"
# assertNoMatch:"way highway=footway"
# assertNoMatch:"way highway=footway"
# assertNoMatch:"way highway=residential cycleway=lane"
# assertNoMatch:"way highway=residential maxspeed=20"
err.append({
'class':
9004005,
'subclass':
469607562,
'text':
mapcss.tr(u'{0} used with {1}', capture_tags, u'{0.value}',
u'{1.tag}')
})
# way[footway=left][/^footway:/]
# way[footway=right][/^footway:/]
# way[footway=both][/^footway:/]
# way[footway=no][/^footway:/]
if u'footway' in keys:
match = False
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'footway')
== mapcss._value_capture(capture_tags, 0, u'left')
and mapcss._tag_capture(capture_tags, 1, tags,
self.re_4dcdb354)))
except mapcss.RuleAbort:
pass
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'footway')
== mapcss._value_capture(capture_tags, 0, u'right')
and mapcss._tag_capture(capture_tags, 1, tags,
self.re_4dcdb354)))
except mapcss.RuleAbort:
pass
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'footway')
== mapcss._value_capture(capture_tags, 0, u'both')
and mapcss._tag_capture(capture_tags, 1, tags,
self.re_4dcdb354)))
except mapcss.RuleAbort:
pass
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'footway')
== mapcss._value_capture(capture_tags, 0, u'no')
and mapcss._tag_capture(capture_tags, 1, tags,
self.re_4dcdb354)))
except mapcss.RuleAbort:
pass
if match:
# setnot_fixable_footway
# group:tr("deprecated tagging")
# throwWarning:tr("{0} is deprecated, use {1} instead. Also check similar tags like {2}","{0.tag}","sidewalk","{1.key}")
# assertMatch:"way footway=both footway:surface=asphalt"
set_not_fixable_footway = True
err.append({
'class':
9004006,
'subclass':
141262069,
'text':
mapcss.tr(
u'{0} is deprecated, use {1} instead. Also check similar tags like {2}',
capture_tags, u'{0.tag}', u'sidewalk', u'{1.key}')
})
# way[footway=none][/footway:/]
if u'footway' in keys:
match = False
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'footway')
== mapcss._value_capture(capture_tags, 0, u'none')
and mapcss._tag_capture(capture_tags, 1, tags,
self.re_61bbe299)))
except mapcss.RuleAbort:
pass
if match:
# setnot_fixable_footway
# group:tr("deprecated tagging")
# throwWarning:tr("{0} is deprecated, use {1} instead. Also check similar tags like {2}","{0.tag}","sidewalk=no","{1.key}")
set_not_fixable_footway = True
err.append({
'class':
9004006,
'subclass':
1570348899,
'text':
mapcss.tr(
u'{0} is deprecated, use {1} instead. Also check similar tags like {2}',
capture_tags, u'{0.tag}', u'sidewalk=no', u'{1.key}')
})
# way[footway=left]!.not_fixable_footway
# way[footway=right]!.not_fixable_footway
# way[footway=both]!.not_fixable_footway
# way[footway=no]!.not_fixable_footway
if u'footway' in keys:
match = False
try:
match = match or (
(not set_not_fixable_footway
and mapcss._tag_capture(capture_tags, 0, tags, u'footway')
== mapcss._value_capture(capture_tags, 0, u'left')))
except mapcss.RuleAbort:
pass
try:
match = match or (
(not set_not_fixable_footway
and mapcss._tag_capture(capture_tags, 0, tags, u'footway')
== mapcss._value_capture(capture_tags, 0, u'right')))
except mapcss.RuleAbort:
pass
try:
match = match or (
(not set_not_fixable_footway
and mapcss._tag_capture(capture_tags, 0, tags, u'footway')
== mapcss._value_capture(capture_tags, 0, u'both')))
except mapcss.RuleAbort:
pass
try:
match = match or (
(not set_not_fixable_footway
and mapcss._tag_capture(capture_tags, 0, tags, u'footway')
== mapcss._value_capture(capture_tags, 0, u'no')))
except mapcss.RuleAbort:
pass
if match:
# setfixable_footway
# group:tr("deprecated tagging")
# throwWarning:tr("{0} is deprecated","{0.tag}")
# suggestAlternative:"sidewalk"
# fixChangeKey:"footway => sidewalk"
set_fixable_footway = True
err.append({
'class':
9004006,
'subclass':
2076937761,
'text':
mapcss.tr(u'{0} is deprecated', capture_tags, u'{0.tag}'),
'fix': {
'+': dict([[u'sidewalk',
mapcss.tag(tags, u'footway')]]),
'-': ([u'footway'])
}
})
# way[footway=none]!.not_fixable_footway
if u'footway' in keys:
match = False
try:
match = match or (
(not set_not_fixable_footway
and mapcss._tag_capture(capture_tags, 0, tags, u'footway')
== mapcss._value_capture(capture_tags, 0, u'none')))
except mapcss.RuleAbort:
pass
if match:
# setfixable_footway
# group:tr("deprecated tagging")
# throwWarning:tr("{0} is deprecated","{0.tag}")
# suggestAlternative:"sidewalk=no"
# fixRemove:"footway"
# fixAdd:"sidewalk=no"
set_fixable_footway = True
err.append({
'class':
9004006,
'subclass':
430589555,
'text':
mapcss.tr(u'{0} is deprecated', capture_tags, u'{0.tag}'),
'fix': {
'+': dict([[u'sidewalk', u'no']]),
'-': ([u'footway'])
}
})
# way[footway][footway!=sidewalk][footway!=crossing]!.fixable_footway!.not_fixable_footway
if u'footway' in keys:
match = False
try:
match = match or (
(not set_fixable_footway and not set_not_fixable_footway
and mapcss._tag_capture(capture_tags, 0, tags, u'footway')
and mapcss._tag_capture(capture_tags, 1, tags, u'footway')
!= mapcss._value_capture(capture_tags, 1, u'sidewalk')
and mapcss._tag_capture(capture_tags, 2, tags, u'footway')
!= mapcss._value_capture(capture_tags, 2, u'crossing')))
except mapcss.RuleAbort:
pass
if match:
# throwWarning:tr("Value of ''{0}'' should either be ''{1}'' or ''{2}''. For sidewalks use ''{3}'' instead.","{0.key}","{1.value}","{2.value}","sidewalk=left|right|both|no")
# assertMatch:"way footway=bar"
# assertNoMatch:"way footway=left footway:left:surface=asphalt"
# assertNoMatch:"way footway=left"
# assertNoMatch:"way footway=none"
err.append({
'class':
9004007,
'subclass':
156640320,
'text':
mapcss.tr(
u'Value of \'\'{0}\'\' should either be \'\'{1}\'\' or \'\'{2}\'\'. For sidewalks use \'\'{3}\'\' instead.',
capture_tags, u'{0.key}', u'{1.value}', u'{2.value}',
u'sidewalk=left|right|both|no')
})
return err
def way(self, data, tags, *args):
capture_tags = {}
keys = tags.keys()
err = []
# way[cycleway][cycleway:right][cycleway:left]
if u'cycleway' in keys:
match = False
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'cycleway')
and mapcss._tag_capture(capture_tags, 1, tags,
u'cycleway:right')
and mapcss._tag_capture(capture_tags, 2, tags,
u'cycleway:left')))
except mapcss.RuleAbort:
pass
if match:
# osmoseTags:list("tag","highway","cycleway")
# osmoseItemClassLevel:"4030/40301/2"
# throwWarning:tr("{0} with {1} and {2}","{0.key}","{1.key}","{2.key}")
# assertMatch:"way cycleway=a cycleway:right=b cycleway:left=c"
err.append({
'class':
40301,
'subclass':
0,
'text':
mapcss.tr(u'{0} with {1} and {2}', capture_tags,
u'{0.key}', u'{1.key}', u'{2.key}')
})
# way[footway=sidewalk][highway!~/footway|construction/]
if u'footway' in keys:
match = False
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'footway')
== mapcss._value_capture(capture_tags, 0, u'sidewalk')
and not mapcss.regexp_test_(
mapcss._value_capture(capture_tags, 1,
self.re_1825c777),
mapcss._tag_capture(capture_tags, 1, tags,
u'highway'))))
except mapcss.RuleAbort:
pass
if match:
# osmoseTags:list("tag","highway","footway")
# osmoseItemClassLevel:"2080/20805/3"
# throwWarning:tr("{0} without {1}","{0.tag}","highway=footway|construction")
# assertNoMatch:"way footway=sidewalk highway=construction construction=footway"
# assertNoMatch:"way footway=sidewalk highway=footway"
# assertMatch:"way footway=sidewalk highway=path"
err.append({
'class':
20805,
'subclass':
0,
'text':
mapcss.tr(u'{0} without {1}', capture_tags, u'{0.tag}',
u'highway=footway|construction')
})
# way[highway=service][service=psv][psv!=yes]
if u'highway' in keys:
match = False
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'highway')
== mapcss._value_capture(capture_tags, 0, u'service')
and mapcss._tag_capture(capture_tags, 1, tags, u'service')
== mapcss._value_capture(capture_tags, 1, u'psv')
and mapcss._tag_capture(capture_tags, 2, tags, u'psv') !=
mapcss._value_capture(capture_tags, 2, u'yes')))
except mapcss.RuleAbort:
pass
if match:
# osmoseTags:list("tag","highway")
# osmoseItemClassLevel:"4010/40101/2"
# throwWarning:tr("{0} is preferred to {1}","{2.tag}","{1.tag}")
# fixAdd:"psv=yes"
# fixRemove:"service"
# assertMatch:"way highway=service service=psv psv=no"
# assertNoMatch:"way highway=service service=psv psv=yes"
err.append({
'class':
40101,
'subclass':
0,
'text':
mapcss.tr(u'{0} is preferred to {1}', capture_tags,
u'{2.tag}', u'{1.tag}'),
'fix': {
'+': dict([[u'psv', u'yes']]),
'-': ([u'service'])
}
})
# way[highway=cycleway][cycleway=track]
if u'highway' in keys:
match = False
try:
match = match or ((
mapcss._tag_capture(capture_tags, 0, tags, u'highway')
== mapcss._value_capture(capture_tags, 0, u'cycleway')
and mapcss._tag_capture(capture_tags, 1, tags, u'cycleway')
== mapcss._value_capture(capture_tags, 1, u'track')))
except mapcss.RuleAbort:
pass
if match:
# osmoseTags:list("tag","highway","cycleway")
# osmoseItemClassLevel:"3032/30328/2"
# throwWarning:tr("{0} with {1}","{0.tag}","{1.tag}")
# fixRemove:"cycleway"
err.append({
'class':
30328,
'subclass':
0,
'text':
mapcss.tr(u'{0} with {1}', capture_tags, u'{0.tag}',
u'{1.tag}'),
'fix': {
'-': ([u'cycleway'])
}
})
# way[cycleway=~/opposite|opposite_lane/][!oneway]
# way[cycleway=~/opposite|opposite_lane/][oneway=no]
if u'cycleway' in keys:
match = False
try:
match = match or ((mapcss.regexp_test_(
mapcss._value_capture(capture_tags, 0, self.re_67b51e41),
mapcss._tag_capture(capture_tags, 0, tags, u'cycleway'))
and not mapcss._tag_capture(
capture_tags, 1, tags, u'oneway')))
except mapcss.RuleAbort:
pass
try:
match = match or ((mapcss.regexp_test_(
mapcss._value_capture(capture_tags, 0, self.re_67b51e41),
mapcss._tag_capture(capture_tags, 0, tags, u'cycleway'))
and mapcss._tag_capture(
capture_tags, 1, tags,
u'oneway') == mapcss._value_capture(
capture_tags, 1, u'no')))
except mapcss.RuleAbort:
pass
if match:
# osmoseTags:list("tag","highway","cycleway","fix:survey")
# osmoseItemClassLevel:"2030/20301/1"
# throwError:tr("Opposite cycleway without oneway")
# assertNoMatch:"way cycleway=lane oneway=yes"
# assertNoMatch:"way cycleway=opposite oneway=yes"
# assertMatch:"way cycleway=opposite"
err.append({
'class':
20301,
'subclass':
0,
'text':
mapcss.tr(u'Opposite cycleway without oneway',
capture_tags)
})
# way:righthandtraffic["cycleway:right"=~/opposite|opposite_lane/][oneway=yes]
# way:righthandtraffic["cycleway:left"=~/opposite|opposite_lane/][oneway="-1"]
# way!:righthandtraffic["cycleway:left"=~/opposite|opposite_lane/][oneway=yes]
# way!:righthandtraffic["cycleway:right"=~/opposite|opposite_lane/][oneway="-1"]
if u'cycleway:left' in keys or u'cycleway:right' in keys:
match = False
try:
match = match or (
(mapcss.regexp_test_(
mapcss._value_capture(capture_tags, 0,
self.re_67b51e41),
mapcss._tag_capture(capture_tags, 0, tags,
u'cycleway:right'))
and mapcss._tag_capture(capture_tags, 1, tags, u'oneway')
== mapcss._value_capture(capture_tags, 1, u'yes')
and mapcss.setting(self.father.config.options,
u'driving_side') != u'left'))
except mapcss.RuleAbort:
pass
try:
match = match or (
(mapcss.regexp_test_(
mapcss._value_capture(capture_tags, 0,
self.re_67b51e41),
mapcss._tag_capture(capture_tags, 0, tags,
u'cycleway:left'))
and mapcss._tag_capture(capture_tags, 1, tags, u'oneway')
== mapcss._value_capture(capture_tags, 1, u'-1')
and mapcss.setting(self.father.config.options,
u'driving_side') != u'left'))
except mapcss.RuleAbort:
pass
try:
match = match or (
(mapcss.regexp_test_(
mapcss._value_capture(capture_tags, 0,
self.re_67b51e41),
mapcss._tag_capture(capture_tags, 0, tags,
u'cycleway:left'))
and mapcss._tag_capture(capture_tags, 1, tags, u'oneway')
== mapcss._value_capture(capture_tags, 1, u'yes')
and mapcss.setting(self.father.config.options,
u'driving_side') == u'left'))
except mapcss.RuleAbort:
pass
try:
match = match or (
(mapcss.regexp_test_(
mapcss._value_capture(capture_tags, 0,
self.re_67b51e41),
mapcss._tag_capture(capture_tags, 0, tags,
u'cycleway:right'))
and mapcss._tag_capture(capture_tags, 1, tags, u'oneway')
== mapcss._value_capture(capture_tags, 1, u'-1')
and mapcss.setting(self.father.config.options,
u'driving_side') == u'left'))
except mapcss.RuleAbort:
pass
if match:
# osmoseTags:list("tag","highway","cycleway","fix:survey")
# osmoseItemClassLevel:"2030/20302/1"
# throwError:tr("Opposite or opposite lane in the same way of the oneway")
# assertMatch:"way cycleway:right=opposite oneway=yes"
# assertNoMatch:"way cycleway=opposite oneway=yes"
err.append({
'class':
20302,
'subclass':
0,
'text':
mapcss.tr(
u'Opposite or opposite lane in the same way of the oneway',
capture_tags)
})
return err
def relation(self, data, tags, members):
capture_tags = {}
keys = tags.keys()
err = []
# *[access][highway=proposed]
# *[motor_vehicle?][vehicle!=no][access!=no][bicycle_road!=yes][highway=~/^(motorway|motorway_link|trunk|trunk_link|primary|primary_link|secondary|secondary_link|tertiary|tertiary_link|unclassified|residential|service|living_street)$/]
# *[bridge=no]
# *[building=no]
# *[elevation="0"]
# *[layer="0"]
if (u'bridge' in keys) or (u'building' in keys) or (
u'elevation'
in keys) or (u'access' in keys and u'highway' in keys) or (
u'highway' in keys
and u'motor_vehicle' in keys) or (u'layer' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (
mapcss._tag_capture(capture_tags, 0, tags, u'access')
and mapcss._tag_capture(capture_tags, 1, tags,
u'highway')
== mapcss._value_capture(capture_tags, 1, u'proposed'))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (
mapcss._tag_capture(
capture_tags, 0, tags,
u'motor_vehicle') in ('yes', 'true', '1') and
mapcss._tag_capture(capture_tags, 1, tags, u'vehicle')
!= mapcss._value_capture(capture_tags, 1, u'no') and
mapcss._tag_capture(capture_tags, 2, tags, u'access')
!= mapcss._value_capture(capture_tags, 2, u'no')
and mapcss._tag_capture(capture_tags, 3, tags,
u'bicycle_road') !=
mapcss._value_capture(capture_tags, 3, u'yes')
and mapcss.regexp_test_(
mapcss._value_capture(capture_tags, 4,
self.re_3ad9e1f5),
mapcss._tag_capture(capture_tags, 4, tags,
u'highway')))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(
capture_tags, 0, tags,
u'bridge') == mapcss._value_capture(
capture_tags, 0, u'no'))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(
capture_tags, 0, tags,
u'building') == mapcss._value_capture(
capture_tags, 0, u'no'))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(
capture_tags, 0, tags,
u'elevation') == mapcss._value_capture(
capture_tags, 0, u'0'))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(
capture_tags, 0, tags,
u'layer') == mapcss._value_capture(
capture_tags, 0, u'0'))
except mapcss.RuleAbort:
pass
if match:
# group:tr("unnecessary tag")
# throwWarning:tr("{0} is unnecessary","{0.tag}")
# fixRemove:"{0.key}"
err.append({
'class':
9010001,
'subclass':
1949087363,
'text':
mapcss.tr(u'{0} is unnecessary',
mapcss._tag_uncapture(capture_tags, u'{0.tag}')),
'allow_fix_override':
True,
'fix': {
'-':
([mapcss._tag_uncapture(capture_tags, u'{0.key}')])
}
})
# *[emergency=permissive]
if (u'emergency' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(
capture_tags, 0, tags,
u'emergency') == mapcss._value_capture(
capture_tags, 0, u'permissive'))
except mapcss.RuleAbort:
pass
if match:
# throwWarning:tr("{0} makes no sense","{0.tag")
# fixAdd:"emergency=yes"
err.append({
'class': 9010002,
'subclass': 325672362,
'text': mapcss.tr(u'{0} makes no sense', u'{0.tag'),
'allow_fix_override': True,
'fix': {
'+': dict([[u'emergency', u'yes']])
}
})
# *[payment:cash][payment:coins][payment:notes]
if (u'payment:cash' in keys and u'payment:coins' in keys
and u'payment:notes' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(capture_tags, 0, tags,
u'payment:cash')
and mapcss._tag_capture(capture_tags, 1, tags,
u'payment:coins')
and mapcss._tag_capture(capture_tags, 2, tags,
u'payment:notes'))
except mapcss.RuleAbort:
pass
if match:
# group:tr("unnecessary tag")
# throwWarning:tr("{0} together with {1} and {2}. Remove {0}.","{0.key}","{1.key}","{2.key}")
# fixRemove:"payment:cash"
err.append({
'class':
9010001,
'subclass':
1340792439,
'text':
mapcss.tr(u'{0} together with {1} and {2}. Remove {0}.',
mapcss._tag_uncapture(capture_tags, u'{0.key}'),
mapcss._tag_uncapture(capture_tags, u'{1.key}'),
mapcss._tag_uncapture(capture_tags, u'{2.key}')),
'allow_fix_override':
True,
'fix': {
'-': ([u'payment:cash'])
}
})
return err
def relation(self, data, tags, members):
capture_tags = {}
keys = tags.keys()
err = []
set_pt_route = set_pt_route_master = False
# relation[type=route][!route]
if (u'type' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'type') == mapcss._value_capture(capture_tags, 0, u'route') and not mapcss._tag_capture(capture_tags, 1, tags, u'route'))
except mapcss.RuleAbort: pass
if match:
# throwError:tr("Missing transportation mode, add a tag route = bus/coach/tram/etc")
err.append({'class': 9014009, 'subclass': 828849115, 'text': mapcss.tr(u'Missing transportation mode, add a tag route = bus/coach/tram/etc')})
# relation[type=route_master][!route_master][!route]
if (u'type' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'type') == mapcss._value_capture(capture_tags, 0, u'route_master') and not mapcss._tag_capture(capture_tags, 1, tags, u'route_master') and not mapcss._tag_capture(capture_tags, 2, tags, u'route'))
except mapcss.RuleAbort: pass
if match:
# throwError:tr("Missing transportation mode, add a tag route = bus/coach/tram/etc")
err.append({'class': 9014009, 'subclass': 607011337, 'text': mapcss.tr(u'Missing transportation mode, add a tag route = bus/coach/tram/etc')})
# relation[type=route_master][!route_master][route]
if (u'route' in keys and u'type' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'type') == mapcss._value_capture(capture_tags, 0, u'route_master') and not mapcss._tag_capture(capture_tags, 1, tags, u'route_master') and mapcss._tag_capture(capture_tags, 2, tags, u'route'))
except mapcss.RuleAbort: pass
if match:
# throwError:tr("Missing transportation mode, change tag route to route_master")
# fixChangeKey:"route=>route_master"
err.append({'class': 9014010, 'subclass': 3385524, 'text': mapcss.tr(u'Missing transportation mode, change tag route to route_master'), 'allow_fix_override': True, 'fix': {
'+': dict([
[u'route_master', mapcss.tag(tags, u'route')]]),
'-': ([
u'route'])
}})
# relation[type=route][route=~/^(bus|coach|train|subway|monorail|trolleybus|aerialway|funicular|ferry|tram|share_taxi|light_rail|school_bus)$/]
if (u'route' in keys and u'type' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'type') == mapcss._value_capture(capture_tags, 0, u'route') and mapcss.regexp_test_(mapcss._value_capture(capture_tags, 1, self.re_37f81db8), mapcss._tag_capture(capture_tags, 1, tags, u'route')))
except mapcss.RuleAbort: pass
if match:
# setpt_route
set_pt_route = True
# relation[type=route_master][route_master=~/^(bus|coach|train|subway|monorail|trolleybus|aerialway|funicular|ferry|tram|share_taxi|light_rail|school_bus)$/]
if (u'route_master' in keys and u'type' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'type') == mapcss._value_capture(capture_tags, 0, u'route_master') and mapcss.regexp_test_(mapcss._value_capture(capture_tags, 1, self.re_37f81db8), mapcss._tag_capture(capture_tags, 1, tags, u'route_master')))
except mapcss.RuleAbort: pass
if match:
# setpt_route_master
set_pt_route_master = True
# relation.pt_route[!public_transport:version]
if True:
match = False
if not match:
capture_tags = {}
try: match = (set_pt_route and not mapcss._tag_capture(capture_tags, 0, tags, u'public_transport:version'))
except mapcss.RuleAbort: pass
if match:
# -osmoseItemClassLevel:"2140/21401/3"
# throwError:tr("Missing public_transport:version tag on a public_transport route relation")
# assertNoMatch:"relation type=route route=bus public_transport:version=1"
# assertMatch:"relation type=route route=bus"
err.append({'class': 21401, 'subclass': 0, 'text': mapcss.tr(u'Missing public_transport:version tag on a public_transport route relation')})
# relation.pt_route[!network]
# relation.pt_route_master[!network]
if True:
match = False
if not match:
capture_tags = {}
try: match = (set_pt_route and not mapcss._tag_capture(capture_tags, 0, tags, u'network'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (set_pt_route_master and not mapcss._tag_capture(capture_tags, 0, tags, u'network'))
except mapcss.RuleAbort: pass
if match:
# -osmoseItemClassLevel:"2140/21402/3"
# throwError:tr("Missing network tag on a public_transport relation")
# assertNoMatch:"relation type=route route=bus network=BiBiBus"
# assertMatch:"relation type=route route=bus"
err.append({'class': 21402, 'subclass': 0, 'text': mapcss.tr(u'Missing network tag on a public_transport relation')})
# relation.pt_route[!operator]
# relation.pt_route_master[!operator]
if True:
match = False
if not match:
capture_tags = {}
try: match = (set_pt_route and not mapcss._tag_capture(capture_tags, 0, tags, u'operator'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (set_pt_route_master and not mapcss._tag_capture(capture_tags, 0, tags, u'operator'))
except mapcss.RuleAbort: pass
if match:
# -osmoseItemClassLevel:"2140/21403/3"
# throwError:tr("Missing operator tag on a public_transport relation")
# assertNoMatch:"relation type=route route=bus operator=BiBiBus"
# assertMatch:"relation type=route route=bus"
err.append({'class': 21403, 'subclass': 0, 'text': mapcss.tr(u'Missing operator tag on a public_transport relation')})
# relation.pt_route[!ref]
# relation.pt_route_master[!ref]
if True:
match = False
if not match:
capture_tags = {}
try: match = (set_pt_route and not mapcss._tag_capture(capture_tags, 0, tags, u'ref'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (set_pt_route_master and not mapcss._tag_capture(capture_tags, 0, tags, u'ref'))
except mapcss.RuleAbort: pass
if match:
# -osmoseItemClassLevel:"2140/21404/3"
# throwError:tr("Missing ref tag for line number on a public_transport relation")
# assertNoMatch:"relation type=route route=bus ref=3"
# assertMatch:"relation type=route route=bus"
err.append({'class': 21404, 'subclass': 0, 'text': mapcss.tr(u'Missing ref tag for line number on a public_transport relation')})
# relation.pt_route[!from]
# relation.pt_route[!to]
if True:
match = False
if not match:
capture_tags = {}
try: match = (set_pt_route and not mapcss._tag_capture(capture_tags, 0, tags, u'from'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (set_pt_route and not mapcss._tag_capture(capture_tags, 0, tags, u'to'))
except mapcss.RuleAbort: pass
if match:
# -osmoseItemClassLevel:"2140/21405/3"
# throwError:tr("Missing from/to tag on a public_transport route relation")
# assertNoMatch:"relation type=route route=bus from=A to=B"
# assertMatch:"relation type=route route=bus from=A"
# assertMatch:"relation type=route route=bus to=B"
# assertMatch:"relation type=route route=bus"
err.append({'class': 21405, 'subclass': 0, 'text': mapcss.tr(u'Missing from/to tag on a public_transport route relation')})
# relation.pt_route["operator"=~/STIF|Kéolis|Véolia/][inside("FR")]
# relation.pt_route_master["operator"=~/STIF|Kéolis|Véolia/][inside("FR")]
if (u'operator' in keys):
match = False
if not match:
capture_tags = {}
try: match = (set_pt_route and mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_25554804), mapcss._tag_capture(capture_tags, 0, tags, u'operator')) and mapcss.inside(self.father.config.options, u'FR'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (set_pt_route_master and mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_25554804), mapcss._tag_capture(capture_tags, 0, tags, u'operator')) and mapcss.inside(self.father.config.options, u'FR'))
except mapcss.RuleAbort: pass
if match:
# throwError:tr("Check the operator tag")
err.append({'class': 9014013, 'subclass': 286137008, 'text': mapcss.tr(u'Check the operator tag')})
# relation.pt_route["network"=~/STIF|Kéolis|Véolia/][inside("FR")]
# relation.pt_route_master["network"=~/STIF|Kéolis|Véolia/][inside("FR")]
if (u'network' in keys):
match = False
if not match:
capture_tags = {}
try: match = (set_pt_route and mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_25554804), mapcss._tag_capture(capture_tags, 0, tags, u'network')) and mapcss.inside(self.father.config.options, u'FR'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (set_pt_route_master and mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_25554804), mapcss._tag_capture(capture_tags, 0, tags, u'network')) and mapcss.inside(self.father.config.options, u'FR'))
except mapcss.RuleAbort: pass
if match:
# throwError:tr("Check the network tag")
err.append({'class': 9014014, 'subclass': 735027962, 'text': mapcss.tr(u'Check the network tag')})
# relation.pt_route!.route_ok
# Use undeclared class pt_route, route_ok
return err
def way(self, data, tags, *args):
capture_tags = {}
keys = tags.keys()
err = []
# way["mtb:scale:uphill"][!incline]
if u'mtb:scale:uphill' in keys:
match = False
try:
match = match or ((mapcss._tag_capture(capture_tags, 0, tags,
u'mtb:scale:uphill')
and not mapcss._tag_capture(
capture_tags, 1, tags, u'incline')))
except mapcss.RuleAbort:
pass
if match:
# throwWarning:tr("Way contains ''{0}'' but not ''{1}''.","{0.key}","{1.key}")
err.append({
'class':
9013001,
'subclass':
1368047539,
'text':
mapcss.tr(u'Way contains \'\'{0}\'\' but not \'\'{1}\'\'.',
capture_tags, u'{0.key}', u'{1.key}')
})
# way["mtb:scale:uphill"][highway][highway!~/path|track/]
if u'mtb:scale:uphill' in keys:
match = False
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags,
u'mtb:scale:uphill')
and mapcss._tag_capture(capture_tags, 1, tags, u'highway')
and not mapcss.regexp_test_(
mapcss._value_capture(capture_tags, 2,
self.re_6937bec1),
mapcss._tag_capture(capture_tags, 2, tags,
u'highway'))))
except mapcss.RuleAbort:
pass
if match:
# throwWarning:tr("Way contains ''{0}'' but is neither a track nor a path.","{0.key}")
err.append({
'class':
9013002,
'subclass':
139842783,
'text':
mapcss.tr(
u'Way contains \'\'{0}\'\' but is neither a track nor a path.',
capture_tags, u'{0.key}')
})
# way["mtb:scale"]["mtb:scale"!~/^[0-6][-+]?$/]
if u'mtb:scale' in keys:
match = False
try:
match = match or ((mapcss._tag_capture(
capture_tags, 0, tags, u'mtb:scale'
) and not mapcss.regexp_test_(
mapcss._value_capture(capture_tags, 1, self.re_1b95e3e9),
mapcss._tag_capture(capture_tags, 1, tags, u'mtb:scale'))))
except mapcss.RuleAbort:
pass
if match:
# throwWarning:tr("Invalid ''{0}'' value: ''{1}''","{0.key}","{0.value}")
err.append({
'class':
9013003,
'subclass':
1229830952,
'text':
mapcss.tr(u'Invalid \'\'{0}\'\' value: \'\'{1}\'\'',
capture_tags, u'{0.key}', u'{0.value}')
})
# way["mtb:scale:uphill"]["mtb:scale:uphill"!~/^[0-5]$/]
if u'mtb:scale:uphill' in keys:
match = False
try:
match = match or ((mapcss._tag_capture(
capture_tags, 0, tags,
u'mtb:scale:uphill') and not mapcss.regexp_test_(
mapcss._value_capture(capture_tags, 1,
self.re_3d3b0752),
mapcss._tag_capture(capture_tags, 1, tags,
u'mtb:scale:uphill'))))
except mapcss.RuleAbort:
pass
if match:
# throwWarning:tr("Invalid ''{0}'' value: ''{1}''","{0.key}","{0.value}")
err.append({
'class':
9013003,
'subclass':
86930524,
'text':
mapcss.tr(u'Invalid \'\'{0}\'\' value: \'\'{1}\'\'',
capture_tags, u'{0.key}', u'{0.value}')
})
# way["mtb:scale:imba"]["mtb:scale:imba"!~/^[0-4]$/]
if u'mtb:scale:imba' in keys:
match = False
try:
match = match or ((mapcss._tag_capture(
capture_tags, 0, tags,
u'mtb:scale:imba') and not mapcss.regexp_test_(
mapcss._value_capture(capture_tags, 1,
self.re_731f6ce6),
mapcss._tag_capture(capture_tags, 1, tags,
u'mtb:scale:imba'))))
except mapcss.RuleAbort:
pass
if match:
# throwWarning:tr("Invalid ''{0}'' value: ''{1}''","{0.key}","{0.value}")
err.append({
'class':
9013003,
'subclass':
2005358544,
'text':
mapcss.tr(u'Invalid \'\'{0}\'\' value: \'\'{1}\'\'',
capture_tags, u'{0.key}', u'{0.value}')
})
return err
def relation(self, data, tags, *args):
capture_tags = {}
keys = tags.keys()
err = []
# *["addr:street"=~/.+;(.+)?/]
# *[highway=~/.+;(.+)?/]
# *[lanes=~/.+;(.+)?/]
# *[maxspeed=~/.+;(.+)?/]
# *[name=~/.+;(.+)?/]
# *[surface=~/.+;(.+)?/]
# *[water=~/.+;(.+)?/]
if u'addr:street' in keys or u'highway' in keys or u'lanes' in keys or u'maxspeed' in keys or u'name' in keys or u'surface' in keys or u'water' in keys:
match = False
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_53db61ac), mapcss._tag_capture(capture_tags, 0, tags, u'addr:street'))))
except mapcss.RuleAbort: pass
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_53db61ac), mapcss._tag_capture(capture_tags, 0, tags, u'highway'))))
except mapcss.RuleAbort: pass
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_53db61ac), mapcss._tag_capture(capture_tags, 0, tags, u'lanes'))))
except mapcss.RuleAbort: pass
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_53db61ac), mapcss._tag_capture(capture_tags, 0, tags, u'maxspeed'))))
except mapcss.RuleAbort: pass
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_53db61ac), mapcss._tag_capture(capture_tags, 0, tags, u'name'))))
except mapcss.RuleAbort: pass
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_53db61ac), mapcss._tag_capture(capture_tags, 0, tags, u'surface'))))
except mapcss.RuleAbort: pass
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_53db61ac), mapcss._tag_capture(capture_tags, 0, tags, u'water'))))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("{0} with multiple values","{0.key}")
err.append({'class': 9005001, 'subclass': 1911063816, 'text': mapcss.tr(u'{0} with multiple values', capture_tags, u'{0.key}')})
# *[source=~/^(;.*|.*;;.*|.*;)$/]
# *["source:addr"=~/^(;.*|.*;;.*|.*;)$/]
# *["source:maxspeed"=~/^(;.*|.*;;.*|.*;)$/]
# *["source:name"=~/^(;.*|.*;;.*|.*;)$/]
# *["source:position"=~/^(;.*|.*;;.*|.*;)$/]
# *["source:postcode"=~/^(;.*|.*;;.*|.*;)$/]
# *[ref=~/^(;.*|.*;;.*|.*;)$/]
# *[int_ref=~/^(;.*|.*;;.*|.*;)$/]
# *[old_ref=~/^(;.*|.*;;.*|.*;)$/]
# *[source_ref=~/^(;.*|.*;;.*|.*;)$/]
# *[route_ref=~/^(;.*|.*;;.*|.*;)$/]
# *[attribution=~/^(;.*|.*;;.*|.*;)$/]
# *[name=~/^(;.*|.*;;.*|.*;)$/]
# *[alt_name=~/^(;.*|.*;;.*|.*;)$/]
# *[note=~/^(;.*|.*;;.*|.*;)$/]
# *[fixme=~/^(;.*|.*;;.*|.*;)$/]
# *["addr:housenumber"=~/^(;.*|.*;;.*|.*;)$/]
# *[destination=~/^(;.*|.*;;.*|.*;)$/]
# *[exit_to=~/^(;.*|.*;;.*|.*;)$/]
# *[surface=~/^(;.*|.*;;.*|.*;)$/]
# *["building:use"=~/^(;.*|.*;;.*|.*;)$/]
# *[traffic_sign=~/^(;.*|.*;;.*|.*;)$/]
# *[voltage=~/^(;.*|.*;;.*|.*;)$/]
# *[cuisine=~/^(;.*|.*;;.*|.*;)$/]
if u'addr:housenumber' in keys or u'alt_name' in keys or u'attribution' in keys or u'building:use' in keys or u'cuisine' in keys or u'destination' in keys or u'exit_to' in keys or u'fixme' in keys or u'int_ref' in keys or u'name' in keys or u'note' in keys or u'old_ref' in keys or u'ref' in keys or u'route_ref' in keys or u'source' in keys or u'source:addr' in keys or u'source:maxspeed' in keys or u'source:name' in keys or u'source:position' in keys or u'source:postcode' in keys or u'source_ref' in keys or u'surface' in keys or u'traffic_sign' in keys or u'voltage' in keys:
match = False
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'source'))))
except mapcss.RuleAbort: pass
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'source:addr'))))
except mapcss.RuleAbort: pass
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'source:maxspeed'))))
except mapcss.RuleAbort: pass
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'source:name'))))
except mapcss.RuleAbort: pass
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'source:position'))))
except mapcss.RuleAbort: pass
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'source:postcode'))))
except mapcss.RuleAbort: pass
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'ref'))))
except mapcss.RuleAbort: pass
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'int_ref'))))
except mapcss.RuleAbort: pass
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'old_ref'))))
except mapcss.RuleAbort: pass
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'source_ref'))))
except mapcss.RuleAbort: pass
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'route_ref'))))
except mapcss.RuleAbort: pass
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'attribution'))))
except mapcss.RuleAbort: pass
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'name'))))
except mapcss.RuleAbort: pass
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'alt_name'))))
except mapcss.RuleAbort: pass
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'note'))))
except mapcss.RuleAbort: pass
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'fixme'))))
except mapcss.RuleAbort: pass
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'addr:housenumber'))))
except mapcss.RuleAbort: pass
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'destination'))))
except mapcss.RuleAbort: pass
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'exit_to'))))
except mapcss.RuleAbort: pass
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'surface'))))
except mapcss.RuleAbort: pass
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'building:use'))))
except mapcss.RuleAbort: pass
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'traffic_sign'))))
except mapcss.RuleAbort: pass
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'voltage'))))
except mapcss.RuleAbort: pass
try: match = match or ((mapcss.regexp_test_(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'cuisine'))))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("empty value in semicolon-separated ''{0}''","{0.key}")
err.append({'class': 9005002, 'subclass': 978530936, 'text': mapcss.tr(u'empty value in semicolon-separated \'\'{0}\'\'', capture_tags, u'{0.key}')})
return err
def way(self, data, tags, *args):
capture_tags = {}
keys = tags.keys()
err = []
# *[access][highway=proposed]
# *[motor_vehicle?][vehicle!=no][access!=no][bicycle_road!=yes][highway=~/^(motorway|motorway_link|trunk|trunk_link|primary|primary_link|secondary|secondary_link|tertiary|tertiary_link|unclassified|residential|service|living_street)$/]
# *[bridge=no]
# *[building=no]
# *[elevation="0"]
# *[layer="0"]
if u'access' in keys or u'bridge' in keys or u'building' in keys or u'elevation' in keys or u'layer' in keys or u'motor_vehicle' in keys:
match = False
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'access')
and mapcss._tag_capture(capture_tags, 1, tags, u'highway')
== mapcss._value_capture(capture_tags, 1, u'proposed')))
except mapcss.RuleAbort:
pass
try:
match = match or ((
mapcss._tag_capture(
capture_tags, 0, tags,
u'motor_vehicle') in ('yes', 'true', '1')
and mapcss._tag_capture(capture_tags, 1, tags, u'vehicle')
!= mapcss._value_capture(capture_tags, 1, u'no')
and mapcss._tag_capture(capture_tags, 2, tags, u'access')
!= mapcss._value_capture(capture_tags, 2, u'no') and
mapcss._tag_capture(capture_tags, 3, tags, u'bicycle_road')
!= mapcss._value_capture(capture_tags, 3, u'yes')
and mapcss.regexp_test_(
mapcss._value_capture(capture_tags, 4,
self.re_3ad9e1f5),
mapcss._tag_capture(capture_tags, 4, tags,
u'highway'))))
except mapcss.RuleAbort:
pass
try:
match = match or ((mapcss._tag_capture(
capture_tags, 0, tags, u'bridge') == mapcss._value_capture(
capture_tags, 0, u'no')))
except mapcss.RuleAbort:
pass
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'building')
== mapcss._value_capture(capture_tags, 0, u'no')))
except mapcss.RuleAbort:
pass
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'elevation')
== mapcss._value_capture(capture_tags, 0, u'0')))
except mapcss.RuleAbort:
pass
try:
match = match or ((mapcss._tag_capture(
capture_tags, 0, tags, u'layer') == mapcss._value_capture(
capture_tags, 0, u'0')))
except mapcss.RuleAbort:
pass
if match:
# group:tr("unnecessary tag")
# throwWarning:tr("{0} is unnecessary","{0.tag}")
# fixRemove:"{0.key}"
# assertMatch:"way bridge=no"
# assertMatch:"way highway=proposed access=no"
# assertMatch:"way layer=0"
err.append({
'class':
9010001,
'subclass':
1949087363,
'text':
mapcss.tr(u'{0} is unnecessary', capture_tags, u'{0.tag}'),
'fix': {
'-': ([u'{0.key}'])
}
})
# *[emergency=permissive]
if u'emergency' in keys:
match = False
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'emergency')
== mapcss._value_capture(capture_tags, 0, u'permissive')))
except mapcss.RuleAbort:
pass
if match:
# throwWarning:tr("{0} makes no sense","{0.tag")
# fixAdd:"emergency=yes"
# assertNoMatch:"way emergency=designated"
# assertMatch:"way emergency=permissive"
err.append({
'class':
9010002,
'subclass':
325672362,
'text':
mapcss.tr(u'{0} makes no sense', capture_tags, u'{0.tag'),
'fix': {
'+': dict([[u'emergency', u'yes']])
}
})
# *[payment:cash][payment:coins][payment:notes]
if u'payment:cash' in keys:
match = False
try:
match = match or ((
mapcss._tag_capture(capture_tags, 0, tags, u'payment:cash')
and mapcss._tag_capture(capture_tags, 1, tags,
u'payment:coins')
and mapcss._tag_capture(capture_tags, 2, tags,
u'payment:notes')))
except mapcss.RuleAbort:
pass
if match:
# group:tr("unnecessary tag")
# throwWarning:tr("{0} together with {1} and {2}. Remove {0}.","{0.key}","{1.key}","{2.key}")
# fixRemove:"payment:cash"
err.append({
'class':
9010001,
'subclass':
1340792439,
'text':
mapcss.tr(u'{0} together with {1} and {2}. Remove {0}.',
capture_tags, u'{0.key}', u'{1.key}',
u'{2.key}'),
'fix': {
'-': ([u'payment:cash'])
}
})
# way[waterway][oneway?]
if u'waterway' in keys:
match = False
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'waterway')
and mapcss._tag_capture(capture_tags, 1, tags, u'oneway')
in ('yes', 'true', '1')))
except mapcss.RuleAbort:
pass
if match:
# group:tr("unnecessary tag")
# throwWarning:tr("{0} is unnecessary for {1}","{1.key}","{0.key}")
# fixRemove:"{1.key}"
err.append({
'class':
9010001,
'subclass':
877465780,
'text':
mapcss.tr(u'{0} is unnecessary for {1}', capture_tags,
u'{1.key}', u'{0.key}'),
'fix': {
'-': ([u'{1.key}'])
}
})
# way[waterway][oneway=-1]
if u'waterway' in keys:
match = False
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'waterway')
and mapcss._tag_capture(capture_tags, 1, tags, u'oneway')
== mapcss._value_capture(capture_tags, 1, -1)))
except mapcss.RuleAbort:
pass
if match:
# group:tr("unnecessary tag")
# throwWarning:tr("{0} is unnecessary for {1}. The flow direction is defined by the way direction.","{1.key}","{0.key}")
err.append({
'class':
9010001,
'subclass':
1802985931,
'text':
mapcss.tr(
u'{0} is unnecessary for {1}. The flow direction is defined by the way direction.',
capture_tags, u'{1.key}', u'{0.key}')
})
return err
def way(self, data, tags, *args):
capture_tags = {}
keys = tags.keys()
err = []
# way[entrance]
# way[railway=subway_entrance]
# way[man_made=survey_point]
# way[aeroway=holding_position]
# way[power=transformer]
# way[power=pole]
# way[power=catenary_mast]
# way[power=terminal]
# way[amenity=vending_machine]
# way[natural=peak]
# way[natural=saddle]
# way[natural=volcano]
# way[natural=tree]
# way[highway=give_way]
# way[highway=milestone]
# way[highway=mini_roundabout]
# way[highway=stop]
# way[highway=street_lamp]
# way[highway=traffic_signals]
# way[highway=turning_loop]
# way[highway=turning_circle]
# way[highway=motorway_junction]
if u'aeroway' in keys or u'amenity' in keys or u'entrance' in keys or u'highway' in keys or u'man_made' in keys or u'natural' in keys or u'power' in keys or u'railway' in keys:
match = False
try:
match = match or ((mapcss._tag_capture(capture_tags, 0, tags,
u'entrance')))
except mapcss.RuleAbort:
pass
try:
match = match or ((mapcss._tag_capture(capture_tags, 0, tags,
u'railway')
== mapcss._value_capture(
capture_tags, 0, u'subway_entrance')))
except mapcss.RuleAbort:
pass
try:
match = match or ((mapcss._tag_capture(capture_tags, 0, tags,
u'man_made')
== mapcss._value_capture(
capture_tags, 0, u'survey_point')))
except mapcss.RuleAbort:
pass
try:
match = match or ((mapcss._tag_capture(capture_tags, 0, tags,
u'aeroway')
== mapcss._value_capture(
capture_tags, 0, u'holding_position')))
except mapcss.RuleAbort:
pass
try:
match = match or ((mapcss._tag_capture(
capture_tags, 0, tags, u'power') == mapcss._value_capture(
capture_tags, 0, u'transformer')))
except mapcss.RuleAbort:
pass
try:
match = match or ((mapcss._tag_capture(
capture_tags, 0, tags, u'power') == mapcss._value_capture(
capture_tags, 0, u'pole')))
except mapcss.RuleAbort:
pass
try:
match = match or ((mapcss._tag_capture(
capture_tags, 0, tags, u'power') == mapcss._value_capture(
capture_tags, 0, u'catenary_mast')))
except mapcss.RuleAbort:
pass
try:
match = match or ((mapcss._tag_capture(
capture_tags, 0, tags, u'power') == mapcss._value_capture(
capture_tags, 0, u'terminal')))
except mapcss.RuleAbort:
pass
try:
match = match or ((mapcss._tag_capture(capture_tags, 0, tags,
u'amenity')
== mapcss._value_capture(
capture_tags, 0, u'vending_machine')))
except mapcss.RuleAbort:
pass
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'natural')
== mapcss._value_capture(capture_tags, 0, u'peak')))
except mapcss.RuleAbort:
pass
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'natural')
== mapcss._value_capture(capture_tags, 0, u'saddle')))
except mapcss.RuleAbort:
pass
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'natural')
== mapcss._value_capture(capture_tags, 0, u'volcano')))
except mapcss.RuleAbort:
pass
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'natural')
== mapcss._value_capture(capture_tags, 0, u'tree')))
except mapcss.RuleAbort:
pass
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'highway')
== mapcss._value_capture(capture_tags, 0, u'give_way')))
except mapcss.RuleAbort:
pass
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'highway')
== mapcss._value_capture(capture_tags, 0, u'milestone')))
except mapcss.RuleAbort:
pass
try:
match = match or ((mapcss._tag_capture(capture_tags, 0, tags,
u'highway')
== mapcss._value_capture(
capture_tags, 0, u'mini_roundabout')))
except mapcss.RuleAbort:
pass
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'highway')
== mapcss._value_capture(capture_tags, 0, u'stop')))
except mapcss.RuleAbort:
pass
try:
match = match or ((mapcss._tag_capture(capture_tags, 0, tags,
u'highway')
== mapcss._value_capture(
capture_tags, 0, u'street_lamp')))
except mapcss.RuleAbort:
pass
try:
match = match or ((mapcss._tag_capture(capture_tags, 0, tags,
u'highway')
== mapcss._value_capture(
capture_tags, 0, u'traffic_signals')))
except mapcss.RuleAbort:
pass
try:
match = match or ((mapcss._tag_capture(capture_tags, 0, tags,
u'highway')
== mapcss._value_capture(
capture_tags, 0, u'turning_loop')))
except mapcss.RuleAbort:
pass
try:
match = match or ((mapcss._tag_capture(capture_tags, 0, tags,
u'highway')
== mapcss._value_capture(
capture_tags, 0, u'turning_circle')))
except mapcss.RuleAbort:
pass
try:
match = match or ((mapcss._tag_capture(capture_tags, 0, tags,
u'highway')
== mapcss._value_capture(
capture_tags, 0, u'motorway_junction')))
except mapcss.RuleAbort:
pass
if match:
# throwWarning:tr("{0} on a way. Should be used on a node.","{0.tag}")
err.append({
'class':
9003007,
'subclass':
172369653,
'text':
mapcss.tr(u'{0} on a way. Should be used on a node.',
capture_tags, u'{0.tag}')
})
# way[restriction][restriction=~/^(no_right_turn|no_left_turn|no_u_turn|no_straight_on|only_right_turn|only_left_turn|only_straight_on|no_entry|no_exit)$/]
# way[type=multipolygon]
# way[route=bus]
if u'restriction' in keys or u'route' in keys or u'type' in keys:
match = False
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'restriction')
and mapcss.regexp_test_(
mapcss._value_capture(capture_tags, 1,
self.re_22f56734),
mapcss._tag_capture(capture_tags, 1, tags,
u'restriction'))))
except mapcss.RuleAbort:
pass
try:
match = match or ((mapcss._tag_capture(
capture_tags, 0, tags, u'type') == mapcss._value_capture(
capture_tags, 0, u'multipolygon')))
except mapcss.RuleAbort:
pass
try:
match = match or ((mapcss._tag_capture(
capture_tags, 0, tags, u'route') == mapcss._value_capture(
capture_tags, 0, u'bus')))
except mapcss.RuleAbort:
pass
if match:
# throwError:tr("{0} on a way. Should be used in a relation","{0.tag}")
err.append({
'class':
9003008,
'subclass':
1728608057,
'text':
mapcss.tr(u'{0} on a way. Should be used in a relation',
capture_tags, u'{0.tag}')
})
return err
