Module: Ruby::Node::Traversal::Misc

Included in:
Ruby::Node
Defined in:
lib/traversal/misc.rb

Instance Method Summary collapse

Instance Method Details

#args?(value, with_block = nil) ⇒ Boolean

Returns:

  • (Boolean) 


5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
# File 'lib/traversal/misc.rb', line 5

def args?(value, with_block = nil) 
  found = 0        
  obj = has_a_block?(with_block) ? self.block : self
  args_list = get_args_list(obj)
  return false if !args_list    
  args_list.elements.each do |arg|    
    argument = retrieve_arg(arg)  
    next if !valid_arg?(argument)
    value.each do |v|            
      v = v[:array] if v.respond_to?(:has_key?) && v[:array]              
      found += 1 if argument == v
    end
  end     
  return found == argument_count(value)
end

#argument_count(args) ⇒ Object 



21
22
23
 
# File 'lib/traversal/misc.rb', line 21

def argument_count(args)
  args.reject{|arg| !valid_arg?(arg)}.size
end

#convert_value(value, type = nil) ⇒ Object 



52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/traversal/misc.rb', line 52

def convert_value(value, type = nil)
  type_val = type || value
  case type_val                    
  when Ruby::Symbol  
    value.to_sym
  when Ruby::Integer
    value.to_i                          
  when Ruby::Float
    value.to_f        
  when Ruby::Hash
    type ? get_hash(type) : value       
  when Ruby::Array
    type ? get_array(type) : value       
  when Ruby::Assoc   
    return get_assoc(type)
  else
    value
  end
end

#get_arg(arg) ⇒ Object 



72
73
74
 
# File 'lib/traversal/misc.rb', line 72

def get_arg(arg)  
  get_symbol(arg) || get_assoc(arg) || get_composite(arg) || get_identifier(arg) || get_token(arg) || resolve_arg_wrapper(arg)
end

#get_args_list(obj) ⇒ Object 



33
34
35
36
37
 
# File 'lib/traversal/misc.rb', line 33

def get_args_list(obj)                         
  return obj.params if obj.respond_to? :params 
  return obj.arguments if obj.respond_to? :arguments 
  # return obj if obj.class == Ruby::ArgsList       
end

#get_array(args) ⇒ Object 



89
90
91
92
93
94
95
96
97
 
# File 'lib/traversal/misc.rb', line 89

def get_array(args)
  return nil if arg.class != Ruby::Array
  arr = []  
  args.each do |arg|
     arr << get_arg(arg)
  end
  return arr if !arr.empty?
  nil
end

#get_assoc(arg) ⇒ Object 



111
112
113
114
 
# File 'lib/traversal/misc.rb', line 111

def get_assoc(arg)
  return nil if !(arg.class == Ruby::Assoc) 
  get_hash_item(arg)      
end

#get_composite(arg) ⇒ Object 



82
83
84
85
86
87
 
# File 'lib/traversal/misc.rb', line 82

def get_composite(arg)
  return nil if !arg.respond_to? :elements
  e = arg.elements
  return get_arg(e[0]) if e.size == 1
  get_hash(e) || get_array(e)
end

#get_hash(args) ⇒ Object 



99
100
101
102
103
104
105
106
107
108
109
 
# File 'lib/traversal/misc.rb', line 99

def get_hash(args)    
  return nil if !args.class == Ruby::Hash
  items = args.respond_to?(:elements) ? args.elements : args 
  hash = {}  
  items.each do |arg|  
     hash_val = get_arg(arg) 
     hash.merge!(hash_val)
  end    
  return hash if !hash.empty?
  nil
end

#get_hash_item(arg) ⇒ Object 



116
117
118
119
120
121
 
# File 'lib/traversal/misc.rb', line 116

def get_hash_item(arg)   
  return if !arg.respond_to? :key      
  key = get_key(arg.key)
  value = get_value(arg.value)
  return {key => value}
end

#get_identifier(arg) ⇒ Object 



138
139
140
 
# File 'lib/traversal/misc.rb', line 138

def get_identifier(arg)
  get_token(arg.identifier) if arg.respond_to? :identifier
end

#get_key(key) ⇒ Object 



123
124
125
126
127
128
129
130
 
# File 'lib/traversal/misc.rb', line 123

def get_key(key)             
  if key.respond_to? :identifier
   id = get_identifier(key)
  end
  return id.to_sym if key.class == Ruby::Symbol
  return get_token(key) if key.class == Ruby::Variable
  id
end

#get_string(arg) ⇒ Object 



142
143
144
 
# File 'lib/traversal/misc.rb', line 142

def get_string(arg)
  get_token(arg.elements[0]) if arg.class == Ruby::String
end

#get_symbol(arg) ⇒ Object 



76
77
78
79
80
 
# File 'lib/traversal/misc.rb', line 76

def get_symbol(arg)
  return nil if !(arg.class == Ruby::Symbol)
  t = get_token(arg)
  t ? t.to_sym : nil
end

#get_token(arg) ⇒ Object 



146
147
148
 
# File 'lib/traversal/misc.rb', line 146

def get_token(arg)                             
  arg.token if arg.respond_to? :token
end

#get_value(value) ⇒ Object

Needs rework!



133
134
135
136
 
# File 'lib/traversal/misc.rb', line 133

def get_value(value)
  real_value = get_arg(value)
  convert_value(real_value, value)
end

#has_a_block?(with_block) ⇒ Boolean

Returns:

  • (Boolean) 


29
30
31
 
# File 'lib/traversal/misc.rb', line 29

def has_a_block?(with_block)
  with_block && self.respond_to?(:block)
end

#resolve_arg_wrapper(arg_wrapper) ⇒ Object 



39
40
41
42
43
44
 
# File 'lib/traversal/misc.rb', line 39

def resolve_arg_wrapper(arg_wrapper)
  return arg_wrapper.arg if arg_wrapper.respond_to? :arg            
  return arg_wrapper.param if arg_wrapper.respond_to? :param            
  return arg_wrapper if arg_wrapper.class == Ruby::Arg
  arg_wrapper
end

#retrieve_arg(arg_wrapper) ⇒ Object 



46
47
48
49
50
 
# File 'lib/traversal/misc.rb', line 46

def retrieve_arg(arg_wrapper)
  arg = resolve_arg_wrapper(arg_wrapper)
  argument = get_arg(arg)       
  convert_value(argument, arg)
end

#valid_arg?(arg) ⇒ Boolean

Returns:

  • (Boolean) 


25
26
27
 
# File 'lib/traversal/misc.rb', line 25

def valid_arg?(arg)
  arg && arg != {} 
end