pakyow-core 1.0.0.rc5 → 1.0.0

data/lib/pakyow/application/behavior/operations.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+require "pakyow/operation"
+
+module Pakyow
+  class Application
+    module Behavior
+      # Adds support for operations.
+      #
+      module Operations
+        class Lookup
+          def initialize(operations:, app:)
+            operations.each do |operation|
+              define_singleton_method operation.__object_name.name do |values = {}, &block|
+                (block ? Class.new(operation, &block) : operation).new(app: app, **values).perform
+              end
+            end
+          end
+        end
+
+        extend Support::Extension
+
+        apply_extension do
+          on "load" do
+            load_aspect(:operations)
+          end
+
+          attr_reader :operations
+          after "initialize" do
+            @operations = Lookup.new(operations: state(:operation), app: self)
+          end
+        end
+
+        class_methods do
+          # Define operations as stateful when an app is defined.
+          #
+          # @api private
+          def make(*)
+            super.tap do |new_class|
+              new_class.stateful :operation, Operation
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/application/behavior/pipeline.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  class Application
+    module Behavior
+      # Loads default pipeline actions based on included frameworks.
+      #
+      module Pipeline
+        extend Support::Extension
+
+        apply_extension do
+          # We set the priority very low here in case initialize hooks in other frameworks define
+          # state that should be loaded into the pipeline (e.g. controllers).
+          #
+          after "initialize", "initialize.pipeline", priority: -10 do
+            self.class.__pipeline.dup.tap do |pipeline|
+              load_pipeline_defaults(pipeline)
+              @__pipeline = pipeline.callable(self)
+            end
+          end
+        end
+
+        private
+
+        def load_pipeline_defaults(pipeline)
+          if self.class.includes_framework?(:assets)
+            pipeline.action(Actions::Assets::Public, self)
+            pipeline.action(Actions::Assets::Process)
+          end
+
+          if self.class.includes_framework?(:realtime) && Pakyow.config.realtime.server && !is_a?(Plugin)
+            pipeline.action(Actions::Realtime::Upgrader)
+          end
+
+          if self.class.includes_framework?(:routing) && !Pakyow.env?(:prototype)
+            state(:controller).each do |controller|
+              pipeline.action(controller, self)
+            end
+          end
+
+          if instance_variable_defined?(:@plugs)
+            @plugs.each do |plug_instance|
+              pipeline.action(plug_instance)
+            end
+          end
+
+          if self.class.includes_framework?(:presenter)
+            pipeline.action(Actions::Presenter::AutoRender)
+          end
+
+          if self.class.includes_framework?(:routing) && !Pakyow.env?(:prototype) && !is_a?(Plugin)
+            pipeline.action(Actions::Routing::RespondMissing)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/application/behavior/plugins.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require "pakyow/errors"
+
+require "pakyow/support/deep_dup"
+require "pakyow/support/extension"
+
+require "pakyow/plugin/lookup"
+
+module Pakyow
+  class Application
+    module Behavior
+      # @api private
+      module Plugins
+        extend Support::Extension
+
+        using Support::DeepDup
+
+        attr_reader :plugs
+
+        def plug(name, instance = :default)
+          @plugs.find { |plug|
+            plug.class.plugin_name == name && plug.class.__object_name.namespace.parts.last == instance
+          }
+        end
+
+        apply_extension do
+          class_state :__plugs, default: [], inheritable: true
+
+          # Create a dynamic helper that allows plugin helpers to be called in context of a specific plug.
+          #
+          on "initialize" do
+            self.class.register_helper :passive, Module.new {
+              Pakyow.plugins.keys.map.each do |plugin_name|
+                define_method plugin_name do |plug = :default|
+                  app.plugs.send(plugin_name, plug).helper_caller(
+                    app.class.included_helper_context(self),
+                    @connection,
+                    self
+                  )
+                end
+              end
+            }
+          end
+
+          # Setting priority to low gives the app a chance to do any pre-loading
+          # that might affect how plugins are setup.
+          #
+          after "initialize", "load.plugins", priority: :low do
+            @plugs = Plugin::Lookup.new([])
+
+            self.class.__plugs.each do |plug|
+              if self.class.includes_framework?(:presenter)
+                require "pakyow/plugin/helpers/presenter/rendering"
+                plug.register_helper :passive, Plugin::Helpers::Presenter::Rendering
+              end
+
+              # Include frameworks from app.
+              #
+              plug.include_frameworks(
+                *self.class.config.loaded_frameworks
+              )
+
+              # Copy settings from the app config.
+              #
+              plug.config.instance_variable_set(
+                :@__settings, config.__settings.deep_dup.merge(plug.config.__settings)
+              )
+
+              # Copy defaults from the app config.
+              #
+              plug.config.instance_variable_set(
+                :@__defaults, config.__defaults.deep_dup.merge(plug.config.__defaults)
+              )
+
+              # Copy groups from the app config.
+              #
+              plug.config.instance_variable_set(
+                :@__groups, config.__groups.deep_dup.merge(plug.config.__groups)
+              )
+
+              # Override config values that require a specific value.
+              #
+              full_name = [plug.plugin_name]
+              unless plug.__object_name.namespace.parts.last == :default
+                full_name << plug.__object_name.namespace.parts.last
+              end
+
+              plug.config.name = full_name.join("_").to_sym
+
+              # Create a dynamic helper that allows plugin helpers to be called in context of a specific plug.
+              #
+              plug.register_helper :passive, Module.new {
+                Pakyow.plugins.keys.map.each do |plugin_name|
+                  define_method plugin_name do |instance_name = :default|
+                    app.parent.plugs.send(plugin_name, instance_name).helper_caller(
+                      app.class.included_helper_context(self),
+                      @connection,
+                      self
+                    )
+                  end
+                end
+              }
+
+              # Finally, create the plugin instance.
+              #
+              @plugs << plug.new(self)
+            end
+
+            @plugs.finalize
+          end
+
+          after "boot" do
+            @plugs.each(&:booted)
+          end
+        end
+
+        class_methods do
+          attr_reader :__plugs
+
+          def plug(plugin_name, at: "/", as: :default, &block)
+            plugin_name = plugin_name.to_sym
+
+            unless plugin = Pakyow.plugins[plugin_name]
+              raise UnknownPlugin.new_with_message(
+                plugin: plugin_name
+              )
+            end
+
+            app = self
+            plug = plugin.make(
+              "plug",
+              within: Support::ObjectNamespace.new(
+                *__object_name.namespace.parts + [plugin_name, as]
+              ),
+              mount_path: at,
+            ) do
+              # Creates a connection subclass that other frameworks can safely extend.
+              #
+              isolate(app.isolated(:Connection))
+
+              instance_exec(&block) if block
+            end
+
+            @__plugs << plug
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/application/behavior/rescuing.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  class Application
+    module Behavior
+      # Lets an app to be rescued from errors encountered during boot. Once rescued,
+      # an app returns a 500 response with the error that caused it to fail.
+      #
+      module Rescuing
+        extend Support::Extension
+
+        # Error the app was rescued from.
+        #
+        attr_reader :rescued
+
+        # Returns true if the app has been rescued.
+        #
+        def rescued?
+          instance_variable_defined?(:@rescued) && !!@rescued
+        end
+
+        private
+
+        # Enters rescue mode after logging the error.
+        #
+        def rescue!(error)
+          @rescued = error
+
+          performing :rescue do
+            Pakyow.logger.error(error)
+
+            message = <<~ERROR
+              #{self.class} failed to initialize.
+
+              #{error.message}
+              #{error.backtrace.join("\n")}
+            ERROR
+
+            # Override call to always return an errored response.
+            #
+            define_singleton_method :call do |connection|
+              connection.status = 500
+              connection.body = StringIO.new(message)
+              connection.halt
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/application/behavior/restarting.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+require "pakyow/support/silenceable"
+Pakyow::Support::Silenceable.silence_warnings do
+  require "filewatcher"
+end
+
+require "pakyow/support/extension"
+
+module Pakyow
+  class Application
+    module Behavior
+      # Handles triggering restarts in the parent process.
+      #
+      module Restarting
+        extend Support::Extension
+
+        apply_extension do
+          configurable :process do
+            setting :watched_paths, []
+            setting :excluded_paths, []
+            setting :restartable, false
+
+            defaults :development do
+              setting :restartable, true
+            end
+
+            defaults :prototype do
+              setting :restartable, true
+            end
+          end
+
+          after "initialize" do
+            setup_for_restarting
+          end
+
+          # Setting up for restarting even after the app fails to initialize lets
+          # the developer fix the problem and let the server restart on its own.
+          #
+          after "rescue" do
+            setup_for_restarting
+          end
+        end
+
+        private
+
+        def setup_for_restarting
+          if config.process.restartable
+            config.process.watched_paths << File.join(config.src, "**/*.rb")
+            config.process.watched_paths << File.join(config.lib, "**/*.rb")
+
+            # FIXME: this doesn't need to be hardcoded, but instead determined
+            # from the source location when registered with the environment
+            config.process.watched_paths << "./config/application.rb"
+
+            Thread.new do
+              Filewatcher.new(
+                config.process.watched_paths,
+                exclude: config.process.excluded_paths
+              ).watch do |_path, _event|
+                FileUtils.mkdir_p "./tmp"
+                FileUtils.touch "./tmp/restart.txt"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/application/behavior/sessions.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+require "pakyow/support/inflector"
+
+module Pakyow
+  class Application
+    module Behavior
+      module Sessions
+        extend Support::Extension
+
+        apply_extension do
+          attr_reader :session_object, :session_options
+
+          after "configure" do
+            if config.session.enabled
+              require "pakyow/application/connection/session/#{config.session.object}"
+
+              @session_object = Pakyow::Application::Connection::Session.const_get(
+                Support.inflector.classify(config.session.object)
+              )
+
+              @session_options = if config.session.respond_to?(config.session.object)
+                config.session.public_send(config.session.object)
+              else
+                {}
+              end
+            end
+          rescue LoadError => error
+            # TODO: Improve this with a specific "session object missing" error.
+            #
+            raise error
+          end
+        end
+      end
+    end
+  end
+end

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

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

data/lib/pakyow/{app → application}/connection.rb

@@ -5,16 +5,16 @@ require "delegate"
 require "pakyow/support/hookable"
 
 module Pakyow
-  class App
+  class Application
     class Connection < SimpleDelegator
       attr_reader :app
 
       include Support::Hookable
       events :initialize, :dup
 
-      require "pakyow/app/connection/behavior/session"
-      require "pakyow/app/connection/behavior/verifier"
-      require "pakyow/app/connection/behavior/values"
+      require "pakyow/application/connection/behavior/session"
+      require "pakyow/application/connection/behavior/verifier"
+      require "pakyow/application/connection/behavior/values"
 
       include Behavior::Session
       include Behavior::Verifier