Class: Object

Inherits:
BasicObject
Defined in:
lib/y_support/unicode.rb,
lib/y_support/try.rb,
lib/y_support/respond_to.rb,
lib/y_support/null_object.rb,
lib/y_support/local_object.rb,
lib/y_support/inert_recorder.rb,
lib/y_support/core_ext/object/misc.rb,
lib/y_support/typing/object/typing.rb,
lib/y_support/core_ext/object/inspection.rb

Overview

Object class is patched with #LocalObject (alias L!) constructor, and #local_object?, alias #ℓ? inquirer.

Instance Method Summary collapse

Instance Method Details

#aA_blank(what_is_receiver = insp) ⇒ Object

Fails with ArgumentError unless the ActiveSupport method #blank returns true for the receiver.



138
139
140
 
# File 'lib/y_support/typing/object/typing.rb', line 138

def aA_blank what_is_receiver=insp
  tap { blank? or fail ArgumentError, "%s not blank".X!( what_is_receiver ) }
end

#aA_present(what_is_receiver = insp) ⇒ Object

Fails with ArgumentError unless the ActiveSupport method #present returns true for the receiver.



145
146
147
148
149
 
# File 'lib/y_support/typing/object/typing.rb', line 145

def aA_present what_is_receiver=insp
  tap {
    present? or fail ArgumentError, "%s not present".X!( what_is_receiver )
  }
end

#aT(what_is_receiver = insp, how_comply = nil, &b) ⇒ Object

This method takes a block and fails with TypeError, unless the receiver fullfills the block criterion. Optional arguments customize customize the error message. First optional argument describes the receiver, the second one describes the tested duck type. If the criterion block takes at least one argument, the receiver is passed to it. If the criterion block takes no arguments (arity 0), it is executed inside the singleton class of the receiver (using #instance_exec method). If no block is given, it is checked, whether the object is truey.



49
50
51
52
53
54
 
# File 'lib/y_support/typing/object/typing.rb', line 49

def aT what_is_receiver=insp, how_comply=nil, &b
  return tap { fail TypeError unless self } unless b
  return self if b.( self )
  m = "%s fails " + ( how_comply ? "to #{how_comply}" : "its check" )
  fail TypeError, m.X!( what_is_receiver ) 
end

#aT_blank(what_is_receiver = insp) ⇒ Object

Fails with TypeError unless activesupport’s #blank returns true for the receiver.



124
125
126
 
# File 'lib/y_support/typing/object/typing.rb', line 124

def aT_blank what_is_receiver=insp
  tap { blank? or fail TypeError, "%s not blank".X!( what_is_receiver ) }
end

#aT_complies(klass, what_is_receiver = insp) ⇒ Object Also known as: aT_class_complies

Fails with TypeError unless the receiver declares compliance with the given class, or is a descendant of that class. Second optional argument customizes the error message (receiver description).



85
86
87
88
 
# File 'lib/y_support/typing/object/typing.rb', line 85

def aT_complies klass, what_is_receiver=insp
  return self if class_complies? klass
  fail TypeError, "%s does not comply with #{klass}".X!( what_is_receiver )
end

#aT_equal(other, what_is_receiver = insp, what_is_other = nil) ⇒ Object

Fails with TypeError unless the receiver, according to #== method, is equal to the argument. Two more optional arguments customize the error message (receiver description and the description of the other object).



105
106
107
108
109
 
# File 'lib/y_support/typing/object/typing.rb', line 105

def aT_equal other, what_is_receiver=insp, what_is_other=nil
  return self if self == other
  wo = what_is_other || "the prescribed value (#{other.insp})"
  fail TypeError, "%s must be equal to %s".X!( [ what_is_receiver, wo ] )
end

#aT_kind_of(klass, what_is_receiver = insp) ⇒ Object Also known as: aT_is_a

Fails with TypeError unless the receiver is of the prescribed class. Second optional argument customizes the error message (receiver description).



75
76
77
78
 
# File 'lib/y_support/typing/object/typing.rb', line 75

def aT_kind_of klass, what_is_receiver=insp
  return self if is_a? klass
  fail TypeError, "%s not a #{klass}".X!( what_is_receiver )
end

#aT_not(what_is_receiver = insp, how_comply = nil, &b) ⇒ Object

This method takes a block and fails with TypeError, unless the receiver causes the supplied block to return falsey value. Optional arguments customize customize the error message. First optional argument describes the receiver, the second one describes the tested duck type. If the criterion block takes at least one argument (or more arguments), the receiver is passed to it. If the criterion block takes no arguments (arity 0), it is executed inside the singleton class of the receiver (using #instance_exec method). If no block is given, it is checked, whether the object is falsey.



65
66
67
68
69
70
 
# File 'lib/y_support/typing/object/typing.rb', line 65

def aT_not what_is_receiver=insp, how_comply=nil, &b
  return tap { fail TypeError if self } unless b
  return self unless b.( self )
  m = how_comply ? "%s must not #{how_comply}" : "%s fails its check"
  fail TypeError, m.X!( what_is_receiver )
end

#aT_not_equal(other, what_is_receiver = insp, what_is_other = nil) ⇒ Object

Fails with TypeError unless the receiver, according to #== method, differs from to the argument. Two more optional arguments customize the error message (receiver description and the description of the other object).



115
116
117
118
119
 
# File 'lib/y_support/typing/object/typing.rb', line 115

def aT_not_equal other, what_is_receiver=insp, what_is_other=nil
  return self unless self == other
  wo = what_is_other || "the prescribed value (#{other.insp})"
  fail TypeError, "%s must not == %s".X!( [ what_is_receiver, wo ] )
end

#aT_present(what_is_receiver = insp) ⇒ Object

Fails with TypeError unless activesupport’s #present returns true for the receiver.



131
132
133
 
# File 'lib/y_support/typing/object/typing.rb', line 131

def aT_present what_is_receiver=insp
  tap { present? or fail TypeError, "%s not present".X!( what_is_receiver ) }
end

#aT_respond_to(method_name, what_is_receiver = insp) ⇒ Object Also known as: aT_responds_to

Fails with TypeError unless the receiver responds to the given method. Second optional argument customizes the error message (receiver description).



94
95
96
97
98
 
# File 'lib/y_support/typing/object/typing.rb', line 94

def aT_respond_to method_name, what_is_receiver=insp
  return self if respond_to? method_name
  fail TypeError,
       "%s does not respond to '#{method_name}'".X!( what_is_receiver )
end

#class_compliance ⇒ Object

Class compliance (declared class compliance + ancestors).



22
23
24
 
# File 'lib/y_support/typing/object/typing.rb', line 22

def class_compliance
  singleton_class_or_class.compliance
end

#class_complies?(klass) ⇒ Boolean

Class compliance inquirer (declared compliance + class ancestors).

Returns:

  • (Boolean) 


10
11
12
 
# File 'lib/y_support/typing/object/typing.rb', line 10

def class_complies? klass
  singleton_class_or_class.complies? klass
end

#class_declares_compliance?(klass) ⇒ Boolean

Declared class compliance.

Returns:

  • (Boolean) 


16
17
18
 
# File 'lib/y_support/typing/object/typing.rb', line 16

def class_declares_compliance? klass
  singleton_class_or_class.declares_compliance? klass
end

#declare_class_compliance!(klass) ⇒ Object

Declaration of class compliance.



34
35
36
 
# File 'lib/y_support/typing/object/typing.rb', line 34

def declare_class_compliance! klass
  singleton_class_or_class.declare_compliance! klass
end

#declared_class_compliance ⇒ Object

Declared class compliance.



28
29
30
 
# File 'lib/y_support/typing/object/typing.rb', line 28

def declared_class_compliance
  singleton_class_or_class.declared_compliance
end

#InertRecorder(*args, &block) ⇒ Object

InertRecorder constructor.



50
 
# File 'lib/y_support/inert_recorder.rb', line 50

def InertRecorder *args, █ InertRecorder.new *args, &block end

#insp ⇒ Object

Constructs the string “#Object.selfself.class:#self”. Useful for inspection.



4
5
6
 
# File 'lib/y_support/core_ext/object/inspection.rb', line 4

def insp
  "#{self}:#{self.class}"
end

#local_object?(signature = nil) ⇒ Boolean Also known as: ℓ?

False for normal objects, overriden in the LocalObject class.

Returns:

  • (Boolean) 


41
 
# File 'lib/y_support/local_object.rb', line 41

def local_object? signature=nil; false end

#LocalObject(signature = caller_locations( 1, 1 )[0].label) ⇒ Object Also known as: L!

LocalObject constructor.



34
35
36
 
# File 'lib/y_support/local_object.rb', line 34

def LocalObject signature=caller_locations( 1, 1 )[0].label
  LocalObject.new signature
end

#Maybe(object, null_object_signature = nil) ⇒ Object

Converts #nil?-positive objects to a NullObject. Second optional argument specifies the signature of the null object to be created.



89
90
91
 
# File 'lib/y_support/null_object.rb', line 89

def Maybe object, null_object_signature=nil
  object.nil? ? NullObject.new( null_object_signature ) : object
end

#Null(signature = nil) ⇒ Object

NullObject constructor.



95
 
# File 'lib/y_support/null_object.rb', line 95

def Null( signature=nil ); NullObject.new signature end

#null_object?(signature = nil) ⇒ Boolean Also known as: null?

Always false for ordinary objects, overriden in NullObject instances.

Returns:

  • (Boolean) 


83
 
# File 'lib/y_support/null_object.rb', line 83

def null_object? signature=nil; false end

#param_class(hash, with: {}) ⇒ Object

Constructs heir classes (parametrized subclasses) of the supplied modules (classes) and makes them available under specified getters. Expects a hash of pairs { symbol: class }, and a hash of parameters with which to parametrize the modules (classes). The methods guards against collisions in the subclass getter symbols, rasing NameError should these shadow or overwrite existing methods.



51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/y_support/core_ext/object/misc.rb', line 51

def param_class( hash, with: {} )
  hash.each { |ß, m|
    case m
    when Class then
      parametrized_subclass = m.parametrize( with )
      set_attr_with_readers( ß => parametrized_subclass )
    when Module then
      heir_class = m.heir_class( with )
      set_attr_with_readers( ß => heir_class )
    else fail TypeError, "#{m} must be a module or a class!"
    end
  }
  return nil
end

#param_class!(hash, with: {}) ⇒ Object

Like #param_class, but it shadows or overwrites existing methods colliding with the getters of the parametrized classes. See +#set_attr_with_readers!“ for full explanation of the shadowing / overwriting behavior.



70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
# File 'lib/y_support/core_ext/object/misc.rb', line 70

def param_class!( hash, with: {} )
  hash.each { |ß, m|
    case m
    when Class then
      parametrized_subclass = m.parametrize( with )
      set_attr_with_readers!( ß => parametrized_subclass )
    when Module then
      heir_class = m.heir_class( with )
      set_attr_with_readers!( ß => heir_class )
    else fail TypeError, "#{m} must be a module or a class!"
    end
  }
  return nil
end

#RespondTo(method) ⇒ Object

RespondTo constructor.



17
 
# File 'lib/y_support/respond_to.rb', line 17

def RespondTo method; RespondTo.create method end

#set_attr_with_readers(hash) ⇒ Object

Assigns prescribed atrributes to the object and makes them accessible with getter (reader) methods. Raises NameError should any of the getters shadow / overwrite existing methods.



11
12
13
14
15
16
 
# File 'lib/y_support/core_ext/object/misc.rb', line 11

def set_attr_with_readers hash
  hash.each_pair { |ß, value|
    fail NameError, "Method \##{ß} already defined!" if methods.include? ß
    set_attr_with_readers! ß => value
  }
end

#set_attr_with_readers!(hash) ⇒ Object

Like #set_attr_with_readers, but it overloads existing methods, if present. Whereas #set_attr_with_readers guards against the presence of methods with the same name, #set_attr_with_reader! overloads them in the following way:

  • Colliding instance method defined in the singleton class of the receiver is overwritten (redefined).

  • Colliding instance methods defined on the receiver’s class ancestors are overloaded (partially shadowed). If the method message is sent without arguments or block, the reader activates and returns the corresponding instance variable regardless of what the behavior of the shadowed method might have been. However, if the method message is sent with arguments or block, the original method is invoked (via super) and its result returned.



32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/y_support/core_ext/object/misc.rb', line 32

def set_attr_with_readers! hash
  hash.each_pair { |ß, value|
    instance_variable_set "@#{ß}", value
    singleton_class.class_exec do
      define_method ß do |*args, &block|
        return instance_variable_get "@#{ß}" if args.empty? && block.nil?
        super *args, &block
      end
    end
  }
end

#try(receiver_NL_description = self, attempt_NL_description, &block) ⇒ Object Also known as: consciously

Try method takes two textual arguments and one block. The first (optional) argument is a natural language description of the method’s receiver (with #to_s of the receiver used by default). The second argument is a natural language description of the supplied block’s contract – in other words, what the supplied block tries to do. Finally, the block contains the code to perform the described risky action. Inside the block, #note method is available, which builds up the context information for a good error message, should the risky action raise one.



127
128
129
130
131
 
# File 'lib/y_support/try.rb', line 127

def try receiver_NL_description=self, attempt_NL_description, &block
  Consciously::Try.new( object: receiver_NL_description,
                       text: attempt_NL_description,
                       &block ).__invoke__
end

#Π(collection) ⇒ Object

Product. The argument is expected to be a collection; block can be specified. Basically same as chaining .reduce( :* ) to the end; Π() notation can be more readable at times.



32
33
34
35
36
 
# File 'lib/y_support/unicode.rb', line 32

def Π( collection )
  collection.reduce { |acc, element|
    acc * ( block_given? ? yield( element ) : element )
  }
end

#Σ(collection) ⇒ Object

Sum. The argument is expected to be a collection; block can be specified. Basically same as chaining .reduce( :+ ) to the end; Σ() notation can be more readable at times.



22
23
24
25
26
 
# File 'lib/y_support/unicode.rb', line 22

def Σ( collection )
  collection.reduce { |acc, element|
    acc + ( block_given? ? yield( element ) : element )
  }
end