maruto 0.0.5 → 0.0.6

data/lib/maruto.rb

@@ -3,8 +3,4 @@ require 'maruto/magento_config'
 require 'maruto/magento_instance'
 
 module Maruto
-	def self.warnings(magento_root)
-		magento = MagentoInstance.load(magento_root)
-		magento[:warnings]
-	end
 end

data/lib/maruto/magento_config.rb

@@ -75,37 +75,6 @@ module Maruto
 							end
 						end
 
-						##########################################################################################
-						# EVENTS
-
-						# TODO same for:
-						# '/config/frontend/events/*'
-						# '/config/adminhtml/events/*'
-						doc.xpath('/config/global/events/*').each do |node|
-							# puts node
-							event = node.name
-							observers = @global_events_observers[event] ||= {}
-
-							node.xpath("observers/*").each do |observer_node|
-								observer_name = observer_node.name
-								if observers.include? observer_name
-									mod_first  = observers[observer_name][:defined]
-									mod_second = mm_name
-									@warnings << "event:#{event} observer:#{observer_name} - defined in #{mod_first} and redefined in #{mod_second}"
-									# TODO check if there is a dependency path between mod_first and mod_second
-									# print_module(mod_first)
-									# print_module(mod_second)
-								end
-								observers[observer_name] = {
-									:class   => observer_node.at_xpath('class').content,
-									:method  => observer_node.at_xpath('method').content,
-									:defined => mm_name,
-								}
-							end
-
-							@global_events_observers[event] = observers
-						end
-
 					end
 				end # modules().each
 

data/lib/maruto/magento_instance.rb

@@ -9,10 +9,11 @@ module Maruto::MagentoInstance
 			sorted_modules, active_modules = Maruto::ModuleDefinition.analyse_module_definitions(all_modules)
 
 			sorted_modules.each do |m|
-				Maruto::ModuleConfiguration.load(m)
-				# ModuleConfiguration.analyse(m, active_modules)
+				Maruto::ModuleConfiguration.parse_module_configuration(m)
 			end
 
+			event_observers = Maruto::ModuleConfiguration.collect_event_observers(sorted_modules)
+
 			# TODO move to function: collect_warnings + write spec
 			warnings = []
 			all_modules.each do |m|
@@ -20,10 +21,11 @@ module Maruto::MagentoInstance
 			end
 
 			{
-				:active_modules => active_modules.map{|k,v| v},
-				:all_modules    => all_modules,
-				:sorted_modules => sorted_modules,
-				:warnings       => warnings,
+				:active_modules  => active_modules,
+				:all_modules     => Hash[all_modules.collect { |m| [m[:name], m]}],
+				:sorted_modules  => sorted_modules,
+				:event_observers => event_observers,
+				:warnings        => warnings,
 			}
 		end
 	end

data/lib/maruto/module_configuration.rb

@@ -3,46 +3,58 @@ require 'nokogiri'
 
 module Maruto::ModuleConfiguration
 
-	def self.load(m)
+	def self.parse_module_configuration(m)
 		f = File.open(m[:config_path])
-		doc = Nokogiri::XML(f) { |config| config.strict }
+		xml_root = Nokogiri::XML(f) { |config| config.strict }.root
 		f.close
 
-		read_module_version(m, doc.root)
+		version_warnings = parse_module_version(m, xml_root)
+		event_warnings   = parse_all_event_observers(m, xml_root)
+
+		config_warnings = version_warnings + event_warnings
+
+		all_module_warnings = m[:warnings] || []
+		all_module_warnings.concat(config_warnings.map { |msg| { :file => m[:config_path], :message => msg } })
+
+		m[:warnings] = all_module_warnings unless all_module_warnings.size == 0
+
+		m
 	end
 
-	def self.read_module_version(m, xml_root)
+	def self.parse_module_version(m, xml_root)
 		xml_node = xml_root.at_xpath('/config/modules')
+
 		if xml_node.nil?
-			m[:warnings] ||= []
-			m[:warnings] << { :file => m[:config_path], :message => "config.xml is missing a /config/modules node" }
-			return m
+			return ["config.xml is missing a /config/modules node"]
 		end
 
+		warnings = []
+
 		unless xml_node.at_xpath("./#{m[:name]}")
-			m[:warnings] ||= []
-			m[:warnings] << { :file => m[:config_path], :message => "config.xml is missing a /config/modules/#{m[:name]} node" }
+			warnings << "config.xml is missing a /config/modules/#{m[:name]} node"
 		end
 
 		xml_node.xpath("./*").each do |n|
 			unless n.name.to_sym == m[:name]
-				m[:warnings] ||= []
-				m[:warnings] << { :file => m[:config_path], :message => "config.xml contains configuration for a different module (/config/modules/#{n.name})" }
+				warnings << "config.xml contains configuration for a different module (/config/modules/#{n.name})"
 			end
 		end
 
-		if xml_node.at_xpath("./#{m[:name]}/version")
-			m[:version] = xml_node.at_xpath("./#{m[:name]}/version").content
-		end
+		m[:version] = xml_node.at_xpath("./#{m[:name]}/version").content unless xml_node.at_xpath("./#{m[:name]}/version").nil?
 
-		m
+		warnings
 	end
 
-	def self.parse_scoped_events_observers(base_path, xml_node)
+	def self.parse_scoped_event_observers(base_path, xml_node)
+
+		return [],[] if xml_node.nil?
 
-		return [] if xml_node.nil?
+		events   = []
+		warnings = []
 
-		events = []
+		if xml_node.size > 1
+			warnings << "duplicate element in config.xml (#{base_path})"
+		end
 
 		xml_node.xpath('events/*').each do |e|
 			event = {
@@ -56,9 +68,25 @@ module Maruto::ModuleConfiguration
 					:name => o.name,
 					:path => event[:path] + '/observers/' + o.name,
 				}
-				observer[:type]   = o.at_xpath('type').content
-				observer[:class]  = o.at_xpath('class').content
-				observer[:method] = o.at_xpath('method').content
+				type              = o.at_xpath('type').content   unless o.at_xpath('type').nil?
+				observer[:class]  = o.at_xpath('class').content  unless o.at_xpath('class').nil?
+				observer[:method] = o.at_xpath('method').content unless o.at_xpath('method').nil?
+
+				# see Mage_Core_Model_App::dispatchEvent
+				if type.nil?
+					# default is singleton
+					observer[:type] = :singleton
+				elsif type == 'object'
+					# object is an alias for model
+					observer[:type] = :model
+					warnings << "#{observer[:path]}/type 'object' is an alias for 'model'"
+				elsif /^(disabled|model|singleton)$/ =~ type
+					observer[:type] = type.to_sym
+				else
+					# everything else => default (with warning)
+					observer[:type] = :singleton
+					warnings << "#{observer[:path]}/type replaced with 'singleton', was '#{type}' (possible values: 'disabled', 'model', 'singleton', or nothing)"
+				end
 
 				event[:observers] << observer
 			end
@@ -66,17 +94,65 @@ module Maruto::ModuleConfiguration
 			events << event
 		end
 
+		return events, warnings
+	end
+
+	def self.parse_all_event_observers(m, xml_node)
+		areas = [:global, :frontend, :adminhtml, :crontab]
+		events = {}
+		warnings = []
+		areas.each do |area|
+			e, w = parse_scoped_event_observers("/config/#{area}",    xml_node.xpath("/config/#{area}"))
+
+			events[area] = e if e.size > 0
+			warnings.concat w
+		end
+		m[:events] = events if events.keys.size > 0
+
+		warnings << "the 'admin' area should not contain events (/config/admin/events)" unless xml_node.at_xpath("/config/admin/events").nil?
+
+		return warnings
+	end
+
+	def self.collect_scoped_event_observers(area, sorted_modules)
+		events = Hash.new
+
+		sorted_modules.each do |m|
+			if m.include? :events and m[:events].include? area then
+				m[:events][area].each do |event|
+					event_name = event[:name]
+					events[event_name] ||= Hash.new
+					event[:observers].each do |observer|
+						observer_name = observer[:name]
+						if events[event_name].include? observer_name
+							add_module_config_warning(m, "event_observer:#{area}/#{event_name}/#{observer_name} - defined in #{events[event_name][observer_name][:module]} and redefined in #{m[:name]}")
+						end
+						events[event_name][observer_name] = observer
+						events[event_name][observer_name][:module] = m[:name]
+					end
+				end
+			end
+		end
+
 		events
 	end
 
-	def self.parse_all_events_observers(base_path, xml_node)
-		# TODO handle multiple global / frontend / adminhtml nodes
-		h = {
-			:global    => parse_scoped_events_observers(base_path + '/global',    xml_node.at_xpath('global')),
-			:frontend  => parse_scoped_events_observers(base_path + '/frontend',  xml_node.at_xpath('frontend')),
-			:adminhtml => parse_scoped_events_observers(base_path + '/adminhtml', xml_node.at_xpath('adminhtml')),
-		}
-		h.delete_if {|k,v| v.size == 0}
+	def self.collect_event_observers(sorted_modules)
+		areas = [:global, :frontend, :adminhtml, :crontab]
+		events = {}
+
+		areas.each do |area|
+			events[area] = collect_scoped_event_observers(area, sorted_modules)
+		end
+
+		events
+	end
+
+private
+
+	def self.add_module_config_warning(m, msg)
+		m[:warnings] ||= []
+		m[:warnings] << { :file => m[:config_path], :message => msg }
 	end
 
 end

data/lib/maruto/module_definition.rb

@@ -90,6 +90,11 @@ module Maruto::ModuleDefinition
 						m[:active] = false
 					end
 				end
+			else
+				if m[:code_pool] == :core and m[:name].to_s.start_with? 'Mage_' then
+					m[:warnings] ||= []
+					m[:warnings] << { :file => m[:defined], :message => "core/#{m[:name]} is inactive, but models and helpers will still be loaded" }
+				end
 			end
 		end
 		# remove inactive modules

data/lib/maruto/runner.rb

@@ -43,6 +43,7 @@ class Maruto::Runner < Thor
 
 	desc "warnings", "list potential problems found in the config"
 	method_option :magento_root, :aliases => "-m", :default => "."
+	method_option :with_core, :type => :boolean, :aliases => "-c", :default => false
 	def warnings()
 
 		magento_root = check_magento_folder()
@@ -52,11 +53,19 @@ class Maruto::Runner < Thor
 
 		# next gen maruto:
 
-		all_warnings = Maruto::warnings magento_root
-		all_warnings.group_by { |e| e[:module] }.each do |m,module_warnings|
-			puts "[module:#{m}]"
-			module_warnings.each do |w|
-				puts "   [file:#{w[:file]}] #{w[:message]}"
+		with_core = options[:with_core]
+
+		magento = Maruto::MagentoInstance.load(magento_root)
+
+		magento[:warnings].group_by { |e| e[:module] }.each do |m,module_warnings|
+			if with_core or magento[:all_modules][m][:code_pool] != :core then
+				puts "[module:#{m}]"
+				module_warnings.group_by { |e| e[:file] }.each do |file,warnings|
+					puts "  [file:#{file}]"
+					warnings.each do |w|
+						puts "    #{w[:message]}"
+					end
+				end
 			end
 		end
 
@@ -77,18 +86,41 @@ class Maruto::Runner < Thor
 
 	end
 
-	desc "observers", "list observers sorted and grouped by their events"
+	desc "observers", "list observers sorted and grouped by their event or area"
 	method_option :magento_root, :aliases => "-m", :default => "."
+	method_option :group_by_scope, :type => :boolean, :aliases => "-s", :default => false
 	def observers()
 
 		magento_root = check_magento_folder()
 
-		magento_config = Maruto::MagentoConfig.new magento_root
+		magento = Maruto::MagentoInstance.load(magento_root)
+
+		group_by_scope = options[:group_by_scope]
 
-		magento_config.observers.sort_by { |k, v| k }.each do |event, observers|
-			puts event
-			observers.each do |observer|
-				puts "   #{observer}"
+		if group_by_scope then
+			magento[:event_observers].each do |area, events|
+				events.each do |event, observers|
+					puts "#{area}/#{event}"
+					observers.each do |name, observer|
+						puts "  #{name} (module:#{observer[:module]} type:#{observer[:type]} class:#{observer[:class]} method:#{observer[:method]})"
+					end
+				end
+			end
+		else
+			grouped_by_events = Hash.new
+			magento[:event_observers].each do |area, events|
+				events.each do |event, observers|
+					grouped_by_events[event] ||= Hash.new
+					grouped_by_events[event][area] = observers
+				end
+			end
+			grouped_by_events.sort_by { |k, v| k }.each do |event, areas|
+				puts "#{event}"
+				areas.each do |area, observers|
+					observers.each do |name, observer|
+						puts "  #{area}/#{name} (module:#{observer[:module]} type:#{observer[:type]} class:#{observer[:class]} method:#{observer[:method]})"
+					end
+				end
 			end
 		end
 

data/lib/maruto/version.rb

@@ -1,3 +1,3 @@
 module Maruto
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

data/spec/module_definition_spec.rb

@@ -61,6 +61,9 @@ describe Maruto::ModuleDefinition do
 		end
 
 		it "will find dependencies" do
+			h = Maruto::ModuleDefinition.parse_module_definition(@xml_nodes[:Mage_Core])
+			h.wont_include :dependencies
+
 			h = Maruto::ModuleDefinition.parse_module_definition(@xml_nodes[:Mage_Eav])
 			h.must_include :dependencies
 			h[:dependencies].size.must_equal 1
@@ -179,15 +182,25 @@ describe Maruto::ModuleDefinition do
 		end
 		it "will not include inactive modules (in Array or Hash)" do
 			parsed_module_definitions = [
-				@module_a.merge({ :active => false}),
+				@module_a.merge({ :active => false }),
+			]
+			a,h = Maruto::ModuleDefinition.analyse_module_definitions(parsed_module_definitions)
+			a.size.must_equal 0
+			h.size.must_equal 0
+		end
+		it "will warn when a core/Mage_ module is inactive" do
+			parsed_module_definitions = [
+				@module_a.merge({ :active => false, :warnings => ['first warning'] }),
 			]
 			a,h = Maruto::ModuleDefinition.analyse_module_definitions(parsed_module_definitions)
 			a.size.must_equal 0
 			h.size.must_equal 0
+			parsed_module_definitions[0][:warnings].size.must_equal 2
+			parsed_module_definitions[0][:warnings][-1][:message].must_include 'inactive'
 		end
 		it "will remove missing dependencies and add a warning" do
 			parsed_module_definitions = [
-				@module_a.merge({ :active => true, :dependencies => [:Mage_B, :Mage_C], :warnings => ['first warning']}),
+				@module_a.merge({ :active => true, :dependencies => [:Mage_B, :Mage_C], :warnings => ['first warning'] }),
 				@module_b.merge({ :active => true }),
 				@module_c.merge({ :active => false }),
 			]
@@ -198,7 +211,7 @@ describe Maruto::ModuleDefinition do
 		end
 		it "will remove duplicate dependencies and add a warning" do
 			parsed_module_definitions = [
-				@module_a.merge({ :active => true, :dependencies => [:Mage_B, :Mage_C, :Mage_B], :warnings => ['first warning']}),
+				@module_a.merge({ :active => true, :dependencies => [:Mage_B, :Mage_C, :Mage_B], :warnings => ['first warning'] }),
 				@module_b.merge({ :active => true }),
 				@module_c.merge({ :active => true }),
 			]

data/spec/module_events_spec.rb

@@ -6,166 +6,426 @@ module Maruto
 
 	describe ModuleConfiguration do
 
-		describe "when parsing a module config.xml" do
-			describe "and reading events observers" do
-				before do
-					@xml_node = Nokogiri::XML('''
-						<events>
-							<first_event>
-								<observers>
-									<first_observer>
-										<type>model</type>                    <!-- model, object or singleton -->
-										<class>Mage_A_Model_Observer</class>  <!-- observers class or class alias -->
-										<method>methodName</method>           <!-- observer\'s method to be called -->
-										<args></args>                         <!-- additional arguments passed to observer -->
-									</first_observer>
-								</observers>
-							</first_event>
-							<second_event>
-								<observers>
-									<second_observer>
-										<type>object</type>
-										<class>Mage_B_Model_Observer</class>
-										<method>doSomething</method>
-									</second_observer>
-									<third_observer>
-										<type>singleton</type>
-										<class>Mage_C_Model_Observer</class>
-										<method>helloWorld</method>
-									</third_observer>
-								</observers>
-							</second_event>
-						</events>
-					''').root.at_xpath('/')
-				end
-				it "will return a array of events" do
-					e = ModuleConfiguration.parse_scoped_events_observers('', @xml_node)
-					e.must_be_kind_of Array
-					e.size.must_equal 2
-				end
-				it "will handle a missing <events> element or a nil node" do
-					node = Nokogiri::XML('''
-						<hello></hello>
-					''').root.at_xpath('/')
-					e = ModuleConfiguration.parse_scoped_events_observers('', node)
-					e.must_be_kind_of Array
-					e.size.must_equal 0
-
-					e = ModuleConfiguration.parse_scoped_events_observers('', nil)
-					e.must_be_kind_of Array
-					e.size.must_equal 0
-				end
-				it "will build the path to an event" do
-					e = ModuleConfiguration.parse_scoped_events_observers('root', @xml_node)
-					e[0][:path].must_equal 'root/events/first_event'
-				end
-				it "will read the name type class and method of an observer" do
-					e = ModuleConfiguration.parse_scoped_events_observers('', @xml_node)
-					e[0][:observers][0][:name].must_equal 'first_observer'
-					e[0][:observers][0][:type].must_equal 'model'
-					e[0][:observers][0][:class].must_equal 'Mage_A_Model_Observer'
-					e[0][:observers][0][:method].must_equal 'methodName'
-				end
-				it "will build the path to an event observer" do
-					e = ModuleConfiguration.parse_scoped_events_observers('root', @xml_node)
-					e[0][:observers][0][:path].must_equal 'root/events/first_event/observers/first_observer'
-				end
-				it "will group observers by events" do
-					e = ModuleConfiguration.parse_scoped_events_observers('', @xml_node)
-					e.size.must_equal 2
-					e[0].must_include :name
-					e[0].must_include :observers
-					e[0][:name].must_equal 'first_event'
-					e[0][:observers].size.must_equal 1
-					e[1][:name].must_equal 'second_event'
-					e[1][:observers].size.must_equal 2
-				end
 
-				# TODO multiple global xml nodes?
-
-				# it "will warn when an event has no observers" do
-				# 	@xml_node_no_obs = Nokogiri::XML('''
-				# 		<events><first_event></first_event></events>
-				# 	''').root.at_xpath('/events')
-				# 	e = ModuleConfiguration.parse_events_observers(@xml_node_no_obs)
-				# 	e.size.must_equal 1
-				# 	e[0].must_include :warnings
-				# 	e[0][:warnings].size.must_equal 1
-				# end
-				# it "will warn when an event has an empty observers node" do
-				# 	@xml_node_empty_obs = Nokogiri::XML('''
-				# 		<events><first_event><observers></observers></first_event></events>
-				# 	''').root.at_xpath('/events')
-				# 	e = ModuleConfiguration.parse_events_observers(@xml_node_empty_obs)
-				# 	e.size.must_equal 1
-				# 	e[0][:warnings].size.must_equal 1
-				# end
-				# it "will warn if an observers type is invalid" do
-				# 	e = ModuleConfiguration.parse_events_observers(@xml_node)
-				# 	e[1][:warnings].size.must_equal 1
-				# 	e[1][:warnings][0].must_include '<type>something</type>'
-				# end
-				# it "will warn if an observers class is invalid" do
-				# 	# TODO
-				# end
+		describe "when parsing a module config.xml and reading scoped event observers" do
+
+			before do
+				@events_root = Nokogiri::XML('''
+					<events>
+						<first_event>
+							<observers>
+								<first_observer>
+									<type>model</type>                    <!-- model, singleton or disabled, default is singleton (object is an alias for model) -->
+									<class>Mage_A_Model_Observer</class>  <!-- observers class or class alias -->
+									<method>methodName</method>           <!-- observer\'s method to be called -->
+									<args></args>                         <!-- additional arguments passed to observer -->
+								</first_observer>
+							</observers>
+						</first_event>
+						<second_event>
+							<observers>
+								<second_observer>
+									<class>Mage_B_Model_Observer</class>
+									<method>doSomething</method>
+								</second_observer>
+								<third_observer>
+									<type>object</type>
+									<class>Mage_C_Model_Observer</class>
+									<method>helloWorld</method>
+								</third_observer>
+								<disabled_observer>
+									<type>disabled</type>
+									<class>Mage_C_Model_Observer</class>
+									<method>helloWorld</method>
+								</disabled_observer>
+							</observers>
+						</second_event>
+					</events>
+				''').root.xpath('/')
 			end
 
-			it "will group events by scope and build the correct path" do
+			it "will return a array of events" do
+				events, warnings = ModuleConfiguration.parse_scoped_event_observers('', @events_root)
+				events.must_be_kind_of Array
+				events.size.must_equal 2
+			end
+			it "will return a array of warnings" do
+				events, warnings = ModuleConfiguration.parse_scoped_event_observers('', @events_root)
+				warnings.must_be_kind_of Array
+			end
+			it "will handle a missing <events> element or a nil node" do
+				node = Nokogiri::XML('''
+					<hello></hello>
+				''').root.xpath('/')
+				events, warnings = ModuleConfiguration.parse_scoped_event_observers('', node)
+				events.must_be_kind_of Array
+				events.size.must_equal 0
+
+				events, warnings = ModuleConfiguration.parse_scoped_event_observers('', nil)
+				events.must_be_kind_of Array
+				events.size.must_equal 0
+			end
+			it "will build the path to an event" do
+				events, warnings = ModuleConfiguration.parse_scoped_event_observers('root', @events_root)
+				events[0][:path].must_equal 'root/events/first_event'
+			end
+			it "will read the name, class, and method of an observer" do
+				events, warnings = ModuleConfiguration.parse_scoped_event_observers('', @events_root)
+				events[0][:observers][0][:name].must_equal 'first_observer'
+				events[0][:observers][0][:class].must_equal 'Mage_A_Model_Observer'
+				events[0][:observers][0][:method].must_equal 'methodName'
+			end
+			# see Mage_Core_Model_App::dispatchEvent
+			it "will read the type of an observer" do
+				events, warnings = ModuleConfiguration.parse_scoped_event_observers('', @events_root)
+				events[0][:observers][0][:type].must_equal :model
+			end
+			it "will handle observer declarations with default type" do
+				events, warnings = ModuleConfiguration.parse_scoped_event_observers('', @events_root)
+				events[1][:observers][0][:type].must_equal :singleton
+			end
+			it "will treat type 'object' as an alias to 'model'" do
+				events, warnings = ModuleConfiguration.parse_scoped_event_observers('', @events_root)
+				events[1][:observers][1][:type].must_equal :model
+			end
+			it "will handle disabled observers" do
+				events, warnings = ModuleConfiguration.parse_scoped_event_observers('', @events_root)
+				events[1][:observers][2][:type].must_equal :disabled
+			end
+			it "will handle observers with an invalid type and add a warning" do
+				node = Nokogiri::XML('''
+					<events>
+						<first_event>
+							<observers>
+								<invalid_type>
+									<type>something</type>
+									<class>Hello_World</class>
+									<method>helloWorld</method>
+								</invalid_type>
+							</observers>
+						</first_event>
+					</events>
+				''').root.xpath('/')
+				events, warnings = ModuleConfiguration.parse_scoped_event_observers('root', node)
+				events.size.must_equal 1
+				events[0][:observers].size.must_equal 1
+				events[0][:observers][0].must_include :type
+				events[0][:observers][0][:type].must_equal :singleton
+				warnings.size.must_equal 1
+				warnings[0].must_include 'root/events/first_event/observers/invalid_type/type'
+				warnings[0].must_include 'singleton'
+				warnings[0].must_include 'something'
+			end
+			it "will build the path to an event observer" do
+				events, warnings = ModuleConfiguration.parse_scoped_event_observers('root', @events_root)
+				events[0][:observers][0][:path].must_equal 'root/events/first_event/observers/first_observer'
+			end
+			it "will group observers by event" do
+				events, warnings = ModuleConfiguration.parse_scoped_event_observers('', @events_root)
+				events.size.must_equal 2
+				events[0].must_include :name
+				events[0].must_include :observers
+				events[0][:name].must_equal 'first_event'
+				events[0][:observers].size.must_equal 1
+				events[1][:name].must_equal 'second_event'
+				events[1][:observers].size.must_equal 3
+			end
+			it "will handle incomplete observer declarations" do
+				node = Nokogiri::XML('''
+					<events>
+						<first_event>
+							<observers>
+								<o1></o1>
+								<o2>
+									<class></class>
+									<method></method>
+								</o2>
+							</observers>
+						</first_event>
+					</events>
+				''').root.xpath('/')
+				events, warnings = ModuleConfiguration.parse_scoped_event_observers('root', node)
+				events.size.must_equal 1
+				events[0][:observers].size.must_be :>, 0
+			end
+			# it "will warn if an observers class is invalid" do
+			# 	# TODO
+			# end
+			it "will handle duplicate areas and add a warning" do
 				node = Nokogiri::XML('''<config>
-					<global>
+					<area>
 						<events>
 							<e1><observers></observers></e1>
 						</events>
-					</global>
-					<frontend>
+					</area>
+					<area>
 						<events>
 							<e2><observers></observers></e2>
-							<e3></e3>
 						</events>
-					</frontend>
-					<adminhtml>
-						<events>
-							<e4></e4>
-							<e5></e5>
-							<e6></e6>
-						</events>
-					</adminhtml>
+					</area>
 				</config>''').root
+				events, warnings = ModuleConfiguration.parse_scoped_event_observers('/config/area', node.xpath('/config/area'))
+				events.size.must_equal 2
+				warnings.size.must_equal 1
+				warnings[0].must_include '/config/area'
+			end
+		end
+
+		describe "when parsing all event observers" do
+
+			before do
+				@module_a = { :name => :Mage_A, :active => true, :code_pool => :core, :defined => 'a', :config_path => 'app/code/core/Mage/A/etc/config.xml' }
+				@xml_root = Nokogiri::XML('''
+					<config>
+						<global>
+							<events>
+								<e1><observers><o1><type>invalid</type></o1></observers></e1>
+							</events>
+						</global>
+						<frontend>
+							<events>
+								<e2><observers></observers></e2>
+								<e3></e3>
+							</events>
+						</frontend>
+						<adminhtml>
+							<events>
+								<e4></e4>
+								<e5></e5>
+								<e6></e6>
+							</events>
+						</adminhtml>
+						<crontab>
+							<events>
+								<e1></e1>
+							</events>
+						</crontab>
+					</config>
+				''').root
+			end
+
+			it "will add events to the module" do
+				@module_a.wont_include :events
+				ModuleConfiguration.parse_all_event_observers(@module_a, @xml_root)
+				@module_a.must_include :events
+			end
+
+			it "will collect warnings into an array" do
+				warnings = ModuleConfiguration.parse_all_event_observers(@module_a, @xml_root)
+				warnings.size.must_be :>, 0
+			end
+
+
+			it "will group events by scope and build the correct path" do
+				@module_a.wont_include :events
+				ModuleConfiguration.parse_all_event_observers(@module_a, @xml_root)
+				@module_a.must_include :events
 
-				e = ModuleConfiguration.parse_all_events_observers('root', node)
+				@module_a[:events].must_be_kind_of Hash
+				@module_a[:events].must_include :global
+				@module_a[:events].must_include :frontend
+				@module_a[:events].must_include :adminhtml
 
-				e.must_be_kind_of Hash
-				e.must_include :global
-				e.must_include :frontend
-				e.must_include :adminhtml
+				@module_a[:events][:global].size.must_equal 1
+				@module_a[:events][:global][0][:name].must_equal 'e1'
+				@module_a[:events][:global][0][:path].must_include '/config/global/events'
 
-				e[:global].size.must_equal 1
-				e[:global][0][:name].must_equal 'e1'
-				e[:global][0][:path].must_include 'root/global/events'
+				@module_a[:events][:frontend].size.must_equal 2
+				@module_a[:events][:frontend][0][:name].must_equal 'e2'
+				@module_a[:events][:frontend][0][:path].must_include '/config/frontend/events'
 
-				e[:frontend].size.must_equal 2
-				e[:frontend][0][:name].must_equal 'e2'
-				e[:frontend][0][:path].must_include 'root/frontend/events'
+				@module_a[:events][:adminhtml].size.must_equal 3
+				@module_a[:events][:adminhtml][0][:name].must_equal 'e4'
+				@module_a[:events][:adminhtml][0][:path].must_include '/config/adminhtml/events'
 
-				e[:adminhtml].size.must_equal 3
-				e[:adminhtml][0][:name].must_equal 'e4'
-				e[:adminhtml][0][:path].must_include 'root/adminhtml/events'
+				@module_a[:events][:crontab].size.must_equal 1
+				@module_a[:events][:crontab][0][:name].must_equal 'e1'
+				@module_a[:events][:crontab][0][:path].must_include '/config/crontab/events'
 			end
+
 			it "will skip scopes without events" do
-				node = Nokogiri::XML('''
+				node = Nokogiri::XML('''<config>
+					<global>
+						<events>
+							<e1><observers><o1></o1></observers></e1>
+						</events>
+					</global>
+				</config>''').root
+
+				@module_a.wont_include :events
+				ModuleConfiguration.parse_all_event_observers(@module_a, node)
+				@module_a.must_include :events
+
+				@module_a[:events].wont_include :frontend
+				@module_a[:events].wont_include :adminhtml
+			end
+
+			it "will skip :events without events" do
+				node = Nokogiri::XML('''<config>
 					<global>
 						<events>
 						</events>
 					</global>
 					<frontend>
 					</frontend>
-				''').root
-				e = ModuleConfiguration.parse_all_events_observers('', node)
-				e.must_be_kind_of Hash
-				e.wont_include :global
-				e.wont_include :frontend
-				e.wont_include :adminhtml
+				</config>''').root
+
+				@module_a.wont_include :events
+				warnings = ModuleConfiguration.parse_all_event_observers(@module_a, node)
+				@module_a.wont_include :events
+
+				warnings.size.must_equal 0
+			end
+
+			it "will add a warning for events in the 'admin' area" do
+				node = Nokogiri::XML('''<config>
+					<admin>
+						<events>
+						</events>
+					</admin>
+				</config>''').root
+
+				@module_a.wont_include :events
+				warnings = ModuleConfiguration.parse_all_event_observers(@module_a, node)
+				@module_a.wont_include :events
+
+				warnings.size.must_equal 1
+			end
+
+		end
+
+		describe "when collecting all event observers" do
+			before do
+				@module_a = { :name => :Mage_A, :active => true, :code_pool => :core, :defined => 'a', :config_path => 'app/code/core/Mage/A/etc/config.xml' }
+				@module_b = { :name => :Mage_B, :active => true, :code_pool => :core, :defined => 'b', :config_path => 'app/code/core/Mage/B/etc/config.xml' }
+				@module_c = { :name => :Mage_C, :active => true, :code_pool => :core, :defined => 'c', :config_path => 'app/code/core/Mage/C/etc/config.xml' }
+				@module_d = { :name => :Mage_D, :active => true, :code_pool => :core, :defined => 'd', :config_path => 'app/code/core/Mage/D/etc/config.xml' }
+
+				@observer_1 = { :name => 'a_o1', :type => 'singleton', :class => 'Mage_A_Model_Observer', :method => 'global_1' }
+
+				@module_a[:events] = {
+					:global => [{ :name => 'e1', :observers => [
+						@observer_1,
+						{ :name => 'a_o2', :type => 'singleton', :class => 'Mage_A_Model_Observer', :method => 'global_2' }
+					] }],
+					:adminhtml => [{ :name => 'e1', :observers => [
+						{ :name => 'a_o1', :type => 'singleton', :class => 'Mage_A_Model_Observer', :method => 'adminhtml_1' }
+					] }],
+					:frontend => [{ :name => 'e1', :observers => [
+						{ :name => 'a_o1', :type => 'singleton', :class => 'Mage_A_Model_Observer', :method => 'frontend_1' }
+					] }]
+				}
+
+				@sorted_modules = [@module_a]
+			end
+
+			it "will group observers by event" do
+				h = ModuleConfiguration.collect_scoped_event_observers(:global, @sorted_modules)
+				h.must_include 'e1'
+				h['e1'].must_include 'a_o1'
+				h['e1'].must_include 'a_o2'
+
+				[:name, :type, :class, :method].each do |key|
+					h['e1']['a_o1'].must_include key
+				end
+
+				@module_a.wont_include :warnings
+			end
+			it "will add the source module to the observer" do
+				h, w = ModuleConfiguration.collect_scoped_event_observers(:global, @sorted_modules)
+				h['e1']['a_o1'].must_include :module
+				h['e1']['a_o1'][:module].must_equal :Mage_A
+				@module_a.wont_include :warnings
 			end
+			it "will add a warning when overwriting an observer" do
+				@module_b[:events] = {
+					:global => [{ :name => 'e1', :observers => [ @observer_1 ] }]
+				}
+				h = ModuleConfiguration.collect_scoped_event_observers(:global, [@module_a, @module_b])
+
+				@module_b.must_include :warnings
+				@module_b[:warnings].size.must_equal 1
+			end
+			it "will add a warning when overwriting an observer without module dependency" do
+				# TODO
+			end
+			it "wont add a warning when overwriting an observer to disable it" do
+				# TODO
+			end
+			it "will add a warning when disabling a non-existing observer" do
+				# TODO
+			end
+
+
+			it "will include all areas" do
+				h = ModuleConfiguration.collect_event_observers([])
+
+				h.keys.size.must_equal 4
+
+				h.must_include :global
+				h.must_include :adminhtml
+				h.must_include :frontend
+				h.must_include :crontab
+
+				h[:global].must_be_kind_of Hash
+				h[:global].size.must_equal 0
+
+				h[:adminhtml].must_be_kind_of Hash
+				h[:adminhtml].size.must_equal 0
+
+				h[:frontend].must_be_kind_of Hash
+				h[:frontend].size.must_equal 0
+
+				h[:crontab].must_be_kind_of Hash
+				h[:crontab].size.must_equal 0
+			end
+
+			it "will group observers by area" do
+				h = ModuleConfiguration.collect_event_observers(@sorted_modules)
+
+				h[:global].must_include 'e1'
+				h[:global]['e1'].must_include 'a_o1'
+				h[:global]['e1'].must_include 'a_o2'
+
+				h[:adminhtml].must_include 'e1'
+				h[:adminhtml]['e1'].must_include 'a_o1'
+				h[:adminhtml]['e1'].wont_include 'a_o2'
+
+				h[:frontend].must_include 'e1'
+				h[:frontend]['e1'].must_include 'a_o1'
+				h[:frontend]['e1'].wont_include 'a_o2'
+
+				h[:crontab].wont_include 'e1'
+
+				@module_a.wont_include :warnings
+			end
+		end
+
+		describe "when analysing event observers" do
+
+			it "will add a warning when an observer has already been declared" do
+
+			end
+
+			# it "will warn when an event has no observers" do
+			# 	xml_node_no_obs = Nokogiri::XML('''
+			# 		<config><scope><events><first_event></first_event></events></scope></config>
+			# 	''').root
+			# 	events, warnings = ModuleConfiguration.parse_scoped_event_observers('root', xml_node_no_obs.xpath('/config/scope'))
+			# 	events.size.must_equal 0
+			# 	warnings.size.must_equal 1
+			# 	warnings[0].must_include 'root/events/first_event'
+			# end
+			# it "will warn when an event has an empty observers node" do
+			# 	xml_node_empty_obs = Nokogiri::XML('''
+			# 		<config><scope><events><first_event><observers></observers></first_event></events></scope></config>
+			# 	''').root
+			# 	events, warnings = ModuleConfiguration.parse_scoped_event_observers('root', xml_node_empty_obs.xpath('/config/scope'))
+			# 	events.size.must_equal 0
+			# 	warnings.size.must_equal 1
+			# 	warnings[0].must_include 'root/events/first_event/observers'
+			# end
+
 		end
 	end
 end

data/spec/module_version_spec.rb

@@ -20,29 +20,24 @@ module Maruto
 			''').root
 		end
 
-		it "will return the module definition hash" do
-			m = ModuleConfiguration.read_module_version(@module_a, @xml_config_root)
-			m.must_be_kind_of Hash
-			m.must_equal @module_a
+		it "will return the an array of warnings" do
+			warnings = ModuleConfiguration.parse_module_version(@module_a, @xml_config_root)
+			warnings.must_be_kind_of Array
 		end
-		it "will add the version to the hash" do
-			m = ModuleConfiguration.read_module_version(@module_a, @xml_config_root)
-			m.must_include :version
-			m[:version].must_equal '0.0.1'
+		it "will add the version to the module" do
+			ModuleConfiguration.parse_module_version(@module_a, @xml_config_root)
+			@module_a.must_include :version
+			@module_a[:version].must_equal '0.0.1'
 		end
 		it "will add a warning when then modules node is missing" do
-			w = @module_a.merge({ :warnings => ['first warning'] })
-			m = ModuleConfiguration.read_module_version(w, Nokogiri::XML('<config><a></a></config>').root)
-			m[:warnings].size.must_equal 2
-			m[:warnings][-1][:file].must_equal m[:config_path]
-			m[:warnings][-1][:message].must_include '/config/modules'
+			warnings = ModuleConfiguration.parse_module_version(@module_a, Nokogiri::XML('<config><a></a></config>').root)
+			warnings.size.must_equal 1
+			warnings[0].must_include '/config/modules'
 		end
 		it "will add a warning when then node with the module's name is missing" do
-			w = @module_a.merge({ :warnings => ['first warning'] })
-			m = ModuleConfiguration.read_module_version(w, Nokogiri::XML('<config><modules></modules></config>').root)
-			m[:warnings].size.must_equal 2
-			m[:warnings][-1][:file].must_equal m[:config_path]
-			m[:warnings][-1][:message].must_include '/config/modules/Mage_A'
+			warnings = ModuleConfiguration.parse_module_version(@module_a, Nokogiri::XML('<config><modules></modules></config>').root)
+			warnings.size.must_equal 1
+			warnings[0].must_include '/config/modules/Mage_A'
 		end
 		it "will add a warning when there is a node from a different module" do
 			xml_config_root = Nokogiri::XML('''
@@ -55,13 +50,10 @@ module Maruto
 					</Mage_B>
 				</modules></config>
 			''').root
-			w = @module_a.merge({ :warnings => ['first warning'] })
-			m = ModuleConfiguration.read_module_version(w, xml_config_root)
-			m[:warnings].size.must_equal 2
-			m[:warnings][-1][:file].must_equal m[:config_path]
-			m[:warnings][-1][:message].must_include 'Mage_B'
+			warnings = ModuleConfiguration.parse_module_version(@module_a, xml_config_root)
+			warnings.size.must_equal 1
+			warnings[0].must_include 'Mage_B'
 		end
 
 	end
-
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: maruto
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-03 00:00:00.000000000 Z
+date: 2013-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri