syntropy 0.20 → 0.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 652c2d240350e3a5d0ce18cdd73a76a2ea3920a58ca777f46c34aa8a6e567ecd
-  data.tar.gz: cd49374a2469e501ea9adec27db55f9b047a418e7f1291894a9dd68c7d2e367f
+  metadata.gz: 8069c4fe6a21289babda24dae14b580c5ea476a5d77bdcb09e31ae72d751459c
+  data.tar.gz: de80dbc652706f64819cef25d23ca81f19ed0e628d2860ae01a0e5792ea1bc6d
 SHA512:
-  metadata.gz: f1861340956ffbf7db1b0163ec7a1fd84f1b2c422ae9d25ab7cfa531b70459e22e306876bba6e1865e1cc398475d536a5726dbe276744b127fe416851162fe62
-  data.tar.gz: 8ccf9cc252f7efa6e086ca830fbc9a6f836ecb43f91880d9c399aeb05fe8ca42677de6f1493785ef436c3b5a3f999ed50c7834c17b37ff1b779ed24539016ffd
+  metadata.gz: ec0769f1619a71b926a19c56499b28c4e2331d05d417c8d0d6d3b21c1804a2ea2e52c93307a716c289c381b617bb66fcd174bb92b0c9b612f80f7561b32f0bba
+  data.tar.gz: b836b5a0bd012ae3a179c515cb177959723da53e99c0bb2212a1b5caab6270b38a9a33282b73279a6915ac768324cd61604ce6db02237f33b55980145c87f5e8

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+# 0.21 2025-09-29
+
+- Fix routing with wildcard `index+.rb` modules
+
 # 0.20 2025-09-17
 
 - Update Papercraft

data/lib/syntropy/app.rb

@@ -110,7 +110,9 @@ module Syntropy
       @router_proc = @routing_tree.router_proc
     end
 
-
+    # Mounts the builtin applet on the routing tree.
+    #
+    # @return [void]
     def mount_builtin_applet
       path = @env[:builtin_applet_path]
       @builtin_applet ||= Syntropy.builtin_applet(@env, mount_path: path)

data/lib/syntropy/routing_tree.rb

@@ -309,6 +309,10 @@ module Syntropy
       plus, ext = m[1..2]
       kind = FILE_TYPE[ext]
       handle_subtree = (plus == '+') && (kind == :module)
+      if handle_subtree
+        path = path.gsub(/\/index\+$/, '')
+        path = '/' if path.empty?
+      end
       set_index_route_target(parent:, path:, kind:, fn:, handle_subtree:)
     end
 
@@ -443,29 +447,79 @@ module Syntropy
     # @return [String] router proc code to be `eval`ed
     def generate_routing_tree_code
       buffer = +''
-      buffer << "# frozen_string_literal: true\n"
+      buffer << "# frozen_string_literal: true\n\n"
 
-      emit_code_line(buffer, '->(path, params) {')
-      emit_code_line(buffer, '  entry = @static_map[path]; return entry if entry')
-      emit_code_line(buffer, '  parts = path.split("/")')
+      wildcard_root = @root[:handle_subtree]
+      childless_root = !@root[:children] || @root[:children].empty?
 
-      if @root[:path] != '/'
-        root_parts = @root[:path].split('/')
-        segment_idx = root_parts.size
-        validate_parts = []
-        (1..(segment_idx - 1)).each do |i|
-          validate_parts << "(parts[#{i}] != #{root_parts[i].inspect})"
-        end
-        emit_code_line(buffer, "  return nil if #{validate_parts.join(' || ')}")
+      if wildcard_root && childless_root
+        emit_wildcard_childless_root_code(buffer, @root[:path])
       else
+        emit_router_proc_prelude(buffer)
         segment_idx = 1
+        if @root[:path] != '/'
+          root_parts = @root[:path].split('/')
+          segment_idx = root_parts.size
+          emit_root_validate_guard(buffer:, root_parts:)
+        end
+
+        visit_routing_tree_entry(buffer:, entry: @root, segment_idx:)
+        emit_router_proc_postlude(buffer, default_route_path: wildcard_root && @root[:path])
       end
 
-      visit_routing_tree_entry(buffer:, entry: @root, segment_idx:)
+      buffer#.tap { puts '*' * 40; puts it; puts }
+    end
+
+    # Emits optimized code for a childless wildcard router.
+    #
+    # @param buffer [String] output buffer
+    # @param root_path [String] router root path
+    # @return [void]
+    def emit_wildcard_childless_root_code(buffer, root_path)
+      emit_code_line(buffer, '->(path, params) {')
+      if root_path != '/'
+        re = /^#{Regexp.escape(root_path)}(\/.*)?$/
+        emit_code_line(buffer, "  return if path !~ #{re.inspect}")
+      end
+      emit_code_line(buffer, "  @dynamic_map[#{root_path.inspect}]")
+      emit_code_line(buffer, '}')
+    end
+
+    # Emits router proc prelude code.
+    #
+    # @param buffer [String] output buffer
+    # @return [void]
+    def emit_router_proc_prelude(buffer)
+      emit_code_line(buffer, '->(path, params) {')
+      emit_code_line(buffer, '  entry = @static_map[path]; return entry if entry')
+      emit_code_line(buffer, '  parts = path.split("/")')
+    end
+
+    # Emits root path validation guard code.
+    #
+    # @param buffer [String] output buffer
+    # @param root_parts [Array<String>] root path parts
+    # @return [void]
+    def emit_root_validate_guard(buffer:, root_parts:)
+      validate_parts = []
+      (1...root_parts.size).each do |i|
+        validate_parts << "(parts[#{i}] != #{root_parts[i].inspect})"
+      end
+      emit_code_line(buffer, "  return nil if #{validate_parts.join(' || ')}")
+    end
 
-      emit_code_line(buffer, "  return nil")
+    # Emits router proc postlude code.
+    #
+    # @param buffer [String] output buffer
+    # @param default_route_path [String, nil] default route path
+    # @return [void]
+    def emit_router_proc_postlude(buffer, default_route_path:)
+      if default_route_path
+        emit_code_line(buffer, "  return @dynamic_map[#{default_route_path.inspect}]")
+      else
+        emit_code_line(buffer, "  return nil")
+      end
       emit_code_line(buffer, "}")
-      buffer#.tap { puts '*' * 40; puts it; puts }
     end
 
     # Generates routing logic code for the given route entry.
@@ -507,40 +561,7 @@ module Syntropy
       end
 
       if entry[:children]
-        param_entry = entry[:children]['[]']
-        entry[:children].each do |k, child_entry|
-          # skip if wildcard entry (treated in else clause below)
-          next if k == '[]'
-
-          # skip if entry is void (no target, no children)
-          has_target = child_entry[:target]
-          has_children = child_entry[:children] && !child_entry[:children].empty?
-          next if !has_target && !has_children
-
-          if has_target && !has_children
-            # use the target
-            next if child_entry[:static]
-
-            emit_code_line(buffer, "#{ws}when #{k.inspect}")
-            if_clause = child_entry[:handle_subtree] ? '' : " if !parts[#{segment_idx + 1}]"
-            route_value = "@dynamic_map[#{child_entry[:path].inspect}]"
-            emit_code_line(buffer, "#{ws}  return #{route_value}#{if_clause}")
-
-          elsif has_children
-            # otherwise look at the next segment
-            next if is_void_route?(child_entry) && !param_entry
-
-            emit_code_line(buffer, "#{ws}when #{k.inspect}")
-            visit_routing_tree_entry(buffer:, entry: child_entry, indent: indent + 1, segment_idx: segment_idx + 1)
-          end
-        end
-
-        # parametric route
-        if param_entry
-          emit_code_line(buffer, "#{ws}else")
-          emit_code_line(buffer, "#{ws}  params[#{param_entry[:param].inspect}] = p")
-          visit_routing_tree_entry(buffer:, entry: param_entry, indent: indent + 1, segment_idx: segment_idx + 1)
-        end
+        emit_routing_tree_entry_children_clauses(buffer:, entry:, indent:, segment_idx:)
       end
       emit_code_line(buffer, "#{ws}end")
     end
@@ -564,7 +585,7 @@ module Syntropy
     # @param entry [Hash] route entry
     # @return [bool]
     def is_void_route?(entry)
-      return false if entry[:param]
+      return false if entry[:param] || entry[:target]
 
       if entry[:children]
         return true if !entry[:children]['[]'] && entry[:children]&.values&.all? { is_void_route?(it) }
@@ -575,6 +596,58 @@ module Syntropy
       false
     end
 
+    # Emits case clauses for the given entry's children.
+    #
+    # @param buffer [String] output buffer
+    # @param entry [Hash] route entry
+    # @param indent [Integer] indent level
+    # @param segment_idx [Integer] path segment index
+    # @return [void]
+    def emit_routing_tree_entry_children_clauses(buffer:, entry:, indent:, segment_idx:)
+      ws = ' ' * (indent * 2)
+
+      param_entry = entry[:children]['[]']
+      entry[:children].each do |k, child_entry|
+        # skip if wildcard entry (treated in else clause below)
+        next if k == '[]'
+
+        # skip if entry is void (no target, no children)
+        has_target = child_entry[:target]
+        has_children = child_entry[:children] && !child_entry[:children].empty?
+        next if !has_target && !has_children
+
+        if has_target && !has_children
+          # use the target
+          next if child_entry[:static]
+
+          emit_code_line(buffer, "#{ws}when #{k.inspect}")
+          if_clause = child_entry[:handle_subtree] ? '' : " if !parts[#{segment_idx + 1}]"
+
+          child_path = child_entry[:path]
+          route_value = "@dynamic_map[#{child_path.inspect}]"
+          emit_code_line(buffer, "#{ws}  return #{route_value}#{if_clause}")
+
+        elsif has_children
+          # otherwise look at the next segment
+          next if is_void_route?(child_entry) && !param_entry
+
+          emit_code_line(buffer, "#{ws}when #{k.inspect}")
+          visit_routing_tree_entry(buffer:, entry: child_entry, indent: indent + 1, segment_idx: segment_idx + 1)
+        end
+      end
+
+      # parametric route
+      if param_entry
+        emit_code_line(buffer, "#{ws}else")
+        emit_code_line(buffer, "#{ws}  params[#{param_entry[:param].inspect}] = p")
+        visit_routing_tree_entry(buffer:, entry: param_entry, indent: indent + 1, segment_idx: segment_idx + 1)
+      # wildcard route
+      elsif entry[:handle_subtree]
+        emit_code_line(buffer, "#{ws}else")
+        emit_code_line(buffer, "#{ws}  return @dynamic_map[#{entry[:path].inspect}]")
+      end
+    end
+
     DEBUG = !!ENV['DEBUG']
 
     # Emits the given code into the given buffer, with a line break at the end.

data/lib/syntropy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Syntropy
-  VERSION = '0.20'
+  VERSION = '0.21'
 end

data/test/test_routing_tree.rb

@@ -408,3 +408,167 @@ class RoutingTreeTest < Minitest::Test
     }
   end
 end
+
+class RoutingTreeWildcardIndexTest < Minitest::Test
+  def test_wildcard_root_index_routing_on_docs
+    file_tree = {
+      'site': {
+        'index+.rb': '',
+      }
+    }
+
+    @root_dir = "/tmp/#{__FILE__.gsub('/', '-')}-#{SecureRandom.hex}"
+    make_tmp_file_tree(@root_dir, file_tree)
+    @rt = Syntropy::RoutingTree.new(root_dir: File.join(@root_dir, 'site'), mount_path: '/docs')
+
+    router = @rt.router_proc
+
+    route = router.('/docs', {})
+    assert_equal '/docs', route[:path]
+
+    route = router.('/docs/foo', {})
+    assert_equal '/docs', route[:path]
+
+    route = router.('/docs/foo/bar', {})
+    assert_equal '/docs', route[:path]
+
+    route = router.('/docsa', {})
+    assert_nil route
+  end
+
+  def test_wildcard_root_index_routing_on_root
+    file_tree = {
+      'site': {
+        'index+.rb': '',
+      }
+    }
+
+    @root_dir = "/tmp/#{__FILE__.gsub('/', '-')}-#{SecureRandom.hex}"
+    make_tmp_file_tree(@root_dir, file_tree)
+    @rt = Syntropy::RoutingTree.new(root_dir: File.join(@root_dir, 'site'), mount_path: '/')
+
+    router = @rt.router_proc
+
+    route = router.('/', {})
+    assert_equal '/', route[:path]
+
+    route = router.('/foo', {})
+    assert_equal '/', route[:path]
+
+    route = router.('/foo/bar', {})
+    assert_equal '/', route[:path]
+  end
+
+  def test_wildcard_root_index_with_children
+    file_tree = {
+      'site': {
+        'about.rb': '',
+        'foo+.rb': '',
+        'index+.rb': '',
+      }
+    }
+
+    @root_dir = "/tmp/#{__FILE__.gsub('/', '-')}-#{SecureRandom.hex}"
+    make_tmp_file_tree(@root_dir, file_tree)
+    @rt = Syntropy::RoutingTree.new(root_dir: File.join(@root_dir, 'site'), mount_path: '/docs')
+    router = @rt.router_proc
+
+    route = router.('/docs', {})
+    assert_equal '/docs', route[:path]
+
+    route = router.('/docs/about', {})
+    assert_equal '/docs/about', route[:path]
+
+    route = router.('/docs/foo', {})
+    assert_equal '/docs/foo+', route[:path]
+
+    route = router.('/docs/foo/bar', {})
+    assert_equal '/docs/foo+', route[:path]
+
+    route = router.('/docs/baz', {})
+    assert_equal '/docs', route[:path]
+
+    route = router.('/docsa', {})
+    assert_nil route
+  end
+
+  def test_wildcard_root_index_with_static_children
+    file_tree = {
+      'site': {
+        'about.rb': '',
+        'foo.rb': '',
+        'index+.rb': '',
+      }
+    }
+
+    @root_dir = "/tmp/#{__FILE__.gsub('/', '-')}-#{SecureRandom.hex}"
+    make_tmp_file_tree(@root_dir, file_tree)
+    @rt = Syntropy::RoutingTree.new(root_dir: File.join(@root_dir, 'site'), mount_path: '/docs')
+    router = @rt.router_proc
+
+    route = router.('/docs', {})
+    assert_equal '/docs', route[:path]
+
+    route = router.('/docs/about', {})
+    assert_equal '/docs/about', route[:path]
+
+    route = router.('/docs/foo', {})
+    assert_equal '/docs/foo', route[:path]
+
+    route = router.('/docs/foo/bar', {})
+    assert_equal '/docs', route[:path]
+
+    route = router.('/docs/baz', {})
+    assert_equal '/docs', route[:path]
+
+    route = router.('/docsa', {})
+    assert_nil route
+  end
+
+  def test_wildcard_nested_index
+    file_tree = {
+      'site': {
+        'foo': {
+          'index+.rb': ''
+        },
+        'bar': {
+          'about.rb': '',
+          'foo.rb': '',
+          'index+.rb': '',
+        },
+        # 'baz+.rb': ''
+      }
+    }
+
+    @root_dir = "/tmp/#{__FILE__.gsub('/', '-')}-#{SecureRandom.hex}"
+    make_tmp_file_tree(@root_dir, file_tree)
+    @rt = Syntropy::RoutingTree.new(root_dir: File.join(@root_dir, 'site'), mount_path: '/docs')
+    router = @rt.router_proc
+
+    route = router.('/docs', {})
+    assert_nil route
+
+    route = router.('/docs/foo', {})
+    assert_equal '/docs/foo', route[:path]
+
+    route = router.('/docs/foo/bar', {})
+    assert_equal '/docs/foo', route[:path]
+
+    route = router.('/docs/foo/about', {})
+    assert_equal '/docs/foo', route[:path]
+
+    route = router.('/docs/bar', {})
+    assert_equal '/docs/bar', route[:path]
+
+    route = router.('/docs/bar/baz', {})
+    assert_equal '/docs/bar', route[:path]
+
+    route = router.('/docs/bar/about', {})
+    assert_equal '/docs/bar/about', route[:path]
+
+    route = router.('/docs/bars/about', {})
+    assert_nil route
+  end
+
+  
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: syntropy
 version: !ruby/object:Gem::Version
-  version: '0.20'
+  version: '0.21'
 platform: ruby
 authors:
 - Sharon Rosner