class Yoda::Parsing::NodeObjects::Namespace

Attributes

node[R]

@return [::Parser::AST::Node]

parent[R]

@return [Namespace, nil]

Public Class Methods

new(node, parent = nil) click to toggle source

@param node [::Parser::AST::Node] @param parent [Namespace, nil]

# File lib/yoda/parsing/node_objects/namespace.rb, line 15
def initialize(node, parent = nil)
  fail ArgumentError, node unless node.is_a?(::Parser::AST::Node)
  fail ArgumentError, parent unless !parent || parent.is_a?(Namespace)
  @node = node
  @parent = parent
end

Public Instance Methods

body_node() click to toggle source

@return [::Parser::AST::Node]

# File lib/yoda/parsing/node_objects/namespace.rb, line 23
def body_node
  return node if type == :root
  return node.children[2] if type == :class
  node.children[1]
end
calc_current_location_method(location) click to toggle source

@param location [Location] @return [MethodNodeWrapper, nil]

# File lib/yoda/parsing/node_objects/namespace.rb, line 88
def calc_current_location_method(location)
  namespace = calc_current_location_namespace(location)
  namespace && namespace.child_methods.find { |method| location.included?(method.node.location) }
end
calc_current_location_namespace(location) click to toggle source

@param location [Location] @return [Namespace, nil]

# File lib/yoda/parsing/node_objects/namespace.rb, line 80
def calc_current_location_namespace(location)
  return nil unless location.included?(node.location)
  including_child_namespace = child_namespaces.find { |namespace| location.included?(namespace.node.location) }
  including_child_namespace ? including_child_namespace.calc_current_location_namespace(location) : self
end
child_methods() click to toggle source

@return [Wrappers::MethodNodeWrapper]

# File lib/yoda/parsing/node_objects/namespace.rb, line 40
def child_methods
  @child_methods ||= child_nodes_of(body_node).select { |node| %i(def defs).include?(node.type) }.map { |node| MethodDefinition.new(node, self) }
end
child_namespaces() click to toggle source

@return [Namespace]

# File lib/yoda/parsing/node_objects/namespace.rb, line 35
def child_namespaces
  @child_namespaces ||= child_nodes_of(body_node).select { |node| %i(module class sclass).include?(node.type) }.map { |node| self.class.new(node, self) }
end
const_node() click to toggle source

@return [::Parser::AST::Node, nil]

# File lib/yoda/parsing/node_objects/namespace.rb, line 30
def const_node
  %i(root sclass).include?(type) ? nil : node.children[0]
end
full_name() click to toggle source

@return [String, Symbol]

# File lib/yoda/parsing/node_objects/namespace.rb, line 63
def full_name
  return :root if type == :root
  parent_name = parent && !parent.root? ? parent.full_name : ''
  const_node ? ConstNode.new(const_node).to_s(parent_name) : parent_name
end
path() click to toggle source

@return [String]

# File lib/yoda/parsing/node_objects/namespace.rb, line 52
def path
  name = full_name
  name == :root ? '' : name
end
paths_from_root() click to toggle source

@return [Array<String>]

# File lib/yoda/parsing/node_objects/namespace.rb, line 70
def paths_from_root
  if root?
    [path]
  else
    parent ? parent.paths_from_root + [path] : ['', path]
  end
end
root?() click to toggle source

@return [true, false]

# File lib/yoda/parsing/node_objects/namespace.rb, line 58
def root?
  type == :root
end
type() click to toggle source
# File lib/yoda/parsing/node_objects/namespace.rb, line 44
def type
  @type ||= begin
    return node.type if %i(module class sclass).include?(node.type)
    :root
  end
end

Private Instance Methods

child_nodes_of(node) click to toggle source
# File lib/yoda/parsing/node_objects/namespace.rb, line 95
def child_nodes_of(node)
  # @todo evaluate nodes in the namespace
  return [] unless node
  return node.children.map { |child| child_nodes_of(child) }.flatten.compact if node.type == :begin
  [node]
end