Class: RakeOE::PrjFileCache

Inherits:
Object
  • Object
show all
Defined in:
lib/rakeoe/prj_file_cache.rb

Overview

Finds all project files and reads them into memory Maps found entries to the following hash format:

{"PRJ_TYPE1" => [{"NAME1"=>{"SETTING1" => "VALUE1", "SETTING2" => "VALUE2", ... },
                 {"NAME2"=>{"SETTING1" => "VALUE1", "SETTING2" => "VALUE2", ... },
                  ... ,
                ]
{"PRJ_TYPE2" => [{"NAME100"=>{"SETTING1" => "VALUE1", "SETTING2" => "VALUE2", ... },
                 {"NAME101"=>{"SETTING1" => "VALUE1", "SETTING2" => "VALUE2", ... },
                 ... ,
                ]
}

XXX DS: IDEA: generate all runtime dependencies at the beginning for each prj, XXX DS: e.g. lib includes, source files, dependency files etc. and cache those as own variable in @prj_list

Class Attribute Summary collapse

Class Method Summary collapse

Class Attribute Details

.prj_list ⇒ Object

Returns the value of attribute prj_list.



24
25
26
 
# File 'lib/rakeoe/prj_file_cache.rb', line 24

def prj_list
  @prj_list
end

Class Method Details

.contain?(prj_type, prj_name) ⇒ Boolean

Do we know anything about prj_name ?

Returns:

  • (Boolean) 


115
116
117
118
 
# File 'lib/rakeoe/prj_file_cache.rb', line 115

def self.contain?(prj_type, prj_name)
  return false unless @prj_list.has_key?(prj_type)
  @prj_list[prj_type].has_key?(prj_name)
end

.deps_recursive(values, setting, visited = Set.new) ⇒ Object

Recursive function that uses each value of the array given via parameter ‘values’ and uses parameter ‘setting’ for accessing the values for next recursion step until all values have been traversed in all projects



146
147
148
149
150
151
152
153
154
155
 
# File 'lib/rakeoe/prj_file_cache.rb', line 146

def self.deps_recursive(values, setting, visited=Set.new)
  return visited if values.nil?
  values.each do |val|
    next if (visited.include?(val))
    visited << val
    next_values = PrjFileCache.get_with_name(val, setting)
    deps_recursive(next_values, setting, visited)
  end
  visited
end

.directory(prj_type, prj_name) ⇒ Object

Returns the directory in which the prj is



129
130
131
132
 
# File 'lib/rakeoe/prj_file_cache.rb', line 129

def self.directory(prj_type, prj_name)
  return nil unless self.contain?(prj_type, prj_name)
  @prj_list[prj_type][prj_name]['PRJ_HOME']
end

.entries_reversed(prj_types) ⇒ Array

Returns all entries for given project types as an array of reversed prj_name => prj_type mappings

Parameters:

  • prj_types (Array) —

    project types as defined by the PRJ_TYPE property

Returns:

  • (Array) —

    Array of hashes prj_name => prj_type



191
192
193
194
195
 
# File 'lib/rakeoe/prj_file_cache.rb', line 191

def self.entries_reversed(prj_types)
  prj_types.each_with_object(Hash.new) do |prj_type, h|
    h.merge!(@prj_list[prj_type].invert) if @prj_list.has_key?(prj_type)
  end
end

.exported_lib_incs(name) ⇒ Object

Returns exported include directories of a library project. If given name does not exist in local library projects, an empty array is returned.

Parameters:

  • name —

    name of library

Returns:

  • exported library includes



278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
 
# File 'lib/rakeoe/prj_file_cache.rb', line 278

def self.exported_lib_incs(name)
  rv = []
  # try LIB
  exported_inc_dirs = self.get('LIB', name, 'EXPORTED_INC_DIRS')
  if exported_inc_dirs.to_s.empty?
    # try SOLIB
    exported_inc_dirs = self.get('SOLIB', name, 'EXPORTED_INC_DIRS')
    unless exported_inc_dirs.to_s.empty?
      exported_inc_dirs.split.each do |dir|
        rv << self.get('SOLIB', name, 'PRJ_HOME') + '/' + dir
      end
    end
  else
    exported_inc_dirs.split.each do |dir|
      rv << self.get('LIB', name, 'PRJ_HOME') + '/' + dir
    end
  end
  rv
end

.for_each(prj_type, &block) ⇒ Object

iterate over each project with given project type



135
136
137
138
 
# File 'lib/rakeoe/prj_file_cache.rb', line 135

def self.for_each(prj_type, &block)
  return unless @prj_list.has_key?(prj_type)
  @prj_list[prj_type].each_pair &block
end

.get(prj_type, prj_name, setting) ⇒ Object

Returns specific value of a setting of the specified project



90
91
92
93
 
# File 'lib/rakeoe/prj_file_cache.rb', line 90

def self.get(prj_type, prj_name, setting)
  return nil unless self.contain?(prj_type, prj_name)
  @prj_list[prj_type][prj_name][setting] || nil
end

.get_lib_entries(libs) ⇒ Object

Returns specific project library settings with given library names

Parameters:

  • libs —

    Name of libraries



77
78
79
80
81
82
83
84
85
 
# File 'lib/rakeoe/prj_file_cache.rb', line 77

def self.get_lib_entries(libs)
  rv = {}
  self.entries_reversed(['ALIB', 'SOLIB']).each_pair do |entries, prj_name|
    if libs.include?(prj_name)
      rv[prj_name] = entries
    end
  end
  rv
end

.get_with_name(prj_name, setting) ⇒ Object

Returns specific value of a setting of the specified project



98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/rakeoe/prj_file_cache.rb', line 98

def self.get_with_name(prj_name, setting)
  projects = @prj_list.values.flatten
  projects.each do |project|
    values = project[prj_name]
    if values
      value = values[setting].split
      if value
        return value
      else
        return []
      end
    end
  end
  []
end

.join_regex_keys_for!(a_string) ⇒ Object

Joins all entries with keys that are appended with a regular expression that match the given match_string. Make them available via the base key name without the regular expression.

Parameters:

  • a_string —

    String to be matched against key in all kvr with appended regular expression



245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
 
# File 'lib/rakeoe/prj_file_cache.rb', line 245

def self.join_regex_keys_for!(a_string)
  @prj_list.each_pair do |prj_type, prj_names|
    prj_names.each_pair do |prj_name, defs|
      defs.each_pair do |property, value|
        # split properties containing /../
        base, key_regex = property.split(/\//)
        if (key_regex)
          if a_string.match(Regexp.new(key_regex))
            if base.end_with?('_')
              base_key = base.chop
            else
              base_key = base
            end

            # if base_key does not yet exist, create an empty string
            @prj_list[prj_type][prj_name][base_key] ||= ''
            @prj_list[prj_type][prj_name][base_key] += " #{@prj_list[prj_type][prj_name][property]}"
          end
        end
      end
    end
  end
end

.project_entry_buildable?(entry, platform) ⇒ Boolean

Checks if the project entries build prerequisites are met.

If at least one of the following criteria are met, the method returns false:

* project variable PRJ_TYPE == "DISABLED"
* project variable IGNORED_PLATFORMS contains build platform

Parameters:

  • entry —

    The project name

  • platform —

    Current platform

Returns:

  • (Boolean) —

    true if project can be built on current platform

  • false if project settings prohibit building



215
216
217
218
 
# File 'lib/rakeoe/prj_file_cache.rb', line 215

def self.project_entry_buildable?(entry, platform)
  (entry['IGNORED_PLATFORMS'].include?(platform)) &&
      (entry['PRJ_TYPE'] != 'DISABLED')
end

.project_names(prj_type) ⇒ Object

Returns all found project names



122
123
124
125
 
# File 'lib/rakeoe/prj_file_cache.rb', line 122

def self.project_names(prj_type)
  return [] unless @prj_list.has_key?(prj_type)
  @prj_list[prj_type].keys
end

.search_recursive(params = {}) ⇒ Object

Searches recursively for all projects with name and associate Dependency with given attribute

Returns a hash of the following form: { ‘name1’ => [‘name2’, ‘name3’, …],

'name2' => ['name1', 'name3', ...],
'name3' => ['name1', 'name5', ...],

}



167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
 
# File 'lib/rakeoe/prj_file_cache.rb', line 167

def self.search_recursive(params={})
  attribute = params[:attribute]
  names = params[:names]
  rv = {}
  @prj_list.values.flatten.each do |projects|
    projects.each_pair do |prj_name, prj_attributes|
      if (names.include?(prj_name))
        attr_values = prj_attributes[attribute].split
        dependencies = deps_recursive(attr_values, attribute)
        rv[prj_name] = dependencies.to_a
      end
    end
  end
  rv
end

.set_defaults(properties) ⇒ Object

Sets default properties that should be included for every found project file



35
36
37
 
# File 'lib/rakeoe/prj_file_cache.rb', line 35

def self.set_defaults(properties)
  @defaults = properties
end

.sweep_recursive(dirs = []) ⇒ Object

Search, read and parse all project files in given directories and add them to prj_list according to their PRJ_TYPE setting.

Parameters:

  • dirs (defaults to: []) —

    List of directories to search recursively for prj.rake files



43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/rakeoe/prj_file_cache.rb', line 43

def self.sweep_recursive(dirs=[])
  globs = dirs.map{|dir| dir+'/**/prj.rake'}
  all_prj_files = FileList[globs]
  raise "No projects inside #{dirs}?!" if all_prj_files.empty?

  all_prj_files.each do |file|
    # extract last path from prj.rake as project name
    dir = File.dirname(file)
    name = File.basename(dir)
    kvr = KeyValueReader.new(file)
    kvr.merge(@defaults)

    prj_type = kvr.get('PRJ_TYPE')

    raise "Attribute PRJ_TYPE not set in #{dir}/prj.rake" if prj_type.empty?

    # add attribute PRJ_HOME
    kvr.set('PRJ_HOME', dir)
    kvr.set('PRJ_FILE', file)
    @prj_list[prj_type] ||= {}
    if @prj_list[prj_type].member?(name)
      raise "#{dir}/prj.rake: project \"#{name}\" for PRJ_TYPE \'#{prj_type}\' already defined in #{@prj_list[prj_type][name]['PRJ_HOME']}"
      # XXX we should use a new attribute PRJ_NAME for conflicting project names ...
    end

    @prj_list[prj_type].merge!({name => kvr.env})
  end
end