Module | PP::PPMethods
In: | pp.rb

### Methods

comma_breakable guard_inspect_key object_address_group object_group pp pp_hash pp_object seplist

### Constants

InspectKey | = | :__inspect_key__

### Public Instance methods

comma_breakable()

A convenience method which is same as follows:

      text ','
      breakable

[Source]

    # File pp.rb, line 149
        def comma_breakable
          text ','
          breakable
        end

guard_inspect_key() {|| ...}

[Source]

    # File pp.rb, line 96
        def guard_inspect_key
          if Thread.current[InspectKey] == nil
            Thread.current[InspectKey] = []
          end

          save = Thread.current[InspectKey]

          begin
            Thread.current[InspectKey] = []
            yield
          ensure
            Thread.current[InspectKey] = save
          end
        end

object_address_group(obj, &block)

[Source]

    # File pp.rb, line 139
        def object_address_group(obj, &block)
          id = "%x" % (obj.__id__ * 2)
          id.sub!(/\Af(?=[[:xdigit:]]{2}+\z)/, '') if id.sub!(/\A\.\./, '')
          group(1, "\#<#{obj.class}:0x#{id}", '>', &block)
        end

object_group(obj) {|| ...}

A convenience method which is same as follows:

      group(1, '#<' + obj.class.name, '>') { ... }

[Source]

    # File pp.rb, line 135
        def object_group(obj, &block) # :yield:
          group(1, '#<' + obj.class.name, '>', &block)
        end

pp(obj)

Adds `obj` to the pretty printing buffer using Object#pretty_print or Object#pretty_print_cycle.

Object#pretty_print_cycle is used when `obj` is already printed, a.k.a the object reference chain has a cycle.

[Source]

    # File pp.rb, line 116
        def pp(obj)
          id = obj.__id__

          if Thread.current[InspectKey].include? id
            group {obj.pretty_print_cycle self}
            return
          end

          begin
            Thread.current[InspectKey] << id
            group {obj.pretty_print self}
          ensure
            Thread.current[InspectKey].pop unless PP.sharing_detection
          end
        end

pp_hash(obj)

[Source]

    # File pp.rb, line 206
        def pp_hash(obj)
          group(1, '{', '}') {
            seplist(obj, nil, :each_pair) {|k, v|
              group {
                pp k
                text '=>'
                group(1) {
                  breakable ''
                  pp v
                }
              }
            }
          }
        end

pp_object(obj)

[Source]

    # File pp.rb, line 191
        def pp_object(obj)
          object_address_group(obj) {
            seplist(obj.pretty_print_instance_variables, lambda { text ',' }) {|v|
              breakable
              v = v.to_s if Symbol === v
              text v
              text '='
              group(1) {
                breakable ''
                pp(obj.instance_eval(v))
              }
            }
          }
        end

seplist(list, sep=nil, iter_method=:each) {|element| ...}

Adds a separated list. The list is separated by comma with breakable space, by default.

seplist iterates the `list` using `iter_method`. It yields each object to the block given for seplist. The procedure `separator_proc` is called between each yields.

If the iteration is zero times, `separator_proc` is not called at all.

If `separator_proc` is nil or not given, +lambda { comma_breakable }+ is used. If `iter_method` is not given, :each is used.

For example, following 3 code fragments has similar effect.

      q.seplist([1,2,3]) {|v| xxx v }

      q.seplist([1,2,3], lambda { comma_breakable }, :each) {|v| xxx v }

      xxx 1
      q.comma_breakable
      xxx 2
      q.comma_breakable
      xxx 3

[Source]

    # File pp.rb, line 178
        def seplist(list, sep=nil, iter_method=:each) # :yield: element
          sep ||= lambda { comma_breakable }
          first = true
          list.__send__(iter_method) {|*v|
            if first
              first = false
            else
              sep.call
            end
            yield(*v)
          }
        end

[Validate]