pakyow-presenter 0.11.3 → 1.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 5083bed2c1a6c7c03aded460060cb26708435a60
-  data.tar.gz: 5a09f8082023ac3cb21ec975dbbc793379ab86ea
+SHA256:
+  metadata.gz: 1bd0c274a2f3fdcfc17a93a8390f6e785280815105100977f2e57770d44b3bb3
+  data.tar.gz: 270e993fbfd4ff58aac7ad070ab050e8b21029204e6a356ebf0fc82cd268aa25
 SHA512:
-  metadata.gz: dcbca0b0d95e29ad8fd4ea0de656747fc51ac02b49bb0d8d51e52cf732afa451536fbb9dd70b194b2570e70c0dceb1d0dff17f5f3727ed06c6d790316ff56db1
-  data.tar.gz: 027ad8c270f1d8946061e1a7314d845959d77a01c5dd5d310e9ff9e9c1e85fa5f06b7131e7c85cc671bc5ef3a3869d4d6430c80f6c338fa909da73a25b0a7457
+  metadata.gz: 30cd88cf117723d9800598412000b59b1a4d825a3a6766250209ba5e7ac902c579273f0160ddc055e2339342e0d7fa96e6ff91474e73d3273d7666e8bf4581e0
+  data.tar.gz: aef3ab5a380c55076f59e6947096a7c4e92c7c630263ca96627a1cd78cd9d99f11b870db904f169d109804346a81944593b4f0da818d45c99a2c1e793b7d7562

data/{pakyow-presenter/CHANGELOG.md → CHANGELOG.md}

@@ -1,8 +1,3 @@
-# 0.11.2
-
-  * Fixes bug causing resource bindings to be incorrect in some cases
-  * Fixes bug creating unscoped view collection from composer
-
 # 0.11.0
 
   * Fixes several bugs related to nested partials

data/LICENSE

@@ -0,0 +1,4 @@
+Copyright (c) Metabahn, LLC
+
+Pakyow Presenter 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-presenter/README.md → README.md}

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

data/lib/pakyow/generators/presenter/presenter_generator.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "pakyow/generator"
+
+module Pakyow
+  # @api private
+  module Generators
+    class Presenter < Generator
+      def self.source_root
+        File.expand_path("../", __FILE__)
+      end
+
+      argument :app
+      argument :name
+      argument :view_path
+
+      def create_presenter
+        template("templates/presenter.rb.tt", File.join(app.config.src, "presenters/#{name}_presenter.rb"))
+      end
+
+      protected
+
+      def normalized_view_path
+        File.join("/", view_path)
+      end
+    end
+  end
+end

data/lib/pakyow/generators/presenter/templates/presenter.rb.tt

@@ -0,0 +1,2 @@
+presenter "<%= normalized_view_path %>" do
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  class Plugin
+    module Helpers
+      module Rendering
+        extend Support::Extension
+
+        prepend_methods do
+          def render(path = @connection.get(:__endpoint_path) || @connection.path, *args)
+            super(File.join(@connection.app.class.mount_path, path), *args)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/actions/auto_render.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pakyow
+  module Presenter
+    module Actions
+      # Renders a view in the case a controller wasn't called.
+      #
+      class AutoRender
+        def call(connection)
+          connection.app.isolated(:Renderer).render_implicitly(connection)
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/attributes/attribute.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Pakyow
+  module Presenter
+    class Attributes
+      # @api private
+      class Attribute
+        def initialize(value)
+          @value = value
+        end
+
+        def initialize_copy(_)
+          @value = @value.dup
+        end
+
+        def ==(other)
+          @value == other
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/attributes/boolean.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "pakyow/presenter/attributes/string"
+
+module Pakyow
+  module Presenter
+    class Attributes
+      # Boolean is an odd attribute, since we ultimately want it to behave in this way:
+      #
+      #   view.attrs[:checked] = true
+      #   => <input checked="checked" ...>
+      #
+      #   view.attrs[:checked] = false
+      #   => <input ...>
+      #
+      # To support this, +Attributes+ manages setting / removing the value on the
+      # underlying object; all we do is behave like a String.
+      #
+      # @api private
+      class Boolean < String
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/attributes/hash.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+require "pakyow/support/safe_string"
+
+require "pakyow/presenter/attributes/attribute"
+
+module Pakyow
+  module Presenter
+    class Attributes
+      # Wraps the value for a hash-type view attribute (e.g. style).
+      #
+      # Behaves just like a normal +Hash+.
+      #
+      class Hash < Attribute
+        VALUE_SEPARATOR = ":".freeze
+        PAIR_SEPARATOR  = ";".freeze
+
+        WRITE_VALUE_SEPARATOR = ": ".freeze
+        WRITE_PAIR_SEPARATOR  = "; ".freeze
+
+        extend Forwardable
+        def_delegators :@value, :any?, :empty?, :clear
+
+        include Support::SafeStringHelpers
+
+        def include?(key)
+          @value.include?(key.to_s)
+        end
+
+        def value?(value)
+          @value.value?(value.to_s)
+        end
+
+        def [](key)
+          @value[key.to_s]
+        end
+
+        def []=(key, value)
+          @value[ensure_html_safety(key)] = ensure_html_safety(value)
+        end
+
+        def delete(key)
+          @value.delete(key.to_s)
+        end
+
+        def to_s
+          string = ::String.new
+          first = true
+          @value.each do |key, value|
+            unless first
+              string << WRITE_PAIR_SEPARATOR
+            end
+
+            string << key
+            string << WRITE_VALUE_SEPARATOR
+            string << value
+            first = false
+          end
+
+          unless string.empty?
+            string = string + PAIR_SEPARATOR
+          end
+
+          string
+        end
+
+        class << self
+          include Support::SafeStringHelpers
+
+          def parse(value)
+            if value.is_a?(::Hash)
+              new(::Hash[value.map { |k, v| [ensure_html_safety(k), ensure_html_safety(v.to_s)]}])
+            elsif value.respond_to?(:to_s)
+              new(value.to_s.split(PAIR_SEPARATOR).each_with_object({}) { |style, attributes|
+                key, value = style.split(VALUE_SEPARATOR)
+                next unless key && value
+                attributes[ensure_html_safety(key.strip)] = ensure_html_safety(value.strip)
+              })
+            else
+              raise ArgumentError.new("expected value to be a Hash or String")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/attributes/set.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require "set"
+
+require "pakyow/support/safe_string"
+
+require "pakyow/presenter/attributes/attribute"
+
+module Pakyow
+  module Presenter
+    class Attributes
+      # Wraps the value for a set-type view attribute (e.g. class).
+      #
+      # Behaves just like a normal +Set+.
+      #
+      class Set < Attribute
+        VALUE_SEPARATOR = " ".freeze
+
+        extend Forwardable
+        def_delegators :@value, :to_a, :any?, :empty?, :clear
+
+        include Support::SafeStringHelpers
+
+        def include?(value)
+          @value.include?(value.to_s)
+        end
+
+        def <<(value)
+          @value << ensure_html_safety(value)
+        end
+
+        def add(value)
+          @value.add(ensure_html_safety(value))
+        end
+
+        def delete(value)
+          @value.delete(value.to_s)
+        end
+
+        def to_s
+          @value.to_a.join(VALUE_SEPARATOR)
+        end
+
+        class << self
+          include Support::SafeStringHelpers
+
+          def parse(value)
+            if value.is_a?(Array) || value.is_a?(::Set)
+              new(::Set.new(value.map { |v| ensure_html_safety(v) }))
+            elsif value.respond_to?(:to_s)
+              new(::Set.new(value.to_s.split(VALUE_SEPARATOR).map { |v| ensure_html_safety(v) }))
+            else
+              raise ArgumentError.new("expected value to be an Array, Set, or String")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/attributes/string.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+require "pakyow/support/safe_string"
+
+require "pakyow/presenter/attributes/attribute"
+
+module Pakyow
+  module Presenter
+    class Attributes
+      # Wraps the value for a string-type view attribute (e.g. href).
+      #
+      # Behaves just like a normal +String+.
+      #
+      class String < Attribute
+        extend Forwardable
+        def_delegators :@value, :empty?, :include?
+
+        def to_s
+          @value
+        end
+
+        def to_str
+          to_s
+        end
+
+        class << self
+          include Support::SafeStringHelpers
+
+          def parse(value)
+            new(ensure_html_safety(value.to_s))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/presenter/attributes.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+require "pakyow/support/safe_string"
+
+require "pakyow/presenter/attributes/boolean"
+require "pakyow/presenter/attributes/hash"
+require "pakyow/presenter/attributes/set"
+require "pakyow/presenter/attributes/string"
+
+module Pakyow
+  module Presenter
+    class Attributes
+      class << self
+        def typed_value_for_attribute_with_name(value, name)
+          type = type_of_attribute(name.to_sym)
+
+          if value.is_a?(type)
+            value
+          else
+            type.parse(value)
+          end
+        end
+
+        def type_of_attribute(attribute)
+          ATTRIBUTE_TYPES[attribute.to_sym] || ATTRIBUTE_TYPE_DEFAULT
+        end
+
+        def default_value_for_attribute(attribute)
+          type = type_of_attribute(attribute.to_sym)
+          if type == ATTRIBUTE_TYPE_SET
+            ::Set.new
+          elsif type == ATTRIBUTE_TYPE_HASH
+            ::Hash.new
+          elsif type == ATTRIBUTE_TYPE_BOOLEAN
+            false
+          else
+            ::String.new
+          end
+        end
+      end
+
+      # Object for hash attributes
+      ATTRIBUTE_TYPE_HASH = Attributes::Hash
+      # Object for set attributes
+      ATTRIBUTE_TYPE_SET = Attributes::Set
+      # Object for boolean attributes
+      ATTRIBUTE_TYPE_BOOLEAN = Attributes::Boolean
+      # Default attribute object
+      ATTRIBUTE_TYPE_DEFAULT = Attributes::String
+
+      # Maps non-default attributes to their type
+      ATTRIBUTE_TYPES = {
+        class: ATTRIBUTE_TYPE_SET,
+        style: ATTRIBUTE_TYPE_HASH,
+        selected: ATTRIBUTE_TYPE_BOOLEAN,
+        checked: ATTRIBUTE_TYPE_BOOLEAN,
+        disabled: ATTRIBUTE_TYPE_BOOLEAN,
+        readonly: ATTRIBUTE_TYPE_BOOLEAN,
+        multiple: ATTRIBUTE_TYPE_BOOLEAN,
+      }.freeze
+
+      extend Forwardable
+
+      include Support::SafeStringHelpers
+
+      # @!method keys
+      #   Returns keys from {@attributes}.
+      #
+      # @!method []
+      #   Returns value of key from {@attributes}.
+      #
+      # @!method []=
+      #   Returns sets value for key on {@attributes}.
+      #
+      # @!method delete
+      #   Deletes key by name from {@attributes}.
+      #
+      def_delegators :@attributes, :keys, :delete, :each
+
+      # Wraps a hash of view attributes
+      #
+      # @param attributes [Hash]
+      #
+      def initialize(attributes)
+        attributes.wrap do |value, name|
+          Attributes.typed_value_for_attribute_with_name(value, name)
+        end
+
+        @attributes = attributes
+      end
+
+      def [](attribute)
+        attribute = attribute.to_sym
+        attribute_type = self.class.type_of_attribute(attribute)
+
+        if attribute_type == ATTRIBUTE_TYPE_BOOLEAN
+          @attributes.key?(attribute)
+        else
+          @attributes[attribute] ||= attribute_type.new(self.class.default_value_for_attribute(attribute))
+        end
+      end
+
+      def []=(attribute, value)
+        attribute = ensure_html_safety(attribute.to_s).to_sym
+
+        if value.nil?
+          @attributes.delete(attribute)
+        elsif self.class.type_of_attribute(attribute) == ATTRIBUTE_TYPE_BOOLEAN
+          if value
+            @attributes[attribute] = self.class.typed_value_for_attribute_with_name(attribute, attribute)
+          else
+            @attributes.delete(attribute)
+          end
+        else
+          @attributes[attribute] = self.class.typed_value_for_attribute_with_name(value, attribute)
+        end
+      end
+
+      def has?(attribute)
+        @attributes.key?(attribute.to_sym)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+require "pakyow/support/path_version"
+
+module Pakyow
+  module Presenter
+    module Behavior
+      module Config
+        extend Support::Extension
+
+        apply_extension do
+          configurable :presenter do
+            setting :path do
+              File.join(config.root, "frontend")
+            end
+
+            setting :embed_authenticity_token, true
+            setting :version
+
+            configurable :features do
+              setting :streaming, false
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+require "redcarpet"
+
+require "pakyow/support/bindable"
+require "pakyow/support/extension"
+
+require "pakyow/error"
+
+module Pakyow
+  module Presenter
+    module Behavior
+      module ErrorRendering
+        extend Support::Extension
+
+        def self.render_error(error, context)
+          context.respond_to :html do
+            if Pakyow.env?(:production)
+              context.render "/500"
+            else
+              unless error.is_a?(Pakyow::Error)
+                error = Pakyow::Error.build(error)
+              end
+
+              error.extend Support::Bindable
+              context.expose :pw_error, error
+              context.render "/development/500"
+            end
+          end
+        end
+
+        apply_extension do
+          handle 404 do
+            respond_to :html do
+              render "/404"
+            end
+          end
+
+          handle 500 do |error|
+            ErrorRendering.render_error(error, self)
+          end
+
+          handle UnknownPage, as: 404 do |error|
+            if Pakyow.env?(:production)
+              trigger 404
+            else
+              ErrorRendering.render_error(error, self)
+            end
+          end
+
+          handle ImplicitRenderingError, as: 404 do |error|
+            if Pakyow.env?(:production)
+              trigger 404
+            else
+              ErrorRendering.render_error(error, self)
+            end
+          end
+
+          binder :pw_error do
+            def message
+              html_safe(markdown.render(format(object.message)))
+            end
+
+            def contextual_message
+              if object.respond_to?(:contextual_message)
+                html_safe(markdown.render(format(object.contextual_message)))
+              else
+                nil
+              end
+            end
+
+            def details
+              html_safe(markdown.render(format(object.details)))
+            end
+
+            def backtrace
+              html_safe(object.condensed_backtrace.to_a.map { |line|
+                CGI.escape_html(line)
+              }.join("<br>"))
+            end
+
+            def link
+              part :href do
+                object.url
+              end
+
+              part :content do
+                object.url
+              end
+            end
+
+            private
+
+            def markdown
+              @markdown ||= Redcarpet::Markdown.new(
+                Redcarpet::Render::HTML.new({})
+              )
+            end
+
+            def format(string)
+              string = string.dup
+
+              # Replace `foo' with `foo` to render as inline code.
+              #
+              string.dup.scan(/`([^']*)'/).each do |match|
+                string.gsub!("`#{match[0]}'", "`#{match[0]}`")
+              end
+
+              # Format object references as inline code.
+              #
+              string.dup.scan(/#<(.*)>/).each do |match|
+                string.gsub!("#<#{match[0]}>", "`#<#{match[0]}>`")
+              end
+
+              string
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Presenter
+    module Behavior
+      module Exposures
+        extend Support::Extension
+
+        apply_extension do
+          unless ancestors.include?(Plugin)
+            # Copy exposures from the plugin renderer.
+            #
+            after "load.plugins" do
+              plugs.each do |plug|
+                plug.isolated(:Renderer).__expose_fns.each do |fn|
+                  isolated(:Renderer).send(:expose) do |connection|
+                    fn.call(connection, plug)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Presenter
+    module Behavior
+      # Performs a render if a controller is called but doesn't explicitly render.
+      #
+      module ImplicitRendering
+        extend Support::Extension
+
+        apply_extension do
+          after :dispatch, :implicit_render do
+            connection.app.isolated(:Renderer).render_implicitly(connection)
+          end
+        end
+      end
+    end
+  end
+end