Sending params to a partial when using Phlex with Hanami 2

[choallin]

I'm using Phlex with a new Hanami 2 app. Hanami has a quite great DI system. This system gives me an instance of my dependencies when I load them into my classes.
Since I'm getting an already instantiated object I can't pass args to the object without doing something weird.
I'm rendering my partials with the help of the render method. To pass the arguments down to my object I created a monkey patch that uses the already existing kwargs parameter of the render method and passes this to the components call method.

def render(renderable, *args, **kwargs, &block)
	case renderable
	when Phlex::HTML
		renderable.call(@_target, view_context: @_view_context, parent: self, **kwargs, &block) # HERE
	when Class
		if renderable < Phlex::HTML
			renderable.call(@_target, view_context: @_view_context, parent: self, **kwargs, &block) # AND HERE
		end
	else
		raise ArgumentError, "You can't render a #{renderable}."
	end

	nil
end

Is there a interest to merge this into Phlex? If not, could you please provide another way of passing arguments to my objects beside instantiation.

[joeldrapper]

How would you pick up the new arguments on call? Would you override that in view that's being rendered?

I haven't benchmarked this, but I’m cautious that picking up *args and **kwargs splats is slow and will allocate a new Array and Hash each time, even if no additional arguments or keyword arguments are provided.

Do you have an example of how you would use this feature? I can’t see how it would be better than just passing these arguments to the initialiser.

[choallin]

Right now I've overwritten the call method in my base view class. Here is the method:

def call(buffer = +"", view_context: nil, parent: nil, params: {}, &block)
      params.keys.each do |key|
        instance_variable_set("@#{key}".to_sym, params[key])
      end
      super(buffer, view_context: view_context, parent: parent, &block)
    end

Here is an example of why this feature is needed for me - this is a Hanami 2 action (endpoint):

module Foci
  module Actions
    module Focus
      class Form < Foci::Action
        include Deps[
          "view_helpers.new_resource_card",
          lang_repo: "base.repos.language",
          layout: "views.layout.foci"
        ]

        def handle(request, response)
          # Do something with the parameters ...

         # HERE: the `new_resource_card` is an instantiated object which inherits from my base view class which inherits from Phlex::View
          # Since it is already created from the DI system I can't put in some params during creation but only when I'm invoking the `call` method.
          # Therefore, I'm sending the arguments the view needs to render itself now. 
          response.body = new_resource_card.(params: {params: params, errors: errors, resource: focus, layout: layout, header: "New Focus"})
        end
      end
    end
  end
end

When we can send arguments with the call method as well this has the advantage that Ruby doesn't have to create a new view object every time. I have a view small "partials" that have a few arguments but the object itself is only created once from the DI system.
I haven't benchmarked this yet either, so I can't say anything about the real performance loss/gain...

[joeldrapper]

I’m not keen on this idea for a few reasons:

1. I expect setting instance variables like this will be very slow in comparison to what we do now.
2. By taking the arguments in #call, you no longer have the ability to provide a callable instance that already knows what its arguments are — this is useful or other patterns.
3. Using the same instance multiple times risks old instance variables leaking from one render to another.

@marcoroth just contributed a change #429 that makes view classes themselves callable.

def self.call(...) = new(...).call

I think is a good compromise. It exposes a callable interface while maintaining safety between renders.

[wuarmin]

@choallin You could register classes, instead of instances via dry-system.
https://github.com/dry-rb/dry-system/blob/5dfe7ae1a5ab90732a671fb815cf37399d8bc986/CHANGELOG.md?plain=1#L170