raindeer 0.9.9 → 0.9.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd04746632169d1c9898fe5f95552c13660f45ae76f039b4863a2eb58eb000bb
-  data.tar.gz: 1582e33cd80570a8d8a2164c3d8236515738f75e7a63204fbc50c7edcf195e4d
+  metadata.gz: a6acad3a557af79fc084ff7e8eddc2e0db5595ba7980dbf67b1ddbfbb702fd5d
+  data.tar.gz: 71af14856b712fed992b81b5ea38ee097bacf06ed5385b018edb424530ce1dd0
 SHA512:
-  metadata.gz: 7d5770cbfc5d25cefb54ae0273c89acac0220b516ae41014741b6d9bedb1515806ae198c60e41e694a10823e694766b7fb841c588e16fa1a1326bcc381493d48
-  data.tar.gz: 557024f64d7dd9c40c5c1ce1d19f803995aa28db1d9ce5381b25499135e2aef0e2b42e8ffb479313bc2172d8b1b851db5edf4cc89b0a5925dbd9d3bae75d3621
+  metadata.gz: b23946d114027b0da1f7e4d4c685676d96a44c5fbfe345365e97f1963c805cde33613e8f67a79d67aed768b08592ed5faf7a67fe817713b170337c84cb8861a6
+  data.tar.gz: 123024ebe02083e5bb0092d50b52946585f59df8e17da19bd4ab46725659ef827e3621d0ad5469f5feb77d0b2f24a4850f486812569e26550fef65e21df583e3

data/lib/raindeer/boot.rb

@@ -4,6 +4,7 @@ require 'low_event'
 require 'low_node'
 require 'low_type'
 require 'observers'
+require 'plugs'
 require 'providers'
 
 # File paths are relative to the directory where the process is run from, so the app can just require this boot file.
@@ -45,6 +46,7 @@ end
 # FRAMEWORK EXTERNAL API
 #################################################
 
+require_relative 'integrations'
 require_relative 'raindeer'
 
 #################################################

data/lib/raindeer/integrations.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative '../router/http'
+
+class LowNode
+  include Rain::HTTP
+end

data/lib/router/{route_event.rb → events/route_event.rb}

@@ -6,8 +6,8 @@ module Rain
   class RouteEvent < ::LowEvent
     attr_reader :route, :params
 
-    def initialize(route:, action: :render, params: Hash | nil)
-      super(key: route.path, action:)
+    def initialize(route:, actions: [], params: Hash | nil)
+      super(key: route.path, actions:)
 
       @route = route
       @params = params

data/lib/router/{wildcard_route_event.rb → events/wildcard_event.rb}

@@ -3,7 +3,7 @@
 require 'low_event'
 
 module Rain
-  class WildcardRouteEvent < ::LowEvent
+  class WildcardEvent < ::LowEvent
     attr_reader :route, :params
 
     def initialize(key:, route:, action: :render)

data/lib/router/http.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Rain
+  module HTTP
+    GET = :get
+    QUERY = :query
+    POST = :post
+    PUT = :put
+    PATCH = :patch
+    DELETE = :delete
+
+    VERBS = [GET, QUERY, POST, PUT, PATCH, DELETE]
+  end
+end

data/lib/router/route.rb

@@ -1,14 +1,33 @@
 # frozen_string_literal: true
 
+require_relative 'http'
+
 module Rain
   class Route
     include LowType
 
     attr_reader :path, :verbs
 
-    def initialize(path: String, verbs: Array[String | nil] | [])
+    def initialize(path: String, verbs: Array[Symbol] | [])
       @path = path
       @verbs = verbs
     end
+
+    class << self
+      # Route[] is used as a value object to access existing routes.
+      # Create new routes with new() instead... collection syntax is misused too frequently for instantiation.
+      def [](value)
+        path, verbs = decode(value:)
+        new(path:, verbs:)
+      end
+
+      def decode(value: String | Hash)
+        if value.is_a?(Hash)
+          return [value.values.first, [*value.keys.first]]
+        end
+        
+        [value, HTTP::VERBS]
+      end
+    end
   end
 end

data/lib/router/router.rb

@@ -1,73 +1,77 @@
 # frozen_string_literal: true
 
 require 'low_event'
-require 'providers'
 
+require_relative 'events/route_event'
+require_relative 'events/wildcard_event'
+require_relative 'http'
 require_relative 'route'
-require_relative 'route_event'
 require_relative 'trie'
-require_relative 'wildcard_route_event'
 
 module Rain
+  # Defines routes and routes requests to a matching route event.
   class Router
     include LowType
     include Observers
+    include Low::Events
+    include Low::Types
+    include Rain::HTTP
 
     attr_reader :routes, :trie
 
     def initialize
-      @breadcrumbs = []
+      @current_level = []
       @routes = {}
       @trie = Trie.new
     end
 
-    def route(path, verbs = [], &block)
-      @breadcrumbs << path
-      path = @breadcrumbs.join
+    def route(value, &block)
+      path, verbs = Route.decode(value:)
 
-      route = Route.new(path:, verbs: [*verbs])
+      @current_level << path
+      path = @current_level.join
+
+      route = Route.new(path:, verbs:)
       @routes[path] = route
       @trie.merge(route:)
 
       block.call if block_given?
 
-      @breadcrumbs.pop
+      @current_level.pop
     end
 
     def get(path, &block)
-      route(path, 'GET', &block)
+      route(GET => path, &block)
     end
 
     def post(path, &block)
-      route(path, 'POST', &block)
+      route(POST => path, &block)
     end
 
     def update(path, &block)
-      route(path, 'UPDATE', &block)
+      route(UPDATE => path, &block)
     end
 
     def delete(path, &block)
-      route(path, 'DELETE', &block)
+      route(DELETE => path, &block)
     end
 
-    # TODO: Define type: ::Low::Events::RequestEvent
-    # You can override any route/status simply by adding your own observer.
-    def handle(event:)
+    def request(event: RequestEvent)
       response_event = nil
 
       # The last route event will render a response event which we want to return to the request event.
-      @trie.match(path: event.request.path).each do |route_event|
-        response_event = route_event.trigger
+      @trie.match(request: event.request).each do |route_event|
+        response_event = route_event.take
       end
       return response_event if response_event
 
       if @routes['/*']
         route = Route.new(path: event.request.path, verbs: @routes['/*'].verbs)
-        wildcard_event = WildcardRouteEvent.trigger(key: '/*', action: :render, route:)
+        wildcard_event = WildcardEvent.take(key: '/*', action: :render, route:)
         return wildcard_event if wildcard_event
       end
 
-      Low::Events::StatusEvent.trigger(status: Low::Types::Status[404], request: event.request)
+      StatusEvent.take(status: Status[404], request: event.request)
     end
   end
 end

data/lib/router/trie.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'events/route_event'
 require_relative 'route'
-require_relative 'route_event'
 require_relative 'trie_node'
 
 module Rain
@@ -39,15 +39,17 @@ module Rain
       current_node.route = route
     end
 
-    def match(path:, current_node: @root_node, current_index: 0, params: {})
+    def match(request:, current_node: @root_node, current_index: 0, params: {})
+      path = request.path
+
       return [] if (key = path[current_index]).nil?
 
       route_events = []
 
       # Static request path segment.
       if (child_node = current_node.child(key:))
-        route_events << route_event(next_index: current_index + 1, params:, path:, route: child_node.route) if child_node.route
-        route_events = [*route_events, *match(path:, current_node: child_node, current_index: current_index + 1, params:)]
+        route_events << route_event(next_index: current_index + 1, params:, request:, route: child_node.route) if child_node.route
+        route_events = [*route_events, *match(request:, current_node: child_node, current_index: current_index + 1, params:)]
       end
 
       # Dynamic request path segment.
@@ -57,8 +59,8 @@ module Rain
         arg, next_index = capture_arg(arg_start_index: current_index, path:)
         params[param.delete_prefix(':').to_sym] = arg
 
-        route_events << route_event(next_index:, params:, path:, route: child_node.route) if child_node.route
-        route_events = [*route_events, *match(path:, current_node: child_node, current_index: next_index, params:)]
+        route_events << route_event(next_index:, params:, request:, route: child_node.route) if child_node.route
+        route_events = [*route_events, *match(request:, current_node: child_node, current_index: next_index, params:)]
       end
 
       route_events
@@ -66,10 +68,15 @@ module Rain
 
     private
 
-    # Mid nodes handle events, end nodes render events.
-    def route_event(next_index:, params:, path:, route:)
-      action = path[next_index].nil? ? :render : :handle
-      RouteEvent.new(action:, route:, params:)
+    # Mid nodes side_effect, end nodes render.
+    def route_event(next_index:, params:, request:, route:)
+      action = request.path[next_index].nil? ? :render : :side_effect
+      action = receive if action == :render && request.body
+
+      actions = [action]
+      actions << request.method.downcase.to_sym unless action == :side_effect
+
+      RouteEvent.new(actions:, route:, params:)
     end
 
     def capture_param(current_index:, path:)

data/lib/system/system_routes.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 Raindeer.router do
-  get '/system' do
-    get '/events'
-    get '/routes'
+  route :get => '/system' do
+    route :get => '/events'
+    route :get => '/routes'
   end
 end

data/lib/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Raindeer
-  VERSION = '0.9.9'
+  VERSION = '0.9.10'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: raindeer
 version: !ruby/object:Gem::Version
-  version: 0.9.9
+  version: 0.9.10
 platform: ruby
 authors:
 - maedi
@@ -288,13 +288,15 @@ files:
 - lib/pages/raindown/raindown.rb
 - lib/raindeer/boot.rb
 - lib/raindeer/cli.rb
+- lib/raindeer/integrations.rb
 - lib/raindeer/raindeer.rb
+- lib/router/events/route_event.rb
+- lib/router/events/wildcard_event.rb
+- lib/router/http.rb
 - lib/router/route.rb
-- lib/router/route_event.rb
 - lib/router/router.rb
 - lib/router/trie.rb
 - lib/router/trie_node.rb
-- lib/router/wildcard_route_event.rb
 - lib/support/config_loader.rb
 - lib/system/dashboard_node.rbx
 - lib/system/events_node.rbx