rubycritic 0.0.5 → 1.4.0

data/lib/rubycritic/analysers/smells/reek.rb

@@ -0,0 +1,44 @@
+require "rubycritic/analysers/helpers/reek"
+require "rubycritic/core/smell"
+
+module Rubycritic
+  module Analyser
+
+    class ReekSmells
+      def initialize(analysed_modules)
+        @analysed_modules = analysed_modules
+      end
+
+      def run
+        @analysed_modules.each do |analysed_module|
+          add_smells_to(analysed_module)
+        end
+      end
+
+      private
+
+      def add_smells_to(analysed_module)
+        Reek.new(analysed_module.path).smells.each do |smell|
+          analysed_module.smells << create_smell(smell)
+        end
+      end
+
+      def create_smell(smell)
+        Smell.new(
+          :locations => smell_locations(smell.source, smell.lines),
+          :context   => smell.context,
+          :message   => smell.message,
+          :type      => smell.smell_type,
+          :cost      => 0
+        )
+      end
+
+      def smell_locations(file_path, file_lines)
+        file_lines.uniq.map do |file_line|
+          Location.new(file_path, file_line)
+        end.sort
+      end
+    end
+
+  end
+end

data/lib/rubycritic/analysers_runner.rb

@@ -1,25 +1,36 @@
-require "rubycritic/analysers/reek"
-require "rubycritic/smell_adapters/reek"
+require "rubycritic/source_locator"
+require "rubycritic/core/analysed_module"
+require "rubycritic/analysers/smells/flay"
+require "rubycritic/analysers/smells/flog"
+require "rubycritic/analysers/smells/reek"
+require "rubycritic/analysers/complexity"
+require "rubycritic/analysers/churn"
+require "rubycritic/analysers/attributes"
 
 module Rubycritic
 
   class AnalysersRunner
-    ANALYSERS = ["Reek"]
+    ANALYSERS = [
+      Analyser::FlaySmells,
+      Analyser::FlogSmells,
+      Analyser::ReekSmells,
+      Analyser::Complexity,
+      Analyser::Attributes,
+      Analyser::Churn
+    ]
 
     def initialize(paths)
       @paths = paths
     end
 
     def run
-      smell_adapters
+      ANALYSERS.each { |analyser| analyser.new(analysed_modules).run }
+      analysed_modules
     end
 
-    private
-
-    def smell_adapters
-      ANALYSERS.map do |analyser_name|
-        analyser = Object.const_get("Rubycritic::Analyser::#{analyser_name}").new(@paths)
-        Object.const_get("Rubycritic::SmellAdapter::#{analyser_name}").new(analyser)
+    def analysed_modules
+      @analysed_modules ||= SourceLocator.new(@paths).pathnames.map do |pathname|
+        AnalysedModule.new(:pathname => pathname)
       end
     end
   end

data/lib/rubycritic/cli/application.rb

@@ -0,0 +1,24 @@
+require "rubycritic"
+require "rubycritic/cli/options"
+
+module Rubycritic
+  module Cli
+    class Application
+      STATUS_SUCCESS = 0
+      STATUS_ERROR   = 1
+
+      def initialize(argv)
+        @options = Options.new(argv)
+      end
+
+      def execute
+        parsed_options = @options.parse
+        ::Rubycritic.create(parsed_options).execute
+        STATUS_SUCCESS
+      rescue OptionParser::InvalidOption => error
+        $stderr.puts "Error: #{error}"
+        STATUS_ERROR
+      end
+    end
+  end
+end

data/lib/rubycritic/cli/options.rb

@@ -0,0 +1,79 @@
+require "optparse"
+
+module Rubycritic
+  module Cli
+    class Options
+      def initialize(argv)
+        @argv = argv
+        @parser = OptionParser.new
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def parse
+        @parser.new do |opts|
+          opts.banner = "Usage: rubycritic [options] [paths]"
+
+          opts.on("-p", "--path [PATH]", "Set path where report will be saved (tmp/rubycritic by default)") do |path|
+            @root = path
+          end
+
+          opts.on(
+            "-f", "--format [FORMAT]",
+            [:html, :json],
+            "Report smells in the given format:",
+            "  html (default)",
+            "  json"
+          ) do |format|
+            @format = format
+          end
+
+          opts.on("-m", "--mode-ci", "Use CI mode (faster, but only analyses last commit)") do
+            @mode = :ci
+          end
+
+          opts.on("--deduplicate-symlinks", "De-duplicate symlinks based on their final target") do
+            @deduplicate_symlinks = true
+          end
+
+          opts.on("--suppress-ratings", "Suppress letter ratings") do
+            @suppress_ratings = true
+          end
+
+          opts.on_tail("-v", "--version", "Show gem's version") do
+            @mode = :version
+          end
+
+          opts.on_tail("-h", "--help", "Show this message") do
+            @mode = :help
+          end
+        end.parse!(@argv)
+        self
+      end
+
+      def help_text
+        @parser.help
+      end
+
+      def to_h
+        {
+          :mode => @mode,
+          :root => @root,
+          :format => @format,
+          :deduplicate_symlinks => @deduplicate_symlinks,
+          :paths => paths,
+          :suppress_ratings => @suppress_ratings
+        }
+      end
+
+      private
+
+      def paths
+        if @argv.empty?
+          ["."]
+        else
+          @argv
+        end
+      end
+    end
+  end
+end

data/lib/rubycritic/commands/ci.rb

@@ -0,0 +1,26 @@
+require "rubycritic/source_control_systems/base"
+require "rubycritic/analysers_runner"
+require "rubycritic/reporter"
+
+module Rubycritic
+  module Command
+    class Ci
+      def initialize(paths)
+        @paths = paths
+        Config.source_control_system = SourceControlSystem::Base.create
+      end
+
+      def execute
+        report(critique)
+      end
+
+      def critique
+        AnalysersRunner.new(@paths).run
+      end
+
+      def report(analysed_modules)
+        Reporter.generate_report(analysed_modules)
+      end
+    end
+  end
+end

data/lib/rubycritic/commands/default.rb

@@ -0,0 +1,28 @@
+require "rubycritic/source_control_systems/base"
+require "rubycritic/analysers_runner"
+require "rubycritic/revision_comparator"
+require "rubycritic/reporter"
+
+module Rubycritic
+  module Command
+    class Default
+      def initialize(paths)
+        @paths = paths
+        Config.source_control_system = SourceControlSystem::Base.create
+      end
+
+      def execute
+        report(critique)
+      end
+
+      def critique
+        analysed_modules = AnalysersRunner.new(@paths).run
+        RevisionComparator.new(@paths).set_statuses(analysed_modules)
+      end
+
+      def report(analysed_modules)
+        Reporter.generate_report(analysed_modules)
+      end
+    end
+  end
+end

data/lib/rubycritic/commands/help.rb

@@ -0,0 +1,13 @@
+module Rubycritic
+  module Command
+    class Help
+      def initialize(help_text)
+        @help_text = help_text
+      end
+
+      def execute
+        puts @help_text
+      end
+    end
+  end
+end

data/lib/rubycritic/commands/version.rb

@@ -0,0 +1,11 @@
+require "rubycritic/version"
+
+module Rubycritic
+  module Command
+    class Version
+      def execute
+        puts "RubyCritic #{VERSION}"
+      end
+    end
+  end
+end

data/lib/rubycritic/configuration.rb

@@ -0,0 +1,33 @@
+module Rubycritic
+  class Configuration
+    attr_reader :root
+    attr_accessor :source_control_system, :mode, :format, :deduplicate_symlinks,
+      :suppress_ratings
+
+    def set(options)
+      self.mode = options[:mode] || :default
+      self.root = options[:root] || "tmp/rubycritic"
+      self.format = options[:format] || :html
+      self.deduplicate_symlinks = options[:deduplicate_symlinks] || false
+      self.suppress_ratings = options[:suppress_ratings] || false
+    end
+
+    def root=(path)
+      @root = File.expand_path(path)
+    end
+  end
+
+  module Config
+    def self.configuration
+      @configuration ||= Configuration.new
+    end
+
+    def self.set(options = {})
+      configuration.set(options)
+    end
+
+    def self.method_missing(method, *args, &block)
+      configuration.public_send(method, *args, &block)
+    end
+  end
+end

data/lib/rubycritic/core/analysed_module.rb

@@ -0,0 +1,66 @@
+require "virtus"
+require "rubycritic/core/rating"
+
+module Rubycritic
+
+  class AnalysedModule
+    include Virtus.model
+
+    attribute :name
+    attribute :pathname
+    attribute :smells,        Array,   :default => []
+    attribute :churn
+    attribute :committed_at
+    attribute :complexity
+    attribute :duplication,   Integer, :default => 0
+    attribute :methods_count
+
+    def path
+      @path ||= pathname.to_s
+    end
+
+    def cost
+      @cost ||= smells.map(&:cost).inject(0, :+) + (complexity / 25)
+    end
+
+    def rating
+      @rating ||= Rating.from_cost(cost)
+    end
+
+    def complexity_per_method
+      if methods_count == 0
+        "N/A"
+      else
+        complexity.fdiv(methods_count).round(1)
+      end
+    end
+
+    def smells?
+      !smells.empty?
+    end
+
+    def smells_at_location(location)
+      smells.select { |smell| smell.at_location?(location) }
+    end
+
+    def to_h
+      {
+        :name => name,
+        :path => path,
+        :smells => smells,
+        :churn => churn,
+        :committed_at => committed_at,
+        :complexity => complexity,
+        :duplication => duplication,
+        :methods_count => methods_count,
+        :cost => cost,
+        :rating => rating
+      }
+    end
+
+    def to_json(*a)
+      to_h.to_json(*a)
+    end
+  end
+
+end

data/lib/rubycritic/{location.rb → core/location.rb}

@@ -7,15 +7,30 @@ module Rubycritic
 
     def initialize(path, line)
       @pathname = Pathname.new(path)
-      @line = line
+      @line = line.to_i
+    end
+
+    def file_name
+      @pathname.basename.sub_ext("").to_s
     end
 
     def to_s
       "#{pathname}:#{line}"
     end
 
+    def to_h
+      {
+        :path => pathname.to_s,
+        :line => line
+      }
+    end
+
+    def to_json(*a)
+      to_h.to_json(*a)
+    end
+
     def ==(other)
-      self.class == other.class && state == other.state
+      state == other.state
     end
 
     def <=>(other)

data/lib/rubycritic/core/rating.rb

@@ -0,0 +1,30 @@
+module Rubycritic
+
+  class Rating
+    def self.from_cost(cost)
+      if    cost <= 2  then new("A")
+      elsif cost <= 4  then new("B")
+      elsif cost <= 8  then new("C")
+      elsif cost <= 16 then new("D")
+      else new("F")
+      end
+    end
+
+    def initialize(letter)
+      @letter = letter
+    end
+
+    def to_s
+      @letter
+    end
+
+    def to_h
+      @letter
+    end
+
+    def to_json(*a)
+      to_h.to_json(*a)
+    end
+  end
+
+end

data/lib/rubycritic/{smell.rb → core/smell.rb}

@@ -1,5 +1,5 @@
 require "virtus"
-require "rubycritic/location"
+require "rubycritic/core/location"
 
 module Rubycritic
 
@@ -7,37 +7,46 @@ module Rubycritic
     include Virtus.model
 
     attribute :context
+    attribute :cost
     attribute :locations
     attribute :message
     attribute :score
-    attribute :type
     attribute :status
+    attribute :type
 
-    def pathnames
-      @pathnames ||= locations.map(&:pathname).uniq
-    end
-
-    def located_in?(other_location)
+    def at_location?(other_location)
       locations.any? { |location| location == other_location }
     end
 
-    def has_multiple_locations?
+    def multiple_locations?
       locations.length > 1
     end
 
     def ==(other)
-      self.class == other.class && state == other.state
+      state == other.state
     end
     alias_method :eql?, :==
 
-    def <=>(other)
-      locations <=> other.locations
-    end
-
     def to_s
       "(#{type}) #{context} #{message}"
     end
 
+    def to_h
+      {
+        :context => context,
+        :cost => cost,
+        :locations => locations,
+        :message => message,
+        :score => score,
+        :status => status,
+        :type => type
+      }
+    end
+
+    def to_json(*a)
+      to_h.to_json(*a)
+    end
+
     def hash
       state.hash
     end

data/lib/rubycritic/generators/html/assets/javascripts/application.js

@@ -0,0 +1,104 @@
+prettyPrint();
+
+emphasizeLineFromFragment();
+
+function emphasizeLineFromFragment() {
+    emphasizeLine(window.location.hash)
+}
+
+$(".js-file-code").on("click", ".js-smell-location", emphasizeLineFromHref);
+
+function emphasizeLineFromHref(event) {
+    if (hrefTargetIsOnCurrentPage(this) && !event.ctrlKey) {
+        $(".js-file-code li").removeClass("highlight");
+        var lineId = "#" + this.href.split("#")[1];
+        emphasizeLine(lineId);
+        return false;
+    }
+}
+
+function hrefTargetIsOnCurrentPage(aTag) {
+    return (window.location.pathname === aTag.pathname);
+}
+
+function emphasizeLine(lineReference) {
+    scrollToTarget(lineReference);
+    highlightLine(lineReference);
+}
+
+function scrollToTarget(lineReference) {
+    $.scrollTo(lineReference, {
+        duration: 300,
+        easing: "linear",
+        onAfter: function() {
+            window.location.hash = lineReference;
+        }
+    });
+}
+
+function highlightLine(lineReference) {
+    $(lineReference).addClass("highlight");
+}
+
+$("#js-toggle-smells").on("click", toggleSmells);
+
+function toggleSmells() {
+    $(".js-smells").toggle();
+}
+
+$("#js-index-table")
+    .tablesorter({          // Sort the table
+        sortList: [[0,0]]   // on the first column, in ascending order
+    })
+    .floatThead();          // Make table headers stick to the top when scrolling
+
+$(".js-timeago").timeago();
+
+$("#js-chart-container").highcharts({
+    chart: {
+        type: "scatter",
+        zoomType: "xy"
+    },
+    title: {
+        text: "Churn vs Complexity"
+    },
+    xAxis: {
+        title: {
+            enabled: true,
+            text: "Churn"
+        },
+        floor: 0,
+        startOnTick: true,
+        endOnTick: true
+    },
+    yAxis: {
+        title: {
+            text: "Complexity"
+        },
+        floor: 0,
+        startOnTick: true,
+        endOnTick: true
+    },
+    plotOptions: {
+        scatter: {
+            marker: {
+                radius: 5,
+                states: {
+                    hover: {
+                        enabled: true,
+                        lineColor: "rgb(100,100,100)"
+                    }
+                }
+            },
+            tooltip: {
+                headerFormat: "<b>{point.key}</b><br>",
+                pointFormat: "Committed {point.x} times, with Flog score of {point.y}"
+            }
+        }
+    },
+    series: [{
+        showInLegend: false,
+        color: "steelblue",
+        data: turbulenceData
+    }]
+});