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