pelusa 0.0.1

data/lib/pelusa/lint/demeter_law.rb

@@ -0,0 +1,35 @@
+module Pelusa
+  module Lint
+    class DemeterLaw
+      def initialize
+        @violations = Set.new
+      end
+
+      def check(klass)
+        initialize
+        iterate_lines!(klass)
+
+        return SuccessfulAnalysis.new(name) if @violations.empty?
+
+        FailedAnalysis.new(name, @violations) do |violations|
+          "There are #{violations.length} Demeter law violations in lines #{violations.to_a.join(', ')}."
+        end
+      end
+
+      private
+
+      def name
+        "Respects Demeter law"
+      end
+
+      def iterate_lines!(klass)
+        iterator = Iterator.new do |node|
+          if node.is_a?(Rubinius::AST::Send) && node.receiver.is_a?(Rubinius::AST::Send)
+            @violations << node.line
+          end
+        end
+        Array(klass).each(&iterator)
+      end
+    end
+  end
+end

data/lib/pelusa/lint/else_clauses.rb

@@ -0,0 +1,40 @@
+module Pelusa
+  module Lint
+    class ElseClauses
+      def initialize
+        @violations = Set.new
+      end
+
+      def check(klass)
+        initialize
+        iterate_lines!(klass)
+
+        return SuccessfulAnalysis.new(name) if @violations.empty?
+
+        FailedAnalysis.new(name, @violations) do |violations|
+          "There are #{violations.length} else clauses in lines #{violations.to_a.join(', ')}"
+        end
+      end
+
+      private
+
+      def name
+        "Doesn't use else clauses"
+      end
+
+      def iterate_lines!(klass)
+        iterator = Iterator.new do |node|
+          if node.is_a?(Rubinius::AST::If)
+            has_body = node.body && !node.body.is_a?(Rubinius::AST::NilLiteral)
+            has_else = node.else && !node.else.is_a?(Rubinius::AST::NilLiteral)
+
+            if has_body && has_else
+              @violations << node.else.line
+            end
+          end
+        end
+        Array(klass).each(&iterator)
+      end
+    end
+  end
+end

data/lib/pelusa/lint/indentation_level.rb

@@ -0,0 +1,94 @@
+module Pelusa
+  module Lint
+    class IndentationLevel
+      def initialize
+        @violations = Set.new
+      end
+
+      def check(klass)
+        initialize
+        iterate_lines!(klass)
+
+        return SuccessfulAnalysis.new(name) if @violations.empty?
+
+        FailedAnalysis.new(name, @violations) do |violations|
+          "There's too much indentation in lines #{violations.to_a.join(', ')}."
+        end
+      end
+
+      private
+
+      def name
+        "Doesn't use more than one indentation level inside methods"
+      end
+
+      def iterate_lines!(klass)
+        iterator = Iterator.new do |node|
+          if node.is_a?(Rubinius::AST::Define)
+            _iterate = Iterator.new do |node|
+              __iterate = Iterator.new do |node|
+                if body = get_body_from_node[node]
+                  if node.line != [body].flatten.first.line
+                    @violations << body.line
+                  end
+                end
+              end
+
+              Array(get_body_from_node[node]).each(&__iterate)
+            end
+            node.body.array.each(&_iterate)
+          end
+        end
+
+        Array(klass).each(&iterator)
+      end
+
+      def get_body_from_node
+        lambda do |node|
+          if node.respond_to?(:body) && !node.body.is_a?(Rubinius::AST::NilLiteral)
+             node.body
+          elsif node.respond_to?(:else)
+             node.else
+          end
+        end
+      end
+    end
+  end
+end
+    def check_indentation_levels!
+      violations = Set.new
+
+      get_body_from_node = lambda do |node|
+        if node.respond_to?(:body) && !node.body.is_a?(Rubinius::AST::NilLiteral)
+           node.body
+        elsif node.respond_to?(:else)
+           node.else
+        end
+      end
+
+      iterate = self.class.iterator do |node|
+        if node.is_a?(Rubinius::AST::Define)
+          _iterate = self.class.iterator do |node|
+            __iterate = self.class.iterator do |node|
+              if body = get_body_from_node[node]
+                if node.line != [body].flatten.first.line
+                  violations << body.line
+                end
+              end
+            end
+
+            Array(get_body_from_node[node]).each(&__iterate)
+          end
+          node.body.array.each(&_iterate)
+        end
+      end
+
+      report "Doesn't use more than one indentation level" do
+        Array(ast).each(&iterate)
+        if violations.empty?
+          Report.new
+        else
+          Report.new(violations) { |violations| "There's too much of indentation at lines #{violations.to_a.join(', ')}." }
+        end
+      end
+    end

data/lib/pelusa/lint/instance_variables.rb

@@ -0,0 +1,39 @@
+module Pelusa
+  module Lint
+    class InstanceVariables
+      def initialize
+        @ivars = Set.new
+      end
+
+      def check(klass)
+        initialize
+        iterate_lines!(klass)
+
+        return SuccessfulAnalysis.new(name) if @ivars.length < limit
+
+        FailedAnalysis.new(name, @ivars) do |ivars|
+          "This class uses #{ivars.length} instance variables: #{ivars.to_a.join(', ')}."
+        end
+      end
+
+      private
+
+      def name
+        "Uses less than #{limit} ivars"
+      end
+
+      def limit
+        3
+      end
+
+      def iterate_lines!(klass)
+        iterator = Iterator.new do |node|
+          if node.is_a?(Rubinius::AST::InstanceVariableAccess) || node.is_a?(Rubinius::AST::InstanceVariableAssignment)
+            @ivars << node.name
+          end
+        end
+        Array(klass).each(&iterator)
+      end
+    end
+  end
+end

data/lib/pelusa/lint/line_restriction.rb

@@ -0,0 +1,41 @@
+module Pelusa
+  module Lint
+    class LineRestriction
+      def initialize
+        @lines = Set.new
+      end
+
+      def check(klass)
+        initialize
+        iterate_lines!(klass)
+
+        return SuccessfulAnalysis.new(name) if lines < limit
+
+        FailedAnalysis.new(name, lines) do |lines|
+          "This class has #{lines} lines."
+        end
+      end
+
+      private
+
+      def name
+        "Is below #{limit} lines"
+      end
+
+      def limit
+        50
+      end
+
+      def lines
+        @lines.max - @lines.min
+      end
+
+      def iterate_lines!(klass)
+        iterator = Iterator.new do |node|
+          @lines << node.line if node.respond_to?(:line)
+        end
+        Array(klass).each(&iterator)
+      end
+    end
+  end
+end

data/lib/pelusa/lint/properties.rb

@@ -0,0 +1,37 @@
+module Pelusa
+  module Lint
+    class Properties
+      def initialize
+        @violations = Set.new
+      end
+
+      def check(klass)
+        initialize
+        iterate_lines!(klass)
+
+        return SuccessfulAnalysis.new(name) if @violations.empty?
+
+        FailedAnalysis.new(name, @violations) do |violations|
+          "There are getters, setters or properties in lines #{violations.to_a.join(', ')}"
+        end
+      end
+
+      private
+
+      def name
+        "Doesn't use getters, setters or properties"
+      end
+
+      def iterate_lines!(klass)
+        iterator = Iterator.new do |node|
+          if node.is_a?(Rubinius::AST::Send)
+            if [:attr_accessor, :attr_writer, :attr_reader].include? node.name
+              @violations << node.line
+            end
+          end
+        end
+        Array(klass).each(&iterator)
+      end
+    end
+  end
+end

data/lib/pelusa/lint/short_identifiers.rb

@@ -0,0 +1,54 @@
+module Pelusa
+  module Lint
+    class ShortIdentifiers
+      def initialize
+        @violations = Set.new
+      end
+
+      def check(klass)
+        initialize
+        iterate_lines!(klass)
+
+        return SuccessfulAnalysis.new(name) if @violations.empty?
+
+        FailedAnalysis.new(name, formatted_violations) do |violations|
+          "Names are too short: #{violations.join(', ')}"
+        end
+      end
+
+      private
+
+      def name
+        "Uses descriptive names"
+      end
+
+      def iterate_lines!(klass)
+        iterator = Iterator.new do |node|
+          if node.respond_to?(:name)
+            name = node.name.respond_to?(:name) ? node.name.name.to_s : node.name.to_s
+            if name =~ /[a-z]/ && name.length < 3 && !["p", "pp"].include?(name)
+              next if name =~ /^[A-Z]/ # Ignore constants
+              @violations << [name, node.line]
+            end
+          end
+        end
+        Array(klass).each(&iterator)
+      end
+
+      def formatted_violations
+        grouped_violations = @violations.inject({}) do |hash, (name, line)|
+          hash[name] ||= []
+          hash[name] << line
+          hash
+        end
+
+        violations = []
+
+        grouped_violations.each_pair do |name, lines|
+          violations << "#{name} (line #{lines.join(', ')})"
+        end
+        violations
+      end
+    end
+  end
+end

data/lib/pelusa/report.rb

@@ -0,0 +1,27 @@
+module Pelusa
+  # Public: A Report is a wrapper that relates a class name with all its
+  # analyses for different lint checks.
+  #
+  class Report
+    # Public: Initializes a new Report.
+    #
+    # class_name - The Symbol name of the class being analyzed.
+    # analyses   - An Array of Analysis objects.
+    def initialize(class_name, analyses)
+      @class_name = class_name
+      @analyses   = analyses
+    end
+
+    def class_name
+      @class_name
+    end
+
+    def analyses
+      @analyses
+    end
+
+    def successful?
+      @analyses.all? { |analysis| analysis.successful? }
+    end
+  end
+end

data/lib/pelusa/reporters/reporter.rb

@@ -0,0 +1,22 @@
+module Pelusa
+  class Reporter
+    def self.print_banner
+    end
+
+    def initialize(filename)
+      @filename = filename
+    end
+
+    def reports=(reports)
+      @reports = reports
+    end
+
+    def report
+      raise NotImplementedError
+    end
+
+    def successful?
+      @reports.all? { |report| report.successful? }
+    end
+  end
+end

data/lib/pelusa/reporters/ruby_reporter.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module Pelusa
+  class RubyReporter < Reporter
+    def report
+      hash = @reports.inject({}) do |acc, report|
+        class_name = report.class_name
+        acc[class_name] = hashify_report(report)
+        acc
+      end
+      hash[:filename] = @filename unless hash.empty?
+      hash
+    end
+
+    private
+
+    def hashify_report(report)
+      analyses = report.analyses
+      analyses.inject({}) do |acc, analysis|
+        name = analysis.name
+        acc[name] = {
+          status:  analysis.status,
+          message: analysis.message,
+        }
+        acc
+      end
+    end
+  end
+end

data/lib/pelusa/reporters/stdout_reporter.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+module Pelusa
+  class StdoutReporter < Reporter
+    def self.print_banner
+      puts "  \e[0;35mϟ\e[0m \e[0;32mPelusa \e[0;35mϟ\e[0m"
+      puts "  \e[0;37m----------\e[0m"
+    end
+
+    def report
+      puts "  \e[0;36m#{@filename}\e[0m"
+      puts
+
+      @reports.each do |class_report|
+        print_report(class_report)
+      end
+    end
+
+    private
+
+    def print_report(class_report)
+      class_name = class_report.class_name
+
+      puts "  class #{class_name}"
+
+      analyses = class_report.analyses
+      analyses.each do |analysis|
+        print_analysis(analysis)
+      end
+      puts
+    end
+
+    def print_analysis(analysis)
+      name    = analysis.name
+      status  = analysis.status
+      message = analysis.message
+
+      print "    \e[0;33m✿ %s \e[0m" % name
+
+      if analysis.successful?
+        print "\e[0;32m✓\e[0m\n"
+        return
+      end
+
+      print "\e[0;31m✗\n\t"
+      puts message
+      print "\e[0m"
+    end
+  end
+end