ruby-lint 0.0.2 → 0.0.3

data/lib/ruby-lint/extensions/string.rb

@@ -0,0 +1,15 @@
+class String
+  unless method_defined?(:snake_case)
+    ##
+    # Creates a new string that is `snake_cased`.
+    #
+    # @example
+    #  "FooBar".snake_case # => "foo_bar"
+    #
+    # @return [String]
+    #
+    def snake_case
+      return self.gsub(/([a-z])([A-Z])/, '\\1_\\2').gsub('::', '_').downcase
+    end
+  end
+end # String

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

@@ -0,0 +1,41 @@
+module RubyLint
+  module Helper
+    ##
+    # The ConstantPaths helper module can be used to easily iterate over the
+    # segments of a constant path and perform lookups on each segment.
+    #
+    module ConstantPaths
+      ##
+      # Iterates over each segment of the constant path and yields the supplied
+      # block.
+      #
+      # @example
+      #  path = s(:constant_path, s(:constant, 'A'), s(:constant, 'B')
+      #
+      #  iterate_constant_path(path) do |name, segment, definition|
+      #    puts name
+      #  end
+      #
+      # @param [RubyLint::Node] node The constant path to iterate over.
+      #
+      # @yieldparam [String] name The name of the current segment.
+      # @yieldparam [RubyLint::Node] node The raw AST node of the current
+      #  segment.
+      # @yieldparam [RubyLint::Definition::RubyObject] definition The
+      #  definition object of the current segment.
+      #
+      def iterate_constant_path(node)
+        definitions = current_scope
+
+        node.children.each do |segment|
+          name       = segment.children[0]
+          definition = definitions.lookup(:constant, name)
+
+          yield name, segment, definition
+
+          definition ? definitions = definition : break
+        end
+      end
+    end # ConstantPaths
+  end # Helper
+end # RubyLint

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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,98 @@
+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

@@ -0,0 +1,91 @@
+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/inspector.rb

@@ -0,0 +1,191 @@
+module RubyLint
+  ##
+  # The Inspector class is a debugging related class primarily used for making
+  # it easy to display a list of methods/constants of a given source constant.
+  #
+  # Note that this class is considered to be a private API and as such may
+  # change without any notice.
+  #
+  # @!attribute [r] constant
+  #  @return [Class]
+  # @!attribute [r] constant_name
+  #  @return [String]
+  #
+  class Inspector
+    attr_reader :constant, :constant_name
+
+    ##
+    # @param [String|Class] constant
+    #
+    def initialize(constant)
+      @constant_name = constant
+
+      if constant.is_a?(String)
+        constant = resolve_constant(constant)
+      end
+
+      @constant = constant
+    end
+
+    ##
+    # Returns an Array containing all child constants and their childrne
+    # (recursively).
+    #
+    # The constants returned by this method are returned as String instances
+    # containing the full path (e.g. `Encoding::BINARY` instead of `BINARY`).
+    #
+    # @param [Class] source
+    # @param [Array] ignore
+    # @return [Array<String>]
+    #
+    def inspect_constants(source = constant, ignore = [])
+      source_name    = source.to_s
+      constants      = []
+      have_children  = []
+      include_source = source != Object
+
+      if include_source
+        constants << source_name
+        ignore     = ignore + [source.to_s]
+      end
+
+      source.constants.each do |name|
+        next unless source.const_defined?(name)
+
+        constant  = source.const_get(name)
+        name      = name.to_s
+        full_name = include_source ? "#{source_name}::#{name}" : name
+
+        next if ignore.include?(full_name)
+
+        ignore    << constant
+        constants << full_name
+
+        if process_child_constants?(source, constant)
+          have_children << constant
+        end
+      end
+
+      have_children.each do |constant|
+        inspect_constants(constant, ignore).each do |child|
+          constants << child unless constants.include?(child)
+        end
+      end
+
+      return constants
+    end
+
+    ##
+    # Returns an Array containing all method objects sorted by their names.
+    #
+    # @return [Array]
+    #
+    def inspect_methods
+      return [] unless constant.respond_to?(:methods)
+
+      methods = constant.methods(false).map do |name|
+        method_information(:method, name)
+      end
+
+      return methods.sort_by(&:name)
+    end
+
+    ##
+    # Returns an Array containing all instance methods sorted by their names.
+    #
+    # @return [Array]
+    #
+    def inspect_instance_methods
+      return [] unless constant.respond_to?(:instance_methods)
+
+      methods = constant.instance_methods(false).map do |name|
+        method_information(:instance_method, name)
+      end
+
+      return methods.sort_by(&:name)
+    end
+
+    ##
+    # Formats the list of methods in a human readable format.
+    #
+    # @param [Array] methods
+    # @return [String]
+    #
+    def format_methods(methods)
+      output  = []
+      longest = 0
+
+      methods.each do |method|
+        longest = method.name.length if method.name.length > longest
+      end
+
+      methods.each do |method|
+        output << "%-#{longest}s: %s" % [
+          method.name,
+          method.parameters.inspect
+        ]
+      end
+
+      return output.join("\n")
+    end
+
+    ##
+    # Formats a list of constants in a human readable format.
+    #
+    # @param [Array] constants
+    # @return [String]
+    #
+    def format_constants(constants)
+      return constants.join("\n")
+    end
+
+    private
+
+    ##
+    # @param [Class] source
+    # @param [Class] constant
+    # @return [TrueClass|FalseClass]
+    #
+    def process_child_constants?(source, constant)
+      return constant.respond_to?(:constants) \
+        && constant != source \
+        && !constant.constants.empty?
+    end
+
+    ##
+    # Returns the method object for the given type and name.
+    #
+    # @param [Symbol] type
+    # @param [Symbol] name
+    # @return [UnboundMethod]
+    #
+    def method_information(type, name)
+      return constant.send(type, name)
+    end
+
+    ##
+    # Converts a String based constant path into an actual constant.
+    #
+    # @param [String] constant
+    # @return [Class]
+    # @raise [ArgumentError] Raised when one of the segments doesn't exist.
+    #
+    def resolve_constant(constant)
+      current = Object
+      final   = nil
+
+      constant.split('::').each do |segment|
+        if current.const_defined?(segment)
+          current = final = current.const_get(segment)
+        else
+          raise(
+            ArgumentError,
+            "Constant #{segment} does not exist in #{constant}"
+          )
+        end
+      end
+
+      return final
+    end
+  end # Inspector
+end # RubyLint