pakyow-core 1.0.0.rc5 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b04af7b325d0cc914fdfd8fd532d3ae22d118121c97c2f368af0b661412f120
-  data.tar.gz: a0ad74d7cf6d0b7f83badf14b4048d66f26f52fa0e1208388f6027528f92c80a
+  metadata.gz: b05dfdf492076f0324c4bb0e1567f96c180672f9dd86fb038fdd350bcf4844fe
+  data.tar.gz: bff7b800c753d8b417b22412ac5334e6f6984f55296bb004761ccf83d927d1b2
 SHA512:
-  metadata.gz: 79447f22d448507b3ca69ea4b34288a03dd89895379c1c60c42b41adddedac530138e87622216fcd3c68f89b0369a42b1dfb7a8fcc0fe0c068d7db7772ed12fd
-  data.tar.gz: 8915e4739ee5c1dcdacd54aaf8214b9940fcb6449ec345356d5d3e9742ddfc8a487b787f224943e1d6ace467ad3dcf98db19608b472764d5d78ccf07e143d23c
+  metadata.gz: af3cfb3710fa7552a6d1defefb2158c2b82d57adc4da6e5e7bdb2ed1d66492a04ffda19a3cb9b13ce17adff6e7991536d493b1615b1d3c26c57049c5331f5a5d
+  data.tar.gz: 423e1fe954bbd6e102a1b477b27fe37f8840f51e7bb35b1598a47426300c487ef56cd90b63e22e294f11432c623550c93219eb8a1f2d71f0a7b8a39765daac01

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# UNRELEASED
+
+# 1.0
+
+  * Hello, Web

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

@@ -8,19 +8,19 @@ 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/application/config"
+require "pakyow/application/behavior/sessions"
+require "pakyow/application/behavior/endpoints"
+require "pakyow/application/behavior/pipeline"
+require "pakyow/application/behavior/frameworks"
+require "pakyow/application/behavior/aspects"
+require "pakyow/application/behavior/helpers"
+require "pakyow/application/behavior/rescuing"
+require "pakyow/application/behavior/restarting"
+require "pakyow/application/behavior/isolating"
+require "pakyow/application/behavior/initializers"
+require "pakyow/application/behavior/plugins"
+require "pakyow/application/behavior/operations"
 
 require "pakyow/connection"
 
@@ -29,11 +29,11 @@ module Pakyow
   # 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
+  #   Pakyow::Application.define do
   #     # state shared between all apps goes here
   #   end
   #
-  #   class API < Pakyow::App
+  #   class API < Pakyow::Application
   #     # state for this app goes here
   #   end
   #
@@ -43,7 +43,7 @@ module Pakyow
   #
   # = Pipeline
   #
-  # Requests are received by {App#call}, creating a {Connection} object that
+  # Requests are received by {Application#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
@@ -53,28 +53,28 @@ module Pakyow
   # 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
+  # Application 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.
+  # Application objects can be configured.
   #
-  #   Pakyow::App.configure do
+  #   Pakyow::Application.configure do
   #     config.name = "my-app"
   #   end
   #
   # It's possible to configure for certain environments.
   #
-  #   Pakyow::App.configure :development do
+  #   Pakyow::Application.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
+  #   Pakyow::Application.configure do
   #     config.foo = "bar"
   #   end
   #
@@ -94,14 +94,14 @@ module Pakyow
   #
   # Here's how to log a message after initialize:
   #
-  #   Pakyow::App.after "initialize" do
+  #   Pakyow::Application.after "initialize" do
   #     logger.info "initialized #{self}"
   #   end
   #
   # @see Support::Hookable
   #
-  class App
-    require "pakyow/app/connection"
+  class Application
+    require "pakyow/application/connection"
 
     class << self
       def inherited(subclass)
@@ -117,7 +117,7 @@ module Pakyow
     #
     attr_reader :environment
 
-    # App mount path.
+    # Application mount path.
     #
     attr_reader :mount_path
 
@@ -131,7 +131,7 @@ module Pakyow
     include Support::Definable
     include Support::Pipeline
 
-    include Behavior::Config
+    include Config
     include Behavior::Sessions
     include Behavior::Endpoints
     include Behavior::Pipeline

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+require "pakyow/loader"
+
+module Pakyow
+  class Application
+    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)
+          __load_aspect(aspect, path: path, target: target)
+        end
+
+        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
+end

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

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

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

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

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+require "pakyow/support/safe_string"
+
+require "pakyow/helper"
+
+require "pakyow/application/helpers/app"
+require "pakyow/application/helpers/connection"
+
+module Pakyow
+  class Application
+    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::Application::Helpers::Application,
+                    Support::SafeStringHelpers
+                  ],
+
+                  passive: [
+                    Pakyow::Application::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 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
+
+          # @api private
+          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
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/{environment → application}/behavior/initializers.rb

@@ -3,15 +3,15 @@
 require "pakyow/support/extension"
 
 module Pakyow
-  module Environment
+  class Application
     module Behavior
       module Initializers
         extend Support::Extension
 
         apply_extension do
-          on "configure" do
-            Dir.glob(File.join(Pakyow.config.root, "config/initializers/environment/**/*.rb")).each do |initializer|
-              require initializer
+          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

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+require "pakyow/support/inflector"
+
+module Pakyow
+  class Application
+    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 MyApplication < Pakyow::Application
+          #     isolate Pakyow::Controller do
+          #       def self.special_behavior
+          #         puts "it works"
+          #       end
+          #     end
+          #   end
+          #
+          #   MyApplication::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::Application::subclass+.
+        #
+        def isolated(*args, &block)
+          self.class.isolated(*args, &block)
+        end
+      end
+    end
+  end
+end