module Nucleon::Mixin::Macro::PluginInterface

Public Instance Methods

plugin_collection(_namespace, _type, _method_options = {}) click to toggle source
    # File lib/core/mixin/macro/plugin_interface.rb
 15 def plugin_collection(_namespace, _type, _method_options = {})
 16   _method_config = Config.ensure(_method_options)
 17   _method_config.set(:plugin, true)
 18 
 19   _plural          = _method_config.init(:plural, "#{_type}s").get(:plural)
 20   _search_proc     = _method_config.get(:search_proc)
 21   _single_instance = _method_config.get(:single_instance, false)
 22   _plugin_type     = _method_config.get(:plugin_type, _type)
 23 
 24   @@object_types[_type] = _method_config
 25 
 26   logger.debug("Creating new plugin collection #{_namespace} #{_type}")
 27 
 28   #---------------------------------------------------------------------------
 29 
 30   object_utilities
 31 
 32   #---
 33 
 34   unless respond_to? :each_plugin
 35     logger.debug("Defining plugin interface method: each_plugin")
 36 
 37     define_method :each_plugin do |plugin_types = nil, providers = nil, &code|
 38       providers = [ providers ] if providers && ! providers.is_a?(Array)
 39 
 40       filter_proc = Proc.new {|type, config| config[:plugin] }
 41       each_object_type(plugin_types, filter_proc) do |type, plural, options|
 42         logger.debug("Processing plugin type #{type}/#{plural} with: #{options.inspect}")
 43 
 44         send(plural).each do |provider, plugins|
 45           logger.debug("Processing plugin provider: #{provider}")
 46 
 47           unless providers && ! providers.include?(provider)
 48             if plugins.is_a?(Hash)
 49               plugins.each do |name, plugin|
 50                 logger.debug("Processing plugin: #{name}")
 51                 code.call(type, provider, name, plugin)
 52               end
 53             else
 54               logger.debug("Processing plugin: #{plugin.plugin_name}")
 55               code.call(type, provider, plugin.plugin_name, plugin)
 56             end
 57           end
 58         end
 59       end
 60     end
 61   end
 62 
 63   #---
 64 
 65   logger.debug("Defining plugin interface method: each_#{_type}")
 66 
 67   define_method "each_#{_type}" do |providers = nil, &code|
 68     each_plugin(_type, providers) do |type, provider, name, plugin|
 69       code.call(provider, name, plugin)
 70     end
 71   end
 72 
 73   #---------------------------------------------------------------------------
 74 
 75   logger.debug("Defining plugin interface method: #{_plural}")
 76 
 77   define_method "#{_plural}" do |provider = nil, reset = false|
 78     keys = ( provider ? [ _plural, provider ] : _plural )
 79     send("init_#{_plural}", provider) if reset || _get(keys, {}).empty?
 80     _get(keys, {})
 81   end
 82 
 83   #---
 84 
 85   logger.debug("Defining plugin interface method: init_#{_plural}")
 86 
 87   define_method "init_#{_plural}" do |providers = nil|
 88     data = hash(_search_proc.call) if _search_proc
 89     data = get_hash(_plural) unless data
 90 
 91     providers = [ providers ] if providers && ! providers.is_a?(Array)
 92     providers.collect! { |elem| elem.to_sym } if providers
 93 
 94     logger.debug("Initializing #{_plugin_type} plugin data: #{data.inspect}")
 95     logger.debug("Providers: #{providers.inspect}")
 96 
 97     symbol_map(data).each do |provider, instance_settings|
 98       if ! providers || providers.include?(provider)
 99         if _single_instance
100           logger.debug("Initializing single instance plugin: #{instance_settings.inspect}")
101 
102           plugin = Nucleon.plugin(_namespace, _plugin_type, provider, Config.ensure(instance_settings).import({ :meta => { :parent => myself }, :new => true }))
103 
104           _set([ _plural, provider ], plugin)
105         else
106           instance_settings.each do |name, options|
107             if name != :settings
108               logger.debug("Initializing plugin #{_plugin_type} #{name}: #{options.inspect}")
109 
110               plugin = Nucleon.plugin(_namespace, _plugin_type, provider, Config.ensure(options).import({ :name => name, :meta => { :parent => myself }, :new => true }))
111 
112               _set([ _plural, provider, name ], plugin)
113             end
114           end
115         end
116       end
117     end
118   end
119 
120   #---
121 
122   logger.debug("Defining plugin interface method: set_#{_plural}")
123 
124   define_method "set_#{_plural}" do |data = {}|
125     data = Config.ensure(data).export
126 
127     send("clear_#{_plural}")
128     set(_plural, data)
129 
130     logger.debug("Setting #{_plural}")
131 
132     data.each do |provider, instance_settings|
133       if _single_instance
134         logger.debug("Setting single #{_plugin_type} #{provider}: #{instance_settings.inspect}")
135 
136         plugin = Nucleon.plugin(_namespace, _plugin_type, provider, Config.ensure(instance_settings).import({ :meta => { :parent => myself }, :new => true }))
137 
138         _set([ _plural, provider ], plugin)
139       else
140         instance_settings.each do |name, options|
141           logger.debug("Setting #{_plugin_type} #{provider} #{name}: #{options.inspect}")
142 
143           plugin = Nucleon.plugin(_namespace, _plugin_type, provider, Config.ensure(options).import({ :name => name, :meta => { :parent => myself }, :new => true }))
144 
145           _set([ _plural, provider, name ], plugin)
146         end
147       end
148     end
149   end
150 
151   #---
152 
153   logger.debug("Defining plugin interface method: clear_#{_plural}")
154 
155   define_method "clear_#{_plural}" do
156     get(_plural).keys.each do |provider|
157       logger.debug("Clearing #{_type} #{provider}")
158 
159       if _single_instance
160         send("delete_#{_type}", provider)
161       else
162         get_hash([ _plural, provider ]).keys.each do |name|
163           send("delete_#{_type}", provider, name)
164         end
165       end
166     end
167   end
168 
169   #---------------------------------------------------------------------------
170 
171   if _single_instance
172     logger.debug("Defining single instance plugin interface method: #{_type}_config")
173 
174     define_method "#{_type}_config" do |provider = nil|
175       keys = [ _plural ]
176       keys << provider unless provider.nil?
177       Config.new(get(keys, {}), {}, true, false)
178     end
179 
180     #---
181 
182     logger.debug("Defining single instance plugin interface method: #{_type}_setting")
183 
184     define_method "#{_type}_setting" do |provider, property, default = nil, format = false|
185       get([ _plural, provider, property ], default, format)
186     end
187 
188     #---
189 
190     logger.debug("Defining single instance plugin interface method: #{_type}")
191 
192     define_method "#{_type}" do |provider, reset = false|
193       if reset || _get([ _plural, provider ], nil).nil?
194         options = get([ _plural, provider ], nil)
195 
196         unless options.nil?
197           plugin = Nucleon.plugin(_namespace, _plugin_type, provider, Config.ensure(options).import({ :meta => { :parent => myself }, :new => true }))
198 
199           logger.debug("Initializing plugin #{_plugin_type} #{provider}: #{options.inspect}")
200 
201           _set([ _plural, provider ], plugin)
202         end
203       end
204       _get([ _plural, provider ])
205     end
206 
207     #---
208 
209     logger.debug("Defining single instance plugin interface method: set_#{_type}")
210 
211     define_method "set_#{_type}" do |provider, options = {}|
212       options = Config.ensure(options).export
213 
214       set([ _plural, provider ], options)
215 
216       plugin = Nucleon.plugin(_namespace, _plugin_type, provider, Config.ensure(options).import({ :meta => { :parent => myself }, :new => true }))
217 
218       logger.debug("Setting single #{_plugin_type} #{provider}: #{options.inspect}")
219 
220       _set([ _plural, provider ], plugin)
221       plugin
222     end
223 
224     #---
225 
226     logger.debug("Defining single instance plugin interface method: set_#{_type}_setting")
227 
228     define_method "set_#{_type}_setting" do |provider, property, value = nil|
229       logger.debug("Setting single #{provider} property #{property} to #{value.inspect}")
230       set([ _plural, provider, property ], value)
231     end
232 
233     #---
234 
235     logger.debug("Defining single instance plugin interface method: delete_#{_type}")
236 
237     define_method "delete_#{_type}" do |provider, remove_plugin = true|
238       plugin = send(_type, provider)
239 
240       logger.debug("Deleting single #{_type} #{provider}")
241 
242       delete([ _plural, provider ])
243       _delete([ _plural, provider ])
244 
245       Nucleon.remove_plugin(plugin) if remove_plugin && ! plugin.nil?
246     end
247 
248     #---
249 
250     logger.debug("Defining single instance plugin interface method: delete_#{_type}_setting")
251 
252     define_method "delete_#{_type}_setting" do |provider, property|
253       logger.debug("Deleting single #{provider} property: #{property}")
254       delete([ _plural, provider, property ])
255     end
256 
257     #---
258 
259     logger.debug("Defining single instance plugin interface method: search_#{_type}")
260 
261     define_method "search_#{_type}" do |provider, keys, default = '', format = false, extra_groups = []|
262       plugin_config = send("#{_type}_config", provider)
263       logger.debug("Searching single #{_type} #{provider}: #{plugin_config.inspect}")
264 
265       search_object(plugin_config, keys, default, format, extra_groups)
266     end
267 
268   #---------------------------------------------------------------------------
269   else
270     logger.debug("Defining multi instance plugin interface method: #{_type}_config")
271 
272     define_method "#{_type}_config" do |provider = nil, name = nil|
273       keys = [ _plural ]
274       keys << provider unless provider.nil?
275       keys << name unless name.nil?
276       Config.new(get(keys, {}), {}, true, false)
277     end
278 
279     #---
280 
281     logger.debug("Defining multi instance plugin interface method: #{_type}_setting")
282 
283     define_method "#{_type}_setting" do |provider, name, property, default = nil, format = false|
284       get([ _plural, provider, name, property ], default, format)
285     end
286 
287     #---
288 
289     logger.debug("Defining multi instance plugin interface method: #{_type}")
290 
291     define_method "#{_type}" do |provider, name, reset = false|
292       if reset || _get([ _plural, provider, name ], nil).nil?
293         options = get([ _plural, provider, name ], nil)
294 
295         unless options.nil?
296           plugin = Nucleon.plugin(_namespace, _plugin_type, provider, Config.ensure(options).import({ :name => name, :meta => { :parent => myself }, :new => true }))
297 
298           logger.debug("Initializing plugin #{_plugin_type} #{provider}: #{options.inspect}")
299 
300           _set([ _plural, provider, name ], plugin)
301         end
302       end
303       _get([ _plural, provider, name ])
304     end
305 
306     #---
307 
308     logger.debug("Defining multi instance plugin interface method: set_#{_type}")
309 
310     define_method "set_#{_type}" do |provider, name, options = {}|
311       options = Config.ensure(options).export
312 
313       set([ _plural, provider, name ], options)
314       plugin = Nucleon.plugin(_namespace, _plugin_type, provider, Config.ensure(options).import({ :name => name, :meta => { :parent => myself }, :new => true }))
315 
316       logger.debug("Setting #{_plugin_type} #{provider} #{name}: #{options.inspect}")
317 
318       _set([ _plural, provider, name ], plugin)
319       plugin
320     end
321 
322     #---
323 
324     logger.debug("Defining multi instance plugin interface method: set_#{_type}_setting")
325 
326     define_method "set_#{_type}_setting" do |provider, name, property, value = nil|
327       logger.debug("Setting #{provider} #{name} property #{property} to #{value.inspect}")
328       set([ _plural, provider, name, property ], value)
329     end
330 
331     #---
332 
333     logger.debug("Defining multi instance plugin interface method: delete_#{_type}")
334 
335     define_method "delete_#{_type}" do |provider, name, remove_plugin = true|
336       plugin = send(_type, provider, name)
337 
338       logger.debug("Deleting #{_type} #{provider} #{name}")
339 
340       delete([ _plural, provider, name ])
341       _delete([ _plural, provider, name ])
342 
343       Nucleon.remove_plugin(plugin) if remove_plugin && ! plugin.nil?
344     end
345 
346     #---
347 
348     logger.debug("Defining multi instance plugin interface method: delete_#{_type}_setting")
349 
350     define_method "delete_#{_type}_setting" do |provider, name, property|
351       logger.debug("Deleting #{provider} #{name} property: #{property}")
352       delete([ _plural, provider, name, property ])
353     end
354 
355     #---
356 
357     logger.debug("Defining multi instance plugin interface method: search_#{_type}")
358 
359     define_method "search_#{_type}" do |provider, name, keys, default = '', format = false, extra_groups = []|
360       plugin_config = send("#{_type}_config", provider, name)
361       logger.debug("Searching #{_type} #{provider} #{name}: #{plugin_config.inspect}")
362 
363       search_object(plugin_config, keys, default, format, extra_groups)
364     end
365   end
366 end