pretty-prints a representation this JSI to the given printer
 @return [void]
516089
def pretty_print(q)
      q.instance_exec(self) do |obj|
        text "\#<#{obj.class.to_s}"
        group_sub {
          nest(2) {
            breakable ' '
            pp obj.instance
          }
        }
        breakable ''
        text '>'
      end
    end
570372
def json_pretty_print(item = nil)
      FFI_Yajl::Encoder.new(pretty: true, validate_utf8: false).encode(item || @data)
    end
572806
def printer(self):
        """"""
        for key in self.statediag:
            if key.trans is not None and len(key.trans) > 0:
                print '****** ' + repr(key.id) + '(' + repr(key.type)\
                      + ' on sym ' + repr(key.sym) + ') ******'
                print key.trans
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
432133
def pretty_print(self, warnings=False):
        
        msg = []
        if (warnings) and (len(self.warnings) > 0):
            msg.append(u"Warnings:")
            for warning in self.warnings:
                msg.append(u"  %s" % warning)
        if len(self.errors) > 0:
            msg.append(u"Errors:")
            for error in self.errors:
                msg.append(u"  %s" % error)
        return u"\n".join(msg)
650167
def pretty_print(n):
    """"""
    if type(n) != int:
        return n

    ret = []
    n = str(n)
    for i in range(len(n) - 1, -1, -1):
        ret.append(n[i])
        if (len(n) - i) % 3 == 0:
            ret.append(',')
    ret.reverse()
    return ''.join(ret[1:]) if ret[0] == ',' else ''.join(ret)
691934
def prettyPrintPacket(ctrl_table):
	
	print('---------------------------------------')
	print("{:.<29} {}".format('id', ctrl_table['id']))
	ctrl_table.pop('id')
	for key, value in ctrl_table.items():
		print("{:.<29} {}".format(key, value))
539083
function BindExpression(node, print) {
  print.plain(node.object);
  this.push("::");
  print.plain(node.callee);
}
526586
def pretty_print_table_instance(table):
    """"""
    assert isinstance(table, Table)

    def pretty_print_row(styled, plain):
        """Pretty print a row."""
        click.secho(
            " | ".join(
                v + " " * (table.column_widths[k] - len(plain[k]))
                for k, v in enumerate(styled)
            )
        )

    pretty_print_row(table.headers, table.plain_headers)
    for k, row in enumerate(table.rows):
        pretty_print_row(row, table.plain_rows[k])
630286
def print
      result = "in #{path}"
      if !begin_line.nil? && !end_line.nil?
        if begin_line != end_line
          if !begin_column.nil? && !end_column.nil?
            result += ", line #{begin_line}:#{begin_column} to line #{end_line}:#{end_column}"
          elsif !begin_column.nil? && end_column.nil?
            result += ", line #{begin_line}:#{begin_column} to line #{end_line}"
          elsif begin_column.nil? && !end_column.nil?
            result += ", line #{begin_line} to line #{end_line}:#{end_column}"
          else
            result += ", lines #{begin_line}-#{end_line}"
          end
        else
          if begin_column.nil?
            result += ", line #{begin_line}"
          else
            result += ", line #{begin_line}:#{begin_column}"
            result += "-#{end_column}" unless end_column.nil?
          end
        end
      end
      result
    end
136752
def pretty_print_table(headers, rows):
    """"""
    table = make_table(headers=headers, rows=rows)
    pretty_print_table_instance(table)
1203518
def on_print(self, node):    # ('dest', 'values', 'nl')
        
        dest = self.run(node.dest) or self.writer
        end = ''
        if node.nl:
            end = '\n'
        out = [self.run(tnode) for tnode in node.values]
        if out and len(self.error) == 0:
            self._printer(*out, file=dest, end=end)
1320979
def to_definition(only: nil, except: nil, context: {})
      GraphQL::Schema::Printer.print_schema(self, only: only, except: except, context: context)
    end
1139271
def _print(self, *args):
        
        string = u" ".join(args) + '\n'
        self.fobj.write(string)
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
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
345916
def pprint(to_be_printed):
    """"""
    try:
        import pprint as pp
        # generate an instance PrettyPrinter
        # pp.PrettyPrinter().pprint(to_be_printed)
        pp.pprint(to_be_printed)
    except ImportError:
        if isinstance(to_be_printed, dict):
            print('{')
            for k, v in to_be_printed.items():
                print("'" + k + "'" if isinstance(k, basestring) else k,
                      ': ',
                      "'" + v + "'" if isinstance(k, basestring) else v,
                      sep="")
            print('}')
        else:
            print('could not import pprint module, appling regular print')
            print(to_be_printed)