pakyow-ui 0.11.3 → 1.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: b844430b966145355c6fbe487e29146929844acc
-  data.tar.gz: 11749702224aaa8734d3f3a833ecb964ecbca8fb
+SHA256:
+  metadata.gz: e73cc5b15a5dc52180b3e004a21835916a5c94b91e50716e4d9decc0d8b47129
+  data.tar.gz: '095d1cf65f4d828ed90260b501ea7e6a7759dbfe02d1d3ecfd30e9ad4f234b0f'
 SHA512:
-  metadata.gz: 24877fe45b5e018abd93bdee153398beca25fd06ac74e135e1220716618ceeee54c024ac8387ac52441c7b7ab160f0df18dc76ec4824af9b4e3f88fec1ce45b7
-  data.tar.gz: 056c6222bec4874a0c4a07768fb8c8aa8d71f7a05389762c34f59f6fe99d22f12ce6e35acaab62e30fa9f81b448b557b9d924afe0f64720bf0fa23cc26309bad
+  metadata.gz: 78cee63f23c55096e8fd1fc2fcc13526766172ba9346cf54ffb00c25679945f641921a39f6cec6c5c5aeedabacc89ef4434ea302787babfa52d1b701947b610c
+  data.tar.gz: 937625badf07777bc7ebd71413d86aa27cc1e9af28f9d25e5c595a376d0528d8984168e6db12ebe8730515d161b7951f314a2b1cb6bc81d92de7be7dfa3fb770

data/LICENSE

@@ -0,0 +1,4 @@
+Copyright (c) Metabahn, LLC
+
+Pakyow UI is an open-source project licensed under the terms of the LGPLv3 license.
+See <https://choosealicense.com/licenses/lgpl-3.0/> for license text.

data/{pakyow-ui/README.md → README.md}

@@ -307,8 +307,7 @@ Source code can be downloaded as part of the Pakyow project on Github:
 
 # License
 
-Pakyow UI is released free and open-source under the [MIT
-License](http://opensource.org/licenses/MIT).
+Pakyow UI is free and open-source under the [LGPLv3 license](https://choosealicense.com/licenses/lgpl-3.0/).
 
 # Support
 

data/lib/pakyow/ui/behavior/recording.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+require "pakyow/ui/recordable"
+
+module Pakyow
+  module UI
+    module Behavior
+      module Recording
+        extend Support::Extension
+
+        def find_ui_presenter_for(presenter_class)
+          if is_a?(Plugin)
+            # Look for the presenter in the plugin first, falling back to the app.
+            #
+            ui_presenter_class = parent.ui_presenters.find { |klass|
+              klass.ancestors.include?(presenter_class)
+            }
+          end
+
+          ui_presenter_class ||= @ui_presenters.find { |klass|
+            klass.ancestors.include?(presenter_class)
+          }
+        end
+
+        apply_extension do
+          # Create subclasses of each presenter, then make the subclasses recordable.
+          # These subclasses will be used when performing a ui presentation instead
+          # of the original presenter, but they'll behave identically!
+          #
+          after "initialize" do
+            @ui_presenters = [isolated(:Presenter)].concat(
+              state(:presenter)
+            ).concat(
+              state(:component).map(&:__presenter_class)
+            ).map { |presenter_class|
+              Class.new(presenter_class) do
+                include Recordable
+              end
+            }
+          end
+
+          class_eval do
+            attr_reader :ui_presenters
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/ui/behavior/rendering/install_transforms.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+require "pakyow/presenter/view"
+
+module Pakyow
+  module UI
+    module Behavior
+      module Rendering
+        module InstallTransforms
+          extend Support::Extension
+
+          apply_extension do
+            attach do |presenter|
+              presenter.render node: -> {
+                nodes = []
+
+                if html_node = object.find_first_significant_node(:html)
+                  nodes << Pakyow::Presenter::View.from_object(html_node)
+                end
+
+                if !object.is_a?(StringDoc) && object.significant?(:component)
+                  nodes << Pakyow::Presenter::View.from_object(object)
+                end
+
+                object.each_significant_node_without_descending_into_type(:component, descend: true) do |node|
+                  if node.label(:components).any? { |c| c[:renderable ] }
+                    nodes << Pakyow::Presenter::View.from_object(node)
+                  end
+                end
+
+                nodes
+              } do
+                if transformation_id = presentables[:__transformation_id]
+                  # Set the transformation_id on the target node so that transformations can be applied to the right place.
+                  #
+                  attributes[:"data-t"] = transformation_id
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/ui/behavior/rendering.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+require "pakyow/support/deep_dup"
+require "pakyow/support/extension"
+require "pakyow/support/inflector"
+
+require "pakyow/realtime/helpers/subscriptions"
+
+require "pakyow/ui/handler"
+
+module Pakyow
+  module UI
+    module Behavior
+      module Rendering
+        extend Support::Extension
+
+        apply_extension do
+          isolated :Renderer do
+            include Realtime::Helpers::Subscriptions
+
+            def socket_client_id
+              presentables[:__socket_client_id]
+            end
+
+            on "render" do
+              unless presentables.include?(:__ui_transform) || subscribables.empty?
+                # To keep up with the node(s) that matter for the transformation, a `data-t` attribute
+                # is added to the node that contains the transformation_id. When the transformation is
+                # triggered in the future, the client knows what node to apply tranformations to.
+                #
+                # Note that when we're presenting an entire view, `data-t` is set on the `html` node.
+                #
+                transformation_target = case @presenter.view.object
+                when StringDoc
+                  @presenter.view.object.find_first_significant_node(:html)
+                when StringDoc::Node
+                  @presenter.view.object
+                end
+
+                if transformation_target
+                  ui_renderer_instance = @app.isolated(:UIRenderer).allocate
+
+                  instance_variables.each do |ivar|
+                    ui_renderer_instance.instance_variable_set(ivar, instance_variable_get(ivar))
+                  end
+
+                  metadata = {
+                    renderer: ui_renderer_instance
+                  }
+
+                  payload = {
+                    metadata: Marshal.dump(metadata)
+                  }
+
+                  # Generate a unique id based on the value of the metadata. This guarantees that the
+                  # transformation id will be consistent across subscriptions.
+                  #
+                  transformation_id = Digest::SHA1.hexdigest(payload[:metadata])
+                  presentables[:__transformation_id] = transformation_id
+                  payload[:transformation_id] = transformation_id
+
+                  # Find every subscribable presentable, creating a data subscription for each.
+                  #
+                  subscribables.each do |subscribable|
+                    subscribable.subscribe(socket_client_id, handler: Handler, payload: payload) do |ids|
+                      # Subscribe the subscriptions to the "transformation" channel.
+                      #
+                      subscribe(:transformation, *ids.uniq)
+                    end
+                  end
+                end
+              end
+            end
+
+            using Support::DeepDup
+
+            private def subscribables
+              @subscribables ||= presentables.reject { |presentable_name, _|
+                presentable_name.to_s.start_with?("__")
+              }.map { |_, value|
+                proxy = if value.is_a?(Data::Proxy)
+                  value
+                elsif value.instance_variable_defined?(:@__proxy)
+                  value.instance_variable_get(:@__proxy)
+                else
+                  nil
+                end
+
+                if proxy && proxy.subscribable?
+                  proxy.deep_dup
+                else
+                  nil
+                end
+              }.compact.uniq { |subscribable|
+                subscribable.source.__getobj__
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/ui/behavior/timeouts.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module UI
+    module Behavior
+      module Timeouts
+        extend Support::Extension
+
+        apply_extension do
+          on :join do
+            @connection.app.data.persist(@id)
+          end
+
+          on :leave do
+            @connection.app.data.expire(@id, config.realtime.timeouts.disconnect)
+          end
+
+          isolated :Renderer do
+            after "render" do
+              # Expire subscriptions if the connection is never established.
+              #
+              @app.data.expire(presentables[:__socket_client_id], @app.config.realtime.timeouts.initial)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/ui/framework.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "pakyow/framework"
+
+require "pakyow/ui/helpers"
+
+require "pakyow/ui/behavior/recording"
+require "pakyow/ui/behavior/rendering"
+require "pakyow/ui/behavior/timeouts"
+
+require "pakyow/ui/behavior/rendering/install_transforms"
+
+module Pakyow
+  module UI
+    class Framework < Pakyow::Framework(:ui)
+      # @api private
+      module PresenterForContext
+        def presenter_for_context(presenter_class, context)
+          if context.presentables.include?(:__ui_transform)
+            instance = find_ui_presenter_for(presenter_class).new(
+              context.view, app: context.app, presentables: context.presentables
+            )
+
+            instance.instance_variable_set(:@calls, context.calls)
+            instance
+          else
+            super
+          end
+        end
+      end
+
+      def boot
+        object.class_eval do
+          register_helper :passive, Helpers
+
+          include Behavior::Recording
+          include Behavior::Rendering
+          include Behavior::Timeouts
+
+          isolated :Renderer do
+            include Behavior::Rendering::InstallTransforms
+          end
+
+          prepend PresenterForContext
+
+          ui_renderer = Class.new(isolated(:Renderer)) do
+            def marshal_load(state)
+              deserialize(state)
+              @presenter_class = @app.find_ui_presenter_for(@presenter_class)
+              initialize_presenter
+            end
+
+            def perform(*)
+              @presenter.to_html
+            end
+          end
+
+          # Delete the render_components build step since ui will not be invoking the component.
+          #
+          ui_renderer.__build_fns.delete_if { |fn|
+            fn.source_location[0].end_with?("render_components.rb")
+          }
+
+          unless const_defined?(:UIRenderer, false)
+            const_set(:UIRenderer, ui_renderer)
+          end
+
+          after :initialize do
+            config.data.subscriptions.version = config.version
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/ui/handler.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "pakyow/connection"
+
+require "pakyow/data/proxy"
+require "pakyow/data/sources/ephemeral"
+
+require "pakyow/realtime/channel"
+
+require "pakyow/ui/recordable"
+
+module Pakyow
+  module UI
+    class Handler
+      def initialize(app)
+        @app = app
+      end
+
+      def call(args, subscription: nil, result: nil)
+        renderer = Marshal.restore(args[:metadata])[:renderer]
+        renderer.presentables[:__ui_transform] = true
+
+        # If an ephemeral caused the update, replace the value for any matching presentables.
+        #
+        if result.is_a?(Data::Sources::Ephemeral)
+          renderer.presentables.each do |key, value|
+            if value.is_a?(Data::Proxy) && value.source.is_a?(Data::Sources::Ephemeral) && value.source.type == result.type && value.source.qualifications == result.qualifications
+              value.instance_variable_set(:@source, result)
+            end
+          end
+        end
+
+        renderer.perform
+
+        @app.websocket_server.subscription_broadcast(
+          Realtime::Channel.new(:transformation, subscription[:id]),
+          { id: args[:transformation_id], calls: renderer.presenter }
+        )
+      end
+    end
+  end
+end

data/lib/pakyow/ui/helpers.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Pakyow
+  module UI
+    module Helpers
+      def ui?
+        @connection.request_header?("pw-ui")
+      end
+
+      def ui
+        @connection.request_header("pw-ui")
+      end
+
+      def ui_transform?
+        @connection.set?(:__ui_transform)
+      end
+    end
+  end
+end

data/lib/pakyow/ui/recordable/attribute.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "delegate"
+require "json"
+
+require "pakyow/ui/recordable/helpers/client_remapping"
+
+module Pakyow
+  module UI
+    module Recordable
+      class Attribute < SimpleDelegator
+        include Helpers::ClientRemapping
+
+        def initialize(attribute)
+          __setobj__(attribute)
+          @calls = []
+        end
+
+        %i([] []= << delete clear add).each do |method_name|
+          define_method method_name do |*args|
+            super(*args).tap do
+              @calls << [remap_for_client(method_name), args, [], []]
+            end
+          end
+        end
+
+        def to_json(*)
+          @calls.to_json
+        end
+
+        # Fixes an issue using pp inside a delegator.
+        #
+        def pp(*args)
+          Kernel.pp(*args)
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/ui/recordable/attributes.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "json"
+
+require "pakyow/ui/recordable/attribute"
+require "pakyow/ui/recordable/helpers/client_remapping"
+
+module Pakyow
+  module UI
+    module Recordable
+      class Attributes < Pakyow::Presenter::Attributes
+        include Helpers::ClientRemapping
+
+        %i([] []=).each do |method_name|
+          define_method method_name do |*args|
+            result = super(*args)
+            result = case method_name
+            when :[]
+              Attribute.new(result)
+            else
+              result
+            end
+
+            result.tap do
+              subsequent = if result.is_a?(Attribute)
+                result
+              else
+                []
+              end
+
+              @calls << [remap_for_client(method_name), args, [], subsequent]
+            end
+          end
+        end
+
+        def to_json(*)
+          @calls.to_json
+        end
+
+        class << self
+          def from_attributes(attributes)
+            new(attributes.instance_variable_get(:@attributes)).tap { |instance|
+              instance.instance_variable_set(:@calls, [])
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/ui/recordable/helpers/client_remapping.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Pakyow
+  module UI
+    module Recordable
+      module Helpers
+        module ClientRemapping
+          def remap_for_client(method_name)
+            case method_name
+            when :[]
+              :get
+            when :[]=
+              :set
+            when :<<
+              :add
+            when :title=
+              :setTitle
+            when :html=
+              :setHtml
+            when :endpoint_action
+              :endpointAction
+            else
+              method_name
+            end
+          end
+        end
+      end
+    end
+  end
+end