Class: Object

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

Overview

:nodoc:

Defined Under Namespace

Modules: InstanceExecMethods

Instance Method Summary collapse

Methods included from URI::Kernel

#unuri, #uri

Instance Method Details

#against(*msg, &blk) ⇒ Object

Objectified message or block application. Only a message or a block can be given, not both.

msg - method and arguments [Array] blk - procedure block [Proc]

Examples

a = [1,2,3,4,5]
c = a.against(:>, 2)
c.select  #=> [3,4,5]

a = [1,2,3,4,5]
c = a.against(:>)
c.select(2)  #=> [3,4,5]

Returns [Functor]

TODO: Better name for this method?

Raises:

  • (ArgumentError) 


25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/standard/facets/against.rb', line 25

def against(*msg, &blk)
  raise ArgumentError, "too many arguments" if blk && !msg.empty?

 this = self

  blk = ::Proc.new{ |x,*a| x.__send__(*msg, *a) } unless blk

  #if blk
  Functor.new do |m, *a, &b|
	  if b
	    b2 = ::Proc.new{ |*x| blk.call(*b.call(*x), *a) }
      else
        b2 = blk
	  end
	  this.__send__(m, &b2)
  end
  #else
 #	Functor.new do |m, *a, &b|
 #		if b
 #		  b2 = ::Proc.new{ |*x| b.call(*x).__send__(*msg, *a) }
 #		else
 #		  b2 = ::Proc.new{ |x| x.__send__(*msg, *a) }
 #		end
 #		this.__send__(m, &b2)
 #	end
  #end
end

#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.

Uncommon:

  • require ‘facets/kernel/instance_exec’



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

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

#itself ⇒ Object

An identity method that provides access to an object’s ‘self’.

Example

[1,2,3,4,5,1,2,2,3].group_by(&:itself)
#=> {1=>[1, 1], 2=>[2, 2, 2], 3=>[3, 3], 4=>[4], 5=>[5]}

CREDIT: Michael Kohl



12
13
14
 
# File 'lib/core/facets/object/itself.rb', line 12

def itself
  self
end

#null? ⇒ Boolean

Returns:

  • (Boolean) 


33
34
35
 
# File 'lib/standard/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

#try_dup ⇒ Object

Alternative name for #dup!



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

def try_dup
  dup!
end