laser 0.7.0.pre1

data/lib/laser/rake/task.rb

@@ -0,0 +1,46 @@
+require 'rake'
+module Laser
+  module Rake
+    class LaserTask
+      include ::Rake::DSL
+
+      Settings = Struct.new(:libs, :extras, :options, :using, :fix) do
+        def initialize(*args)
+          super
+          self.libs ||= []
+          self.extras ||= []
+          self.options ||= ''
+          self.using ||= []
+          self.fix ||= []
+        end
+      end
+
+      attr_accessor :settings
+
+      def initialize(task_name)
+        @settings = Settings.new
+        yield @settings if block_given?
+        @settings.using = [:all] if @settings.using.empty?
+        task task_name do
+          run
+        end
+      end
+
+      def run
+        require 'laser'
+        files = []
+        if @settings.libs.any?
+          @settings.libs.each do |lib|
+            Dir["#{lib}/**/*.rb"].each do |file|
+              files << file
+            end
+          end
+        end
+        runner = Laser::Runner.new(self.settings.options.split(/\s/) + files)
+        runner.using = self.settings.using
+        runner.fix = self.settings.fix
+        runner.run
+      end
+    end
+  end
+end

data/lib/laser/runner.rb

@@ -0,0 +1,189 @@
+module Laser
+  class Runner
+    attr_accessor :using, :fix
+
+    def initialize(argv)
+      @argv = argv
+      @using = [:all]
+      @fix = [:all]
+    end
+
+    def run
+      settings, files = collect_options_and_arguments
+      # parse_forest: Array<Array<String, Sexp>>
+      parse_forest = files.zip(files.map { |file| Ripper.sexp(read_file(file))})
+      settings[:__using__] = warnings_to_consider
+      settings[:__fix__] = warnings_to_fix
+      scanner = Scanner.new(settings)
+      warnings = collect_warnings(files, scanner)
+      display_warnings(warnings, settings) if settings[:display]
+      print_modules if settings[:"list-modules"]
+    end
+
+    def collect_options_and_arguments
+      swizzling_argv do
+        settings = get_settings
+        handle_global_options(settings)
+        p settings if settings[:debug]
+        files = ARGV.dup
+        [settings, files]
+      end
+    end
+    
+    # Processes the global options, which includes picking which warnings to
+    # run against the source code. The settings provided determine what
+    # modifies the runner's settings.
+    #
+    # @param [Hash] settings the settings from the command-line to process.
+    # @option settings :only (String) a list of warning names or short names
+    #   that will be the only warnings run. The names should be whitespace-delimited.
+    # @option settings :"line-length" (Integer) a maximum line length to
+    #   generate a warning for. A common choice is 80/83.
+    def handle_global_options(settings)
+      if settings[:"line-length"]
+        @using << Laser.LineLengthWarning(settings[:"line-length"])
+      end
+      if (only_name = settings[:only])
+        @fix = @using = Warning.concrete_warnings.select do |w|
+          classname = w.name && w.name.split('::').last
+          (classname && only_name.index(classname)) || (w.short_name && w.short_name.index(only_name))
+        end
+      end
+      if settings[:profile]
+        require 'benchmark'
+        require 'profile'
+        SETTINGS[:profile] = true
+      end
+      ARGV.replace(['(stdin)']) if settings[:stdin]
+    end
+
+    # Parses the command-line options using Trollop
+    #
+    # @return [Hash{Symbol => Object}] the settings entered by the user
+    def get_settings
+      warning_opts = get_warning_options
+      Trollop::options do
+        banner 'LASER: Lexically- and Semantically-Enriched Ruby'
+        opt :fix, 'Should errors be fixed in-line?', short: '-f'
+        opt :display, 'Should errors be displayed?', short: '-b', default: true
+        opt :'report-fixed', 'Should fixed errors be reported anyway?', short: '-r'
+        opt :'line-length', 'Warn at the given line length', short: '-l', type: :int
+        opt :only, 'Only consider the given warning (by short or full name)', short: '-O', type: :string
+        opt :stdin, 'Read Ruby code from standard input', short: '-s'
+        opt :'list-modules', 'Print the discovered, loaded modules'
+        opt :profile, 'Run the profiler during execution'
+        warning_opts.each { |warning| opt(*warning) }
+      end
+    end
+
+    # Gets all the options from the warning plugins and collects them
+    # with overriding rules. The later the declaration is run, the higher the
+    # priority the option has.
+    def get_warning_options
+      all_options = Warning.all_warnings.inject({}) do |result, warning|
+        options = warning.options
+        options = [options] if options.any? && !options[0].is_a?(Array)
+        options.each do |option|
+          result[option.first] = option
+        end
+        result
+      end
+      all_options.values
+    end
+
+    # Prints the known modules after analysis.
+    def print_modules
+      Analysis::LaserModule.all_modules.map do |mod|
+        result = []
+        result << if Analysis::LaserClass === mod && mod.superclass
+                  then "#{mod.path} < #{mod.superclass.path}"
+                  else mod.name
+                  end
+        result
+      end.sort.flatten.each { |name| puts name }
+    end
+
+    def read_file(file)
+      case file
+      when '(stdin)' then $stdin.read
+      else File.read(file)
+      end
+    end
+
+    # Converts a list of warnings and symbol shortcuts for warnings to just a
+    # list of warnings.
+    def convert_warning_list(list)
+      list.map do |list|
+        case list
+        when :all then Warning.all_warnings
+        when :whitespace
+          [ExtraBlankLinesWarning, ExtraWhitespaceWarning,
+           OperatorSpacing, MisalignedUnindentationWarning]
+          else list
+        end
+      end.flatten
+    end
+
+    # Returns the list of warnings the user has activated for use.
+    def warnings_to_consider
+      convert_warning_list(@using)
+    end
+
+    # Returns the list of warnings the user has selected for fixing
+    def warnings_to_fix
+      convert_warning_list(@fix)
+    end
+
+    # Sets the ARGV variable to the runner's arguments during the execution
+    # of the block.
+    def swizzling_argv
+      old_argv = ARGV.dup
+      ARGV.replace @argv
+      yield
+    ensure
+      ARGV.replace old_argv
+    end
+
+    # Collects warnings from all the provided files by running them through
+    # the scanner.
+    #
+    # @param [Array<String>] files the files to scan. If (stdin) is in the
+    #   array, then data will be read from STDIN until EOF is reached.
+    # @param [Scanner] scanner the scanner that will look for warnings
+    #   in the source text.
+    # @return [Array<Warning>] a set of warnings, ordered by file.
+    def collect_warnings(files, scanner)
+      full_list = files.map do |file|
+        data = file == '(stdin)' ? STDIN.read : File.read(file)
+        if scanner.settings[:fix]
+          scanner.settings[:output_file] = scanner.settings[:stdin] ? STDOUT : File.open(file, 'w')
+        end
+        results = scanner.scan(data, file)
+        if scanner.settings[:fix] && !scanner.settings[:stdin]
+          scanner.settings[:output_file].close
+        end
+        results
+      end
+      full_list.flatten
+    end
+
+    # Displays warnings using user-provided settings.
+    #
+    # @param [Array<Warning>] warnings the warnings generated by the input
+    #   files, ordered by file
+    # @param [Hash{Symbol => Object}] settings the user-set display settings
+    def display_warnings(warnings, settings)
+      num_fixable = warnings.select { |warn| warn.fixable? }.size
+      num_total = warnings.size
+
+      results = "#{num_total} warnings found. #{num_fixable} are fixable."
+      puts results
+      puts '=' * results.size
+
+      warnings.each do |warning|
+        puts "#{warning.file}:#{warning.line_number} #{warning.name} " +
+             "(#{warning.severity}) - #{warning.desc}"
+      end
+    end
+  end
+end

data/lib/laser/scanner.rb

@@ -0,0 +1,169 @@
+module Laser
+  class Scanner
+    attr_accessor :settings
+    attr_accessor :indent_stack
+
+    DEFAULT_SETTINGS = {fix: false, output: STDOUT, indent_size: 2,
+                        __using__: Laser::Warning.warning_set,
+                        __fix__: Laser::Warning.warning_set}
+
+    # Initializes the scanner with the given settings
+    #
+    # @param [Hash] settings the settings to use to customize this scanner's
+    #   scanning behavior
+    def initialize(settings = {})
+      @settings = DEFAULT_SETTINGS.merge(settings)
+      @settings[:__scanner__] = self
+      self.indent_stack = []
+    end
+
+    # Returns the list of warnings to use for scanning.
+    def using
+      @settings[:__using__]
+    end
+
+    # Should we use this warning?
+    def using?(warning)
+      @settings[:__using__].include? warning
+    end
+
+    # Returns the list of warnings to use for scanning.
+    def fix
+      @settings[:__fix__]
+    end
+
+    # Should we use this warning?
+    def fixing?(warning)
+      @settings[:__fix__].include? warning.class
+    end
+
+    # Scans the text for warnings.
+    #
+    # @param [String] text the input ruby file to scan
+    # @return [Array[Laser::Warnings]] the warnings generated by the code.
+    #   If the code is clean, an empty array is returned.
+    def scan(text, filename='(none)')
+      warnings = scan_for_file_warnings(text, filename)
+      text = filter_fixable(warnings).inject(text) do |text, warning|
+        warning.fix(text)
+      end
+      with_fixing_piped_to_output do
+        text.split(/\n/).each_with_index do |line, number|
+          warnings.concat process_line(line, number + 1, filename)
+        end
+      end
+      warnings += unused_method_warnings
+      warnings
+    end
+
+    def with_fixing_piped_to_output
+      self.settings[:output_lines] = []
+      yield
+      if @settings[:fix]
+        self.settings[:output_file].write self.settings[:output_lines].join("\n")
+      end
+    end
+
+    # Finds all matching warnings, and if the user wishes, fix a subset of them.
+    def process_line(line, line_number, filename)
+      warnings = all_warnings_for_line(line, line_number, filename)
+      fix_input(warnings, line, line_number, filename) if @settings[:fix]
+      warnings
+    end
+
+    # Tries to fix the given line with a set of matching warnings for that line.
+    # May recurse if there are multiple warnings on the same line.
+    def fix_input(warnings, line, line_number, filename)
+      fixable_warnings = filter_fixable warnings
+      if fixable_warnings.size == 1
+        self.settings[:output_lines] << fixable_warnings.first.fix rescue line
+      elsif fixable_warnings.size > 1
+        new_text = fixable_warnings.first.fix rescue line
+        process_line(new_text, line_number, filename)
+      else
+        self.settings[:output_lines] << line
+      end
+    end
+
+    # Returns all warnings that match the line
+    def all_warnings_for_line(line, line_number, filename)
+      new_warnings = check_for_indent_warnings!(line, filename)
+      new_warnings.concat scan_for_line_warnings(line, filename)
+      new_warnings.each {|warning| warning.line_number = line_number}
+    end
+
+    # Returns only the warnings that we should fix
+    def filter_fixable(warnings)
+      warnings.select {|warning| warning.fixable? && fixing?(warning) }
+    end
+
+    # Checks for new warnings based on indentation.
+    def check_for_indent_warnings!(line, filename)
+      return [] if line == ""
+      indent_size = get_indent_size line
+      if indent_size > current_indent
+        self.indent_stack.push indent_size
+      elsif indent_size < current_indent
+        previous = self.indent_stack.pop
+        if indent_size != current_indent &&
+           using.include?(MisalignedUnindentationWarning)
+          warnings_to_check = [MisalignedUnindentationWarning.new(filename, line, current_indent)]
+          return filtered_warnings_from_line(line, warnings_to_check)
+        end
+      end
+      []
+    end
+
+    def unused_method_warnings
+      methods = Analysis::UnusedMethodDetection.unused_methods
+      methods.map do |method| 
+        ast_node = method.proc.ast_node
+        UncalledMethodWarning.new(ast_node.file_name, ast_node.line_number, method: method)
+      end
+    end
+
+    # Gets the current indent size
+    def current_indent
+      self.indent_stack.last || 0
+    end
+
+    # Gets the indent size of a given line
+    def get_indent_size(line)
+      line.match(/^\s*/)[0].size
+    end
+
+    # Goes through all file warning subclasses and see what warnings the file
+    # generates as a whole.
+    def scan_for_file_warnings(file, filename)
+      scan_for_warnings(using & FileWarning.all_warnings, file, filename)
+    end
+
+    # Goes through all line warning subclasses and checks if we got some new
+    # warnings for a given line
+    def scan_for_line_warnings(line, filename)
+      warnings = scan_for_warnings(using & LineWarning.all_warnings, line, filename)
+      filtered_warnings_from_line(line, warnings)
+    end
+
+    private
+
+    # Filters the list of warnings by checking the line for warnings to
+    # ignore. The line should contain "laser: ignore ClassToIgnore" in a comment,
+    # though you can omit the space between "laser:" and "ignore".
+    def filtered_warnings_from_line(line, warnings)
+      match = line.match(/#.*laser:\s*ignore\s+(.*)$/)
+      return warnings unless match && ignore_label = match[1]
+      class_names = ignore_label.split
+      result = warnings.reject do |warning|
+        class_names.include?(warning.class.name.gsub(/.*::(.*)/, '\1')) ||
+          class_names.include?(warning.class.short_name)
+      end
+      result
+    end
+
+    def scan_for_warnings(warnings, content, filename)
+      warnings.map! { |warning| warning.new(filename, content, @settings)}
+      warnings.map { |warning| warning.generated_warnings(warning.body)}.flatten
+    end
+  end
+end

data/lib/laser/standard_library/_thread.rb

@@ -0,0 +1,110 @@
+class Thread
+  class << self
+    def abort_on_exception
+    end
+    
+    def abort_on_exception=(bool)
+    end
+    
+    def current
+    end
+    
+    # yields: once
+    def exclusive
+    end
+    
+    def exit
+    end
+    
+    def start(*args)
+    end
+    alias :fork :start
+    
+    def kill(thread)
+    end
+    
+    def list
+    end
+    
+    def main
+    end
+    
+    def pass
+    end
+    
+    def stop
+    end
+  end
+  
+  def [](key)
+  end
+  
+  def []=(key, val)
+  end
+  
+  def abort_on_exception
+  end
+  
+  def abort_on_exception=(val)
+  end
+  
+  def add_trace_func(proc)
+  end
+  
+  def alive?
+  end
+  
+  def backtrace
+  end
+  
+  def exit
+  end
+  alias kill exit
+  alias terminate exit
+  
+  def group
+  end
+  
+  def inspect
+  end
+  
+  def join(limit=nil)
+  end
+  
+  def key?(sym)
+  end
+  
+  def keys
+  end
+  
+  def priority
+  end
+  
+  def priority=(val)
+  end
+  
+  # raises: always
+  def raise(*args)
+  end
+  
+  def run
+  end
+  
+  def safe_level
+  end
+  
+  def set_trace_func(proc)
+  end
+  
+  def status
+  end
+  
+  def stop?
+  end
+  
+  def value
+  end
+  
+  def wakeup
+  end
+end