# frozen_string_literal: true require "forwardable" require "string_doc/meta_node" require "pakyow/support/core_refinements/array/ensurable" require "pakyow/support/core_refinements/string/normalization" require "pakyow/support/class_state" require "pakyow/support/safe_string" require "pakyow/support/string_builder" require "pakyow/presenter/presentable" require "pakyow/presenter/presenters/endpoint" module Pakyow module Presenter # Presents a view object with dynamic state in context of an app instance. In normal usage you # will be interacting with presenters rather than the {View} directly. # class Presenter extend Support::Makeable extend Support::ClassState class_state :__attached_renders, default: [], inheritable: true class_state :__global_options, default: {}, inheritable: true class_state :__presentation_logic, default: {}, inheritable: true class_state :__versioning_logic, default: {}, inheritable: true using Support::Refinements::Array::Ensurable include Support::SafeStringHelpers include Presentable # The view object being presented. # attr_reader :view # The logger object. # attr_reader :logger # Values to be presented. # attr_reader :presentables # The app object. # # @api private attr_reader :app def initialize(view, app:, presentables: {}) @app, @view, @presentables = app, view, presentables @logger = Pakyow.logger @called = false end # Returns a presenter for a view binding. # # @see View#find def find(*names) result = if found_view = @view.find(*names) presenter_for(found_view) else nil end if result && block_given? yield result end result end # Returns an array of presenters, one for each view binding. # # @see View#find_all # @api private def find_all(*names) @view.find_all(*names).map { |view| presenter_for(view) } end # Returns the named form from the view being presented. # def form(name) if found_form = @view.form(name) presenter_for(found_form) else nil end end # Returns all forms. # # @api private def forms @view.forms.map { |form| presenter_for(form) } end # Returns the component matching +name+. # def component(name) if found_component = @view.component(name) presenter_for(found_component) else nil end end # Returns all components. # # @api private def components(renderable: false) @view.components(renderable: renderable).map { |component| presenter_for(component) } end # Returns the title value from the view being presented. # def title @view.title&.text end # Sets the title value on the view. # def title=(value) unless @view.title if head_view = @view.head title_view = View.new("") head_view.append(title_view) end end @view.title&.html = strip_tags(value) end # Uses the view matching +version+, removing all other versions. # def use(version) @view.use(version) self end # Returns a presenter for the view matching +version+. # def versioned(version) presenter_for(@view.versioned(version)) end # Yields +self+. # def with tap do yield self end end # Transforms the view to match +data+. # # @see View#transform # def transform(data, yield_binder = false) tap do data = Array.ensure(data).reject(&:nil?) if data.respond_to?(:empty?) && data.empty? if @view.is_a?(VersionedView) && @view.version?(:empty) @view.use(:empty); @view.object.set_label(:bound, true) else remove end else template = @view.soft_copy insertable = @view current = @view data.each do |object| binder = binder_or_data(object) current.transform(binder) if block_given? yield presenter_for(current), yield_binder ? binder : object end unless current.equal?(@view) insertable.after(current) insertable = current end current = template.soft_copy end end end end # Binds +data+ to the view, using the appropriate binder if available. # def bind(data) tap do data = binder_or_data(data) if data.is_a?(Binder) bind_binder_to_view(data, @view) else @view.bind(data) end set_binding_info(data) set_endpoint_params(data) end end # Transforms the view to match +data+, then binds, using the appropriate binder if available. # # @see View#present # def present(data) tap do transform(data, true) do |presenter, binder| if block_given? yield presenter, binder.object end unless presenter.view.object.labeled?(:bound) || self.class.__presentation_logic.empty? self.class.__presentation_logic[presenter.view.channeled_binding_name].to_a.each do |presentation_logic| presenter.instance_exec(binder.object, &presentation_logic[:block]) end end if presenter.view.is_a?(VersionedView) unless presenter.view.used? || self.class.__versioning_logic.empty? # Use global versions. # presenter.view.names.each do |version| self.class.__versioning_logic[version]&.each do |logic| if presenter.instance_exec(binder.object, &logic[:block]) presenter.use(version); break end end end end # If we still haven't used a version, use one implicitly. # unless presenter.view.used? presenter.use_implicit_version end # Implicitly use binding props. # presenter.view.binding_props.map { |binding_prop| binding_prop.label(:binding) }.uniq.each do |binding_prop_name| if found = presenter.view.find(binding_prop_name) presenter_for(found).use_implicit_version unless found.used? end end end presenter.bind(binder) presenter.view.binding_scopes.uniq { |binding_scope| binding_scope.label(:binding) }.each do |binding_node| plural_binding_node_name = Support.inflector.pluralize(binding_node.label(:binding)).to_sym if nested_view = presenter.find(binding_node.label(:binding)) if binder.object.include?(binding_node.label(:binding)) nested_view.present(binder.object[binding_node.label(:binding)]) elsif binder.object.include?(plural_binding_node_name) nested_view.present(binder.object[plural_binding_node_name]) else nested_view.remove end end end end end end # @see View#append # def append(view) tap do @view.append(view) end end # @see View#prepend # def prepend(view) tap do @view.prepend(view) end end # @see View#after # def after(view) tap do @view.after(view) end end # @see View#before # def before(view) tap do @view.before(view) end end # @see View#replace # def replace(view) tap do @view.replace(view) end end # @see View#remove # def remove tap do @view.remove end end # @see View#clear # def clear tap do @view.clear end end # Returns true if +self+ equals +other+. # def ==(other) other.is_a?(self.class) && @view == other.view end def method_missing(name, *args, &block) if @view.respond_to?(name) value = @view.public_send(name, *args, &block) if value.equal?(@view) self else value end else super end end def respond_to_missing?(name, include_private = false) @view.respond_to?(name, include_private) || super end # @api private def wrap_data_in_binder(data) if data.is_a?(Binder) data else binder_for_current_scope(data) end end def to_html(output = String.new) @view.object.to_html(output, context: self) end def to_s @view.to_s end def presenter_for(view, type: nil) if view.nil? nil else instance = self.class.new( view, app: @app, presentables: @presentables ) type ||= view.object.label(:presenter_type) type ? type.new(instance) : instance end end # @api private def endpoint(name) found = [] object.each_significant_node(:endpoint) do |endpoint_node| if endpoint_node.label(:endpoint) == name.to_sym found << endpoint_node end end if found.any? if found[0].is_a?(StringDoc::MetaNode) presenter_for(View.from_object(found[0])) else presenter_for(View.from_object(StringDoc::MetaNode.new(found))) end else nil end end # @api private def endpoint_action endpoint_action_node = object.find_first_significant_node( :endpoint_action ) || object presenter_for(View.from_object(endpoint_action_node)) end # @api private def use_implicit_version case object when StringDoc::MetaNode if object.internal_nodes.all? { |node| node.labeled?(:version) && node.label(:version) != VersionedView::DEFAULT_VERSION } use(object.internal_nodes.first.label(:version)) else use(:default) end else if versions.all? { |view| view.object.labeled?(:version) && view.object.label(:version) != VersionedView::DEFAULT_VERSION } use(versions.first.object.label(:version)) else use(:default) end end end private def binder_for_current_scope(data) context = if plug = @view.label(:plug) @app.plug(plug[:name], plug[:instance]) else @app end binder = context.state(:binder).find { |possible_binder| possible_binder.__object_name.name == @view.label(:binding) } unless binder binder = @app.isolated(:Binder) context = @app end binder.new(data, app: context) end def bind_binder_to_view(binder, view) view.each_binding_prop do |binding| value = binder.__value(binding.label(:binding)) if value.is_a?(BindingParts) && binding_view = view.find(binding.label(:binding)) value.accept(*binding_view.label(:include).to_s.split(" ")) value.reject(*binding_view.label(:exclude).to_s.split(" ")) value.non_content_values(binding_view).each_pair do |key, value_part| binding_view.attrs[key] = value_part end binding_view.object.set_label(:bound, true) end end binder.binding! view.bind(binder) end def binder_or_data(data) if data.nil? || data.is_a?(Array) || data.is_a?(Binder) data else wrap_data_in_binder(data) end end def set_binding_info(data) object = if data.is_a?(Binder) data.object else data end if object && @view.object.labeled?(:binding) binding_info = { @view.object.label(:binding) => object[:id] } set_binding_info_for_node(@view.object, binding_info) @view.object.each_significant_node(:binding, descend: true) do |binding_node| set_binding_info_for_node(binding_node, binding_info) end @view.object.each_significant_node(:form, descend: true) do |form_node| set_binding_info_for_node(form_node, binding_info) end end end def set_binding_info_for_node(node, info) unless node.labeled?(:binding_info) node.set_label(:binding_info, {}) end node.label(:binding_info).merge!(info) end def set_endpoint_params(data) object = if data.is_a?(Binder) data.object else data end if @view.object.labeled?(:endpoint) set_endpoint_params_for_node(@view.object, object) end @view.object.each_significant_node(:endpoint, descend: true) do |endpoint_node| set_endpoint_params_for_node(endpoint_node, object) end end def set_endpoint_params_for_node(node, object) endpoint_object = node.label(:endpoint_object) endpoint_params = node.label(:endpoint_params) if endpoint_object && endpoint_params endpoint_object.params.each do |param| if param.to_s.start_with?("#{@view.label(:binding)}_") key = param.to_s.split("_", 2)[1].to_sym if object.include?(key) endpoint_params[param] = object[key]; next end end if object.include?(param) endpoint_params[param] = object[param] end end end end def present?(key, object) !internal_presentable?(key) && (object_presents?(object, key) || plug_presents?(object, key)) end def internal_presentable?(key) key.to_s.start_with?("__") end def object_presents?(object, key) key == plural_channeled_binding_name || key == singular_channeled_binding_name end def plug_presents?(object, key) key = key.to_s object.labeled?(:plug) && key.start_with?(object.label(:plug)[:key]) && # FIXME: Find a more performant way to do this # object_presents?(object, key.split("#{object.label(:plug)[:key]}.", 2)[1].to_sym) end class << self using Support::Refinements::String::Normalization attr_reader :path # @api private def make(path, **kwargs, &block) path = String.normalize_path(path) super(path, path: path, **kwargs, &block) end # Defines a render to attach to a node. # def render(*binding_path, node: nil, priority: :default, &block) if node && !node.is_a?(Proc) raise ArgumentError, "Expected `#{node.class}' to be a proc" end if binding_path.empty? && node.nil? node = -> { self } end @__attached_renders << { binding_path: binding_path, node: node, priority: priority, block: block } end # Defines a presentation block called when +binding_name+ is presented. If +channel+ is # provided, the block will only be called for that channel. # def present(binding_name, &block) (@__presentation_logic[binding_name.to_sym] ||= []) << { block: block } end # Defines a versioning block called when +version_name+ is presented. # def version(version_name, &block) (@__versioning_logic[version_name] ||= []) << { block: block } end # Attaches renders to a view's doc. # def attach(view) views_with_renders = {} renders = @__attached_renders.dup # Automatically present exposed values for this view. Doing this dynamically lets us # optimize. The alternative is to attach a render to the entire view, which is less # performant because the entire structure must be duped. # view.binding_scopes.map { |binding_node| { binding_path: [ binding_node.label(:channeled_binding) ] } }.uniq.each do |binding_render| renders << { binding_path: binding_render[:binding_path], priority: :low, block: Proc.new { if object.labeled?(:binding) && !object.labeled?(:bound) presentables.each do |key, value| if present?(key, object) present(value); break end end end } } end # Setup binding endpoints in a similar way to automatic presentation above. # Presenters::Endpoint.attach_to_node(view.object, renders) renders.each do |render| return_value = if node = render[:node] view.instance_exec(&node) else view.find(*render[:binding_path]) end case return_value when Array return_value.each do |each_value| relate_value_to_render(each_value, render, views_with_renders) end when View, VersionedView relate_value_to_render(return_value, render, views_with_renders) end end views_with_renders.values.each do |view_with_renders, renders_for_view| attach_to_node = view_with_renders.object if attach_to_node.is_a?(StringDoc) attach_to_node = attach_to_node.find_first_significant_node(:html) end if attach_to_node renders_for_view.each do |render| attach_to_node.transform priority: render[:priority], &render_proc(view_with_renders, render, &render[:block]) end end end end # Defines options attached to a form binding. # def options_for(form_binding, field_binding, options = nil, &block) form_binding = form_binding.to_sym field_binding = field_binding.to_sym @__global_options[form_binding] ||= {} @__global_options[form_binding][field_binding] = { options: options, block: block } end private def render_proc(_view, _render = nil, &block) Proc.new do |node, context, string| case node when StringDoc::MetaNode if node.nodes.any? returning = node presenter = context.presenter_for( VersionedView.new(View.from_object(node)) ) else next node end when StringDoc::Node returning = StringDoc.empty returning.append(node) presenter = context.presenter_for( View.from_object(node) ) end presenter.instance_exec(node, context, string, &block); returning rescue => error if presenter.app.config.presenter.features.streaming Pakyow.logger.houston(error) presenter.clear presenter.attributes[:class] << :"render-failed" presenter.view.object.set_label(:failed, true) presenter.object else raise error end end end def relate_value_to_render(value, render, state) final_value = case value when View, VersionedView value else View.new(value.to_s) end # Group the renders by node and view type. # (state["#{final_value.object.object_id}::#{final_value.class}"] ||= [final_value, []])[1] << render end end end end end