ruby-lint 0.0.2 → 0.0.3

metadata.gz.asc

@@ -0,0 +1,17 @@
+-----BEGIN PGP SIGNATURE-----
+Version: GnuPG v2.0.19 (GNU/Linux)
+
+iQIcBAABAgAGBQJRdZvaAAoJEPMbESk2SfREY1gP/0UTWkTwDBrtPXxDQSF6M0lk
+v2AxKsRx/fyQZx6QAgNuCR+aOGKTHwiyHzJ6Kkk8uRqH8x4XUUj8drl3ASToZxGc
+hYrm26FPKUovqkoyW9zP6Ybp1GhkEdSLq1MoFg5ZZAgvRovz4RXLHQulwMo0f2Yd
+0KFHMYQyyEH+S+nq7gt0ZBtsxPzoLG4l2g4QV9d4iie0mU7hXOFmhW6QQ02sx9EP
+qTEFHCIalpGBLHfCL+GEPo8P6ro1jSMRqWCvB15mtdGtqCKpg4u/EB5c2YQsgJAl
+UGFUOIEYw6UyfEqu3D0gPmNf8PUviL3BAI6CUBeN0tV6XNBzgcEAHrCqY+wwoC9b
+gFzRLW2q7A1Kq41NRNCUnrrc81ojEZeA/9V+y5hJWrQWPTQtTPeFcLbPUqDkh6FX
+yX+CjhHoKvG52d1IcpExctKr74jXUmyQVPxrFEfumt8HrMTqGuPVaKAUI10wZvAE
+tWAtTioTQbJ+2AUQnS0J33CVEZbih1MwDHUCnJQEYV1wqacW7sBPaV5OBFFXBcr7
+xENLrtctZFGfQNxAFZEasLsTOmnY8sekW8axAs2Lb3VPd8sK1MXYFWnlFzkZc+jR
+kGxzEHdmWytp4y2UIj2rnNQqv2y6muB61b53CbFJT3LIv+KhCb09/leg7oa7yYu5
++fQy0GBWGfzgWdidG/8z
+=0Dl7
+-----END PGP SIGNATURE-----

data/.rbenv-version

@@ -1 +0,0 @@
-1.9.3-p194

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

@@ -1,407 +0,0 @@
-module RubyLint
-  module Analyze
-    ##
-    # {RubyLint::Analyze::CodingStyle} checks if a block of code matches a given
-    # set of coding standards. While none of the problems found by this class
-    # are considered harmful they are usually frowned upon as they do not
-    # follow the unofficial but generally accepted Ruby coding standards.
-    #
-    # ## Standards References
-    #
-    # The following was used to determine the standards this class should
-    # assume to be correct:
-    #
-    # * https://github.com/styleguide/ruby
-    # * https://github.com/bbatsov/ruby-style-guide
-    # * http://confluence.jetbrains.net/display/RUBYDEV/RubyMine+Inspections
-    # * My own opinion
-    #
-    # ## Checks
-    #
-    # This class checks for the following:
-    #
-    # * The length of method and variable names, should be less than the value
-    #   set in {RubyLint::Analyze::CodingStyle::MAXIMUM\_NAME\_LENGTH}.
-    # * The use of class variables (it's relatively rare that you actually need
-    #   those).
-    # * The use of parenthesis around various statements: these are not needed
-    #   in Ruby.
-    # * The use of camelCase for method and variable names instead of
-    #   `snake_case`, the latter is what Ruby code should use.
-    # * Whether or not predicate methods are named correctly.
-    # * If a particular method name should be replaced by a different one (e.g.
-    #   "map" instead of "collect").
-    #
-    class CodingStyle < RubyLint::Callback
-      ##
-      # A short description of this class.
-      #
-      # @return [String]
-      #
-      DESCRIPTION = 'Checks the coding style of a block of code.'
-
-      ##
-      # The maximum length for method and variable names.
-      #
-      # @return [Fixnum]
-      #
-      MAXIMUM_NAME_LENGTH = 30
-
-      ##
-      # Hash containing the names of method names and the names that should be
-      # used instead.
-      #
-      # @return [Hash]
-      #
-      RECOMMENDED_METHOD_NAMES = {
-        'collect'  => 'map',
-        'detect'   => 'find',
-        'find_all' => 'select',
-        'inject'   => 'reduce',
-        'length'   => 'size'
-      }
-
-      ##
-      # @see RubyLint::Callback#initialize
-      #
-      def initialize(*args)
-        super
-
-        @in_method        = false
-        @predicate_method = false
-      end
-
-      ##
-      # Called when an instance variable is found.
-      #
-      # The following checks are run for instance variables:
-      #
-      # * Whether or not instance variables are `snake_cased` instead of
-      #   camelCased.
-      # * Whether or not the length of an instance variable is smaller than the
-      #   value defined in {RubyLint::Analyze::CodingStyle::MAXIMUM\_NAME\_LENGTH}.
-      #
-      # @param [RubyLint::Token::VariableToken] token The token containing details
-      #  about the variable.
-      #
-      def on_instance_variable(token)
-        validate_name(token)
-      end
-
-      ##
-      # Called when a class variable is found.
-      #
-      # This method will check for the same things as
-      # {RubyLint::Analyze::CodingStyle#on_instance_variable} along with adding an
-      # info message about class variables being discouraged.
-      #
-      # @see RubyLint::Analyze::CodingStyle#on_instance_variable
-      #
-      def on_class_variable(token)
-        validate_name(token)
-
-        info(
-          'the use of class variables is discouraged',
-          token.line,
-          token.column
-        )
-      end
-
-      ##
-      # Called when a constant is found.
-      #
-      # @see RubyLint::Analyze::CodingStyle#on_instance_variable
-      #
-      def on_constant(token)
-        validate_name_length(token)
-      end
-
-      ##
-      # Called when a global variable is found.
-      #
-      # @see RubyLint::Analyze::CodingStyle#on_instance_variable
-      #
-      def on_global_variable(token)
-        validate_name(token)
-      end
-
-      ##
-      # Called when an instance variable is found.
-      #
-      # @see RubyLint::Analyze::CodingStyle#on_instance_variable
-      #
-      def on_local_variable(token)
-        validate_name(token)
-      end
-
-      ##
-      # Called when a value is assigned.
-      #
-      # This method checks for the name of the used variable (similar to
-      # instance variables) as well as adding a warning when an instance
-      # variable is assigned.
-      #
-      # @see RubyLint::Analyze::CodingStyle#on_instance_variable
-      # @see RubyLint::Analyze::CodingStyle#on_class_variable
-      #
-      def on_assignment(token)
-        validate_name(token)
-
-        if token.type == :class_variable
-          info(
-            'the use of class variables is discouraged',
-            token.line,
-            token.column
-          )
-        end
-      end
-
-      ##
-      # Called when a return statement is found.
-      #
-      # @param [RubyLint::Token::StatementToken] token The token of the return
-      #  statement.
-      #
-      def on_return(token)
-        if !token.value or token.value.empty? or !@in_method
-          return
-        end
-
-        token.value.each do |value|
-          # TODO: this probably won't work very well if there's a lambda inside
-          # a method that returns `true` or `false`.
-          if value.type == :keyword \
-          and (value.name == 'true' or value.name == 'false')
-            @predicate_method = true
-
-            break
-          end
-        end
-      end
-
-      ##
-      # Called when a method is defined. This method validates the name similar
-      # to instance variables as well as checking if the method definition
-      # modifies a core Ruby constant.
-      #
-      # @see RubyLint::Analyze::CodingStyle#on_instance_variable
-      #
-      def on_method_definition(token)
-        validate_name(token)
-
-        if token.receiver
-          validate_ruby_constant_modification(token.receiver)
-        end
-
-        @in_method = true
-      end
-
-      ##
-      # Called when a class is created. This callback adds a warning if a core
-      # Ruby constant is modified.
-      #
-      # @param [RubyLint::Token::ClassToken] token Token class containing details
-      #  about the newly created class.
-      #
-      def on_class(token)
-        validate_ruby_constant_modification(token)
-      end
-
-      ##
-      # Called after a method token has been processed. This callback checks if
-      # a method is a predicate method and if so if the name is set correctly.
-      #
-      # @param [RubyLint::Token::MethodDefinitionToken] token The token containing
-      #  details about the method definition.
-      # @todo This method currently only performs a very limited check for
-      #  predicate methods. Once a proper scoping system has been implemented
-      #  this method should be updated accordingly.
-      #
-      def after_method_definition(token)
-        if @predicate_method and token.name !~ /\?$/
-          info(
-            'predicate methods should end with a question mark',
-            token.line,
-            token.column
-          )
-        end
-
-        @in_method        = false
-        @predicate_method = false
-      end
-
-      ##
-      # Called when a method call is found.
-      #
-      # This method checks if the used method should be named differently
-      # instead (e.g. "map" instead of "collect").
-      #
-      # @param [RubyLint::Token::MethodToken] token Token containing details about
-      #  the method.
-      #
-      def on_method(token)
-        if RECOMMENDED_METHOD_NAMES.key?(token.name)
-          recommended = RECOMMENDED_METHOD_NAMES[token.name]
-
-          info(
-            'it is recommended to use the method "%s" instead of "%s"' % [
-              recommended,
-              token.name
-            ],
-            token.line,
-            token.column
-          )
-        end
-      end
-
-      ##
-      # Called when an if statement is found.
-      #
-      # This method checks to see if there are any parenthesis around the
-      # statement and adds an info message if this is the case.
-      #
-      # @param [RubyLint::Token::StatementToken] token The token containing
-      #  details about the if statement.
-      #
-      def on_if(token)
-        validate_parenthesis(token)
-      end
-
-      ##
-      # Called when an elsif statement is found.
-      #
-      # @see RubyLint::Analyze::CodingStyle#on_if
-      #
-      def on_elsif(token)
-        validate_parenthesis(token)
-      end
-
-      ##
-      # Called when a while statement is found.
-      #
-      # @see RubyLint::Analyze::CodingStyle#on_if
-      #
-      def on_while(token)
-        validate_parenthesis(token)
-      end
-
-      ##
-      # Called when a case statement is found.
-      #
-      # @see RubyLint::Analyze::CodingStyle#on_if
-      #
-      def on_case(token)
-        validate_parenthesis(token)
-      end
-
-      ##
-      # Called when a when statement is found.
-      #
-      # @see RubyLint::Analyze::CodingStyle#on_if
-      #
-      def on_when(token)
-        validate_parenthesis(token)
-      end
-
-      ##
-      # Called when an until statement is found.
-      #
-      # @see RubyLint::Analyze::CodingStyle#on_if
-      #
-      def on_until(token)
-        validate_parenthesis(token)
-      end
-
-      ##
-      # Called when an unless statement is found.
-      #
-      # @see RubyLint::Analyze::CodingStyle#on_if
-      #
-      def on_unless(token)
-        validate_parenthesis(token)
-      end
-
-      private
-
-      ##
-      # Validates the name of the specified token. This method will check for
-      # the use of camelCase as well as checking for the length of the name.
-      #
-      # @param [RubyLint::Token::Token] token The token to validate.
-      #
-      def validate_name(token)
-        if !token.respond_to?(:name) or !token.name
-          return
-        end
-
-        if token.name =~ /[a-z]+[A-Z]+/
-          info(
-            'the use of camelCase for names is discouraged',
-            token.line,
-            token.column
-          )
-        end
-
-        validate_name_length(token)
-      end
-
-      ##
-      # Checks if the name of the given token is too long or not. The maximum
-      # length of names is set in
-      # {RubyLint::Analyze::CodingStyle::MAXIMUM\_NAME\_LENGTH}.
-      #
-      # @param [RubyLint::Token::Token] token The token to validate.
-      #
-      def validate_name_length(token)
-        if !token.respond_to?(:name) or !token.name
-          return
-        end
-
-        if token.name.length > MAXIMUM_NAME_LENGTH
-          info(
-            "method and variable names should not be longer than " \
-              "#{MAXIMUM_NAME_LENGTH} characters",
-            token.line,
-            token.column
-          )
-        end
-      end
-
-      ##
-      # Checks if there are any parenthesis wrapped around a statement.
-      #
-      # @param [RubyLint::Token::Token] token The token to validate.
-      #
-      def validate_parenthesis(token)
-        if token.code =~ /#{token.type}\s*\(/
-          info(
-            'the use of parenthesis for statements is discouraged',
-            token.line,
-            token.column
-          )
-        end
-      end
-
-      ##
-      # Adds a warning for modifying a core Ruby constant.
-      #
-      # @param [RubyLint::Token::Token] token The token class to validate.
-      #
-      def validate_ruby_constant_modification(token)
-        if token.name.is_a?(Array)
-          name = token.name.join('::')
-        else
-          name = token.name
-        end
-
-        if Object.constants.include?(name.to_sym)
-          warning(
-            'modification of a core Ruby constant',
-            token.line,
-            token.column
-          )
-        end
-      end
-    end # CodingStyle
-  end # Analyze
-end # RubyLint

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

@@ -1,244 +0,0 @@
-module RubyLint
-  module Analyze
-    ##
-    # {RubyLint::Analyze::Definitions} is a callback class that is used for
-    # building a list of all the definitions (variables, methods, etc) of a
-    # block of Ruby code.
-    #
-    # The resulting instance of {RubyLint::Definition} is stored in the `@storage`
-    # instance variable under the key `:scope`. This makes it possible for
-    # other callback classes to access this data easily.
-    #
-    class Definitions < RubyLint::Callback
-      include Helper::Scoping
-
-      ##
-      # A short description of this class.
-      #
-      # @return [String]
-      #
-      DESCRIPTION = 'Builds a list of definitions, always enabled.'
-
-      ##
-      # Array containing the key names of the variables that should be exported
-      # out of a method definition.
-      #
-      # @return [Array]
-      #
-      EXPORT_VARIABLES = [:instance_variable, :class_variable, :constant]
-
-      ##
-      # Hash containing the scoping data to copy over when extending a class
-      # using a module.
-      #
-      # @return [Hash]
-      #
-      INCLUDE_SYMBOLS = {
-        'include' => {
-          :constant        => :constant,
-          :instance_method => :instance_method
-        },
-        'extend' => {
-          :constant        => :constant,
-          :instance_method => :method
-        }
-      }
-
-      ##
-      # Called when a value is assigned to a variable.
-      #
-      # @param [RubyLint::Token::AssignmentToken] token
-      #
-      def on_assignment(token)
-        if token.type == :global_variable
-          variable_scope = @storage[:scope]
-        else
-          variable_scope = scope
-        end
-
-        # Assignment using a constant path. In this case each path segment
-        # should exist (with the exception of the last one) for the assignment
-        # to take place.
-        if token.name.is_a?(Array)
-          name_scope = scope
-
-          token.name[0..-2].each do |segment|
-            name_scope = name_scope.lookup(:constant, segment)
-          end
-
-          if name_scope
-            variable_scope = name_scope
-          else
-            return
-          end
-
-          name = token.name[-1]
-          type = :constant
-        else
-          name = token.name
-          type = token.type
-        end
-
-        variable_scope.add(
-          type,
-          name,
-          Definition.new(nil, :token => token, :reset => false)
-        )
-      end
-
-      ##
-      # Called when a new method is defined.
-      #
-      # @param [RubyLint::Token::MethodDefinitionToken] token
-      #
-      def on_method_definition(token)
-        type      = :instance_method
-        new_scope = Definition.new(scope, :token => token)
-        target    = scope
-
-        token.parameters.each do |param|
-          new_scope.add(
-            param.type,
-            param.name,
-            Definition.new(nil, :token => param, :reset => false)
-          )
-        end
-
-        # The method is a class method.
-        if token.receiver
-          type = :method
-
-          if token.receiver.name != 'self' \
-          and token.receiver.name != @namespace[-1]
-            found  = target.lookup(token.receiver.type, token.receiver.name)
-            target = found if found
-          end
-        end
-
-        target.add(type, token.name, new_scope)
-
-        @scopes << new_scope
-      end
-
-      ##
-      # Called after a method definition has been processed.
-      #
-      # @see RubyLint::Analyze::Definitions#on_method_definition
-      #
-      def after_method_definition(token)
-        # TODO: exporting these variables should only be done if the method is
-        # actually called.
-        last_scope = @scopes.pop
-
-        EXPORT_VARIABLES.each do |key|
-          scope.symbols[key] = scope.symbols[key].merge(
-            last_scope.symbols[key]
-          )
-        end
-      end
-
-      ##
-      # Called when a class definition is found.
-      #
-      # @param [RubyLint::Token::ClassToken] token
-      #
-      def on_class(token)
-        name       = token.name.join('::')
-        @namespace << name
-        existing   = scope.lookup(:constant, name)
-
-        # If a class has already been defined the scope should not be
-        # overwritten.
-        if existing
-          existing.parent << scope
-          @scopes         << existing
-
-          return
-        end
-
-        parent    = scope.lookup(:constant, token.parent.join('::'))
-        new_scope = Definition.new([parent, scope], :token => token)
-
-        scope.add(:constant, name, new_scope)
-
-        @scopes << new_scope
-      end
-
-      ##
-      # Called after a class definition was found and processed.
-      #
-      # @see RubyLint::Analyze::Definitions#on_class
-      #
-      def after_class(token)
-        @scopes.pop
-        @namespace.pop
-      end
-
-      ##
-      # Called when a module is defined.
-      #
-      # @param [RubyLint::Token::Token] token
-      #
-      def on_module(token)
-        name       = token.name.join('::')
-        @namespace << name
-        existing   = scope.lookup(:constant, name)
-
-        # If a module has already been defined the scope should not be
-        # overwritten.
-        if existing
-          existing.parent << scope
-          @scopes         << existing
-
-          return
-        end
-
-        new_scope = Definition.new(scope, :token => token)
-
-        scope.add(:constant, name, new_scope)
-
-        @scopes << new_scope
-      end
-
-      ##
-      # Called after a module definition has been processed.
-      #
-      # @see RubyLint::Analyze::Definitions#on_module
-      #
-      def after_module(token)
-        @scopes.pop
-        @namespace.pop
-      end
-
-      ##
-      # Called when a method call is found. This callback is used to extend
-      # classes using modules.
-      #
-      # @param [RubyLint::Token::MethodToken] token
-      #
-      def on_method(token)
-        if INCLUDE_SYMBOLS.key?(token.name)
-          token.parameters.each do |param|
-            found = nil
-
-            # Extract the definition and scope to include.
-            if param.type == :constant_path
-              found = resolve_definition(param.name)
-            elsif param.type == :constant
-              found = scope.lookup(:constant, param.name)
-            end
-
-            next unless found
-
-            # Copy over all the constants and methods.
-            INCLUDE_SYMBOLS[token.name].each do |source, target|
-              found.symbols[source].each do |name, data|
-                scope.add(target, name, data)
-              end
-            end
-          end
-        end
-      end
-    end # Definitions
-  end # Analyze
-end # RubyLint