Project

General

Profile

Download (11.2 KB)

Bug #6929 » 0001-Documentation-for-Ripper.patch

zzak (zzak _), 08/26/2012 02:34 AM

View differences:

ext/ripper/extconf.rb
require 'mkmf'
require 'rbconfig'
def main
def main # :nodoc:
unless find_executable('bison')
unless File.exist?('ripper.c') or File.exist?("#{$srcdir}/ripper.c")
raise 'missing bison; abort'
ext/ripper/lib/ripper.rb
require 'ripper/lexer'
require 'ripper/filter'
require 'ripper/sexp'
# Ripper is a Ruby script parser.
#
# You can get information from the parser with event-based style.
# Information such as abstract syntax trees or simple lexical analysis of the
# Ruby program.
#
# == Usage
#
# Ripper provides an easy interface for parsing your program into a symbolic
# expression tree (or S-expression).
#
# Understanding the output of the parser may come as a challenge, it's
# recommended you use PP to format the output for legibility.
#
# require 'ripper'
# require 'pp'
#
# pp Ripper.sexp('def hello(world); "Hello, #{world}!"; end')
# #=> [:program,
# [[:def,
# [:@ident, "hello", [1, 4]],
# [:paren,
# [:params, [[:@ident, "world", [1, 10]]], nil, nil, nil, nil, nil, nil]],
# [:bodystmt,
# [[:void_stmt],
# [:string_literal,
# [:string_content,
# [:@tstring_content, "Hello, ", [1, 19]],
# [:string_embexpr, [[:var_ref, [:@ident, "world", [1, 28]]]]],
# [:@tstring_content, "!", [1, 34]]]]],
# nil,
# nil,
# nil]]]]
#
# You can see in the example above, the expression starts with +:program+.
#
# From here, a method definition at +:def+, followed by the method's identifier
# <code>:@ident</code>. After the method's identifier comes the parentheses
# +:paren+ and the method parameters under +:params+.
#
# Next is the method body, starting at +:bodystmt+ (+stmt+ meaning statement),
# which contains the full definition of the method.
#
# In our case, we're simply returning a String, so next we have the
# +:void_stmt+ followed by a +:string_literal+.
#
# Within our +:string_literal+ you'll notice two <code>@tstring_content</code>,
# this is the literal part for <code>Hello, </code> and <code>!</code>. Between
# the two <code>@tstring_content</code> statements is a +:string_embexpr+,
# where _embexpr_ is an embedded expression. Our expression consists of a local
# variable, or +var_ref+, with the identifier (<code>@ident</code>) of +world+.
#
# == Resources
#
# * {Ruby Inside}[http://www.rubyinside.com/using-ripper-to-see-how-ruby-is-parsing-your-code-5270.html]
#
# == Requirements
#
# * ruby 1.9 (support CVS HEAD only)
# * bison 1.28 or later (Other yaccs do not work)
#
# == License
#
# Ruby License.
#
# Minero Aoki
# aamine@loveruby.net
# http://i.loveruby.net
class Ripper; end
ext/ripper/lib/ripper/core.rb
class Ripper
# Parses Ruby program read from _src_.
# _src_ must be a String or a IO or a object which has #gets method.
# Parses the given Ruby program read from +src+.
# +src+ must be a String or an IO or a object with a #gets method.
def Ripper.parse(src, filename = '(ripper)', lineno = 1)
new(src, filename, lineno).parse
end
......
end
# This method is called when weak warning is produced by the parser.
# _fmt_ and _args_ is printf style.
# +fmt+ and +args+ is printf style.
def warn(fmt, *args)
end
# This method is called when strong warning is produced by the parser.
# _fmt_ and _args_ is printf style.
# +fmt+ and +args+ is printf style.
def warning(fmt, *args)
end
ext/ripper/lib/ripper/filter.rb
class Ripper
# This class handles only scanner events,
# and they are dispatched in the `right' order (same with input).
# which are dispatched in the 'right' order (same with input).
class Filter
# Creates a new Ripper::Filter instance, passes parameters +src+,
# +filename+, and +lineno+ to Ripper::Lexer.new
#
# The lexer is for internal use only.
def initialize(src, filename = '-', lineno = 1)
@__lexer = Lexer.new(src, filename, lineno)
@__line = nil
......
@__col
end
# Starts parsing. _init_ is a data accumulator.
# It is passed to the next event handler (as of Enumerable#inject).
# Starts the parser.
# +init+ is a data accumulator and is passed to the next event handler (as
# of Enumerable#inject).
def parse(init = nil)
data = init
@__lexer.lex.each do |pos, event, tok|
......
private
# This method is called when some event handler have not defined.
# _event_ is :on_XXX, _token_ is scanned token, _data_ is a data
# accumulator. The return value of this method is passed to the
# next event handler (as of Enumerable#inject).
# This method is called when some event handler is undefined.
# +event+ is :on_XXX, +token+ is the scanned token, and +data+ is a data
# accumulator.
#
# The return value of this method is passed to the next event handler (as
# of Enumerable#inject).
def on_default(event, token, data)
data
end
ext/ripper/lib/ripper/lexer.rb
class Ripper
# Tokenizes Ruby program and returns an Array of String.
# Tokenizes the Ruby program and returns an Array of String.
def Ripper.tokenize(src, filename = '-', lineno = 1)
Lexer.new(src, filename, lineno).tokenize
end
# Tokenizes Ruby program and returns an Array of Array,
# which is formatted like [[lineno, column], type, token].
# Tokenizes the Ruby program and returns an Array of an Array,
# which is formatted like <code>[[lineno, column], type, token]</code>.
#
# require 'ripper'
# require 'pp'
......
class TokenPattern #:nodoc:
class Error < ::StandardError; end
class CompileError < Error; end
class MatchError < Error; end
class Error < ::StandardError # :nodoc:
end
class CompileError < Error # :nodoc:
end
class MatchError < Error # :nodoc:
end
class << self
alias compile new
......
MAP[tok] or raise CompileError, "unknown token: #{tok}"
end
class MatchData
class MatchData # :nodoc:
def initialize(tokens, match)
@tokens = tokens
@match = match
ext/ripper/lib/ripper/sexp.rb
# [EXPERIMENTAL]
# Parses +src+ and create S-exp tree.
# Returns more readable tree rather than Ripper.sexp_raw.
# This method is for mainly developer use.
# This method is mainly for developer use.
#
# require 'ripper'
# require 'pp'
......
# [EXPERIMENTAL]
# Parses +src+ and create S-exp tree.
# This method is for mainly developer use.
# This method is mainly for developer use.
#
# require 'ripper'
# require 'pp'
ext/ripper/tools/generate.rb
require 'optparse'
def main
def main # :nodoc:
mode = nil
ids1src = nil
ids2src = nil
......
end
end
def usage(msg)
def usage(msg) # :nodoc:
$stderr.puts msg
$stderr.puts @parser.help
exit false
end
def generate_eventids1(ids)
def generate_eventids1(ids) # :nodoc:
buf = ""
ids.each do |id, arity|
buf << %Q[static ID ripper_id_#{id};\n]
......
buf
end
def generate_eventids2_table(ids)
def generate_eventids2_table(ids) # :nodoc:
buf = ""
buf << %Q[static void\n]
buf << %Q[ripper_init_eventids2_table(VALUE self)\n]
......
buf
end
def read_ids1(path)
def read_ids1(path) # :nodoc:
strip_locations(read_ids1_with_locations(path))
end
def strip_locations(h)
def strip_locations(h) # :nodoc:
h.map {|event, list| [event, list.first[1]] }\
.sort_by {|event, arity| event.to_s }
end
def check_arity(h)
def check_arity(h) # :nodoc:
invalid = false
h.each do |event, list|
unless list.map {|line, arity| arity }.uniq.size == 1
......
abort if invalid
end
def read_ids1_with_locations(path)
def read_ids1_with_locations(path) # :nodoc:
h = {}
File.open(path) {|f|
f.each do |line|
......
h
end
def read_ids2(path)
def read_ids2(path) # :nodoc:
File.open(path) {|f|
return f.read.scan(/ripper_id_(\w+)/).flatten.uniq.sort
}
ext/ripper/tools/preproc.rb
require 'optparse'
def main
def main # :nodoc:
output = nil
parser = OptionParser.new
parser.banner = "Usage: #{File.basename($0)} [--output=PATH] <parse.y>"
......
end
end
def prelude(f, out)
def prelude(f, out) # :nodoc:
while line = f.gets
case line
when %r</\*%%%\*/>
......
end
end
def grammar(f, out)
def grammar(f, out) # :nodoc:
while line = f.gets
case line
when %r</\*%%%\*/>
......
end
end
def usercode(f, out)
def usercode(f, out) # :nodoc:
while line = f.gets
out << line
end
(1-1/2)