pakyow-presenter 0.11.3 → 1.0.0.rc1

data/lib/pakyow/presenter/errors.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "pakyow/support/core_refinements/string/normalization"
+
+require "pakyow/error"
+
+module Pakyow
+  module Presenter
+    class Error < Pakyow::Error
+    end
+
+    class FrontMatterParsingError < Error
+    end
+
+    class UnknownPage < Error
+      using Support::Refinements::String::Normalization
+
+      def contextual_message
+        <<~MESSAGE
+          Pakyow couldn't render a view for `#{String.normalize_path(@context)}`. Try creating a view template for this path:
+
+              frontend/pages#{template_path}.html
+
+            * [Learn about view templates &rarr;](https://pakyow.com/docs/frontend/composition/)
+        MESSAGE
+      end
+
+      private
+
+      def template_path
+        if @context.to_s.empty? || @context.to_s == "/"
+          "/index"
+        else
+          @context
+        end
+      end
+    end
+
+    class ImplicitRenderingError < UnknownPage
+      def name
+        "Unknown page"
+      end
+
+      def contextual_message
+        if Pakyow.env?(:prototype)
+          super
+        else
+          <<~MESSAGE
+            #{super}
+
+            If you want to call backend code instead, create a controller endpoint that handles this request:
+
+                get "#{@context}" do
+                  # your code here
+                end
+
+              * [Learn about controllers &rarr;](https://pakyow.com/docs/routing/)
+          MESSAGE
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/framework.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require "pakyow/framework"
+
+require "pakyow/support/indifferentize"
+require "pakyow/support/core_refinements/string/normalization"
+
+require "pakyow/presenter/behavior/config"
+require "pakyow/presenter/behavior/error_rendering"
+require "pakyow/presenter/behavior/exposures"
+require "pakyow/presenter/behavior/implicit_rendering"
+require "pakyow/presenter/behavior/initializing"
+require "pakyow/presenter/behavior/modes"
+require "pakyow/presenter/behavior/versions"
+require "pakyow/presenter/behavior/watching"
+
+require "pakyow/presenter/helpers/rendering"
+
+require "pakyow/presenter/renderable"
+
+require "pakyow/presenter/renderer"
+
+require "pakyow/presenter/rendering/actions/cleanup_prototype_nodes"
+require "pakyow/presenter/rendering/actions/cleanup_unbound_bindings"
+require "pakyow/presenter/rendering/actions/create_template_nodes"
+require "pakyow/presenter/rendering/actions/insert_prototype_bar"
+require "pakyow/presenter/rendering/actions/install_authenticity"
+require "pakyow/presenter/rendering/actions/place_in_mode"
+require "pakyow/presenter/rendering/actions/render_components"
+require "pakyow/presenter/rendering/actions/set_page_title"
+require "pakyow/presenter/rendering/actions/setup_endpoints"
+require "pakyow/presenter/rendering/actions/setup_forms"
+
+module Pakyow
+  module Presenter
+    class Framework < Pakyow::Framework(:presenter)
+      using Support::Indifferentize
+      using Support::Refinements::String::Normalization
+
+      def boot
+        require "pakyow/presenter/presentable_error"
+
+        object.class_eval do
+          isolate Binder
+          isolate Presenter
+
+          # Make sure component presenters inherit from this app's presenter.
+          #
+          isolated_presenter = isolated(:Presenter)
+          isolate Component do
+            @__presenter_class = isolated_presenter
+          end
+
+          isolate Renderer do
+            include Actions::CleanupPrototypeNodes
+            include Actions::CleanupUnboundBindings
+            include Actions::InsertPrototypeBar
+            include Actions::InstallAuthenticity
+            include Actions::PlaceInMode
+            include Actions::CreateTemplateNodes
+            include Actions::SetupEndpoints
+            include Actions::SetupForms
+            include Actions::SetPageTitle
+          end
+
+          after "load" do
+            isolated(:Renderer) do
+              include Actions::RenderComponents
+            end
+          end
+
+          # Build presenter classes for compound components.
+          #
+          after :initialize, priority: :high do
+            state(:templates).each do |templates|
+              templates.each do |template|
+                template.object.each_significant_node(:component, descend: true) do |node|
+                  if node.label(:components).count > 1
+                    component_classes = node.label(:components).each_with_object([]) { |component_label, arr|
+                      component_class = state(:component).find { |component|
+                        component.__object_name.name == component_label[:name]
+                      }
+
+                      if component_class
+                        arr << component_class
+                      end
+                    }
+
+                    if component_classes.count > 1
+                      state(:presenter) << Actions::RenderComponents.find_or_build_compound_presenter(
+                        self, component_classes
+                      )
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          def presenter_for_context(presenter_class, context)
+            presenter_class.new(
+              context.view, app: context.app, presentables: context.presentables
+            )
+          end
+
+          stateful :binder,    isolated(:Binder)
+          stateful :component, isolated(:Component)
+          stateful :presenter, isolated(:Presenter)
+
+          stateful :processor, Processor
+          stateful :templates, Templates
+
+          aspect :binders
+          aspect :components
+          aspect :presenters
+
+          register_helper :active, Helpers::Rendering
+
+          isolated :Connection do
+            include Renderable
+          end
+
+          isolated :Controller do
+            include Behavior::ImplicitRendering
+
+            action :verify_form_metadata do
+              if metadata = params[:_form]
+                connection.set(
+                  :__form,
+                  JSON.parse(
+                    connection.verifier.verify(metadata)
+                  ).indifferentize
+                )
+
+                params.delete(:_form)
+              end
+            end
+          end
+
+          on "load" do
+            self.class.include_helpers :global, isolated(:Binder)
+            self.class.include_helpers :global, isolated(:Presenter)
+            self.class.include_helpers :active, isolated(:Component)
+
+            # Override the app helper so that config returns the component config.
+            # FIXME: Find a clearer way to do this.
+            #
+            isolated(:Component) do
+              if instance_methods(false).include?(:config)
+                remove_method :config
+              end
+
+              attr_reader :config
+            end
+          end
+
+          # Let each renderer action attach renders to the app's presenter.
+          #
+          after "initialize", priority: :low do
+            [isolated(:Presenter)].concat(
+              state(:presenter)
+            ).concat(
+              state(:component).map(&:__presenter_class)
+            ).uniq.each do |presenter|
+              isolated(:Renderer).attach!(presenter, app: self)
+            end
+          end
+
+          # Update the presenter version and rebuild the app version.
+          #
+          after "initialize" do
+            config.presenter.version = Support::PathVersion.build(config.presenter.path)
+
+            app_version = Digest::SHA1.new
+            app_version.update(config.version)
+            app_version.update(config.presenter.version)
+            config.version = app_version.to_s
+          end
+
+          include Behavior::Config
+          include Behavior::ErrorRendering
+          include Behavior::Exposures
+          include Behavior::Initializing
+          include Behavior::Modes
+          include Behavior::Versions
+          include Behavior::Watching
+
+          def view_info_for_path(path)
+            path = String.collapse_path(path)
+
+            state(:templates).lazy.map { |store|
+              store.info(path)
+            }.find(&:itself)
+          end
+
+          def view?(path)
+            !view_info_for_path(path).nil?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/front_matter_parser.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "pakyow/support/indifferentize"
+
+module Pakyow
+  module Presenter
+    # Parses front matter from text files.
+    #
+    # @api private
+    module FrontMatterParser
+      MATTER_MATCHER = /\A---\s*\n(.*?\n?)^---\s*$\n?/m
+
+      # Parses HTML and returns a hash of front matter info
+      #
+      def self.parse(html_string, _file = nil)
+        unless match = html_string.match(MATTER_MATCHER)
+          return Support::IndifferentHash.new
+        end
+
+        begin
+          Support::IndifferentHash.deep(YAML.load(match.captures[0]).to_h)
+        rescue Psych::SyntaxError => error
+          raise FrontMatterParsingError.build(error, context: match.captures[0])
+        end
+      end
+
+      # Returns HTML with front matter removed
+      #
+      def self.scrub(html_string)
+        html_string.gsub(MATTER_MATCHER, "")
+      end
+
+      # Parses HTML and returns:
+      # - a hash of front matter info
+      # - the HTML with front matter removed
+      #
+      def self.parse_and_scrub(html_string)
+        return parse(html_string), scrub(html_string)
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/helpers/rendering.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pakyow
+  module Presenter
+    module Helpers
+      module Rendering
+        def render(view_path = nil, as: nil, modes: [:default])
+          @connection.app.isolated(:Renderer).render(
+            @connection,
+            view_path: view_path,
+            presenter_path: as,
+            modes: modes
+          )
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/presentable.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Pakyow
+  module Presenter
+    module Presentable
+      def method_missing(method_name, *args, &block)
+        if presentable?(method_name)
+          @presentables[args.unshift(method_name).join(":").to_sym]
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        presentable?(method_name) || super
+      end
+
+      private
+
+      def presentable?(presentable_key)
+        presentable_key = presentable_key.to_s
+        instance_variable_defined?(:@presentables) && @presentables.any? { |key, _|
+          key.to_s.start_with?(presentable_key)
+        }
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/presentable_error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "pakyow/error"
+
+module Pakyow
+  class Error
+    def [](key)
+      if respond_to?(key)
+        public_send(key)
+      else
+        nil
+      end
+    end
+
+    def include?(key)
+      respond_to?(key)
+    end
+  end
+end