Class: Rulebow::Digest

Inherits:
Object
  • Object
show all
Defined in:
lib/rulebow/digest.rb

Overview

Digest class is used to read and write lists of files with their associated checksums. This class uses SHA1.

Defined Under Namespace

Classes: For

Constant Summary collapse

DEFAULT_NAME =

The name of the master digest.

'default'

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(system) ⇒ Digest

Initialize new instance of Digest.



27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/rulebow/digest.rb', line 27

def initialize(system)
  @system = system
  #@name   = (options[:name] || MASTER_NAME).to_s
  #@ignore = options[:ignore]

  @filename = system.state_file

  @current = Hash.new{ |h,k| h[k.to_s] = {} }
  @saved   = Hash.new{ |h,k| h[k.to_s] = {} }

  read
  refresh
end

Instance Attribute Details

#current ⇒ Hash (readonly)

Digest of files as they are presently on disk. [Hash]



16
17
18
 
# File 'lib/rulebow/digest.rb', line 16

def current
  @current
end

#saved ⇒ Hash (readonly)

Digest of files as saved in the digest file. [Hash]



19
20
21
 
# File 'lib/rulebow/digest.rb', line 19

def saved
  @saved
end

#system ⇒ System (readonly)

System instance. [System]



13
14
15
 
# File 'lib/rulebow/digest.rb', line 13

def system
  @system
end

Instance Method Details

#[](ruleset) ⇒ Object

Get current digest for a given ruleset.



42
43
44
 
# File 'lib/rulebow/digest.rb', line 42

def [](ruleset)
  for_ruleset(ruleset)
end

#checksum(file) ⇒ String

Compute the sha1 identifer for a file.



146
147
148
149
150
151
152
153
154
 
# File 'lib/rulebow/digest.rb', line 146

def checksum(file)
  sha = ::Digest::SHA1.new
  File.open(file, 'r') do |fh|
    fh.each_line do |l|
      sha << l
    end
  end
  sha.hexdigest
end

#clear_all ⇒ Object

Remove all digests.



54
55
56
 
# File 'lib/rulebow/digest.rb', line 54

def clear_all
  FileUtils.rm(filename)
end

#filename ⇒ String

The digest file’s path.



49
50
51
 
# File 'lib/rulebow/digest.rb', line 49

def filename
  @filename
end

#filter(ruleset, files) ⇒ Array<String>

Filter files of those to be ignored.



162
163
164
165
166
167
168
169
170
171
 
# File 'lib/rulebow/digest.rb', line 162

def filter(ruleset, files)
  #case ruleset.ignore
  #when Watchlist
    ruleset.digest.filter(files)
  #when Array
  #  files.reject!{ |path| ignore.any?{ |ig| /^#{ig}/ =~ path } }
  #else
  #  files
  #end
end

#for_ruleset(ruleset) ⇒ Object 



174
175
176
 
# File 'lib/rulebow/digest.rb', line 174

def for_ruleset(ruleset)
  For.instance(self, getruleset(ruleset))
end

#getruleset(ruleset) ⇒ Object (private) 



181
182
183
184
185
186
187
188
 
# File 'lib/rulebow/digest.rb', line 181

def getruleset(ruleset)
  case ruleset
  when Ruleset
    ruleset
  else
    system.rulesets[ruleset.to_sym]
  end
end

#read ⇒ void

This method returns an undefined value.

Load digest from file system.



61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
# File 'lib/rulebow/digest.rb', line 61

def read
  return unless File.exist?(filename)

  name = DEFAULT_NAME
  save = Hash.new{ |h,k| h[k.to_s] = {} }

  File.read(filename).lines.each do |line|
    if md = /^\[(\w+)\]$/.match(line)
      name = md[1]
    end
    if md = /^(\w+)\s+(.*?)$/.match(line)
      save[name][md[2]] = md[1]
    end
  end

  save.each do |name, digest|
    @saved[name] = digest
  end
end

#refresh(ruleset = nil) ⇒ void

This method returns an undefined value.

Refresh current digest for a given ruleset, or all rulesets if not given.



84
85
86
87
88
89
90
91
92
93
 
# File 'lib/rulebow/digest.rb', line 84

def refresh(ruleset=nil)
  if ruleset
    ruleset = getruleset(ruleset)
    current[ruleset.name.to_s] = ruleset.watchlist.digest
  else
    system.rulesets.each do |name, ruleset|
      refresh(ruleset)
    end
  end
end

#remove(ruleset) ⇒ Object

Remove digest.



116
117
118
119
120
121
122
123
124
 
# File 'lib/rulebow/digest.rb', line 116

def remove(ruleset)
  case ruleset
  when Ruleset
    current.remove(ruleset.name)
  else
    current.remove(ruleset.to_str)
  end
  save
end

#save(ruleset = nil) ⇒ void

This method returns an undefined value.

Save current digest.



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

def save(ruleset=nil)
  if ruleset
    ruleset = getruleset(ruleset)
    refresh(ruleset)
    saved[ruleset.name.to_s] = current[ruleset.name.to_s]
  else
    refresh
    saved = current
  end

  dir = File.dirname(filename)
  FileUtils.mkdir_p(dir) unless File.directory?(dir)
  File.open(filename, 'w') do |f|
    f << to_s
  end
end

#to_s ⇒ String

Produce the representation of the digest that is stored to disk.



129
130
131
132
133
134
135
136
137
138
139
 
# File 'lib/rulebow/digest.rb', line 129

def to_s
  s = ""
  saved.each do |name, list|
    s << "[#{name}]\n"
    list.each do |path, id|
      s << "#{id} #{path}\n"
    end
    s << "\n"
  end
  s
end