def parse(self, token_parser: TokenParser) -> Either[SymbolName, StringSdv]:
is_plain_token, fragments = parse_fragments_from_tokens__w_is_plain(token_parser.token_stream, self._conf)
mb_just_symbol_name = _is_single_sym_ref(fragments)
if is_plain_token and mb_just_symbol_name is not None:
return Either.of_left(fragments[0].value)
else:
return Either.of_right(
string_sdv_from_fragments(fragments, self._conf.reference_restrictions)
)
def _parse_plain_list_element(
self,
token_parser: TokenParser) -> Either[SymbolName, ArgumentsSdv]:
sym_ref_or_string = self._string_or_sym_ref_parser.parse_from_token_parser(
token_parser)
if sym_ref_or_string.is_left():
return Either.of_left(sym_ref_or_string.left())
else:
return Either.of_right(
ArgumentsSdv.new_without_validation(
list_sdvs.from_string(sym_ref_or_string.right())))
def parse_sym_ref_or_fragments_from_token(token: Token) -> Either[SymbolName, List[symbol_syntax.Fragment]]:
if token.is_quoted and token.is_hard_quote_type:
return Either.of_right([symbol_syntax.constant(token.string)])
fragments = symbol_syntax.split(token.string)
mb_just_symbol_name = _is_single_sym_ref(fragments)
return (
Either.of_left(mb_just_symbol_name)
if token.is_plain and mb_just_symbol_name is not None
else
Either.of_right(fragments)
)
def parse_from_token_parser(
self, token_parser: TokenParser) -> Either[str, StringSdv]:
token_parser.require_has_valid_head_token(self._conf.argument_name)
head = token_parser.head
if head.source_string.startswith(string.HERE_DOCUMENT_MARKER_PREFIX):
string_sdv = self._here_doc_parser.parse_from_token_parser(
token_parser)
return Either.of_right(string_sdv)
elif TEXT_UNTIL_EOL_TOKEN_MATCHER.matches(head):
token_parser.consume_head()
string_sdv = parse_string.parse_rest_of_line_as_single_string(
token_parser, strip_space=True)
return Either.of_right(string_sdv)
else:
return self._plain_string_parser.parse(token_parser)
def _with_non_empty_token_stream(
self, tokens: TokenStream) -> Either[SymbolName, PathSdv]:
initial_argument_string = tokens.remaining_part_of_current_line
relativity_info = parse_explicit_relativity_info(
self.conf.rel_opt_conf.options, self.conf.source_file_location,
tokens)
if not self.conf.rel_opt_conf.path_suffix_is_required and tokens.remaining_part_of_current_line_is_empty:
if relativity_info is None:
return self._result_from_no_arguments()
else:
path_part_sdv2_path_sdv = self._path_constructor(
relativity_info)
return Either.of_right(
path_part_sdv2_path_sdv(path_part_sdvs.empty()))
if tokens.look_ahead_state is LookAheadState.SYNTAX_ERROR:
raise SingleInstructionInvalidArgumentException(
std_error_message_text_for_token_syntax_error(
tokens.head_syntax_error_description))
elif tokens.look_ahead_state is LookAheadState.NULL:
raise SingleInstructionInvalidArgumentException(
'Missing {}: {}'.format(
self.conf.rel_opt_conf.argument_syntax_name,
initial_argument_string))
head_token = tokens.head
if reserved_tokens.IS_RESERVED_WORD.matches(head_token):
raise SingleInstructionInvalidArgumentException(
'Illegal file name: {}'.format(head_token.string))
elif head_token.type is TokenType.PLAIN:
ensure_is_not_option_argument(head_token.source_string)
tokens.consume()
if relativity_info is None:
return self._without_explicit_relativity(head_token)
else:
path_part_2_path_sdv = self._path_constructor(relativity_info)
return Either.of_right(
self._with_explicit_relativity(head_token,
path_part_2_path_sdv))
def _without_explicit_relativity(
self, path_argument: Token) -> Either[SymbolName, PathSdv]:
sym_ref_of_fragments = parse_string.parse_sym_ref_or_fragments_from_token(
path_argument)
if sym_ref_of_fragments.is_left():
if path_argument.is_plain:
return Either.of_left(sym_ref_of_fragments.left())
else:
return Either.of_right(
self.symbol_name_reducer.reduce_left(
sym_ref_of_fragments.left()))
else:
string_fragments = sym_ref_of_fragments.right()
if _string_fragments_is_constant(string_fragments):
return Either.of_right(
self._just_string_argument(path_argument.string))
else:
return Either.of_right(
self._just_argument_with_symbol_references(
string_fragments))
class TestRight(unittest.TestCase):
SUT = Either.of_right('Snake skin boots')
CHECKER = Checker(
SUT,
check_form__true=_is_right,
check_form__false=_is_left,
getter__valid=_get_right,
getter__invalid=_get_left,
expected_from_getter='Snake skin boots',
)
def test_valid_access(self):
self.CHECKER.test_valid_access(self)
def test_invalid_access(self):
self.CHECKER.test_invalid_access(self)
def _parse_existing_path(
token_parser: TokenParser) -> Either[SymbolName, ArgumentsSdv]:
path = _PATH_PARSER.parse_from_token_parser(token_parser)
return Either.of_right(arguments_sdvs.ref_to_path_that_must_exist(path))
def _parse_existing_dir(
token_parser: TokenParser) -> Either[SymbolName, ArgumentsSdv]:
path = _PATH_PARSER.parse_from_token_parser(token_parser)
return Either.of_right(
arguments_sdvs.ref_to_file_that_must_exist(path, FileType.DIRECTORY))
def _result_from_no_arguments(self, ) -> Either[SymbolName, PathSdv]:
return Either.of_right(
path_sdvs.constant(
path_ddvs.of_rel_option(
self.conf.rel_opt_conf.options.default_option,
path_ddvs.empty_path_part())))
def test_reduce_left(self):
reducer = _Reducer(72, 'hello')
actual = reducer.reduce(Either.of_left(72))
self.assertEqual(True, actual)
def _is_right(e: Either) -> bool:
return e.is_right()
def _is_left(e: Either) -> bool:
return e.is_left()