[libpath-dispatcher-perl] annotated tag upstream/1.06 created (now fe2ef76)
Florian Schlichting
fsfs at moszumanska.debian.org
Mon Nov 9 22:02:29 UTC 2015
This is an automated email from the git hooks/post-receive script.
fsfs pushed a change to annotated tag upstream/1.06
in repository libpath-dispatcher-perl.
at fe2ef76 (tag)
tagging a408943c59c868ccb97e1814f690f1c85caa310a (commit)
replaces upstream/1.05
tagged by Florian Schlichting
on Mon Nov 9 22:08:57 2015 +0100
- Log -----------------------------------------------------------------
Upstream version 1.06
David Pottage (3):
Switch packaging to Dist::Zilla
Add Dist::Zilla's build dir to .gitignore
Remove Module::Install from dependencies
Florian Ragwitz (2):
Failing test for swallowing exceptions
Stop swallowing exceptions
Florian Schlichting (1):
Imported Upstream version 1.06
Shawn M Moore (235):
Doc typo fix
Eq just had Regex's doc copied over, fix.
Doc for Path::Dispatcher::Role::Rules
Doc for Metadata rule
Amend synopsis to include "extensible" :)
Merge branch 'master' of git://github.com/robertkrimen/path-dispatcher
Merge branch 'master' of git://github.com/robertkrimen/path-dispatcher
Minor fixes
Update the Cookbook with "then", some verbiage
Uncomment "then"'s doc
Use "then" in the chaining test
Fix spelling of delimiter :)
It's just "abort" not "abort rule"
Make Chain a subclass of Always
Always use a plan
.gitignore
Merge branch 'builder' of git://github.com/robertkrimen/path-dispatcher
Some cleanup in Builder
Some cleanup
Begin removing ends_dispatch and before/after
Some more cleanup, killing stages harder
Fully remove stages, yay
Use $builder's next_rule and last_rule
Factor out the builder class
Factor out dispatcher class
Cleanup; make the options to Path::Dispatcher::Declarative, such as
More simplifications
Restore the default of case sensitive tokens
Factor out populating defaults
Make rule_creators a method
Unimport Any::Moose's sugar
Ignore more dist crap
Don't stomp on any rule's existing name
Bring Cookbook up to date, add tests to make sure I'm not lying
Be way more lenient in boxing a path - anything that isn't a
Oops, wrong class name
Don't specify defaults more than needed
0.10 changes
Bump to 0.11
Consistency fixes from confound
Better example, since you should always run coderefs through $match->run
The attribute name is _matches not matches
Another badly named key
clone_object was deprecated
Ignore cover_db
0.11 Changes
Bump to 0.12
Give dispatch rule a "rules" method
Failing test for not preserving undef in run_with_number_vars
Handle undef number vars better
Anchor the regex for efficiency
0.12 changes
Bump to 0.13
Force 0 or 1 for the set_number_vars default
I am a big dummy
Add unshift_rule method
0.13 changes
Revert ? 1 : 0, it was just a weird symptom
Minimum version 5.8.1
Bump Module::Install
Makefile.PL tweaks
Add repository information
Add dist crap to Changes
Bump to 0.14
Add failing test for lazy dispatch
Remove commented out code
Revert "Add failing test for lazy dispatch"
Doc tweaks
Basic tests for completion
Add stub complete method
Okay this one is not simple!
Add an actually-simple test
Refactor _prefix_match out to let rules simplify their match logic
_complete for Eq rules
Promote complete to a public method; stub for all Rules
Test completing on an individual rule
When we try to complete on a dispatcher, let each rule have at it
Refactor Token matching into something with a callback
Remove tracing from Tokens->_match for now
Ease refactoring
Refactor _match so complete will be able to reuse its logic
A complete method for Tokens
Complete paths should not return themselves
Kill EOL whitespace
More tests
complete for Under rules
Add the prefix back in when we complete an Under
complete returns full paths
Remove duplicate completions
A fix for, and more tests for, token matching
Handle delimiters infinitesimally better
Refactor tests to use new complete_ok
Another complete_ok refactor
Painful delimiter tests
First stab at making delimiters work better
Remove excess delimiters in untokenize
Add ->complete to declarative dispatchers
Handle alternations better
More tests to make sure tokens complete properly
Link to path-dispatcher-debugger
Document Dispatcher->complete
0.14 changes (post-release and post-tag, oops :))
Bump to 0.15
Rules of type dispatch forward "complete" requests
Add alternation rules
Empty intersections and alternations do not match
Case insensitivity for Eq rules
First cut of a generic Sequence rule (like Tokens but better)
Some better error checking. Not very happy with this yet.
Sequences are unlike Tokens in that delimiter is mostly unimportant
Make Sequence more tokeney
Need to pass a path object to rule->complete
We want to return the whole path for completion not just the last word
Tests for Sequence + custom rule
Add enum rule for convenience
Factor out path autoboxing
More completion tests
By convention, ->complete does not include the path itself
Add enum sugar to Declarative
Add tests for completing enums
Remove Path::Dispatcher::Declarative
No longer require Sub::Exporter
This doesn't actually warn til much later
0.15 changes thus far
unimport Any::Moose and make_immutable in Sequence
Some doc for Sequence
Fix Enum's doc to not be a copy of Eq's
$2 doesn't make sense here
More doc fixes
Fix Eq's handling of complete with an already-complete path
Completion for Alternation rules
Copyright year
Changes copyediting :)
Bump Module::Install
Documentation for shell tab completion
Use glob assignment instead of regex matching for populating $1 etc
Failing tests for various $1 issues
Clear $1 etc for the block
TODO the stompy test
More tests
Link to my P-D talk
0.16 changes
Remove set_number_vars option
Temporary refactoring patch
Pass match object into rule blocks instead number vars (wip)
Be more specific: positional_captures not result
Fix up first test
Fix up second test file
Validate positional_captures
Default positional_captures to []
Stronger API for returning results from matching
shift off the match
$match->positional_captures not [$1, $2, $3]
test is obsolete
undef is a valid number variable value
Fix uses of ->result
Better error when the _match result is mistyped
More positional_captures stuff
Add a ->pos method to Match
Match documentation update
Make pos 1-indexed like $1 $2..
Add tests for the match object itself
Add named capture support
Tests for named captures
Enforce scalar context at the Match level not Dispatch
Don't bother with this warning
Ignore .prove
Drop BUGS section
Fix release year of 0.15
Make all readwrite attributes readonly
Make _dispatch rule
0.16 changes
Remove trace/name/readable_attributes
Tidy
Another talk :)
Make what you replace clearer
Use ->pos instead of $1 in doc
Test cleanup
Another change
Bump MI
Bump to 0.16
Add ->named($key) for named captures
More doc
Don't use the setter in Chain
Merge branch 'master' of http://github.com/rafl/path-dispatcher
$exception not $xcpt
Use a simpler always-match rule
Bump to 1.00; Changes
Factor out the named_captures eval, much faster this way
Ignore Makefile.old
Use done_testing like Moose does
Better dep list
Give matches a parent match (for Under etc)
Let the caller easily pass extra args to the match constructor
Pass the parent match to the new match's constructor
Tests for capturing Under prefix parameters
More tests for parent matches
Depend on 5.10 for t/026-named-captures.t
A bit more documentation
Changes
According to CPAN Testers you need 5.10.1 :/
Bump to 1.01
Better example class names
A bit about the flexibility and extensibility
Justify "flexible" and "extensible" dispatch
Point to tab completion
HTTPx::Dispatcher is deprecated in favor of Router::Simple
Link to miyagawa's plack-dispatching-samples
Remove shebang from test files
Document why we always die unconditionally
We accidentally untokenized twice
only provide leftover if we need it.
Default leftover to ''
1.02 Changes
Bump to 1.02
Add a test demonstrating custom populating of named_captures
Update copyright
Test for multiple delimiters in a row
Tests for the Chain rule type
gitignore MYMETA.yml (generated by 5.14.0's toolchain)
Refactor to present a generic "payload" instead of requiring a "block"
Delegate match->payload to match->rule->payload
Test for arbitrary payloads
Make sure running dispatches gives a sane error message
Better toolchaining
Remove inc
More gitignore
1.03 and its Changes
Convert all tests to Test::Fatal
1.04 and its Changes
Force blead to provide $' if we need it
1.05 and its Changes
Merge pull request #1 from chrestomanci/Dist-Zilla-deployment
1.06 and its Changes
gitignore output files
clkao (1):
fix test plan.
robertkrimen (5):
Added missing -base to use in SYNOPSIS
Added slash-path-delimeter recipe w/test
Don't display 'then' dox
Added rudimentary chaining support in the form of a new rule and a new
Created Path::Dispatcher::Builder
sartak (267):
Project layout
Begin the API (upon which the sugar will be built)
Reify rules
Tweak rule a little, add matches and run methods
Flesh out the dispatch code
Better test Jifty::Dispatcher compat - each rule coderef receives no arguments
Refactor the dispatcher rule, solidify the "match" method
Add more tests
Keep track of $1 and friends, and populate them at the right time
More rule tests
Make sure that the dispatch thunk sets $1 etc properly
Return undef when dispatch 404s, tests for it
Run rules in stages
Pass the current match state to begin/end stage methods
Make attributes read-only for sanity/optimization purposes
Allow rules to be "fallthrough" or not; by default, "on" rules are not fallthrough, others are
(Failing) tests for aborting the dispatch
Implement aborting the dispatch by die-ing with a special value
Support for arbitrary dispatch matching with coderefs (so we can support Jifty::Dispatcher's "when" rule type)
Begin Path::Dispatcher::Declarative
Figure out how sugar will be distributed
Add "on", more tests
Add (failing) tests for layering dispatcher rules across subclasses
Add failing tests for having a super dispatcher
Support (and more tests for) "super" dispatchers
Small refactor to give defer_to_super_dispatcher more control
Support for super dispatchers in the sugar layer
Support for named dispatchers
Declarative dispatchers take their name from the package into which they're installed
Support for adding stages (plugins!) and adding rules to before/on/after any stage. Rename the before and after stages to first and last.
Failing tests for dispatching with arguments
We can now pass arguments to each rule's block from "run" or invoking the coderef returned by "dispatch"
Make sure that we return no useful value, so we don't have to worry about backwards compatibility when we figure out how to return values from a dispatch/run
Throw an error if "use Path::Dispatcher -base" or similar is used
"use MyApp::Dispatcher" should not export sugar. but "use MyFramework::Dispatcher -base" should
ignore blib
Reify dispatch and dispatch match, refactor super dispatcher to just splat its matches into the current dispatch's matches
Move the "invoke match" logic into match where it belongs (and now can be subclassed to do interesting things)
add_rule should not silently create new rules, because we'll be getting multiple rule subclasses
We also don't need rule_class any more
Add some Rule subclasses: CodeRef, Regex, Tokens. Regex will probably be subsumed by Tokens
Remove the logic in Rule that is controlled by subclasses
Test fixes for the API change in add_rule
Simplest implementation of tokens rule
Refactor out the qualifying-stage-names code
Always redispatch (now more extensibly), subclasses can disable this for efficiency if they wish
Reify dispatch stage so we can have more logic in it
Allow rules to have a stage object or name
Solidify when a match ends the current stage by adding a method to the stage class
Be more helpful in "use Path::Dispatcher 'foo'"
Clean up some old code
Rules now belong to stages. Rules are now also stage-agnostic. Much cleaner code and concepts :)
Misc cleanup
Assign dispatcher names based on class name, instead of always Path::Dispatcher
Remove another vestigial line
Remove the first and last stages. If apps want them, they can add them
Finally pass all tests by asking stages if we should allow redispatch
Remove begin_stage/end_stage, they'll be better off as method modifiers in a commit or two
Begin refactoring the redispatch logic to instead have stages with match_ends_dispatch. If no stage with match_ends_dispatch has a rule that matched, then we'll redispatch.
Break up dispatch into a bunch of specialized methods
Add the concept of a "cleanup" stage, a stage that still runs after a dispatch abruptly ends in a stage
Check for, and run, cleanup stages if we abort the dispatch
Support multiple dispatches when we redispatch (for plugins or MI)
We need to "stop" during run, not dispatch, because if something calls next_rule, it's akin to $self->SUPER::method
Eureka. Matching against the empty regex is totally nondeterministic because of older Perl's optimization of //
Support for continuing on to the next rule as if the current rule hadn't been matched (next_rule)
Did I really spell it Patch in four different places?
Add sugar for next/last rule
Make sure we clear number variables if we don't do an empty-string match
Oh. Dynamic scope.
Invoke the "outermost" dispatcher when using declarative's dispatch/run
Here shall go the ugly match logic
Clean up die handling and expected exceptions (heh).. halve the number of evals we wrap around rule-running code
Tests for what the rule closures receive as input. Needs improvement!
Set $_ to the path we matched against
We can't discard the invocant if run/dispatch are used as sugar
todoify some tests
Remove "cleanup stage" for now
Minor code cleanup
Downgrade MI to 0.70
dist doc
Bump to 0.02
Add a synopsis which uses the API
Add an "intersection" compound rule
Allow regexes in the token matcher, and write tests
Support for alternation in the tokens rules
Better intuition of rule class in Path::Dispatcher::Declarative
Avoid undef warnings and possible false positives by bailing out if we run out of input
Begin implementation of prefix matching
Support for prefix matches in the tokens rule, rename the attribute "splitter" to "delimiter"
Add tests for prefix matches
Regex prefix implementation and tests
Return undef if there's no match in Intersection
Remove intersections for now, not worth supporting them if they're not being used yet
Consistency in the test
Make the code black optional
Refactor: the rule returns the match, instead of returning results
Promote Match out of Dispatch/ (1/2)
Promote Match out of Dispatch/ (2/2)
Remove stages! They kind of muddy things for little benefit at this point
More explicit support for multiple matches from a rule, etc
Fixes for the rules attr in Path::Dispatcher
"under" rules
More substantial tests for under
Grep out 0-length tokens
More under tests.. looking good.. :)
Make attributes rw
Blocks are no longer required, so don't pass block => undef and trip the type constraint
Split the create/add phases of declarative rule creation
Misc incisions
Initial support for "under" but it won't compose with itself so we need more syntax
Allow passing in an already-instantiated rule to _add_rule
Figure out a syntax for under rules that works well enough for v1
Use the empty string for no leftover instead of undef
Require that declarative dispatchers inherit from Path::Dispatcher::Declarative, for sanity (and feature) reasons
Make the helper functions in PDD methods so we can have methods that subclasses override
Allow dispatchers to override the token delimiter
Better error in a Rule class without _match
Doc for the primary Path::Dispatcher module
Doc for Path::Dispatcher::Rule
Rule::CodeRef doc
Rule::Regex doc
Rule::Tokens doc
Require that the predicate of an under rule match just a prefix
Rule::Under doc
Make under rules immutable and remove their sugar
Match doc
Dispatch doc, that covers all of the classes
Changes
Basic doc for Declarative
Bump to 0.03
Typo fixes in the doc
Factor out (un)tokenization into methods
Require "-base" because otherwise "use MyApp::Dispatcher" fails when we just want to use it
Remove super dispatchers, redispatching will simply be a rule type
Remove add_redispatch
Path::Dispatcher::Rule::Dispatch which is a much saner and more flexible "super dispatcher"
"match" is what returns the PD::Match objects, not "_match"
For now we need to inform the dispatcher of the super dispatcher, hopefully this can become automatic in the future
Don't settle for matching a prefix if the tokens rule does not want to be prefix matched
Rename "run" to "redispatch"
Add "rewrite" sugar
Pass on args
Rename redispatch back to run, it's not worth having separate
Add a rewrite example to the PDD synopsis
Changes
Prior art etc :)
Bump to 0.04
Oops, forgot to regenerate the signature
Bump to 0.05
Skeleton of the Rule::Dispatch doc
It's called init_arg not init_args
Pass through return values
Each match gets a scalar result
Add tests for run returning values
Test fixes
Turn ends_dispatch into an attribute
Make tests work!
Changes thus far
Add support for case insensitive matching in tokens rules
Plenty of tokens tests
Allow a declarative dispatcher to decide whether it wants its token-rules to be case sensitive
Tests for token_delimiter and case_sensitive_tokens config
Include the regex in the (unlikely) error just in case
Fill in the blanks of the PDRD synopsis :)
Test that "use Path::Dispatcher -base" throws a helpful error
Ignore cover_db
Add an alias "has_match"
Test that the matcher returning the wrong thing throws an error. This will probably never come up in practice but it is a limitation for now
We require Test::Exception now
first_match
Test that trying to run a rule that lacks a coderef is an error
No need to throw an explicit error here, Perl gives an even better method-missing error
Argh, fix the type constraint check for tokens
Test coverage improvements
Make the Tokens type constraint do what I actually want it to; TODO: make it sane
Remove the "if length(leftover) && !prefix" check; it doesn't actually make sense
Ensure that token matching is by default case sensitive in the declarative dispatcher
Doc, ignore Makefile.old
Add redispatch_to sugar
Begin improving the declarative tests
declarative abort test fixes
t/103-input test fixes
Remove t/lib
Make sure that redispatching directly to a dispatcher object works too
Plan fix
Mention in the top-level doc that run passes on args to each codeblock
Add an Always rule
Special case on '' => sub {} to match everything
Update Changes
Bump to 0.06
Add an "empty" rule
Class name fix
Make "on ''" match only the empty path
Change
Bump to 0.07
PD::Path class
First cut of conversion to use path objects
Missed a spot
Support for single string arg in new: Path::Dispatcher::Path->new("/my/path")
In rule codeblocks, have $_ be the path string not the path object
Test fixes
Factor out the "collection of rules" attribute into a role
Implementation of an "intersection" rule; all its rules must match
Tests for intersections
First pass at a Metadata matching rule
Pass in the right value
Path->get_metadata (which can be overridden by subclasses!)
Make metadata only match a single metadata value
Begin writing tests for metadata
Simple rule: Eq, which tests: path eq $string
Refactor Metadata to take a rule for matching the metadata
Test to make sure that path + metadata matching works, as that'll be the most common use case for intersections
Let rules have an optional name, for tracing
Begin implementing a debugging tracer
Declarative dispatcher sets rule name
Trace running codeblocks
Don't require under rules be named when naming subrules
Cleanup
Add the under rule earlier so it gets a name for subrules to use
Include "readable attributes" in the trace (regex, tokens, etc)
Begin giving rules readable_attributes
Rename the metadata key from "name" to "field" because "name" is now used for all rules
Don't include the stringified rule if we have a name
Slightly better rule name formatting (parent - rule file:line)
Trace levels; 2 turns on readable_attributes, 10 turns on deparsing of run blocks
Token match tracing
See also: HTTPx-Dispatcher
use the Eq rule for string predicates
Prefix matching for Eq rules
Test fixes, this kind of sucks
Revert that; tokens are more useful
Tokens' readable_attributes
Doh! Forgot to include the delimiter in the non-ref rules. (Also case sensitivity.. whimper)
Rename the empty rule test from its old name, "always"
TODO tests for under dwimming wrt path
Stringify Path::Dispatcher::Path into the path, so that wise users can call methods on it to get metadata etc
Ignore .prove
Cleanup
Verbiage tweaks
Remove shebangs; no need for them
More cleanup
Some doc for Path::Dispatcher::Path
On sufficiently high levels, dump CodeRef's matcher attribute too
Test fix, since error text changed
Lots of Changes!
Refactor cloning path objects but changing the path inside it into $path->clone_path($new_path)
Refactor to avoid code duplication
Begin writing overview doc for Path::Dispatcher::Declarative
Pass $stage to rule_creators
Metadata sugar
Tests for metadata-matching sugar
(Failing) tests for metadata deep data structures
More Changes
Bump to 0.08
Inline uses of MooseX::AttributeHelpers
Depend on Moose::Util::TypeConstraints less
Any::Moose-ify Path::Dispatcher
The actual error is that Mouse doesn't support custom TC failure messages; that's acceptable for now
Update Changes for Any::Moose
Changes time
Bump to 0.09
Avoid using method modifiers since it'd be a new dep when Mouse is used
Update Changes
Bump to 0.10
Update copyright year
No need to futz with @- and @+, since a regex match in list context returns $1, $2, ...
-----------------------------------------------------------------------
No new revisions were added by this update.
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-perl/packages/libpath-dispatcher-perl.git
More information about the Pkg-perl-cvs-commits
mailing list