Module: Maruto::ModuleDefinition

Defined in:
lib/maruto/module_definition.rb

Defined Under Namespace

Classes: ModuleSorter

Class Method Summary collapse

Class Method Details

.analyse_module_definitions(module_definitions) ⇒ Object 



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
 
# File 'lib/maruto/module_definition.rb', line 77

def self.analyse_module_definitions(module_definitions)
  h = Hash.new
  module_definitions.each do |m|
    mod_name = m[:name]
    if h.include? mod_name then
      # disable first module
      h[mod_name][:active] = false
      m[:warnings] ||= []
      m[:warnings] << { :file => m[:defined], :message => "duplicate module definition (in '#{h[mod_name][:defined]}' and '#{m[:defined]}')" }
    end
    if m[:active]
      h[mod_name] = m
      m[:config_path] = "app/code/#{m[:code_pool]}/#{mod_name.to_s.gsub(/_/, '/')}/etc/config.xml"
      if !File.exist?(m[:config_path])
        m[:warnings] ||= []
        m[:warnings]<< { :file => m[:defined], :message => "config.xml is missing (searching '#{m[:config_path]}' for #{m[:name]})" }
        m[:active] = false
      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
  h.reject!{|n,m| !m[:active]}
  # check dependencies
  h.reject{|n,m| !m.include? :dependencies}.each do |mod_name, m|
    # group by module name: hash of module_name => [module_name]
    dependencies = m[:dependencies].group_by{ |e| e }
    # find duplicates
    duplicates       = Hash[dependencies.select{ |k, v| v.size > 1 }].keys  # in ruby 1.8.7 select returns an array of tuples
    # unique values
    m[:dependencies] = dependencies.keys
    if duplicates.size > 0
      m[:warnings] ||= []
      m[:warnings] << { :file => m[:defined], :message => "duplicate dependencies (#{duplicates.join(', ')})" }
    end
    m[:dependencies].delete_if do |d|
      unless h.include? d
        m[:warnings] ||= []
        m[:warnings] << { :file => m[:defined], :message => "missing dependency: '#{d}'" }
        true
      end
    end
  end
  [ModuleSorter.new(h).sorted, h]
end

.parse_all_module_definitions ⇒ Object 



57
58
59
 
# File 'lib/maruto/module_definition.rb', line 57

def self.parse_all_module_definitions()
  Dir.glob('app/etc/modules/*.xml').reduce([]) { |result, path| result + self.parse_module_definition_file(path) }
end

.parse_module_definition(xml_node) ⇒ Object 



7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
# File 'lib/maruto/module_definition.rb', line 7

def self.parse_module_definition(xml_node)
  module_definition = { :name => xml_node.name.to_sym }

  module_definition[:active]    = !(/^(false|off)$/ =~ xml_node.at_xpath('active').content) if xml_node.at_xpath('active')
  module_definition[:code_pool] = xml_node.at_xpath('codePool').content.to_sym if xml_node.at_xpath('codePool')

  deps = xml_node.xpath('depends/*').map { |e| e.name.to_sym }
  module_definition[:dependencies] = deps if deps.size > 0

  unless xml_node.at_xpath('active') and /^(true|false|off)$/ =~ xml_node.at_xpath('active').content then
    module_definition[:warnings] = []
    # TODO write test
    if xml_node.at_xpath('active')
      module_definition[:warnings] << { :message => "value for active element should be in ['true','false','off'] (element: #{xml_node.at_xpath('active')})" }
    else
      module_definition[:warnings] << { :message => "missing element: active (#{xml_node.path})" }
    end
  end

  unless xml_node.at_xpath('codePool') and /^(core|community|local)$/ =~ xml_node.at_xpath('codePool').content then
    module_definition[:warnings] ||= []
    # TODO write test
    if xml_node.at_xpath('codePool')
      module_definition[:warnings] << { :message => "value for codePool element should be in ['core','community','local'] (element: #{xml_node.at_xpath('codePool')})" }
    else
      module_definition[:warnings] << { :message => "missing element: codePool (#{xml_node.path})" }
    end
  end

  module_definition
end

.parse_module_definition_file(path) ⇒ Object 



39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
# File 'lib/maruto/module_definition.rb', line 39

def self.parse_module_definition_file(path)
  f = File.open(path)
  doc = Nokogiri::XML(f) { |config| config.strict }
  f.close

  modules = doc.xpath('//modules/*').map { |xml_node| self.parse_module_definition(xml_node).merge({:defined => path}) }

  modules.each do |m|
    if m.include? :warnings then
      m[:warnings].each do |w|
        w[:file] = path
      end
    end
  end

  modules
end