File: README.md

package info (click to toggle)
ruby-fuzzyurl 0.8.0-1
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, buster, sid, stretch
  • size: 148 kB
  • ctags: 30
  • sloc: ruby: 517; makefile: 3
file content (96 lines) | stat: -rw-r--r-- 3,178 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
# Fuzzyurl

[![Build Status](https://travis-ci.org/gamache/fuzzyurl.rb.svg?branch=master)](https://travis-ci.org/gamache/fuzzyurl.rb)

Non-strict parsing, composition, and wildcard matching of URLs in
Ruby.

## Introduction

Fuzzyurl provides two related functions: non-strict parsing of URLs or
URL-like strings into their component pieces (protocol, username, password,
hostname, port, path, query, and fragment), and fuzzy matching of URLs
and URL patterns.

Specifically, URLs that look like this:

    [protocol ://] [username [: password] @] [hostname] [: port] [/ path] [? query] [# fragment]

Fuzzyurls can be constructed using some or all of the above
fields, optionally replacing some or all of those fields with a `*`
wildcard if you wish to use the Fuzzyurl as a URL mask.


## Installation


## Parsing URLs

    irb> Fuzzyurl.from_string("https://api.example.com/users/123?full=true")
    #=> #<Fuzzyurl:0x007ff55b914f58 @protocol="https", @username=nil, @password=nil, @hostname="api.example.com", @port=nil, @path="/users/123", @query="full=true", @fragment=nil>


## Constructing URLs

    irb> f = Fuzzyurl.new(hostname: "example.com", protocol: "http", port: "8080")
    irb> f.to_s
    #=> "http://example.com:8080"


## Matching URLs

Fuzzyurl supports wildcard matching:

* `*` matches anything, including `null`.
* `foo*` matches `foo`, `foobar`, `foo/bar`, etc.
* `*bar` matches `bar`, `foobar`, `foo/bar`, etc.

Path and hostname matching allows the use of a greedier wildcard `**` in
addition to the naive wildcard `*`:

* `*.example.com` matches `filsrv-01.corp.example.com` but not `example.com`.
* `**.example.com` matches `filsrv-01.corp.example.com` and `example.com`.
* `/some/path/*` matches `/some/path/foo/bar` and `/some/path/`
   but not `/some/path`
* `/some/path/**` matches `/some/path/foo/bar` and `/some/path/`
   and `/some/path`

The `Fuzzyurl.mask` function aids in the creation of URL masks.

    irb> Fuzzyurl.mask
    #=> #<Fuzzyurl:0x007ff55b039578 @protocol="*", @username="*", @password="*", @hostname="*", @port="*", @path="*", @query="*", @fragment="*">

    irb> Fuzzyurl.matches?(Fuzzyurl.mask, "http://example.com:8080/foo/bar")
    #=> true

    irb> mask = Fuzzyurl.mask(path: "/a/b/**")
    irb> Fuzzyurl.matches?(mask, "https://example.com/a/b/")
    #=> true
    irb> Fuzzyurl.matches?(mask, "git+ssh://jen@example.com/a/b/")
    #=> true
    irb> Fuzzyurl.matches?(mask, "https://example.com/a/bar")
    #=> false

`Fuzzyurl.bestMatch`, given a list of URL masks and a URL, will return
the given mask which most closely matches the URL:

    irb> masks = ["/foo/*", "/foo/bar", Fuzzyurl.mask]
    irb> Fuzzyurl.best_match(masks, "http://example.com/foo/bar")
    #=> "/foo/bar"

If you'd prefer the array index instead of the matching mask itself, use
`Fuzzyurl.best_match_index` instead:

    irb> Fuzzyurl.best_match_index(masks, "http://example.com/foo/bar")
    #=> 1


## Authorship and License

Fuzzyurl is copyright 2014-2015, Pete Gamache.

Fuzzyurl is released under the MIT License.  See LICENSE.txt.

If you got this far, you should probably follow me on Twitter.
[@gamache](https://twitter.com/gamache)