pakyow-presenter 1.0.0.rc5 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9c5ded933f632e265d0b327876438738c77bce50a049293a2983686edd48906
-  data.tar.gz: 0e9f53b49ed7459f2fccd800f25fdbe23ee9569b1cace8c7cdc10886316bd913
+  metadata.gz: 684f68ffcb0cc1beb6e24ffd407b5dcd71238cd08342ebcab0aed8f53329e28a
+  data.tar.gz: 582b3a284d885de7587b72dbffe85f8d5c8a6119d7b6ab56c0b96f8422d47249
 SHA512:
-  metadata.gz: 19eac50259216de2e775bf7d149cae08c0fc464ad42f2cceca3928523f2a424a374aee67863eb22e85e8dfd361b8943183a81482bd4eccbfba9ad322dbc2db43
-  data.tar.gz: 4ab0bad959c389aa8bbcf36fccfe5b6f096ab454d937a36b58bec6d86a3a2d564362e334477cb239fb74e8cbf0387a3b469b51bea9136a14a8f6cf3df6cd2be6
+  metadata.gz: 116abaea114cf8c7779de420e803ce9fd72f62ccbdd7060425a28cf18093e031780bca8f7cc23812fcca1c02a2aebded8e3d3d3b919b71051d4a9e4ebef785e8
+  data.tar.gz: 8b450ea512a99c840560da6565501f9999334ca82d2391a6b75ec1cb16d30305cc248da55515aced259069c713a6c64af244c4a1d85c61893f5123c2358b9a39

data/CHANGELOG.md

@@ -1,110 +1,5 @@
-# 0.11.0
+# UNRELEASED
 
-  * Fixes several bugs related to nested partials
-  * Reprocesses view contents with html processor
-  * Fixes a bug causing partials not to be duped
-  * Automatically defines bindings as restful
-  * Introduces binding parts
-  * Fixes a bug removing a node from StringDoc
-  * Renames `app.all_views_visible` config option to `presenter.require_route`
-  * Fixes some bugs caused by not properly duping view objects
-  * Replaces Nokogiri with Oga
-  * Moves everything into the Pakyow namespace
-  * Adds support for versioned props
-  * Prioritize root view paths over child paths
-  * ViewVersion state is now properly updated when matching
+# 1.0
 
-# 0.10.0 / 2015-10-19
-
-  * Adds precomposition to composer
-  * Fixes binding action for nested resources
-  * Fixes variable name in remap_partials
-  * Setup form on `_root` rather than `action` prop
-  * Handles view paths that don't define an `index` view
-  * Adds `ViewCollection#scoped_as` convenience method
-  * Renames default template to `default` (instead of `pakyow`)
-  * Adds convenience method to check for view existence
-  * Support binding hashes with `String` keys
-  * Fixes a bug when a node is inserted after another node that also has a sibling
-  * Fixes binding to props nested in partial
-  * Now allows views for a view store to be fragmented across multiple directories
-  * Adds versioned scopes with auto empty handling
-  * Now sets scope name explicitly for `ViewCollection` built from a `View`
-  * Adds a helper method for checking if a attribute exists
-  * Adds support for components and channels (realtime ftw)
-  * Adds id of object to scoped node during binding
-  * Fixes a bug with view contexts in presenter helpers
-  * Ported all tests to rspec
-  * Fixes a bug finding scopes in a nested partial
-  * Fixes a bug where unused partials still being included as parts in the composer
-  * Fixes a `StringDoc` bug when structure is empty
-  * Fixes bug preventing passed binding functions from being used when no binding sets are registered for scope
-  * Fixes namespace collisions
-  * Fixes error when matching data empty collection
-  * Renames `inner_html` to `html`
-  * Now only reloads a view store if the contents have changed
-  * Yields `prop` node rather than full `scope` in bindings
-  * Handles `AttributesCollection#<<` for all use cases
-  * Adds `to_html` method on composer
-  * No longer complains about a view store missing a template directory
-  * Now finds view info for a path that doesn't contain a page
-  * Allows root nodes to be appendable in string doc
-  * Removes nokogiri doc
-
-# 0.9.1 / 2014-12-06
-
-  * Fixes bug where name attribute wasn't set on form fields when binding without a value
-  * Fixes bug causing all partials (not just available ones) to be defined as view parts
-  * Fixes bug causing form action binding to break
-
-# 0.9.0 / 2014-11-09
-
-  * Introduces StringDoc, replacing Nokogiri for view rendering with a performant alternative
-  * Adds the ability to set an empty first option in bindings
-  * Remove the annoying "no content" for container log message
-  * Binding context must now be explicitly passed when binding
-  * Yield bindable value before bindable in view binding fns
-  * Fixes bug causing non-html view contents to be processed twice
-  * Removes support for Ruby versions < 2.0.0
-
-# 0.8.0 / 2014-03-02
-
-  * Major rewrite, including new view syntax, composer, and transformation api
-
-# 0.7.2 / 2012-02-29
-
-  * No changes -- bumped version to be consistent
-
-# 0.7.1 / 2012-01-08
-
-  * View caching fixes
-  * Changed binder to allow definition for multiple endpoints
-  * Changed in_context to accept context as block argument
-  * Changed action binder to add leading slash if needed
-  * Change to allow a view's content to be set to nil
-  * Fixed Views#find method
-
-# 0.7.0 / 2011-11-19
-
-  * Cleaned up core/presenter interface
-  * Optimized view caching
-  * Binding occurs on the label an object is being bound to, not the object type
-  * Root view override in index directories no longer specify a root view for siblings
-  * Fixed problem binding to a checkbox who’s value attribute is not set
-
-# 0.6.3 / 2011-09-13
-
-  * Fixes binding to bindings defined by HTML 'name' attribute
-
-# 0.6.2 / 2011-08-20
-
-  * Fixes issue binding object to root nodes
-  * JRuby Support
-
-# 0.6.1 / 2011-08-20
-
-  * Fixes gemspec problem
-
-# 0.6.0 / 2011-08-20
-
- * Initial gem release of 0.6.0 codebase
+  * Hello, Web

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pakyow
+  class Application
+    module Actions
+      module Presenter
+        # 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
+end

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+require "redcarpet"
+
+require "pakyow/support/bindable"
+require "pakyow/support/extension"
+
+require "pakyow/error"
+
+module Pakyow
+  class Application
+    module Behavior
+      module Presenter
+        module ErrorRendering
+          extend Support::Extension
+
+          # @api private
+          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 Pakyow::Presenter::UnknownPage, as: 404 do |error|
+              if Pakyow.env?(:production)
+                trigger 404
+              else
+                ErrorRendering.render_error(error, self)
+              end
+            end
+
+            handle Pakyow::Presenter::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
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  class Application
+    module Behavior
+      module Presenter
+        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
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  class Application
+    module Behavior
+      module Presenter
+        # 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
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+require "pakyow/plugin"
+
+module Pakyow
+  class Application
+    module Behavior
+      module Presenter
+        module Initializing
+          extend Support::Extension
+
+          apply_extension do
+            unless ancestors.include?(Plugin)
+              after "initialize", "initialize.presenter", priority: :high do
+                state(:templates) << Pakyow::Presenter::Templates.new(
+                  :default,
+                  config.presenter.path,
+                  processor: Pakyow::Presenter::ProcessorCaller.new(
+                    state(:processor).map { |processor|
+                      processor.new(self)
+                    }
+                  )
+                )
+
+                state(:templates) << Pakyow::Presenter::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
+
+            # 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) << Pakyow::Presenter::Renderer::Behavior::RenderComponents.find_or_build_compound_presenter(
+                          self, component_classes
+                        )
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  class Application
+    module Behavior
+      module Presenter
+        module Modes
+          # @api private
+          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
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  class Application
+    module Behavior
+      module Presenter
+        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
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  class Application
+    module Behavior
+      module Presenter
+        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
+end

data/lib/pakyow/{presenter/behavior/config.rb → application/config/presenter.rb}

@@ -4,9 +4,9 @@ require "pakyow/support/extension"
 require "pakyow/support/path_version"
 
 module Pakyow
-  module Presenter
-    module Behavior
-      module Config
+  class Application
+    module Config
+      module Presenter
         extend Support::Extension
 
         apply_extension do

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Pakyow
+  class Application
+    module Helpers
+      module Presenter
+        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
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  class Plugin
+    module Helpers
+      module Presenter
+        module Rendering
+          extend Support::Extension
+
+          prepend_methods do
+            def render(view_path = nil, as: nil, modes: [:default])
+              super(File.join(@connection.app.class.mount_path, view_path), as: as, modes: modes)
+            rescue Pakyow::Presenter::UnknownPage
+              # Try rendering the view from the app.
+              #
+              connection = @connection.app.parent.isolated(:Connection).from_connection(
+                @connection, :@app => @connection.app.parent
+              )
+
+              connection.app.isolated(:Renderer).render(
+                connection,
+                view_path: view_path,
+                presenter_path: as,
+                modes: modes
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end