ruby-lint 0.0.2 → 0.0.3

data/lib/ruby-lint/analyze/method_validation.rb

@@ -1,104 +0,0 @@
-module RubyLint
-  module Analyze
-    ##
-    # {RubyLint::Analyze::MethodValidation} is used to validate method calls.
-    # Errors are added for calling undefined methods, calling methods with
-    # invalid parameters and so on.
-    #
-    class MethodValidation < RubyLint::Callback
-      include Helper::DefinitionResolver
-
-      ##
-      # A short description of this class.
-      #
-      # @return [String]
-      #
-      DESCRIPTION = 'Validates method calls and the specified parameters.'
-
-      ##
-      # Hash containing the various Ruby classes that are used to represent
-      # various types.
-      #
-      # @return [Hash]
-      #
-      TYPE_CLASSES = {
-        :string      => 'String',
-        :integer     => 'Fixnum', # Fixnum and Bignum share the same methods.
-        :float       => 'Float',
-        :symbol      => 'Symbol',
-        :array       => 'Array',
-        :hash        => 'Hash',
-        :brace_block => 'Proc',
-        :lambda      => 'Proc',
-        :regexp      => 'Regexp',
-        :range       => 'Range'
-      }
-
-      ##
-      # Called when a method call is found.
-      #
-      # @param [RubyLint::Token::MethodToken] token
-      #
-      def on_method(token)
-        # Method called on a receiver (e.g. `String.new`).
-        if token.receiver
-          receiver_name  = token.receiver.name
-          receiver_scope = scope
-          receiver_type  = token.receiver.type
-          method_type    = :instance_method
-
-          if receiver_name.is_a?(Array)
-            return unless valid_constant_path?(token.receiver)
-
-            receiver_scope = resolve_definition(receiver_name)
-          end
-
-          # Method calls on variables such as `name.upcase`.
-          if token.receiver.is_a?(Token::VariableToken) \
-          and receiver_type != :constant \
-          and receiver_type != :constant_path
-            value = receiver_scope.lookup(receiver_type, receiver_name)
-
-            if !value.nil? and !value.token.value.nil?
-              value         = value.token.value
-              receiver_type = TYPE_CLASSES[value.type]
-            end
-
-            # Extract the class from a method call.
-            if value.respond_to?(:receiver)
-              while value.respond_to?(:receiver)
-                value = value.receiver
-              end
-
-              receiver_type = value.name
-            end
-
-          # Methods called directly on a type such as `'name'.upcase`.
-          elsif TYPE_CLASSES[receiver_type]
-            receiver_type = TYPE_CLASSES[receiver_type]
-
-          # Everything else.
-          else
-            method_type   = :method
-            receiver_type = receiver_name.is_a?(Array) \
-              ? receiver_name[-1] \
-              : receiver_name
-          end
-
-          # Retrieve the constant to check for the existence of the method.
-          found = receiver_scope.lookup(:constant, receiver_type)
-
-          if found and !definition_exists?(method_type, token, found)
-            if method_type == :instance_method
-              error = "undefined instance method #{token.name}"
-            else
-              error = "undefined class method #{token.name}"
-            end
-
-            error(error, token.line, token.column)
-          end
-        end
-      end
-    end # MethodValidation
-  end # Analyze
-end # RubyLint

data/lib/ruby-lint/callback.rb

@@ -1,67 +0,0 @@
-module RubyLint
-  ##
-  # {RubyLint::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 < RubyLint::Callback
-  #
-  #     end
-  #
-  # Once extended the following helper methods are provided:
-  #
-  # * {RubyLint::Callback#error}
-  # * {RubyLint::Callback#warning}
-  # * {RubyLint::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 {RubyLint::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 [RubyLint::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 RubyLint::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 RubyLint::Callback#error
-    #
-    def info(message, line, column)
-      @report.add(:info, message, line, column) if @report
-    end
-  end # Callback
-end # RubyLint

data/lib/ruby-lint/constant_importer.rb

@@ -1,112 +0,0 @@
-module RubyLint
-  ##
-  # {RubyLint::ConstantImporter} is a module that can be used to create a list of
-  # method definitions (using {RubyLint::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
-    # {RubyLint::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 {RubyLint::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
-        const_token = Token::VariableToken.new(
-          :type => :constant,
-          :name => name
-        )
-
-        scope = Definition.new(
-          nil,
-          :lazy     => true,
-          :constant => const,
-          :token    => const_token
-        )
-
-        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 # RubyLint

data/lib/ruby-lint/definition.rb

@@ -1,230 +0,0 @@
-module RubyLint
-  ##
-  # {RubyLint::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 = RubyLint::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 {RubyLint::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|RubyLint::Definition] parent The parent scope(s). Set this to
-    #  an Array of {RubyLint::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 [RubyLint::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 [RubyLint::Token::Token|NilClass]
-    #
-    def token
-      return @options[:token]
-    end
-
-    ##
-    # Sets the token of the scope.
-    #
-    # @param [RubyLint::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 # RubyLint