ruby-lint 0.0.1a

data/lib/rlint/analyze/unused_variables.rb

@@ -0,0 +1,103 @@
+module Rlint
+  module Analyze
+    ##
+    # {Rlint::Analyze::UnusedVariables} is used to check for unused local,
+    # instance, class and global variables.
+    #
+    class UnusedVariables < Rlint::Callback
+      include Helper::DefinitionResolver
+
+      ##
+      # A short description of this class.
+      #
+      # @return [String]
+      #
+      DESCRIPTION = 'Checks for variables that are assigned but unused.'
+
+      ##
+      # Hash containing the human readable names for various variable types.
+      #
+      # @return [Hash]
+      #
+      HUMAN_READABLE = {
+        :local_variable    => 'local variable',
+        :instance_variable => 'instance variable',
+        :class_variable    => 'class variable',
+        :global_variable   => 'global variable'
+      }
+
+      ##
+      # Array containing the variable callback methods to define.
+      #
+      # @return [Array]
+      #
+      UNUSED_VARIABLES = [
+        :on_local_variable,
+        :on_instance_variable,
+        :on_class_variable,
+        :on_global_variable
+      ]
+
+      UNUSED_VARIABLES.each do |name|
+        define_method(name) do |token|
+          unused_variables.delete(token.name)
+        end
+      end
+
+      ##
+      # @see Rlint::Callback#initialize
+      #
+      def initialize(*args)
+        super
+
+        @unused_variables = [{}]
+      end
+
+      ##
+      # Called when a new scope is found.
+      #
+      def on_new_scope
+        @unused_variables << {}
+      end
+
+      ##
+      # Called after a new scope has ended.
+      #
+      def after_new_scope
+        # Add the warnings for all the unused variables.
+        unused_variables.each do |name, token|
+          readable = HUMAN_READABLE[token.type]
+
+          warning(
+            "assigned but unused #{readable} #{token.name}",
+            token.line,
+            token.column
+          )
+        end
+
+        @unused_variables.pop
+      end
+
+      ##
+      # Called when a variable is assigned.
+      #
+      # @param [Rlint::Token::AssignmentToken] token
+      #
+      def on_assignment(token)
+        unused_variables[token.name] = token
+      end
+
+      private
+
+      ##
+      # Returns the Hash to use for storing unused variables for the current
+      # scope.
+      #
+      # @return [Hash]
+      #
+      def unused_variables
+        return @unused_variables[-1]
+      end
+    end # UnusedVariables
+  end # Analyze
+end # Rlint

data/lib/rlint/callback.rb

@@ -0,0 +1,67 @@
+module Rlint
+  ##
+  # {Rlint::Callback} is a class that can be used (but you're not required to)
+  # to remove some common boilerplate code from custom callback classes.
+  #
+  # Using this class can be done by simply extending it:
+  #
+  #     class MyCallback < Rlint::Callback
+  #
+  #     end
+  #
+  # Once extended the following helper methods are provided:
+  #
+  # * {Rlint::Callback#error}
+  # * {Rlint::Callback#warning}
+  # * {Rlint::Callback#info}
+  #
+  # These 3 methods can be used to add data to a report. If no report is set
+  # the methods will not execute any code. This means your own code does not
+  # have to check for a valid instance of {Rlint::Report} in the `@report`
+  # instance variable every time you want to add data to it.
+  #
+  class Callback
+    ##
+    # Creates a new instance of the class and stores the report.
+    #
+    # @param [Rlint::Report|NilClass] report The report instance to use.
+    # @param [Hash] options A hash containing custom options to set for the
+    #  callback.
+    #
+    def initialize(report = nil, storage = {})
+      @report  = report
+      @storage = storage
+    end
+
+    protected
+
+    ##
+    # Adds an error message to the report.
+    #
+    # @param [String] message The message to add.
+    # @param [Fixnum] line The line number of the message.
+    # @param [Fixnum] column The column number of the message.
+    #
+    def error(message, line, column)
+      @report.add(:error, message, line, column) if @report
+    end
+
+    ##
+    # Adds a warning message to the report.
+    #
+    # @see Rlint::Callback#error
+    #
+    def warning(message, line, column)
+      @report.add(:warning, message, line, column) if @report
+    end
+
+    ##
+    # Adds a regular informational message to the report.
+    #
+    # @see Rlint::Callback#error
+    #
+    def info(message, line, column)
+      @report.add(:info, message, line, column) if @report
+    end
+  end # Callback
+end # Rlint

data/lib/rlint/cli.rb

@@ -0,0 +1,167 @@
+require 'optparse'
+
+module Rlint
+  ##
+  # {Rlint::CLI} is the commandline interface to Rlint.
+  #
+  class CLI
+    ##
+    # Creates a new instance of the class and configures OptionParser.
+    #
+    def initialize
+      @formatters = constant_short_names(Rlint::Formatter)
+      @analyzers  = constant_short_names(Rlint::Analyze)
+
+      @option_parser = OptionParser.new do |opts|
+        opts.banner         = 'A static code analysis tool and linter for Ruby'
+        opts.program_name   = 'rlint'
+        opts.version        = Rlint::VERSION
+        opts.summary_indent = '  '
+
+        opts.separator ''
+        opts.separator 'Usage:'
+        opts.separator '  $ rlint [FILES] [OPTIONS]'
+
+        opts.separator ''
+        opts.separator 'Analyzers:'
+        opts.separator hash_to_list(@analyzers)
+
+        opts.separator ''
+        opts.separator 'Formatters:'
+        opts.separator hash_to_list(@formatters)
+
+        opts.separator ''
+        opts.separator 'Reporting Levels:'
+        opts.separator "  error\n  warning\n  info"
+
+        opts.separator ''
+        opts.separator 'Options:'
+
+        opts.on(
+          '-f',
+          '--formatter=VALUE',
+          'The formatter to use',
+          String
+        ) do |formatter|
+          if @formatters.key?(formatter)
+            Rlint.options.formatter = @formatters[formatter]
+          end
+        end
+
+        opts.on(
+          '-l',
+          '--levels=VALUE',
+          'The reporting levels to enable',
+          Array
+        ) do |levels|
+          Rlint.options.levels = levels.map { |level| level.to_sym }
+        end
+
+        opts.on(
+          '-a',
+          '--analyzers=VALUE',
+          'The analyzers to enable',
+          Array
+        ) do |names|
+          analyzers = Options::REQUIRED_ANALYZERS.dup
+
+          names.each do |name|
+            const = @analyzers[name]
+
+            if const and !analyzers.include?(const)
+              analyzers << const
+            end
+          end
+
+          Rlint.options.analyzers = analyzers
+        end
+
+        opts.on('-h', '--help', 'Shows this help message') do
+          puts @option_parser
+          exit
+        end
+
+        opts.on('-v', '--version', 'Shows the current version') do
+          version
+        end
+      end
+    end
+
+    ##
+    # Runs Rlint.
+    #
+    # @param [Array] argv Array of commandline parameters.
+    #
+    def run(argv = ARGV)
+      @option_parser.parse!(argv)
+
+      abort 'You have to specify a file to analyze' if argv.empty?
+
+      argv.each do |file|
+        abort "The file #{file} is not valid" unless File.file?(file)
+
+        code      = File.read(file, File.size(file))
+        tokens    = Parser.new(code, file).parse
+        report    = Report.new(file, Rlint.options.levels)
+        iterator  = Iterator.new(report)
+        formatter = Rlint.options.formatter.new
+
+        Rlint.options.analyzers.each { |const| iterator.bind(const) }
+
+        iterator.run(tokens)
+
+        output = formatter.format(report)
+
+        puts output unless output.empty?
+      end
+    end
+
+    ##
+    # Shows the current version of Rlint.
+    #
+    def version
+      puts "Rlint version #{Rlint::VERSION} running on #{RUBY_DESCRIPTION}"
+      exit
+    end
+
+    private
+
+    ##
+    # Returns a hash containing various short names and the constants to use.
+    #
+    # @param  [Class] constant The constant to use.
+    # @return [Hash]
+    #
+    def constant_short_names(constant)
+      hash = {}
+
+      constant.constants.sort.each do |const|
+        name       = const.to_s.gsub(/([a-z]+)([A-Z]+)/, '\\1_\\2').downcase
+        hash[name] = constant.const_get(const)
+      end
+
+      return hash
+    end
+
+    ##
+    # Returns a string containing the names and descriptions of various
+    # constants formatted as a list.
+    #
+    # @param  [Hash] hash
+    # @return [String]
+    #
+    def hash_to_list(hash)
+      longest = hash.keys.sort { |l, r| l.length <=> r.length }[-1].length
+      longest = longest > 32 ? longest : 32
+      list    = []
+
+      hash.each do |name, const|
+        description = const.const_get(:DESCRIPTION)
+
+        list << "  %-#{longest}s %s" % [name, description]
+      end
+
+      return list.join("\n")
+    end
+  end # CLI
+end # Rlint

data/lib/rlint/constant_importer.rb

@@ -0,0 +1,102 @@
+module Rlint
+  ##
+  # {Rlint::ConstantImporter} is a module that can be used to create a list of
+  # method definitions (using {Rlint::Token::MethodDefinitionToken} for a
+  # supplied list of constant names.
+  #
+  module ConstantImporter
+    ##
+    # Boolean that indicates if the Config constant should be ignored or not.
+    #
+    # @return [TrueClass|FalseClass]
+    #
+    IGNORE_CONFIG = Object.const_defined?(:RbConfig)
+
+    ##
+    # Hash containing all the source Ruby methods to retrieve methods and the
+    # keys to store them under.
+    #
+    # @return [Hash]
+    #
+    METHOD_KEYS = {
+      :methods                  => :method,
+      :instance_methods         => :instance_method,
+      :private_methods          => :method,
+      :private_instance_methods => :instance_method
+    }
+
+    ##
+    # Hash containing the parameter types as returned by `Method#parameters`
+    # and the attributes they should be stored in in an instance of
+    # {Rlint::Token::ParametersToken}.
+    #
+    # @return [Hash]
+    #
+    PARAMETER_KEYS = {
+      :req   => :value,
+      :opt   => :optional,
+      :rest  => :rest,
+      :block => :block
+    }
+
+    ##
+    # Imports the methods of a given list of constant names and returns a Hash
+    # containing instances of {Rlint::Definition} for each imported constant.
+    #
+    # @param  [Array] constants An array of constant to import.
+    # @param  [Mixed] source_constant The source constant to use for the
+    #  `const_get` call. Set to `Object` by default.
+    # @return [Hash]
+    #
+    def self.import(constants, source_constant = Object)
+      imported = {}
+
+      constants.each do |name|
+        next if name == :Config and IGNORE_CONFIG
+
+        const = source_constant.const_get(name)
+
+        next unless const
+
+        name  = name.to_s
+        scope = Definition.new(nil, :lazy => true, :constant => const)
+
+        METHOD_KEYS.each do |source, target|
+          next unless const.respond_to?(source)
+
+          const.send(source).each do |method|
+            token = Token::MethodDefinitionToken.new(:name => method.to_s)
+
+            if source =~ /^private/
+              token.visibility = :private
+            end
+
+            # Import all the parameters.
+            const.send(target, method).parameters.each do |param|
+              param_target = PARAMETER_KEYS[param[0]]
+
+              variable = Token::VariableToken.new(
+                :name => param[1].to_s,
+                :type => :local_variable
+              )
+
+              # Determine if the parameter should be appended to a list or set
+              # as the sole parameter.
+              if token.parameters.send(param_target).is_a?(Array)
+                token.parameters.send(param_target).push(variable)
+              else
+                token.parameters.send("#{param_target}=", variable)
+              end
+            end
+
+            scope.add(target, method.to_s, Definition.new(nil, :token => token))
+          end
+        end
+
+        imported[name] = scope
+      end
+
+      return imported
+    end
+  end # ConstantImporter
+end # Rlint

data/lib/rlint/definition.rb

@@ -0,0 +1,230 @@
+module Rlint
+  ##
+  # {Rlint::Definition} is a class used for storing scoping/definition related
+  # information such as the methods that are available for various constants,
+  # variables that have been defined, etc.
+  #
+  # Each instance of this class can also have a number of parent scopes. These
+  # parent scopes can be used to look up data that is inherited in Ruby code
+  # (e.g. constants).
+  #
+  # Basic example of using this class:
+  #
+  #     scope = Rlint::Definition.new
+  #
+  #     scope.lookup(:local_variable, 'name') # => nil
+  #
+  #     scope.add(:local_variable, 'name', 'Ruby')
+  #
+  #     scope.lookup(:local_variable, 'name') # => "Ruby"
+  #
+  class Definition
+    ##
+    # Array containing symbol names that should be looked up in the parent
+    # scopes if they're not found in the current scope.
+    #
+    # @return [Array]
+    #
+    LOOKUP_PARENT = [
+      :instance_variable,
+      :class_variable,
+      :global_variable,
+      :method,
+      :instance_method,
+      :constant
+    ]
+
+    ##
+    # Hash containing the default options and values to use when creating a new
+    # instance of this class.
+    #
+    # @return [Hash]
+    #
+    DEFAULT_OPTIONS = {
+      :lazy     => false,
+      :kernel   => false,
+      :constant => Object,
+      :reset    => true
+    }
+
+    ##
+    # Array containing the parent scopes, set to an empty Array by default.
+    #
+    # @return [Array]
+    #
+    attr_reader :parent
+
+    ##
+    # Hash containing all the symbols (local variables, methods, etc) for the
+    # current scope instance.
+    #
+    # @return [Hash]
+    #
+    attr_reader :symbols
+
+    ##
+    # The constant to lazy import child constants from, set to `Object` by
+    # default.
+    #
+    # @return [Mixed]
+    #
+    attr_reader :constant
+
+    ##
+    # An array containing all the constant names that belong to the constant
+    # set in {Rlint::Definition#constant}. Each name is saved as a String.
+    #
+    # @return [Array]
+    #
+    attr_reader :constants
+
+    ##
+    # Creates a new instance of the scope class and sets the default symbols.
+    #
+    # @param [Array|Rlint::Definition] parent The parent scope(s). Set this to
+    #  an Array of {Rlint::Definition} instances to use multiple parent scopes.
+    # @param [Hash] options A hash containing custom options.
+    #
+    # @option options [TrueClass|FalseClass] :lazy When set to `true` missing
+    #  constants will be lazy loaded.
+    # @option options [TrueClass|FalseClass] :kernel When set to `true` the
+    #  Kernel constant will be loaded by default.
+    # @option options [Class] :constant The constant to use for importing other
+    #  constants, set to `Object` by default.
+    # @option options [TrueClass|FalseClass] :reset When set to `true` the
+    #  `value` attribute of the token will be set to `nil`
+    # @option options [Rlint::Token::Token] :token The token to set for the
+    #  scope.
+    #
+    def initialize(parent = [], options = {})
+      parent = [parent] unless parent.is_a?(Array)
+
+      @options = DEFAULT_OPTIONS.merge(options)
+      @parent  = parent.select { |p| p.is_a?(Definition) }
+      @symbols = {
+        :local_variable    => {},
+        :instance_variable => {},
+        :class_variable    => {},
+        :global_variable   => {},
+        :constant          => {},
+        :method            => {},
+        :instance_method   => {}
+      }
+
+      if @options[:token]
+        self.token = @options[:token]
+      end
+
+      if options[:lazy] and options[:kernel]
+        @symbols[:constant] = ConstantImporter.import(['Kernel'])
+      end
+
+      # Import the default global variables.
+      if options[:kernel]
+        Kernel.global_variables.each do |name|
+          name  = name.to_s
+          token = Token::VariableToken.new(
+            :name => name,
+            :type => :global_variable
+          )
+
+          add(:global_variable, name, Definition.new([], :token => token))
+        end
+      end
+    end
+
+    ##
+    # Adds a new symbol to the scope.
+    #
+    # @param [#to_sym] type The type of symbol to add.
+    # @param [String] name The name of the symbol.
+    # @param [Mixed] value The value to store under the specified name.
+    #
+    def add(type, name, value = nil)
+      @symbols[type.to_sym][name] = value
+    end
+
+    ##
+    # Looks up a symbol in the current and parent scopes (if there are any).
+    #
+    # @param [#to_sym] type The type of symbol to look up.
+    # @param [String] name The name of the symbol to look up.
+    #
+    def lookup(type, name)
+      name   = name.to_s unless name.is_a?(String)
+      symbol = nil
+      type   = type.to_sym
+
+      if @symbols[type] and @symbols[type][name]
+        symbol = @symbols[type][name]
+      # Look up the variable in the parent scope(s) (if any are set).
+      elsif lookup_parent?(type)
+        @parent.each do |parent|
+          parent_symbol = parent.lookup(type, name)
+
+          if parent_symbol
+            symbol = parent_symbol
+            break
+          end
+        end
+      end
+
+      # Lazy import the constant if it exists.
+      if !symbol and lazy_load?(name, type)
+        @symbols[:constant] = @symbols[:constant].merge(
+          ConstantImporter.import([name], @options[:constant])
+        )
+
+        symbol = lookup(type, name)
+      end
+
+      return symbol
+    end
+
+    ##
+    # Returns the token associated with the scope.
+    #
+    # @return [Rlint::Token::Token|NilClass]
+    #
+    def token
+      return @options[:token]
+    end
+
+    ##
+    # Sets the token of the scope.
+    #
+    # @param [Rlint::Token::Token] token The token to use.
+    #
+    def token=(token)
+      @options[:token]       = token.dup
+      @options[:token].value = nil if @options[:reset]
+    end
+
+    private
+
+    ##
+    # Returns a boolean that indicates if the specified symbol should be lazy
+    # loaded.
+    #
+    # @param  [#to_sym] name The name of the symbol.
+    # @param  [Symbol] type The type of the symbol.
+    # @return [TrueClass|FalseClass]
+    #
+    def lazy_load?(name, type)
+      return @options[:lazy] \
+        && type == :constant \
+        && @options[:constant].constants.include?(name.to_sym)
+    end
+
+    ##
+    # Returns a boolean that indicates if the current symbol type should be
+    # looked up in a parent definition.
+    #
+    # @param  [Symbol] type The type of symbol.
+    # @return [Trueclass|FalseClass]
+    #
+    def lookup_parent?(type)
+      return LOOKUP_PARENT.include?(type) && !@parent.empty?
+    end
+  end # Definition
+end # Rlint