ruby-lint 1.0.3 → 1.1.0

data/lib/ruby-lint/template/definition.erb

@@ -1,30 +1,37 @@
 # This file was automatically generated, any manual changes will be lost the
 # next time this file is generated.
 #
-# Created:  <%= Time.new %>
 # Platform: <%= RUBY_ENGINE %> <%= Rubinius::VERSION rescue RUBY_VERSION %>
 
-<% @constants.each do |constant| %>
-RubyLint::GlobalScope.definitions.define_constant('<%= constant.name %>') do |klass|
-  <%- if constant.superclass -%>
-  klass.inherits(RubyLint::GlobalScope.constant_proxy('<%= constant.superclass %>'))
-  <%- end -%>
+RubyLint.registry.register('<%= @constants[0].name %>') do |defs|
+  <%- @constants.each do |constant| -%>
+  defs.define_constant('<%= constant.name %>') do |klass|
+    <%- if constant.superclass -%>
+    klass.inherits(defs.constant_proxy('<%= constant.superclass %>', RubyLint.registry))
+    <%- end -%>
+    <%- constant.modules.each do |mod| -%>
+    klass.inherits(defs.constant_proxy('<%= mod %>', RubyLint.registry))
+    <%- end -%>
 
-  <%- constant.methods.each do |type, collection| -%>
-  <%- collection.each do |name, args| -%>
+    <%- constant.methods.each do |type, collection| -%>
+    <%- collection.each do |name, args| -%>
 
-  <%- if args.empty? -%>
-  klass.define_<%= type %>('<%= name %>')
-  <%- else -%>
-  klass.define_<%= type %>('<%= name %>') do |method|
-    <%- args.each do |arg| -%>
-    method.define_<%= arg[:type] %>('<%= arg[:name] %>')
+    <%- if args.empty? -%>
+    klass.define_<%= type %>('<%= name %>')
+    <%- else -%>
+    klass.define_<%= type %>('<%= name %>') do |method|
+      <%- args.each do |arg| -%>
+      method.define_<%= arg[:type] %>('<%= arg[:name] %>')
+      <%- end -%>
+      <%- if return_instance?(type, name) -%>
+
+      method.returns { |object| object.instance }
+      <%- end -%>
+    end
+    <%- end -%>
+    <%- end -%>
     <%- end -%>
   end
-  <%- end -%>
-  <%- end -%>
+
   <%- end -%>
 end
-<% end %>
-
-RubyLint::GlobalScope.definitions.lookup(:const, '<%= @constants[0].name %>').deep_freeze

data/lib/ruby-lint/template/scope.rb

@@ -14,6 +14,18 @@ module RubyLint
         end
       end
 
+      ##
+      # Returns `true` if the method's definition should return an instance of
+      # the container.
+      #
+      # @param [Symbol] type
+      # @param [Symbol] name
+      #
+      def return_instance?(type, name)
+        return (type == :method && name == :new) ||
+          (type == :instance_method && name == :initialize)
+      end
+
       ##
       # @return [Binding]
       #

data/lib/ruby-lint/variable_predicates.rb

@@ -34,6 +34,13 @@ module RubyLint
       :nil    => 'NilClass'
     }
 
+    ##
+    # List of variable types used in {#variable?}.
+    #
+    # @return [Array]
+    #
+    VARIABLE_TYPES = [:lvar, :ivar, :cvar, :gvar]
+
     PREDICATE_METHODS.each do |type|
       define_method("#{type}?") do
         return @type == type
@@ -60,5 +67,12 @@ module RubyLint
     def ruby_class
       return RUBY_CLASSES[type]
     end
+
+    ##
+    # @return [TrueClass|FalseClass]
+    #
+    def variable?
+      return VARIABLE_TYPES.include?(type)
+    end
   end # VariablePredicates
 end # RubyLint

data/lib/ruby-lint/version.rb

@@ -1,3 +1,3 @@
 module RubyLint
-  VERSION = '1.0.3'
+  VERSION = '1.1.0'
 end # RubyLint

data/lib/ruby-lint/virtual_machine.rb

@@ -161,16 +161,19 @@ module RubyLint
     def after_initialize
       @comments ||= {}
 
-      @associations   = {}
-      @definitions    = initial_definitions
-      @scopes         = [@definitions]
-      @value_stack    = NestedStack.new
-      @variable_stack = NestedStack.new
-      @ignored_nodes  = []
-      @visibility     = :public
+      @associations    = {}
+      @definitions     = initial_definitions
+      @constant_loader = ConstantLoader.new(:definitions => @definitions)
+      @scopes          = [@definitions]
+      @value_stack     = NestedStack.new
+      @variable_stack  = NestedStack.new
+      @ignored_nodes   = []
+      @visibility      = :public
 
       reset_docstring_tags
       reset_method_type
+
+      @constant_loader.bootstrap
     end
 
     ##
@@ -182,6 +185,9 @@ module RubyLint
     def run(ast)
       ast = [ast] unless ast.is_a?(Array)
 
+      # pre-load all the built-in definitions.
+      @constant_loader.run(ast)
+
       ast.each { |node| iterate(node) }
 
       freeze
@@ -386,7 +392,7 @@ module RubyLint
     def after_array(node)
       builder = DefinitionBuilder::RubyArray.new(
         node,
-        current_scope,
+        self,
         :values => value_stack.pop
       )
 
@@ -408,7 +414,7 @@ module RubyLint
     def after_hash(node)
       builder = DefinitionBuilder::RubyHash.new(
         node,
-        current_scope,
+        self,
         :values => value_stack.pop
       )
 
@@ -478,6 +484,7 @@ module RubyLint
         parent = evaluate_node(parent_node)
 
         if !parent or !parent.const?
+          # FIXME: this should use `definitions` instead.
           parent = current_scope.lookup(:const, 'Object')
         end
       end
@@ -498,7 +505,7 @@ module RubyLint
     # @param [RubyLint::AST::Node] node
     #
     def on_block(node)
-      builder    = DefinitionBuilder::RubyBlock.new(node, current_scope)
+      builder    = DefinitionBuilder::RubyBlock.new(node, self)
       definition = builder.build
 
       associate_node(node, definition)
@@ -555,7 +562,7 @@ module RubyLint
 
       builder = DefinitionBuilder::RubyMethod.new(
         node,
-        current_scope,
+        self,
         :type       => @method_type,
         :receiver   => receiver,
         :visibility => @visibility
@@ -613,6 +620,7 @@ module RubyLint
           update_parents_from_tag(docstring_tags.param_tags[name], var)
         end
 
+        associate_node(node, var)
         current_scope.add(type, name, var)
         current_scope.add_definition(var)
       end
@@ -660,6 +668,13 @@ Received: #{arguments.length}
         EOF
       end
 
+      # Associate the argument definitions with their nodes.
+      arguments.each_with_index do |obj, index|
+        arg_node = node.children[2 + index]
+
+        associate_node(arg_node, obj)
+      end
+
       # If the receiver doesn't exist there's no point in associating a context
       # with it.
       if receiver and !receiver_definition
@@ -736,6 +751,52 @@ Received: #{arguments.length}
       evaluator.evaluate(arguments, current_scope)
     end
 
+    ##
+    # @return [RubyLint::Definition::RubyObject]
+    #
+    def current_scope
+      return @scopes.last
+    end
+
+    ##
+    #
+    # @return [RubyLint::Definition::RubyObject]
+    #
+    def previous_scope
+      return @scopes[-2]
+    end
+
+    ##
+    # @param [String] name
+    # @return [RubyLint::Definition::RubyObject]
+    #
+    def global_constant(name)
+      found = definitions.lookup(:const, name)
+
+      # Didn't find it? Lets see if the constant loader knows about it.
+      unless found
+        @constant_loader.load_constant(name)
+
+        found = definitions.lookup(:const, name)
+      end
+
+      return found
+    end
+
+    ##
+    # Evaluates and returns the value of the given node.
+    #
+    # @param [RubyLint::AST::Node] node
+    # @return [RubyLint::Definition::RubyObject]
+    #
+    def evaluate_node(node)
+      value_stack.add_stack
+
+      iterate(node)
+
+      return value_stack.pop.first
+    end
+
     private
 
     ##
@@ -747,10 +808,14 @@ Received: #{arguments.length}
       definitions = Definition::RubyObject.new(
         :name          => 'root',
         :type          => :root,
-        :parents       => [GlobalScope.definitions],
-        :instance_type => :instance
+        :instance_type => :instance,
+        :inherit_self  => false
       )
 
+      definitions.parents = [
+        definitions.constant_proxy('Object', RubyLint.registry)
+      ]
+
       definitions.define_self
 
       return definitions
@@ -764,7 +829,7 @@ Received: #{arguments.length}
     # @param [Hash] options
     #
     def define_module(node, definition_builder, options = {})
-      builder    = definition_builder.new(node, current_scope, options)
+      builder    = definition_builder.new(node, self, options)
       definition = builder.build
       scope      = builder.scope
       existing   = scope.lookup(definition.type, definition.name, false)
@@ -784,20 +849,6 @@ Received: #{arguments.length}
       push_scope(definition)
     end
 
-    ##
-    # @return [RubyLint::Definition::RubyObject]
-    #
-    def current_scope
-      return @scopes.last
-    end
-
-    ##
-    # @return [RubyLint::Definition::RubyObject]
-    #
-    def previous_scope
-      return @scopes[-2]
-    end
-
     ##
     # Associates the given node and defintion with each other.
     #
@@ -950,7 +1001,7 @@ Received: #{arguments.length}
     # @param [Hash] options
     #
     def create_primitive(node, options = {})
-      builder = DefinitionBuilder::Primitive.new(node, current_scope, options)
+      builder = DefinitionBuilder::Primitive.new(node, self, options)
 
       return builder.build
     end
@@ -1037,20 +1088,6 @@ Received: #{arguments.length}
       end
     end
 
-    ##
-    # Evaluates and returns the value of the given node.
-    #
-    # @param [RubyLint::AST::Node] node
-    # @return [RubyLint::Definition::RubyObject]
-    #
-    def evaluate_node(node)
-      value_stack.add_stack
-
-      iterate(node)
-
-      return value_stack.pop.first
-    end
-
     ##
     # Includes the definition `inherit` in the list of parent definitions of
     # `definition`.
@@ -1145,8 +1182,7 @@ Received: #{arguments.length}
     # @return [RubyLint::Definition::RubyObject]
     #
     def lookup_type_definition(name)
-      return current_scope.lookup(:const, name) ||
-        GlobalScope.global_constant(name)
+      return current_scope.lookup(:const, name) || global_constant(name)
     end
 
     ##
@@ -1159,7 +1195,7 @@ Received: #{arguments.length}
       # THINK: currently ruby-lint assumes methods always return a single type
       # but YARD allows you to specify multiple ones. For now we'll take the
       # first one but there should be a nicer way to do this.
-      definition.returns(definitions[0]) if definitions[0]
+      definition.returns(definitions[0].instance) if definitions[0]
     end
 
     ##

data/ruby-lint.gemspec

@@ -12,34 +12,23 @@ Gem::Specification.new do |s|
   s.executables = ['ruby-lint']
   s.license     = 'MIT'
 
-  s.post_install_message = <<-EOF.strip
-Thanks for installing ruby-lint. Keep in mind that ruby-lint is still a young
-project and as such there will be bugs, false positives and otherwise weird
-behaviour. If you encounter any of these issues please report them (and provide
-some sample code) at the issue tracker:
-
-https://github.com/YorickPeterse/ruby-lint/issues/new
-
-If you have any further questions you can find me on Twitter/Freenode/Github
-using the handle "yorickpeterse".
-  EOF
+  s.post_install_message = 'Please report any issues at: ' \
+    'https://github.com/YorickPeterse/ruby-lint/issues/new'
 
   s.files = File.read(File.expand_path('../MANIFEST', __FILE__)).split("\n")
 
   s.has_rdoc              = 'yard'
   s.required_ruby_version = '>= 1.9.3'
 
-  s.add_dependency 'parser', ['~> 2.0']
+  s.add_dependency 'parser', ['~> 2.1', '>= 2.1.1']
   s.add_dependency 'slop', ['~> 3.4', '>= 3.4.7']
 
   s.add_development_dependency 'rake'
   s.add_development_dependency 'rspec', ['>= 2.14']
   s.add_development_dependency 'yard'
-  s.add_development_dependency 'pry-rescue'
   s.add_development_dependency 'simplecov'
   s.add_development_dependency 'coveralls'
   s.add_development_dependency 'json'
   s.add_development_dependency 'kramdown'
   s.add_development_dependency 'redcard'
-  s.add_development_dependency 'gnuplot'
 end

data/spec/ruby-lint/analysis/undefined_methods_spec.rb

@@ -48,7 +48,7 @@ String.example_method
   example 'add an error when calling a method defined in a different scope' do
     code = <<-CODE
 class Person
-  def name
+  def person_name
     return 'name'
   end
 
@@ -57,7 +57,7 @@ class Person
   end
 end
 
-name
+person_name
     CODE
 
     report = build_report(code, RubyLint::Analysis::UndefinedMethods)
@@ -70,7 +70,7 @@ name
 
     entry.line.should    == 11
     entry.column.should  == 1
-    entry.message.should == 'undefined method name'
+    entry.message.should == 'undefined method person_name'
   end
 
   describe 'core Ruby types' do
@@ -317,4 +317,21 @@ end
     entry.message.should == 'undefined method to_foo on an instance of ' \
       'Fixnum, Bignum or Numeric'
   end
+
+  context 'method missing' do
+    example 'do not add errors when method_missing is defined' do
+      code = <<-CODE
+class Foo
+  def method_missing; end
+end
+
+foo = Foo.new
+foo.bar
+      CODE
+
+      report = build_report(code, RubyLint::Analysis::UndefinedMethods)
+
+      report.entries.empty?.should == true
+    end
+  end
 end

data/spec/ruby-lint/analysis/useless_equality_checks_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+describe RubyLint::Analysis::UselessEqualityChecks do
+  example 'compare a String literal with a Fixnum literal' do
+    code   = "'foo' == 10"
+    report = build_report(code, RubyLint::Analysis::UselessEqualityChecks)
+    entry  = report.entries[0]
+
+    entry.line.should    == 1
+    entry.column.should  == 1
+    entry.message.should == 'Comparing String with Fixnum evaluates to false'
+  end
+
+  example 'compare a variable with a Fixnum literal' do
+    code = <<-EOF
+string = 'foo'
+
+string == 10
+    EOF
+
+    report = build_report(code, RubyLint::Analysis::UselessEqualityChecks)
+    entry  = report.entries[0]
+
+    entry.message.should == 'Comparing String with Fixnum evaluates to false'
+  end
+
+  example 'compare two variables' do
+    code = <<-EOF
+string = 'foo'
+number = 10
+
+string == number
+    EOF
+
+    report = build_report(code, RubyLint::Analysis::UselessEqualityChecks)
+    entry  = report.entries[0]
+
+    entry.message.should == 'Comparing String with Fixnum evaluates to false'
+  end
+
+  example 'compare a String literal with a method call' do
+    code = <<-EOF
+# @return [Fixnum]
+def number
+  return 10
+end
+
+'foo' == number
+    EOF
+
+    report = build_report(code, RubyLint::Analysis::UselessEqualityChecks)
+    entry  = report.entries[0]
+
+    entry.message.should == 'Comparing String with Fixnum evaluates to false'
+  end
+
+  example 'ignore values that are unknown' do
+    code = <<-EOF
+def foo
+end
+
+10 == foo
+    EOF
+
+    report = build_report(code, RubyLint::Analysis::UselessEqualityChecks)
+
+    report.entries.empty?.should == true
+  end
+
+  example 'calling methods on objects that return unknown values' do
+    code = <<-CODE
+def example(number)
+  return '10' == number.to_s
+end
+    CODE
+
+    report = build_report(code, RubyLint::Analysis::UselessEqualityChecks)
+
+    report.entries.empty?.should == true
+  end
+
+  context 'ignoring variables with unknown values' do
+    example 'ignore a local variable without a value' do
+      code = <<-CODE
+[10, 20].each do |number|
+  number == false
+end
+      CODE
+
+      report = build_report(code, RubyLint::Analysis::UselessEqualityChecks)
+
+      report.entries.empty?.should == true
+    end
+
+    example 'ignore an instance variable without a value' do
+      code = <<-CODE
+[10, 20].each do |@number|
+  @number == false
+end
+      CODE
+
+      report = build_report(code, RubyLint::Analysis::UselessEqualityChecks)
+
+      report.entries.empty?.should == true
+    end
+  end
+end