Class: Object

Inherits:
BasicObject
Includes:
InstanceExecMethods, URI::Kernel
Defined in:
lib/standard/facets/uri.rb,
lib/core/facets/object/dup.rb,
lib/core/facets/object/replace.rb,
lib/supplemental/facets/nullclass.rb,
lib/core/facets/object/object_state.rb,
lib/core-uncommon/facets/kernel/instance_exec.rb

Overview

module Kernel

Defined Under Namespace

Modules: InstanceExecMethods

Instance Method Summary collapse

Methods included from URI::Kernel

#unuri, #uri

Instance Method Details

#clone? ⇒ Boolean

Returns:

  • (Boolean) 


23
 
# File 'lib/core/facets/object/dup.rb', line 23

def clone? ; true ; end

#dup! ⇒ Object

Override this in a child class if it cannot be dup’ed.

obj1 = Object.new
obj2 = obj1.dup!
obj2.equal?(obj1)    #=> false

CREDIT: Dan Kubb (extlib)



9
10
11
 
# File 'lib/core/facets/object/dup.rb', line 9

def dup!
  dup
end

#dup? ⇒ Boolean

Can you safely call #dup on this object?

Returns false for nil, false, true, symbols, and numbers; true otherwise.

Returns:

  • (Boolean) 


22
 
# File 'lib/core/facets/object/dup.rb', line 22

def dup?   ; true ; end

#instance_exec(*args, &block) ⇒ Object

Evaluate the block with the given arguments within the context of this object, so self is set to the method receiver.

From Mauricio’s eigenclass.org/hiki/bounded+space+instance_exec

This version has been borrowed from Rails for compatibility sake.

NOTE: This is not a common core extension (due to the use of thread.rb) and is not loaded automatically when using require 'facets'. However it is a core method in Ruby 1.9, so this only matters for users of Ruby 1.8.x or below.



24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/core-uncommon/facets/kernel/instance_exec.rb', line 24

def instance_exec(*args, &block)
  begin
    old_critical, Thread.critical = Thread.critical, true
    n = 0
    n += 1 while respond_to?(method_name = "__instance_exec#{n}")
    InstanceExecMethods.module_eval { define_method(method_name, &block) }
  ensure
    Thread.critical = old_critical
  end

  begin
    __send__(method_name, *args)
  ensure
    InstanceExecMethods.module_eval { remove_method(method_name) } rescue nil
  end
end

#null? ⇒ Boolean

Returns:

  • (Boolean) 


33
34
35
 
# File 'lib/supplemental/facets/nullclass.rb', line 33

def null?
  false
end

#object_state(data = nil) ⇒ Object

Get or set state of object. You can think of #object_state as an in-code form of marshalling.

class StateExample
  attr_reader :a, :b
  def initialize(a,b)
    @a, @b = a, b
  end
end

obj = StateExample.new(1,2)
obj.a  #=> 1
obj.b  #=> 2

obj.object_state  #=> {:a=>1, :b=>2}

obj.object_state(:a=>3, :b=>4)
obj.a  #=> 3
obj.b  #=> 4

For most object’s this is essentially the same as instance.to_h. But for data structures like Array and Hash it returns a snapshot of their contents, not the state of their instance variables. – TODO: Should this be in module Kernel ? ++



28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/core/facets/object/object_state.rb', line 28

def object_state(data=nil)
  if data
    instance_variables.each do |iv|
      name = iv.to_s.sub(/^[@]/, '').to_sym
      instance_variable_set(iv, data[name])
    end
  else
    data = {}
    instance_variables.each do |iv|
      name = iv.to_s.sub(/^[@]/, '').to_sym
      data[name] = instance_variable_get(iv)
    end
    data
  end
end

#replace(source) ⇒ Object

Replace state of object with the state of another object of the same class (or superclass).

class ReplaceExample
  attr_reader :a, :b
  def initialize(a,b)
    @a, @b = a, b
  end
end

obj1 = ReplaceExample.new(1,2)
obj1.a  #=> 1
obj1.b  #=> 2

obj2 = ReplaceExample.new(3,4)
obj2.a  #=> 3
obj2.b  #=> 4

obj1.replace(obj2)
obj1.a  #=> 3
obj1.b  #=> 4

This is very similar to instance.update, but it is limited by the class of objects, in the same manner as Array#replace.

Raises:

  • (ArgumentError) 


27
28
29
30
31
32
 
# File 'lib/core/facets/object/replace.rb', line 27

def replace(source)
  raise ArgumentError, "not a #{self.class} -- #{source}" unless source.is_a?(self.class)
  instance_variables.each do |iv|
    instance_variable_set(iv, source.instance_variable_get(iv))
  end
end

#try_dup ⇒ Object

Alternative name for #dup!



14
15
16
 
# File 'lib/core/facets/object/dup.rb', line 14

def try_dup
  dup!
end