Class: Micon::Core

Inherits:
Object
  • Object
show all
Defined in:
lib/micon/core.rb

Overview

There are 3 types of component scopes: :application, :instance and custom scope. Custom scopes are managed with ‘activate` and `deactivate` methods.

Instance Attribute Summary collapse

Instance Method Summary collapse

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(m, *args, &block) ⇒ Object (protected)

Generates helper methods, so you can use ‘micon.logger` instead of `micon`



373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
 
# File 'lib/micon/core.rb', line 373

def method_missing m, *args, &block
  super if args.size > 1 or block

  key = m.to_s.sub(/[?=]$/, '').to_sym
  self.class.class_eval do
    define_method key do
      self[key]
    end

    define_method "#{key}=" do |value|
      self[key] = value
    end

    define_method "#{key}?" do
      include? key
    end
  end

  send m, *args
end

Instance Attribute Details

#custom_scopes ⇒ Object

Scope Management.



6
7
8
 
# File 'lib/micon/core.rb', line 6

def custom_scopes
  @custom_scopes
end

#metadata ⇒ Object

Metadata.



152
153
154
 
# File 'lib/micon/core.rb', line 152

def metadata
  @metadata
end

Instance Method Details

#[](key) ⇒ Object 



79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/micon/core.rb', line 79

def [] key
  sname = @registry[key] || autoload_component_definition(key)

  case sname
  when :instance
    return create_object(key)
  when :application
    o = @application[key]
    unless o
      return create_object(key, @application)
    else
      return o
    end
  else # custom scope.
    container = @custom_scopes[sname]
    raise_without_self "Scope '#{sname}' not started!" unless container
    o = container[key]
    unless o
      return create_object(key, container)
    else
      return o
    end
  end
end

#[]=(key, value) ⇒ Object 



104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
 
# File 'lib/micon/core.rb', line 104

def []= key, value
  raise "can't assign nill as :#{key} component!" unless value

  sname = @registry[key] || autoload_component_definition(key)

  value = case sname
  when :instance
    raise_without_self "You can't outject variable with the 'instance' sname!"
  when :application
    @application[key] = value
  else # custom scope.
    container = @custom_scopes[sname]
    raise_without_self "Scope '#{sname}' not started!" unless container
    container[key] = value
  end

  @metadata.call_after key, value

  value
end

#activate(sname, container = {}, &block) ⇒ Object 



8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
# File 'lib/micon/core.rb', line 8

def activate sname, container = {}, &block
  raise_without_self "Only custom scopes can be activated!" if sname == :application or sname == :instance
  raise "container should have type of Hash but has #{container.class.name}" unless container.is_a? Hash

  raise_without_self "Scope '#{sname}' already active!" if !block and @custom_scopes[sname]

  if block
    begin
      outer_container_or_nil = @custom_scopes[sname]
      @custom_scopes[sname] = container
      @metadata.with_scope_callbacks sname, container, &block
    ensure
      if outer_container_or_nil
        @custom_scopes[sname] = outer_container_or_nil
      else
        @custom_scopes.delete sname
      end
    end
  else
    # not support nested scopes without block
    @custom_scopes[sname] = container
    @metadata.call_before_scope sname, container
  end
end

#active?(sname) ⇒ Boolean

Returns:

  • (Boolean) 


43
44
45
46
47
48
49
 
# File 'lib/micon/core.rb', line 43

def active? sname
  if sname == :application or sname == :instance
    true
  else
    @custom_scopes.include? sname
  end
end

#after(component, options = {}, &block) ⇒ Object 



178
179
180
181
182
183
184
185
186
187
 
# File 'lib/micon/core.rb', line 178

def after component, options = {}, &block
  if include? component
    if options[:bang]
      raise_without_self "component :#{component} already created!"
    else
      block.call self[component]
    end
  end
  @metadata.register_after component, &block
end

#after_scope(sname, options = {}, &block) ⇒ Object 



195
196
197
198
199
 
# File 'lib/micon/core.rb', line 195

def after_scope sname, options = {}, &block
  options[:bang] = true unless options.include? :bang
  raise_without_self "scope :#{sname} already started!" if options[:bang] and active?(sname)
  @metadata.register_after_scope sname, &block
end

#before(component, options = {}, &block) ⇒ Object 



173
174
175
176
 
# File 'lib/micon/core.rb', line 173

def before component, options = {}, &block
  raise_without_self "component :#{component} already created!" if options[:bang] and include?(component)
  @metadata.register_before component, &block
end

#before_scope(sname, options = {}, &block) ⇒ Object 



189
190
191
192
193
 
# File 'lib/micon/core.rb', line 189

def before_scope sname, options = {}, &block
  options[:bang] = true unless options.include? :bang
  raise_without_self "scope :#{sname} already started!" if options[:bang] and active?(sname)
  @metadata.register_before_scope sname, &block
end

#clear ⇒ Object 



51
52
53
54
 
# File 'lib/micon/core.rb', line 51

def clear
  @application.clear
  @custom_scopes.clear
end

#clone ⇒ Object Also known as: deep_clone 



201
202
203
204
205
206
207
208
209
210
 
# File 'lib/micon/core.rb', line 201

def clone
  another = super
  %w(@metadata @application @custom_scopes).each do |name| # @loaded_classes, @constants
    value = instance_variable_get name
    another.instance_variable_set name, value.clone
  end
  another.instance_variable_set '@registry', another.metadata.registry
  another.instance_variable_set '@initialized', another.instance_variable_get('@initialized')
  another
end

#deactivate(sname) ⇒ Object 



33
34
35
36
37
38
39
40
41
 
# File 'lib/micon/core.rb', line 33

def deactivate sname
  raise_without_self "Only custom scopes can be deactivated!" if sname == :application or sname == :instance

  raise_without_self "Scope '#{sname}' not active!" unless container = @custom_scopes[sname]

  @metadata.call_after_scope sname, container
  @custom_scopes.delete sname
  container
end

#deinitialize! ⇒ Object 



233
234
235
 
# File 'lib/micon/core.rb', line 233

def deinitialize!
  Object.send(:remove_const, :MICON) if Object.const_defined?(:MICON)
end

#delete(key) ⇒ Object 



125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
# File 'lib/micon/core.rb', line 125

def delete key
  sname = @registry[key]

  case sname
  when nil
  when :instance
    raise_without_self "You can't outject variable with the 'instance' scope!"
  when :application
    @application.delete key
  else # custom scope.
    container = @custom_scopes[sname]
    container.delete key if container
  end
end

#delete_all(key) ⇒ Object 



140
141
142
143
 
# File 'lib/micon/core.rb', line 140

def delete_all key
  metadata.delete key
  delete key
end

#development(&block) ⇒ Object 



261
 
# File 'lib/micon/core.rb', line 261

def development █ block.call if development? end

#development? ⇒ Boolean

Returns:

  • (Boolean) 


257
 
# File 'lib/micon/core.rb', line 257

def development?; mode == :development end

#empty? ⇒ Boolean

Returns:

  • (Boolean) 


56
57
58
 
# File 'lib/micon/core.rb', line 56

def empty?
  @application.empty? and @custom_scopes.empty?
end

#include?(key) ⇒ Boolean

Component Management.

Returns:

  • (Boolean) 


62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/micon/core.rb', line 62

def include? key
  sname = @registry[key]

  case sname
  when nil
    false
  when :instance
    true
  when :application
    @application.include? key
  else # custom scope.
    container = @custom_scopes[sname]
    return false unless container
    container.include? key
  end
end

#initialize! ⇒ Object 



213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
 
# File 'lib/micon/core.rb', line 213

def initialize!
  unless @initialized
    # Quick access to Metadata inner variable. I intentially broke
    # the Metadata incapsulation to provide better performance, don't refactor it.
    @registry = {}
    @metadata = Micon::Metadata.new(@registry)
    @stack = {}

    @application, @custom_scopes = {}, {}

    @initialized = true
  end

  # Micon::Core is independent itself and there can be multiple Cores simultaneously.
  # But some of its extensions can work only with one global instance, and them need to know how to get it,
  # the MICON constant references this global instance.
  Object.send(:remove_const, :MICON) if Object.const_defined?(:MICON)
  Object.const_set :MICON, self
end

#mode ⇒ Object

‘mode` used to search for component configuration, examples:

  • ‘app/runtime/logger.production.yml`

  • ‘app/runtime/production/logger.yml`



249
 
# File 'lib/micon/core.rb', line 249

def mode; @mode ||= :development end

#mode=(mode) ⇒ Object 



250
251
252
253
254
 
# File 'lib/micon/core.rb', line 250

def mode= mode
  mode, force = mode
  raise "some components have been already initialized before You set :mode!" unless empty? or force
  @mode = mode
end

#mode? ⇒ Boolean

Returns:

  • (Boolean) 


255
 
# File 'lib/micon/core.rb', line 255

def mode?; !!@mode end

#production(&block) ⇒ Object 



262
 
# File 'lib/micon/core.rb', line 262

def production █ block.call if production? end

#production? ⇒ Boolean

Returns:

  • (Boolean) 


258
 
# File 'lib/micon/core.rb', line 258

def production?; mode == :production end

#raise_without_self(message) ⇒ Object

Raises:

  • (RuntimeError) 


265
266
267
 
# File 'lib/micon/core.rb', line 265

def raise_without_self message
  raise RuntimeError, message, caller.select{|path| path !~ /\/lib\/micon\//}
end

#register(key, options = {}, &initializer) ⇒ Object 



154
155
156
157
158
159
160
161
162
163
164
165
166
167
 
# File 'lib/micon/core.rb', line 154

def register key, options = {}, &initializer
  raise "key should not be nil or false value!" unless key

  sname = options.delete(:scope) || :application
  dependencies = Array(options.delete(:require) || options.delete(:depends_on))

  raise "unknown options :#{options.keys.join(', :')}!" unless options.empty?

  unless @registry.object_id == @metadata.registry.object_id
    raise "internal error, reference to registry aren't equal to actual registry!"
  end
  @metadata.registry[key] = sname
  @metadata.initializers[key] = [initializer, dependencies]
end

#reset(key) ⇒ Object 



145
146
147
148
 
# File 'lib/micon/core.rb', line 145

def reset key
  delete key
  self[key]
end

#runtime_path ⇒ Object

‘runtime_path` is used to search for component configurations, it may be `app/runtime` for example..



238
 
# File 'lib/micon/core.rb', line 238

def runtime_path; @runtime_path ||= File.expand_path('.') end

#runtime_path=(runtime_path) ⇒ Object 



239
240
241
242
243
 
# File 'lib/micon/core.rb', line 239

def runtime_path= runtime_path
  runtime_path, force = runtime_path
  raise "some components have been already initialized before You set :runtime_path!" unless empty? or force
  @runtime_path = runtime_path
end

#runtime_path? ⇒ Boolean

Returns:

  • (Boolean) 


244
 
# File 'lib/micon/core.rb', line 244

def runtime_path?; !!@runtime_path end

#test(&block) ⇒ Object 



263
 
# File 'lib/micon/core.rb', line 263

def test █ block.call if test? end

#test? ⇒ Boolean

Returns:

  • (Boolean) 


259
 
# File 'lib/micon/core.rb', line 259

def test?; mode == :test end

#unregister(key) ⇒ Object 



169
170
171
 
# File 'lib/micon/core.rb', line 169

def unregister key
  @metadata.delete key
end