Module: RMTools::CodeReader::Defaults

Defined in:
lib/rmtools/dev/code_reader.rb

Constant Summary collapse

Leftop = 
leftop = '\[{(<=>~+\-*,;^&\|'
Ender = 
'\s*\)? *(?:end\b|[\n;})\]])'
StringParseRE = 
/#{heredoc}|#{simple}|[{}]|[^\w#{rightop}'"`\/\\]\?\\?\S/m
HeredocParseRE = 
/\n|#{heredoc}|#{simple}/m
ArgumentsParseRE = 
/#{simple
}|(\d[\d.]+|:[@$_a-z]\w*|[@$]\w+) *#{
}|([@$_a-z][:.\w!?]+)([(`"' ] *|:['"]?)?#{
}| *( [:?]\s|=[>~]|[<!>]=|[+\-\|*%,])\s*#{
}|[{}()\[\]\n;,\|]| end\b/m
StringRE = 
/(^['"`]$)|^#{percent}$/
RERE = 
%r{(?:^|[#{leftop}\w!\s/])\s*(/)}
HeredocRE = 
heredoc_handle.to_re
Symbol = 
/^:#{name}$/
Attrs = 
/\s(c)?(?:attr_(reader|writer|accessor))[( ] *((?::\w+ *,\s*)*:\w+)#{Ender}/
Include = 
/\s(include|extend)[( ] *#{mname}/
AliasMethod = 
/\salias_method :#{name} *,\s*:#{name}/
Beginners = 
/(([#{leftop}\n]?\s*)(if|unless|while|until))#{
}|(.)?(?:(do|for)|begin|case)/
EOF = 
/($0\s*==\s*__FILE__\s*|__FILE__\s*==\s*\$0\s*)?\n/
BlockOpen = 
/(?:^\{\s*\||.\{)$/
Ord = 
/^\W\?\\?\S$/
MainParseRE = 
/#{simple
}|#{call_}|[{}]#{
}|(^|\n)=begin\b#{
}|^\s*[;\(]? *(#{mod_def}|#{method_def})#{
}|:#{name
}|[^\w#{rightop}'"`\/\\]\?\\?\S#{
}|#{heredoc
}|(^|[#{leftop}\n])\s*((if|unless)\b|#{
                                            }[;\(]? *#{class_def})#{
}|(^|[\n;])\s*(while|until)\b#{
}|(^|[#{leftop}\s?])(do|case|begin|for)\b#{
}|\s(c)?(?:attr_(reader|writer|accessor))[( ] *((?::\w+ *,\s*)*:\w+)#{Ender
}|\salias_method +:#{name} *,\s*:#{name
}|\s(include|extend)[( ] *#{mname
}|(^|[;\s])(#{alias_def}|end|__END__)\b/m
ModDef = 
mod_def.to_re
ClassDef = 
class_def.to_re
MethodDef = 
method_def.to_re
AliasDef = 
alias_def.to_re

Instance Method Summary collapse

Instance Method Details

#Alias(s, m) ⇒ Object 



134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
 
# File 'lib/rmtools/dev/code_reader.rb', line 134

def Alias(s, m)
  debug(s)       
  _stack = clean_stack
  case _stack.any? && _stack[-1][0]
    when false, :def, :block
        return
    when :singleton
        prefix = _stack[-1][1]
        new, old = '.'+m[1], '.'+m[2]
    else
        prefix = _stack.lasts*'::'
        new, old = '#'+m[1], '#'+m[2]
  end
  @MethodCache[prefix][new] = @MethodCache[prefix][old] || "def #{new}(*args)\n  #{old}(*args)\nend"
end

#Class(s, m) ⇒ Object 



78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/rmtools/dev/code_reader.rb', line 78

def Class(s, m)       
  debug(s)       
  _stack = clean_stack
  if _stack[-1] == [:block]
      stack << [:beginner]
  elsif m[1]
      if m[2] =~ /^[@$]/
          stack << [:beginner]
      elsif _stack.any? and _stack[-1][0] == :def
          stack << [:beginner]
      else
          slf = _stack.lasts*'::'
          name = m[2].sub 'self.', ''
          name.sub! 'self', slf
          name = fix_module_name slf, name
          stack << [:singleton, name]
      end
  else
      new = clean_stack.lasts*'::'
      stack << [:class, m[2]]
      name = fix_module_name new, m[3] if m[3]
      new << '::' if new.b
      new << m[2]
      @MethodCache[new] ||= {}
      inherit! new, name if m[3]
  end
end

#debug(s) ⇒ Object 



72
73
74
75
76
 
# File 'lib/rmtools/dev/code_reader.rb', line 72

def debug(s)
  $log.debug(:caller=>1) {"#{s.string[0, s.pos].count("\n")+1}:#{s.head.size + s.matched_size - ((s.head+s.matched).reverse.index("\n") || 0)}"}
  $log.debug(@stack, :caller=>1)
  $log.debug(:caller=>1) {Painter.g(s.head+s.matched)}
end

#Method(s, m) ⇒ Object 



112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
 
# File 'lib/rmtools/dev/code_reader.rb', line 112

def Method(s, m)
  debug(s)
  _stack = clean_stack(true)
  if _stack[-1] == [:block]
    stack << [:beginner]
  else
    start = s.pos - s.matched[/[^\n]+$/].size
    name = m[1].sub(/::([^:.]+)$/, '.\1')
    name.sub!(/#{_stack.last[1]}\./, 'self.') if _stack.any?
    if name[/^self\.(.+)/]
      stack << [:def, "#{_stack.lasts*'::'}.#$1", start]
    elsif name['.'] and name =~ /^[A-Z]/
      mod, name = name/'.'
      fix_module_name(_stack.lasts*'::', mod) >> '.' >> name
      stack << [:def, name, start]
    else
      prefix = (_stack.any? && _stack[-1][0] == :singleton) ? _stack[-1][1]+'.' : _stack.lasts*'::'+'#'
      stack << [:def, prefix+name, start]
    end
  end
end

#Module(s, m) ⇒ Object 



106
107
108
109
110
 
# File 'lib/rmtools/dev/code_reader.rb', line 106

def Module(s, m)
  debug(s)       
  stack << [:mod, m[1]]
  @MethodCache[clean_stack.lasts*'::'] = {}
end