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 _______________________________________________ Pkg-perl-cvs-commits mailing list Pkg-perl-cvs-commits@lists.alioth.debian.org http://lists.alioth.debian.org/cgi-bin/mailman/listinfo/pkg-perl-cvs-commits