Scriptable RefactorErl interface

ris is similar to ri, with the following basic ideas:

• results are always returned via the function return value.
  
• no mandatory standard output.
  
• arguments very regular - semantic queries for almost everything.
  
• you can also input a semantic query via atoms instead of strings to ease escaping.
  
• operations are composable (i.e., continue one where another has left off) - queries and refactorings can go back and forth.
  
• you can perform a series of batch refactorings in a single step by selecting multiple entities at once.
  

Usage examples

Adding files

Added = ris:add_byname("mymods.erl").
ReAdded = ris:add('mods[name~"mymodu.*"]').

Dropping files

ris:drop('mods[name ~ "mymo.*"]').

Refactorings

RenamedVars = ris:rename("mods.fun.var[name=="Colour"]", "Color").

MovedFuns = ris:move("mods[name ~ "^referl_.*"].fun[exported==false]",
                     fun(F)->
                         ris:qstr([F,".mod.name"])++"_util"
                     end).

Moved = ris:move("mods[name==mod1].fun[name==fun1 and arity==3]", mod2).

NewFun = ris:extract("mods[name==module1]
                         .fun[name==f and arity==0]
                             .expr[last==false]",
                      mynewfun).

NewVar = ris:intvar("mods[name==module1]
                        .fun[name==f and arity==0]
                            .expr[index==1].esub[class/=pattern]",
                    "Varname").

NewRec = ris:intrec("mods[name==module1]
                        .fun[name==f and arity==0]
                            .expr[index==1].esub[class/=pattern]",
                     {newrec,[field1,field2]}).

NewFun = ris:reorder("mod[name==mod1].fun[name==fun1,arity==3]",
                     [3,2,1]).

NewFun = ris:tupfun("mod[name==mod1].fun[name==fun1,arity==3]",
                    {1,2}).

ris:generalize("mod[name==china].fun[name==sum].var[name=="A"]").

ris:eliminate("mod[name==china].fun[name==sum].var[name=="A"]").

ris:inline("mod[name==china].fun[name==sum]
               .expr[type/=pattern and index==1]").

Operators

The result of the queries can be combined with the following set operators:

• Intersection: The following example takes the intersection of the files included by the two modules.

ris:q({"mods[name==mod1].includes", intersect,
       "mods[name==mod2].includes"}).

• Union: similar to the above (use key 'union').
  
• Substraction: similar to the above (use key 'minus').
  
• Range: Ranges of expressions can be selected which denotes a list of continuous expressions between two syntactical siblings. An empty semantic query denotes the beginning or end of a block when used as the initial or final limit respectively. In this example, the expression range starts from the (first) match expression that contains "Var1" in the pattern side up to the end of the syntactical block.

NewFun = ris:extract({"mods[name=mod1]
                          .fun[name==f and arity==0]
                             .expr[type==match_expr]
                                 .esub[class==pattern and
                                       type==variable and
                                       .var[name=="Var1"]]",
                       range, ""}, mynewfun).

• Sequence: Queries can be sequenced to continue a query from where another has left off. This example first adds the module from file 'mymodule.erl'. The add call returns the entities loaded. A semantic query aggregate of a list works by executing the first query (or in this case, specifying a starting entity), and then running the next query in the chain (in this case getting the name of files included by the add call).

ris:q([ris:add_byname("mymodule.erl"),".includes.name"]).

• Another sequence example: The following example shows an example for composition. It first renames all functions whose name is 'duck' to 'quack'. It then appends the suffix '_quacker' to the name of all functions which call these quacks. The new name is automatically converted to an atom.

New = ris:rename('mods.fun[name==duck]',quack),
Callers = ris:q([New,".callers"]),
[ris:rename(Fun,atom_to_list(Name)++"_quacker") ||
 Fun <- Callers,
 Name <- ris:q([Fun,".name"])].
 New = ris:rename('mods.fun[name==duck]',quack),
 Callers = ris:q([New,".callers"]),
 ris:rename(Callers,
            fun(Fun)->
                ris:qstr([Fun,".name"]) ++ "_quacker"
            end).

Textual display

Use ris:show/1 to stringify entities. ris:show/2 does the same while accepting additional options already known for ri:q/3. Use the respective ris:print/1 and ris:print/2 functions for screen and file output.

ris:print(ris:q("mods.fun")).

The following gives the same result set, but written to the given file and annotated with line numbers. (Note that you could also manually write the output of ris:show/1 to a file.)

ris:print(ris:q("mods.fun"),
          [{out,"funs.txt"}, linenum]).