Class: Object

Inherits:
BasicObject
Defined in:
lib/y_support/typing.rb,
lib/y_support/try.rb,
lib/y_support/unicode.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

Overview

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

Constant Summary collapse

AErr =

Alias for ArgumentError

ArgumentError
TErr =

Alias for TypeError

TypeError

Instance Method Summary collapse

Instance Method Details

#aT(what_is_receiver = nil, 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
55
56
57
 
# File 'lib/y_support/typing/object/typing.rb', line 49

def aT what_is_receiver=nil, how_comply=nil, &b
  if block_given? then
    m = "%s fails #{how_comply ? 'to %s' % how_comply : 'its duck type'}!" %
      if what_is_receiver then what_is_receiver.to_s.capitalize else
        "#{self.class} instance #{object_id}"
      end
    tap { b.( self ) or fail TypeError, m }
  else self or fail TypeError end
end

#aT_blank(what_is_receiver = nil) ⇒ Object

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



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

def aT_blank what_is_receiver=nil
  r = 
  m = "#%s fails to be blank!" %
    if what_is_receiver then what_is_receiver.to_s.capitalize else
      "#{self.class} instance #{object_id}"
    end
  tap { blank? or fail TypeError, m }
end

#aT_class_complies(klass, what_is_receiver = nil) ⇒ Object

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



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

def aT_class_complies klass, what_is_receiver=nil
  m = "%s does not comply or declare compliance with #{klass}!" %
    if what_is_receiver then what_is_receiver.to_s.capitalize else
      "#{self.class} instance #{object_id}"
    end
  tap { class_complies? klass or fail TypeError, m }
end

#aT_equal(other, what_is_receiver = nil, 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).



119
120
121
122
123
124
125
 
# File 'lib/y_support/typing/object/typing.rb', line 119

def aT_equal other, what_is_receiver=nil, what_is_other=nil
  r = what_is_receiver ? what_is_receiver.to_s.capitalize :
    "#{self.class} instance #{object_id}"
  o = what_is_other || "the prescribed value (#{other.class})"
  m = "%s is not equal (==) to %s!" % [r, o]
  tap { self == other or fail TypeError, m }
end

#aT_kind_of(klass, what_is_receiver = nil) ⇒ 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).



81
82
83
84
85
86
87
 
# File 'lib/y_support/typing/object/typing.rb', line 81

def aT_kind_of klass, what_is_receiver=nil
  m = "%s is not a kind of #{klass}!" %
    if what_is_receiver then what_is_receiver.to_s.capitalize else
      "#{self.class} instance #{object_id}"
    end
  tap { kind_of? klass or fail TypeError, m }
end

#aT_not(what_is_receiver = nil, 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.



68
69
70
71
72
73
74
75
76
 
# File 'lib/y_support/typing/object/typing.rb', line 68

def aT_not what_is_receiver=nil, how_comply=nil, &b
  if block_given? then
    m = how_comply ? "%s must not #{how_comply}!" : "%s fails its duck type!"
    m %= if what_is_receiver then what_is_receiver.to_s.capitalize else
           "#{self.class} instance #{object_id}"
         end
    tap { fail TypeError, m if b.( self ) }
  else tap { fail TypeError if self } end
end

#aT_not_equal(other, what_is_receiver = nil, 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).



131
132
133
134
135
136
137
 
# File 'lib/y_support/typing/object/typing.rb', line 131

def aT_not_equal other, what_is_receiver=nil, what_is_other=nil
  r = what_is_receiver ? what_is_receiver.to_s.capitalize :
    "#{self.class} instance #{object_id}"
  o = what_is_other || "the prescribed value (#{other.class})"
  m = "%s fails to differ from %s!" % [r, o]
  tap { fail TypeError, m if self == other }
end

#aT_present(what_is_receiver = nil) ⇒ Object

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



154
155
156
157
158
159
160
 
# File 'lib/y_support/typing/object/typing.rb', line 154

def aT_present what_is_receiver=nil
  m = "%s fails to be present!" %
    if what_is_receiver then what_is_receiver.to_s.capitalize else
      "#{self.class} instance #{object_id}"
    end
  tap { present? or fail TypeError, m }
end

#aT_respond_to(method_name, what_is_receiver = nil) ⇒ 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).



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

def aT_respond_to method_name, what_is_receiver=nil
  m = "%s does not respond to method '#{method_name}'!" %
    if what_is_receiver then what_is_receiver.to_s.capitalize else
      "#{self.class} instance #{object_id}"
    end
  tap { respond_to? method_name or fail TypeError, m }
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

#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: (fail ArgumentError, "No parameters!")) ⇒ Object

Constructs parametrized subclasses of the supplied classes and makes them available under specified getters. Expects a hash of pairs { reader_symbol: class }, and a hash of parameters, with which the class(es) is (are) parametrized. Raises NameError should any of the getters shadow / overwrite existing methods.



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

def param_class hash, with: (fail ArgumentError, "No parameters!")
  hash.each { |ß, ç|
    sub = ç.parametrize with
    set_attr_with_readers( ß => sub )
  }
  return nil
end

#param_class!(hash, with: (fail ArgumentError, "No parameters!")) ⇒ Object

Constructs parametrized subclasses of the supplied classes and makes them available under specified getters. Expects a hash of pairs { reader_symbol: class }, and a hash of parameters, with which the class(es) is (are) parametrized. Shadows / overwrites existing methods.



46
47
48
49
50
51
52
 
# File 'lib/y_support/core_ext/object/misc.rb', line 46

def param_class! hash, with: (fail ArgumentError, "No parameters!")
  hash.each { |ß, ç|
    sub = ç.parametrize with
    set_attr_with_readers!( ß => sub )
  }
  return nil
end

#RespondTo(method) ⇒ Object

RespondTo constructor.



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

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.



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

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

Assigns prescribed atrributes to the object and makes them accessible with getter (reader) methods. Shadows / overwrites existing methods.



20
21
22
23
24
25
 
# File 'lib/y_support/core_ext/object/misc.rb', line 20

def set_attr_with_readers! hash
  hash.each_pair { |symbol, value|
    instance_variable_set "@#{symbol}", value
    singleton_class.class_exec { attr_reader symbol }
  }
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.



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

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.



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

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