pelusa 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.rbx

data/.rvmrc

@@ -0,0 +1 @@
+rvm use rbx-head@pelusa

data/.travis.yml

@@ -0,0 +1,4 @@
+env:
+ - RBXOPT=-X19
+rvm:
+  - rbx-2.0

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in pelusa.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+
+task :default => :test

data/Readme.md

@@ -0,0 +1,74 @@
+# pelusa - a Ruby Lint to improve your OO skills [![Build Status](https://secure.travis-ci.org/codegram/pelusa.png)](http://travis-ci.org/codegram/pelusa)
+
+Pelusa is a static analysis tool and framework to inspect your code style and
+notify you about possible red flags or missing best practices.
+
+Above all pelusa _doesn't run your code_ -- it just analyzes it syntactically
+to gain superficial insights about it, and raise red flags when needed.
+
+Pelusa needs [Rubinius](http://rubini.us) to run, due to how easy it is to work
+with a Ruby AST with it, but it doesn't mean that your Ruby code must run on
+Rubinius. Since it's a static analysis tool, pelusa doesn't care what your code
+runs on, it just looks at it and tells you stuff.
+
+Here's a sample of pelusa linting on its own code base:
+
+![](http://f.cl.ly/items/3Z341M0q2u1K242m0144/%D0%A1%D0%BD%D0%B8%D0%BC%D0%BE%D0%BA%20%D1%8D%D0%BA%D1%80%D0%B0%D0%BD%D0%B0%202012-02-14%20%D0%B2%203.29.38%20PM.png)
+
+## Install and usage
+
+    rvm use rbx-head
+    gem install pelusa
+
+Then go to a directory where you have some Ruby code, and type this:
+
+    pelusa path/to/some_file.rb
+
+Or just run all the Ruby files (`**/*.rb`) without arguments:
+
+    pelusa
+
+## About the default set of Lints
+
+This project was born as an inspiration from [one of our Monday
+Talks](http://talks.codegram.com/object-oriented-nirvana) about Object Oriented
+Nirvana by @oriolgual. After reading [this blog
+post](http://binstock.blogspot.com/2008/04/perfecting-oos-small-classes-and-short.html)
+he prepared his talk and I (Txus) found it interesting, so I explored the
+possibility of programmatically linting these practices on a Ruby project. This
+*doesn't mean* that any of us thinks these are the true and only practices of
+Object Orientation, it's just a set of constraints that are fun to follow to
+achieve a mindset shift in the long run.
+
+Anyway, you are always free to implement your own lints, or the ones that suit
+your team the best.
+
+## Pelusa as a static analysis framework
+
+With Pelusa, writing your own lints becomes very easy. Check out some of the
+default lints under the `lib/pelusa/lint/` directory.
+
+At some point it will be user-extendable by default, but for now you are better
+off forking the project and adding your own lints as you need them in your team
+(or removing some default ones you don't like).
+
+## Contributing
+
+You can easily contribute to Pelusa. Its codebase is simple and
+[extensively documented][documentation].
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add specs for it. This is important so we don't break it in a future
+  version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  If you want to have your own version, that is fine but bump version
+  in a commit by itself I can ignore when I pull.
+* Send me a pull request. Bonus points for topic branches.
+
+[documentation]: http://rubydoc.info/github/codegram/pelusa/master/frames
+
+## License
+
+MIT License. Copyright 2011 [Codegram Technologies](http://codegram.com)
+

data/bin/pelusa

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'pelusa'
+
+cli = Pelusa::Cli.new(ARGV)
+exit cli.run

data/lib/pelusa.rb

@@ -0,0 +1,22 @@
+module Pelusa
+  # Public: Runs the runner on a set of files.
+  #
+  # Returns an Array of results of a given Reporter
+  def self.run(files=[], reporter=StdoutReporter, lints=Lint.all)
+    runner = Runner.new(lints, reporter)
+    runner.run(files)
+  end
+end
+
+require 'pelusa/cli'
+require 'pelusa/runner'
+require 'pelusa/analyzer'
+require 'pelusa/lint'
+require 'pelusa/analysis'
+require 'pelusa/class_analyzer'
+require 'pelusa/report'
+require 'pelusa/iterator'
+
+require 'pelusa/reporters/reporter'
+require 'pelusa/reporters/stdout_reporter'
+require 'pelusa/reporters/ruby_reporter'

data/lib/pelusa/analysis.rb

@@ -0,0 +1,88 @@
+module Pelusa
+  # Public: An Analysis the result of applying a Lint check to a class.
+  #
+  # Examples
+  #
+  #   analysis = SuccessfulAnalysis.new("Is below 50 lines")
+  #   analysis.successful?
+  #   # => true
+  #
+  #   failure = FailedAnalysis.new("Is below 50 lines", 123) do |lines|
+  #     "There are too many lines (#{lines})"
+  #   end
+  #   failure.successful?
+  #   # => false
+  #   failure.message
+  #   # => "There are too many lines (123)"
+  #
+  class Analysis
+    def initialize(name)
+      @name = name
+    end
+
+    def name
+      @name
+    end
+
+    def successful?
+      raise NotImplementedError
+    end
+
+    def failed?
+      not successful?
+    end
+
+    def message
+      ""
+    end
+
+    def status
+      successful? ? "successful" : "failed"
+    end
+  end
+
+  # Public: A SuccessfulAnalysis is an analysis that has passed a particular
+  # lint check.
+  #
+  class SuccessfulAnalysis < Analysis
+    # Public: A successful analysis is always successful, obviously.
+    #
+    # Returns true.
+    def successful?
+      true
+    end
+  end
+
+  # Public: A FailedAnalysis is an analysis that has failed a particular
+  # lint check.
+  #
+  class FailedAnalysis < Analysis
+    # Public: Initializes a new FailedAnalysis.
+    #
+    # name    - The name of the lint check.
+    # payload - An object to use in the message to aid the user in fixing the
+    #           problem.
+    # block   - A block to generate the message. It must yield the payload
+    #           object.
+    def initialize(name, payload, &block)
+      super(name)
+      @payload = payload
+      @block   = block
+    end
+
+    # Public: A failed analysis is never successful , obviously.
+    #
+    # Returns false.
+    def successful?
+      false
+    end
+
+    # Public: Generates an explicative message yielding the payload object to
+    # the block, so that the user gets some hint to fix the problem.
+    #
+    # Returns the String message.
+    def message
+      @block.call(@payload)
+    end
+  end
+end

data/lib/pelusa/analyzer.rb

@@ -0,0 +1,48 @@
+module Pelusa
+  class Analyzer
+    # Public: Initializes an Analyzer.
+    #
+    # ast      - The abstract syntax tree to analyze.
+    # reporter - The class that will be used to create the report.
+    # filename - The name of the file that we're analyzing.
+    def initialize(lints, reporter, filename)
+      @lints    = lints
+      @reporter = reporter.new(filename)
+    end
+
+    # Public: Makes a report out of several classes contained in the AST.
+    #
+    # ast - The abstract syntax tree to analyze.
+    #
+    # Returns a Report of all the classes.
+    def analyze(ast)
+      reports = extract_classes(ast).map do |klass|
+        class_analyzer = ClassAnalyzer.new(klass)
+        class_name     = class_analyzer.class_name
+        analysis       = class_analyzer.analyze(@lints)
+
+        Report.new(class_name, analysis)
+      end
+      @reporter.reports = reports
+      @reporter
+    end
+
+    #######
+    private
+    #######
+
+    # Internal: Extracts the classes out of the AST and returns their nodes.
+    #
+    # ast - The abstract syntax tree to extract the classes from.
+    #
+    # Returns an Array of Class nodes.
+    def extract_classes(ast)
+      classes = []
+      class_iterator = Iterator.new do |node|
+        classes << node if node.is_a?(Rubinius::AST::Class)
+      end
+      Array(ast).each(&class_iterator)
+      classes
+    end
+  end
+end

data/lib/pelusa/class_analyzer.rb

@@ -0,0 +1,28 @@
+class Pelusa::ClassAnalyzer
+  # Public: Initializes a ClassAnalyzer.
+  #
+  # klass - The class AST node.
+  def initialize(klass)
+    @klass = klass
+  end
+
+  # Public: Returns the name of the Class being analyzed.
+  #
+  # Returns the String name.
+  def class_name
+    name = @klass.name
+    name.name
+  end
+
+  # Public: Analyzes a class with a series of lints.
+  #
+  # lints - The lints to check for.
+  #
+  # Returns a collection of Analysis, one for each lint.
+  def analyze(lints)
+    lints.map do |lint_class|
+      lint = lint_class.new
+      lint.check(@klass)
+    end
+  end
+end

data/lib/pelusa/cli.rb

@@ -0,0 +1,27 @@
+module Pelusa
+  # The cli is a class responsible of handling all the command line interface
+  # logic.
+  #
+  class Cli
+    def initialize(args=ARGV)
+      @args = args
+    end
+
+    def run
+      _files = files
+      if _files.empty?
+        warn "\n  No files specified -- PROCESS ALL THE FILES!\n"
+        _files = Dir["**/*.rb"]
+      end
+
+      Pelusa.run(_files)
+    end
+
+    def files
+      if glob = @args.detect { |arg| arg =~ /\*/ }
+        return Dir[glob]
+      end
+      @args.select { |arg| arg =~ /\.rb/ }
+    end
+  end
+end

data/lib/pelusa/iterator.rb

@@ -0,0 +1,39 @@
+module Pelusa
+  class Iterator
+    NodeIterator = lambda do |node, check|
+      check.call(node)
+
+      if node.respond_to?(:each)
+        return node.each { |node| NodeIterator.call(node, check) }
+      end
+
+      ivars    = node.instance_variables
+      children = ivars.map { |ivar| node.instance_variable_get(ivar) }
+
+      return children.each { |node| NodeIterator.call(node, check) }
+    end
+
+    # Public: Initializes a new Iterator with a particular lint check.
+    #
+    # lint - The lint block that yields a node to assert for particular
+    # conditions in that node.
+    def initialize(&lint)
+      @iterator = lambda { |node| NodeIterator.call(node, lint) }
+    end
+
+    # Public: Calls the iterator with the given arguments.
+    #
+    # node - The root node from which to iterate.
+    def call(node)
+      @iterator.call(node)
+    end
+
+    # Public: Returns the iterator. Useful when using symbol to proc
+    # conversions, such as &iterator.
+    #
+    # Returns the Proc iterator.
+    def to_proc
+      @iterator
+    end
+  end
+end

data/lib/pelusa/lint.rb

@@ -0,0 +1,29 @@
+require 'set'
+require 'pelusa/lint/line_restriction'
+require 'pelusa/lint/instance_variables'
+require 'pelusa/lint/demeter_law'
+require 'pelusa/lint/indentation_level'
+require 'pelusa/lint/else_clauses'
+require 'pelusa/lint/properties'
+require 'pelusa/lint/collection_wrappers'
+require 'pelusa/lint/short_identifiers'
+
+module Pelusa
+  # Public: A Lint is a quality standard, applicable on a given piece of code to
+  # check its compliance.
+  #
+  module Lint
+    def self.all
+      [
+        LineRestriction,
+        InstanceVariables,
+        DemeterLaw,
+        IndentationLevel,
+        ElseClauses,
+        Properties,
+        CollectionWrappers,
+        ShortIdentifiers,
+      ]
+    end
+  end
+end

data/lib/pelusa/lint/collection_wrappers.rb

@@ -0,0 +1,50 @@
+module Pelusa
+  module Lint
+    class CollectionWrappers
+      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|
+          "Using an instance variable apart from the array ivar in lines #{violations.to_a.join(', ')}"
+        end
+      end
+
+      private
+
+      def name
+        "Doesn't mix array instance variables with others"
+      end
+
+      def iterate_lines!(klass)
+        array_assignment = nil
+
+        get_array_assignment = Iterator.new do |node|
+          if node.is_a?(Rubinius::AST::InstanceVariableAssignment) &&
+            (node.value.is_a?(Rubinius::AST::ArrayLiteral) ||
+            node.value.is_a?(Rubinius::AST::EmptyArray))
+              array_assignment = node
+          end
+        end
+
+        iterator = Iterator.new do |node|
+          next if node == array_assignment || !array_assignment
+
+          if node.is_a?(Rubinius::AST::InstanceVariableAssignment)
+            @violations << node.line
+          elsif node.is_a?(Rubinius::AST::InstanceVariableAccess) && node.name != array_assignment.name
+            @violations << node.line
+          end
+        end
+        Array(klass).each(&get_array_assignment)
+        Array(klass).each(&iterator)
+      end
+    end
+  end
+end