Class: Debci::Repository

Inherits:
Object
  • Object
show all
Defined in:
lib/debci/repository.rb

Overview

This class implements the backend access to the debci data files. Normally you should access the data through objects of the Debci::Package class, which you can obtain by calling this class' find_package method.

>> repository = Debci::Repository.new
>> package = repository.find_package('mypackage')

Defined Under Namespace

Classes: PackageNotFound

Instance Method Summary (collapse)

Constructor Details

- (Repository) initialize(path = nil)

:nodoc:



17
18
19
20
21
# File 'lib/debci/repository.rb', line 17

def initialize(path=nil) # :nodoc:
  path ||= Debci.config.data_basedir
  @path = path
  @data_dirs = Dir.glob(File.join(path, 'packages', '*', '*')).reject { |d| d =~ /\.old$/ }
end

Instance Method Details

- (Object) architectures

Returns an Array of architectures known to this debci instance



29
30
31
# File 'lib/debci/repository.rb', line 29

def architectures
  @architectures ||= @data_dirs.map { |d| File.basename(d) }.uniq.sort
end

- (Object) architectures_for(package)

Returns an Array of architectures for which there is data for package.



45
46
47
48
# File 'lib/debci/repository.rb', line 45

def architectures_for(package)
  package = String(package)
  data_dirs_for(package).map { |d| File.basename(d) }.uniq
end

- (Object) each_package

Iterates over all packages

For each package in the repostory, a Debci::Package object will be passed in to the block passed.

Example:

repository.each_package do |pkg| puts pkg end



76
77
78
79
80
81
# File 'lib/debci/repository.rb', line 76

def each_package
  packages.sort.each do |pkgname|
    pkg = Debci::Package.new(pkgname, self)
    yield pkg
  end
end

- (Object) find_package(name)

Returns a single package by its names.

Raises a Debci::PackageNotFound is there is no package with that name.



57
58
59
60
61
62
63
# File 'lib/debci/repository.rb', line 57

def find_package(name)
  if !packages.include?(name)
    raise PackageNotFound.new(name)
  end

  Debci::Package.new(name, self)
end

- (Object) history_for(package, suite, architecture)

Backend implementation for Debci::Package#history



112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
# File 'lib/debci/repository.rb', line 112

def history_for(package, suite, architecture)
  return unless File.exists?(file = File.join(data_dir(suite, architecture, package), 'history.json'))

  entries = nil

  begin
    File.open(file) do |f|
      entries = JSON.load(f)
    end
  rescue JSON::ParserError
    true
  end

  entries.map { |test| Debci::Status.from_data(test, suite, architecture) }
end

- (Object) news_for(package, n = 10)

Backend implementation for Debci::Package#news



129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
# File 'lib/debci/repository.rb', line 129

def news_for(package, n=10)
  suites = '{' + self.suites.join(',') + '}'
  architectures = '{' + self.architectures.join(',') + '}'
  history = Dir.glob(File.join(data_dir(suites, architectures, package), '[0-9]*.json')).sort_by { |f| File.basename(f) }

  news = []

  while !history.empty?
    file = history.pop
    dir = File.expand_path(File.dirname(file) + '/../..')
    suite = File.basename(File.dirname(dir))
    architecture = File.basename(dir)
    status = load_status(file, suite, architecture)
    if status.newsworthy?
      news << status
    end
    if news.size >= n
      break
    end
  end

  news
end

- (Object) packages

Returns a Set of packages known to this debci instance



34
35
36
# File 'lib/debci/repository.rb', line 34

def packages
  @packages ||= @data_dirs.map { |d| Dir.glob(File.join(d, '*/*')) }.flatten.map { |d| File.basename(d) }.to_set
end

- (Object) search(query)

Searches packages by name.

Returns an Array of Debci::Package objects. On an exact match, will return an Array with a single element. Otherwise all packages that match the query (which is converted into a regular expression) are returned.



88
89
90
91
92
93
94
95
96
97
98
99
# File 'lib/debci/repository.rb', line 88

def search(query)
  # first try exact match
  match = packages.select { |p| p == query }

  # then try regexp match
  if match.empty?
    re = Regexp.new(query)
    match = packages.select { |p| p =~ re }
  end

  match.map { |p| Debci::Package.new(p, self)}
end

- (Object) status_for(package)

Backend implementation for Debci::Package#status



102
103
104
105
106
107
108
109
# File 'lib/debci/repository.rb', line 102

def status_for(package)
  architectures.map do |arch|
    suites.map do |suite|
      status_file = File.join(data_dir(suite, arch, package), 'latest.json')
      load_status(status_file, suite, arch)
    end
  end
end

- (Object) status_history(suite, architecture)

Returns the status history for this debci instance



154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
# File 'lib/debci/repository.rb', line 154

def status_history(suite, architecture)
  return unless File.exists?(file = File.join(status_dir(suite, architecture), 'history.json'))

  data = nil

  begin
    File.open(file, 'r') do |f|
      data = JSON.load(f)
    end
  rescue JSON::ParserError
    true
  end

  data
end

- (Object) suites

Returns an Array of suites known to this debci instance



24
25
26
# File 'lib/debci/repository.rb', line 24

def suites
  @suites ||= Dir.glob(File.join(@path, 'packages', '*')).reject { |d| d =~ /\.old$/ }.map { |d| File.basename(d) }.sort
end

- (Object) suites_for(package)

Returns an Array of suites for which there is data for package.



39
40
41
42
# File 'lib/debci/repository.rb', line 39

def suites_for(package)
  package = String(package)
  data_dirs_for(package).map { |d| File.basename(File.dirname(d)) }.uniq
end