pakyow-presenter 0.11.3 → 1.0.0.rc1

data/lib/pakyow/presenter/behavior/initializing.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+require "pakyow/plugin"
+
+module Pakyow
+  module Presenter
+    module Behavior
+      module Initializing
+        extend Support::Extension
+
+        apply_extension do
+          unless ancestors.include?(Plugin)
+            after "load", "load.presenter" do
+              state(:templates) << Templates.new(
+                :default,
+                config.presenter.path,
+                processor: ProcessorCaller.new(
+                  state(:processor)
+                )
+              )
+
+              state(:templates) << Templates.new(:errors, File.join(File.expand_path("../../../", __FILE__), "views", "errors"))
+            end
+
+            after "load.plugins" do
+              # Load plugin frontend after the app so that app has priority.
+              #
+              @plugs.each(&:load_frontend)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/behavior/modes.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Presenter
+    module Behavior
+      module Modes
+        class ModeCallContext
+          def initialize(connection)
+            @connection = connection
+          end
+        end
+
+        extend Support::Extension
+
+        attr_accessor :__ui_modes
+
+        def mode(name, &block)
+          @__ui_modes[name.to_sym] = wrap_mode_block(block)
+        end
+
+        private def wrap_mode_block(block)
+          if is_a?(Plugin)
+            wrap_mode_block_for_plug(self, block)
+          else
+            Proc.new do |connection|
+              isolated(:ModeCallContext).new(connection).instance_eval(&block)
+            end
+          end
+        end
+
+        private def wrap_mode_block_for_plug(plug, block)
+          Proc.new do |connection|
+            plug.helper_caller(:passive, connection, plug).instance_eval(&block)
+          end
+        end
+
+        prepend_methods do
+          def initialize(*)
+            @__ui_modes = Hash[
+              self.class.__ui_modes.map { |name, block|
+                [name, wrap_mode_block(block)]
+              }
+            ]
+
+            super
+          end
+        end
+
+        apply_extension do
+          class_state :__ui_modes, default: {}, inheritable: true
+
+          after "load" do
+            ([:html] + state(:processor).map(&:extensions).flatten).uniq.each do |extension|
+              config.process.watched_paths << File.join(config.presenter.path, "**/*.#{extension}")
+            end
+          end
+
+          isolate ModeCallContext
+
+          on "load" do
+            self.class.include_helpers :passive, isolated(:ModeCallContext)
+          end
+
+          if ancestors.include?(Plugin)
+            # Copy ui modes from other plugins to this plugin.
+            #
+            after "load" do
+              parent.plugs.each do |plug|
+                plug.__ui_modes.each do |mode, block|
+                  unless @__ui_modes.key?(mode)
+                    plug_namespace = plug.class.__object_name.namespace.parts.last
+
+                    full_mode = if plug_namespace == :default
+                      :"@#{plug.class.plugin_name}.#{mode}"
+                    else
+                      :"@#{plug.class.plugin_name}(#{plug_namespace}).#{mode}"
+                    end
+
+                    @__ui_modes[full_mode] = block
+                  end
+                end
+              end
+            end
+          else
+            # Copy ui modes from plugins to the app.
+            #
+            after "load.plugins" do
+              plugs.each do |plug|
+                plug.__ui_modes.each do |mode, block|
+                  unless @__ui_modes.key?(mode)
+                    plug_namespace = plug.class.__object_name.namespace.parts.last
+
+                    full_mode = if plug_namespace == :default
+                      :"@#{plug.class.plugin_name}.#{mode}"
+                    else
+                      :"@#{plug.class.plugin_name}(#{plug_namespace}).#{mode}"
+                    end
+
+                    @__ui_modes[full_mode] = block
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        class_methods do
+          def mode(name, &block)
+            @__ui_modes[name.to_sym] = block
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/behavior/versions.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Presenter
+    module Behavior
+      module Versions
+        extend Support::Extension
+
+        apply_extension do
+          if ancestors.include?(Plugin)
+            # Copy global versioning logic from other plugins to this plugin.
+            #
+            after "load" do
+              presenters = [isolated(:Presenter)].concat(state(:presenter))
+
+              parent.plugs.each do |plug|
+                plug.isolated(:Presenter).__versioning_logic.each_pair do |version, logic_arr|
+                  logic_arr.each do |logic|
+                    presenters.each do |presenter|
+                      unless presenter.__versioning_logic.include?(version)
+                        plug_namespace = plug.class.__object_name.namespace.parts.last
+
+                        prefix = if plug_namespace == :default
+                          plug.class.plugin_name
+                        else
+                          "#{plug.class.plugin_name}(#{plug_namespace})"
+                        end
+
+                        presenter.version :"@#{prefix}.#{version}" do |object|
+                          instance_exec(object, plug, &logic[:block])
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          else
+            # Copy global versioning logic from plugin presenters.
+            #
+            after "load.plugins" do
+              presenters = [isolated(:Presenter)].concat(state(:presenter))
+
+              plugs.each do |plug|
+                plug.isolated(:Presenter).__versioning_logic.each_pair do |version, logic_arr|
+                  logic_arr.each do |logic|
+                    presenters.each do |presenter|
+                      plug_namespace = plug.class.__object_name.namespace.parts.last
+
+                      prefix = if plug_namespace == :default
+                        plug.class.plugin_name
+                      else
+                        "#{plug.class.plugin_name}(#{plug_namespace})"
+                      end
+
+                      presenter.version :"@#{prefix}.#{version}" do |object|
+                        instance_exec(object, plug, &logic[:block])
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/behavior/watching.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Presenter
+    module Behavior
+      module Watching
+        extend Support::Extension
+
+        apply_extension do
+          after "load" do
+            ([:html] + state(:processor).map(&:extensions).flatten).uniq.each do |extension|
+              config.process.watched_paths << File.join(config.presenter.path, "**/*.#{extension}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/binder.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "pakyow/support/makeable"
+
+module Pakyow
+  module Presenter
+    # Decorates an object being bound to the view.
+    #
+    class Binder
+      extend Support::Makeable
+
+      # The object being bound.
+      #
+      attr_reader :object
+
+      def initialize(object, app:)
+        @object, @app = object, app
+        @parts = {}
+        @binding = false
+        @memoized = {}
+      end
+
+      # Defines a binding part, which binds to an aspect of the view.
+      #
+      # @example
+      #   binder :post do
+      #     def title(value)
+      #       part :class do
+      #         [:first_classname, :second_classname]
+      #       end
+      #
+      #       part :content do
+      #         value.to_s.reverse
+      #       end
+      #     end
+      #   end
+      #
+      def part(name, &block)
+        parts_for(caller_locations(1, 1)[0].label.to_sym).define_part(name, block)
+      end
+
+      # Returns the value for a key (including parts).
+      #
+      def __value(key)
+        if @memoized.include?(key)
+          @memoized[key]
+        else
+          @memoized[key] = if respond_to?(key)
+            value = public_send(key)
+
+            if parts?(key)
+              parts_for(key)
+            else
+              value
+            end
+          else
+            @object[key]
+          end
+        end
+      end
+
+      # Returns the underlying object value for a key.
+      #
+      def [](key)
+        @object[key]
+      end
+
+      # Returns only the content value for a key.
+      #
+      def __content(key, view)
+        return_value = __value(key)
+        if return_value.is_a?(BindingParts)
+          if return_value.content?
+            return_value.content(view)
+          else
+            @object[key]
+          end
+        else
+          return_value
+        end
+      end
+
+      # Returns +true+ if the binder might return a value for +key+.
+      #
+      def include?(key)
+        return false if @binding && !@object.include?(key) && (parts?(key) && !parts_for(key).content?)
+        respond_to?(key) || @object.include?(key)
+      end
+
+      # Returns +true+ if the a value is present for +key+.
+      #
+      def present?(key)
+        !__value(key).nil?
+      end
+
+      # Flips a switch, telling the binder that we now only care about content, not other parts.
+      # This is so that we can transform based on parts, but bind only based on content.
+      #
+      # @api private
+      def binding!
+        @binding = true
+      end
+
+      private
+
+      def parts?(name)
+        @parts.include?(name.to_sym)
+      end
+
+      def parts_for(name)
+        @parts[name] ||= BindingParts.new
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/binding_parts.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Pakyow
+  module Presenter
+    class BindingParts
+      def initialize
+        @parts = {}
+      end
+
+      def define_part(name, block)
+        @parts[name] = block
+      end
+
+      def content?
+        @parts.include?(:content)
+      end
+
+      def content(view)
+        @parts[:content].call(view.text)
+      end
+
+      def values(view)
+        values_for_parts(@parts, view)
+      end
+
+      def non_content_values(view)
+        values_for_parts(@parts.reject { |name, _|
+          name == :content
+        }, view)
+      end
+
+      def reject(*parts)
+        parts = parts.map(&:to_sym)
+        @parts.delete_if { |key, _| parts.include? key }
+      end
+
+      def accept(*parts)
+        return if parts.empty?
+        parts = parts.map(&:to_sym)
+        @parts.keep_if { |key, _| parts.include? key }
+      end
+
+      def to_json(*)
+        @parts.to_json
+      end
+
+      private
+
+      def values_for_parts(parts, view)
+        Hash[parts.map { |name, block|
+          value = if block.arity == 0
+            block.call
+          else
+            view.attrs[name].tap do |current_value|
+              block.call(current_value)
+            end
+          end
+
+          [name, value]
+        }]
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/component.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "pakyow/support/class_state"
+require "pakyow/support/hookable"
+require "pakyow/support/makeable"
+require "pakyow/support/makeable/object_maker"
+
+module Pakyow
+  module Presenter
+    # Reusable functionality for a component of your presentation.
+    #
+    class Component
+      extend Support::Makeable
+
+      extend Support::ClassState
+      class_state :__presenter_class, default: Presenter, inheritable: true
+
+      include Support::Hookable
+      events :render
+
+      # @api private
+      attr_reader :connection
+
+      def initialize(connection:, config: {})
+        @connection, @config = connection, config
+      end
+
+      def perform
+        # intentionally empty
+      end
+
+      private
+
+      class << self
+        def presenter(&block)
+          @__presenter_class = Class.new(@__presenter_class) do
+            class_eval(&block)
+          end
+
+          Support::ObjectMaker.define_object_on_target_with_constant_name(
+            @__presenter_class, self, :Presenter
+          )
+        end
+
+        def parse(string)
+          component, config_string = string.split("(")
+
+          {
+            name: component.strip.to_sym,
+            config: parse_config(config_string)
+          }
+        end
+
+        def parse_config(string)
+          if string
+            string.strip[0..-2].split(",").each_with_object({}) { |config_string_part, values|
+              key, value = config_string_part.split(":")
+
+              value = if value
+                value.strip
+              else
+                true
+              end
+
+              values[key.strip.to_sym] = value
+            }
+          else
+            {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/composers/component.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "string_doc"
+
+require "pakyow/support/deep_dup"
+
+require "pakyow/presenter/errors"
+require "pakyow/presenter/view"
+
+require "pakyow/presenter/composers/view"
+
+module Pakyow
+  module Presenter
+    module Composers
+      class Component < View
+        using Support::DeepDup
+
+        attr_reader :component_path
+
+        def initialize(view_path, component_path, app:, labels: {})
+          super(view_path, app: app)
+          @component_path = component_path
+          @labels = labels
+        end
+
+        def key
+          @view_path + "::" + @component_path.join("::")
+        end
+
+        def post_process(view)
+          self.class.follow_path(@component_path, view)
+        end
+
+        def finalize(view)
+          if @labels.any?
+            if view.frozen?
+              view = view.soft_copy
+            end
+
+            @labels.each_pair do |key, value|
+              view.object.set_label(key, value)
+            end
+          end
+
+          view
+        end
+
+        def marshal_dump
+          {
+            app: @app,
+            view_path: @view_path,
+            component_path: @component_path
+          }
+        end
+
+        def marshal_load(state)
+          @labels = {}
+          state.each do |key, value|
+            instance_variable_set(:"@#{key}", value)
+          end
+        end
+
+        class << self
+          # Follow the path to find the correct component.
+          #
+          def follow_path(path, view)
+            path = path.dup
+            while step = path.shift
+              view = view.components[step]
+            end
+
+            view
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/composers/view.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "string_doc"
+
+require "pakyow/support/class_state"
+require "pakyow/support/deep_dup"
+require "pakyow/support/core_refinements/string/normalization"
+
+require "pakyow/presenter/errors"
+
+module Pakyow
+  module Presenter
+    module Composers
+      class View
+        extend Support::ClassState
+        class_state :__cache, default: {}
+
+        using Support::DeepDup
+        using Support::Refinements::String::Normalization
+
+        attr_reader :view_path
+
+        UNRETAINED_SIGNIFICANCE = %i(container partial template).freeze
+
+        def initialize(view_path, app:)
+          @view_path = String.normalize_path(view_path)
+          @app = app
+        end
+
+        def key
+          @view_path
+        end
+
+        def view(return_cached: false)
+          cache_key = :"#{@app.config.name}__#{@view_path}"
+
+          unless view = View.__cache[cache_key]
+            unless info = @app.view_info_for_path(@view_path)
+              error = UnknownPage.new("No view at path `#{@view_path}'")
+              error.context = @view_path
+              raise error
+            end
+
+            info = info.deep_dup
+            view = info[:layout].build(info[:page]).tap { |view_without_partials|
+              view_without_partials.mixin(info[:partials])
+            }
+
+            # We collapse built views down to significance that is considered "renderable". This is
+            # mostly an optimization, since it lets us collapse some nodes into single strings and
+            # reduce the number of operations needed for a render.
+            #
+            view.object.collapse(
+              *(StringDoc.significant_types.keys - UNRETAINED_SIGNIFICANCE)
+            )
+
+            # Empty nodes are removed as another render-time optimization leading to fewer operations.
+            #
+            view.object.remove_empty_nodes
+
+            View.__cache[cache_key] = view
+          end
+
+          if return_cached
+            view
+          else
+            view.dup
+          end
+        end
+      end
+    end
+  end
+end