pakyow-presenter 0.11.3 → 1.0.0.rc1

data/lib/pakyow/presenter/processor.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Pakyow
+  module Presenter
+    class ProcessorCaller
+      def initialize(instances)
+        @processors = normalize(instances)
+      end
+
+      def process(content, extension)
+        processors_for_extension(extension).each do |processor|
+          content = processor.process(content)
+        end
+
+        unless extension == :html
+          processors_for_extension(:html).each do |processor|
+            content = processor.process(content)
+          end
+        end
+
+        content
+      end
+
+      def process?(extension)
+        @processors.key?(extension.tr(".", "").to_sym)
+      end
+
+      protected
+
+      def processors_for_extension(extension)
+        @processors[extension] || []
+      end
+
+      def normalize(instances)
+        instances.each_with_object({}) { |instance, processors|
+          instance.extensions.each do |extension|
+            (processors[extension] ||= []) << instance
+          end
+        }
+      end
+    end
+
+    class Processor
+      extend Support::Makeable
+
+      class << self
+        attr_reader :name, :extensions, :block
+
+        def make(name, *extensions, **kwargs, &block)
+          # name is expected to also be an extension
+          extensions.unshift(name).map!(&:to_sym)
+          super(name, extensions: extensions, block: block, **kwargs) {}
+        end
+
+        def process(content)
+          block.call(content)
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/renderable.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Presenter
+    # @api private
+    module Renderable
+      extend Support::Extension
+
+      prepend_methods do
+        def initialize(*args)
+          @rendered = false
+          super
+        end
+      end
+
+      def rendered
+        @rendered = true
+        halt
+      end
+
+      def rendered?
+        @rendered == true
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/renderer.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+require "pakyow/support/class_state"
+require "pakyow/support/deep_freeze"
+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/composers/view"
+
+module Pakyow
+  module Presenter
+    class Renderer
+      using Support::DeepFreeze
+
+      extend Support::ClassState
+      class_state :__presenter_views, default: {}, inheritable: true
+      class_state :__presenters_by_path, default: {}, inheritable: true
+      class_state :__build_fns, default: [], inheritable: true
+      class_state :__attach_fns, default: [], inheritable: true
+      class_state :__expose_fns, default: [], inheritable: true
+
+      extend Support::DeepFreeze
+      unfreezable :__presenters_by_path, :__presenter_views
+
+      include Support::Hookable
+      events :render
+
+      # @api private
+      attr_reader :app, :presentables, :presenter
+
+      def initialize(app:, presentables:, presenter_class:, composer:, modes: [:default])
+        @app, @presentables, @presenter_class, @composer, @modes = app, presentables, presenter_class, composer, modes
+        initialize_presenter
+      end
+
+      def perform(output = String.new)
+        performing :render do
+          @presenter.to_html(output)
+        end
+      end
+
+      def marshal_dump
+        {
+          app: @app,
+          presentables: @presentables.reject { |_, value|
+            # Filter out the component connection that we expose for component rendering.
+            #
+            value.is_a?(@app.isolated(:Connection))
+          },
+          presenter_class: @presenter_class,
+          composer: @composer,
+          modes: @modes
+        }
+      end
+
+      def marshal_load(state)
+        deserialize(state)
+        initialize_presenter
+      end
+
+      private
+
+      def deserialize(state)
+        state.each do |key, value|
+          instance_variable_set(:"@#{key}", value)
+        end
+      end
+
+      def initialize_presenter
+        @presenter = @presenter_class.new(
+          find_or_build_presenter_view(@app, @composer, @presenter_class, @modes),
+          presentables: @presentables, app: @app
+        )
+      end
+
+      def find_or_build_presenter_view(app, composer, presenter, modes)
+        presenter_view_key = [composer.key, presenter, modes]
+
+        unless presenter_view = self.class.__presenter_views[presenter_view_key]
+          presenter_view = composer.view
+
+          self.class.build!(presenter_view, app: app, modes: modes, composer: composer)
+
+          if composer.respond_to?(:post_process)
+            presenter_view = composer.post_process(presenter_view)
+          end
+
+          presenter.attach(presenter_view)
+          presenter_view.deep_freeze
+
+          self.class.__presenter_views[presenter_view_key] = presenter_view
+        end
+
+        if composer.respond_to?(:finalize)
+          presenter_view = composer.finalize(presenter_view)
+        end
+
+        presenter_view
+      end
+
+      class << self
+        using Support::Refinements::Proc::Introspection
+        using Support::Refinements::String::Normalization
+
+        def render(connection, view_path: nil, presenter_path: nil, modes: [:default])
+          connection.app.__ui_modes.each do |mode, block|
+            if block.call(connection)
+              modes << mode
+            end
+          end
+
+          view_path = if view_path
+            String.normalize_path(view_path)
+          else
+            connection.get(:__endpoint_path) || connection.path
+          end
+
+          presenter_path = if presenter_path
+            String.normalize_path(presenter_path)
+          else
+            view_path.dup
+          end
+
+          if connection.app.is_a?(Plugin) && connection.app.class.mount_path != "/"
+            presenter_path.gsub!(/^#{connection.app.class.mount_path}/, "")
+          end
+
+          presenter = find_presenter(connection.app, presenter_path)
+
+          expose!(connection)
+
+          renderer = new(
+            app: connection.app,
+            presentables: connection.values,
+            presenter_class: presenter,
+            composer: Composers::View.new(view_path, app: connection.app),
+            modes: modes
+          )
+
+          connection.set_header("content-type", "text/html")
+
+          if connection.app.config.presenter.features.streaming
+            connection.stream do
+              renderer.perform(connection.body)
+            end
+          else
+            output = renderer.perform(StringIO.new); output.rewind
+            connection.body = output
+          end
+
+          connection.rendered
+        end
+
+        def render_implicitly(connection)
+          view_path = connection.get(:__endpoint_path) || connection.path
+
+          if render_implicitly?(connection)
+            begin
+              catch :halt do
+                render(connection, view_path: view_path)
+              end
+            rescue UnknownPage => error
+              unless connection.app.is_a?(Plugin)
+                raise ImplicitRenderingError.build(error, context: view_path)
+              end
+            end
+          end
+        rescue StandardError => error
+          connection.logger.houston(error)
+
+          if connection.app.class.includes_framework?(:routing)
+            catch :halt do
+              connection.app.controller_for_connection(connection).handle_error(error)
+            end
+          end
+        end
+
+        def build!(view, app:, modes:, composer:)
+          @__build_fns.each do |fn|
+            options = {}
+
+            if fn.keyword_argument?(:app)
+              options[:app] = app
+            end
+
+            if fn.keyword_argument?(:modes)
+              options[:modes] = modes
+            end
+
+            if fn.keyword_argument?(:composer)
+              options[:composer] = composer
+            end
+
+            fn.call(view, **options)
+          end
+        end
+
+        def attach!(presenter, app:)
+          @__attach_fns.each do |fn|
+            options = {}
+
+            if fn.keyword_argument?(:app)
+              options[:app] = app
+            end
+
+            fn.call(presenter, **options)
+          end
+        end
+
+        def expose!(connection)
+          @__expose_fns.each do |fn|
+            fn.call(connection)
+          end
+        end
+
+        def find_presenter(app, path)
+          path = String.normalize_path(path)
+          unless presenter = @__presenters_by_path[path]
+            presenter = if path.nil? || Pakyow.env?(:prototype)
+              app.isolated(:Presenter)
+            else
+              find_presenter_for_path(app, path)
+            end
+
+            @__presenters_by_path[path] = presenter
+          end
+
+          presenter
+        end
+
+        private
+
+        def build(&block)
+          @__build_fns << block
+        end
+
+        def attach(&block)
+          @__attach_fns << block
+        end
+
+        def expose(&block)
+          @__expose_fns << block
+        end
+
+        IMPLICIT_HTTP_METHODS = %i(get head).freeze
+        IMPLICIT_HTTP_FORMATS = %i(any html).freeze
+
+        def render_implicitly?(connection)
+          IMPLICIT_HTTP_METHODS.include?(connection.method) && IMPLICIT_HTTP_FORMATS.include?(connection.format) &&
+            (Pakyow.env?(:prototype) || ((!connection.halted?) && !connection.rendered?))
+        end
+
+        def find_presenter_for_path(app, path)
+          presenter_for_path(app, String.collapse_path(path)) || app.isolated(:Presenter)
+        end
+
+        def presenter_for_path(app, path)
+          app.state(:presenter).find { |presenter|
+            presenter.path == path
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Presenter
+    module Actions
+      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

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Presenter
+    module Actions
+      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

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Presenter
+    module Actions
+      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

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Presenter
+    module Actions
+      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

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+require "pakyow/support/message_verifier"
+require "pakyow/support/safe_string"
+
+module Pakyow
+  module Presenter
+    module Actions
+      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

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Presenter
+    module Actions
+      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