Class: Module

Inherits:
Object show all
Includes:
CacheMethods, Tins::Annotate, Tins::ClassMethod, Tins::Concern::ModuleMixin, Tins::Constant, Tins::DSLAccessor, Tins::Delegate, Tins::FromModule, Tins::Implement, Tins::ParameterizedModule
Defined in:
lib/tins/memoize.rb,
lib/tins/xt/named.rb,
lib/tins/xt/dslkit.rb,
lib/tins/xt/concern.rb,
lib/tins/xt/annotate.rb,
lib/tins/xt/implement.rb

Direct Known Subclasses

Tins::NullClass

Constant Summary

Constants included from Tins::Implement

Tins::Implement::MESSAGES

Constants included from Tins::Delegate

Tins::Delegate::UNSET

Instance Method Summary collapse

Methods included from Tins::Implement

#implement, #implement_in_submodule

Methods included from Tins::Annotate

#annotate

Methods included from Tins::Concern::ModuleMixin

#tins_concern_args, #tins_concern_configure

Methods included from Tins::FromModule

#parameterize

Methods included from Tins::ParameterizedModule

#parameterize_for

Methods included from Tins::Delegate

#delegate

Methods included from Tins::ClassMethod

#class_attr_accessor, #class_attr_reader, #class_attr_writer, #class_define_method

Methods included from Tins::Eigenclass

#eigenclass_eval

Methods included from Tins::DSLAccessor

#dsl_accessor, #dsl_reader

Methods included from Tins::Constant

#constant

Instance Method Details

#memoize_function(*function_ids) ⇒ Object

Automatically memoize calls of the functions function_ids. The memoized result does ONLY depend on the arguments given to the function.



65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
# File 'lib/tins/memoize.rb', line 65

def memoize_function(*function_ids)
  function_ids.extend(ExtractLastArgumentOptions)
  function_ids, opts = function_ids.extract_last_argument_options
  mc = __memoize_cache__
  function_ids.each do |function_id|
    function_id = function_id.to_s.to_sym
    memoize_apply_visibility function_id do
      orig_function = instance_method(function_id)
      __send__(:define_method, function_id) do |*args|
        if mc.key?(function_id) and result = mc[function_id][args]
          result
        else
          (mc[function_id] ||= {})[args] = result = orig_function.bind(self).call(*args)
          opts[:freeze] and result.freeze
          $DEBUG and warn "#{self.class} cached function #{function_id}(#{args.inspect unless args.empty?}) = #{result.inspect}"
        end
        result
      end
    end
  end
  function_ids.size == 1 ? function_ids.first : function_ids
end

#memoize_method(*method_ids) ⇒ Object

Automatically memoize calls of the the methods method_ids. The memoized results do NOT ONLY depend on the arguments, but ALSO on the object the method is called on.



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/tins/memoize.rb', line 36

def memoize_method(*method_ids)
  method_ids.extend(ExtractLastArgumentOptions)
  method_ids, opts = method_ids.extract_last_argument_options
  include CacheMethods
  method_ids.each do |method_id|
    method_id = method_id.to_s.to_sym
    memoize_apply_visibility method_id do
      orig_method = instance_method(method_id)
      __send__(:define_method, method_id) do |*args|
        mc = __memoize_cache__
        if mc.key?(method_id) and result = mc[method_id][args]
          result
        else
          (mc[method_id] ||= {})[args] = result = orig_method.bind(self).call(*args)
          $DEBUG and warn "#{self.class} cached method #{method_id}(#{args.inspect unless args.empty?}) = #{result.inspect} [#{__id__}]"
          opts[:freeze] and result.freeze
        end
        result
      end
    end
  end
  method_ids.size == 1 ? method_ids.first : method_ids
end

#named(name, method, *args, &named_block) ⇒ Object 



15
16
17
18
19
20
21
22
 
# File 'lib/tins/xt/named.rb', line 15

def named(name, method, *args, &named_block)
  include Module.new {
    define_method(name) do |*rest, &block|
      block = named_block if named_block
      __send__(method, *(args + rest), &block)
    end
  }
end