Module: Forwardable::Extended

Defined in:
lib/forwardable/extended.rb,
lib/forwardable/extended/version.rb

Constant Summary collapse

VERSION = 
"2.6.0"

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.extended(klass) ⇒ Object

Make our methods private on the class, there is no reason for public.



17
18
19
20
21
22
23
 
# File 'lib/forwardable/extended.rb', line 17

def self.extended(klass)
  instance_methods.each do |method|
    klass.private_class_method(
      method
    )
  end
end

Instance Method Details

#def_delegator(accessor, method, alias_ = method, **kwd) ⇒ Object

Wraps around traditional delegation and modern delegation.



135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
 
# File 'lib/forwardable/extended.rb', line 135

def def_delegator(accessor, method, alias_ = method, **kwd)
  kwd, alias_ = alias_, method if alias_.is_a?(Hash) && !kwd.any?

  if alias_.is_a?(Hash) || !kwd.any?
    Forwardable.instance_method(:def_delegator).bind(self) \
      .call(accessor, method, alias_)

  elsif !kwd[:type]
    def_modern_delegator(
      accessor, method, alias_, **kwd
    )

  else
    raise ArgumentError, "Alias not supported." if alias_ != method
    send("def_#{kwd[:type]}_delegator", accessor, method, **kwd.tap do |obj|
      obj.delete(:type)
    end)
  end
end

#def_delegators(accessor, *methods) ⇒ Object

Create multiple delegates at once.



159
160
161
162
163
164
165
166
167
 
# File 'lib/forwardable/extended.rb', line 159

def def_delegators(accessor, *methods)
  kwd = methods.shift if methods.first.is_a?(Hash)
  kwd = methods.pop   if methods. last.is_a?(Hash)
  kwd = {} unless kwd

  methods.each do |method|
    def_delegator accessor, method, **kwd
  end
end

#def_hash_delegator(hash, method, key: method, **kwd) ⇒ Object

Delegate a method to a hash and key.



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/forwardable/extended.rb', line 40

def def_hash_delegator(hash, method, key: method, **kwd)
  prefix, suffix, wrap = prepare_delegate(**kwd)

  if suffix
    method = method.to_s.gsub(
      /\?$/, ""
    )
  end

  class_eval delegate_debug(<<-STR), __FILE__, __LINE__ - 9
    def #{method}#{suffix}(*args)
      #{wrap}(
        #{prefix}#{hash}[#{key.inspect}]
      )

    rescue Exception
      if !Forwardable.debug && $@ && [email protected]_to?(:delete_if)
        [email protected]_if do |source|
          source =~ %r"#{Regexp.escape(__FILE__)}"o
        end
      end

      raise
    end
  STR
end

#def_ivar_delegator(ivar, alias_ = ivar, **kwd) ⇒ Object

Delegate a method to an instance variable.



71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/forwardable/extended.rb', line 71

def def_ivar_delegator(ivar, alias_ = ivar, **kwd)
  prefix, suffix, wrap = prepare_delegate(**kwd)

  if suffix
    alias_ = alias_.to_s.gsub(
      /\?$/, ""
    )
  end

  class_eval delegate_debug(<<-STR), __FILE__, __LINE__ - 9
    def #{alias_.to_s.gsub(/\A@/, "")}#{suffix}
      #{wrap}(
        #{prefix}#{ivar}
      )

    rescue Exception
      if !Forwardable.debug && $@ && [email protected]_to?(:delete_if)
        [email protected]_if do |source|
          source =~ %r"#{Regexp.escape(__FILE__)}"o
        end
      end

      raise
    end
  STR
end

#def_modern_delegator(accessor, method, alias_ = method, args: { :before => [], :after => [] }, **kwd) ⇒ Object

Like def_delegator but allows you to send args and do other stuff.



102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
 
# File 'lib/forwardable/extended.rb', line 102

def def_modern_delegator(accessor, method, alias_ = method, args: \
    { :before => [], :after => [] }, **kwd)

  prefix, suffix, wrap = prepare_delegate(**kwd)
  args = { :before => args } unless args.is_a?(Hash)
  b = [args[:before]].flatten.compact.map(&:to_s).join(", ")
  a = [args[ :after]].flatten.compact.map(&:to_s).join(", ")
  b = b + ", " unless args[:before].nil? || args[:before].empty?
  a = ", " + a unless args[ :after].nil? || args[ :after].empty?
  alias_ = alias_.to_s.gsub(/\?$/, "") if suffix

  class_eval delegate_debug(<<-STR), __FILE__, __LINE__ - 10
    def #{alias_}#{suffix}(*args, &block)
      #{wrap}(#{prefix}#{accessor}.send(
        #{method.inspect}, #{b}*args#{a}, &block
      ))

    rescue Exception
      if !Forwardable.debug && $@ && [email protected]_to?(:delete_if)
        [email protected]_if do |source|
          source =~ %r"#{Regexp.escape(__FILE__)}"o
        end
      end

      raise
    end
  STR
end

#rb_delegate(method, to: nil, alias_of: method, **kwd) ⇒ Object

Delegate using a Rails-like interface.

Raises:

  • (ArgumentError) 


29
30
31
32
33
34
 
# File 'lib/forwardable/extended.rb', line 29

def rb_delegate(method, to: nil, alias_of: method, **kwd)
  raise ArgumentError, "to must be provided" unless to
  def_delegator(
    to, alias_of, method, **kwd
  )
end