tyler.durden/powerline
1
0
Fork 0
mirror of https://github.com/powerline/powerline.git synced 2025-07-29 08:45:15 +02:00
Code Issues Packages Projects Releases Wiki Activity

Some fixes for flake8

Browse Source
This commit is contained in:
ZyX 2013-03-10 23:12:07 +04:00
parent 3fd1215091
commit 5da848fa4a
14 changed files with 1466 additions and 1539 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
powerline/lint/__init__.py
View File

@ -861,6 +861,7 @@ def check(path=None):
)) ))
lhadproblem = [False] lhadproblem = [False]
def load_config(stream): def load_config(stream):
r, hadproblem = load(stream) r, hadproblem = load(stream)
if hadproblem: if hadproblem:

14
powerline/lint/markedjson/__init__.py
View File

@ -1,14 +1,9 @@
from .error import *
from .tokens import *
from .events import *
from .nodes import *
from .loader import *
__version__ = '3.10' __version__ = '3.10'
from .loader import Loader
def load(stream, Loader=Loader): def load(stream, Loader=Loader):
""" """
Parse the first YAML document in a stream Parse the first YAML document in a stream
@ -20,4 +15,3 @@ def load(stream, Loader=Loader):
return r, loader.haserrors return r, loader.haserrors
finally: finally:
loader.dispose() loader.dispose()

10
powerline/lint/markedjson/composer.py
View File

@ -1,15 +1,15 @@
__all__ = ['Composer', 'ComposerError'] __all__ = ['Composer', 'ComposerError']
from .error import MarkedYAMLError from .error import MarkedYAMLError
from .events import * from .events import * # NOQA
from .nodes import * from .nodes import * # NOQA
class ComposerError(MarkedYAMLError): class ComposerError(MarkedYAMLError):
pass pass
class Composer:
class Composer:
def __init__(self): def __init__(self):
pass pass
@ -60,7 +60,6 @@ class Composer:
return node return node
def compose_node(self, parent, index): def compose_node(self, parent, index):
event = self.peek_event()
self.descend_resolver(parent, index) self.descend_resolver(parent, index)
if self.check_event(ScalarEvent): if self.check_event(ScalarEvent):
node = self.compose_scalar_node() node = self.compose_scalar_node()
@ -116,4 +115,3 @@ class Composer:
end_event = self.get_event() end_event = self.get_event()
node.end_mark = end_event.end_mark node.end_mark = end_event.end_mark
return node return node

82
powerline/lint/markedjson/constructor.py
View File

@ -1,11 +1,11 @@
__all__ = ['BaseConstructor', 'Constructor', 'ConstructorError'] __all__ = ['BaseConstructor', 'Constructor', 'ConstructorError']
from .error import * from .error import MarkedYAMLError
from .nodes import * from .nodes import * # NOQA
from .markedvalue import * from .markedvalue import gen_marked_value
import collections, datetime, base64, binascii, re, sys, types import collections
import types
from functools import wraps from functools import wraps
@ -13,7 +13,8 @@ from functools import wraps
try: try:
from __builtin__ import unicode from __builtin__ import unicode
except ImportError: except ImportError:
unicode = str unicode = str # NOQA
def marked(func): def marked(func):
@wraps(func) @wraps(func)
@ -21,13 +22,13 @@ def marked(func):
return gen_marked_value(func(self, node, *args, **kwargs), node.start_mark) return gen_marked_value(func(self, node, *args, **kwargs), node.start_mark)
return f return f
class ConstructorError(MarkedYAMLError): class ConstructorError(MarkedYAMLError):
pass pass
class BaseConstructor:
class BaseConstructor:
yaml_constructors = {} yaml_constructors = {}
yaml_multi_constructors = {}
def __init__(self): def __init__(self):
self.constructed_objects = {} self.constructed_objects = {}
@ -73,23 +74,7 @@ class BaseConstructor:
if node.tag in self.yaml_constructors: if node.tag in self.yaml_constructors:
constructor = self.yaml_constructors[node.tag] constructor = self.yaml_constructors[node.tag]
else: else:
for tag_prefix in self.yaml_multi_constructors: raise ConstructorError(None, None, 'no constructor for tag %s' % node.tag)
if node.tag.startswith(tag_prefix):
tag_suffix = node.tag[len(tag_prefix):]
constructor = self.yaml_multi_constructors[tag_prefix]
break
else:
if None in self.yaml_multi_constructors:
tag_suffix = node.tag
constructor = self.yaml_multi_constructors[None]
elif None in self.yaml_constructors:
constructor = self.yaml_constructors[None]
elif isinstance(node, ScalarNode):
constructor = self.__class__.construct_scalar
elif isinstance(node, SequenceNode):
constructor = self.__class__.construct_sequence
elif isinstance(node, MappingNode):
constructor = self.__class__.construct_mapping
if tag_suffix is None: if tag_suffix is None:
data = constructor(self, node) data = constructor(self, node)
else: else:
@ -154,8 +139,8 @@ class BaseConstructor:
cls.yaml_constructors = cls.yaml_constructors.copy() cls.yaml_constructors = cls.yaml_constructors.copy()
cls.yaml_constructors[tag] = constructor cls.yaml_constructors[tag] = constructor
class Constructor(BaseConstructor):
class Constructor(BaseConstructor):
def construct_scalar(self, node): def construct_scalar(self, node):
if isinstance(node, MappingNode): if isinstance(node, MappingNode):
for key_node, value_node in node.value: for key_node, value_node in node.value:
@ -208,24 +193,14 @@ class Constructor(BaseConstructor):
self.construct_scalar(node) self.construct_scalar(node)
return None return None
bool_values = {
'yes': True,
'no': False,
'true': True,
'false': False,
'on': True,
'off': False,
}
@marked @marked
def construct_yaml_bool(self, node): def construct_yaml_bool(self, node):
value = self.construct_scalar(node) value = self.construct_scalar(node).value
return self.bool_values[value.lower()] return bool(value)
@marked @marked
def construct_yaml_int(self, node): def construct_yaml_int(self, node):
value = self.construct_scalar(node) value = self.construct_scalar(node).value
value = value.replace('_', '')
sign = +1 sign = +1
if value[0] == '-': if value[0] == '-':
sign = -1 sign = -1
@ -233,42 +208,17 @@ class Constructor(BaseConstructor):
value = value[1:] value = value[1:]
if value == '0': if value == '0':
return 0 return 0
elif value.startswith('0b'):
return sign*int(value[2:], 2)
elif value.startswith('0x'):
return sign*int(value[2:], 16)
elif value[0] == '0':
return sign*int(value, 8)
elif ':' in value:
digits = [int(part) for part in value.split(':')]
digits.reverse()
base = 1
value = 0
for digit in digits:
value += digit*base
base *= 60
return sign*value
else: else:
return sign * int(value) return sign * int(value)
@marked @marked
def construct_yaml_float(self, node): def construct_yaml_float(self, node):
value = self.construct_scalar(node) value = self.construct_scalar(node).value
value = value.replace('_', '').lower()
sign = +1 sign = +1
if value[0] == '-': if value[0] == '-':
sign = -1 sign = -1
if value[0] in '+-': if value[0] in '+-':
value = value[1:] value = value[1:]
elif ':' in value:
digits = [float(part) for part in value.split(':')]
digits.reverse()
base = 1
value = 0.0
for digit in digits:
value += digit*base
base *= 60
return sign*value
else: else:
return sign * float(value) return sign * float(value)
@ -291,6 +241,7 @@ class Constructor(BaseConstructor):
"could not determine a constructor for the tag %r" % node.tag, "could not determine a constructor for the tag %r" % node.tag,
node.start_mark) node.start_mark)
Constructor.add_constructor( Constructor.add_constructor(
'tag:yaml.org,2002:null', 'tag:yaml.org,2002:null',
Constructor.construct_yaml_null) Constructor.construct_yaml_null)
@ -321,4 +272,3 @@ Constructor.add_constructor(
Constructor.add_constructor(None, Constructor.add_constructor(None,
Constructor.construct_undefined) Constructor.construct_undefined)

7
powerline/lint/markedjson/error.py
View File

@ -1,4 +1,3 @@
__all__ = ['Mark', 'YAMLError', 'MarkedYAMLError', 'echoerr'] __all__ = ['Mark', 'YAMLError', 'MarkedYAMLError', 'echoerr']
@ -8,8 +7,8 @@ import sys
def strtrans(s): def strtrans(s):
return s.replace('\t', '>---') return s.replace('\t', '>---')
class Mark:
class Mark:
def __init__(self, name, index, line, column, buffer, pointer): def __init__(self, name, index, line, column, buffer, pointer):
self.name = name self.name = name
self.index = index self.index = index
@ -53,6 +52,7 @@ class Mark:
else: else:
return where.encode('utf-8') return where.encode('utf-8')
class YAMLError(Exception): class YAMLError(Exception):
pass pass
@ -61,6 +61,7 @@ def echoerr(*args, **kwargs):
sys.stderr.write('\n') sys.stderr.write('\n')
sys.stderr.write(format_error(*args, **kwargs) + '\n') sys.stderr.write(format_error(*args, **kwargs) + '\n')
def format_error(context=None, context_mark=None, problem=None, problem_mark=None, note=None): def format_error(context=None, context_mark=None, problem=None, problem_mark=None, note=None):
lines = [] lines = []
if context is not None: if context is not None:
@ -79,8 +80,8 @@ def format_error(context=None, context_mark=None, problem=None, problem_mark=Non
lines.append(note) lines.append(note)
return '\n'.join(lines) return '\n'.join(lines)
class MarkedYAMLError(YAMLError):
class MarkedYAMLError(YAMLError):
def __init__(self, context=None, context_mark=None, def __init__(self, context=None, context_mark=None,
problem=None, problem_mark=None, note=None): problem=None, problem_mark=None, note=None):
YAMLError.__init__(self, format_error(context, context_mark, problem, YAMLError.__init__(self, format_error(context, context_mark, problem,

18
powerline/lint/markedjson/events.py
View File

@ -1,10 +1,11 @@
# Abstract classes. # Abstract classes.
class Event(object): class Event(object):
def __init__(self, start_mark=None, end_mark=None): def __init__(self, start_mark=None, end_mark=None):
self.start_mark = start_mark self.start_mark = start_mark
self.end_mark = end_mark self.end_mark = end_mark
def __repr__(self): def __repr__(self):
attributes = [key for key in ['implicit', 'value'] attributes = [key for key in ['implicit', 'value']
if hasattr(self, key)] if hasattr(self, key)]
@ -12,11 +13,13 @@ class Event(object):
for key in attributes]) for key in attributes])
return '%s(%s)' % (self.__class__.__name__, arguments) return '%s(%s)' % (self.__class__.__name__, arguments)
class NodeEvent(Event): class NodeEvent(Event):
def __init__(self, start_mark=None, end_mark=None): def __init__(self, start_mark=None, end_mark=None):
self.start_mark = start_mark self.start_mark = start_mark
self.end_mark = end_mark self.end_mark = end_mark
class CollectionStartEvent(NodeEvent): class CollectionStartEvent(NodeEvent):
def __init__(self, implicit, start_mark=None, end_mark=None, def __init__(self, implicit, start_mark=None, end_mark=None,
flow_style=None): flow_style=None):
@ -26,20 +29,25 @@ class CollectionStartEvent(NodeEvent):
self.end_mark = end_mark self.end_mark = end_mark
self.flow_style = flow_style self.flow_style = flow_style
class CollectionEndEvent(Event): class CollectionEndEvent(Event):
pass pass
# Implementations. # Implementations.
class StreamStartEvent(Event): class StreamStartEvent(Event):
def __init__(self, start_mark=None, end_mark=None, encoding=None): def __init__(self, start_mark=None, end_mark=None, encoding=None):
self.start_mark = start_mark self.start_mark = start_mark
self.end_mark = end_mark self.end_mark = end_mark
self.encoding = encoding self.encoding = encoding
class StreamEndEvent(Event): class StreamEndEvent(Event):
pass pass
class DocumentStartEvent(Event): class DocumentStartEvent(Event):
def __init__(self, start_mark=None, end_mark=None, def __init__(self, start_mark=None, end_mark=None,
explicit=None, version=None, tags=None): explicit=None, version=None, tags=None):
@ -49,6 +57,7 @@ class DocumentStartEvent(Event):
self.version = version self.version = version
self.tags = tags self.tags = tags
class DocumentEndEvent(Event): class DocumentEndEvent(Event):
def __init__(self, start_mark=None, end_mark=None, def __init__(self, start_mark=None, end_mark=None,
explicit=None): explicit=None):
@ -56,9 +65,11 @@ class DocumentEndEvent(Event):
self.end_mark = end_mark self.end_mark = end_mark
self.explicit = explicit self.explicit = explicit
class AliasEvent(NodeEvent): class AliasEvent(NodeEvent):
pass pass
class ScalarEvent(NodeEvent): class ScalarEvent(NodeEvent):
def __init__(self, implicit, value, def __init__(self, implicit, value,
start_mark=None, end_mark=None, style=None): start_mark=None, end_mark=None, style=None):
@ -69,15 +80,18 @@ class ScalarEvent(NodeEvent):
self.end_mark = end_mark self.end_mark = end_mark
self.style = style self.style = style
class SequenceStartEvent(CollectionStartEvent): class SequenceStartEvent(CollectionStartEvent):
pass pass
class SequenceEndEvent(CollectionEndEvent): class SequenceEndEvent(CollectionEndEvent):
pass pass
class MappingStartEvent(CollectionStartEvent): class MappingStartEvent(CollectionStartEvent):
pass pass
class MappingEndEvent(CollectionEndEvent): class MappingEndEvent(CollectionEndEvent):
pass pass

16
powerline/lint/markedjson/loader.py
View File

@ -1,16 +1,15 @@
__all__ = ['Loader'] __all__ = ['Loader']
from .reader import * from .reader import Reader
from .scanner import * from .scanner import Scanner
from .parser import * from .parser import Parser
from .composer import * from .composer import Composer
from .constructor import * from .constructor import Constructor
from .resolver import * from .resolver import Resolver
from .error import echoerr from .error import echoerr
class Loader(Reader, Scanner, Parser, Composer, Constructor, Resolver):
class Loader(Reader, Scanner, Parser, Composer, Constructor, Resolver):
def __init__(self, stream): def __init__(self, stream):
Reader.__init__(self, stream) Reader.__init__(self, stream)
Scanner.__init__(self) Scanner.__init__(self)
@ -23,4 +22,3 @@ class Loader(Reader, Scanner, Parser, Composer, Constructor, Resolver):
def echoerr(self, *args, **kwargs): def echoerr(self, *args, **kwargs):
echoerr(*args, **kwargs) echoerr(*args, **kwargs)
self.haserrors = True self.haserrors = True

3
powerline/lint/markedjson/markedvalue.py
View File

@ -1,12 +1,15 @@
__all__ = ['gen_marked_value', 'MarkedValue'] __all__ = ['gen_marked_value', 'MarkedValue']
class MarkedValue: class MarkedValue:
def __init__(self, value, mark): def __init__(self, value, mark):
self.mark = mark self.mark = mark
self.value = value self.value = value
classcache = {} classcache = {}
def gen_marked_value(value, mark): def gen_marked_value(value, mark):
if value.__class__ in classcache: if value.__class__ in classcache:
Marked = classcache[value.__class__] Marked = classcache[value.__class__]

8
powerline/lint/markedjson/nodes.py
View File

@ -1,10 +1,10 @@
class Node(object): class Node(object):
def __init__(self, tag, value, start_mark, end_mark): def __init__(self, tag, value, start_mark, end_mark):
self.tag = tag self.tag = tag
self.value = value self.value = value
self.start_mark = start_mark self.start_mark = start_mark
self.end_mark = end_mark self.end_mark = end_mark
def __repr__(self): def __repr__(self):
value = self.value value = self.value
#if isinstance(value, list): #if isinstance(value, list):
@ -22,8 +22,10 @@ class Node(object):
value = repr(value) value = repr(value)
return '%s(tag=%r, value=%s)' % (self.__class__.__name__, self.tag, value) return '%s(tag=%r, value=%s)' % (self.__class__.__name__, self.tag, value)
class ScalarNode(Node): class ScalarNode(Node):
id = 'scalar' id = 'scalar'
def __init__(self, tag, value, def __init__(self, tag, value,
start_mark=None, end_mark=None, style=None): start_mark=None, end_mark=None, style=None):
self.tag = tag self.tag = tag
@ -32,6 +34,7 @@ class ScalarNode(Node):
self.end_mark = end_mark self.end_mark = end_mark
self.style = style self.style = style
class CollectionNode(Node): class CollectionNode(Node):
def __init__(self, tag, value, def __init__(self, tag, value,
start_mark=None, end_mark=None, flow_style=None): start_mark=None, end_mark=None, flow_style=None):
@ -41,9 +44,10 @@ class CollectionNode(Node):
self.end_mark = end_mark self.end_mark = end_mark
self.flow_style = flow_style self.flow_style = flow_style
class SequenceNode(CollectionNode): class SequenceNode(CollectionNode):
id = 'sequence' id = 'sequence'
class MappingNode(CollectionNode): class MappingNode(CollectionNode):
id = 'mapping' id = 'mapping'

29
powerline/lint/markedjson/parser.py
View File

@ -1,26 +1,18 @@
__all__ = ['Parser', 'ParserError'] __all__ = ['Parser', 'ParserError']
from .error import MarkedYAMLError from .error import MarkedYAMLError
from .tokens import * from .tokens import * # NOQA
from .events import * from .events import * # NOQA
from .scanner import *
class ParserError(MarkedYAMLError): class ParserError(MarkedYAMLError):
pass pass
class Parser: class Parser:
# Since writing a recursive-descendant parser is a straightforward task, we
# do not give many comments here.
DEFAULT_TAGS = {
'!': '!',
'!!': 'tag:yaml.org,2002:',
}
def __init__(self): def __init__(self):
self.current_event = None self.current_event = None
self.yaml_version = None self.yaml_version = None
self.tag_handles = {}
self.states = [] self.states = []
self.marks = [] self.marks = []
self.state = self.parse_stream_start self.state = self.parse_stream_start
@ -64,7 +56,6 @@ class Parser:
# explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* # explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
def parse_stream_start(self): def parse_stream_start(self):
# Parse the stream start. # Parse the stream start.
token = self.get_token() token = self.get_token()
event = StreamStartEvent(token.start_mark, token.end_mark, event = StreamStartEvent(token.start_mark, token.end_mark,
@ -76,10 +67,8 @@ class Parser:
return event return event
def parse_implicit_document_start(self): def parse_implicit_document_start(self):
# Parse an implicit document. # Parse an implicit document.
if not self.check_token(StreamEndToken): if not self.check_token(StreamEndToken):
self.tag_handles = self.DEFAULT_TAGS
token = self.peek_token() token = self.peek_token()
start_mark = end_mark = token.start_mark start_mark = end_mark = token.start_mark
event = DocumentStartEvent(start_mark, end_mark, explicit=False) event = DocumentStartEvent(start_mark, end_mark, explicit=False)
@ -94,15 +83,12 @@ class Parser:
return self.parse_document_start() return self.parse_document_start()
def parse_document_start(self): def parse_document_start(self):
# Parse an explicit document. # Parse an explicit document.
if not self.check_token(StreamEndToken): if not self.check_token(StreamEndToken):
token = self.peek_token() token = self.peek_token()
start_mark = token.start_mark
self.echoerr(None, None, self.echoerr(None, None,
"expected '<stream end>', but found %r" "expected '<stream end>', but found %r" % token.id,
% self.peek_token().id, token.start_mark)
self.peek_token().start_mark)
return StreamEndEvent(token.start_mark, token.end_mark) return StreamEndEvent(token.start_mark, token.end_mark)
else: else:
# Parse the end of the stream. # Parse the end of the stream.
@ -114,7 +100,6 @@ class Parser:
return event return event
def parse_document_end(self): def parse_document_end(self):
# Parse the document end. # Parse the document end.
token = self.peek_token() token = self.peek_token()
start_mark = end_mark = token.start_mark start_mark = end_mark = token.start_mark
@ -130,7 +115,7 @@ class Parser:
return self.parse_node() return self.parse_node()
def parse_node(self, indentless_sequence=False): def parse_node(self, indentless_sequence=False):
start_mark = end_mark = tag_mark = None start_mark = end_mark = None
if start_mark is None: if start_mark is None:
start_mark = end_mark = self.peek_token().start_mark start_mark = end_mark = self.peek_token().start_mark
event = None event = None

34
powerline/lint/markedjson/reader.py
View File

@ -1,35 +1,21 @@
# This module contains abstractions for the input stream. You don't have to # This module contains abstractions for the input stream. You don't have to
# looks further, there are no pretty code. # looks further, there are no pretty code.
#
# We define two classes here.
#
# Mark(source, line, column)
# It's just a record and its only use is producing nice error messages.
# Parser does not use it for any other purposes.
#
# Reader(source, data)
# Reader determines the encoding of `data` and converts it to unicode.
# Reader provides the following methods and attributes:
# reader.peek(length=1) - return the next `length` characters
# reader.forward(length=1) - move the current position to `length` characters.
# reader.index - the number of the current character.
# reader.line, stream.column - the line and the column of the current character.
__all__ = ['Reader', 'ReaderError'] __all__ = ['Reader', 'ReaderError']
from .error import YAMLError, Mark from .error import YAMLError, Mark
import codecs, re import codecs
import re
try: try:
from __builtin__ import unicode, unichr from __builtin__ import unicode, unichr
except ImportError: except ImportError:
unicode = str unicode = str # NOQA
unichr = chr unichr = chr # NOQA
class ReaderError(YAMLError): class ReaderError(YAMLError):
def __init__(self, name, position, character, encoding, reason): def __init__(self, name, position, character, encoding, reason):
self.name = name self.name = name
self.character = character self.character = character
@ -49,6 +35,7 @@ class ReaderError(YAMLError):
% (self.character, self.reason, % (self.character, self.reason,
self.name, self.position) self.name, self.position)
class Reader(object): class Reader(object):
# Reader: # Reader:
# - determines the data encoding and converts it to a unicode string, # - determines the data encoding and converts it to a unicode string,
@ -59,7 +46,6 @@ class Reader(object):
# - a file-like object with its `read` method returning `str`, # - a file-like object with its `read` method returning `str`,
# Yeah, it's ugly and slow. # Yeah, it's ugly and slow.
def __init__(self, stream): def __init__(self, stream):
self.name = None self.name = None
self.stream = None self.stream = None
@ -115,13 +101,13 @@ class Reader(object):
self.full_buffer, self.full_pointer) self.full_buffer, self.full_pointer)
NON_PRINTABLE = re.compile('[^\t\n\x20-\x7E' + unichr(0x85) + (unichr(0xA0) + '-' + unichr(0xD7FF)) + (unichr(0xE000) + '-' + unichr(0xFFFD)) + ']') NON_PRINTABLE = re.compile('[^\t\n\x20-\x7E' + unichr(0x85) + (unichr(0xA0) + '-' + unichr(0xD7FF)) + (unichr(0xE000) + '-' + unichr(0xFFFD)) + ']')
def check_printable(self, data): def check_printable(self, data):
match = self.NON_PRINTABLE.search(data) match = self.NON_PRINTABLE.search(data)
if match: if match:
character = match.group() character = match.group()
position = self.index + (len(self.buffer) - self.pointer) + match.start() position = self.index + (len(self.buffer) - self.pointer) + match.start()
raise ReaderError(self.name, position, ord(character), raise ReaderError(self.name, position, ord(character), 'unicode', "special characters are not allowed")
'unicode', "special characters are not allowed")
def update(self, length): def update(self, length):
if self.raw_buffer is None: if self.raw_buffer is None:
@ -137,8 +123,7 @@ class Reader(object):
except UnicodeDecodeError as exc: except UnicodeDecodeError as exc:
character = self.raw_buffer[exc.start] character = self.raw_buffer[exc.start]
position = self.stream_pointer - len(self.raw_buffer) + exc.start position = self.stream_pointer - len(self.raw_buffer) + exc.start
raise ReaderError(self.name, position, character, raise ReaderError(self.name, position, character, exc.encoding, exc.reason)
exc.encoding, exc.reason)
self.check_printable(data) self.check_printable(data)
self.buffer += data self.buffer += data
self.full_buffer += data self.full_buffer += data
@ -157,4 +142,3 @@ class Reader(object):
self.stream_pointer += len(data) self.stream_pointer += len(data)
if not data: if not data:
self.eof = True self.eof = True

22
powerline/lint/markedjson/resolver.py
View File

@ -1,16 +1,16 @@
__all__ = ['BaseResolver', 'Resolver'] __all__ = ['BaseResolver', 'Resolver']
from .error import * from .error import MarkedYAMLError
from .nodes import * from .nodes import * # NOQA
import re import re
class ResolverError(MarkedYAMLError): class ResolverError(MarkedYAMLError):
pass pass
class BaseResolver:
class BaseResolver:
DEFAULT_SCALAR_TAG = 'tag:yaml.org,2002:str' DEFAULT_SCALAR_TAG = 'tag:yaml.org,2002:str'
DEFAULT_SEQUENCE_TAG = 'tag:yaml.org,2002:seq' DEFAULT_SEQUENCE_TAG = 'tag:yaml.org,2002:seq'
DEFAULT_MAPPING_TAG = 'tag:yaml.org,2002:map' DEFAULT_MAPPING_TAG = 'tag:yaml.org,2002:map'
@ -94,16 +94,10 @@ class BaseResolver:
if regexp.match(value): if regexp.match(value):
return tag return tag
else: else:
raise ResolverError('while resolving plain scalar', None, self.echoerr('While resolving plain scalar', None,
"expected floating-point value, integer, null or boolean, but got %r" % value, 'expected floating-point value, integer, null or boolean, but got %r' % value,
mark) mark)
implicit = implicit[1] return self.DEFAULT_SCALAR_TAG
if self.yaml_path_resolvers:
exact_paths = self.resolver_exact_paths[-1]
if kind in exact_paths:
return exact_paths[kind]
if None in exact_paths:
return exact_paths[None]
if kind is ScalarNode: if kind is ScalarNode:
return self.DEFAULT_SCALAR_TAG return self.DEFAULT_SCALAR_TAG
elif kind is SequenceNode: elif kind is SequenceNode:
@ -111,9 +105,11 @@ class BaseResolver:
elif kind is MappingNode: elif kind is MappingNode:
return self.DEFAULT_MAPPING_TAG return self.DEFAULT_MAPPING_TAG
class Resolver(BaseResolver): class Resolver(BaseResolver):
pass pass
Resolver.add_implicit_resolver( Resolver.add_implicit_resolver(
'tag:yaml.org,2002:bool', 'tag:yaml.org,2002:bool',
re.compile(r'''^(?:true|false)$''', re.X), re.compile(r'''^(?:true|false)$''', re.X),

17
powerline/lint/markedjson/scanner.py
View File

@ -1,4 +1,3 @@
# Scanner produces tokens of the following types: # Scanner produces tokens of the following types:
# STREAM-START # STREAM-START
# STREAM-END # STREAM-END
@ -11,25 +10,22 @@
# FLOW-ENTRY # FLOW-ENTRY
# KEY # KEY
# VALUE # VALUE
# ALIAS(value)
# ANCHOR(value)
# TAG(value)
# SCALAR(value, plain, style) # SCALAR(value, plain, style)
# #
# Read comments in the Scanner code for more details. # Read comments in the Scanner code for more details.
#
__all__ = ['Scanner', 'ScannerError'] __all__ = ['Scanner', 'ScannerError']
from .error import MarkedYAMLError from .error import MarkedYAMLError
from .tokens import * from .tokens import * # NOQA
class ScannerError(MarkedYAMLError): class ScannerError(MarkedYAMLError):
pass pass
class SimpleKey: class SimpleKey:
# See below simple keys treatment. # See below simple keys treatment.
def __init__(self, token_number, index, line, column, mark): def __init__(self, token_number, index, line, column, mark):
self.token_number = token_number self.token_number = token_number
self.index = index self.index = index
@ -37,8 +33,8 @@ class SimpleKey:
self.column = column self.column = column
self.mark = mark self.mark = mark
class Scanner:
class Scanner:
def __init__(self): def __init__(self):
"""Initialize the scanner.""" """Initialize the scanner."""
# It is assumed that Scanner and Reader will have a common descendant. # It is assumed that Scanner and Reader will have a common descendant.
@ -226,8 +222,6 @@ class Scanner:
def remove_possible_simple_key(self): def remove_possible_simple_key(self):
# Remove the saved possible key position at the current flow level. # Remove the saved possible key position at the current flow level.
if self.flow_level in self.possible_simple_keys: if self.flow_level in self.possible_simple_keys:
key = self.possible_simple_keys[self.flow_level]
del self.possible_simple_keys[self.flow_level] del self.possible_simple_keys[self.flow_level]
# Fetchers. # Fetchers.
@ -243,9 +237,7 @@ class Scanner:
self.tokens.append(StreamStartToken(mark, mark, self.tokens.append(StreamStartToken(mark, mark,
encoding=self.encoding)) encoding=self.encoding))
def fetch_stream_end(self): def fetch_stream_end(self):
# Reset simple keys. # Reset simple keys.
self.remove_possible_simple_key() self.remove_possible_simple_key()
self.allow_simple_key = False self.allow_simple_key = False
@ -463,7 +455,6 @@ class Scanner:
while True: while True:
length = 0 length = 0
while True: while True:
ch = self.peek(length)
if self.peek(length) not in 'eE.0123456789nul-tr+fas': if self.peek(length) not in 'eE.0123456789nul-tr+fas':
break break
length += 1 length += 1

16
powerline/lint/markedjson/tokens.py
View File

@ -1,8 +1,8 @@
class Token(object): class Token(object):
def __init__(self, start_mark, end_mark): def __init__(self, start_mark, end_mark):
self.start_mark = start_mark self.start_mark = start_mark
self.end_mark = end_mark self.end_mark = end_mark
def __repr__(self): def __repr__(self):
attributes = [key for key in self.__dict__ attributes = [key for key in self.__dict__
if not key.endswith('_mark')] if not key.endswith('_mark')]
@ -11,47 +11,55 @@ class Token(object):
for key in attributes]) for key in attributes])
return '%s(%s)' % (self.__class__.__name__, arguments) return '%s(%s)' % (self.__class__.__name__, arguments)
#class BOMToken(Token):
# id = '<byte order mark>'
class StreamStartToken(Token): class StreamStartToken(Token):
id = '<stream start>' id = '<stream start>'
def __init__(self, start_mark=None, end_mark=None, def __init__(self, start_mark=None, end_mark=None,
encoding=None): encoding=None):
self.start_mark = start_mark self.start_mark = start_mark
self.end_mark = end_mark self.end_mark = end_mark
self.encoding = encoding self.encoding = encoding
class StreamEndToken(Token): class StreamEndToken(Token):
id = '<stream end>' id = '<stream end>'
class FlowSequenceStartToken(Token): class FlowSequenceStartToken(Token):
id = '[' id = '['
class FlowMappingStartToken(Token): class FlowMappingStartToken(Token):
id = '{' id = '{'
class FlowSequenceEndToken(Token): class FlowSequenceEndToken(Token):
id = ']' id = ']'
class FlowMappingEndToken(Token): class FlowMappingEndToken(Token):
id = '}' id = '}'
class KeyToken(Token): class KeyToken(Token):
id = '?' id = '?'
class ValueToken(Token): class ValueToken(Token):
id = ':' id = ':'
class FlowEntryToken(Token): class FlowEntryToken(Token):
id = ',' id = ','
class ScalarToken(Token): class ScalarToken(Token):
id = '<scalar>' id = '<scalar>'
def __init__(self, value, plain, start_mark, end_mark, style=None): def __init__(self, value, plain, start_mark, end_mark, style=None):
self.value = value self.value = value
self.plain = plain self.plain = plain
self.start_mark = start_mark self.start_mark = start_mark
self.end_mark = end_mark self.end_mark = end_mark
self.style = style self.style = style