ruby-lint 0.0.3 → 0.0.4

data/lib/ruby-lint/default_names.rb

@@ -0,0 +1,19 @@
+RubyLint::Configuration.register_names 'analysis' do |names|
+  RubyLint::Analysis.constants.each do |const|
+    next if const == :Base
+
+    names[const.to_s.snake_case] = RubyLint::Analysis.const_get(const)
+  end
+end
+
+RubyLint::Configuration.register_names 'presenters' do |names|
+  RubyLint::Presenter.constants.each do |const|
+    names[const.to_s.snake_case] = RubyLint::Presenter.const_get(const)
+  end
+end
+
+RubyLint::Configuration.register_names 'levels' do |names|
+  RubyLint::Report::DEFAULT_LEVELS.each do |level|
+    names[level.to_s] = level
+  end
+end

data/lib/ruby-lint/definition/constant_proxy.rb

@@ -0,0 +1,56 @@
+module RubyLint
+  module Definition
+    ##
+    # {RubyLint::Definition::ConstantProxy} is a proxy class for constant
+    # definitions. The primary use case for this class is inheriting constants
+    # in the pre-generated definitions found in the definitions directory. By
+    # using this class when creating definitions the load order doesn't matter,
+    # as long as the data is there at some point in time.
+    #
+    # @!attribute [r] proxy_source
+    #  @return [RubyLint::Definition::RubyObject]
+    #
+    # @!attribute [r] proxy_name
+    #  @return [String]
+    #
+    # @!attribut [r] proxy_definition
+    #  @return [RubyLint::Definition::RubyObject]
+    #
+    class ConstantProxy
+      attr_reader :proxy_source, :proxy_name, :proxy_definition
+
+      ##
+      # @param [RubyLint::Definition::RubyObject] source The source definition
+      #  to use for looking up the definition associated with the current
+      #  proxy.
+      # @param [String] name The name/constant path of the constant that this
+      #  proxy belongs to.
+      #
+      def initialize(source, name)
+        @proxy_source = source
+        @proxy_name   = name
+      end
+
+      # Pre-define all the methods of the definition, this is faster than
+      # having to rely on method_missing.
+      RubyObject.instance_methods(false).each do |method|
+        define_method(method) do |*args, &block|
+          lookup_proxy_definition
+
+          proxy_definition.send(method, *args, &block) if proxy_definition
+        end
+      end
+
+      private
+
+      ##
+      # Looks up the associated definition and stores it if it exists.
+      #
+      def lookup_proxy_definition
+        return if proxy_definition
+
+        @proxy_definition = proxy_source.lookup_constant_path(proxy_name)
+      end
+    end # ConstantProxy
+  end # Definition
+end # RubyLint

data/lib/ruby-lint/definition/ruby_method.rb

@@ -21,119 +21,28 @@ module RubyLint
     #  @return [RubyLint::Definition::RubyObject] The rest argument of a
     #   method definition.
     #
-    # @!attribute [r] more_arguments
-    #  @return [Array] A set of "more" arguments of the method definition.
-    #
     # @!attribute [r] block_argument
     #  @return [RubyLint::Definition::RubyObject] The block argument of a
     #   method definition.
     #
-    # @!attribute [r] method_type
-    #  @return [Symbol] The type of method definition, set to `:method` for
-    #   class methods and `:instance_method` for instance methods.
-    #
     # @!attribute [r] return_value
     #  @return [Mixed] The value that is returned by the method.
     #
     class RubyMethod < RubyObject
-      ##
-      # Hash that contains the node types and attribute names to store the
-      # arguments in.
-      #
-      # @return [Hash]
-      #
-      ARGUMENT_TYPE_MAPPING = {
-        :argument          => :arguments,
-        :optional_argument => :optional_arguments,
-        :rest_argument     => :rest_argument,
-        :more_argument     => :more_arguments,
-        :block_argument    => :block_argument
-      }
-
       attr_reader :block_argument,
         :arguments,
-        :method_type,
-        :more_arguments,
         :optional_arguments,
         :rest_argument,
         :return_value,
         :visibility
 
       ##
-      # @see RubyLint::Definition::RubyObject#new_from_node
-      #
-      def self.new_from_node(node, options = {})
-        options  = default_method_options.merge(options)
-        options  = options.merge(gather_arguments(node))
-        receiver = node.receiver
-
-        options[:method_type] ||= node.method_type
-
-        if receiver
-          options[:receiver]    = RubyObject.new_from_node(receiver)
-          options[:method_type] = :method
-        end
-
-        return super(node, options)
-      end
-
-      ##
-      # Returns a Hash containing all the arguments grouped together based on
-      # their types.
-      #
-      # @param [RubyLint::Node] node
-      # @return [Hash]
-      #
-      def self.gather_arguments(node)
-        arguments = default_arguments
-
-        ARGUMENT_TYPE_MAPPING.each do |from, to|
-          args = node.gather_arguments(from)
-          args = args.map { |n| RubyObject.new_from_node(n, :value => n.value) }
-
-          arguments[to] = arguments[to].is_a?(Array) ? args : args[0]
-        end
-
-        return arguments
-      end
-
-      ##
-      # Returns the default Hash for a set of method arguments.
-      #
-      # @return [Hash]
-      #
-      def self.default_arguments
-        return {
-          :arguments          => [],
-          :optional_arguments => [],
-          :rest_argument      => nil,
-          :more_arguments     => [],
-          :block_argument     => nil
-        }
-      end
-
-      ##
-      # Returns a Hash containing the default options for this class. The name
-      # is different than {RubyLint::Definition::RubyObject#default_options} to
-      # prevent any naming issues.
+      # Called after a new instance is created of this class. This method is
+      # called before calling any supplied blocks.
       #
-      # @return [Hash]
-      #
-      def self.default_method_options
-        return {:method_type => :instance_method}
-      end
-
-      ##
-      # @see RubyLint::Definition::RubyObject#initialize
-      #
-      def initialize(*args)
-        @arguments          = []
-        @optional_arguments = []
-        @more_arguments     = []
-
-        super
-
-        define_arguments unless method?
+      def after_initialize
+        @arguments          ||= []
+        @optional_arguments ||= []
       end
 
       ##
@@ -161,7 +70,7 @@ module RubyLint
       # @param [String] name The name of the argument.
       #
       def define_argument(name)
-        @arguments << create_variable(name)
+        @arguments << create_argument(:arg, name)
       end
 
       ##
@@ -170,7 +79,7 @@ module RubyLint
       # @see RubyLint::Definition::RubyObject#define_argument
       #
       def define_optional_argument(name)
-        @optional_arguments << create_variable(name)
+        @optional_arguments << create_argument(:optarg, name)
       end
 
       ##
@@ -179,16 +88,7 @@ module RubyLint
       # @see RubyLint::Definition::RubyObject#define_argument
       #
       def define_rest_argument(name)
-        @rest_argument = create_variable(name)
-      end
-
-      ##
-      # Defines a more argument for the method.
-      #
-      # @see RubyLint::Definition::RubyObject#define_argument
-      #
-      def define_more_argument(name)
-        @more_arguments << create_variable(name)
+        @rest_argument = create_argument(:restarg, name)
       end
 
       ##
@@ -197,51 +97,29 @@ module RubyLint
       # @see RubyLint::Definition::RubyObject#define_argument
       #
       def define_block_argument(name)
-        @block_argument = create_variable(name)
+        @block_argument = create_argument(:blockarg, name)
       end
 
       private
 
       ##
-      # Adds all the arguments of this method to the definitions list.
+      # Adds a new argument to the method as well as adding it as a local
+      # variable. Note that although the argument's variable is saved under a
+      # argument key (e.g. `:arg`) the actual definition type is set to
+      # `:lvar`.
+      #
+      # @param [Symbol] type The type of argument.
+      # @param [String] name The name of the argument.
       #
-      def define_arguments
-        all_arguments.each do |params|
-          next unless params
-
-          params.each do |param|
-            add(param.type, param.name, param) if param
-          end
-        end
-      end
-
-      ##
-      # Returns an Array containing all the method arguments. Each arguments
-      # set (even single ones such as the more argument) is returned as an
-      # Array making it easier to iterate over the collection.
-      #
-      # @return [Array]
-      #
-      def all_arguments
-        return [
-          arguments,
-          optional_arguments,
-          [rest_argument],
-          more_arguments,
-          [block_argument]
-        ]
-      end
-
-      ##
-      # @param [String] name
       # @return [RubyLint::Definition::RubyObject]
       #
-      def create_variable(name)
-        variable = RubyObject.new(:type => :local_variable, :name => name)
+      def create_argument(type, name)
+        argument = RubyObject.new(:type => :lvar, :name => name)
 
-        add(variable.type, variable.name, variable)
+        add(argument.type, argument.name, argument)
+        add(type, argument.name, argument)
 
-        return variable
+        return argument
       end
     end # RubyMethod
   end # Definition

data/lib/ruby-lint/definition/ruby_object.rb

@@ -16,14 +16,14 @@ module RubyLint
     # Using the RubyObject class one could create a definition for the String
     # class as following:
     #
-    #     string  = RubyObject.new(:name => 'String', :type => :constant)
+    #     string  = RubyObject.new(:name => 'String', :type => :const)
     #     newline = RubyObject.new(
     #       :name  => 'NEWLINE',
-    #       :type  => :constant,
+    #       :type  => :const,
     #       :value => "\n"
     #     )
     #
-    #     string.add(:constant, newline.name, newline)
+    #     string.add(:const, newline.name, newline)
     #
     # For more information see the documentation of the corresponding methods.
     #
@@ -34,12 +34,7 @@ module RubyLint
     #  @return [Mixed] The value of the object.
     #
     # @!attribute [r] type
-    #  @return [Symbol] The type of object, e.g. `:constant`.
-    #
-    # @!attribute [r] ignore
-    #  @return [TrueClass|FalseClass] When set to `true` the definition should
-    #   be ignored by any analysis related code. This is mostly used when no
-    #   meaningful data could be assigned (e.g. block arguments).
+    #  @return [Symbol] The type of object, e.g. `:const`.
     #
     # @!attribute [r] definitions
     #  @return [Hash] Hash containing all child the definitions.
@@ -47,10 +42,6 @@ module RubyLint
     # @!attribute [rw] parents
     #  @return [Array] Array containing the parent definitions.
     #
-    # @!attribute [rw] receiver
-    #  @return [RubyLint::Definition::RubyObject] The receiver on which the
-    #   object was defined/called.
-    #
     # @!attribute [rw] reference_amount
     #  @return [Numeric] The amount of times an object was referenced.
     #   Currently this is only used for variables.
@@ -63,6 +54,11 @@ module RubyLint
     #  @return [Array] A list of data types to also add to the parent
     #   definitions when adding an object to the current one.
     #
+    # @!attribute [r] members_as_value
+    #  @return [TrueClass|FalseClass] When set to `true` the {#value} getter
+    #   returns a collection of the members instead of the manually defined
+    #   value.
+    #
     class RubyObject
       include VariablePredicates
 
@@ -73,101 +69,54 @@ module RubyLint
       # @return [Array]
       #
       LOOKUP_PARENT = [
-        :class_variable,
-        :constant,
-        :global_variable,
+        :const,
+        :cvar,
+        :gvar,
         :instance_method,
-        :instance_variable,
+        :ivar,
         :keyword,
         :method
-      ]
+      ].freeze
 
       ##
       # String used to separate segments in a constant path.
       #
       # @return [String]
       #
-      PATH_SEPARATOR = '::'
-
-      attr_reader :update_parents,
-        :column,
-        :definitions,
-        :ignore,
-        :name,
-        :type,
-        :value
-
-      attr_accessor :instance_type,
-        :parents,
-        :receiver,
-        :reference_amount
+      PATH_SEPARATOR = '::'.freeze
 
       ##
-      # Creates a new RubyObject instance based on an instance of
-      # {RubyLint::Node}. This method is primarily used in
-      # {RubyLint::DefinitionsBuilder}, in most cases third-party code should
-      # not have a need for this method.
+      # Array containing the valid data types that can be stored.
       #
-      # @param [RubyLint::Node] node
-      # @return [RubyLint::Definition::RubyObject]
+      # @return [Array<Symbol>]
       #
-      def self.new_from_node(node, options = {})
-        path_segments = []
-
-        if node.constant_path?
-          path_segments = node.children[0..-2].reverse
-          node          = node.children[-1]
-        end
-
-        options[:name] ||= node.name
-        options[:type] ||= node.type
-
-        # Checking to see if :value evaluates to `true` would mean you could
-        # never manually assign a nil value.
-        unless options.key?(:value)
-          options[:value] = node.value
-        end
-
-        if options[:value]
-          options[:value] = create_value_definitions(options[:value])
-        end
+      VALID_TYPES = [
+        :lvar,
+        :ivar,
+        :cvar,
+        :gvar,
+        :const,
+        :method,
+        :instance_method,
+        :member,
+        :keyword,
+        :arg,
+        :optarg,
+        :restarg,
+        :blockarg
+      ].freeze
 
-        object = new(options)
+      attr_reader :update_parents,
+        :definitions,
+        :members_as_value,
+        :name,
+        :type
 
-        # Assign the receivers of this object.
-        #
-        # TODO: this approach doesn't take existing definitions into account,
-        # instead it will always create a new one for each segment.
-        if !path_segments.empty? and !options[:receiver]
-          path_segments.inject(object) do |source, segment|
-            source.receiver = new_from_node(segment)
-            source.receiver
-          end
-        end
-
-        return object
-      end
-
-      ##
-      # Converts either a single {RubyLint::Node} instance or a collection of
-      # instances into {RubyObject} instances.
-      #
-      # @param [RubyLint::Node|Array<RubyLint::Node>] value
-      # @return [RubyLint::Node|Array<RubyLint::Node>]
-      #
-      def self.create_value_definitions(value)
-        if value.is_a?(Array)
-          value = value.map { |v| create_value_definitions(v) }
-        elsif value.is_a?(Node)
-          value = RubyObject.new_from_node(value)
-        end
-
-        return value
-      end
+      attr_accessor :instance_type, :parents, :reference_amount
 
       ##
       # @example
-      #  string = RubyObject.new(:name => 'String', :type => :constant)
+      #  string = RubyObject.new(:name => 'String', :type => :const)
       #
       # @param [Hash] options Hash containing additional options such as the
       #  parent definitions. For a list of available options see the
@@ -176,35 +125,61 @@ module RubyLint
       # @yieldparam [RubyLint::Definition::RubyObject]
       #
       def initialize(options = {})
-        options = default_options.merge(options)
-
         options.each do |key, value|
           instance_variable_set("@#{key}", value)
         end
 
-        clear!
+        @update_parents   ||= []
+        @instance_type    ||= :class
+        @parents          ||= []
+        @reference_amount ||= 0
+
+        @definitions = Hash.new { |hash, key| hash[key] = {} }
+        @value       = nil if members_as_value
+
+        after_initialize if respond_to?(:after_initialize)
 
         yield self if block_given?
       end
 
       ##
-      # Sets the value of the definition. If a {RubyLint::Node} instance is
-      # specified it will be converted to a definition instance.
+      # Returns the value of the definition. If `members_as_value` is set to
+      # `true` the return value is a Hash containing the names and values of
+      # each member.
       #
-      # @param [RubyLint::Definition::RubyObject|RubyLint::Node] value
+      # @return [Hash|RubyLint::Definition::RubyObject]
+      #
+      def value
+        return members_as_value ? list(:member) : @value
+      end
+
+      ##
+      # Sets the value of the definition.
+      #
+      # @param [Mixed] value
       #
       def value=(value)
-        @value = value.is_a?(Node) ? RubyObject.new_from_node(value) : value
+        @value = value
+      end
+
+      ##
+      # Adds the definition object to the current one.
+      #
+      # @see #add
+      # @param [RubyLint::Definition::RubyObject] definition
+      #
+      def add_definition(definition)
+        add(definition.type, definition.name, definition)
       end
 
       ##
       # Adds a new definition to the definitions list.
       #
       # @example
-      #  string  = RubyObject.new(:name => 'String', :type => :constant)
+      #  string  = RubyObject.new(:name => 'String', :type => :const)
       #  newline = RubyObject.new(
       #    :name  => 'NEWLINE',
-      #    :type  => :constant,
+      #    :type  => :const,
       #    :value => "\n"
       #  )
       #
@@ -220,13 +195,13 @@ module RubyLint
       # @raise [ArgumentError] Raised when the specified type was invalid.
       #
       def add(type, name, value)
-        type = prepare_type(type)
+        type = type.to_sym
 
         unless value.is_a?(RubyObject)
           raise TypeError, "Expected RubyObject but got #{value.class}"
         end
 
-        unless definitions.key?(type)
+        unless VALID_TYPES.include?(type)
           raise ArgumentError, ":#{type} is not a valid type of data to add"
         end
 
@@ -244,22 +219,24 @@ module RubyLint
       # If no definition was found `nil` will be returned.
       #
       # @example
-      #  string  = RubyObject.new(:name => 'String', :type => :constant)
+      #  string  = RubyObject.new(:name => 'String', :type => :const)
       #  newline = RubyObject.new(
       #    :name  => 'NEWLINE',
-      #    :type  => :constant,
+      #    :type  => :const,
       #    :value => "\n"
       #  )
       #
       #  string.add(newline.type, newline.name, newline)
       #
-      #  string.lookup(:constant, 'NEWLINE') # => #<RubyLint::Definition...>
+      #  string.lookup(:const, 'NEWLINE') # => #<RubyLint::Definition...>
       #
       # @param [#to_sym] type
       # @param [String] name
+      # @param [TrueClass|FalseClass] lookup_parent Whether definitions should
+      #  be looked up from parent definitions.
       # @return [RubyLint::Definition::RubyObject|NilClass]
       #
-      def lookup(type, name)
+      def lookup(type, name, lookup_parent = true)
         type, name = prepare_lookup(type, name)
         found      = nil
 
@@ -267,7 +244,7 @@ module RubyLint
           found = definitions[type][name]
 
         # Look up the definition in the parent scope(s) (if any are set).
-        elsif lookup_parent?(type)
+        elsif lookup_parent?(type) and lookup_parent
           parents.each do |parent|
             parent_definition = parent.lookup(type, name)
 
@@ -282,61 +259,71 @@ module RubyLint
       end
 
       ##
-      # Returns the definition for the given constant path. If one of the
-      # segments does not exist an error is raised instead.
+      # Returns the definition for the given constant path.
       #
       # @example
       #  example.lookup_constant_path('A::B') # => #<RubyLint::Definition...>
       #
       # @param [String|Array<String>] path
       # @return [RubyLint::Definition::RubyObject]
-      # @raise [ArgumentError] Raised when an invalid constant path is
-      #  specified.
       #
       def lookup_constant_path(path)
         constant = self
         path     = path.split(PATH_SEPARATOR) if path.is_a?(String)
 
         path.each do |segment|
-          found = constant.lookup(:constant, segment)
-
-          if found
-            constant = found
-          else
-            name = path.join(PATH_SEPARATOR)
+          found = constant.lookup(:const, segment)
 
-            raise ArgumentError, "Invalid constant path: #{name}"
-          end
+          found ? constant = found : return
         end
 
         return constant
       end
 
       ##
-      # Mimics a method call based on the given method name and the instance
-      # type of the current definition.
+      # Mimics a method call by executing the method for the given name. This
+      # method should be defined in the current definition.
+      #
+      # @param [String] name The name of the method.
+      # @return [Mixed]
+      #
+      def call_method(name)
+        method = lookup(method_call_type, name)
+
+        unless method
+          raise NoMethodError, "Undefined method #{name} for #{self.inspect}"
+        end
+
+        return method.call(self)
+      end
+
+      ##
+      # Returns `true` if a method is defined, similar to `respond_to?`.
+      #
+      # @return [TrueClass|FalseClass]
+      #
+      def method_defined?(name)
+        return has_definition?(method_call_type, name)
+      end
+
+      ##
+      # Performs a method call on the current definition.
       #
       # If the return value of a method definition is set to a Proc (or any
       # other object that responds to `:call`) it will be called and passed the
       # current instance as an argument.
       #
-      # @todo Support for method arguments, if needed.
-      # @param [String] name The name of the method to call.
+      # TODO: add support for specifying method arguments.
+      #
+      # @param [RubyLint::Definition::RubyObject] context The context in which
+      #  the method was called.
       # @return [Mixed]
       #
-      def call(name)
-        method       = lookup(method_call_type, name)
-        return_value = nil
+      def call(context = self)
+        retval = return_value
+        retval = retval.call(context) if retval.respond_to?(:call)
 
-        if method
-          return_value = method.return_value
-
-          if return_value.respond_to?(:call)
-            return_value = return_value.call(self)
-          end
-        end
-
-        return return_value
+        return retval
       end
 
       ##
@@ -388,14 +375,6 @@ module RubyLint
         return instance_type == :instance
       end
 
-      ##
-      # Updates the definition object so that it represents an instance of a
-      # Ruby value.
-      #
-      def instance!
-        @instance_type = :instance
-      end
-
       ##
       # Checks if the specified definition is defined in the current object,
       # ignoring data in any parent definitions.
@@ -420,36 +399,17 @@ module RubyLint
       # @return [Array]
       #
       def list(type)
-        return definitions[prepare_type(type)].values
+        return definitions[type.to_sym].values
       end
 
       ##
-      # Returns the length of an attribute or 0.
+      # Returns the amount of definitions stored for a given type.
       #
-      # @param [#to_sym] attribute
+      # @param [#to_sym] type
       # @return [Numeric]
       #
-      def length_of(attribute)
-        value = send(attribute)
-
-        return value ? value.length : 0
-      end
-
-      ##
-      # Resets the list of definitions for the current RubyObject instance.
-      #
-      def clear!
-        @definitions = {
-          :local_variable    => {},
-          :instance_variable => {},
-          :class_variable    => {},
-          :global_variable   => {},
-          :constant          => {},
-          :method            => {},
-          :instance_method   => {},
-          :member            => {},
-          :keyword           => {}
-        }
+      def amount(type)
+        return list(type).length
       end
 
       ##
@@ -481,31 +441,6 @@ module RubyLint
         end
       end
 
-      ##
-      # Returns an Array containing all the receivers of the current
-      # definition. These receivers are sorted from left to right. For example,
-      # assume the following:
-      #
-      #     a.b.c
-      #
-      # In this case the return value would be as following:
-      #
-      #     [a, b, c]
-      #
-      # @return [Array]
-      #
-      def receiver_path
-        receivers = []
-        source    = self
-
-        while receiver = source.receiver
-          receivers << receiver
-          source     = receiver
-        end
-
-        return receivers << self
-      end
-
       ##
       # Creates a new definition object based on the current one that
       # represents an instance of a Ruby value (instead of a class).
@@ -531,7 +466,7 @@ module RubyLint
       # @return [TrueClass|FalseClass]
       #
       def used?
-        return @reference_amount > 0
+        return reference_amount > 0
       end
 
       ##
@@ -549,9 +484,11 @@ module RubyLint
           target     = lookup_constant_path(path[0..-2])
           definition = target.define_constant(path[-1], &block)
         else
-          definition = add_child_definition(name, :constant, &block)
+          definition = add_child_definition(:const, name, &block)
         end
 
+        definition.add(:keyword, 'self', definition)
+
         return definition
       end
 
@@ -565,7 +502,7 @@ module RubyLint
       # @param [Mixed] value
       #
       def define_global_variable(name, value = nil)
-        return add_child_definition(name, :global_variable, value)
+        return add_child_definition(:gvar, name, value)
       end
 
       ##
@@ -578,7 +515,7 @@ module RubyLint
       # @return [RubyLint::Definition::RubyMethod]
       #
       def define_method(name, &block)
-        return add_child_method(name, :method, &block)
+        return add_child_method(:method, name, &block)
       end
 
       ##
@@ -590,7 +527,7 @@ module RubyLint
       # @see RubyLint::Definition::RubyObject#define_method
       #
       def define_instance_method(name, &block)
-        return add_child_method(name, :instance_method, &block)
+        return add_child_method(:instance_method, name, &block)
       end
 
       ##
@@ -614,7 +551,7 @@ module RubyLint
       # @param [Array] definitions
       #
       def inherits(*definitions)
-        self.parents += definitions
+        self.parents.concat(definitions)
       end
 
       ##
@@ -653,12 +590,12 @@ module RubyLint
       ##
       # Adds a new child definition to the current definition.
       #
-      # @param [String] name The name of the definition.
       # @param [Symbol] type The definition type.
+      # @param [String] name The name of the definition.
       # @param [Mixed] value
       # @return [RubyLint::Definition::RubyObject]
       #
-      def add_child_definition(name, type, value = nil, &block)
+      def add_child_definition(type, name, value = nil, &block)
         definition = self.class.new(
           :name    => name,
           :type    => type,
@@ -677,16 +614,15 @@ module RubyLint
       #
       # @see RubyLint::Definition::RubyObject#add_child_definition
       #
-      def add_child_method(name, type, &block)
+      def add_child_method(type, name, &block)
         definition = RubyMethod.new(
-          :name        => name,
-          :type        => :method,
-          :method_type => type,
-          :parents     => [self],
+          :name    => name,
+          :type    => type,
+          :parents => [self],
           &block
         )
 
-        add(definition.method_type, definition.name, definition)
+        add(definition.type, definition.name, definition)
 
         return definition
       end
@@ -702,22 +638,6 @@ module RubyLint
         return LOOKUP_PARENT.include?(type) && !parents.empty?
       end
 
-      ##
-      # Returns a Hash containing the default options.
-      #
-      # @return [Hash]
-      #
-      def default_options
-        return {
-          :update_parents    => [],
-          :instance_type     => :class,
-          :parents           => [],
-          :receiver          => nil,
-          :reference_amount  => 0,
-          :value             => nil
-        }
-      end
-
       ##
       # Casts the type and name of data to look up to the correct values.
       #
@@ -726,31 +646,7 @@ module RubyLint
       # @return [Array]
       #
       def prepare_lookup(type, name)
-        return prepare_type(type), prepare_name(name)
-      end
-
-      ##
-      # Prepares the name of a definition.
-      #
-      # @param [#to_s] name
-      # @return [String]
-      #
-      def prepare_name(name)
-        name = name.to_s unless name.is_a?(String)
-
-        return name
-      end
-
-      ##
-      # Prepares the data type name.
-      #
-      # @param [#to_sym] type
-      # @return [Symbol]
-      #
-      def prepare_type(type)
-        type = type.to_sym unless type.is_a?(Symbol)
-
-        return type
+        return type.to_sym, name.to_s
       end
     end # RubyObject
   end # Definition