ratalada-contrib 2.1.0 → 3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 684119c7ffaadc33fd820a4afad88d7c814e20d95cb397e3b7f200a48b89c252
-  data.tar.gz: de2d2c52778288e334bb95a5bb27420e062714d35924a8db5ab98d4b15491f93
+  metadata.gz: f94789e43bf70a8638e24126024e340669543cdb8126516faf70e4efb0ebb553
+  data.tar.gz: 1e428b4d5dae6ed2dfc9ef06cc28d24bceb982f7255295d3918717e99a431881
 SHA512:
-  metadata.gz: c22ec36581b747dbeccacca95a0ae3d492286682365c5b79d234bfc9ad5dbaed4fb9fd9af5fe1f18933f7823109ce887bde7b6da6f3742636e11e9d91fdd743f
-  data.tar.gz: 5aeb45e1b6984aef2523b41a929d5c7bf3e90df94442c8dc7c5ca8f4366c0aa5feb46e7cb4695171fd922bb0bbe4074cc7bed3cc69f1694f9f48a93b68499370
+  metadata.gz: 7dfe78d482fbd3486981c591e50875219c0f2c1865c1cf7147547021a7a66aaeb535c9e1edeb1d09d85619047791d68805641bb577d2d62ea98267cf740b1669
+  data.tar.gz: 4ca2093d272fc1e124d2c5f6697193206af316b53daf1113e57125b295877226250ecdefb2453a86013a62b8c108820e57d42a419e98e74ff38f2d99c7f5ce95

data/lib/ratalada/contrib/router/file_based/expo.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "mustermann"
+require "mustermann/ast/pattern"
+
+module Mustermann
+  # Expo Router style pattern implementation.
+  #
+  # @example
+  #   Mustermann.new('/[foo]', type: :expo) === '/bar' # => true
+  #
+  # @see Mustermann::Pattern
+  class Expo < AST::Pattern
+    register :expo
+
+    NOT_FOUND = "+not-found"
+    NOT_FOUND_CAPTURE = "unmatched"
+
+    # Turns an Expo Router file path into the route it serves: file extensions
+    # and the +api suffix are dropped, a _layout file stands for its directory,
+    # group segments are invisible and a trailing index is its directory.
+    # Mirrors getContextKey/stripInvisibleSegmentsFromPath in expo-router.
+    # @!visibility private
+    def self.route(string)
+      string   = string.sub(%r{\A(?:\.\.?/|/)+}, "")
+      string   = string.sub(/(\+api)?\.rb$/, "").sub(%r{/?_layout$}, "")
+      segments = (?/ + string.delete_prefix(?/)).split(?/, -1)
+      if segments.last == "index"
+        segments.pop
+      end
+      segments.reject! { |s| s =~ /\A\(.+\)\z/ }
+      if segments.last == NOT_FOUND
+        segments[-1] = "[...#{NOT_FOUND_CAPTURE}]"
+      end
+      segments.join(?/).then { |route| route.empty? ? ?/ : route }
+    end
+
+    def initialize(string, **options)
+      super(Expo.route(string), **options)
+    end
+
+    on(nil, ?]) { |c| unexpected(c) }
+
+    on(?[) do |char|
+      name = expect(%r{[^\[\]/]+}, char: char)
+      expect(?])
+
+      if name.start_with?("...")
+        node(:named_splat, name[3..], constraint: ".+", convert: ->(e) { e.split(?/) })
+      else
+        node(:capture, name)
+      end
+    end
+  end
+end

data/lib/ratalada/contrib/router/file_based/grape_adapter.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "grape"
+require "ratalada/grape"
 
 require_relative "../file_based"
 
@@ -8,47 +8,26 @@ module Ratalada
   module Contrib
     module Router
       module FileBased
-        # The Grape half of file-based routing. Each route file is built the way
-        # `Server.run`'s block is — class_eval'd into a Grape::API subclass, file
-        # contents in place of the block — and Grape then re-hosts that built API
-        # under the prefix its path spelled:
-        #
-        #   parent.mount(file_api => "/teams/:team/settings")
-        #
-        # `mount` is Grape's own (DSL::Routing#mount): it stores the mount path on
-        # the child's settings and replays its endpoints into the parent, so the
-        # file's `get "/members"` compiles as "/teams/:team/settings/members" with
-        # :team in params. Nothing about Grape's path handling is reimplemented.
+        # Teaches Grape `route_prefix`, the same way as Sinatra: the paths of
+        # every route defined while it is set hang off it.
         module GrapeAdapter
-          module_function
-
-          # Returns the Grape::API subclass with every route file mounted.
-          def build(directory)
-            Class.new(::Grape::API).tap do |app|
-              FileBased.build_map(directory).each do |prefix, paths|
-                app.mount(build_file(paths) => mount_path(prefix))
-              end
+          def route(methods, paths = ["/"], route_options = {}, &block)
+            unless route_prefix.to_s.empty?
+              paths = Array(paths).map { |path| FileBased.join(route_prefix, path.to_s) }
             end
-          end
-
-          # One route file and the layouts above it, built exactly like a
-          # Server.run block: the layouts' `helpers`, `before` blocks and `use`
-          # calls land in the same API as the file's own routes.
-          def build_file(paths)
-            Class.new(::Grape::API).tap do |api|
-              paths.each { |path| api.class_eval(File.read(path), path, 1) }
-            end
-          end
 
-          # A root file has no prefix; Grape spells that mount point "/".
-          def mount_path(prefix)
-            case prefix
-            when "" then "/"
-            else prefix
-            end
+            super
           end
         end
       end
     end
   end
 end
+
+class Grape::API::Instance # rubocop:disable Style/ClassAndModuleChildren
+  class << self
+    attr_accessor :route_prefix
+
+    prepend Ratalada::Contrib::Router::FileBased::GrapeAdapter
+  end
+end

data/lib/ratalada/contrib/router/file_based/hanami_adapter.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "hanami/api"
+require "ratalada/hanami"
 
 require_relative "../file_based"
 
@@ -8,49 +8,17 @@ module Ratalada
   module Contrib
     module Router
       module FileBased
-        # The Hanami half of file-based routing. Hanami::API compiles routes
-        # straight into the router's trie, so there is no route list to rewrite
-        # afterwards the way Sinatra's Mustermann patterns can be — what it has
-        # instead is `scope`, the prefix its own router applies while routes are
-        # being defined (Hanami::Router#scope). So the file is evaluated inside
-        # the scope its path spells, which is the same result one step earlier:
-        #
-        #   # app/teams/[team]/settings/index.rb
-        #   get "/members" do
-        #     "members of #{params[:team]}"
-        #   end
-        #
-        # becomes "/teams/:team/settings/members". The file's blocks still run in
-        # the app's own Block::Context, so `params`, `halt` and any `helpers` are
-        # the ones the app defines.
+        # Teaches Hanami::API `route_prefix`. Hanami's router already carries a
+        # path prefix — it is what `scope` sets for the length of its block —
+        # so this is that, set until the next file.
         module HanamiAdapter
-          module_function
-
-          # Returns the rack app: a Hanami::API subclass instance, as the Hanami
-          # frontend builds it, with every route file evaluated into it.
-          def build(directory)
-            app = Class.new(::Hanami::API)
-
-            FileBased.build_map(directory).each do |prefix, paths|
-              mount_route_file(app, prefix, paths)
-            end
-
-            app.new
-          end
-
-          # The layouts above the file are evaluated in the same scope, ahead of
-          # it, so what they add (`use`, extra routes) applies to that prefix.
-          def mount_route_file(app, prefix, paths)
-            sources = paths.map { |path| [File.read(path), path] }
-
-            # `scope` instance_evals its block on the router, so the file's own
-            # `get`/`post` calls are the router's, under the prefix.
-            app.router.scope(prefix) do
-              sources.each { |source, path| instance_eval(source, path, 1) }
-            end
+          def route_prefix=(prefix)
+            @router.instance_variable_set(:@path_prefix, ::Hanami::Router::Prefix.new("/").join(prefix.to_s))
           end
         end
       end
     end
   end
 end
+
+Hanami::API.extend(Ratalada::Contrib::Router::FileBased::HanamiAdapter)

data/lib/ratalada/contrib/router/file_based/sinatra_adapter.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require "mustermann"
-require "rack"
-require "sinatra/base"
+require "ratalada/sinatra"
 
 require_relative "../file_based"
 
@@ -10,81 +8,27 @@ module Ratalada
   module Contrib
     module Router
       module FileBased
-        # The Sinatra half of file-based routing: each route file is built the
-        # same way `Server.run`'s block is — class_eval'd into a Sinatra::Base
-        # subclass — with the file's contents as the input instead of a block. So
-        # a file is ordinary Sinatra:
-        #
-        #   # app/teams/[team]/settings/index.rb
-        #   get "/members" do
-        #     "members of #{params[:team]}"
-        #   end
-        #
-        # Building it yields an app object whose compiled routes are Mustermann
-        # patterns, and those are what the prefix from FileBased gets prepended
-        # to — Mustermann concatenates patterns itself, so "/teams/:team" +
-        # "/members" stays one pattern with both captures.
-        #
-        # The rewritten apps are then chained: a Sinatra app used as rack
-        # middleware forwards the request onward when none of its own routes
-        # matched (Base#route_missing), so the first file that spells the path
-        # answers and the last one falls through to a plain 404.
+        # Teaches Sinatra `route_prefix`: every route defined while it is set
+        # hangs off it, which is how a route file's own `get "/members"` lands
+        # under the prefix its path spelled.
         module SinatraAdapter
-          NOT_FOUND = lambda do |_env|
-            [404, { "content-type" => "text/plain" }, ["Not Found"]]
-          end
-
-          module_function
-
-          def build(directory)
-            apps = FileBased.build_map(directory).map do |prefix, paths|
-              prefix_routes(build_file(paths), prefix)
-            end
-
-            # ponytail: one Sinatra app (and its middleware stack) per file, walked
-            # in order per request. Collapse into one app class if a fat tree ever
-            # shows up in a profile.
-            ::Rack::Builder.new.tap do |builder|
-              apps.each { |app| builder.use(app) }
-              builder.run(NOT_FOUND)
-            end.to_app
-          end
-
-          # One route file and the layouts above it, built exactly like a
-          # Server.run block: the layouts' `helpers`, `before` filters and `use`
-          # calls land in the same class as the file's own routes.
-          def build_file(paths)
-            Class.new(::Sinatra::Base).tap do |app|
-              paths.each { |path| app.class_eval(File.read(path), path, 1) }
-            end
-          end
-
-          # Rewrites every route the built app holds to sit under `prefix`.
-          def prefix_routes(app, prefix)
-            pattern = ::Mustermann.new(prefix, type: :sinatra)
-
-            app.routes.each_value do |signatures|
-              signatures.map! do |(route, conditions, wrapper)|
-                [nest(pattern, route), conditions, wrapper]
-              end
+          def route(verb, path, options = {}, &block)
+            unless route_prefix.to_s.empty?
+              path = FileBased.join(route_prefix, path)
             end
 
-            app
-          end
-
-          # A file's own "/" is the prefix itself, not the prefix with a trailing
-          # slash, so it is the one pattern that replaces rather than extends —
-          # as is any route in a file that sits at the root, where the prefix is
-          # empty.
-          def nest(prefix, route)
-            case [prefix.to_s, route.to_s]
-            in ["", _] then route
-            in [_, "/"] then prefix
-            else prefix + route
-            end
+            super
           end
         end
       end
     end
   end
 end
+
+class Sinatra::Base # rubocop:disable Style/ClassAndModuleChildren
+  set :route_prefix, ""
+
+  class << self
+    prepend Ratalada::Contrib::Router::FileBased::SinatraAdapter
+  end
+end

data/lib/ratalada/contrib/router/file_based.rb

@@ -1,66 +1,56 @@
 # frozen_string_literal: true
 
+require "ratalada"
+
+require_relative "file_based/expo"
+
 module Ratalada
   module Contrib
     module Router
-      # Turns an expo-router style directory of route files into an ordered map
-      # of `prefix => path`. The prefix is what the file's own routes hang off:
-      # a file says `get "/members" do ... end` and the adapter mounts that under
-      # the prefix its path spells, so each adapter only has to decide how it
-      # loads a file and how it spells a placeholder.
-      #
-      #   Ratalada::Contrib::Router::FileBased.build_map("app")
-      #   # => { "" => "app/index.rb",
-      #   #      "/organizations/:slug" => "app/organizations/[slug]/index.rb", ... }
-      #
-      #   FileBased.join("/organizations/:slug", "/users")  # => "/organizations/:slug/users"
-      #   FileBased.join("/organizations/:slug", "/")       # => "/organizations/:slug"
-      #   FileBased.join("", "/")                           # => "/"
-      #
-      # Conventions, all borrowed from expo-router:
-      #
-      #   index.rb          the directory itself           app/teams/index.rb => /teams
-      #   [slug].rb         a single dynamic segment       => /:slug
-      #   [...rest].rb      a catch-all                    => /*rest
-      #   (group)/          grouping only, not a segment   app/(marketing)/docs.rb => /docs
-      #   +not-found.rb     the fallback                   => /*
-      #   _layout.rb        not a route of its own: its contents are evaluated
-      #                     into every route file below it, outermost first, so
-      #                     a layout is whatever the file could have written for
-      #                     itself (helpers, filters, middleware, extra routes).
-      #                     Any other `_` file or directory is ignored outright.
-      #
-      # A map value is the list of files to evaluate, in order: the `_layout.rb`
-      # of each directory from the root down, then the route file itself.
-      #
-      # The map is ordered most specific first (static segments before dynamic,
-      # dynamic before catch-all, +not-found last), so an adapter can define the
-      # routes in iteration order under a first-match-wins router.
       module FileBased
-        NOT_FOUND = "+not-found"
         LAYOUT = "_layout.rb"
 
         module_function
 
-        def build_map(directory, placeholder: ":%s", catch_all: "*%s")
-          root = File.expand_path(directory)
+        # Evaluates every route file in the directory into an app class, under
+        # the prefix its path spells. That class is the frontend's own, so this
+        # is what a Server.run block calls: the block is already being evaluated
+        # into it, and `self` is it. Requiring the frontend's adapter is what
+        # teaches the class `route_prefix`.
+        #
+        #   Server.run { Ratalada::Contrib::Router::FileBased.mount(self, "app") }
+        def mount(app, directory)
+          build_map(directory).each do |prefix, paths|
+            app.route_prefix = prefix
+            paths.each { |path| app.class_eval(File.read(path), path, 1) }
+          end
+        end
 
-          entries = Dir.glob("**/*.rb", base: root).filter_map do |relative|
-            segments = route_segments(relative)
+        # The same, as a whole app built by whichever Ratalada frontend is in
+        # use — for mounting a directory somewhere other than the server's own
+        # run block.
+        def build(directory)
+          Ratalada.frontend.build(proc { FileBased.mount(self, directory) })
+        end
 
-            unless segments.nil?
-              [pattern(segments, placeholder, catch_all), files(root, relative), segments]
-            end
-          end
+        # A hash of route => the files that serve it, ordered most specific
+        # first. Mustermann::Expo does the file path => route translation; all
+        # this adds is which files to evaluate and how the adapter spells a
+        # placeholder.
+        #
+        # {
+        #   "/organisations/:id/edit" => ["./app/organisations/[id]/edit.rb"]
+        # }
+        def build_map(directory, placeholder: ":%s", catch_all: "*%s")
+          root = File.expand_path(directory)
 
-          entries
-            .sort_by { |(pattern, _files, segments)| [specificity(segments), pattern] }
-            .to_h { |(pattern, paths, _segments)| [pattern, paths] }
+          Dir.glob("**/*.rb", base: root)
+            .reject { |relative| relative.split("/").any? { |segment| segment.start_with?("_") } }
+            .map { |relative| [Mustermann::Expo.route(relative), files(root, relative)] }
+            .sort_by { |(route, _paths)| [specificity(route), route] }
+            .to_h { |(route, paths)| [spell(route, placeholder, catch_all), paths] }
         end
 
-        # The route file, with the `_layout.rb` of every directory above it in
-        # front — outermost first, so an inner layout is evaluated last and can
-        # override what an outer one set up.
         def files(root, relative)
           directories = relative.split("/")[0..-2]
 
@@ -68,45 +58,27 @@ module Ratalada
             File.join(root, *directories[0..index], LAYOUT)
           end
 
-          [File.join(root, LAYOUT), *layouts].select { |path| File.file?(path) }
+          [File.join(root, LAYOUT), *layouts]
+            .select { |path| File.file?(path) }
             .push(File.join(root, relative))
         end
 
-        # The route segments of a file, or nil when the file is not a route.
-        def route_segments(relative)
-          unless relative.split("/").any? { |segment| segment.start_with?("_") }
-            "/#{relative.delete_suffix(".rb")}"
-              .delete_suffix("/index")
-              .split("/")
-              .drop(1)
-              .reject { |segment| segment.match?(/\A\(.*\)\z/) }
-          end
-        end
-
-        def pattern(segments, placeholder, catch_all)
-          spelled = segments.map do |segment|
-            case segment
-            when /\A\[\.\.\.(.+)\]\z/ then format(catch_all, Regexp.last_match(1))
-            when /\A\[(.+)\]\z/ then format(placeholder, Regexp.last_match(1))
-            when NOT_FOUND then format(catch_all, "unmatched")
-            else segment
-            end
+        # An expo route in the adapter's own spelling: "/teams/[team]" => "/teams/:team".
+        # The root route is "" — a prefix nothing hangs off, not a route of "/".
+        def spell(route, placeholder, catch_all)
+          route.delete_suffix("/").gsub(%r{\[(\.\.\.)?([^\[\]/]+)\]}) do
+            format(Regexp.last_match(1) ? catch_all : placeholder, Regexp.last_match(2))
           end
-
-          spelled.map { |segment| "/#{segment}" }.join
         end
 
-        # Hangs one of a file's own routes off the prefix its path spelled.
         def join(prefix, route)
           "#{prefix}#{route.delete_suffix("/")}".sub(/\A\z/, "/")
         end
 
-        # Sorts static segments ahead of dynamic ones at the same depth, and the
-        # +not-found fallback behind everything.
-        def specificity(segments)
-          segments.map do |segment|
+        def specificity(route)
+          route.split("/").drop(1).map do |segment|
             case segment
-            when NOT_FOUND then 3
+            when "[...#{Mustermann::Expo::NOT_FOUND_CAPTURE}]" then 3
             when /\A\[\.\.\..+\]\z/ then 2
             when /\A\[.+\]\z/ then 1
             else 0

data/lib/ratalada/contrib/version.rb

@@ -2,6 +2,6 @@
 
 module Ratalada
   module Contrib
-    VERSION = "2.1.0"
+    VERSION = "3.0.1"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ratalada-contrib
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 3.0.1
 platform: ruby
 authors:
 - Nathan K
@@ -15,14 +15,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: mustermann
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '2'
 description: |
   Optional add-on modules for ratalada that do not belong in the core gem.
   Require only the ones you use; each pulls its own framework (the
@@ -42,6 +56,7 @@ files:
 - lib/ratalada/contrib/inertia/middleware.rb
 - lib/ratalada/contrib/inertia/response.rb
 - lib/ratalada/contrib/router/file_based.rb
+- lib/ratalada/contrib/router/file_based/expo.rb
 - lib/ratalada/contrib/router/file_based/grape_adapter.rb
 - lib/ratalada/contrib/router/file_based/hanami_adapter.rb
 - lib/ratalada/contrib/router/file_based/sinatra_adapter.rb