Class: Yoda::Parsing::NodeObjects::Namespace

Inherits:
Object
  • Object
show all
Includes:
AstTraversable
Defined in:
lib/yoda/parsing/node_objects/namespace.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from AstTraversable

#calc_nodes_to_current_location

Constructor Details

#initialize(node, parent = nil) ⇒ Namespace

Returns a new instance of Namespace.

Parameters:

  • node (::Parser::AST::Node)
  • parent (Namespace, nil) (defaults to: nil) 


15
16
17
18
19
20
 
# 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

Instance Attribute Details

#node ⇒ ::Parser::AST::Node (readonly)

Returns:

  • (::Parser::AST::Node) 


8
9
10
 
# File 'lib/yoda/parsing/node_objects/namespace.rb', line 8

def node
  @node
end

#parent ⇒ Namespace? (readonly)

Returns:



11
12
13
 
# File 'lib/yoda/parsing/node_objects/namespace.rb', line 11

def parent
  @parent
end

Instance Method Details

#body_node ⇒ ::Parser::AST::Node

Returns:

  • (::Parser::AST::Node) 


23
24
25
26
27
 
# 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) ⇒ MethodNodeWrapper?

Parameters:

Returns:

  • (MethodNodeWrapper, nil) 


88
89
90
91
 
# 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) ⇒ Namespace?

Parameters:

Returns:



80
81
82
83
84
 
# 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 ⇒ Wrappers::MethodNodeWrapper

Returns:

  • (Wrappers::MethodNodeWrapper) 


40
41
42
 
# 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 ⇒ Namespace

Returns:



35
36
37
 
# 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 ⇒ ::Parser::AST::Node?

Returns:

  • (::Parser::AST::Node, nil) 


30
31
32
 
# 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 ⇒ String, Symbol

Returns:

  • (String, Symbol) 


63
64
65
66
67
 
# 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 ⇒ String

Returns:

  • (String) 


52
53
54
55
 
# File 'lib/yoda/parsing/node_objects/namespace.rb', line 52

def path
  name = full_name
  name == :root ? '' : name
end

#paths_from_root ⇒ Array<String>

Returns:

  • (Array<String>) 


70
71
72
73
74
75
76
 
# 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? ⇒ true, false

Returns:

  • (true, false) 


58
59
60
 
# File 'lib/yoda/parsing/node_objects/namespace.rb', line 58

def root?
  type == :root
end

#type ⇒ Object 



44
45
46
47
48
49
 
# 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