pakyow-core 0.11.3 → 1.0.0.rc1

data/lib/pakyow/behavior/frameworks.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Behavior
+    # Manages {Framework} instances.
+    #
+    module Frameworks
+      extend Support::Extension
+
+      apply_extension do
+        setting :loaded_frameworks, []
+      end
+
+      class_methods do
+        # Includes one or more frameworks into the app class.
+        #
+        def include_frameworks(*frameworks)
+          tap do
+            frameworks.each do |framework_name|
+              include_framework(framework_name)
+            end
+          end
+        end
+
+        # Includes a framework into the app class.
+        #
+        def include_framework(framework_name)
+          framework_name = framework_name.to_sym
+          Pakyow.frameworks.fetch(framework_name).new(self).boot
+          (config.loaded_frameworks << framework_name).uniq!
+        rescue KeyError => error
+          raise UnknownFramework.build(error, framework: framework_name)
+        end
+
+        # Returns true if +framework+ is loaded.
+        #
+        def includes_framework?(framework_name)
+          config.loaded_frameworks.include?(framework_name.to_sym)
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/behavior/helpers.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+require "pakyow/support/makeable"
+require "pakyow/support/safe_string"
+
+require "pakyow/helpers/app"
+require "pakyow/helpers/connection"
+
+module Pakyow
+  module Helper
+    extend Support::Makeable
+  end
+
+  module Behavior
+    # Maintains a list of helper modules, with code for including helpers of a type into an object.
+    #
+    # Helpers are either global, passive, or active. Global helpers contain utility methods or
+    # methods that need application-level state. Passive helpers can access state on the connection
+    # but never change connection state, which active helpers are solely responsible for doing.
+    #
+    module Helpers
+      extend Support::Extension
+
+      apply_extension do
+        class_state :__included_helpers, default: {}, inheritable: true
+
+        setting :helpers,
+                global: [
+                  Pakyow::Helpers::App,
+                  Support::SafeStringHelpers
+                ],
+
+                passive: [
+                  Pakyow::Helpers::Connection
+                ],
+
+                active: []
+
+        on "load" do
+          # Helpers are loaded first so that other aspects inherit them.
+          #
+          load_aspect(:helpers)
+
+          self.class.state(:helper).each do |helper|
+            context = if helper.instance_variable_defined?(:@type)
+              helper.instance_variable_get(:@type)
+            else
+              :global
+            end
+
+            self.class.register_helper(context, helper)
+          end
+        end
+
+        # Define helpers as stateful after an app is made.
+        #
+        after "make", priority: :high do
+          stateful :helper, Helper
+        end
+      end
+
+      class_methods do
+        # Registers a helper module to be loaded on defined endpoints.
+        #
+        def register_helper(context, helper_module)
+          (config.helpers[context.to_sym] << helper_module).uniq!
+        end
+
+        # Includes helpers of a particular context into an object. Global helpers
+        # will automatically be included into active and passive contexts, and
+        # passive helpers will automatically be included into the active context.
+        #
+        def include_helpers(context, object)
+          @__included_helpers[object] = context
+
+          helpers(context.to_sym).each do |helper|
+            object.include helper
+          end
+        end
+
+        def included_helper_context(object)
+          @__included_helpers.each_pair do |object_with_helpers, context|
+            return context if object.is_a?(object_with_helpers)
+          end
+
+          nil
+        end
+
+        def helpers(context)
+          case context.to_sym
+          when :global
+            config.helpers[:global]
+          when :passive
+            config.helpers[:global] + config.helpers[:passive]
+          when :active
+            config.helpers[:global] + config.helpers[:passive] + config.helpers[:active]
+          else
+            raise UnknownHelperContext.new_with_message(
+              context: context
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/behavior/initializers.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Behavior
+    module Initializers
+      extend Support::Extension
+
+      apply_extension do
+        after "make" do
+          Dir.glob(File.join(config.root, "config/initializers/application/**/*.rb")).each do |initializer|
+            class_eval(File.read(initializer), initializer)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/behavior/isolating.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+require "pakyow/support/inflector"
+
+module Pakyow
+  module Behavior
+    # Helps manage isolated classes for an app.
+    #
+    module Isolating
+      extend Support::Extension
+
+      class_methods do
+        # Creates a subclass within the app's namespace.
+        #
+        # @example
+        #   class MyApp < Pakyow::App
+        #     isolate Pakyow::Controller do
+        #       def self.special_behavior
+        #         puts "it works"
+        #       end
+        #     end
+        #   end
+        #
+        #   MyApp::Controller.special_behavior
+        #   => it works
+        #
+        #   Pakyow::Controller
+        #   => NoMethodError (undefined method `special_behavior' for Pakyow::Controller:Class)
+        #
+        def isolate(class_to_isolate, &block)
+          isolated_class_name = Support.inflector.demodulize(class_to_isolate.to_s).to_sym
+
+          unless const_defined?(isolated_class_name, false)
+            const_set(isolated_class_name, Class.new(class_to_isolate))
+          end
+
+          isolated(isolated_class_name).tap do |defined_subclass|
+            defined_subclass.class_eval(&block) if block_given?
+          end
+        end
+
+        # Returns true if the class name is isolated.
+        #
+        def isolated?(class_name)
+          const_defined?(class_name)
+        end
+
+        # Returns the isolated class, evaluating the block (if provided).
+        #
+        def isolated(class_name, &block)
+          if isolated?(class_name)
+            const_get(class_name).tap do |isolated_class|
+              isolated_class.class_eval(&block) if block_given?
+            end
+          else
+            nil
+          end
+        end
+      end
+
+      # Convenience method for +Pakyow::App::subclass+.
+      #
+      def isolated(*args, &block)
+        self.class.isolated(*args, &block)
+      end
+    end
+  end
+end

data/lib/pakyow/behavior/operations.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+require "pakyow/operation"
+
+module Pakyow
+  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.
+        #
+        def make(*)
+          super.tap do |new_class|
+            new_class.stateful :operation, Operation
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/behavior/pipeline.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  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(Assets::Actions::Public, self)
+          pipeline.action(Assets::Actions::Process)
+        end
+
+        if self.class.includes_framework?(:realtime) && Pakyow.config.realtime.server && !is_a?(Plugin)
+          pipeline.action(Realtime::Actions::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(Presenter::Actions::AutoRender)
+        end
+
+        if self.class.includes_framework?(:routing) && !Pakyow.env?(:prototype) && !is_a?(Plugin)
+          pipeline.action(Routing::Actions::RespondMissing)
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/behavior/plugins.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require "pakyow/errors"
+
+require "pakyow/support/deep_dup"
+require "pakyow/support/extension"
+
+require "pakyow/plugin/lookup"
+
+module Pakyow
+  module Behavior
+    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/rendering"
+              plug.register_helper :passive, Plugin::Helpers::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

data/lib/pakyow/behavior/rescuing.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  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

data/lib/pakyow/behavior/restarting.rb

@@ -0,0 +1,68 @@
+# 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
+  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
+
+      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

data/lib/pakyow/behavior/sessions.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+require "pakyow/support/inflector"
+
+module Pakyow
+  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/app/connection/session/#{config.session.object}"
+
+            @session_object = Pakyow::App::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: raise an unknown session object error...
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/behavior/verification.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "pakyow/support/class_state"
+require "pakyow/support/deep_dup"
+require "pakyow/support/extension"
+
+require "pakyow/errors"
+require "pakyow/verifier"
+
+module Pakyow
+  module Behavior
+    module Verification
+      extend Support::Extension
+      using Support::DeepDup
+
+      def verify(values = nil, &block)
+        unless values
+          if self.class.__object_name_to_verify.nil?
+            raise "Expected values to be passed"
+          else
+            values = public_send(self.class.__object_name_to_verify)
+          end
+        end
+
+        original_values = values.deep_dup
+        result = Verifier.new(&block).call(values, context: self)
+
+        unless result.verified?
+          error = InvalidData.new_with_message(:verification)
+          error.context = { object: original_values, result: result }
+          raise error
+        end
+      end
+
+      apply_extension do
+        extend Support::ClassState
+        class_state :__object_name_to_verify, inheritable: true
+      end
+
+      class_methods do
+        def verifies(object)
+          @__object_name_to_verify = object
+        end
+      end
+    end
+  end
+end