rubycrap 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: db809cb564df163b709e7d1c7ae2114161644f32
-  data.tar.gz: 3d3cf3be27dc9382a1db7835f868848532281f18
+  metadata.gz: 301a7ae4c8bff65e8a2924231b19633102557f6b
+  data.tar.gz: 59f381684ce7de0f62079b2a09e4de708b98a2be
 SHA512:
-  metadata.gz: c393f12154ab04189f87a9a32d7ee28d0426161f99f798cc74c12b1e13a8fae8384f00102680a5d44519333ca63225b26b5a634bb6cc32409bf6381e941ef59f
-  data.tar.gz: 5af210175f7635e59fcb91b8d44714b73075868eecfd5ac3698094933540858abc1d9e12ec8ea3b035a57be281872f396ad583b912667cd293f9cc43bc535f1f
+  metadata.gz: b866fdf70f7b39e647b17776c6173a1e7df631a60ad6ba64398b3c9fc847306a1ab69ed43c476baf226636ff4e2550f7905c963277c7461d13f6b86e800d5832
+  data.tar.gz: ee7c2f599cab9ced0627b0bad58fd715a2433d6fd32ccb26c02956719787e9350f2fee4280a6f42d4fe4f823c53bece0b8ba7b306de869e15c5531ed4bf9b02e

data/bin/rubycrap

@@ -6,8 +6,8 @@ require 'logger'
 read_filename = ARGV[0]
 
 if read_filename == nil
-	puts "Please specify an Simplecov coverage.json file as argument"
-	exit 1
+  puts "Please specify an Simplecov coverage.json file as argument"
+  exit 1
 end
 
 case ARGV[1]
@@ -17,4 +17,4 @@ else
   mode = Logger::WARN
 end
 
-Rubycrap.run(read_filename,mode)
+Rubycrap::Application.new(read_filename,mode).execute

data/lib/application.rb

@@ -0,0 +1,170 @@
+require 'parser/current'
+require 'flog_cli'
+require 'json'
+require 'builder'
+require 'rubycrap/logging'
+
+module Rubycrap
+class Application 
+	@simplecov_information=[]
+	@crap_methods=[]
+	def self.minfo(object)
+	  puts ">supports: #{(object.methods  - Object.methods).inspect}\n"
+	end
+
+ # def self.logger
+ #   @logger ||= Logger.new(STDOUT)
+ # end
+	#
+	# => reads the sourcefile with an ast parser to get all the methods, then calculate the method coverage
+	#
+	def self.process_simplecov_file(file)
+	  #get filename with its coverage information
+	  filename = file["filename"]
+    logger.debug(filename)
+	  parse_method_coverage(file,filename)
+	end
+
+	def self.parse_method_coverage(file,filename)
+	  ast = Parser::CurrentRuby.parse(File.open(filename, "r").read)
+	  recursive_search_ast(file,ast)
+	end
+
+	def self.calculate_method_coverage(file,startline,lastline)
+	  # first we get the coverage lines from simplecov
+	  # start position -1 and number of total lines (-1 if you dont want the end)
+	  total_lines = lastline-startline
+    logger.debug("startline #{startline}")
+    logger.debug("latline #{lastline}")
+	  coveragelinestotal = file["coverage"]
+	  	 
+    logger.debug( "total_lines #{total_lines}")
+	  coveragelines = coveragelinestotal.slice(startline-1,total_lines)
+    logger.debug("coveragelines: #{coveragelines}")
+	  covered_lines = 0
+	  coveragelines.each do |line|
+	    if !(line.to_s.eql? "0" or line.to_s.eql? "")
+	      covered_lines = covered_lines + 1
+	    end
+	  end
+	  method_coverage = covered_lines.to_f / total_lines.to_f
+    logger.debug("method_coverage: #{method_coverage}")
+	  return method_coverage
+	end
+
+	def self.recursive_search_ast(file,ast)
+		begin
+			ast.children.each do |child|
+				if child.class.to_s == "Parser::AST::Node"
+				  if (child.type.to_s == "def" or child.type.to_s == "defs")
+
+				    methodname = child.children[0].to_s
+				    startline = child.loc.line
+				    lastline = child.loc.last_line
+				    logger.debug("\nmethodname: #{methodname}")
+				    method_coverage = calculate_method_coverage(file,startline,lastline)
+
+				    @simplecov_information << {:name => methodname, :coverage => method_coverage , :startline => startline, :lastline => lastline}
+				  else
+				    recursive_search_ast(file,child)
+				  end
+				end
+			end
+		rescue
+			# maybe empty source code
+		end
+	end
+
+	def self.crap(score,coverage)
+	#    CRAP(m) = comp(m)^2 * (1 � cov(m)/100)^3 + comp(m)
+	  comp = score
+	  cov = coverage
+	  comp ** 2 * (1 - cov) ** 3 + comp
+	end
+
+	def self.calcualte_crap_from_flog(file)
+		begin
+			FlogCLI.load_plugins
+			options = FlogCLI.parse_options "-qma"
+			flogger = FlogCLI.new options
+
+			flogger.flog file["filename"]
+      logger.debug("flogger absolute_filename: #{file["filename"]}")
+			flogger.each_by_score nil do |class_method, score, call_list|
+				startline = flogger.method_locations[class_method].split(":")[1]
+				absolute_filename = flogger.method_locations[class_method].split(":")[0]
+        logger.debug("flogger startline: #{startline}")
+				#match simplecov line with startine form floc
+				element = @simplecov_information.detect {|f| f[:startline] == startline.to_i }
+				if element.to_s == ""
+          logger.debug("no match with simplecov for logger class_method: #{class_method} startline: #{startline} ")
+				else
+          logger.debug("flogger class_method: #{class_method} simplecov: #{element}")
+					test_coverage = element[:coverage]
+					@crap_methods << {:methodname => class_method, :flog_score => score , :filepath => absolute_filename, :startline => startline, :method_coverage => test_coverage, :crap_score => crap(score,test_coverage)}
+				end
+			end
+		rescue
+			# something went wrong with flog
+		end
+	end
+
+	def self.hasharray_to_html( hashArray )
+	  # collect all hash keys, even if they don't appear in each hash:
+	  headers = hashArray.inject([]){|a,x| a |= x.keys ; a}  # use array union to find all unique headers/keys                              
+
+	  html = Builder::XmlMarkup.new(:indent => 2)
+	  html.table {
+	    html.tr { headers.each{|h| html.th(h)} }
+	    hashArray.each do |row|
+	      html.tr { row.values.each { |value| html.td(value) }}
+	    end
+	  }
+	  return html
+	end
+
+	def self.run(coveragefile,mode)
+    logger.level = mode
+    coverage = JSON.parse(File.open(coveragefile, "r").read)
+
+		# file = coverage["files"].first
+		#
+		# => get all the source filenames from the coverage file
+		#
+		puts "total files: #{coverage["files"].count}"
+		coverage["files"].each.with_index(1) do |file, index|
+      logger.debug("file nr. #{index}")
+		  process_simplecov_file(file)
+		  calcualte_crap_from_flog(file)
+		end
+
+		@sorted = @crap_methods.sort_by { |k| -k[:crap_score] }
+
+		puts "\nRESULTS"
+		@sorted.each do |element|
+			puts "#{element[:crap_score].round}".ljust(6) + "#{element[:methodname]}  ---> #{element[:filepath]}:#{element[:startline]}"
+		end
+
+		#
+		# buidler sucks
+		# it doesnt do thead and tbody
+		# and th: isnt accepted in datatables
+
+
+		# <script   src="https://code.jquery.com/jquery-2.2.2.min.js"   integrity="sha256-36cp2Co+/62rEAAYHLmRCPIych47CvdM+uTBJwSzWjI="   crossorigin="anonymous"></script>
+		# <script   src="https://cdn.datatables.net/1.10.11/js/jquery.dataTables.js" crossorigin="anonymous"></script>
+		# <link rel="stylesheet" type="text/css" href="https://cdn.datatables.net/1.10.11/css/jquery.dataTables.min.css">
+		# <script type="text/javascript">
+		#   $(document).ready(function(){
+		#     $('#myTable').DataTable();
+		#   });
+		# </script>
+
+		# <table id="myTable">
+
+		File.open("CRAP.html", 'w') { |file| file.write(hasharray_to_html(@sorted)) }
+		puts "THE END"
+	end
+
+end
+end

data/lib/rubycrap.rb

@@ -1,169 +1,5 @@
-require 'parser/current'
-require 'flog_cli'
-require 'json'
-require 'builder'
-require 'logger'
+require 'rubycrap/application'
 
-class Rubycrap
-	@simplecov_information=[]
-	@crap_methods=[]
-	def self.minfo(object)
-	  puts ">supports: #{(object.methods  - Object.methods).inspect}\n"
-	end
-
-  def self.logger
-    @logger ||= Logger.new(STDOUT)
-  end
-	#
-	# => reads the sourcefile with an ast parser to get all the methods, then calculate the method coverage
-	#
-	def self.process_simplecov_file(file)
-	  #get filename with its coverage information
-	  filename = file["filename"]
-    logger.debug(filename)
-	  parse_method_coverage(file,filename)
-	end
-
-	def self.parse_method_coverage(file,filename)
-	  ast = Parser::CurrentRuby.parse(File.open(filename, "r").read)
-	  recursive_search_ast(file,ast)
-	end
-
-	def self.calculate_method_coverage(file,startline,lastline)
-	  # first we get the coverage lines from simplecov
-	  # start position -1 and number of total lines (-1 if you dont want the end)
-	  total_lines = lastline-startline
-    logger.debug("startline #{startline}")
-    logger.debug("latline #{lastline}")
-	  coveragelinestotal = file["coverage"]
-	  	 
-    logger.debug( "total_lines #{total_lines}")
-	  coveragelines = coveragelinestotal.slice(startline-1,total_lines)
-    logger.debug("coveragelines: #{coveragelines}")
-	  covered_lines = 0
-	  coveragelines.each do |line|
-	    if !(line.to_s.eql? "0" or line.to_s.eql? "")
-	      covered_lines = covered_lines + 1
-	    end
-	  end
-	  method_coverage = covered_lines.to_f / total_lines.to_f
-    logger.debug("method_coverage: #{method_coverage}")
-	  return method_coverage
-	end
-
-	def self.recursive_search_ast(file,ast)
-		begin
-			ast.children.each do |child|
-				if child.class.to_s == "Parser::AST::Node"
-				  if (child.type.to_s == "def" or child.type.to_s == "defs")
-
-				    methodname = child.children[0].to_s
-				    startline = child.loc.line
-				    lastline = child.loc.last_line
-				    logger.debug("\nmethodname: #{methodname}")
-				    method_coverage = calculate_method_coverage(file,startline,lastline)
-
-				    @simplecov_information << {:name => methodname, :coverage => method_coverage , :startline => startline, :lastline => lastline}
-				  else
-				    recursive_search_ast(file,child)
-				  end
-				end
-			end
-		rescue
-			# maybe empty source code
-		end
-	end
-
-	def self.crap(score,coverage)
-	#    CRAP(m) = comp(m)^2 * (1 � cov(m)/100)^3 + comp(m)
-	  comp = score
-	  cov = coverage
-	  comp ** 2 * (1 - cov) ** 3 + comp
-	end
-
-	def self.calcualte_crap_from_flog(file)
-		begin
-			FlogCLI.load_plugins
-			options = FlogCLI.parse_options "-qma"
-			flogger = FlogCLI.new options
-
-			flogger.flog file["filename"]
-      logger.debug("flogger absolute_filename: #{file["filename"]}")
-			flogger.each_by_score nil do |class_method, score, call_list|
-				startline = flogger.method_locations[class_method].split(":")[1]
-				absolute_filename = flogger.method_locations[class_method].split(":")[0]
-        logger.debug("flogger startline: #{startline}")
-				#match simplecov line with startine form floc
-				element = @simplecov_information.detect {|f| f[:startline] == startline.to_i }
-				if element.to_s == ""
-          logger.debug("no match with simplecov for logger class_method: #{class_method} startline: #{startline} ")
-				else
-          logger.debug("flogger class_method: #{class_method} simplecov: #{element}")
-					test_coverage = element[:coverage]
-					@crap_methods << {:methodname => class_method, :flog_score => score , :filepath => absolute_filename, :startline => startline, :method_coverage => test_coverage, :crap_score => crap(score,test_coverage)}
-				end
-			end
-		rescue
-			# something went wrong with flog
-		end
-	end
-
-	def self.hasharray_to_html( hashArray )
-	  # collect all hash keys, even if they don't appear in each hash:
-	  headers = hashArray.inject([]){|a,x| a |= x.keys ; a}  # use array union to find all unique headers/keys                              
-
-	  html = Builder::XmlMarkup.new(:indent => 2)
-	  html.table {
-	    html.tr { headers.each{|h| html.th(h)} }
-	    hashArray.each do |row|
-	      html.tr { row.values.each { |value| html.td(value) }}
-	    end
-	  }
-	  return html
-	end
-
-	def self.run(coveragefile,mode)
-    logger.level = mode
-    coverage = JSON.parse(File.open(coveragefile, "r").read)
-
-		# file = coverage["files"].first
-		#
-		# => get all the source filenames from the coverage file
-		#
-		puts "total files: #{coverage["files"].count}"
-		coverage["files"].each.with_index(1) do |file, index|
-      logger.debug("file nr. #{index}")
-		  process_simplecov_file(file)
-		  calcualte_crap_from_flog(file)
-		end
-
-		@sorted = @crap_methods.sort_by { |k| -k[:crap_score] }
-
-		puts "\nRESULTS"
-		@sorted.each do |element|
-			puts "#{element[:crap_score].round}".ljust(6) + "#{element[:methodname]}  ---> #{element[:filepath]}:#{element[:startline]}"
-		end
-
-		#
-		# buidler sucks
-		# it doesnt do thead and tbody
-		# and th: isnt accepted in datatables
-
-
-		# <script   src="https://code.jquery.com/jquery-2.2.2.min.js"   integrity="sha256-36cp2Co+/62rEAAYHLmRCPIych47CvdM+uTBJwSzWjI="   crossorigin="anonymous"></script>
-		# <script   src="https://cdn.datatables.net/1.10.11/js/jquery.dataTables.js" crossorigin="anonymous"></script>
-		# <link rel="stylesheet" type="text/css" href="https://cdn.datatables.net/1.10.11/css/jquery.dataTables.min.css">
-		# <script type="text/javascript">
-		#   $(document).ready(function(){
-		#     $('#myTable').DataTable();
-		#   });
-		# </script>
-
-		# <table id="myTable">
-
-		File.open("CRAP.html", 'w') { |file| file.write(hasharray_to_html(@sorted)) }
-		puts "THE END"
-	end
+module Rubycrap
 
 end
-

data/lib/rubycrap/application.rb

@@ -0,0 +1,42 @@
+require 'parser/current'
+require 'flog_cli'
+require 'json'
+require 'builder'
+require 'rubycrap/logging'
+require 'rubycrap/coverage'
+require 'rubycrap/crap'
+require 'rubycrap/reporter'
+
+module Rubycrap
+  class Application
+  
+    def initialize(filename,mode)
+      Rubycrap::logger.level = mode
+      coverage = JSON.parse(File.open(filename, "r").read)
+      @coverage_files = coverage["files"]
+    end
+
+    def self.minfo(object)
+      puts ">supports: #{(object.methods  - Object.methods).inspect}\n"
+    end
+
+    def execute
+      @crap_methods = []
+      puts "total files: #{@coverage_files.count}"
+      @coverage_files.each.with_index(1) do |file, index|
+        Rubycrap::logger.debug("file nr. #{index}")
+        simplecov_information = Rubycrap::Coverage.new(file).process_simplecov_file
+        @crap_methods.concat(Rubycrap::Crap.new(simplecov_information,file).calculate_with_flog)
+      end
+      show_results
+    end
+
+    def show_results
+      reporter = Rubycrap::Reporter.new(@crap_methods)
+      puts "\nTOP 10 RESULTS"
+      reporter.console
+      reporter.html
+      puts "THE END"
+    end
+  end
+end

data/lib/rubycrap/coverage.rb

@@ -0,0 +1,88 @@
+require 'rubycrap/logging'
+
+module Rubycrap
+  class Coverage
+
+    attr_reader :file,:filename, :coverage
+
+    def initialize(file)
+      @file = file
+      @filename = file["filename"]
+      @coverage = file["coverage"]
+      @simplecov_information = []
+    end
+
+    def process_simplecov_file
+      Rubycrap::logger.debug(filename)
+      ast = parse_method_coverage
+      search_methods(ast)
+      @simplecov_information
+    end
+
+    def parse_method_coverage
+       Parser::CurrentRuby.parse(File.open(filename, "r").read)
+    end
+
+    def search_methods(ast)
+	if (ast.nil?)
+		return nil
+	end
+	if(!ast.respond_to?(:children))
+		return nil
+	end
+        ast.children.each do |child|
+        if(child.class.to_s == "Parser::AST::Node")
+	Rubycrap::logger.debug("TYPE AST - #{child.type.to_s}")
+	end 
+	 if(def_method?(child))
+            methodname = child.children[0].to_s == "(self)" ? child.children[1].to_s : child.children[0].to_s
+            startline = child.loc.line
+            lastline = child.loc.last_line
+            Rubycrap::logger.debug("\nmethodname: #{methodname}")
+            method_coverage = calculate_method_coverage(startline,lastline)
+            @simplecov_information << {:name => methodname, 
+                                      :coverage => method_coverage , 
+                                      :startline => startline, 
+                                      :lastline => lastline}
+          else
+            search_methods(child)
+          end
+        end
+    end
+    
+    def calculate_method_coverage(startline,lastline)
+      total_lines = lastline-startline
+      Rubycrap::logger.debug("Startline #{startline} | Lastline #{lastline} | Total_lines #{total_lines}")
+      coveragelinestotal = coverage
+      coveragelines = coveragelinestotal.slice(startline-1,total_lines)
+      Rubycrap::logger.debug("coveragelines: #{coveragelines}")
+      covered_lines = 0
+      not_covered_lines = 0
+      coveragelines.each do |line|
+	if coverage?(line)
+          covered_lines += 1
+        end
+        if (line.to_s.eql? "0")
+          not_covered_lines += 1
+        end
+      end
+      valid_total_lines = covered_lines + not_covered_lines
+      method_coverage = covered_lines.to_f / valid_total_lines.to_f
+      Rubycrap::logger.debug("covered_lines: #{covered_lines}")
+      Rubycrap::logger.debug("not_covered_lines: #{not_covered_lines}")
+      Rubycrap::logger.debug("method_coverage: #{method_coverage}")
+      method_coverage
+    end
+
+    private
+    def def_method?(child)
+      child.class.to_s == "Parser::AST::Node" && 
+        (child.type.to_s == "def" or child.type.to_s == "defs")
+    end
+
+    def coverage?(line)
+      !(line.to_s.eql? "0" or line.to_s.eql? "")
+    end
+
+  end
+end

data/lib/rubycrap/crap.rb

@@ -0,0 +1,55 @@
+require 'flog_cli'
+require 'rubycrap/logging'
+
+module Rubycrap
+  class Crap
+    attr_reader :simplecov_information, :file
+    def initialize(simplecov_information,file)
+      @simplecov_information = simplecov_information
+      @file = file
+      @crap_methods= []
+    end
+
+    def crap(complexity,coverage)
+      complexity ** 2 * (1 - coverage) ** 3 + complexity
+    end
+
+    def calculate_with_flog
+        flog_file(file["filename"])
+        @flogger.each_by_score nil do |class_method, score, call_list|
+          startline = @flogger.method_locations[class_method].split(":")[1]
+          absolute_filename = @flogger.method_locations[class_method].split(":")[0]
+          Rubycrap::logger.debug("flogger class method name: #{class_method}")
+          flog_methodname = class_method.split("#")[1] || class_method.split("::")[1]
+          Rubycrap::logger.debug("flogger method name: #{flog_methodname}")
+          Rubycrap::logger.debug("flogger startline: #{startline}")
+          Rubycrap::logger.debug("SIMPPLECOV : #{simplecov_information}")
+          element = simplecov_information.detect {|f| f[:startline] == startline.to_i && f[:name] == flog_methodname}
+          if element.to_s == ""
+            Rubycrap::logger.debug("no match with simplecov for flogger class_method: #{class_method} startline: #{startline} ")
+          else
+            Rubycrap::logger.debug("flogger class_method: #{class_method} simplecov: #{element}")
+            test_coverage = element[:coverage]
+            @crap_methods << {:methodname => class_method, 
+                             :flog_score => score ,
+                             :filepath => absolute_filename, 
+                             :startline => startline, 
+                             :method_coverage => test_coverage, 
+                             :crap_score => crap(score,test_coverage)}
+          end
+        end
+        @crap_methods
+    end
+
+    private
+    
+    def flog_file(filename)
+      FlogCLI.load_plugins
+      options = FlogCLI.parse_options "-qma"
+      @flogger = FlogCLI.new options
+      @flogger.flog filename
+      Rubycrap::logger.debug("flogger absolute_filename: #{filename}")
+    end
+
+  end
+end

data/lib/rubycrap/logging.rb

@@ -1,6 +1,6 @@
 require 'logger'
 
-module Logging
+module Rubycrap
   def logger
     Logging.logger
   end

data/lib/rubycrap/reporter.rb

@@ -0,0 +1,83 @@
+module Rubycrap
+  class Reporter
+
+    attr_reader :crap_methods, :crap_methods_by_score
+
+    def initialize(crap_methods)
+      @crap_methods = crap_methods
+      @crap_methods_by_score = crap_methods.sort_by { |k| -k[:crap_score] }
+    end
+
+    def html
+      File.open("CRAP.html", 'w') { |file| file.write(build_html) }
+    end
+
+    def console
+      crap_methods_by_score[0..10].each do |element|
+        puts formated_result(element)
+      end
+    end
+
+    private
+
+    def build_html
+      html = Array.new(0)
+      html.push('<script   src="https://code.jquery.com/jquery-2.2.2.min.js"   integrity="sha256-36cp2Co+/62rEAAYHLmRCPIych47CvdM+uTBJwSzWjI="   crossorigin="anonymous"></script>')
+      html.push('<script   src="https://cdn.datatables.net/1.10.11/js/jquery.dataTables.js" crossorigin="anonymous"></script>')
+      html.push('<link rel="stylesheet" type="text/css" href="https://cdn.datatables.net/1.10.11/css/jquery.dataTables.min.css">')
+      html.push('<script type="text/javascript">')
+      html.push('  $(document).ready(function(){')
+      html.push('    $(\'#myTable\').DataTable();')
+      html.push('  });')
+      html.push('</script>')
+      html.push('<table id="myTable">')
+      html.push('<thead>')
+      html.push('  <tr>')
+      html.push('    <th>methodname</th>')
+      html.push('    <th>flog_score</th>')
+      html.push('    <th>filepath</th>')
+      html.push('    <th>startline</th>')
+      html.push('    <th>method_coverage</th>')
+      html.push('    <th>crap_score</th>')
+      html.push('  </tr>')
+      html.push('</thead>')
+      html.push('<tbody>')
+      html.push('')
+
+      @crap_methods_by_score.each do |element|
+        html.push('<tr>')
+        html.push("  <td>#{element[:methodname]}</td>")
+        html.push("  <td>#{element[:flog_score]}</td>")
+        html.push("  <td>#{element[:filepath]}</td>")
+        html.push("  <td>#{element[:startline]}</td>")
+        html.push("  <td>#{element[:method_coverage]}</td>")
+        html.push("  <td>#{element[:crap_score]}</td>")
+        html.push('</tr>')
+      end
+      html.push('</tbody>')
+      html.push('</table>')
+      html.join("\n")
+    end
+
+    def formated_result(element)
+      @crap_element = element
+      "#{crap_score} | #{method_name} |  #{file_path}:#{start_line}"
+    end
+
+    def crap_score
+      @crap_element[:crap_score].round.to_s.ljust(6)
+    end
+
+    def method_name
+      @crap_element[:methodname].ljust(50)
+    end
+
+    def file_path
+      @crap_element[:filepath]
+    end
+
+    def start_line
+      @crap_element[:startline]
+    end
+  end
+end

data/lib/rubycrap/version.rb

@@ -1,3 +1,3 @@
 module Rubycrap
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubycrap
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Ingo Gerhard Jauch
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-05 00:00:00.000000000 Z
+date: 2016-04-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -98,8 +98,13 @@ files:
 - README.md
 - Rakefile
 - bin/rubycrap
+- lib/application.rb
 - lib/rubycrap.rb
+- lib/rubycrap/application.rb
+- lib/rubycrap/coverage.rb
+- lib/rubycrap/crap.rb
 - lib/rubycrap/logging.rb
+- lib/rubycrap/reporter.rb
 - lib/rubycrap/version.rb
 - rubycrap.gemspec
 homepage: ''