Module: PP::PPMethods

Included in:
PP, SingleLine
Defined in:
opal/stdlib/pp.rb

Instance Method Summary collapse

Instance Method Details

#check_inspect_key(id) ⇒ Object

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.



132
133
134
135
136
 
# File 'opal/stdlib/pp.rb', line 132

def check_inspect_key(id)
  Thread.current[:__recursive_key__] &&
  Thread.current[:__recursive_key__][:inspect] &&
  Thread.current[:__recursive_key__][:inspect].include?(id)
end

#comma_breakable ⇒ Object

A convenience method which is same as follows:

text ',' breakable



207
208
209
210
 
# File 'opal/stdlib/pp.rb', line 207

def comma_breakable
  text ','
  breakable
end

#guard_inspect_key ⇒ Object

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



110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
 
# File 'opal/stdlib/pp.rb', line 110

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

#object_address_group(obj, &block) ⇒ Object

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



197
198
199
200
201
 
# File 'opal/stdlib/pp.rb', line 197

def object_address_group(obj, &block)
  str = Kernel.instance_method(:to_s).bind_call(obj)
  str = str.chomp('>')
  group(1, str, '>', &block)
end

#object_group(obj, &block) ⇒ Object

A convenience method which is same as follows:

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



191
192
193
 
# File 'opal/stdlib/pp.rb', line 191

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

#pop_inspect_key(id) ⇒ Object

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



145
146
147
 
# File 'opal/stdlib/pp.rb', line 145

def pop_inspect_key(id)
  Thread.current[:__recursive_key__][:inspect].delete id
end

#pp(obj = undefined) ⇒ Object

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.



154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
 
# File 'opal/stdlib/pp.rb', line 154

def pp(obj = undefined)
  # Opal: consider JS-native variables:
  %x{
    if (obj === null) {
      #{text "null"}
      #{return}
    }
    else if (obj === undefined) {
      #{text "undefined"}
      #{return}
    }
    else if (obj.$$class === undefined) {
      #{text `Object.prototype.toString.apply(obj)`}
      #{return}
    }
  }

  # If obj is a Delegator then use the object being delegated to for cycle
  # detection
  obj = obj.__getobj__ if defined?(::Delegator) and obj.is_a?(::Delegator)

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

  begin
    push_inspect_key(obj)
    group {obj.pretty_print self}
  ensure
    pop_inspect_key(obj) unless PP.sharing_detection
  end
end

#pp_hash(obj) ⇒ Object

A pretty print for a Hash



266
267
268
269
270
271
272
273
274
275
276
277
278
279
 
# File 'opal/stdlib/pp.rb', line 266

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) ⇒ Object

A present standard failsafe for pretty printing any given Object



250
251
252
253
254
255
256
257
258
259
260
261
262
263
 
# File 'opal/stdlib/pp.rb', line 250

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

#push_inspect_key(id) ⇒ Object

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



140
141
142
 
# File 'opal/stdlib/pp.rb', line 140

def push_inspect_key(id)
  Thread.current[:__recursive_key__][:inspect][id] = true
end

#seplist(list, sep = nil, iter_method = :each) ⇒ Object

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



236
237
238
239
240
241
242
243
244
245
246
247
 
# File 'opal/stdlib/pp.rb', line 236

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