Outputs a formatted-purple section message.
 @param [String] m The message to output
 @return [void]
190942
def section(m)
      puts _word_wrap(m, '---> ').purple
      @targets.each { |_, t| t.section(m) }
    end
208512
def paint(color_name, msg)
      if @colors == false || @colors == nil && (Util::OS.windows? || !$stderr.tty?)
        msg
      else
        COLORS[color_name] + msg + CLEAR
      end
    end
1262655
def menu text, &block
      m = Menu.new text, &block 
      m.color = @color
      m.bgcolor = @bgcolor
      add m
      return m
    end
863366
def _color(self, color, msg):
        
        if self.useColor:
            return '{0}{1}{2}'.format(color, msg, self.RESET_SEQ)
        else:
            return msg
1241005
def method_missing(method_name, *args)
      if Color::X11Named.color_names.include?(method_name) && args.empty?
        color(method_name)
      else
        super
      end
    end
1143504
def plain_output(message, color)
      if @options['without-color']
        puts message
      else
        puts Colorize.send(color, message)
      end
    end
1351113
def format(options = {})
      options = options.dup
      o = {}
      o[k = :color] = (v = options.delete(k)).nil?? true : v
      raise ArgumentError, "Unknown option(s): #{options.inspect}" if not options.empty?

      require_valid

      Colorize.colorize *[
        (own?? [[:list_method, :own_marker], OWN_MARKER[0]] : [[:list_method, :not_own_marker], OWN_MARKER[1]]),
        [[:list_method, :obj_module_name], obj_module_name],
        ([[:list_method, :owner_name], "(#{owner_name})"] if not own?),
        [[:list_method, :access], access],
        [[:list_method, :name], method_name],
        ([[:list_method, :visibility], " [#{visibility}]"] if not public?),
        [[:reset]],
      ].compact.flatten(1).reject {|v| v.is_a? Array and not o[:color]}
    end
735995
def _print(self, msg, color=None, arrow=False, indent=None):
        
        if color:
            msg = colored(msg, color)

        if arrow:
            msg = colored('===> ', 'blue') + msg

        if indent:
            msg = ('     ' * indent) + msg

        print(msg)

        return msg
1216183
def say(message = '', color = nil, new_line = nil)
      Strainer.log.info(message.gsub(/\e\[\d+[;\d]*m/, ''))

      return if quiet?
      super(message, color)
    end
774241
def method_missing(m, *args, &block)
      if m.to_s =~ /^with_(.+)$/
        with($1.to_sym => args.first)
        self
      else
        super
      end
    end
1064992
def extended_message
    @extended_message ||= begin
      sections = []
      
      sections << details_section unless details_section.nil?
      sections << context_section unless context_section.nil?
      
      joined = sections.join "\n\n"
    end
  end
488602
def message(msg, indent=False, mtype='standard', caption=False):
    """"""
    if caption:
        msg = '\n' + msg + '\n' + '-'*len(msg) + '\n'
    if mtype == 'warning':
        msg = colorlog('Warning:  ' + msg, 'yellow')
    if mtype == 'error':
        msg = colorlog('Error:  ' + msg, 'red')
    if mtype == 'debug':
        msg = colorlog('Debug:  ' + msg, 'pink')
    if mtype == 'info':
        msg = colorlog('Info:  ' + msg, 'green')
    if indent:
        msg = '  ' + msg
    sys.stderr.write(msg)
198178
def output!
      output  = "#{Time.now} | "
      output += "[#{@namespace.gsub('_', ' ')}] " unless @namespace.nil?
      output += @message
      puts output if defined?(Logg::ALWAYS_PUTS) && Logg::ALWAYS_PUTS
      return output
    end
343217
def text(*val)
      if val.empty?
        return @text
      else
        s = val[0].dup
        s = s.to_s if !s.is_a? String  # 2009-01-15 17:32 
        if (( ix = s.index('&')) != nil)
          s.slice!(ix,1)
          @underline = ix #unless @form.nil? # this setting a fake underline in messageboxes
          @text = s # mnemo needs this for setting description
          mnemonic s[ix,1]
        end
        @text = s
      end
      return self 
    end
707638
def message(message, verbose_prefix = '', relative_indentation = 2)
      message = verbose_prefix + message if verbose?
      puts_indented message if verbose?

      @indentation_level += relative_indentation
      yield if block_given?
      @indentation_level -= relative_indentation
    end
1067594
def summary_print(formatted = false)
      errors = 0
      warnings = 0
      findings.each { |finding|
        if finding.failure
          errors += 1
        else
          warnings += 1
        end
      }
      if errors == 0 && warnings == 0
        result = "#{FORMATTING_CHECKMARK} PASSED with no warning".colorize(:green)
      elsif errors == 0
        result = "#{FORMATTING_WARNING} PASSED with #{warnings} warning".colorize(:yellow)
      elsif warnings == 0
        result = "#{FORMATTING_BALL} FAILED with #{errors} error".colorize(:red)
      else
        result = "#{FORMATTING_BALL} FAILED with #{errors} error and #{warnings} warning".colorize(:red)
      end
      if formatted
        result
      else
        result[result.index(' ') + 1..result.length]
      end
    end
880694
def format(self):
        
        _bold = bold
        if not self.pretty:
            _bold = lambda x: x
        # Attach memory address and return
        _attrs = self._format_attrs()
        self.data = "<{}.{}({}){}>{}".format(
            self.obj.__module__ if hasattr(self.obj, "__module__") \
                else "__main__",
            _bold(self.obj.__class__.__name__),
            _attrs,
            ":{}".format(hex(id(self.obj))) if self.address else "",
            _break+self.supplemental if self.supplemental else "")
        return stdout_encode(self.data)