Class: Kernel

Inherits:
Object
  • Object
show all
Defined in:
motion-prime/core_ext/kernel.rb

Instance Method Summary collapse

Instance Method Details

#allocate_strong_references(key = nil) ⇒ Object 



61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'motion-prime/core_ext/kernel.rb', line 61

def allocate_strong_references(key = nil)
  unless self.respond_to?(:strong_references)
    Prime.logger.debug "User must define `strong_references` in `#{self.class.name}`"
    return false
  end

  refs = Array.wrap(self.strong_references).compact
  unless refs.present?
    Prime.logger.debug "`strong_references` are empty for `#{self.class.name}`"
    return false
  end

  @_strong_references ||= {}
  key ||= [@_strong_references.count, Time.now.to_i].join('_')
  @_strong_references[key] = refs.map(&:strong_ref)
  key
end

#allocated_references_released? ⇒ Boolean

Returns:

  • (Boolean) 


89
90
91
92
93
94
95
 
# File 'motion-prime/core_ext/kernel.rb', line 89

def allocated_references_released?
  unless self.respond_to?(:strong_references)
    Prime.logger.debug "User must define `strong_references` in `#{self.class.name}`"
    return false
  end
  @_strong_references.all? { |key, ref| @_strong_references.count; ref.retainCount == @_strong_references.count }
end

#benchmark(key, &block) ⇒ Object 



2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
# File 'motion-prime/core_ext/kernel.rb', line 2

def benchmark(key, &block)
  if Prime.env.development?
    t = Time.now
    result = block.call
    time = Time.now - t
    MotionPrime.benchmark_data[key] ||= {}
    MotionPrime.benchmark_data[key][:count] ||= 0
    MotionPrime.benchmark_data[key][:total] ||= 0
    MotionPrime.benchmark_data[key][:count] += 1
    MotionPrime.benchmark_data[key][:total] += time
    result
  else
    block.call
  end
end

#class_name_without_kvo ⇒ Object 



49
50
51
 
# File 'motion-prime/core_ext/kernel.rb', line 49

def class_name_without_kvo
  self.class.name.gsub(/^NSKVONotifying_/, '')
end

#clear_instance_variables(options = {}) ⇒ Object 



97
98
99
100
101
102
103
104
105
 
# File 'motion-prime/core_ext/kernel.rb', line 97

def clear_instance_variables(options = {})
  ivars = self.instance_variables
  excluded_ivars = Array.wrap(options[:except]).map(&:to_s)
  clear_block = proc { |ivar|
    next if excluded_ivars.include?(ivar[1..-1])
    self.instance_variable_set(ivar, nil)
  }.weak!
  ivars.each(&clear_block)
end

#inspect_hash(hash, depth = 0) ⇒ Object 



31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
# File 'motion-prime/core_ext/kernel.rb', line 31

def inspect_hash(hash, depth = 0)
  return '{}' if hash.blank?
  res = hash.map.with_index do |(key, value), i|
    k = "#{'  '*depth}#{i.zero? ? '{' : ' '}#{key.inspect}=>"
    pair = if value.is_a?(Hash)
      "#{k}\n#{inspect_hash(value, depth + 1)}"
    else
      [k, value.inspect].join
    end
    if i == hash.count-1
      pair + '}'
    else
      pair + ",\n"
    end
  end
  res.join
end

#pp(*attrs) ⇒ Object 



18
19
20
21
22
23
24
25
26
27
28
29
 
# File 'motion-prime/core_ext/kernel.rb', line 18

def pp(*attrs)
  attrs = [*attrs]
  results = attrs.map.with_index do |entity, i|
    if entity.is_a?(Hash)
      "#{"\n" unless attrs[i-1].is_a?(Hash)}#{inspect_hash(entity)}\n"
    else
      entity.inspect
    end
  end
  NSLog(results.compact.join(' '))
  attrs
end

#release_strong_references(key = nil) ⇒ Object 



79
80
81
82
83
84
85
86
87
 
# File 'motion-prime/core_ext/kernel.rb', line 79

def release_strong_references(key = nil)
  unless self.respond_to?(:strong_references)
    Prime.logger.debug "User must define `strong_references` in `#{self.class.name}`"
    return false
  end
  key ||= @_strong_references.keys.last
  @_strong_references.try(:delete, key)
  key
end

#strong_ref ⇒ Object 



57
58
59
 
# File 'motion-prime/core_ext/kernel.rb', line 57

def strong_ref
  self
end

#weak_ref ⇒ Object 



53
54
55
 
# File 'motion-prime/core_ext/kernel.rb', line 53

def weak_ref
  WeakRef.new(self)
end