skeptic 0.0.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/.rvmrc

@@ -0,0 +1 @@
+rvm 1.9.2

data/Gemfile

@@ -0,0 +1,17 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+gem 'trollop', '>= 1.16.2'
+
+group :development do
+  gem "rspec"
+  gem "cucumber"
+  gem "aruba"
+  gem "bundler"
+  gem "jeweler"
+  gem "rcov"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Stefan Kanev
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,21 @@
+= skeptic
+
+An **very** experimental static Ruby 1.9 analyzer to point out annoying things in your code. You
+should probably not use it for anything.
+
+Writing it is fun, though.
+
+== Contributing to skeptic
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Stefan Kanev. See LICENSE.txt for
+further details.

data/Rakefile

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "skeptic"
+  gem.homepage = "http://github.com/skanev/skeptic"
+  gem.license = "MIT"
+  gem.summary = %Q{Skeptic points out annoying things in your code}
+  gem.description = %Q{An experimental, half-assed, bug-ridden and highly opinionated code analyzer.}
+  gem.email = "stefan.kanev@gmail.com"
+  gem.authors = ["Stefan Kanev"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+require 'cucumber/rake/task'
+Cucumber::Rake::Task.new(:features)
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "skeptic #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/bin/skeptic

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'skeptic'
+require 'trollop'
+
+opts = Trollop::options do
+  opt :lines_per_method,  'Maximum number of lines per method', type: :int
+  opt :max_nesting_depth, 'Maximum nesting depth', type: :int
+  opt :methods_per_class, 'Maximum number of methods per class', type: :int
+  opt :no_semicolons,     'Complain about semicolons', type: :boolean
+end
+code = File.read ARGV[0]
+
+critic = Skeptic::Critic.new
+
+critic.no_semicolons     = opts[:no_semicolons]
+critic.max_nesting_depth = opts[:max_nesting_depth]
+critic.methods_per_class = opts[:methods_per_class]
+critic.lines_per_method  = opts[:lines_per_method]
+
+critic.criticize code
+
+if critic.criticism.empty?
+  puts 'OK'
+  exit(0)
+else
+  messages = Hash.new { |hash, key| hash[key] = [] }
+
+  critic.criticism.each do |message, type|
+    messages[type] << message
+  end
+
+  messages.each do |type, messages|
+    puts type
+    messages.each do |message|
+      puts "* #{message}"
+    end
+    puts ""
+  end
+
+  exit(1)
+end

data/features/skeptic.feature

@@ -0,0 +1,76 @@
+Feature: Running skeptic
+  Scenario: Nothing to complain about
+    Given a file named "input.rb" with:
+      """
+      foo
+      """
+    When I run `skeptic input.rb`
+    Then it should pass with:
+      """
+      OK
+      """
+
+  Scenario: Banishing semicolons
+    Given a file named "input.rb" with:
+      """
+      foo; bar
+      """
+    When I run `skeptic --no-semicolons input.rb`
+    Then it should fail with:
+      """
+      No semicolons as expression separators
+      * You have a semicolon at line 1, column 3
+      """
+
+  Scenario: Limiting method length
+    Given a file named "input.rb" with:
+      """
+      class Foo
+        def bar
+          one
+          two
+          three
+        end
+      end
+      """
+    When I run `skeptic --lines-per-method 2 input.rb`
+    Then it should fail with:
+      """
+      Number of lines per method (2)
+      * Foo#bar is 3 lines long
+      """
+
+  Scenario: Limiting depth of nesting
+    Given a file named "input.rb" with:
+      """
+      class Foo
+        def bar
+          while true
+            if false
+              really?
+            end
+          end
+        end
+      end
+      """
+    When I run `skeptic --max-nesting-depth 1 input.rb`
+    Then it should fail with:
+      """
+      Maximum nesting depth (1)
+      * Foo#bar has 2 levels of nesting: while > if
+      """
+
+  Scenario: Limiting number of methods per class
+    Given a file named "input.rb" with:
+      """
+      class Foo
+        def bar; end
+        def baz; end
+      end
+      """
+    When I run `skeptic --methods-per-class 1 input.rb`
+    Then it should fail with:
+      """
+      Number of methods per class (1)
+      * Foo has 2 methods: #bar, #baz
+      """

data/features/support/aruba.rb

@@ -0,0 +1 @@
+require 'aruba/cucumber'

data/features/support/env.rb

@@ -0,0 +1,13 @@
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'skeptic'
+
+require 'rspec/expectations'

data/lib/skeptic/critic.rb

@@ -0,0 +1,36 @@
+module Skeptic
+  class Critic
+    attr_accessor :lines_per_method
+    attr_accessor :max_nesting_depth
+    attr_accessor :methods_per_class
+    attr_accessor :no_semicolons
+
+    attr_reader :criticism
+
+    def initialize
+      @criticism = []
+    end
+
+    def criticize(code)
+      @code   = code
+      @tokens = Ripper.lex(code)
+      @sexp   = Ripper.sexp(code)
+
+      rules = {
+        Rules::LinesPerMethod  => lines_per_method,
+        Rules::MaxNestingDepth => max_nesting_depth,
+        Rules::MethodsPerClass => methods_per_class,
+        Rules::NoSemicolons    => no_semicolons,
+      }
+
+      rules.reject { |rule_type, option| option.nil? }.each do |rule_type, option|
+        rule = rule_type.new(option)
+        rule.apply_to @tokens, @sexp
+
+        rule.violations.each do |violation|
+          @criticism << [violation, rule.name]
+        end
+      end
+    end
+  end
+end

data/lib/skeptic/environment.rb

@@ -0,0 +1,32 @@
+module Skeptic
+  class Environment
+    def initialize
+      @stack = [{}]
+    end
+
+    def []=(name, value)
+      @stack.last[name] = value
+    end
+
+    def [](name)
+      closure = @stack.reverse.detect { |closure| closure.has_key? name }
+      closure[name] if closure
+    end
+
+    def push(closure = {})
+      @stack.push closure
+    end
+
+    def pop
+      raise "You went too far unextending env" if @stack.empty?
+      @stack.pop
+    end
+
+    def scoped(closure = {})
+      push closure
+      yield
+    ensure
+      pop
+    end
+  end
+end

data/lib/skeptic/rules/lines_per_method.rb

@@ -0,0 +1,59 @@
+module Skeptic
+  module Rules
+    class LinesPerMethod
+      include SexpVisitor
+
+      def initialize(limit = nil)
+        env[:line_numbers] = []
+        @line_counts = {}
+        @limit = limit
+      end
+
+      def apply_to(tokens, sexp)
+        visit sexp
+        self
+      end
+
+      def size_of(qualified_method_name)
+        @line_counts[qualified_method_name]
+      end
+
+      def violations
+        @line_counts.select { |name, lines| lines > @limit }.map do |name, lines|
+          "#{name} is #{lines} lines long"
+        end
+      end
+
+      def name
+        "Number of lines per method (#@limit)"
+      end
+
+      private
+
+      on :class do |name, parent, body|
+        class_name = [env[:class], extract_name(name)].compact.join('::')
+
+        env.scoped :class => class_name do
+          visit body
+        end
+      end
+
+      on :def do |name, params, body|
+        method_name = extract_name(name)
+
+        env.scoped method: method_name, line_numbers: [] do
+          visit body
+
+          lines = env[:line_numbers].uniq.compact.length
+
+          full_name = "#{env[:class]}##{env[:method]}"
+          @line_counts[full_name] = lines + @line_counts.fetch(full_name, 0)
+        end
+      end
+
+      on :@ident, :@const, :@gvar, :@ivar, :@cvar, :@int, :@float, :@tstring_content, :@kw do |text, location|
+        env[:line_numbers] << location.first
+      end
+    end
+  end
+end

data/lib/skeptic/rules/max_nesting_depth.rb

@@ -0,0 +1,122 @@
+module Skeptic
+  module Rules
+    class MaxNestingDepth
+      include SexpVisitor
+
+      def initialize(limit = nil)
+        env[:scope] = Scope.new
+        @scopes = []
+        @limit  = limit
+      end
+
+      def apply_to(tokens, sexp)
+        visit sexp
+        self
+      end
+
+      def nestings
+        @scopes.uniq
+      end
+
+      def violations
+        @scopes.select { |scope| scope.depth > @limit }.map do |scope|
+          "#{scope.location} has #{scope.depth} levels of nesting: #{scope.levels.join(' > ')}"
+        end
+      end
+
+      def name
+        "Maximum nesting depth (#@limit)"
+      end
+
+      private
+
+      def with(scope)
+        @scopes << scope
+
+        env.scoped scope: scope do
+          yield
+        end
+      end
+
+      def scope
+        env[:scope]
+      end
+
+      on :class do |name, parent, body|
+        visit name
+        visit parent if parent
+
+        with scope.in_class(extract_name(name)) do
+          visit body
+        end
+      end
+
+      on :if, :if_mod, :unless, :unless_mod do |condition, body, alternative|
+        key = sexp_type.to_s.gsub(/_mod$/, '').to_sym
+
+        visit condition
+
+        with scope.push(key) do
+          visit body
+          visit alternative if alternative
+        end
+      end
+
+      on :while, :while_mod, :until, :until_mod do |condition, body|
+        key = sexp_type.to_s.gsub(/_mod$/, '').to_sym
+
+        with scope.push(key) do
+          visit condition
+          visit body
+        end
+      end
+
+      on :method_add_block do |invocation, block|
+        visit invocation
+
+        with scope.push(:iter) do
+          visit block
+        end
+      end
+
+      on :lambda do |params, body|
+        with scope.push(:lambda) do
+          visit params
+          visit body
+        end
+      end
+
+      on :for do |params, iterable, body|
+        visit params
+        visit iterable
+
+        with scope.push(:for) do
+          visit body
+        end
+      end
+
+      on :case do |testable, alternatives|
+        visit testable
+
+        with scope.push(:case) do
+          visit alternatives
+        end
+      end
+
+      on :begin do |body|
+        with scope.push(:begin) do
+          visit body
+        end
+      end
+
+      on :def do |name, params, body|
+        visit name
+        visit params
+
+        with scope.in_method(extract_name(name)) do
+          visit body
+        end
+      end
+    end
+  end
+end

data/lib/skeptic/rules/methods_per_class.rb

@@ -0,0 +1,69 @@
+module Skeptic
+  module Rules
+    class MethodsPerClass
+      include SexpVisitor
+
+      def initialize(limit)
+        @methods = Hash.new { |hash, key| hash[key] = [] }
+        @limit   = limit
+      end
+
+      def apply_to(tokens, tree)
+        visit tree
+        self
+      end
+
+      def methods_in(class_name)
+        @methods[class_name].length
+      end
+
+      def violations
+        violators = @methods.keys.select { |name| @methods[name].length > @limit }
+
+        violators.map do |class_name|
+          method_names = @methods[class_name].map { |name| "##{name}" }
+          count        = method_names.length
+
+          "#{class_name} has #{count} methods: #{method_names.join(', ')}"
+        end
+      end
+
+      def name
+        "Number of methods per class (#@limit)"
+      end
+
+      private
+
+      on :def do |name, params, body|
+        method_name = extract_name(name)
+        class_name  = env[:class]
+
+        @methods[class_name] << method_name
+
+        visit params
+        visit body
+      end
+
+      on :class do |name, parents, body|
+        env.push :class => qualified_class_name(name)
+
+        visit parents if parents
+        visit body
+
+        env.pop
+      end
+
+      on :module do |name, body|
+        env.push :class => qualified_class_name(name)
+
+        visit body
+
+        env.pop
+      end
+
+      def qualified_class_name(name)
+        [env[:class], extract_name(name)].compact.join('::')
+      end
+    end
+  end
+end

data/lib/skeptic/rules/no_semicolons.rb

@@ -0,0 +1,30 @@
+module Skeptic
+  module Rules
+    class NoSemicolons
+      def initialize(enabled = false)
+        @enabled = enabled
+      end
+
+      def apply_to(tokens, sexp)
+        @locations = tokens.
+          select { |location, type, token| token == ';' and type == :on_semicolon }.
+          map { |location, type, token| location }
+        self
+      end
+
+      def violations
+        @locations.map do |line, column|
+          "You have a semicolon at line #{line}, column #{column}"
+        end
+      end
+
+      def name
+        'No semicolons as expression separators'
+      end
+
+      def semicolon_locations
+        @locations
+      end
+    end
+  end
+end

data/lib/skeptic/scope.rb

@@ -0,0 +1,60 @@
+module Skeptic
+  class Scope
+    attr_accessor :class_name, :method_name, :levels
+
+    def initialize(class_name = nil, method_name = nil, levels = [])
+      @class_name  = class_name
+      @method_name = method_name
+      @levels      = levels
+    end
+
+    def ==(other)
+      other.kind_of?(Scope) and
+        self.class_name == other.class_name and
+        self.method_name == other.method_name and
+        self.levels == other.levels
+    end
+
+    def depth
+      levels.length
+    end
+
+    def push(level)
+      copy { |n| n.levels.push level }
+    end
+
+    def pop
+      copy { |n| n.levels.pop }
+    end
+
+    def in_class(class_name)
+      copy { |n| n.class_name = class_name }
+    end
+
+    def in_method(method_name)
+      copy { |n| n.method_name = method_name }
+    end
+
+    def location
+      if class_name and method_name then "#{class_name}##{method_name}"
+        elsif class_name then "#{class_name}#[body]"
+        elsif method_name then "Object##{method_name}"
+        else "[top-level]"
+      end
+    end
+
+    def to_s
+      "#{location} #{@levels.join(':')}".strip
+    end
+
+    def inspect
+      "#<Scope: #{to_s}>"
+    end
+
+    private
+
+    def copy(&block)
+      Scope.new(class_name, method_name, levels.dup).tap(&block)
+    end
+  end
+end