pakyow-presenter 0.11.3 → 1.0.0.rc1

data/lib/pakyow/presenter/rendering/actions/render_components.rb

@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+require "pakyow/presenter/composers/component"
+
+module Pakyow
+  module Presenter
+    module Actions
+      module RenderComponents
+        extend Support::Extension
+
+        apply_extension do
+          build do |view, app:, composer:, modes:|
+            unless Pakyow.env?(:prototype)
+              initial_path = case composer
+              when Composers::Component
+                composer.component_path
+              else
+                []
+              end
+
+              component_view = case composer
+              when Composers::Component
+                composer.class.follow_path(composer.component_path, view)
+              else
+                view
+              end
+
+              RenderComponents.initialize_renderable_components(
+                component_view, app: app, composer: composer, modes: modes, path: initial_path
+              )
+            end
+          end
+
+          expose do |connection|
+            # Prevent state from leaking from the component to the rest of the app.
+            #
+            component_connection = connection.dup
+
+            # Expose the component connection for performing from each component.
+            #
+            connection.set(:__component_connection, component_connection)
+          end
+        end
+
+        # @api private
+        def self.initialize_renderable_components(view, app:, composer:, modes:, path: [])
+          view.components.each_with_index do |component_view, i|
+            current_path = path.dup
+            current_path << i
+
+            # If view will be rendered from the app, look for the component on the app.
+            #
+            component_state = if app.is_a?(Plugin) && app.parent.view?(composer.view_path)
+              app.parent.state(:component)
+            else
+              app.state(:component)
+            end
+
+            components = component_view.object.label(:components).each_with_object([]) { |component_label, arr|
+              component_class = component_state.find { |component|
+                component.__object_name.name == component_label[:name]
+              }
+
+              if component_class
+                # Turn the component into a renderable component. Once an instance is attached on the
+                # backend, the component will not be traversed by renders from its parent instead being
+                # rendered by its own renderer instance.
+                #
+                # We don't want the same restriction for non-renderable components because a change to
+                # the view should not affect how things work on the backend.
+                #
+                component_label[:renderable] = true
+
+                arr << {
+                  class: component_class,
+                  config: component_label[:config]
+                }
+              end
+            }
+
+            if components.any?
+              # Since one or more attached components is renderable, we no longer want to descend.
+              #
+              component_view.object.set_label(:descend, false)
+
+              # Define the render function that calls the component and renders it at render time.
+              #
+              component_render = app.isolated(:Presenter).send(:render_proc, component_view) { |node, _context, string|
+                presentable_component_connection = presentables[:__component_connection]
+                component_connection = presentable_component_connection.dup
+
+                components.each do |component|
+                  presentables.each do |key, value|
+                    if key.to_s.start_with?("__")
+                      component_connection.set(key, value)
+                    end
+                  end
+
+                  # If the component was defined in an app but being called inside a plugin, set the app to the app instead of the plugin.
+                  #
+                  if component_connection.app.is_a?(Plugin) && component[:class].ancestors.include?(component_connection.app.parent.isolated(:Component))
+                    component_connection = component_connection.class.from_connection(component_connection, :@app => component_connection.app.parent)
+                  end
+
+                  component_instance = component[:class].new(
+                    connection: component_connection,
+                    config: component[:config]
+                  )
+
+                  # Call the component.
+                  #
+                  component_instance.perform
+                end
+
+                # Build a compound component presenter.
+                #
+                component_presenter = if components.length > 1
+                  RenderComponents.find_compound_presenter(
+                    app, components.map { |c| c[:class] }
+                  )
+                else
+                  components.first[:class].__presenter_class
+                end
+
+                # Setup the renderer for the component.
+                #
+                renderer = app.isolated(:Renderer).new(
+                  app: app,
+                  presentables: component_connection.values,
+                  presenter_class: component_presenter,
+                  composer: Composers::Component.new(
+                    composer.view_path, current_path, app: app, labels: node.labels
+                  ),
+                  modes: modes
+                )
+
+                # Render to the main buffer.
+                #
+                renderer.perform(string)
+
+                # Return nil so nothing else gets written.
+                #
+                nil
+              }
+
+              # Attach the above render function to the render node.
+              #
+              component_view.object.transform do |node, context, string|
+                component_render.call(node, context, string); nil
+              end
+            else
+              initialize_renderable_components(
+                component_view, app: app, composer: composer, modes: modes, path: current_path
+              )
+            end
+          end
+        end
+
+        # @api private
+        def self.find_renderable_components(view, components = [])
+          view.components.each do |component_view|
+            find_renderable_components(component_view, components)
+
+            if component_view.object.label(:components).any? { |c| c[:renderable] }
+              components << component_view
+            end
+          end
+
+          components
+        end
+
+        # @api private
+        def self.wrap_block(block, context_class)
+          Proc.new do
+            @app.presenter_for_context(
+              context_class.__presenter_class, self
+            ).instance_eval(&block)
+          end
+        end
+
+        # @api private
+        def self.find_compound_presenter(app, component_classes)
+          compound_name = component_classes.map { |component_class|
+            component_class.__object_name.name.to_s
+          }.join("_")
+
+          object_name = Support::ObjectName.namespace(
+            app.class.__object_name.namespace.parts[0], :components, compound_name, :presenter
+          )
+
+          if const_defined?(object_name.constant)
+            const_get(object_name.constant)
+          else
+            nil
+          end
+        end
+
+        # @api private
+        #
+        def self.find_or_build_compound_presenter(app, component_classes)
+          compound_name = component_classes.map { |component_class|
+            component_class.__object_name.name.to_s
+          }.join("_")
+
+          object_name = Support::ObjectName.namespace(
+            app.class.__object_name.namespace.parts[0], :components, compound_name, :presenter
+          )
+
+          if const_defined?(object_name.constant)
+            const_get(object_name.constant)
+          else
+            component_presenter = Class.new(app.isolated(:Presenter))
+            Support::ObjectMaker.define_const_for_object_with_name(component_presenter, object_name)
+
+            component_classes.each do |component_class|
+              # Copy unique attached renders.
+              #
+              component_class.__presenter_class.__attached_renders.each_with_index do |attached_render, i|
+                component_presenter.__attached_renders.insert(i, {
+                  binding_path: attached_render[:binding_path],
+                  channel: attached_render[:channel],
+                  node: attached_render[:node],
+                  priority: attached_render[:priority],
+                  block: wrap_block(attached_render[:block], component_class),
+                })
+              end
+
+              # Copy unique global options.
+              #
+              component_class.__presenter_class.__global_options.each do |form_binding, field_binding_values|
+                field_binding_values.each do |field_binding, field_binding_value|
+                  component_presenter.options_for(
+                    form_binding,
+                    field_binding,
+                    field_binding_value[:options],
+                    &wrap_block(field_binding_value[:block], component_class)
+                  )
+                end
+              end
+
+              # Copy unique presentation logic.
+              #
+              component_class.__presenter_class.__presentation_logic.each do |binding_name, logic_arr|
+                unless component_presenter.__presentation_logic.include?(binding_name)
+                  component_presenter.__presentation_logic[binding_name] = []
+                end
+
+                logic_arr.each_with_index do |logic, i|
+                  component_presenter.__presentation_logic[binding_name].insert(i, {
+                    block: wrap_block(logic[:block], component_class),
+                    channel: logic[:channel]
+                  })
+                end
+              end
+
+              # Copy unique versioning logic.
+              #
+              component_class.__presenter_class.__versioning_logic.each do |binding_name, logic_arr|
+                unless component_presenter.__versioning_logic.include?(binding_name)
+                  component_presenter.__versioning_logic[binding_name] = []
+                end
+
+                logic_arr.each_with_index do |logic, i|
+                  component_presenter.__versioning_logic[binding_name].insert(i, {
+                    block: wrap_block(logic[:block], component_class)
+                  })
+                end
+              end
+            end
+
+            component_presenter
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/rendering/actions/set_page_title.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Presenter
+    module Actions
+      module SetPageTitle
+        extend Support::Extension
+
+        apply_extension do
+          attach do |presenter|
+            presenter.render node: -> {
+              if title_value = info(:title)
+                title.object.set_label(:title_template, title_value); title
+              end
+            } do
+              self.html = html_safe(
+                Support::StringBuilder.new(object.label(:title_template), html_safe: true) { |object_value|
+                  if respond_to?(object_value)
+                    send(object_value, :title) || send(object_value)
+                  elsif @presentables.key?(object_value)
+                    @presentables[object_value]
+                  else
+                    nil
+                  end
+                }.build
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/rendering/actions/setup_endpoints.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+require "pakyow/presenter/presenters/endpoint"
+
+module Pakyow
+  module Presenter
+    module Actions
+      module SetupEndpoints
+        extend Support::Extension
+
+        apply_extension do
+          build do |view, app:|
+            view.object.find_significant_nodes(:endpoint, descend: true).each do |node|
+              if endpoint = app.endpoints.find(name: node.label(:endpoint))
+                node.set_label(:endpoint_object, endpoint)
+                node.set_label(:endpoint_params, {})
+              end
+            end
+          end
+
+          attach do |presenter|
+            if Pakyow.env?(:prototype)
+              presenter.render node: -> {
+                object.find_significant_nodes(:endpoint, descend: true).map { |node|
+                  View.from_object(node)
+                }
+              }, priority: :low do
+                setup
+              end
+            else
+              # Setup non-binding endpoints (binding endpoints are setup dynamically in presenter).
+              #
+              presenter.render node: -> {
+                nodes = []
+                nodes << object if object.is_a?(StringDoc::Node) && object.significant?(:endpoint)
+                nodes.concat(object.find_significant_nodes(:endpoint))
+                nodes.select { |node|
+                  node.labeled?(:endpoint_object)
+                }.map { |node|
+                  View.from_object(node)
+                }
+              }, priority: :low do
+                case self
+                when Presenters::Form
+                  Presenters::Endpoint.new(__getobj__).setup
+                when Presenters::Endpoint
+                  setup
+                end
+              end
+            end
+          end
+
+          expose do |connection|
+            connection.set(:__endpoint, connection.endpoint)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/rendering/actions/setup_forms.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+require "pakyow/support/message_verifier"
+require "pakyow/support/safe_string"
+
+require "pakyow/presenter/presenters/form"
+
+module Pakyow
+  module Presenter
+    module Actions
+      module SetupForms
+        extend Support::Extension
+
+        apply_extension do
+          build do |view, app:|
+            forms = view.forms
+            if !view.object.is_a?(StringDoc) && view.object.significant?(:form)
+              forms << view
+            end
+
+            forms.each do |form|
+              # Allows app renders to set metadata values on forms.
+              #
+              form.object.set_label(:form, {})
+
+              # Set the form id.
+              #
+              form_id = SecureRandom.hex(24)
+              form.object.label(:form)[:id] = form_id
+              form.object.set_label(Presenters::Form::ID_LABEL, form_id)
+
+              # Set the form binding.
+              #
+              form.object.label(:form)[:binding] = form.object.label(:channeled_binding)
+
+              # Setup field names.
+              #
+              form.object.children.each_significant_node(:binding) do |binding_node|
+                if Pakyow::Presenter::Form::FIELD_TAGS.include?(binding_node.tagname)
+                  if binding_node.attributes[:name].to_s.empty?
+                    binding_node.attributes[:name] = "#{form.object.label(:binding)}[#{binding_node.label(:binding)}]"
+                  end
+
+                  if binding_node.tagname == "select" && binding_node.attributes[:multiple]
+                    Presenters::Form.pluralize_field_name(binding_node)
+                  end
+                end
+              end
+
+              # Connect labels.
+              #
+              form.object.children.each_significant_node(:label) do |label_node|
+                if label_node.attributes[:for] && input = form.find(*label_node.attributes[:for].to_s.split("."))
+                  Presenters::Form.connect_input_to_label(input, label_node)
+                end
+              end
+
+              form.prepend(
+                Support::SafeStringHelpers.html_safe(
+                  "<input type=\"hidden\" name=\"_method\">"
+                )
+              )
+
+              form.prepend(
+                Support::SafeStringHelpers.html_safe(
+                  "<input type=\"hidden\" name=\"_form\">"
+                )
+              )
+
+              if app.config.presenter.embed_authenticity_token
+                form.prepend(
+                  Support::SafeStringHelpers.html_safe(
+                    "<input type=\"hidden\" name=\"#{app.config.security.csrf.param}\">"
+                  )
+                )
+              end
+            end
+          end
+
+          attach do |presenter, app:|
+            presenter.render node: -> {
+              forms = self.forms
+              if !object.is_a?(StringDoc) && object.significant?(:form)
+                forms << self
+              end
+
+              forms
+            } do
+              unless setup?
+                if object = object_for_form
+                  if app.class.includes_framework?(:data) && object.is_a?(Data::Proxy)
+                    object = object.one
+                  end
+                end
+
+                if !object.nil?
+                  if labeled?(:endpoint)
+                    setup(object)
+                  else
+                    if object.key?(:id)
+                      update(object)
+                    else
+                      create(object)
+                    end
+                  end
+                elsif labeled?(:binding)
+                  case presentables[:__endpoint_name]
+                  when :edit
+                    update(
+                      __endpoint.params.each_with_object({}) { |(key, _), passed_params|
+                        key = key.to_sym
+                        passed_params[key] = __params[key]
+                      }
+                    )
+                  else
+                    create
+                  end
+                end
+              end
+
+              view.object.label(:form)[:origin] = presentables[:__origin]
+
+              node = view.object.each_significant_node(:field).find { |field_node|
+                field_node.attributes[:name] == "_form"
+              }
+
+              unless node.nil?
+                node.attributes[:value] = presentables[:__verifier].sign(
+                  label(:form).to_json
+                )
+              end
+            end
+
+            presenter.render node: -> {
+              stringified_param = app.config.security.csrf.param.to_s
+              node = object.each_significant_node(:field, descend: true).find { |field_node|
+                field_node.attributes[:name] == stringified_param
+              }
+
+              unless node.nil?
+                View.from_object(node)
+              end
+            } do
+              attributes[:value] = presentables[:__verifier].sign(Support::MessageVerifier.key)
+            end
+
+            presenter.render node: -> {
+              object.each_significant_node(:method_override, descend: true).map { |node|
+                View.from_object(node)
+              }
+            } do
+              remove if attributes[:value].empty?
+            end
+          end
+
+          expose do |connection|
+            connection.set(:__params, connection.params)
+            connection.set(:__endpoint, connection.endpoint)
+            connection.set(:__verifier, connection.verifier)
+
+            origin = if connection.set?(:__form)
+              connection.get(:__form)[:origin]
+            else
+              connection.fullpath
+            end
+
+            connection.set(:__origin, origin)
+          end
+        end
+      end
+    end
+  end
+end