ruby-lint 0.0.3 → 0.0.4

data/lib/ruby-lint/helper/conversion.rb

@@ -1,33 +0,0 @@
-module RubyLint
-  module Helper
-    ##
-    # The Conversion helper can be used to easily convert {RubyLint::Node}
-    # instances into specific definition objects.
-    #
-    module Conversion
-      ##
-      # Returns a {RubyLint::Definition::RubyObject} instance that represents
-      # an instance of the Node's corresponding Ruby class.
-      #
-      # @param [RubyLint::Node] node
-      # @return [RubyLint::Definition::RubyObject]
-      #
-      def instance_for_ruby_type(node)
-        return unless node.ruby_class
-
-        definition = nil
-        class_def  = RubyLint.global_constant(node.ruby_class)
-
-        if class_def
-          definition = Definition::RubyObject.new_from_node(
-            node,
-            :instance_type => :instance,
-            :parents       => [class_def]
-          )
-        end
-
-        return definition
-      end
-    end # Conversion
-  end # Helper
-end # RubyLint

data/lib/ruby-lint/helper/current_scope.rb

@@ -1,98 +0,0 @@
-module RubyLint
-  module Helper
-    ##
-    # {RubyLint::Helper::CurrentScope} is a helper module that makes it easier
-    # to retrieve the current scope in callback methods. Instead of having to
-    # manually retrieve the scope to use based on the current node all you have
-    # to do is include this module and call `current_scope`.
-    #
-    # ## Inheritance
-    #
-    # Due to this module defining a few common callback methods such as
-    # `on_class` you should **always** call `super` if you override these
-    # methods in a class. For example, this will prevent the helper from
-    # working properly:
-    #
-    #     class MyIterator < RubyLint::Iterator
-    #       include RubyLint::Helper::CurrentScope
-    #
-    #       def on_class(node)
-    #         # ...
-    #       end
-    #     end
-    #
-    # This however will not:
-    #
-    #     class MyIterator < RubyLint::Iterator
-    #       include RubyLint::Helper::CurrentScope
-    #
-    #       def on_class(node)
-    #         super
-    #
-    #         # ...
-    #       end
-    #     end
-    #
-    module CurrentScope
-      ##
-      # @see RubyLint::Iterator#initialize
-      #
-      def initialize(*args)
-        super
-
-        @scopes = []
-      end
-
-      ##
-      # Array containing the callback names for which a new scope should be
-      # created.
-      #
-      # @return [Array<Symbol>]
-      #
-      SCOPES = [
-        :block,
-        :class,
-        :method_definition,
-        :module,
-        :root,
-        :sclass
-      ]
-
-      SCOPES.each do |type|
-        define_method("on_#{type}") do |node|
-          set_current_scope(node)
-        end
-
-        define_method("after_#{type}") do |node|
-          set_previous_scope
-        end
-      end
-
-      ##
-      # Returns the current scope.
-      #
-      # @return [RubyLint::Definition::RubyObject]
-      #
-      def current_scope
-        return @scopes[-1]
-      end
-
-      ##
-      # Sets the current scope to the definition associated with the given
-      # node.
-      #
-      # @param [RubyLint::Node] node
-      #
-      def set_current_scope(node)
-        @scopes << associated_definition(node)
-      end
-
-      ##
-      # Sets the current scope back to the previous one.
-      #
-      def set_previous_scope
-        @scopes.pop
-      end
-    end # CurrentScope
-  end # Helper
-end # RubyLint

data/lib/ruby-lint/helper/methods.rb

@@ -1,91 +0,0 @@
-module RubyLint
-  module Helper
-    ##
-    # Helper module that provides various methods for looking up methods,
-    # checking if they exist, etc.
-    #
-    module Methods
-      include CurrentScope
-      include Conversion
-
-      ##
-      # Checks if the method for the given node is defined or not.
-      #
-      # @param [RubyLint::Node] node
-      # @return [TrueClass|FalseClass]
-      #
-      def method_defined?(node)
-        scope = method_scope(node)
-
-        if scope
-          return scope.has_definition?(scope.method_call_type, node.name)
-        else
-          return false
-        end
-      end
-
-      ##
-      # Returns a boolean that indicates if the receiver is valid or not.
-      #
-      # @param [RubyLint::Node] node
-      # @return [TrueClass|FalseClass]
-      #
-      def invalid_receiver?(node)
-        invalid = false
-
-        if node.receiver
-          receiver = method_receiver(node.receiver)
-          invalid  = !receiver || (receiver.variable? && receiver.value.nil?)
-        end
-
-        return invalid
-      end
-
-      ##
-      # Looks up the method definition for the specified method call.
-      #
-      # @param [RubyLint::Node] node
-      # @return [RubyLint::Definition::RubyMethod]
-      #
-      def lookup_method(node)
-        scope = method_scope(node)
-
-        return scope.lookup(scope.method_call_type, node.name)
-      end
-
-      ##
-      # Determines the scope to use for a method call.
-      #
-      # @param [RubyLint::Node] node
-      # @return [RubyLint::Definition::RubyObject]
-      #
-      def method_scope(node)
-        scope = node.receiver ? method_receiver(node.receiver) : current_scope
-
-        return scope.variable? && scope.value ? scope.value : scope
-      end
-
-      ##
-      # Tries to determine the receiver definition of a method call.
-      #
-      # @param [RubyLint::Node|Array] receiver
-      # @return [RubyLint::Definition::RubyObject]
-      #
-      def method_receiver(receiver)
-        receiver = receiver.is_a?(Array) ? receiver[0] : receiver
-        scope    = instance_for_ruby_type(receiver)
-
-        if !scope
-          scope = current_scope.lookup(receiver.type, receiver.name)
-        end
-
-        # Last resort, try to load the receiver as a global constant.
-        if !scope and receiver.constant?
-          scope = RubyLint.global_constant(receiver.name)
-        end
-
-        return scope
-      end
-    end # Methods
-  end # Helper
-end # RubyLint

data/lib/ruby-lint/node.rb

@@ -1,107 +0,0 @@
-module RubyLint
-  ##
-  # {RubyLint::Node} is a class that represents a single node in the AST of a
-  # Ruby program. It contains information such as the type, children, line
-  # number and column number.
-  #
-  class Node < AST::Node
-    include VariablePredicates
-
-    ##
-    # Returns the line number of the node.
-    #
-    # @return [Fixnum]
-    #
-    attr_reader :line
-
-    ##
-    # Returns the column number of the node.
-    #
-    # @return [Fixnum]
-    #
-    attr_reader :column
-
-    ##
-    # Returns the name of the file that the node belongs to.
-    #
-    # @return [String]
-    #
-    attr_reader :file
-
-    ##
-    # @return [String]
-    #
-    def name
-      name = children[0] || type
-      name = name.is_a?(Node) ? name.children[0] : name
-
-      return name.to_s
-    end
-
-    ##
-    # @return [Mixed]
-    #
-    def value
-      value = collection? ? children : children[-1]
-      value = children[1] if variable?
-
-      return value
-    end
-
-    ##
-    # Returns the receiver of the method call/definition.
-    #
-    # @return [RubyLint::Node]
-    #
-    def receiver
-      return method? ? children[-1] : children[-2]
-    end
-
-    ##
-    # Returns a symbol that indicates if a node is either a method or instance
-    # method.
-    #
-    # @return [Symbol]
-    #
-    def method_type
-      return receiver ? :method : :instance_method
-    end
-
-    ##
-    # Gathers a set of arguments and returns them as an Array.
-    #
-    # @param [#to_sym] type The type of arguments to gather.
-    # @return [Array]
-    #
-    def gather_arguments(type = :argument)
-      args = []
-      type = type.to_sym
-
-      children.each do |child|
-        if !child.is_a?(Node) or child.type != :arguments
-          next
-        end
-
-        child.children.each do |child_arg|
-          next unless child_arg.type == type
-
-          args << child_arg.children[0]
-        end
-      end
-
-      return args
-    end
-
-    ##
-    # Iterates over each argument of the given type.
-    #
-    # @param [Symbol] type The argument type.
-    # @yieldparam [RubyLint::Node] argument
-    #
-    def each_argument(type = :argument)
-      gather_arguments(type).each do |arg|
-        yield arg
-      end
-    end
-  end # Node
-end # RubyLint

data/lib/ruby-lint/parser_error.rb

@@ -1,30 +0,0 @@
-module RubyLint
-  ##
-  # Exception class that's raised when the parser {RubyLint::Parser} detects
-  # syntax errors.
-  #
-  # @!attribute [r] line
-  #  @return [Numeric]
-  # @!attribute [r] column
-  #  @return [Numeric]
-  # @!attribute [r] file
-  #  @return [String]
-  #
-  class ParserError < SyntaxError
-    attr_reader :line, :column, :file
-
-    ##
-    # @param [String] message
-    # @param [Numeric] line
-    # @param [Numeric] column
-    # @param [String] file
-    #
-    def initialize(message, line, column, file)
-      @line   = line
-      @column = column
-      @file   = file
-
-      super(message)
-    end
-  end # ParserError
-end # RubyLint

data/spec/ruby-lint/constant_loader.rb

@@ -1,32 +0,0 @@
-require File.expand_path('../../helper', __FILE__)
-
-describe RubyLint::ConstantLoader do
-  after do
-    RubyLint.global_scope.definitions[:constant].delete('ERB')
-  end
-
-  should 'lazy load using a constant' do
-    constant = 'ERB'
-    ast      = parse(constant)
-    iterator = RubyLint::ConstantLoader.new
-
-    RubyLint.global_scope.lookup(:constant, constant).nil?.should == true
-
-    iterator.iterate(ast)
-
-    RubyLint.global_scope.lookup(:constant, constant).nil?.should == false
-  end
-
-  should 'lazy load using a constant path' do
-    constant = 'Enumerable'
-    ast      = parse('Enumerable::Enumerator')
-    iterator = RubyLint::ConstantLoader.new
-
-    RubyLint.global_scope.lookup(:constant, constant).nil?.should == true
-
-    iterator.iterate(ast)
-
-    RubyLint.global_scope.lookup(:constant, constant).nil?.should     == false
-    RubyLint.global_scope.lookup(:constant, 'Enumerator').nil?.should == true
-  end
-end

data/spec/ruby-lint/definition/method_calls.rb

@@ -1,26 +0,0 @@
-require File.expand_path('../../../helper', __FILE__)
-
-describe 'Evaluating method calls on RubyObject instances' do
-  before do
-    @object = ruby_object.new(
-      :name          => 'String',
-      :type          => :constant,
-      :instance_type => :instance
-    )
-
-    @method = ruby_method.new(
-      :name         => 'gsub',
-      :type         => :instance_method,
-      :return_value => proc { |object| object.instance }
-    )
-
-    @object.add(@method.type, @method.name, @method)
-  end
-
-  should 'return a instance when evaluating a method call' do
-    value = @object.call(@method.name)
-
-    value.name.should == @object.name
-    value.type.should == @object.type
-  end
-end

data/spec/ruby-lint/definitions_builder/assignments/arrays.rb

@@ -1,71 +0,0 @@
-require File.expand_path('../../../../helper', __FILE__)
-
-describe 'Building variable definitions' do
-  should 'assign arrays as instances' do
-    defs  = build_definitions('numbers = []')
-    value = defs.lookup(:local_variable, 'numbers').value
-
-    value.instance?.should == true
-
-    value.has_definition?(:instance_method, 'each').should == true
-  end
-
-  describe 'array index assignments' do
-    should 'process single index assignments' do
-      code = <<-CODE
-  numbers    = []
-  numbers[0] = 10
-      CODE
-
-      defs    = build_definitions(code)
-      numbers = defs.lookup(:local_variable, 'numbers')
-
-      numbers.is_a?(ruby_object).should       == true
-      numbers.value.is_a?(ruby_object).should == true
-      numbers.value.type.should               == :array
-
-      first = numbers.lookup(:member, 0)
-
-      first.is_a?(ruby_object).should == true
-      first.type.should               == :integer
-
-      first.value.is_a?(ruby_object).should == true
-      first.value.type.should               == :integer
-      first.value.value.should              == '10'
-    end
-
-    should 'process multiple index assignments' do
-      code = <<-CODE
-numbers        = []
-numbers[0,1]   = 10
-numbers[2,3]   = 20, 30
-numbers[4,5,6] = 40, 50
-      CODE
-
-      defs    = build_definitions(code)
-      numbers = defs.lookup(:local_variable, 'numbers')
-
-      numbers.lookup(:member, '0').value.value.should == '10'
-      numbers.lookup(:member, '1').value.should       == nil
-      numbers.lookup(:member, '2').value.value.should == '20'
-      numbers.lookup(:member, '3').value.value.should == '30'
-      numbers.lookup(:member, '4').value.value.should == '40'
-      numbers.lookup(:member, '5').value.value.should == '50'
-      numbers.lookup(:member, '6').value.should       == nil
-    end
-
-    should 'process index assignments using variables' do
-      code = <<-CODE
-index          = 1
-numbers        = [10]
-numbers[index] = 20
-      CODE
-
-      defs    = build_definitions(code)
-      numbers = defs.lookup(:local_variable, 'numbers')
-
-      numbers.lookup(:member, '0').value.value.should == '10'
-      numbers.lookup(:member, '1').value.value.should == '20'
-    end
-  end
-end