pakyow-routing 1.0.0.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b2a9aed8421bd98e8fabc612f53b18d697a83a806bb1610d46091eba749d40f3
+  data.tar.gz: 5fe8c0e699df3ef047fd27452a3f53112d445d844ffbfddafadf6011c05d5f17
+SHA512:
+  metadata.gz: e32e28a4d7cbe530e914852b491e7095ecbc7a9a03f3120be638eac9070292f6aff9a58a25304659831dbd1475c8753321b9fe281215369546dd72fa0b04accd
+  data.tar.gz: 66461e2cb4f2aeb6a39c608d2e61176281793f95bbbeebcfbd65e5b5d6e25d181816f7ee58b60a3ecb744274d9da780c53e0640bf92411dfaf4464de41803719

data/CHANGELOG.md

@@ -0,0 +1,137 @@
+# 1.0.0
+
+  * IMPROVED helpers by removing `Helpers::App` and `Helpers::Context`. Instead,
+    `Helpers` is included only into `CallContext`. Extensions to `App` is now
+    considered an edge-case and should be done through other normal means.
+  * IMPROVED hooks by removing `Helpers::Hooks` in favor of `Support::Hookable`.
+  * ADDED verbose log level.
+  * CHANGED default production log level to `info`.
+
+# 0.11.3
+
+  * Adds the ability to `send` StringIO objects
+
+# 0.11.1
+
+  * Includes `Pakyow::Helpers` into `Pakyow::App`
+
+# 0.11.0
+
+  * Adds a `configure` hook for evaluating code before/after configuring app
+  * The `Pakyow::App.define` method now returns the defined app
+  * Explicitly requires `pakyow-support` so core works on its own
+  * Adds a convenience method for defining a restful resource
+  * Adds a `reload` hook for evaluating code before/after reloading app
+  * Better support for sending any IO object or String data
+  * Defaults to `global` when defining app configuration
+  * Adds a new `reloader` config namespace
+  * Redirects requests with `//` to single-slash path
+  * Adds the ability to easily disable middleware
+  * Bundles and configures middleware for session handling
+  * Automatically removes the trailing `/` in request path
+  * Now loads the global config options before env-specific options
+  * Adds the source directory to the load path
+  * Sets default Content-Type to utf-8
+  * Moves everything into the Pakyow namespace
+  * Changes to allow error hooks to halt execution
+  * Adds a convenience method for checking the existence of a route
+  * Protects against internal failures when calling a route with an unknown method
+  * Fixes route hook execution order, prioritizing hooks defined in outer scopes
+
+# 0.10.2 / 2015-11-15
+
+  * Fixes issues presenting error views from gem
+  * Fixes a bug causing routes to inherit hooks from previously defined routes
+  * No longer resets the working context when redirecting or sending a file
+  * Uses Rack's delete_cookie method rather than unset_cookie
+
+# 0.10.0 / 2015-10-19
+
+  * Adds nested route groups / namespaces inherit hooks
+  * Static files are now served by default
+  * Consistently handles externally defined config options
+  * Adds post-processing step to route template expansions
+  * Prevents the logger from breaking when no log to write to
+  * Prevents resouces config from being reset on access
+  * Don't add query params when route building
+  * Fixes bug when defining nested restful routes
+  * Support passing group + route name to `redir` and `reroute`
+  * Updated status code names
+  * Sets mime type of response when setting type
+  * Exposes content type on response object
+  * Adds support for `pakyow.data` in Rack env
+  * Runs global config *after* local config
+  * Makes JSON body available in request params
+  * Fixes a bug in app reloading
+  * Ported all tests to rspec
+  * Adds the ability to halt execution in a 500 handler
+  * Fixes namespace collisions
+  * Use app's template for displaying Pakyow error views
+  * Provides default values for helpers when no context available
+  * Use `Bundler.require` to load dependencies in global config block
+  * Respects before hook order
+  * No longer overrides user-provided type when sending data/files
+
+# 0.9.1 / 2014-12-06
+
+  * No changes -- bumped version to be consistent
+
+# 0.9.0 / 2014-11-09
+
+  * Renames restful "remove" action to "delete"
+  * Improves app generator bundle install by showing progress
+  * Complete refactor of config handling with a shiny DSL
+  * Includes pakyow-rake as a dependency, and updates the generated Rakefile
+  * Removes support for Ruby versions < 2.0.0
+
+# 0.8.0 / 2014-03-02
+
+  * Major rewrite, including changes to app definition and routing
+
+# 0.7.2 / 2012-02-29
+
+  * Application server shuts down gracefully
+  * Fix issue requesting route with format
+  * Fix issue surrounding ignore_routes -- now matches request path in all cases
+
+# 0.7.1 / 2012-01-08
+
+  * Changed loader to only load ruby files
+  * Moved session from app to request
+  * Replaced autoload with require
+  * Fixed generated rackup to use builder
+  * Fixed generated rakefile so it runs in a specific environment
+  * Fixed issue running with ignore_routes turned on
+
+# 0.7.0 / 2011-11-19
+
+  * Added middleware for logging, static, and reloading
+  * Added invoke_route! and invoke_handler! methods
+  * Added before, after, and around hooks to routes
+  * Added pakyow console
+  * Changed methods that modify request/response life cycle to bang methods
+  * Fixed regex route error (was removing route vars)
+  * App file is no longer loaded twice upon initialization
+  * Fix cookie creation when cookie is a non-nil value but not a String
+
+# 0.6.3 / 2011-09-13
+
+  * Fixes several load path issues
+  * Fixes gemspecs so gem can be built/used from anywhere
+  * Fixes inconsistency with with request.params having string and symbol keys
+  * Fixes loading of middleware when staging application (simplifies rackup)
+
+# 0.6.2 / 2011-08-20
+
+  * Fixes issue running pakyow server on Windows
+  * Fixes several issues related to error handlers
+  * Fixes an issue when using alphanumeric ids in restful routes
+  * 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

data/LICENSE

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

@@ -0,0 +1,33 @@
+# pakyow-routing
+
+Routing for Pakyow.
+
+# Download
+
+The latest version of Pakyow Routing can be installed with RubyGems:
+
+```
+gem install pakyow-routing
+```
+
+Source code can be downloaded as part of the Pakyow project on Github:
+
+- https://github.com/pakyow/pakyow/tree/master/pakyow-routing
+
+# License
+
+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
+
+Found a bug? Tell us about it here:
+
+- https://github.com/pakyow/pakyow/issues
+
+We'd love to have you in the community:
+
+- http://pakyow.org/get-involved

data/lib/pakyow/behavior/definition.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Behavior
+    module Definition
+      extend Support::Extension
+
+      apply_extension do
+        include Methods
+        extend Methods
+      end
+
+      module Methods
+        # Defines a RESTful resource.
+        #
+        # @see Routing::Extension::Resource
+        #
+        def resource(name, path, *args, param: Pakyow::Routing::Extension::Resource::DEFAULT_PARAM, &block)
+          controller name, path, *args do
+            expand_within(:resource, param: param, &block)
+          end
+        end
+
+        # Registers an error handler automatically available in all Controller instances.
+        #
+        # @see Routing::Behavior::ErrorHandling#handle
+        def handle(name_exception_or_code, as: nil, &block)
+          const_get(:Controller).handle(name_exception_or_code, as: as, &block)
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/routing/actions/respond_missing.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pakyow
+  module Routing
+    module Actions
+      class RespondMissing
+        def call(connection)
+          connection.app.controller_for_connection(connection).trigger(404)
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/routing/controller/behavior/error_handling.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "pakyow/support/class_state"
+require "pakyow/support/deep_dup"
+require "pakyow/support/extension"
+
+require "pakyow/connection/statuses"
+
+module Pakyow
+  module Routing
+    module Behavior
+      module ErrorHandling
+        extend Support::Extension
+
+        apply_extension do
+          class_state :handlers, default: {}, inheritable: true
+          class_state :exceptions, default: {}, inheritable: true
+
+          include API
+          extend API
+        end
+
+        prepend_methods do
+          using Support::DeepDup
+
+          def initialize(*)
+            @handlers = self.class.handlers.deep_dup
+            @exceptions = self.class.exceptions.deep_dup
+
+            super
+          end
+        end
+
+        # Calls the handler for a particular http status code.
+        #
+        def trigger(name_or_code)
+          code = Connection::Statuses.code(name_or_code)
+          connection.status = code
+          trigger_for_code(code)
+        end
+
+        def handle_error(error)
+          connection.error = error
+          connection.status = 500
+
+          catch :halt do
+            call_handlers_with_args(
+              exceptions_for_class(error.class) || handlers_for_code(500),
+              error
+            )
+          end
+
+          halt
+        end
+
+        private
+
+        def call_handlers_with_args(handlers, *args)
+          handlers.to_a.reverse.each do |status_code, handler|
+            catch :reject do
+              connection.status = status_code
+
+              if handler
+                instance_exec(*args, &handler)
+              end
+
+              halt
+            end
+          end
+        end
+
+        def trigger_for_code(code)
+          call_handlers_with_args(handlers_for_code(code)); halt
+        end
+
+        def handlers_for_code(code)
+          @handlers[code]
+        end
+
+        def exceptions_for_class(klass)
+          @exceptions[klass]
+        end
+
+        module API
+          # Registers an error handler used within a controller or request lifecycle.
+          #
+          # @example Defining for a controller:
+          #   Pakyow::App.controller do
+          #     handle 500 do
+          #       # build and send a response for `request.error`
+          #     end
+          #
+          #     default do
+          #       # do something that might cause an error
+          #     end
+          #   end
+          #
+          # @example Defining for a request lifecycle:
+          #   Pakyow::App.controller do
+          #     default do
+          #       handle 500 do
+          #         # build and send a response for `request.error`
+          #       end
+          #
+          #       # do something that might cause an error
+          #     end
+          #   end
+          #
+          # @example Handling by status code:
+          #   handle 500 do
+          #     # build and send a response
+          #   end
+          #
+          #   default do
+          #     trigger 500
+          #   end
+          #
+          # @example Handling by status name:
+          #   handle :forbidden do
+          #     # build and send a response
+          #   end
+          #
+          #   default do
+          #     trigger 403 # or, `trigger :forbidden`
+          #   end
+          #
+          # @example Handling an exception:
+          #   handle Sequel::NoMatchingRow, as: 404 do
+          #     # build and send a response
+          #   end
+          #
+          #   default do
+          #     raise Sequel::NoMatchingRow
+          #   end
+          #
+          def handle(name_exception_or_code, as: nil, &block)
+            if name_exception_or_code.is_a?(Class) && name_exception_or_code.ancestors.include?(Exception)
+              raise ArgumentError, "status code is required" if as.nil?
+              (@exceptions[name_exception_or_code] ||= []) << [Connection::Statuses.code(as), block]
+            else
+              status_code = Connection::Statuses.code(name_exception_or_code)
+              (@handlers[status_code] ||= []) << [as || status_code, block]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/routing/controller/behavior/param_verification.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+require "pakyow/errors"
+
+require "pakyow/behavior/verification"
+
+module Pakyow
+  module Routing
+    module Behavior
+      module ParamVerification
+        extend Support::Extension
+
+        apply_extension do
+          class_state :__allowed_params, default: [], inheritable: true
+
+          include Pakyow::Behavior::Verification
+
+          # Define the data we wish to verify.
+          #
+          verifies :params
+
+          # Handle all invalid data errors as a bad request, by default.
+          #
+          handle InvalidData, as: :bad_request
+        end
+
+        class_methods do
+          # Perform input verification before one or more routes, identified by name.
+          #
+          # @see Pakyow::Verifier
+          #
+          # @api public
+          def verify(*names, &block)
+            verification_method_name = :"verify_#{names.join("_")}"
+
+            define_method verification_method_name do
+              local_allowed_params = self.class.__allowed_params
+
+              verify do
+                local_allowed_params.each do |allowed_param|
+                  optional allowed_param
+                end
+
+                instance_exec(&block)
+              end
+            end
+
+            action verification_method_name, only: names
+          end
+
+          # Set one or more params as optional in all routes.
+          #
+          def allow_params(*names)
+            @__allowed_params.concat(names).uniq!
+          end
+        end
+
+        prepend_methods do
+          def verify(values = nil, &block)
+            local_allowed_params = self.class.__allowed_params
+
+            super do
+              local_allowed_params.each do |allowed_param|
+                optional allowed_param
+              end
+
+              instance_exec(&block)
+            end
+          end
+        end
+      end
+    end
+  end
+end