Class: Kagemusha

Inherits:
Object
  • Object
show all
Defined in:
lib/kagemusha/core.rb,
lib/kagemusha/date.rb,
lib/kagemusha/rand.rb,
lib/kagemusha/time.rb,
lib/kagemusha/version.rb,
lib/kagemusha/datetime.rb,
lib/kagemusha/composite.rb

Overview

:nodoc:

Defined Under Namespace

Modules: Date, DateTime, Rand, Time Classes: Composite

Constant Summary collapse

VERSION = 
"0.1.0"

Instance Method Summary collapse

Constructor Details

#initialize(klass) ⇒ Kagemusha

:nodoc:



6
7
8
9
10
11
12
13
14
15
 
# File 'lib/kagemusha/core.rb', line 6

def initialize(klass) #:nodoc:
  @klass            = klass
  @meta             = class << @klass; self; end
  @class_methods    = {}
  @instance_methods = {}

  if block_given?
    yield(self)
  end
end

Instance Method Details

#concat(mock) ⇒ Object Also known as: + 



134
135
136
 
# File 'lib/kagemusha/core.rb', line 134

def concat(mock)
  return Kagemusha::Composite.new(self, mock)
end

#define_class_method(name, &block) ⇒ Object Also known as: defs

:nodoc:



17
18
19
20
 
# File 'lib/kagemusha/core.rb', line 17

def define_class_method(name, &block) #:nodoc:
  @class_methods[name.to_s.to_sym] = block
  return self
end

#define_instance_method(name, &block) ⇒ Object Also known as: def

:nodoc:



29
30
31
32
 
# File 'lib/kagemusha/core.rb', line 29

def define_instance_method(name, &block) #:nodoc:
  @instance_methods[name.to_s.to_sym] = block
  return self
end

#swap ⇒ Object

:nodoc:



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
66
67
68
69
70
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
97
98
99
100
101
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
130
131
132
 
# File 'lib/kagemusha/core.rb', line 41

def swap #:nodoc:
  recover_class_methods = @class_methods.map { |name, proc|
    if proc
      begin
        # replace method
        attr = get_accessibility(@meta, name)

        methods = to_symbols(@klass.singleton_methods(false))

        method = @meta.instance_method(name)

        @meta.instance_eval { define_method(name, proc) }
        @meta.instance_eval { private(name) } if attr == :private

        (methods.include?(name) ? [name, :define, nil, method] : [name, :remove])
      rescue NameError
        # insert method
        @meta.instance_eval { define_method(name, proc) }
        [name, :undef]
      end
    else
      begin
        # remove method
        method = @meta.instance_method(name)
        @meta.instance_eval { undef_method(name) }
        [name, :define, nil, method] # FIXME: attr
      rescue NameError
        [name, :nop]
      end
    end
  }

  recover_instance_methods = @instance_methods.map { |name, proc|
    if proc
      begin
        # replace method
        attr = get_accessibility(@klass, name)

        methods  = to_symbols(@klass.public_instance_methods(false))
        methods += to_symbols(@klass.protected_instance_methods(false))
        methods += to_symbols(@klass.private_instance_methods(false))

        method = @klass.instance_method(name)

        @klass.instance_eval { define_method(name, proc) }
        @klass.instance_eval { protected(name) } if attr == :protected
        @klass.instance_eval { private(name)   } if attr == :private

        (methods.include?(name) ? [name, :define, attr, method] : [name, :remove])
      rescue NameError
        # insert method
        @klass.instance_eval { define_method(name, proc) }
        [name, :undef]
      end
    else
      begin
        # remove method
        method = @klass.instance_method(name)
        @klass.instance_eval { undef_method(name) }
        [name, :define, nil, method] # FIXME: attr
      rescue NameError
        [name, :nop]
      end
    end
  }

  return yield
ensure
  recover_class_methods.each { |name, type, attr, method|
    case type
    when :nop    then # nop
    when :remove then @meta.instance_eval { remove_method(name) }
    when :undef  then @meta.instance_eval { undef_method(name) }
    when :define
      @meta.instance_eval { define_method(name, method) }
      @meta.instance_eval { private(name) } if attr == :private
    else raise("BUG")
    end
  }
  recover_instance_methods.each { |name, type, attr, method|
    case type
    when :nop    then # nop
    when :remove then @klass.instance_eval { remove_method(name) }
    when :undef  then @klass.instance_eval { undef_method(name) }
    when :define
      @klass.instance_eval { define_method(name, method) }
      @klass.instance_eval { protected(name) } if attr == :protected
      @klass.instance_eval { private(name)   } if attr == :private
    else raise("BUG")
    end
  }
end

#undefine_class_method(name) ⇒ Object Also known as: undefs

:nodoc:



23
24
25
26
 
# File 'lib/kagemusha/core.rb', line 23

def undefine_class_method(name) #:nodoc:
  @class_methods[name.to_s.to_sym] = false
  return self
end

#undefine_instance_method(name) ⇒ Object Also known as: undef

:nodoc:



35
36
37
38
 
# File 'lib/kagemusha/core.rb', line 35

def undefine_instance_method(name) #:nodoc:
  @instance_methods[name.to_s.to_sym] = false
  return self
end