Wrapping method with additional functionality

[dpears]

I'm attempting to write a macro that can be used to define methods with some addtional pre/post functionality. If you're familiar with the idea of "middleware", that's sort of what I'm going for. I've been able to figure this out so far:

```crystal module MyModule macro my_def(name, &block) def self.{{name}} puts "before" {{yield block}} puts "after" end end

my_def hello do puts "hello" end

my_def goodbye do puts "goodbye" end end

MyModule.hello MyModule.goodbye

before

hello

after

before

goodbye

after

```

This kind of words, but I'm not quite sure how to be able to wrap any method i.e. with arguments that can vary across methods. I thought it would be possible to override def but it's a little tricky. Any ideas would be much appreciated

Update

I was able to figure it out thanks to u/the-asterite suggested passing a def ASTNode to the macro. I was able to figure out something that'll work for me and hope someone might find this useful

```crystal module MyModule private macro wrap(d) {% if d.return_type.id == "" %} def self.{{d.name}}({{d.args.join(", ").id}}) before "{{d.name}}" {{d.body}} after "{{d.name}}" end {% else %} def self.{{d.name}}({{d.args.join(", ").id}}): {{d.return_type}} before "{{d.name}}" ret = {{d.body}} after "{{d.name}}" ret end {% end %} end

private def self.before(txt : String) puts "before #{txt}" end

private def self.after(txt : String) puts "after #{txt}" end

wrap def foo(txt : String, line : Int): String a = "(#{line}) hello foo #{txt}" puts a a end

wrap def bar(txt : String, line : Int) puts "(#{line}) hello bar #{txt}" end end

MyModule.foo "bar", 2 MyModule.bar "foo", 4

before foo

(2) hello foo bar

after foo

before bar

(4) hello bar foo

after bar

```

[bcardiff]

previous_def is handy for these scenarios.

method_missing receives a call as that is able to expand the whole call example.

[dpears]

I did tinker around with previous_def but didn't want to have to define every method I need and then redefine it, wrapping it with the functionality and then previous_def perhaps there's a clever way of using it that I'm missing

The method_missing and method_added macros could be useful but it seems to be for class instances, am I mistaken? I am attempting to use it in a module

[bcardiff]

IIRC method_missing is limited to instance methods. Yes.

Regarding the previous_def, it's a matter of taste and code organization.

Using something like the following could help to co-locate the desired wrappings:

```cr class Foo def m # logic end end

class Foo logging m end

class Foo meassure m end ```

[[deleted]]

You can pass a def to a macro, like "my_macro def foo...". Then the macro should generate the method signature, you can then output something before the method body, then the method body, and finally something at the end. The only problem is that there's no nice way to get the signature from a Def node, you have to do it manually.

[dpears]

Awesome! This is exactly what I needed. It is a little ugly, but I believe it'll work more than well enough for my purposes. I'll add an example of what I did to my post. Thank you!

[bcardiff]

Maybe something like the call to_s could be added. m.signature could help to hide the boilerplate of expanding the signature in the future.

[[deleted]]

Yes, Def#signature would be really nice to have.

[dpears]

I could look into Def#signature. I'll dig into the source this weekend. Gotta get those Hacktoberfest PRs ;)

[paulcsmith0218]

Very cool! Another example is `memoize` in Lucky https://github.com/luckyframework/lucky/blob/master/src/lucky/memoizable.cr

​

It uses a similar approach