text: """
  Cement dummy extension module.
  """
  
  from cement.core.mail import MailHandler
  from cement.core.output import OutputHandler
  from cement.core.template import TemplateHandler
  from cement.utils.misc import minimal_logger
  
  LOG = minimal_logger(__name__)
  
  
  class DummyOutputHandler(OutputHandler):
  
      """
      This class is an internal implementation of the
      :class:`cement.core.output.OutputHandlerBase` interface. It does not take
      any parameters on initialization, and does not actually output anything.
  
      """
  
      class Meta:
  
          """Handler meta-data"""
  
          #: The string identifier of this handler.
          label = "dummy"
  
          #: Whether or not to include ``dummy`` as an available to choice
          #: to override the ``output_handler`` via command line options.
          overridable = False
  
      def render(self, data, template=None, **kw):
          """
          This implementation does not actually render anything to output, but
          rather logs it to the debug facility.
  
          Args:
              data (dict): The data dictionary to render.
  
          Keyword Args:
              template (str): The template parameter is not used by this
                  implementation at all.
  
          """
          LOG.debug("not rendering any output to console")
          LOG.debug("DATA: %s" % data)
          return None
  
  
  class DummyTemplateHandler(TemplateHandler):
  
      """
      This class is an internal implementation of the
      :class:`cement.core.template.TemplateHandlerBase` interface. It does not
      take any parameters on initialization, and does not actually render
      anything.
  
      """
  
      class Meta:
  
          """Handler meta-data"""
  
          #: The string identifier of this handler.
          label = "dummy"
  
      def render(self, content, data, *args, **kw):
          """
          This implementation does not actually render anything, but
          rather logs it to the debug facility.
  
          Args:
              content (str): The content to render as dictionary
              data (dict): The data dictionary to render.
  
          """
          LOG.debug("CONTENT: %s" % content)
          LOG.debug("DATA: %s" % data)
          return None
  
      def copy(self, src, dest, data):
          """
          This implementation does not actually copy anything, but rather logs it
          to the debug facility.
  
          Args:
              src (str): The source template directory.
              dest (str): The destination directory.
              data (dict): The data dictionary to render with templates.
          """
          LOG.debug("COPY: {} -> {}".format(src, dest))
  
  
  class DummyMailHandler(MailHandler):
  
      """
      This class implements the :class:`cement.core.mail.IMail`
      interface, but is intended for use in development as no email is actually
      sent.
  
      Example:
  
      .. code-block:: python
  
          class MyApp(App):
              class Meta:
                  label = 'myapp'
                  mail_handler = 'dummy'
  
          with MyApp() as app:
              app.run()
  
              app.mail.send('This is my fake message',
                  subject='This is my subject',
                  to=['john@example.com', 'rita@example.com'],
                  from_addr='me@example.com',
                  )
  
      The above will print the following to console:
  
      .. code-block:: text
  
          ======================================================================
          DUMMY MAIL MESSAGE
          ----------------------------------------------------------------------
  
          To: john@example.com, rita@example.com
          From: me@example.com
          CC:
          BCC:
          Subject: This is my subject
  
          ---
  
          This is my fake message
  
          ----------------------------------------------------------------------
  
      **Configuration**
  
      This handler supports the following configuration settings:
  
       * **to** - Default ``to`` addresses (list, or comma separated depending
         on the ConfigHandler in use)
       * **from_addr** - Default ``from_addr`` address
       * **cc** - Default ``cc`` addresses (list, or comma separated depending
         on the ConfigHandler in use)
       * **bcc** - Default ``bcc`` addresses (list, or comma separated depending
         on the ConfigHandler in use)
       * **subject** - Default ``subject``
       * **subject_prefix** - Additional string to prepend to the ``subject``
  
  
      You can add these to any application configuration file under a
      ``[mail.dummy]`` section, for example:
  
      **~/.myapp.conf**
  
      .. code-block:: text
  
          [myapp]
  
          # set the mail handler to use
          mail_handler = dummy
  
  
          [mail.dummy]
  
          # default to addresses (comma separated list)
          to = me@example.com
  
          # default from address
          from = someone_else@example.com
  
          # default cc addresses (comma separated list)
          cc = jane@example.com, rita@example.com
  
          # default bcc addresses (comma separated list)
          bcc = blackhole@example.com, someone_else@example.com
  
          # default subject
          subject = This is The Default Subject
  
          # additional prefix to prepend to the subject
          subject_prefix = MY PREFIX >
  
      """
  
      class Meta:
  
          """Handler meta-data."""
  
          #: Unique identifier for this handler
          label = "dummy"
  
      def _get_params(self, **kw):
          params = {}
          for item in ["to", "from_addr", "cc", "bcc", "subject"]:
              config_item = self.app.config.get(self._meta.config_section, item)
              params[item] = kw.get(item, config_item)
  
          # also grab the subject_prefix
          params["subject_prefix"] = self.app.config.get(
              self._meta.config_section, "subject_prefix"
          )
  
          return params
  
      def send(self, body, **kw):
          """
          Mimic sending an email message, but really just print what would be
          sent to console.  Keyword arguments override configuration
          defaults (cc, bcc, etc).
  
          Args:
              body: The message body to send
  
          Keyword Args:
              to (list): List of recipients (generally email addresses)
              from_addr (str): Address (generally email) of the sender
              cc (list): List of CC Recipients
              bcc (list): List of BCC Recipients
              subject (str): Message subject line
  
          Returns:
              bool:``True`` if message is sent successfully, ``False`` otherwise
  
          Example:
  
              .. code-block:: python
  
                  # Using all configuration defaults
                  app.mail.send('This is my message body')
  
                  # Overriding configuration defaults
                  app.mail.send('My message body'
                      to=['john@example.com'],
                      from_addr='me@example.com',
                      cc=['jane@example.com', 'rita@example.com'],
                      subject='This is my subject',
                      )
  
          """
          # shorted config values
          params = self._get_params(**kw)
          msg = "\n" + "=" * 77 + "\n"
          msg += "DUMMY MAIL MESSAGE\n"
          msg += "-" * 77 + "\n\n"
          msg += "To: %s\n" % ", ".join(params["to"])
          msg += "From: %s\n" % params["from_addr"]
          msg += "CC: %s\n" % ", ".join(params["cc"])
          msg += "BCC: %s\n" % ", ".join(params["bcc"])
  
          if params["subject_prefix"] not in [None, ""]:
              msg += "Subject: {} {}\n\n---\n\n".format(
                  params["subject_prefix"], params["subject"]
              )
          else:
              msg += "Subject: %s\n\n---\n\n" % params["subject"]
          msg += body + "\n"
  
          msg += "\n" + "-" * 77 + "\n"
  
          print(msg)
          return True
  
  
  def load(app):
      app.handler.register(DummyOutputHandler)
      app.handler.register(DummyTemplateHandler)
      app.handler.register(DummyMailHandler)
  