Pretty-prints a censored options hash, if :verbose.
428117
def print_options
      return unless self[:verbose]

      Helper.log.info "Using these options:"
      # For ruby 2.5.0+
      censored_values.each do |key, value|
        print(key.inspect, "=>", value.inspect)
        puts ""
      end
      puts ""
    end
877911
def print_hash(key, value)
      if value.length > @width
        print_long_string value, "#{key}:"
      else
        print "#{key}:", value.cyan
      end
    end
69229
def print(formatted = nil)
      result = name
      unless version.nil?
        result += ", version #{version}"
      end
      if formatted
        result = "#{FORMATTING_STAR.colorize(:yellow)} #{result}"
      end
      result
    end
1289657
def _verbose_message(message, *args, **kwargs):
    """"""
    verbosity = kwargs.pop('verbosity', 1)
    if sys.flags.verbose >= verbosity:
        if not message.startswith(('#', 'import ')):
            message = '# ' + message
        print(message.format(*args), file=sys.stderr)
1235022
def _make_pretty_deprecated(deprecated):
    

    if deprecated != "":
        deprecated = "\n".join(map(lambda n: n[4:], deprecated.split("\n")))
        return "**Deprecated:**\n%s\n" % deprecated
1117238
public boolean print(boolean verbose) {

		String errors = formatErrors();

		if (errors != null) {
			System.err.println(errors);
		}

		if (verbose) {
			System.out.println(formatStats());
		}

		return (errors != null);
	}
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
53384
def pretty_print(pp)
      return super if custom_inspect_method_defined?
      pp.object_address_group(self) do
        if defined?(@attributes) && @attributes
          attr_names = self.class.attribute_names.select { |name| has_attribute?(name) }
          pp.seplist(attr_names, proc { pp.text "," }) do |attr_name|
            pp.breakable " "
            pp.group(1) do
              pp.text attr_name
              pp.text ":"
              pp.breakable
              value = _read_attribute(attr_name)
              value = inspection_filter.filter_param(attr_name, value) unless value.nil?
              pp.pp value
            end
          end
        else
          pp.breakable " "
          pp.text "not initialized"
        end
      end
    end
1212437
def _format_args():
        """"""
        if request and request.args.get('prettyprint'):
            return dict(
                indent=2,
                separators=(', ', ': '),
            )
        else:
            return dict(
                indent=None,
                separators=(',', ':'),
            )
21521
def pretty(self, indent=0, debug=False):
        
        debug_details = ''
        if debug:
            debug_details += '<isliteral=%r, iscanonical=%r>' % (self.isliteral, self.iscanonical)

        obj = "'%s'" % self.obj if isinstance(self.obj, basestring) else repr(self.obj)
        return (' ' * indent) + ('%s(%s%s)' % (self.__class__.__name__, debug_details, obj))
399820
def hide(options = {})
      attributes = {:style => "display:none"}

      if options.has_key?(:unless)
        return options[:unless] ? {} : attributes
      end

      if options.has_key?(:if)
        return options[:if] ? attributes : {}
      end

      attributes
    end
409009
def pretty_print(x, numchars):
    
    s = maybe_truncate(x, numchars)
    return s + ' ' * max(numchars - len(s), 0)
581020
def stripext (cmd, archive, verbosity, extension=""):
    """"""
    if verbosity >= 0:
        print(util.stripext(archive)+extension)
    return None
921701
def format_options(options):
    ''''''
    # split on one of the following tokens: ' -' or '[[' or ']]'
    lines = ['']
    for token in re.split(r'( -|\[\[|\]\])', options):
        if token in ['[[',']]']:
            lines.append(token)
            lines.append('')
        elif token == ' -':
            lines.append(token)
        else:
            lines[-1] += token
    # join all non-empty lines and wrap them into 'span'-tags
    return '<span style="display:block">' + '</span><span style="display:block">'.join(line for line in lines if line.strip()) + '</span>'
328005
def print(self, *args, **kwargs):
        '''
        
        '''
        if self._last_args and self._last_args.verbose:
            print(*args, **kwargs)
247963
function Printr(options) {
  options = options || {};
  options.out = options.out || process.stdout;
  options.err = options.err || process.stderr;
  options.prefix = options.prefix || '';
  this.options = options;
}
1267025
static function censor($str, array $censored, $replacement = '') {
        foreach ($censored as $bad) {
            $str = preg_replace("/$bad/i", $replacement, $str);
        }

        return $str;
    }