# module PP::PPMethods

`Module` that defines helper methods for pretty_print.

### Public Instance Methods

check_inspect_key (id)
Source

    # File lib/pp.rb, line 169
    def check_inspect_key(id)
      Thread.current[:__recursive_key__] &&
      Thread.current[:__recursive_key__][:inspect] &&
      Thread.current[:__recursive_key__][:inspect].include?(id)
    end

Check whether the object_id `id` is in the current buffer of objects to be pretty printed. Used to break cycles in chains of objects to be pretty printed.

comma_breakable ()
Source

    # File lib/pp.rb, line 232
    def comma_breakable
      text ','
      breakable
    end

A convenience method which is same as follows:

    text ','
    breakable

guard_inspect_key () { || ... }
Source

    # File lib/pp.rb, line 147
    def guard_inspect_key
      if Thread.current[:__recursive_key__] == nil
        Thread.current[:__recursive_key__] = {}.compare_by_identity
      end

      if Thread.current[:__recursive_key__][:inspect] == nil
        Thread.current[:__recursive_key__][:inspect] = {}.compare_by_identity
      end

      save = Thread.current[:__recursive_key__][:inspect]

      begin
        Thread.current[:__recursive_key__][:inspect] = {}.compare_by_identity
        yield
      ensure
        Thread.current[:__recursive_key__][:inspect] = save
      end
    end

Yields to a block and preserves the previous set of objects being printed.

object_address_group (obj, &block)
Source

    # File lib/pp.rb, line 222
    def object_address_group(obj, &block)
      str = Kernel.instance_method(:to_s).bind_call(obj)
      str.chomp!('>')
      group(1, str, '>', &block)
    end

A convenience method, like `object_group`, but also reformats the Object’s object_id.

object_group (obj) { || ... }
Source

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

A convenience method which is same as follows:

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

pop_inspect_key (id)
Source

    # File lib/pp.rb, line 182
    def pop_inspect_key(id)
      Thread.current[:__recursive_key__][:inspect].delete id
    end

Removes an object from the set of objects being pretty printed.

pp (obj)
Source

    # File lib/pp.rb, line 191
    def pp(obj)
      # If obj is a Delegator then use the object being delegated to for cycle
      # detection
      obj = obj.__getobj__ if defined?(::Delegator) and ::Delegator === obj

      if check_inspect_key(obj)
        group {obj.pretty_print_cycle self}
        return
      end

      begin
        push_inspect_key(obj)
        group do
          obj.pretty_print self
        rescue NoMethodError
          text Kernel.instance_method(:inspect).bind_call(obj)
        end
      ensure
        pop_inspect_key(obj) unless PP.sharing_detection
      end
    end

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.

pp_hash (obj)
Source

    # File lib/pp.rb, line 291
    def pp_hash(obj)
      group(1, '{', '}') {
        seplist(obj, nil, :each_pair) {|k, v|
          group {
            pp_hash_pair k, v
          }
        }
      }
    end

A pretty print for a `Hash`

pp_hash_pair (k, v)
Source

    # File lib/pp.rb, line 303
    def pp_hash_pair(k, v)
      if Symbol === k
        sym_s = k.inspect
        if sym_s[1].match?(/["$@!]/) || sym_s[-1].match?(/[%&*+\-\/<=>@\]^`|~]/)
          text "#{k.to_s.inspect}:"
        else
          text "#{k}:"
        end
      else
        pp k
        text ' '
        text '=>'
      end
      group(1) {
        breakable
        pp v
      }
    end

A pretty print for a pair of `Hash`

pp_object (obj)
Source

    # File lib/pp.rb, line 275
    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

A present standard failsafe for pretty printing any given `Object`

push_inspect_key (id)
Source

    # File lib/pp.rb, line 177
    def push_inspect_key(id)
      Thread.current[:__recursive_key__][:inspect][id] = true
    end

Adds the object_id `id` to the set of objects being pretty printed, so as to not repeat objects.

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

    # File lib/pp.rb, line 261
    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
        RUBY_VERSION >= "3.0" ? yield(*v, **{}) : yield(*v)
      }
    end

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 { q.comma_breakable }, :each) {|v| xxx v }

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