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