kwala 0.9.0

data/lib/kwala/actions/code_duplication.rb

@@ -0,0 +1,222 @@
+# $Id: code_duplication.rb 29 2008-04-02 07:32:44Z zev $
+#
+# This file implements the logic to check for source code duplication.
+#
+# Requires the Java program PMD which uses the CPD tool.
+
+# Copyright (c) 2006, Ubiquitous Business Technology (http://ubit.com)
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#
+#    * Redistributions of source code must retain the above copyright
+#      notice, this list of conditions and the following disclaimer.
+#
+#    * Redistributions in binary form must reproduce the above
+#      copyright notice, this list of conditions and the following
+#      disclaimer in the documentation and/or other materials provided
+#      with the distribution.
+#
+#    * Neither the name of Ubit nor the names of its
+#      contributors may be used to endorse or promote products derived
+#      from this software without specific prior written permission.
+#
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# == Author
+# Zev Blut (zb@ubit.com)
+
+
+class CodeDuplicationAction < BuildAction
+
+  def initialize
+    @duplicates = nil
+    @file_count = 0
+  end
+
+  def build_action(context)
+    temporarily_remove_symlinks(context.project_directory) do |dir|
+      @duplicates = find_duplicate_code(dir)
+    end
+    # Store file count for scoring
+    @file_count = context.ruby_files.size + context.test_files.size
+  end
+
+  def summary_display(context)
+    template = TemplateFile.new(self.class.summary_template_file)
+    context.amrita_data[:duplicate_code_results] = {
+      :duplicate_count => @duplicates.size,
+      :duplicates => @duplicates
+    }
+    context.amrita_data[:code_duplication_details] =
+     (Amrita::e(:a, :href=>"#{context.project_name}_code_duplication.html") { "Code Duplication Details" })
+    summary_expand(template, context)
+  end
+
+  def detailed_display(context)
+    det_res = expand_code_duplication_template(context.amrita_data[:duplicate_code_results])
+    det_file = "#{context.output_directory}/#{context.project_name}_code_duplication.html"
+    [det_file, det_res]
+  end
+
+  def score
+    # This should be based on code size ratio, for now using file count, but
+    # probably lines of code is better.
+    if @duplicates.size > @file_count
+      1
+    else
+      score_scaling(@duplicates.size, @file_count)
+    end
+  end
+
+  def find_duplicate_code(dir=Dir.pwd)
+    require "rexml/document"
+    results = Array.new
+    Open3.popen3( cpd_command(dir) ) do |stdin, stdout, stderr|
+      xml = time_out_readlines(stdout)
+      if cpd_error?(stderr) || xml.first == "IO readlines timed out."
+        return results
+      end
+      doc = REXML::Document.new(xml.join("\n"))
+      doc.elements.each("pmd-cpd/duplication") do |dup|
+        results << {
+          :duplicate =>  {
+            :entry_num => results.size,
+            :lines => dup.attribute("lines").to_s,
+            :tokens => dup.attribute("tokens").to_s,
+            :code_fragement => highlight_code(dup.elements["codefragment"].cdatas.to_s),
+            :files => dup.get_elements("file").map { |f|
+              {
+                :path => f.attribute("path").to_s,
+                :line => f.attribute("line").to_s
+              }
+            },
+          }
+        }
+      end
+    end
+    results
+  end
+
+
+  def expand_code_duplication_template(data)
+    template = TemplateFile.new(self.class.detailed_template_file)
+    data[:duplicate_refs] = data[:duplicates].map do |d|
+      {
+        :entry_num => Amrita::a(:href=>"\##{d[:duplicate][:entry_num]}") {d[:duplicate][:entry_num]}
+      }
+    end
+    max_size = (data[:duplicates].size - 1)
+    data[:duplicates].each_with_index do |d, idx|
+      d[:duplicate][:entry_num] = Amrita::a(:name=>"#{d[:duplicate][:entry_num]}") {d[:duplicate][:entry_num]}
+      if idx > 0
+        d[:duplicate][:prev_entry_num] = Amrita::a(:href=>"\##{idx - 1}") { "Prev" }
+      end
+      if idx < max_size
+        d[:duplicate][:next_entry_num] = Amrita::a(:href=>"\##{idx + 1}") { "Next" }
+      end
+    end
+    ProjectBuilderUtils.expand_template(template, data)
+  end
+
+  def highlight_code(code)
+    # Check if enscript is installed.
+    cmd = "/usr/bin/enscript --color --language=html -Eruby --output=-"
+    out_data = nil
+    Open3.popen3(cmd) do |stdin, stdout, stderr|
+      stdin.puts code
+      stdin.close
+      out_data = time_out_readlines(stdout).join("")
+      #time_out_readlines(stderr)
+    end
+    if (out_data && ( m = /(<pre>.*<\/pre>)/im.match(out_data) ) )
+      code = Amrita::SanitizedString.new(m[1])
+    end
+
+    code
+  end
+
+  def cpd_command(dir)
+    "java -Xmx256m -cp #{cpd_jar} net.sourceforge.pmd.cpd.CPD" +
+      " --minimum-tokens #{minimum_tokens} --files #{dir}" +
+      " --language ruby --format net.sourceforge.pmd.cpd.XMLRenderer"
+  end
+
+  def cpd_jar
+    EXTERNAL_DIR + "pmd.jar"
+  end
+
+  def minimum_tokens
+    50
+  end
+
+  def cpd_error?(stderr)
+    lines = stderr.readlines
+    if !lines.empty?
+      STDERR.puts "code_duplication error with cpd:", lines
+      true
+    else
+      false
+    end
+  end
+
+  def temporarily_remove_symlinks(dir)
+    symlinks = Hash.new
+
+    Find.find(dir) do |path|
+      if File.symlink?(path)
+        lnk = File.expand_path(path)
+
+        # Need to give it relative to lnk
+        src = File.expand_path(File.readlink(path), File.dirname(lnk))
+
+        # Only remove symlinks that are relative to dir. i.e. inside
+        # project to other parts of the project.
+
+        if src.index(dir) == 0
+
+          symlinks[lnk] = src
+
+          # Store if it is a directory
+          dircheck = File.directory?(path)
+
+          # Remove the link
+          FileUtils.rm_f(path)
+
+          if dircheck
+            # Prune must come after removing the file, because code
+            # after prune will not run.
+            Find.prune
+          end
+
+        end
+      end
+    end
+
+    yield dir
+  ensure
+
+    symlinks.each do |sym, source|
+      begin
+        FileUtils.ln_s(source, sym)
+      rescue => err
+        STDERR.puts "Cannot restore link:", err
+      end
+    end
+  end
+
+end

data/lib/kwala/actions/code_formatting.rb

@@ -0,0 +1,358 @@
+#!/usr/bin/env ruby -w
+# $Id: code_formatting.rb 29 2008-04-02 07:32:44Z zev $
+#
+# Checks for basic formatting violations.
+
+# Copyright (c) 2006, Ubiquitous Business Technology (http://ubit.com)
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#
+#    * Redistributions of source code must retain the above copyright
+#      notice, this list of conditions and the following disclaimer.
+#
+#    * Redistributions in binary form must reproduce the above
+#      copyright notice, this list of conditions and the following
+#      disclaimer in the documentation and/or other materials provided
+#      with the distribution.
+#
+#    * Neither the name of Ubit nor the names of its
+#      contributors may be used to endorse or promote products derived
+#      from this software without specific prior written permission.
+#
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# == Author
+# Zev Blut, Michael Reinsch, Pierre Baumard
+
+require 'stringio'
+
+# TODO: everything except CodeFormattingAction should be extracted from this file
+# - for dependency tracking & tests, cf. Coding Guidelines
+# - would also fix next issue
+
+# XXX: cheat to remove the need to require kwala
+# This should be fixed at a later time.
+if !defined? BuildAction
+  class BuildAction
+  end
+end
+
+
+class CodeFormattingAction < BuildAction
+
+  def initialize(receiver=AmritaViolationReceiver.new)
+    @receiver = receiver
+    @detector = ViolationDetector.new(@receiver)
+  end
+
+  def build_action(context)
+    context.ruby_files.each do |file|
+      check_formatting(file)
+    end
+  end
+
+  def summary_display(context)
+    template = TemplateFile.new(self.class.summary_template_file)
+
+    if @receiver.empty?
+      context.amrita_data[:code_formatting_details] = "Code Formatting"
+
+      msg = "There are no formatting violations."
+      context.amrita_data[:code_formatting_results] = msg
+    else
+
+      context.amrita_data[:code_formatting_results] = {
+        :headers => ["Files"] << @receiver.summary.keys,
+        :values => [@receiver.files] << @receiver.summary.values,
+      }
+
+      url = "#{context.project_name}_code_formatting.html"
+      context.amrita_data[:code_formatting_details] = Amrita::a(:href => url)
+    end
+
+    summary_expand(template, context)
+  end
+
+  def detailed_display(context)
+    template = TemplateFile.new(self.class.detailed_template_file)
+
+    context.amrita_data[:code_formatting_details] = {
+      :entry => @receiver.details
+    }
+
+    det_res = ProjectBuilderUtils.expand_template(template,
+                                                  context.amrita_data)
+
+    base_output_name = "#{ context.output_directory}/#{ context.project_name }"
+    det_file = base_output_name + "_code_formatting.html"
+
+    [det_file, det_res]
+  end
+
+  def score
+    return 10 if @receiver.empty?
+    errors = @receiver.summary.values.inject(0) {|s, v| s + v }
+    # For now made up mappings.
+    case errors
+    when 1..4 : 7
+    when 5..12 : 5
+    when 13..20 : 3
+    else
+      1
+    end
+  end
+
+  # Checks the formatting of a file
+  def check_formatting(file)
+    @detector.check(file)
+  end
+
+end
+
+
+class ViolationDetector
+  extend InheritanceTracker
+
+  attr_accessor :violation_rec
+
+  def initialize(violation_rec)
+    @detectors = []
+    @violation_rec = violation_rec
+  end
+
+  # If detector needs the whole file instead of the lines of the file,
+  # then it must overwrite this method to return false.
+  def uses_lines?
+    true
+  end
+
+  # Add a specific instance of a detector to use when checking for
+  # violations.
+  def add_detector(detector)
+    @detectors << detector
+  end
+
+  # Return detectors used for checking.  If no detectors were
+  # specifically added, then an instance of each subclass of
+  # ViolationDetector is returned.
+  def violation_detectors
+    if @detectors.empty?
+      @detectors = self.class.get_implementors.map { |k| k.new(violation_rec) }
+    end
+
+    @detectors
+  end
+
+  # Checks for violations in a file.
+  # == Parameters
+  # file:: The path to a file to check.
+  # Note: as Katagiri proposed we could make file an IO object to make
+  # this even more general and powerful.
+  def check(file)
+    lines = IO.readlines(file)
+
+    line_detectors, file_detectors = violation_detectors.partition do |vd|
+      vd.uses_lines?
+    end
+
+    line_detectors.each do |detector|
+      detector.check_lines(file, lines)
+    end
+
+    file_detectors.each do |detector|
+      detector.check_file(file)
+    end
+  end
+
+  #############################################################################
+  # Protected
+  #############################################################################
+  protected
+
+  # Overwrite this method to check against all lines in file.
+  # If you want to just check one line then use check_line.
+  # Return an array of violation, if no violations return an empty array.
+  def check_lines(file, lines)
+    viols = []
+
+    lines.each_with_index do |line, idx|
+      idx += 1
+      v = check_line(file, idx, line)
+      viols << v if v
+    end
+
+    viols
+  end
+
+  # Implement this method to check against a line in a file.
+  # Return either a violation instance or nil if no violation found.
+  def check_line(file, line_num, line)
+  end
+
+  # If uses_lines returns false implement this method to check against
+  # the path to a file.
+  def check_file(file)
+  end
+
+end
+
+
+class FileLineCountViolationDetector < ViolationDetector
+
+  MAX_LINE_COUNT = 1000
+
+  def check_lines(file, lines)
+    if lines.size > MAX_LINE_COUNT
+      @violation_rec.violation(file, "", "",
+                               "File line count > #{MAX_LINE_COUNT}",
+                                "Warning")
+    end
+  end
+
+end
+
+
+class TrailingWhiteSpaceViolationDetector < ViolationDetector
+  # cannot use \s because that adds \n which is valid.
+  # Just check for " " and tab for now.
+  TRAILING_WHITE_SPACE = /[ \t]$/
+
+  def check_line(file, line_num, line)
+    if TRAILING_WHITE_SPACE =~ line
+      @violation_rec.violation(file, line_num, line,
+                               "Trailing White Space", "Warning")
+    end
+  end
+
+end
+
+
+class TabViolationDetector < ViolationDetector
+
+  TABS = /\t/
+
+  def check_line(file, line_num, line)
+    if TABS =~ line
+      @violation_rec.violation(file, line_num, line, "Tab", "Warning")
+    end
+  end
+
+end
+
+
+class LineLengthViolationDetector < ViolationDetector
+
+  MAX_LENGTH = 100
+  MAX_LENGTH_WITH_RETURN = MAX_LENGTH + 1 # with \n
+
+  def check_line(file, line_num, line)
+
+    if line.length > MAX_LENGTH_WITH_RETURN
+      @violation_rec.violation(file, line_num, line,
+                               "Line length > #{MAX_LENGTH}",
+                               "Warning")
+
+    end
+  end
+
+end
+
+
+class EOLBackslashViolationDetector < ViolationDetector
+
+  FINAL_BACKSLASH = /\\$/
+
+  def check_line(file, line_num, line)
+    if FINAL_BACKSLASH =~ line
+      @violation_rec.violation(file, line_num, line,
+                               "Backslash at End of Line", "Warning")
+    end
+  end
+
+end
+
+
+class MissingFinalReturnViolationDetector < ViolationDetector
+
+  FINAL_RETURN = /\n$/
+
+  def check_lines(file, lines)
+    if FINAL_RETURN !~ lines.last
+      @violation_rec.violation(file, lines.size, lines.last,
+                               "Missing Final Return", "Warning")
+    end
+  end
+
+end
+
+
+class AmritaViolationReceiver
+
+  attr_reader :summary, :details
+
+  def initialize
+    @summary = Hash.new(0)
+    @details = []
+    @seen_files = []
+  end
+
+  def violation(file, line_num, line, type, level)
+    @summary[type] += 1
+    @details << {
+      :file => file,
+      :type => type,
+      :line_num => line_num,
+      :line => line.inspect
+    }
+    @seen_files << file if !@seen_files.include?(file)
+  end
+
+  def empty?
+    @details.empty?
+  end
+
+  def files
+    @seen_files.size
+  end
+
+end
+
+
+if __FILE__ == $0
+
+  class ViolationPrinter
+    attr_reader :num
+
+    def initialize()
+      @num = 0
+    end
+
+    def violation(file, line_num, line, type, level)
+      puts "#{file} : #{line_num} - #{level} : #{type}"
+      @num += 1
+    end
+  end
+
+  vp = ViolationPrinter.new
+  ca = CodeFormattingAction.new(vp)
+  ARGV.each do |file|
+    res = ca.check_formatting(file)
+  end
+  puts "Number of violations: #{vp.num}"
+
+end