wool 0.5.1

data/.document

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

data/.gitignore

@@ -0,0 +1,23 @@
+## MAC OS
+.DS_Store
+
+## REDCAR
+.redcar
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+

data/LICENSE

@@ -0,0 +1,45 @@
+Copyright (c) 2009 Michael Edgar
+
+                       Spirit of the License
+
+This is an academic project, but I don't know where it will lead. I'm
+licensing Wool this way in part to shield myself from liability (since
+it rewrites code) and because it very well may have commercial applications
+that I may wish to investigate.
+
+                         Wool's License
+
+Academic use only. No commercial or non-profit use. At least until
+I know what I'm doing for sure. I couldn't find a legalese version of
+an "academic use only" license, so I'll just write it again:
+
+No non-academic use! No using Wool on code that will, at some point
+in the near or distant future, produce monetary gain for you, your
+relatives, your friends, your bosses, or anyone tangentially connected
+to you. I don't care if you run it on legacy code that is defunct and
+unused, but may have once derived you commercial gain. But don't run
+it at your workplace. That's against the license.
+
+Oh, and this important bit from the GPL applies as well:
+
+                            NO WARRANTY
+
+  9. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  10. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.

data/README.rdoc

@@ -0,0 +1,17 @@
+= wool
+
+Description goes here.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I 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.
+
+== Copyright
+
+Copyright (c) 2010 Michael Edgar. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,77 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "wool"
+    gem.summary = %Q{Analysis and Linting tool for Ruby.}
+    gem.description = %Q{Wool is an advanced static analysis tool for Ruby.}
+    gem.email = "michael.j.edgar@dartmouth.edu"
+    gem.homepage = "http://github.com/michaeledgar/wool"
+    gem.authors = ["Michael Edgar"]
+    gem.add_dependency "ruby_parser", ">= 2.0.5"
+    gem.add_dependency "ruby2ruby", ">= 1.2.4"
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_development_dependency "yard", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+task :rcov => :default
+
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/**/test*.rb']
+  t.verbose = true
+end
+
+require 'cucumber'
+require 'cucumber/rake/task'
+
+Cucumber::Rake::Task.new(:features) do |t|
+  t.cucumber_opts = "features --format pretty"
+end
+
+if true
+  begin
+    require 'wool'
+    Wool::Rake::WoolTask.new(:wool) do |wool|
+      wool.libs << 'lib' << 'spec'
+      wool.using << :all << Wool::LineLengthMaximum(100) << Wool::LineLengthWarning(80)
+      wool.options = '--debug --fix'
+      wool.fix << Wool::ExtraBlankLinesWarning << Wool::ExtraWhitespaceWarning << Wool::LineLengthWarning(80)
+    end
+  rescue LoadError => err
+    task :wool do
+      abort 'Wool is not available. In order to run wool, you must: sudo gem install wool'
+    end
+  end
+end
+
+task :rebuild => [:gemspec, :build, :install] do
+  %x(rake wool)
+end
+
+task :spec => :check_dependencies
+
+task :default => [:spec, :test]
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yardoc do
+    abort 'YARD is not available. In order to run yardoc, you must: sudo gem install yard'
+  end
+end

data/TODO.md

@@ -0,0 +1,17 @@
+# Cleanup
+
+* Completely remove context stack remnants
+
+# Useful Features
+
+* Easy, DSL-like way to specify regex-matching, token-matching for match?
+* Easy, DSL-like way to specify gsub-based fix calls
+* Token Matching engine. Something along the lines of being able to match: [!whitespace, whitespace?, comment] to match code, possibly some whitespace, and a comment. Could donate to YARD.
+* * DFA? Simple backtracking recursion?
+* * Leftmost-longest
+
+# Useful Warnings
+
+* Assignment in condition
+* Multiline blocks with { } notation
+* Never-executed code

data/VERSION

@@ -0,0 +1 @@
+0.5.1

data/bin/wool

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'wool'
+Wool::Runner.new(ARGV).run

data/features/step_definitions/wool_steps.rb

@@ -0,0 +1,39 @@
+TESTDATA_DIR = File.join(File.dirname(__FILE__), '..', 'support', 'testdata')
+
+Given(/the following inputs and outputs:/) do |table|
+  @table = table
+end
+
+When(/I scan for warnings/) do
+  @result_table = [ ['input', 'output'] ]
+  swizzling_io do
+    @table.hashes.each do |hash|
+      full_path = File.join(TESTDATA_DIR, hash[:input])
+      runner = Wool::Scanner.new({})
+      warnings = runner.scan(File.read(full_path), hash[:input])
+      @result_table << [hash[:input], warnings.size.to_s]
+    end
+  end
+end
+
+Then(/the input and output tables should match/) do
+  @table.diff!(@result_table)
+end
+
+When(/I scan-and-fix warnings/) do
+  @result_table = [ ['input', 'output'] ]
+  swizzling_io do
+    @table.hashes.each do |hash|
+      full_path = File.join(TESTDATA_DIR, hash[:input])
+      expected_output = File.read(File.join(TESTDATA_DIR, hash[:output]))
+      captured_output = StringIO.new
+      Wool::LineLengthMaximum(80)
+      runner = Wool::Scanner.new(:fix => true, :output_file => captured_output)
+      runner.scan(File.read(full_path), hash[:input])
+      reported_output = hash[:output]
+      reported_output += '+' if captured_output.string != expected_output
+      STDERR.puts [captured_output.string, expected_output].inspect if captured_output.string != expected_output
+      @result_table << [hash[:input], reported_output]
+    end
+  end
+end

data/features/support/env.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'wool'
+
+require 'spec/expectations'
+require 'stringio'
+
+def swizzling_io
+  old_stdout, $stdout = $stdout, StringIO.new
+  yield
+  $stdout.string
+ensure
+  $stdout = old_stdout
+end
+  

data/features/support/testdata/1_input

@@ -0,0 +1 @@
+a +b

data/features/support/testdata/1_output

@@ -0,0 +1 @@
+a + b

data/features/support/testdata/2_input

@@ -0,0 +1,4 @@
+def plus(a, b)
+  a+ b  
+  b + a  
+ end

data/features/support/testdata/2_output

@@ -0,0 +1,4 @@
+def plus(a, b)
+  a + b
+  b + a
+end

data/features/support/testdata/3_input

@@ -0,0 +1,8 @@
+def plus(a, b)
+  a+ b  
+  raise StandardError.new('a horrible thing happened and now we stopped') if x > 10 unless y
+  if some_test  
+    do_something
+   end
+ end
+  

data/features/support/testdata/3_output

@@ -0,0 +1,11 @@
+def plus(a, b)
+  a + b
+  unless y
+    if x > 10
+      raise StandardError.new('a horrible thing happened and now we stopped')
+    end
+  end
+  if some_test
+    do_something
+  end
+end

data/features/support/testdata/4_input

@@ -0,0 +1,5 @@
+class SomeBigClass
+  attr_accessor :silly, :monkey
+  
+  def xyz; 'xyz'; end # wool: ignore SemicolonWarning
+ end # wool: ignore MisalignedUnindentationWarning

data/features/support/testdata/4_output

@@ -0,0 +1,5 @@
+class SomeBigClass
+  attr_accessor :silly, :monkey
+
+  def xyz; 'xyz'; end  # wool: ignore SemicolonWarning
+ end  # wool: ignore MisalignedUnindentationWarning

data/features/wool.feature

@@ -0,0 +1,24 @@
+Feature: Find Warnings
+  In order to clean code
+  A user should be able to
+  scan for warnings
+
+  Scenario: Scan Single File
+    Given the following inputs and outputs:
+      | input     | output  |
+      | 1_input   | 1       |
+      | 2_input   | 4       |
+      | 3_input   | 6       |
+      | 4_input   | 3       |
+    When I scan for warnings
+    Then the input and output tables should match
+
+  Scenario: Scan-n-fix Single File
+    Given the following inputs and outputs:
+      | input     | output   |
+      | 1_input   | 1_output |
+      | 2_input   | 2_output |
+      | 3_input   | 3_output |
+      | 4_input   | 4_output |
+    When I scan-and-fix warnings
+    Then the input and output tables should match

data/lib/wool.rb

@@ -0,0 +1,40 @@
+# Dependencies
+require 'ripper'
+require 'wool/third_party/trollop'
+require 'wool/support/module_extensions'
+require 'wool/advice/advice'
+require 'wool/analysis/lexical_analysis'
+require 'wool/analysis/sexp_analysis'
+require 'wool/analysis/visitor'
+require 'wool/analysis/symbol'
+require 'wool/analysis/protocols'
+require 'wool/analysis/signature'
+require 'wool/analysis/wool_class'
+require 'wool/analysis/protocol_registry'
+require 'wool/analysis/scope'
+require 'wool/analysis/annotations'
+require 'wool/advice/comment_advice'
+
+module Wool
+  # MOVE THIS
+  # TODO(adgar): move this to someplace effing sensible
+  def self.initialize_global_scope
+    object_class = SexpAnalysis::WoolClass.new('Object', nil)
+    global = SexpAnalysis::Scope.new(nil, object_class.class_object, {'Object' => object_class})
+    SexpAnalysis::Scope.const_set("GlobalScope", global) unless SexpAnalysis.const_defined?("GlobalScope")
+    object_class.instance_variable_set("@scope", SexpAnalysis::Scope::GlobalScope)
+    module_class = SexpAnalysis::WoolClass.new('Module')
+    module_class.superclass = object_class
+  end
+  initialize_global_scope
+end
+# Runners
+require 'wool/runner'
+require 'wool/rake/task'
+# Program logic
+require 'wool/warning'
+require 'wool/scanner'
+
+module Wool
+  VERSION = "0.5.0"
+end

data/lib/wool/advice/advice.rb

@@ -0,0 +1,42 @@
+module Wool
+  # This module provides other modules the ability to add advice
+  # to methods. This module makes use of these functions opt-in.
+  module Advice
+    def advice_counter
+      @advice_counter ||= 0
+    end
+
+    def bump_advice_counter!
+      @advice_counter += 1
+    end
+
+    def before_advice(meth, advice)
+      with_advice(meth, :before => proc { send(advice) })
+    end
+
+    def after_advice(meth, advice)
+      with_advice(meth, :after => proc { send(advice) })
+    end
+
+    def argument_advice(meth, argument_tweaker)
+      with_advice(meth, :args => argument_tweaker)
+    end
+
+    def with_advice(meth, settings)
+      counter = advice_counter
+      alias_method "#{meth}_old#{counter}".to_sym, meth
+      define_method meth do |*args|
+        identity = proc {|*x| x}
+        instance_eval(&(settings[:before] || identity))
+        if settings[:args]
+          new_args = instance_eval(& proc { send(settings[:args], *args)})
+        end
+        result = send("#{meth}_old#{counter}", *new_args)
+        instance_eval(&(settings[:after] || identity))
+
+        result
+      end
+      bump_advice_counter!
+    end
+  end
+end

data/lib/wool/advice/comment_advice.rb

@@ -0,0 +1,37 @@
+module Wool
+  module Advice
+    # Using this module, you can make your match? method automatically
+    # receive de-commented source text.
+    #
+    # class MyWarning < Wool::Warning do
+    #   extend Wool::Advice::CommentAdvice
+    #
+    #   def self.match?(body, context)
+    #     body.include?('#')
+    #   end
+    #   remove_comments
+    # end
+    module CommentAdvice
+      def self.included(klass)
+        klass.__send__(:extend, ClassMethods)
+        klass.__send__(:include, InstanceMethods)
+      end
+
+      module ClassMethods
+        def remove_comments
+          argument_advice :match?, :comment_removing_twiddler
+        end
+      end
+
+      module InstanceMethods
+        # This twiddler aims to remove comments and trailing whitespace
+        # from the ruby source input, so that warnings that aren't concerned
+        # with the implications of comments in their source can safely
+        # discard them. Uses Ripper to look for comment tokens.
+        def comment_removing_twiddler(body = self.body, settings = {})
+          [split_on_token(body, :on_comment).first.rstrip, settings]
+        end
+      end
+    end
+  end
+end