pakyow-presenter 1.0.0.rc2 → 1.0.0.rc3

data/lib/pakyow/presenter/renderer.rb

@@ -7,7 +7,7 @@ require "pakyow/support/hookable"
 require "pakyow/support/core_refinements/proc/introspection"
 require "pakyow/support/core_refinements/string/normalization"
 
-require "pakyow/presenter/rendering/actions/render_components"
+require "pakyow/presenter/renderer/behavior/render_components"
 
 require "pakyow/presenter/composers/view"
 
@@ -155,6 +155,7 @@ module Pakyow
           connection.rendered
         end
 
+        # @api private
         def render_implicitly(connection)
           view_path = connection.get(:__endpoint_path) || connection.path
 
@@ -179,6 +180,7 @@ module Pakyow
           end
         end
 
+        # @api private
         def build!(view, app:, modes:, composer:)
           @__build_fns.each do |fn|
             options = {}
@@ -199,6 +201,7 @@ module Pakyow
           end
         end
 
+        # @api private
         def attach!(presenter, app:)
           @__attach_fns.each do |fn|
             options = {}
@@ -211,12 +214,14 @@ module Pakyow
           end
         end
 
+        # @api private
         def expose!(connection)
           @__expose_fns.each do |fn|
             fn.call(connection)
           end
         end
 
+        # @api private
         def find_presenter(app, path)
           path = String.normalize_path(path)
           unless presenter = @__presenters_by_path[path]

data/lib/pakyow/presenter/renderer/behavior/cleanup_prototype_nodes.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Presenter
+    class Renderer
+      module Behavior
+        module CleanupPrototypeNodes
+          extend Support::Extension
+
+          apply_extension do
+            build do |view|
+              unless Pakyow.env?(:prototype)
+                view.object.each_significant_node(:prototype, descend: true).map(&:itself).each(&:remove)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/renderer/behavior/cleanup_unbound_bindings.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Presenter
+    class Renderer
+      module Behavior
+        module CleanupUnboundBindings
+          extend Support::Extension
+
+          apply_extension do
+            attach do |presenter|
+              unless Pakyow.env?(:prototype)
+                # Cleanup unbound bindings. We don't do this in prototype mode because it's important
+                # for the prototype to be complete, showing everything to the designer.
+                #
+                presenter.render node: -> {
+                  object.find_significant_nodes(:binding, descend: true).map { |node|
+                    View.from_object(node)
+                  }
+                }, priority: :low do
+                  # We check that the node is still labeled as a binding in case the node was replaced
+                  # during a previous transformation with a node that isn't a binding.
+                  #
+                  unless !view.object.labeled?(:binding) || view.object.labeled?(:bound) || view.object.labeled?(:failed) || view.object.label(:version) == :empty
+                    remove
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/renderer/behavior/create_template_nodes.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Presenter
+    class Renderer
+      module Behavior
+        module CreateTemplateNodes
+          extend Support::Extension
+
+          apply_extension do
+            build do |view|
+              unless Pakyow.env?(:prototype)
+                view.each_binding_scope(descend: true) do |node_with_binding|
+                  attributes = node_with_binding.attributes.attributes_hash.each_with_object({}) do |(attribute, value), acc|
+                    acc[attribute] = value if attribute.to_s.start_with?("data")
+                  end
+
+                  node_with_binding.after("<script type=\"text/template\"#{StringDoc::Attributes.new(attributes).to_s}>#{node_with_binding.render}</script>")
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/renderer/behavior/insert_prototype_bar.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Presenter
+    class Renderer
+      module Behavior
+        module InsertPrototypeBar
+          extend Support::Extension
+
+          apply_extension do
+            attach do |presenter|
+              if Pakyow.env?(:prototype)
+                presenter.render node: -> {
+                  if body = object.find_first_significant_node(:body)
+                    View.from_object(body)
+                  end
+                } do
+                  view.object.append_html <<~HTML
+                    <style>
+                      .pw-prototype {
+                        font-family: -apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Oxygen-Sans,Ubuntu,Cantarell,"Helvetica Neue",sans-serif;
+                        display:flex;
+                        align-items: center;
+                        position: fixed;
+                        z-index: 1000;
+                        right: 0;
+                        bottom: 0;
+                        background: #156eed;
+                        color: #fff;
+                        font-size: 11px;
+                        line-height: 11px;
+                        font-weight: 500;
+                        border-top-left-radius: 1px;
+                        padding-left: 5px;
+                      }
+
+                      .pw-prototype-tag {
+                        background: #ff8b6c;
+                        color: #fff;
+                        text-transform: uppercase;
+                        font-size: 10px;
+                        line-height: 12px;
+                        font-weight: 600;
+                        padding: 5px 5px 4px 5px;
+                        margin-left: 10px;
+                      }
+                    </style>
+
+                    <div class="pw-prototype">
+                      #{InsertPrototypeBar.ui_modes_html(view, __modes || [:default])}
+
+                      <div class="pw-prototype-tag">
+                        Prototype
+                      </div>
+                    </div>
+                  HTML
+                end
+              end
+            end
+
+            expose do |connection|
+              if Pakyow.env?(:prototype)
+                connection.set(:__modes, connection.params[:modes])
+              end
+            end
+          end
+
+          # @api private
+          def self.ui_modes_html(view, current_modes)
+            current_modes = current_modes.map(&:to_sym)
+
+            modes = view.object.each_significant_node(:mode).map { |node|
+              node.label(:mode)
+            }
+
+            modes.unshift(
+              (view.info(:mode) || :default).to_sym
+            ).uniq!
+
+            options = modes.map { |each_mode|
+              selected = if current_modes.include?(each_mode)
+                " selected=\"selected\""
+              else
+                ""
+              end
+
+              nice_mode = Support.inflector.humanize(Support.inflector.underscore(each_mode))
+              "<option value=\"#{each_mode}\"#{selected}>#{nice_mode}</option>"
+            }.join
+
+            <<~HTML
+              UI Mode: <select onchange="document.location = window.location.pathname + '?modes[]=' + this.value " style="-webkit-appearance: none; -moz-appearance: none; -ms-appearance: none; -o-appearance: none; appearance: none; font-size: 11px; font-weight: 500; line-height: 20px; background: none; border: none; color: #fff; outline: none; margin: 0; margin-left: 5px;">
+                #{options}
+              </select>
+            HTML
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/renderer/behavior/install_authenticity.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+require "pakyow/support/message_verifier"
+require "pakyow/support/safe_string"
+
+module Pakyow
+  module Presenter
+    class Renderer
+      module Behavior
+        module InstallAuthenticity
+          extend Support::Extension
+
+          apply_extension do
+            build do |view, app:|
+              if app.config.presenter.embed_authenticity_token && head = view.head
+                head.append(Support::SafeStringHelpers.html_safe("<meta name=\"pw-authenticity-token\">"))
+                head.append(Support::SafeStringHelpers.html_safe("<meta name=\"pw-authenticity-param\" content=\"#{app.config.security.csrf.param}\">"))
+              end
+            end
+
+            attach do |presenter|
+              presenter.render node: -> {
+                node = object.each_significant_node(:meta).find { |meta_node|
+                  meta_node.attributes[:name] == "pw-authenticity-token"
+                }
+
+                unless node.nil?
+                  View.from_object(node)
+                end
+              } do
+                attributes[:content] = @presentables[:__verifier].sign(Support::MessageVerifier.key)
+              end
+            end
+
+            expose do |connection|
+              connection.set(:__verifier, connection.verifier)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/renderer/behavior/place_in_mode.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Presenter
+    class Renderer
+      module Behavior
+        module PlaceInMode
+          extend Support::Extension
+
+          apply_extension do
+            build do |view, modes:|
+              unless Pakyow.env?(:prototype)
+                PlaceInMode.perform(view, modes)
+              end
+            end
+
+            attach do |presenter|
+              if Pakyow.env?(:prototype)
+                presenter.render node: -> {
+                  object.find_significant_nodes(:mode, descend: true).map { |node|
+                    View.from_object(node)
+                  }
+                } do
+                  PlaceInMode.perform(view, __modes)
+                end
+              end
+            end
+
+            expose do |connection|
+              if Pakyow.env?(:prototype)
+                connection.set(:__modes, connection.params[:modes] || [:default])
+              end
+            end
+          end
+
+          # @api private
+          def self.perform(view, modes)
+            if modes.length == 1 && modes.first.to_sym == :default
+              modes = view.info(:modes) || modes
+            end
+
+            modes.map!(&:to_sym)
+
+            if view.object.is_a?(StringDoc::Node) && view.object.significant?(:mode) && !modes.include?(view.object.label(:mode))
+              view.remove
+            else
+              view.object.each_significant_node(:mode, descend: true).select { |node|
+                !modes.include?(node.label(:mode))
+              }.each(&:remove)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/renderer/behavior/render_components.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+require "pakyow/presenter/composers/component"
+
+module Pakyow
+  module Presenter
+    class Renderer
+      module Behavior
+        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
+end