CODEWITHSUNDEEP
rubymetaprogrammingparslet
zml
zml

Reputation: 637

Ruby: How to generate lines of code inside a program?

I am developing a parser in Ruby using the parslet library.

The language I am parsing has a lot of keywords that can be merged into a single parsing rule like this: 

rule(:keyword) {  
    str('keyword1')     |
    str('keyword2')     | 
    str('keyword2')     ... 

}

Is there a good way to generate this set of lines of code dynamically, by reading a text file with all the keywords? This would help me keep my parser clean and small, making it easier to add new keywords without modifying the code.

The pseudo-code of what I want to embed inside the rule(:keyword) would be somethings like this: 

File.read("keywords.txt").each { |k| write_line " str(\'#{k}\') "}

So far, the workaround I have found is to have a separate ruby program loading the parser code as:

keywords = ["keyword1", "keyword2","keyword3"]

subs = {:keyword_list => keywords .inject("") { |a,k| a << "str('#{k}') | \n"} }

eval( File.read("parser.rb") % subs)

where the parser code has the following lines:

rule(:keywords){ 
   %{keyword_list} 
 }

Is there a more elegant way to achieve this?

Upvotes: 1

Views: 167

Answers (2)

Ajedi32
Ajedi32

Reputation: 48368

In this case, you don't really need to "generate lines of code". As @Uri tried to explain in his answer, there's nothing special about the contents of that rule method; it's just plain Ruby code. Because of this, anything you can do in Ruby you can do inside that rule method as well, including read files, dynamically call methods, and call methods on objects.

Let me break down your existing code, so I can better explain how a dynamic solution to the same problem would work:

rule(:keyword) {
  # Stuff here
}

This code right here calls a rule method and passes it :keyword and a block of code. At some point, parslet will call that block and check its return value. Parslet might choose to call the block using instance_exec, which can change the context the block is being executed in to make methods not available outside the block (like str, perhaps) available inside it.

str('keyword1')

Here, inside the context of the rule block, you are calling a method named str with the string "keyword1", and getting the result. Nothing special here, this is just a normal method call.

str('keyword1') | str('keyword2')

Here, the | operator is actually just a method being called on whatever str('keyword1') is returning. This code is equivalent to str('keyword1').send(:'|', str('keyword2')).

str('keyword1') |
str('keyword2') | 
str('keyword2')

Same as before, except this time we're calling | on whatever str('keyword1').send(:'|', str('keyword2')) returned. The result of this method call is returned to the rule method when it calls the block.

So now that you know how all this works, you can perform exactly the same operations (calling str with each keyword, and using the | method to "add up" the results) dynamically, based on the contents of a file perhaps:

rule(:keyword) {  
  File.readlines("keywords.txt").map(&:chomp).map { |k| str(k) }.inject(:|)
}

Breakdown:

rule(:keyword) { # Call the rule method with the `:keyword` argument, and pass
                 # it this block of code.

  File.readlines("keywords.txt"). # Get an array of strings containing all the
                                  # keywords

  map(&:chomp). # Remove surrounding whitespace from each keyword in the array,
                # by calling `chomp` on them. (The strings returned by
                # `File.readlines` include the newline character at the end of
                # each string.)

  map { |k| str(k) }. # Convert each keyword in the array into whatever is
                      # returned by calling `str` with that keyword.

  inject(:|) # Reduce the returned objects to a single one using the `|`
              # method on each object. (Equivalent to obj1 | obj2 | obj3...)
}

And that's it! See? No need to generate any lines of code, just do what the real code is doing, but do it dynamically!

Upvotes: 1

Uri Agassi
Uri Agassi

Reputation: 37409

You can try something like this:

rule(:keyword) {  
  File.readlines("keywords.txt").map { |k| str(k.chomp) }.inject(&:|)
}

Upvotes: 3

Related Questions