Class: Slather::ProfdataCoverageFile

Inherits:
Object
  • Object
show all
Includes:
CoverageInfo, CoverallsCoverage
Defined in:
lib/slather/profdata_coverage_file.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from CoverallsCoverage

#as_json

Methods included from CoverageInfo

#branch_coverage_data_for_statement_on_line, #include_file?, #num_branch_hits_for_statement_on_line, #num_branches_for_statement_on_line, #num_branches_testable, #num_branches_tested, #num_lines_testable, #num_lines_tested, #percentage_branch_coverage_for_statement_on_line, #percentage_lines_tested, #rate_branch_coverage_for_statement_on_line, #rate_branches_tested, #rate_lines_tested, #source_file_pathname_relative_to_repo_root

Constructor Details

#initialize(project, source, line_numbers_first) ⇒ ProfdataCoverageFile

Returns a new instance of ProfdataCoverageFile.



13
14
15
16
17
18
 
# File 'lib/slather/profdata_coverage_file.rb', line 13

def initialize(project, source, line_numbers_first)
  self.project = project
  self.source = source
  self.line_numbers_first = line_numbers_first
  create_line_data
end

Instance Attribute Details

#line_data ⇒ Object

Returns the value of attribute line_data.



11
12
13
 
# File 'lib/slather/profdata_coverage_file.rb', line 11

def line_data
  @line_data
end

#line_numbers_first ⇒ Object

Returns the value of attribute line_numbers_first.



11
12
13
 
# File 'lib/slather/profdata_coverage_file.rb', line 11

def line_numbers_first
  @line_numbers_first
end

#project ⇒ Object

Returns the value of attribute project.



11
12
13
 
# File 'lib/slather/profdata_coverage_file.rb', line 11

def project
  @project
end

#segments ⇒ Object

Returns the value of attribute segments.



11
12
13
 
# File 'lib/slather/profdata_coverage_file.rb', line 11

def segments
  @segments
end

#source ⇒ Object

Returns the value of attribute source.



11
12
13
 
# File 'lib/slather/profdata_coverage_file.rb', line 11

def source
  @source
end

Instance Method Details

#all_lines ⇒ Object 



88
89
90
 
# File 'lib/slather/profdata_coverage_file.rb', line 88

def all_lines
  @all_lines ||= source_code_lines
end

#branch_coverage_data ⇒ Object 



189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
 
# File 'lib/slather/profdata_coverage_file.rb', line 189

def branch_coverage_data
  @branch_coverage_data ||= begin
    branch_coverage_data = Hash.new

    self.segments.each do |segment|
      line, col, hits, has_count, *rest = segment
      next if !has_count
      if branch_coverage_data.key?(line)
        branch_coverage_data[line] = branch_coverage_data[line] + [hits]
      else
        branch_coverage_data[line] = [hits]
      end
    end

    branch_coverage_data
  end
end

#branch_region_data ⇒ Object 



207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
 
# File 'lib/slather/profdata_coverage_file.rb', line 207

def branch_region_data
  @branch_region_data ||= begin
    branch_region_data = Hash.new
    region_start = nil
    current_line = 0
    @segments ||= []
    @segments.each do |segment|
      line, col, hits, has_count, *rest = segment
      # Make column 0 based index
      col = col - 1
      if hits == 0 && has_count
        current_line = line
        region_start = col
      elsif region_start != nil && hits > 0 && has_count
        # if the region wrapped to a new line before ending, put nil to indicate it didnt end on this line
        region_end = line == current_line ? col - region_start : nil
        if branch_region_data.key?(current_line)
          branch_region_data[current_line] << [region_start, region_end]
        else
          branch_region_data[current_line] = [[region_start, region_end]]
        end
        region_start = nil
      end
    end
    branch_region_data
  end
end

#cleaned_gcov_data ⇒ Object 



98
99
100
 
# File 'lib/slather/profdata_coverage_file.rb', line 98

def cleaned_gcov_data
  source_data
end

#coverage_for_line(line, line_numbers_first = self.line_numbers_first) ⇒ Object 



145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
 
# File 'lib/slather/profdata_coverage_file.rb', line 145

def coverage_for_line(line, line_numbers_first = self.line_numbers_first)
  line = line.gsub(":", "|")

  if line_numbers_first
    line =~ /^(\s*)(\d*)\|(\s*)(\d+)\|/
    group = $4
  else
    line =~ /^(\s*)(\d*)\|/
    group = $2
  end

  if group == nil
    # Check for thousands or millions (llvm-cov outputs hit counts as 25.3k or 3.8M)
    if line_numbers_first
      did_match = line =~ /^(\s*)(\d+)\|(\s*)(\d+\.\d+)(k|M)\|/
      group = $4
      units_group = $5
    else
      did_match = line =~ /^(\s*)(\d+\.\d+)(k|M)\|/
      group = $2
      units_group = $3
    end

    if did_match
      count = group.strip
      units = units_group == 'k' ? 1000 : 1000000

      (count.to_f * units).to_i
    else
      return nil
    end
  else
    match = group.strip
    case match
    when /[0-9]+/
      match.to_i
    when /#+/
      0
    when "-"
      nil
    end
  end
end

#ignore_error_lines(lines, line_numbers_first = self.line_numbers_first) ⇒ Object 



76
77
78
79
80
81
82
 
# File 'lib/slather/profdata_coverage_file.rb', line 76

def ignore_error_lines(lines, line_numbers_first = self.line_numbers_first)
  if line_numbers_first
    lines.reject { |line| line.lstrip.start_with?('|', '--') }
  else
    lines
  end
end

#ignored? ⇒ Boolean

Returns:

  • (Boolean) 


248
249
250
251
252
253
254
255
256
257
258
 
# File 'lib/slather/profdata_coverage_file.rb', line 248

def ignored?
  path = source_file_pathname.to_s

  # This indicates a llvm-cov coverage warning (occurs if a passed in source file
  # is not covered or with cache in some cases).
  return true if path.end_with?("isn't covered.")
  # Ignore source files inside of platform SDKs
  return true if path.include?("/Xcode.*\.app\/Contents\/Developer\/Platforms")

  super
end

#line_coverage_data ⇒ Object 



139
140
141
142
143
 
# File 'lib/slather/profdata_coverage_file.rb', line 139

def line_coverage_data
  all_lines.map do |line|
    coverage_for_line(line, self.line_numbers_first)
  end
end

#line_number_in_line(line, line_numbers_first = self.line_numbers_first) ⇒ Object 



106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
 
# File 'lib/slather/profdata_coverage_file.rb', line 106

def line_number_in_line(line, line_numbers_first = self.line_numbers_first)
  if line_numbers_first
    # Skip regex if the number is the first thing in the line
    fastpath_number = line.to_i
    return fastpath_number if fastpath_number != 0
    line =~ /^(\s*)(\d*)/
    group = $2
  else
    line =~ /^(\s*)(\d*)\|(\s*)(\d+)\|/
    group = $4
  end

  if group != nil
    match = group.strip
    case match
      when /[0-9]+/
        return match.to_i
    end
  else
    # llvm-cov outputs hit counts as 25.3k or 3.8M, so check this pattern as well
    did_match = line =~ /^(\s*)(\d+\.\d+)(k|M)\|(\s*)(\d+)\|/

    if did_match
      match = $5.strip
      case match
        when /[0-9]+/
          return match.to_i
      end
    end
  end
  0
end

#line_number_separator ⇒ Object 



239
240
241
 
# File 'lib/slather/profdata_coverage_file.rb', line 239

def line_number_separator
  "|"
end

#path_on_first_line? ⇒ Boolean

Returns:

  • (Boolean) 


27
28
29
 
# File 'lib/slather/profdata_coverage_file.rb', line 27

def path_on_first_line?
  !source.lstrip.start_with?("1|")
end

#raw_data ⇒ Object 



102
103
104
 
# File 'lib/slather/profdata_coverage_file.rb', line 102

def raw_data
  self.source
end

#raw_source ⇒ Object 



92
93
94
95
96
 
# File 'lib/slather/profdata_coverage_file.rb', line 92

def raw_source
  self.source.lines.map do |line|
    line.split('|').last
  end.join
end

#source_code_lines ⇒ Object 



71
72
73
74
 
# File 'lib/slather/profdata_coverage_file.rb', line 71

def source_code_lines
  lines = self.source.split("\n")[(path_on_first_line? ? 1 : 0)..-1]
  ignore_error_lines(lines)
end

#source_data ⇒ Object 



84
85
86
 
# File 'lib/slather/profdata_coverage_file.rb', line 84

def source_data
  all_lines.join("\n")
end

#source_file ⇒ Object 



67
68
69
 
# File 'lib/slather/profdata_coverage_file.rb', line 67

def source_file
  File.new(source_file_pathname)
end

#source_file_basename ⇒ Object 



235
236
237
 
# File 'lib/slather/profdata_coverage_file.rb', line 235

def source_file_basename
  File.basename(source_file_pathname, '.swift')
end

#source_file_pathname ⇒ Object 



31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
# File 'lib/slather/profdata_coverage_file.rb', line 31

def source_file_pathname
  @source_file_pathname ||= begin
    if path_on_first_line?
      end_index = self.source.index(/:?\n/)
      if end_index != nil
        end_index -= 1
        path = self.source[0..end_index]
      else
        # Empty file, output just contains path
        path = self.source.sub ":", ""
      end
      path &&= Pathname(path)
    else
      # llvm-cov was run with just one matching source file
      # It doesn't print the source path in this case, so we have to find it ourselves
      # This is slow because we read every source file and compare it, but this should only happen if there aren't many source files
      digest = Digest::MD5.digest(self.raw_source)
      path = nil

      project.find_source_files.each do |file|
        file_digest = Digest::MD5.digest(File.read(file).strip)

        if digest == file_digest
          path = file
        end
      end

      path
    end
  end
end

#source_file_pathname=(source_file_pathname) ⇒ Object 



63
64
65
 
# File 'lib/slather/profdata_coverage_file.rb', line 63

def source_file_pathname= (source_file_pathname)
    @source_file_pathname = source_file_pathname
end