ruby-lint 0.0.1a

data/lib/rlint/parser_error.rb

@@ -0,0 +1,42 @@
+module Rlint
+  ##
+  # Exception class that's raised when the parser {Rlint::Parser} detects
+  # syntax errors.
+  #
+  class ParserError < SyntaxError
+    ##
+    # The line number on which the error occured.
+    #
+    # @return [Fixnum|Bignum]
+    #
+    attr_reader :line
+
+    ##
+    # The column on which the error occured.
+    #
+    # @return [Fixnum|Bignum]
+    #
+    attr_reader :column
+
+    ##
+    # The name of the file in which the error occured.
+    #
+    # @return [String]
+    #
+    attr_reader :file
+
+    ##
+    # Creates a new instance of the error class.
+    #
+    # @param [String] message The error message.
+    # @param [Fixnum|Bignum] line The line of the error.
+    # @param [Fixnum|Bignum] column The column of the error.
+    # @param [String] file The file in which the error occured.
+    #
+    def initialize(message, line, column, file)
+      @line, @column, @file = line, column, file
+
+      super(message)
+    end
+  end # ParserError
+end # Rlint

data/lib/rlint/report.rb

@@ -0,0 +1,98 @@
+module Rlint
+  ##
+  # {Rlint::Report} is a class used for storing error messages, warnings and
+  # informational messages about code processed by {Rlint::Iterator} and
+  # individual callback classes.
+  #
+  # The process of adding data to a report involves two steps:
+  #
+  # 1. setting which levels to enable
+  # 2. adding the data
+  #
+  # The first step is done by creating a new instance of this class and
+  # defining a list of level names in the constructor's second parameter. The
+  # following levels are used by Rlint itself:
+  #
+  # * `:error`
+  # * `:warning`
+  # * `:info`
+  #
+  # The second step is done by calling {Rlint::Report#add}. This method is used
+  # to add data for a specific level. If this level is disabled the data is not
+  # added to the report.
+  #
+  # A basic example of this is the following:
+  #
+  #     report = Rlint::Report.new('test_file.rb', [:error])
+  #
+  #     report.add(:error, 'This is an error message', 1, 0)
+  #
+  #     # This message will not be added since it's not an error.
+  #     report.add(:info, 'This is an info message', 2, 0)
+  #
+  class Report
+    ##
+    # Array containing the levels that are enabled by default.
+    #
+    # @return [Array]
+    #
+    DEFAULT_LEVELS = [:error, :warning, :info]
+
+    ##
+    # A hash containing the various messages stored per level.
+    #
+    # @return [Hash]
+    #
+    attr_reader :messages
+
+    ##
+    # An array of levels to use. For example, if `:info` is not included any
+    # message using this level is ignored.
+    #
+    # @return [Array]
+    #
+    attr_reader :levels
+
+    ##
+    # String containing the name/path of the file this report belongs to.
+    #
+    # @return [String]
+    #
+    attr_reader :file
+
+    ##
+    # Creates a new instance of the class.
+    #
+    # @param [String] file The name/path of the file that this report belongs
+    #  to.
+    # @param [Array] levels The message levels to use for this report.
+    #
+    def initialize(file = '(rlint)', levels = DEFAULT_LEVELS)
+      @file     = file
+      @levels   = levels
+      @messages = {}
+    end
+
+    ##
+    # Adds a message to the report.
+    #
+    # @param [#to_sym] level The level of the message.
+    # @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 add(level, message, line, column)
+      level = level.to_sym
+
+      return unless @levels.include?(level)
+
+      @messages[level] ||= []
+
+      @messages[level] << {
+        :message => message,
+        :line    => line,
+        :column  => column
+      }
+    end
+  end # Report
+end # Rlint

data/lib/rlint/token/assignment_token.rb

@@ -0,0 +1,46 @@
+module Rlint
+  module Token
+    ##
+    # Token class that is used whenever a value is assigned to a variable,
+    # object attribute or similar.
+    #
+    class AssignmentToken < Token
+      ##
+      # The object receiver, set when a value is assigned to an object
+      # attribute.
+      #
+      # @return [Rlint::Token::Token]
+      #
+      attr_accessor :receiver
+
+      ##
+      # Symbol containing the operator that was used to separate the receiver
+      # and attribute name.
+      #
+      # @return [Symbol]
+      #
+      attr_accessor :operator
+
+      ##
+      # @see Rlint::Token::Token#initialize
+      #
+      def initialize(*args)
+        super
+
+        @type  = :local_variable if @type == :identifier
+        @event = :assignment unless @event == :mass_assignment
+
+        # Correct the types for local variable tokens in the name (only used
+        # for mass assignments).
+        if @name and @name.is_a?(Array)
+          @name.each_with_index do |value, index|
+            if @name[index].respond_to?(:type) \
+            and @name[index].type == :identifier
+              @name[index].type = :local_variable
+            end
+          end
+        end
+      end
+    end # AssignmentToken
+  end # Token
+end # Rlint

data/lib/rlint/token/begin_rescue_token.rb

@@ -0,0 +1,57 @@
+module Rlint
+  module Token
+    ##
+    # Token class used for storing information about begin/rescue/ensure
+    # statements.
+    #
+    class BeginRescueToken < Token
+      ##
+      # Array of rescue statements. Each item is an instance of
+      # {Rlint::Token::StatementToken}.
+      #
+      # @return [Array]
+      #
+      attr_accessor :rescue
+
+      ##
+      # Attribute containing details about the ensure statement.
+      #
+      # @return [Rlint::Token::StatementToken]
+      #
+      attr_accessor :ensure
+
+      ##
+      # Attribute containing details about the else statement.
+      #
+      # @return [Rlint::Token::StatementToken]
+      #
+      attr_accessor :else
+
+      ##
+      # @see Rlint::Token#initialize
+      #
+      def initialize(*args)
+        @type = :begin_rescue
+
+        super
+      end
+
+      ##
+      # @see Rlint::Token::Token#child_nodes
+      #
+      def child_nodes
+        nodes = [@rescue]
+
+        if @ensure
+          nodes << [@ensure]
+        end
+
+        if @else
+          nodes << [@else]
+        end
+
+        return super + nodes
+      end
+    end # BeginRescueToken
+  end # Token
+end # Rlint

data/lib/rlint/token/block_token.rb

@@ -0,0 +1,17 @@
+module Rlint
+  module Token
+    ##
+    # Token class used for storing information about blocks/procs.
+    #
+    # @since 2012-08-05
+    #
+    class BlockToken < Token
+      ##
+      # The parameters of the block.
+      #
+      # @return [Rlint::Token::ParametersToken]
+      #
+      attr_accessor :parameters
+    end
+  end # Token
+end # Rlint

data/lib/rlint/token/case_token.rb

@@ -0,0 +1,44 @@
+module Rlint
+  module Token
+    ##
+    # Token class containing details about a case statement.
+    #
+    class CaseToken < StatementToken
+      ##
+      # Array containing all the `when` statements sorted in the order of their
+      # appearance.
+      #
+      # @return [Array]
+      #
+      attr_accessor :when
+
+      ##
+      # Token containing details about the `else` statement.
+      #
+      # @return [Rlint::Token::StatementToken]
+      #
+      attr_accessor :else
+
+      ##
+      # @see Rlint::Token#initialize
+      #
+      def initialize(*args)
+        @when = []
+        @type = :case
+
+        super
+      end
+
+      ##
+      # @see Rlint::Token::Token#child_nodes
+      #
+      def child_nodes
+        nodes = super
+
+        nodes.insert(1, @when)
+
+        return nodes.select { |array| array.length > 0 }
+      end
+    end # CaseToken
+  end # Token
+end # Rlint

data/lib/rlint/token/class_token.rb

@@ -0,0 +1,24 @@
+module Rlint
+  module Token
+    ##
+    # Token class used for storing data about classes.
+    #
+    class ClassToken < Token
+      ##
+      # The name of the parent class, if specified.
+      #
+      # @return [String]
+      #
+      attr_accessor :parent
+
+      ##
+      # @see Rlint::Token::Token#initialize
+      #
+      def initialize(*args)
+        super
+
+        @parent = ['Object'] if @parent.empty?
+      end
+    end # ClassToken
+  end # Token
+end # Rlint

data/lib/rlint/token/method_definition_token.rb

@@ -0,0 +1,64 @@
+module Rlint
+  module Token
+    ##
+    # Token class used for storing data about a newly defined method.
+    #
+    # @since 2012-08-02
+    #
+    class MethodDefinitionToken < Token
+      ##
+      # The object the method is defined on, only set when this is explicitly
+      # stated.
+      #
+      # @return [Rlint::Token::Token]
+      #
+      attr_accessor :receiver
+
+      ##
+      # The operator that was used to separate the receiver and method name.
+      #
+      # @return [Rlint::Token::Token]
+      #
+      attr_accessor :operator
+
+      ##
+      # The parameters of the method.
+      #
+      # @return [Rlint::Token::ParametersToken]
+      #
+      attr_accessor :parameters
+
+      ##
+      # The visibility of the method, set to `:public` by default.
+      #
+      # @since  2012-08-07
+      # @return [Symbol]
+      #
+      attr_accessor :visibility
+
+      ##
+      # @see Rlint::Token::Token#initialize
+      #
+      def initialize(*args)
+        @parameters = []
+        @visibility = :public
+        @type       = :method_definition
+
+        super
+
+        # Ensure that the parameters attribute always contains an instance of
+        # `Rlint::Token::ParametersToken`.
+        unless @parameters.class == ParametersToken
+          @parameters = ParametersToken.new
+        end
+      end
+
+      ##
+      # @see Rlint::Token::Token#child_nodes
+      #
+      def child_nodes
+        return @parameters.child_nodes + super
+      end
+    end # MethodDefinitionToken
+  end # Token
+end # Rlint

data/lib/rlint/token/method_token.rb

@@ -0,0 +1,58 @@
+module Rlint
+  module Token
+    ##
+    # Token class used for storing methods, their parameters, body, etc.
+    #
+    # @since 2012-07-29
+    #
+    class MethodToken < Token
+      ##
+      # The receiver of the method call, if any.
+      #
+      # @since  2012-08-05
+      # @return [Rlint::Token::Token]
+      #
+      attr_accessor :receiver
+
+      ##
+      # Symbol containing the method separator, if any.
+      #
+      # @since  2012-08-05
+      # @return [Symbol]
+      #
+      attr_accessor :operator
+
+      ##
+      # Array of tokens for the method parameters.
+      #
+      # @since  2012-07-29
+      # @return [Rlint::Token::Parameters]
+      #
+      attr_accessor :parameters
+
+      ##
+      # Token containing details about the block passed to the method.
+      #
+      # @since  2012-08-05
+      # @return [Rlint::Token::BlockToken]
+      #
+      attr_accessor :block
+
+      ##
+      # @see Rlint::Token::Token#initialize
+      #
+      def initialize(*args)
+        @type = :method
+
+        super
+      end
+
+      ##
+      # @see Rlint::Token::Token#child_nodes
+      #
+      def child_nodes
+        return super << @parameters << [@receiver] << [@block]
+      end
+    end # MethodToken
+  end # Token
+end # Rlint