Class: Ripper (Ruby 2.2.4)
Description: Class : Ripper - Ruby 2.2.4

- Home
- Core 2.2.4
- Std-lib 2.2.4
- Downloads

Support for the Ruby 2.2 series has ended. See here for reference.

### Home Classes Methods

### In Files

- ripper/lib/ripper.rb
- ripper/lib/ripper/core.rb
- ripper/lib/ripper/filter.rb
- ripper/lib/ripper/lexer.rb
- ripper/lib/ripper/sexp.rb

### Parent

Object

### Namespace

- CLASS Ripper::Filter

### Methods

- ::lex
- ::parse
- ::sexp
- ::sexp_raw
- ::slice
- ::tokenize

### Class/Module Index

Quicksearch

- Object
- Ripper
- Ripper::Filter

No matching classes.

# Ripper

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,
              [[:string_literal,
                [:string_content,
                 [:@tstring_content, "Hello, ", [1, 18]],
                 [:string_embexpr, [[:var_ref, [:@ident, "world", [1, 27]]]]],
                 [:@tstring_content, "!", [1, 33]]]]],
              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 `:@ident`. 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 `:string_literal` expression.

Within our `:string_literal` you'll notice two `@tstring_content`, this is the literal part for `Hello,` and `!`. Between the two `@tstring_content` statements is a `:string_embexpr`, where embexpr is an embedded expression. Our expression consists of a local variable, or `var_ref`, with the identifier (`@ident`) of `world`.

## Resources¶ ↑

- Ruby Inside

## 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

### Constants

EVENTS

  This array contains name of all ripper events.

PARSER_EVENTS

  This array contains name of parser events.

SCANNER_EVENTS

  This array contains name of scanner events.

### Public Class Methods

lex(src, filename = '-', lineno = 1) click to toggle source

Tokenizes the Ruby program and returns an array of an array, which is formatted like `[[lineno, column], type, token]`.

    require 'ripper'
    require 'pp'

    pp Ripper.lex("def m(a) nil end")
      #=> [[[1,  0], :on_kw,     "def"],
           [[1,  3], :on_sp,     " "  ],
           [[1,  4], :on_ident,  "m"  ],
           [[1,  5], :on_lparen, "("  ],
           [[1,  6], :on_ident,  "a"  ],
           [[1,  7], :on_rparen, ")"  ],
           [[1,  8], :on_sp,     " "  ],
           [[1,  9], :on_kw,     "nil"],
           [[1, 12], :on_sp,     " "  ],
           [[1, 13], :on_kw,     "end"]]

                   # File ripper/lib/ripper/lexer.rb, line 42
    def Ripper.lex(src, filename = '-', lineno = 1)
      Lexer.new(src, filename, lineno).lex
    end

parse(src, filename = '(ripper)', lineno = 1) click to toggle source

Parses the given Ruby program read from `src`. `src` must be a String or an IO or a object with a gets method.

                   # File ripper/lib/ripper/core.rb, line 17
    def Ripper.parse(src, filename = '(ripper)', lineno = 1)
      new(src, filename, lineno).parse
    end

sexp(src, filename = '-', lineno = 1) click to toggle source

EXPERIMENTAL

  Parses `src` and create S-exp tree. Returns more readable tree rather than ::sexp_raw. This method is mainly for developer use.

      require 'ripper'
      require 'pp'

      pp Ripper.sexp("def m(a) nil end")
        #=> [:program,
             [[:def,
              [:@ident, "m", [1, 4]],
              [:paren, [:params, [[:@ident, "a", [1, 6]]], nil, nil, nil, nil]],
              [:bodystmt, [[:var_ref, [:@kw, "nil", [1, 9]]]], nil, nil, nil]]]]

                   # File ripper/lib/ripper/sexp.rb, line 30
    def Ripper.sexp(src, filename = '-', lineno = 1)
      builder = SexpBuilderPP.new(src, filename, lineno)
      sexp = builder.parse
      sexp unless builder.error?
    end

sexp_raw(src, filename = '-', lineno = 1) click to toggle source

EXPERIMENTAL

  Parses `src` and create S-exp tree. This method is mainly for developer use.

      require 'ripper'
      require 'pp'

      pp Ripper.sexp_raw("def m(a) nil end")
        #=> [:program,
             [:stmts_add,
              [:stmts_new],
              [:def,
               [:@ident, "m", [1, 4]],
               [:paren, [:params, [[:@ident, "a", [1, 6]]], nil, nil, nil]],
               [:bodystmt,
                [:stmts_add, [:stmts_new], [:var_ref, [:@kw, "nil", [1, 9]]]],
                nil,
                nil,
                nil]]]]

                   # File ripper/lib/ripper/sexp.rb, line 56
    def Ripper.sexp_raw(src, filename = '-', lineno = 1)
      builder = SexpBuilder.new(src, filename, lineno)
      sexp = builder.parse
      sexp unless builder.error?
    end

slice(src, pattern, n = 0) click to toggle source

EXPERIMENTAL

  Parses `src` and return a string which was matched to `pattern`. `pattern` should be described as Regexp.

      require 'ripper'

      p Ripper.slice('def m(a) nil end', 'ident')                   #=> "m"
      p Ripper.slice('def m(a) nil end', '[ident lparen rparen]+')  #=> "m(a)"
      p Ripper.slice("<<EOS\nstring\nEOS",
                     'heredoc_beg nl $(tstring_content*) heredoc_end', 1)
          #=> "string\n"

                   # File ripper/lib/ripper/lexer.rb, line 84
    def Ripper.slice(src, pattern, n = 0)
      if m = token_match(src, pattern)
      then m.string(n)
      else nil
      end
    end

tokenize(src, filename = '-', lineno = 1) click to toggle source

Tokenizes the Ruby program and returns an array of strings.

    p Ripper.tokenize("def m(a) nil end")
       # => ["def", " ", "m", "(", "a", ")", " ", "nil", " ", "end"]

                   # File ripper/lib/ripper/lexer.rb, line 20
    def Ripper.tokenize(src, filename = '-', lineno = 1)
      Lexer.new(src, filename, lineno).tokenize
    end