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://
      Merge branch 'master' of git://
      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
      Merge branch 'builder' of git://
      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
      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
      $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
      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 
      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 
      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 
      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
      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
      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
      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
      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: 
      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
      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
      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 
      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 

Pkg-perl-cvs-commits mailing list

Reply via email to