textout/textoutpc/Tags/__base__.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from functools import partial as _p

__all__ = ["TextoutRawTag",
	"TextoutBlockTag", "TextoutRawBlockTag",
	"TextoutParagraphTag", "TextoutRawParagraphTag",
	"TextoutInlineTag", "TextoutRawInlineTag",
	"TextoutInlineBlockTag", "TextoutRawInlineBlockTag"]

# ---
# Main base tag class.
# ---
# There are three types of tags:
#
# - Those who know how to are valid straight when they receive their
#   name and value (attribute), and include their content without
#   processing it.
# - Those who are valid straight when they receive their name and value,
#   but process their content.
# - Those who don't know if they are valid until they receive their content,
#   and process it.
#
# All categories can set the `_prepare()` method to process the name
# and value to check their validity and prepare some things.
# The second and third category needs to set the `_content()` method
# (which the existence will be checked after the `_prepare()` method
# is called), which may, as the `_prepare()` method, raise an exception
# if there is a problem with the content.
# ---
# The classes can define the following methods (not including helpers):
#
# - `_prepare()`: will be called at class initialization. `self.name` and
#   `self.value` (attribute) will be set. Exception means the tag with
#   this name/attribute combination is invalid;
# - `_content()`: will be called when the content is set. `self.name`,
#   `self.value` and `self.content` will be set. Exception means the tag
#   with this name/attribute/content combination is invalid;
# - `begin_<fmt>()`: put the beginning of the produced form (by default,
#   nothing);
# - `process_<fmt>()`: put the main content of the produced form (by default,
#   the raw/escaped content for the format);
# - `end_<fmt>()`: put the end of the produced form (by default, nothing).

class TextoutTag:
	""" The textout tag base class.
		Is initialized with these values:
	
		[<name>]<content>[/<name>]
		[<name>=<value>]<content>[/<name>] """

	aliases = ()

	@property
	def name(self):
		return self.__name

	@property
	def _full(self):
		return self.__full

	def __init__(self, name, value, ot):
		""" Initialize the textout tag with the documented members. """

		# Store internal data.

		self.__output_type = ot
		self.__name = name
		if name[0] + name[-1] == "[]":
			self.__full = "[" + name[1:-1] + ("=" + value if value != None \
				else "") + "]"
		else:
			self.__full = name

		# Call both prepare functions.

		if hasattr(self, 'prepare_' + ot):
			self.prepare = getattr(self, 'prepare_' + ot)
		if hasattr(self, 'prepare'):
			self.prepare(name, value)

		# Prepare the preprocessing elements.
		if not hasattr(self, 'preprocess'):
			if hasattr(self, 'preprocess_' + ot):
				self.__preprocess0 = self.preprocess
				self.preprocess = self.__preprocess_double
		elif hasattr(self, 'preprocess_' + ot):
			self.preprocess = getattr(self, 'preprocess_' + ot)

		if hasattr(self, 'preprocess'):
			self.__preprocess2 = self.preprocess
			self.preprocess = self.__preprocess_and_prepare
		else:
			self.__after_preprocess()

		if hasattr(self, 'default_' + ot):
			self.default = getattr(self, 'default_' + ot)

	def __preprocess_double(self, content):
		""" Preprocess using the two methods. """

		ct = self.__preprocess0(content)
		if ct != None: content = ct; del ct
		ct = self.__preprocess1(content)
		if ct != None: content = ct; del ct
		return content

	def __preprocess_and_prepare(self, content):
		""" Preprocess and do the things after. """

		ret = self.__preprocess2(content)
		self.__after_preprocess()
		return ret

	def __out(self, name):
		""" Generic function to call two output functions of the same type. """

		getattr(self, '__' + name)()
		getattr(self, name + '_' + self.__output_type)()

	def __after_preprocess(self):
		ot = self.__output_type

		for otype in ('begin', 'content', 'end'):
			if hasattr(self, otype):
				if hasattr(self, otype + '_' + ot):
					setattr(self, '__' + otype, getattr(self, otype))
					setattr(self, otype, _p(self.__out, otype))
			elif hasattr(self, otype + '_' + ot):
				setattr(self, otype, getattr(self, otype + '_' + ot))

# ---
# Role-specific base tag classes.
# ---

class TextoutRawTag:
	pass

class TextoutBlockTag(TextoutTag):
	pass
class TextoutRawBlockTag(TextoutBlockTag, TextoutRawTag):
	pass

class TextoutParagraphTag(TextoutBlockTag):
	pass
class TextoutRawParagraphTag(TextoutParagraphTag, TextoutRawTag):
	pass

class TextoutInlineBlockTag(TextoutTag):
	pass
class TextoutRawInlineBlockTag(TextoutInlineBlockTag, TextoutRawTag):
	pass

class TextoutInlineTag(TextoutInlineBlockTag):
	pass
class TextoutRawInlineTag(TextoutInlineBlockTag, TextoutRawTag):
	pass

# End of file.