pakyow-core 0.11.3 → 1.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 21965299064896d7f6a0fe9754be19d816af9015
-  data.tar.gz: c43ff75f0e740c9d7c68150d45cfcd386a451728
+SHA256:
+  metadata.gz: 6652c3a490f4119178a05144e2bb48e035748d5511453d30c645d8ef8ca2e648
+  data.tar.gz: 6bcc4365fcb0dff053a82dfdd9284ed016c406a4106da652db8e878a57edbc17
 SHA512:
-  metadata.gz: 4fb95b27d158e2bbf7a14d91a3aa3a80e3fc095b26be99b9500d81ffb8f99f551c9e5431fe52b81d11636f04260eb284f65ef8ba3ae899309dc217fa32f3a07a
-  data.tar.gz: f26f87083735c00dd4fe4635a850b9ad1ed4a2a0c73253655c0c73d8404b64f6cdf45fd352bc86bdb02ec2fb53026c8c423f00aad2a759bc048bd2d5a13a933d
+  metadata.gz: 89dfd288361faac6ccb96b94f48ba464208f609271b4e032279bb4450a42c45c4a6a946962627b0672b85fbd19f05bfba20cf3ec4d95eede722d2ffff40f871a
+  data.tar.gz: bd861c99ce96392a1ed9f0870f53206f9a05e0842f8a6500746fac459dfb01ba18ee6690d6008ee633e0938ed3cac7e4a03d45c904591421f671ef9215ca08c1

data/LICENSE

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

@@ -1,6 +1,6 @@
 # pakyow-core
 
-Core routing for Pakyow.
+Core functionality for Pakyow.
 
 # Download
 
@@ -16,14 +16,13 @@ Source code can be downloaded as part of the Pakyow project on Github:
 
 # License
 
-Pakyow Core is released free and open-source under the [MIT
-License](http://opensource.org/licenses/MIT).
+Pakyow Routing is free and open-source under the [LGPLv3 license](https://choosealicense.com/licenses/lgpl-3.0/).
 
 # Support
 
 Documentation is available here:
 
-- http://pakyow.org/docs/routing
+- http://pakyow.org/docs/
 
 Found a bug? Tell us about it here:
 

data/commands/pakyow

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Automatically run with bundler.
+#
+current_path = File.expand_path(".")
+binstub_path = File.join(current_path, "bin/pakyow")
+if !defined?(Bundler) && File.exist?(binstub_path)
+  exec "#{binstub_path} #{ARGV.join(" ")}"
+else
+  require "pakyow/cli"
+  Pakyow::CLI.new
+end

data/lib/pakyow/app/connection/behavior/session.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  class App
+    class Connection
+      module Behavior
+        module Session
+          extend Support::Extension
+
+          def session
+            unless instance_variable_defined?(:@session)
+              @session = build_session
+            end
+
+            @session
+          end
+
+          private
+
+          def build_session
+            if @app.config.session.enabled
+              @app.session_object.new(self, @app.session_options)
+            else
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/app/connection/behavior/values.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "pakyow/support/deep_dup"
+require "pakyow/support/extension"
+
+module Pakyow
+  class App
+    class Connection
+      module Behavior
+        module Values
+          extend Support::Extension
+          using Support::DeepDup
+
+          # @api private
+          attr_reader :values
+
+          apply_extension do
+            after "initialize" do
+              @values = {}
+            end
+
+            after "dup" do
+              @values = @values.deep_dup
+            end
+          end
+
+          def set?(key)
+            @values.key?(key.to_sym)
+          end
+
+          def set(key, value)
+            @values[key.to_sym] = value
+          end
+
+          def get(key)
+            @values[key.to_sym]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/app/connection/behavior/verifier.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+require "pakyow/support/message_verifier"
+
+module Pakyow
+  class App
+    class Connection
+      module Behavior
+        module Verifier
+          extend Support::Extension
+
+          apply_extension do
+            after "initialize" do
+              session[:verifier_key] ||= Support::MessageVerifier.key
+            end
+          end
+
+          def verifier
+            unless instance_variable_defined?(:@verifier)
+              @verifier = Support::MessageVerifier.new(verifier_key)
+            end
+
+            @verifier
+          end
+
+          def verifier_key
+            session[:verifier_key]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/app/connection/session/abstract.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "pakyow/support/indifferentize"
+
+module Pakyow
+  class App
+    class Connection
+      module Session
+        class Abstract < DelegateClass(Support::IndifferentHash)
+          def initialize(connection, options, values = Support::IndifferentHash.new)
+            @connection, @options = connection, options
+            super(values)
+          end
+
+          # Fixes an issue using pp inside a delegator.
+          #
+          def pp(*args)
+            Kernel.pp(*args)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/app/connection/session/cookie.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "base64"
+
+require "pakyow/support/indifferentize"
+
+require "pakyow/app/connection/session/abstract"
+
+module Pakyow
+  class App
+    class Connection
+      module Session
+        class Cookie < Abstract
+          def initialize(connection, options)
+            if (cookie = connection.cookies[options.name]) && !cookie.is_a?(String)
+              super(connection, options, Support::IndifferentHash.new(cookie[:value].to_h))
+              connection.cookies[options.name][:value] = self
+            else
+              super(connection, options, deserialize(connection, options))
+              connection.cookies[options.name] = Support::IndifferentHash.new(
+                domain: options.domain,
+                path: options.path,
+                max_age: options.max_age,
+                expires: options.expires,
+                secure: options.secure,
+                http_only: options.http_only,
+                same_site: options.same_site,
+                value: self
+              )
+
+              # Update the original cookie value so we can compare for changes.
+              #
+              connection.update_request_cookie(options.name, self.dup)
+            end
+          end
+
+          def to_s
+            Base64.urlsafe_encode64(Marshal.dump(to_h))
+          end
+
+          private
+
+          def deserialize(connection, options)
+            if value = connection.cookies[options.name]
+              Support::IndifferentHash.deep(Marshal.load(Base64.urlsafe_decode64(value)))
+            else
+              Support::IndifferentHash.new
+            end
+          rescue StandardError
+            Support::IndifferentHash.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/app/connection.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+require "pakyow/support/hookable"
+
+module Pakyow
+  class App
+    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"
+
+      include Behavior::Session
+      include Behavior::Verifier
+      include Behavior::Values
+
+      def initialize(app, connection)
+        performing :initialize do
+          @app = app; __setobj__(connection)
+        end
+      end
+
+      def initialize_dup(_)
+        performing :dup do
+          super
+        end
+      end
+
+      def method
+        __getobj__.method
+      end
+
+      # Fixes an issue using pp inside a delegator.
+      #
+      def pp(*args)
+        Kernel.pp(*args)
+      end
+
+      # @api private
+      def self.from_connection(connection, **overrides)
+        instance = allocate
+
+        connection.instance_variables.each do |ivar|
+          instance.instance_variable_set(ivar, overrides[ivar] || connection.instance_variable_get(ivar))
+        end
+
+        instance
+      end
+    end
+  end
+end

data/lib/pakyow/app.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require "pakyow/support/definable"
+require "pakyow/support/deep_freeze"
+require "pakyow/support/class_state"
+require "pakyow/support/inspectable"
+require "pakyow/support/hookable"
+require "pakyow/support/configurable"
+require "pakyow/support/pipeline"
+
+require "pakyow/behavior/config"
+require "pakyow/behavior/sessions"
+require "pakyow/behavior/endpoints"
+require "pakyow/behavior/pipeline"
+require "pakyow/behavior/frameworks"
+require "pakyow/behavior/aspects"
+require "pakyow/behavior/helpers"
+require "pakyow/behavior/rescuing"
+require "pakyow/behavior/restarting"
+require "pakyow/behavior/isolating"
+require "pakyow/behavior/initializers"
+require "pakyow/behavior/plugins"
+require "pakyow/behavior/operations"
+
+require "pakyow/connection"
+
+module Pakyow
+  # Pakyow's main application object. Can be defined directly or subclassed to
+  # create multiple application objects, each containing its own state. These
+  # applications can then be mounted as an endpoint within the environment.
+  #
+  #   Pakyow::App.define do
+  #     # state shared between all apps goes here
+  #   end
+  #
+  #   class API < Pakyow::App
+  #     # state for this app goes here
+  #   end
+  #
+  #   Pakyow.configure do
+  #     mount API, at: "/api"
+  #   end
+  #
+  # = Pipeline
+  #
+  # Requests are received by {App#call}, creating a {Connection} object that
+  # provides an interface to the underlying request state. The connection is
+  # pushed through a pipeline. Each pipeline action can modify the connection
+  # and then either 1) allow the connection to hit the next action 2) halt
+  # pipeline execution completely.
+  #
+  # Once the connection exits the pipeline a response is returned. If an action
+  # halted, the connection is finalized and returned, otherwise app assumes
+  # that the connection was unhandled and returns a canned 404 response.
+  #
+  # App also catches any unhandled errors that occur in the pipeline by simply
+  # logging the error and returning a canned 500 response.
+  #
+  # @see Support::Pipeline
+  #
+  # = Configuration
+  #
+  # App objects can be configured.
+  #
+  #   Pakyow::App.configure do
+  #     config.name = "my-app"
+  #   end
+  #
+  # It's possible to configure for certain environments.
+  #
+  #   Pakyow::App.configure :development do
+  #     config.name = "my-dev-app"
+  #   end
+  #
+  # The +app+ config namespace can be extended with your own custom options.
+  #
+  #   Pakyow::App.configure do
+  #     config.foo = "bar"
+  #   end
+  #
+  # @see Support::Configurable
+  #
+  # = Hooks
+  #
+  # Hooks can be defined for the following events:
+  #
+  #   - initialize
+  #   - configure
+  #   - load
+  #   - finalize
+  #   - boot
+  #   - rescue
+  #   - shutdown
+  #
+  # Here's how to log a message after initialize:
+  #
+  #   Pakyow::App.after "initialize" do
+  #     logger.info "initialized #{self}"
+  #   end
+  #
+  # @see Support::Hookable
+  #
+  class App
+    require "pakyow/app/connection"
+
+    class << self
+      def inherited(subclass)
+        super
+
+        # Creates a connection subclass that other frameworks can safely extend.
+        #
+        subclass.isolate Connection
+      end
+    end
+
+    # Environment the app is booted in, e.g. +:development+.
+    #
+    attr_reader :environment
+
+    # App mount path.
+    #
+    attr_reader :mount_path
+
+    include Support::Inspectable
+    inspectable :@environment
+
+    include Support::Hookable
+    events :initialize, :configure, :load, :finalize, :boot, :rescue, :shutdown
+
+    include Support::Configurable
+    include Support::Definable
+    include Support::Pipeline
+
+    include Behavior::Config
+    include Behavior::Sessions
+    include Behavior::Endpoints
+    include Behavior::Pipeline
+    include Behavior::Frameworks
+    include Behavior::Aspects
+    include Behavior::Helpers
+    include Behavior::Rescuing
+    include Behavior::Restarting
+    include Behavior::Isolating
+    include Behavior::Initializers
+    include Behavior::Plugins
+    include Behavior::Operations
+
+    def initialize(environment, mount_path: "/", &block)
+      super()
+
+      @environment, @mount_path, @rescued = environment, mount_path, false
+
+      performing :initialize do
+        performing :configure do
+          configure!(environment)
+        end
+
+        performing :load do
+          $LOAD_PATH.unshift(config.lib)
+        end
+
+        config.version = Support::PathVersion.build(config.src)
+
+        # Call the Pakyow::Definable initializer.
+        #
+        # This ensures that any state registered in the passed block
+        # has the proper priority against instance and global state.
+        #
+        defined!(&block)
+      end
+    rescue ScriptError, StandardError => error
+      rescue!(error)
+    end
+
+    # Called by the environment after it boots the app.
+    #
+    def booted
+      unless rescued?
+        call_hooks :after, :boot
+      end
+    rescue ScriptError, StandardError => error
+      rescue!(error)
+    end
+
+    # Calls the app pipeline with a connection created from the rack env.
+    #
+    def call(connection)
+      app_connection = isolated(:Connection).new(self, connection)
+      super(app_connection)
+    rescue => error
+      if respond_to?(:controller_for_connection)
+        controller_for_connection(app_connection).handle_error(error)
+      else
+        raise error
+      end
+    end
+
+    def shutdown
+      performing :shutdown do; end
+    end
+
+    def _dump(_)
+      Marshal.dump(
+        {
+          name: config.name
+        }
+      )
+    end
+
+    def self._load(state)
+      Pakyow.app(Marshal.load(state)[:name])
+    end
+
+    # @api private
+    def perform(app_connection)
+      @__pipeline.call(app_connection)
+    end
+  end
+end

data/lib/pakyow/behavior/aspects.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+require "pakyow/loader"
+
+module Pakyow
+  module Behavior
+    # Maintains known aspects and loads them.
+    #
+    module Aspects
+      extend Support::Extension
+
+      apply_extension do
+        setting :aspects, []
+
+        after "load" do
+          config.aspects.each do |aspect|
+            load_aspect(aspect)
+          end
+        end
+      end
+
+      class_methods do
+        # Registers an app aspect by name.
+        #
+        def aspect(name)
+          (config.aspects << name.to_sym).uniq!
+        end
+      end
+
+      private
+
+      def load_aspect(aspect, path: File.join(config.src, aspect.to_s), target: self.class)
+        Dir.glob(File.join(path, "*.rb")) do |file_path|
+          Loader.new(file_path).call(target)
+        end
+
+        Dir.glob(File.join(path, "*")).select { |sub_path| File.directory?(sub_path) }.each do |directory|
+          load_aspect(aspect, path: directory, target: target)
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/behavior/config.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+require "pakyow/support/path_version"
+
+module Pakyow
+  module Behavior
+    module Config
+      extend Support::Extension
+
+      apply_extension do
+        setting :name, :pakyow
+        setting :version
+
+        setting :root do
+          Pakyow.config.root
+        end
+
+        setting :src do
+          File.join(config.root, "backend")
+        end
+
+        setting :lib do
+          File.join(config.src, "lib")
+        end
+
+        configurable :tasks do
+          setting :prelaunch, []
+        end
+
+        configurable :session do
+          setting :enabled, true
+          setting :object, :cookie
+
+          configurable :cookie do
+            setting :name do
+              "#{config.name}.session"
+            end
+
+            setting :domain do
+              Pakyow.config.cookies.domain
+            end
+
+            setting :path do
+              Pakyow.config.cookies.path
+            end
+
+            setting :max_age do
+              Pakyow.config.cookies.max_age
+            end
+
+            setting :expires do
+              Pakyow.config.cookies.expires
+            end
+
+            setting :secure do
+              Pakyow.config.cookies.secure
+            end
+
+            setting :http_only do
+              Pakyow.config.cookies.http_only
+            end
+
+            setting :same_site do
+              Pakyow.config.cookies.same_site
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/behavior/endpoints.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+require "pakyow/endpoints"
+
+module Pakyow
+  module Behavior
+    module Endpoints
+      extend Support::Extension
+
+      apply_extension do
+        after "initialize" do
+          load_endpoints
+        end
+      end
+
+      prepend_methods do
+        def initialize(*)
+          @endpoints = ::Pakyow::Endpoints.new
+
+          super
+        end
+      end
+
+      # Instance of {Endpoints} for path building.
+      #
+      attr_reader :endpoints
+
+      private
+
+      def load_endpoints
+        state.values.each do |state_object|
+          state_object.instances.each do |state_instance|
+            @endpoints.load(state_instance)
+          end
+        end
+      end
+    end
+  end
+end