Given the following non-root tree:
tree = Tree(Symbol).new
tree.add "/prefix/", :prefix
tree.add "/prefix/foo", :foo
Attempt to lookup for `/foo` was incorrectly identifying `:foo` entry as
the correct value.
This change ensures that child nodes of the current node are not scanned
if key and path being looked up do not match.
Fixes#27
Properly skip nodes and continue lookup when the key to be looked up
shares partial elements with others.
With the following scenario:
tree = Radix::Tree(Symbol).new
tree.add "/*glob", :catch_all
tree.add "/resources", :resources
tree.add "/robots.txt", :robots
When attempt to lookup for `/reviews`, it will now correctly return
`:catch_all` as found.
Fixes#23
No longer expose internal functionality used only in tests. Reduce the
exposed elements of `Radix::Result` to focus on payload only.
Also remove the associated array used to collect all the traversed nodes
when performing the lookup.
NOTE: this is a breaking change
Allow usage of `make spec` to run project's specs against default
Crystal compiler or one that can be supplied with `CRYSTAL`
environment variable.
Also provide ways to run in automated mode thanks to watchexec.
[skip ci]
Properly recognize and organize non-ascii keys into nodes, allowing
usage with entries in other languages.
With this change, it is possible to use 2 or 3 bytes wide characters
(Unicode) without issues:
tree = Radix::Tree(Symbol).new
tree.add "/", :root
tree.add "/日本語", :japanese
tree.add "/日本は難しい", :japanese_is_difficult
Which produces the following node hierarchy:
# ( 1) / (:root)
# ( 6) 日本
# (12) は難しい (:japanese_is_difficult)
# ( 3) 語 (:japanese)
And lookup works as expected:
result = tree.find "/日本は難しい"
puts result.found? # => true
Given the following nodes in a tree:
# ( 8) /product
# ( 4) /new
# ( 1) s
tree = Radix::Tree(Symbol).new
tree.add "/products", :products
tree.add "/product/new", :product_new
It failed to properly identify `/products` during lookup:
result = tree.find "/products"
result.found? # => false
Caused by incorrect comparsion of `s` remaining path against `/new`
node instead of continue comparison with the next one.
Fixes#21
The order in which nodes were inserted into a tree might produce
failures in lookup mechanism.
tree = Radix::Tree(Symbol).new
tree.add "/one/:id", :one
tree.add "/one-longer/:id", :two
result = tree.find "/one-longer/10"
# expected `true`
result.found? # => false
In above example, reversing the order of insertion solved the issue,
but exposed the naive sorting/prioritization mechanism used.
This change improves that by properly identifying the kind of node
being evaluated and compared against others of the same kind.
It is now possible to know in advance if a node contains an special
condition (named parameter or globbing) or is a normal one:
node = Radix::Node(Nil).new("a")
node.normal? # => true
node = Radix::Node(Nil).new(":query")
node.named? # => true
node = Radix::Node(Nil).new("*filepath")
node.glob? # => true
Which helps out with prioritization of nodes:
- A normal node ranks higher than a named one
- A named node ranks higher than a glob one
- On two of same kind, ranks are based on priority
With this change in place, above example works as expected:
tree = Radix::Tree(Symbol).new
tree.add "/one/:id", :one
tree.add "/one-longer/:id", :two
result = tree.find "/one-longer/10"
result.found? # => true
Fixes#18
Given two similar keys, one short and one with named parameter, lookup
was incorrectly picking up the named parameter version instead of the
specific one:
tree = Radix::Tree(Symbol).new
tree.add "/tag-edit/:id", :edit_tag
tree.add "/tag-edit2", :alternate_edit_tag
result = tree.find("/tag-edit2")
result.found? # => false
The order of insertion (named before specific) was causing the
lookup mechanism to validate it before checking the other options.
With the changes present here, short or long keys will be affected
anymore by named or globbed keys present when sharing part of the
key.
Fixeskemalcr/kemal#293
Crystal 0.20 introduced a change so `MemoryIO` is know known as
`IO::Memory`.
Since no current spec was using the deprecation redirect, there was
warning raised.
Fixes#16
Lookup was failing when part of the given path matched a key at the
first character, even when the rest of the key didn't match.
It was not possible place a catch all an another key at the same
level that started with same character.
This change ensures that all shared part between path and key is
compared prior assuming usage of that node as part of the lookup.
Closes#14
Catch all parameter was limited to be used *after* a slash (`/`) on
a path (ie. `/members/*trailing`).
Attempts to use it immediately after the path (ie. `/members*trailing`)
was not properly identified or captured.
This change ensures catch all can be used as globbing, allowing capture
of anything after the matching path.
Closes#12
When adding new nodes into the tree, the lookup mechanism failed
to detect same named parameter was already added to it, raising
an exception.
Example:
tree = Radix::Tree(Symbol).new
tree.add "/members/:id/edit", :member_edit
tree.add "/members/export", :members_export
tree.add "/members/:id/videos", :member_videos # Exception
This fix ensures that comparison is done key by key, even if they
are inserted into the tree in a different order.
Closes#9
Introduce `Radix::VERSION` to be used at runtime by users of the
library for any purpose this will help them (expose them, use
conditional blocks or similar).
Also add spec that checks that defined versions in both `shard.yml`
and `Radix::VERSION` matches to avoid messing up releases.
