fuzzyurl 0.2.3 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 24a55de22cf177f22d5d1b7806bffdcd35a812b2
-  data.tar.gz: 8b76e9e3d219f5d956ed8670b666decaca4c066e
+  metadata.gz: b8bc03d75fbe841afed852424c2123761aeff21b
+  data.tar.gz: 0124a1e435856981f3088a25c9ca7348b172d4b8
 SHA512:
-  metadata.gz: 869d297098009d1f17f2e9ab24c42113973add4cd42a8a076d2a10fca91e0ff1ee3f06216de1b7dd1ee5d7dff793bcebfa68c2e27b82063130c301207c8863d0
-  data.tar.gz: 7f7a52b6498061ce98a69556822e8db7dcf1f75b6d4c7fe856654cfb237b9a2abd218571f1a3630539ee6fa9123aa70960ec0d1d68111ef3b77fd8e254b7d32e
+  metadata.gz: 3acd8d87e7df1e4ae87c91e9edde769b84c1b1bd993d7f8275a19d06f2a611384c5af8ca8e7eba1542c06404aedd7161d313b6577ae5c16e84507ce39b41ca9e
+  data.tar.gz: 18eef24b09a6f54690e6ebe53db791a07188050e8fae0fb652db938f076403941c4c2557b1eaf6f9f1eacee4d788fe6d7ee9333eef6ffa215ea2333cd2faaaf6

data/lib/fuzzyurl/fields.rb

@@ -0,0 +1,13 @@
+class Fuzzyurl
+  FIELDS = [
+    :protocol,
+    :username,
+    :password,
+    :hostname,
+    :port,
+    :path,
+    :query,
+    :fragment
+  ]
+end
+

data/lib/fuzzyurl/match.rb

@@ -0,0 +1,127 @@
+require 'fuzzyurl/protocols'
+
+class Fuzzyurl::Match
+  class << self
+
+    # If `mask` (which may contain * wildcards) matches `url` (which may not),
+    # returns an integer representing how closely they match (higher is closer).
+    # If `mask` does not match `url`, returns null.
+    #
+    # @param mask [Fuzzyurl] Fuzzyurl mask to match with
+    # @param url [Fuzzyurl] Fuzzyurl URL to match
+    # @returns [Fuzzyurl] Fuzzyurl-like object containing match scores
+    def match(mask, url)
+      scores = match_scores(mask, url)
+      return nil if scores.values.include?(nil)
+      scores.values.reduce(:+)
+    end
+
+
+    # If `mask` (which may contain * wildcards) matches `url` (which may not),
+    # returns true; otherwise returns false.
+    #
+    # @param mask [Fuzzyurl] Fuzzyurl mask to match with
+    # @param url [Fuzzyurl] Fuzzyurl URL to match
+    # @returns [Fuzzyurl] Fuzzyurl-like object containing match scores
+    def matches?(mask, url)
+      match(mask, url) != nil
+    end
+
+
+    # Returns a Fuzzyurl-like object containing values representing how well
+    # different parts of `mask` and `url` match.  Values are integers for
+    # matches or null for no match; higher integers indicate a better match.
+    #
+    # @param mask [Fuzzyurl] Fuzzyurl mask to match with
+    # @param url [Fuzzyurl] Fuzzyurl URL to match
+    # @returns [Hash] Hash containing match scores for each field
+    def match_scores(mask, url)
+      url_protocol = url.protocol || Fuzzyurl::Protocols.get_protocol(url.port)
+      url_port = url.port || Fuzzyurl::Protocols.get_port(url.protocol)
+      {
+        protocol: fuzzy_match(mask.protocol, url_protocol),
+        username: fuzzy_match(mask.username, url.username),
+        password: fuzzy_match(mask.password, url.password),
+        hostname: fuzzy_match(mask.hostname, url.hostname),
+        port: fuzzy_match(mask.port, url_port),
+        path: fuzzy_match(mask.path, url.path),
+        query: fuzzy_match(mask.query, url.query),
+        fragment: fuzzy_match(mask.fragment, url.fragment)
+      }
+    end
+
+
+    # From a list of Fuzzyurl `masks`, returns the index of the one which best
+    # matches `url`.  Returns null if none of `masks` match.
+    #
+    # @param [Array] Array of Fuzzyurl URL mask objects to match with.
+    # @param [Fuzzyurl] Fuzzyurl URL to match.
+    # @returns [Integer|nil] Index of best matching mask, or null if none match.
+    def best_match_index(masks, url)
+      best_index = nil
+      best_score = -1
+      masks.each_with_index do |mask, i|
+        score = match(mask, url)
+        if score && score > best_score
+          best_score = score
+          best_index = i
+        end
+      end
+      best_index
+    end
+
+
+    # If `mask` (which may contain * wildcards) matches `url` (which may not),
+    # returns 1 if `mask` and `url` match perfectly, 0 if `mask` and `url`
+    # are a wildcard match, or null otherwise.
+    #
+    # Wildcard language:
+    #
+    #     *              matches anything
+    #     foo/*          matches "foo/" and "foo/bar/baz" but not "foo"
+    #     foo/**         matches "foo/" and "foo/bar/baz" and "foo"
+    #     *.example.com  matches "api.v1.example.com" but not "example.com"
+    #     **.example.com matches "api.v1.example.com" and "example.com"
+    #
+    # Any other form is treated as a literal match.
+    #
+    # @param mask [String] String mask to match with (may contain wildcards).
+    # @param value [String] String value to match.
+    # @returns [Integer|nil] 0 for wildcard match, 1 for perfect match, else nil.
+    def fuzzy_match(mask, value)
+      return 0 if mask == "*"
+      return 1 if mask == value
+      return nil if !mask || !value
+
+      if mask.index("**.") == 0
+        mask_value = mask[3..-1]
+        return 0 if value.end_with?(".#{mask_value}")
+        return 0 if mask_value == value
+        return nil
+      end
+      if mask.index("*") == 0
+        return 0 if value.end_with?(mask[1..-1])
+        return nil
+      end
+
+      rev_mask = mask.reverse
+      rev_value = value.reverse
+
+      if rev_mask.index("**/") == 0
+        rev_mask_value = rev_mask[3..-1]
+        return 0 if rev_value.end_with?("/#{rev_mask_value}")
+        return 0 if rev_mask_value == rev_value
+        return nil
+      end
+
+      if rev_mask.index("*") == 0
+        return 0 if rev_value.end_with?(rev_mask[1..-1])
+        return nil
+      end
+
+      nil
+    end
+
+  end
+end
+

data/lib/fuzzyurl/protocols.rb

@@ -0,0 +1,26 @@
+class Fuzzyurl::Protocols
+  PORTS_BY_PROTOCOL = {
+    'ssh' => '22',
+    'http' => '80',
+    'https' => '443'
+  }
+
+  PROTOCOLS_BY_PORT = {
+    '22' => 'ssh',
+    '80' => 'http',
+    '443' => 'https'
+  }
+
+  class << self
+    def get_port(protocol)
+      return nil unless protocol
+      base_protocol = protocol.split('+').last
+      PORTS_BY_PROTOCOL[base_protocol.to_s]
+    end
+
+    def get_protocol(port)
+      PROTOCOLS_BY_PORT[port.to_s]
+    end
+  end
+end
+

data/lib/fuzzyurl/strings.rb

@@ -0,0 +1,56 @@
+require 'fuzzyurl/fields'
+
+class Fuzzyurl::Strings
+  REGEX = %r{
+    ^
+    (?: (?<protocol> \* | [a-zA-Z][A-Za-z+.-]+) ://)?
+    (?: (?<username> \* | [a-zA-Z0-9%_.!~*'();&=+$,-]+)
+        (?: : (?<password> \* | [a-zA-Z0-9%_.!~*'();&=+$,-]*))?
+        @
+    )?
+    (?<hostname> [a-zA-Z0-9\.\*\-]+?)?
+    (?: : (?<port> \* | \d+))?
+    (?<path> / [^\?\#]*)?                 ## captures leading /
+    (?: \? (?<query> [^\#]*) )?
+    (?: \# (?<fragment> .*) )?
+    $
+  }x
+
+  class << self
+
+    def from_string(str, opts={})
+      return nil unless str.kind_of?(String)
+
+      default = opts[:default]
+      if m = REGEX.match(str)
+        fu = Fuzzyurl.new
+        Fuzzyurl::FIELDS.each do |f|
+          fu.send("#{f}=", m[f] || default)
+        end
+        fu
+      else
+        raise ArgumentError, "Couldn't parse url string: #{str}"
+      end
+    end
+
+    def to_string(fuzzyurl)
+      if !fuzzyurl.kind_of?(Fuzzyurl)
+        raise ArgumentError, "`fuzzyurl` must be a Fuzzyurl"
+      end
+
+      fu = fuzzyurl
+      str = ""
+      str << "#{fu.protocol}://" if fu.protocol
+      str << "#{fu.username}" if fu.username
+      str << ":#{fu.password}" if fu.password
+      str << "@" if fu.username
+      str << "#{fu.hostname}" if fu.hostname
+      str << ":#{fu.port}" if fu.port
+      str << "#{fu.path}" if fu.path
+      str << "?#{fu.query}" if fu.query
+      str << "##{fu.fragment}" if fu.fragment
+      str
+    end
+
+  end
+end

data/lib/fuzzyurl/version.rb

@@ -0,0 +1,5 @@
+class Fuzzyurl
+  VERSION = "0.8.0"
+  VERSION_DATE = "2015-12-25"
+end
+

data/lib/fuzzyurl.rb

@@ -1,2 +1,194 @@
-require 'fuzzy_url'
+require 'fuzzyurl/version'
+require 'fuzzyurl/fields'
+require 'fuzzyurl/protocols'
+require 'fuzzyurl/match'
+require 'fuzzyurl/strings'
+
+class Fuzzyurl
+  FIELDS.each {|f| attr_accessor f}
+
+  # Creates a new Fuzzyurl object from the given params or URL string.
+  # Keys of `params` should be symbols.
+  #
+  # @param params [Hash|String|nil] URL string or parameter hash.
+  # @return [Fuzzyurl] New Fuzzyurl object.
+  def initialize(params={})
+    p = params.kind_of?(String) ? Fuzzyurl.from_string(params).to_hash : params
+    (FIELDS & p.keys).each do |f|
+      self.send("#{f}=", p[f])
+    end
+  end
+
+  # Returns a hash representation of this Fuzzyurl, with one key/value pair
+  # for each of `Fuzzyurl::FIELDS`.
+  #
+  # @return [Hash] Hash representation of this Fuzzyurl.
+  def to_hash
+    FIELDS.reduce({}) do |hash, f|
+      val = self.send(f)
+      val = val.to_s if val
+      hash[f] = val
+      hash
+    end
+  end
+
+  # Returns a new copy of this Fuzzyurl, with the given params changed.
+  #
+  # @param params [Hash|nil] New parameter values.
+  # @return [Fuzzyurl] Copy of `self` with the given parameters changed.
+  def with(params={})
+    fu = Fuzzyurl.new(self.to_hash)
+    (FIELDS & params.keys).each do |f|
+      fu.send("#{f}=", params[f].to_s)
+    end
+    fu
+  end
+
+  # Returns a string representation of this Fuzzyurl.
+  #
+  # @return [String] String representation of this Fuzzyurl.
+  def to_s
+    Fuzzyurl::Strings.to_string(self)
+  end
+
+  # @private
+  def ==(other)
+    self.to_hash == other.to_hash
+  end
+
+
+  class << self
+
+    # Returns a Fuzzyurl suitable for use as a URL mask, with the given
+    # values optionally set from `params` (Hash or String).
+    #
+    # @param params [Hash|String|nil] Parameters to set.
+    # @return [Fuzzyurl] Fuzzyurl mask object.
+    def mask(params={})
+      params ||= {}
+      return from_string(params, default: "*") if params.kind_of?(String)
+
+      m = Fuzzyurl.new
+      FIELDS.each do |f|
+        m.send("#{f}=", params.has_key?(f) ? params[f].to_s : "*")
+      end
+      m
+    end
+
+    # Returns a string representation of `fuzzyurl`.
+    #
+    # @param fuzzyurl [Fuzzyurl] Fuzzyurl to convert to string.
+    # @return [String] String representation of `fuzzyurl`.
+    def to_string(fuzzyurl)
+      Fuzzyurl::Strings.to_string(fuzzyurl)
+    end
+
+    # Returns a Fuzzyurl representation of the given URL string.
+    # Any fields not present in `str` will be assigned the value
+    # of `opts[:default]` (defaults to nil).
+    #
+    # @param str [String] String URL to convert to Fuzzyurl.
+    # @param opts [Hash|nil] Options.
+    # @return [Fuzzyurl] Fuzzyurl representation of `str`.
+    def from_string(str, opts={})
+      Fuzzyurl::Strings.from_string(str, opts)
+    end
+
+    # Returns an integer representing how closely `mask` matches `url`
+    # (0 means wildcard match, higher is closer), or nil for no match.
+    #
+    # `mask` and `url` may each be Fuzzyurl or String format.
+    #
+    # @param mask [Fuzzyurl|String] URL mask.
+    # @param url [Fuzzyurl|String] URL.
+    # @return [Integer|nil] 0 for wildcard match, 1 for perfect match, or nil.
+    def match(mask, url)
+      m = mask.kind_of?(Fuzzyurl) ? mask : Fuzzyurl.mask(mask)
+      u = url.kind_of?(Fuzzyurl) ? url : Fuzzyurl.from_string(url)
+      Fuzzyurl::Match.match(m, u)
+    end
+
+    # Returns true if `mask` matches `url`, false otherwise.
+    #
+    # `mask` and `url` may each be Fuzzyurl or String format.
+    #
+    # @param mask [Fuzzyurl|String] URL mask.
+    # @param url [Fuzzyurl|String] URL.
+    # @return [Boolean] Whether `mask` matches `url`.
+    def matches?(mask, url)
+      m = mask.kind_of?(Fuzzyurl) ? m : Fuzzyurl.mask(m)
+      u = url.kind_of?(Fuzzyurl) ? u : Fuzzyurl.from_string(u)
+      m = mask.kind_of?(Fuzzyurl) ? mask : Fuzzyurl.mask(mask)
+      u = url.kind_of?(Fuzzyurl) ? url : Fuzzyurl.from_string(url)
+      Fuzzyurl::Match.matches?(m, u)
+    end
+
+    # Returns a Hash of match scores for each field of `mask` and
+    # `url`, indicating the closeness of the match.  Values are from
+    # `fuzzy_match`: 0 indicates wildcard match, 1 indicates perfect
+    # match, and nil indicates no match.
+    #
+    # `mask` and `url` may each be Fuzzyurl or String format.
+    #
+    # @param mask [Fuzzyurl|String] URL mask.
+    # @param url [Fuzzyurl|String] URL.
+    def match_scores(mask, url)
+      m = mask.kind_of?(Fuzzyurl) ? m : Fuzzyurl.mask(m)
+      u = url.kind_of?(Fuzzyurl) ? u : Fuzzyurl.from_string(u)
+      m = mask.kind_of?(Fuzzyurl) ? mask : Fuzzyurl.mask(mask)
+      u = url.kind_of?(Fuzzyurl) ? url : Fuzzyurl.from_string(url)
+      Fuzzyurl::Match.match_scores(m, u)
+    end
+
+    # Given an array of URL masks, returns the array index of the one which
+    # most closely matches `url`, or nil if none match.
+    #
+    # `url` and each element of `masks` may be Fuzzyurl or String format.
+    #
+    # @param masks [Array] Array of URL masks.
+    # @param url [Fuzzyurl|String] URL.
+    # @return [Integer|nil] Array index of best-matching mask, or nil for no match.
+    def best_match_index(masks, url)
+      ms = masks.map {|m| m.kind_of?(Fuzzyurl) ? m : Fuzzyurl.mask(m)}
+      u = url.kind_of?(Fuzzyurl) ? url : Fuzzyurl.from_string(url)
+      Fuzzyurl::Match.best_match_index(ms, u)
+    end
+
+    # Given an array of URL masks, returns the one which
+    # most closely matches `url`, or nil if none match.
+    #
+    # `url` and each element of `masks` may be Fuzzyurl or String format.
+    #
+    # @param masks [Array] Array of URL masks.
+    # @param url [Fuzzyurl|String] URL.
+    # @return [Integer|nil] Best-matching given mask, or nil for no match.
+    def best_match(masks, url)
+      index = best_match_index(masks, url)
+      index && masks[index]
+    end
+
+    # If `mask` (which may contain * wildcards) matches `url` (which may not),
+    # returns 1 if `mask` and `url` match perfectly, 0 if `mask` and `url`
+    # are a wildcard match, or null otherwise.
+    #
+    # Wildcard language:
+    #
+    #     *              matches anything
+    #     foo/*          matches "foo/" and "foo/bar/baz" but not "foo"
+    #     foo/**         matches "foo/" and "foo/bar/baz" and "foo"
+    #     *.example.com  matches "api.v1.example.com" but not "example.com"
+    #     **.example.com matches "api.v1.example.com" and "example.com"
+    #
+    # Any other form is treated as a literal match.
+    #
+    # @param mask [String] String mask to match with (may contain wildcards).
+    # @param value [String] String value to match.
+    # @returns [Integer|nil] 0 for wildcard match, 1 for perfect match, else nil.
+    def fuzzy_match(mask, value)
+      Fuzzyurl::Match.fuzzy_match(mask, value)
+    end
+
+  end # class << self
+
+end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fuzzyurl
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.8.0
 platform: ruby
 authors:
 - Pete Gamache
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-25 00:00:00.000000000 Z
+date: 2015-12-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -52,22 +52,33 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.13.3
-description: |2
-      FuzzyURL provides two related functions: fuzzy matching of a URL to a URL
-      mask that can contain wildcards, and non-strict parsing of URLs into their
-      component pieces: protocol, username, password, hostname, port, path,
-      query, and fragment.
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
 email: pete@gamache.org
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/fuzzy_url.rb
-- lib/fuzzy_url/matching.rb
-- lib/fuzzy_url/url_components.rb
-- lib/fuzzy_url/version.rb
 - lib/fuzzyurl.rb
-homepage: https://github.com/gamache/fuzzyurl
+- lib/fuzzyurl/fields.rb
+- lib/fuzzyurl/match.rb
+- lib/fuzzyurl/protocols.rb
+- lib/fuzzyurl/strings.rb
+- lib/fuzzyurl/version.rb
+homepage: https://github.com/gamache/fuzzyurl.rb
 licenses:
 - MIT
 metadata: {}
@@ -79,7 +90,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.8.7
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -87,8 +98,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
-summary: Non-strict URL parsing and URL fuzzy matching.
+summary: A library for non-strict parsing, construction, and wildcard-matching of
+  URLs.
 test_files: []

data/lib/fuzzy_url/matching.rb

@@ -1,120 +0,0 @@
-class FuzzyURL
-
-  ## FuzzyURL::Matching provides the logic for 
-  module Matching
-
-    def self.included(klass)
-      klass.extend(ClassMethods)
-    end
-
-    module ClassMethods
-
-      ## Compares a URL mask hash with a URL hash.
-      ## Returns nil on negative match, and an integer match score otherwise.
-      ## This match score is higher for more specific matches.
-      def match_hash(mask, url)
-        score = 0
-        tally = Proc.new {|x| return nil unless x; score += x}
-
-        tally.call match_hostnames(mask[:hostname], url[:hostname])
-        tally.call match_protocols_and_ports(mask, url)
-        tally.call match_paths(mask[:path], url[:path])
-        tally.call fuzzy_match(mask[:query], url[:query])
-        tally.call fuzzy_match(mask[:username], url[:username])
-        tally.call fuzzy_match(mask[:password], url[:password])
-        tally.call fuzzy_match(mask[:fragment], url[:fragment])
-      end
-
-    private
-
-      ## Matches a URL mask hash against a URL hash.
-      ## Returns true on positive match, false otherwise.
-      def matches_hash?(mask, url)
-        match_hash(mask, url) ? true : false
-      end
-
-      ## Matches protocol and port information.
-      ## Returns nil for no match, 0 if two wildcard matches were made, 1 if
-      ## one wildcard match was made, and 2 for an exact match.
-      def match_protocols_and_ports(mask_hash, url_hash)
-        wildcard_matches = 0
-        mask_protocol = mask_hash[:protocol] || 'http'
-        url_protocol = url_hash[:protocol] || 'http'
-        if mask_hash[:protocol] && mask_protocol != '*'
-          return nil if mask_protocol != url_protocol
-        else
-          wildcard_matches += 1
-        end
-
-        mask_port = mask_hash[:port]
-        url_port = url_hash[:port] # || PORT_BY_PROTOCOL[url_protocol]
-
-        if !mask_port || mask_port == '*'
-          wildcard_matches += 1
-        elsif !url_port && PORT_BY_PROTOCOL[url_protocol] == mask_port.to_i
-          wildcard_matches += 1
-        elsif mask_port == url_port
-          ## cool
-        else
-          ## not cool
-          return nil
-        end
-
-        (2 - wildcard_matches)
-      end
-
-      PORT_BY_PROTOCOL = {
-        'http'  => 80,
-        'https' => 443,
-      }
-
-      ## Matches a picee of a mask against a piece of a URL.  Handles wildcards.
-      ## Returns nil for no match, 0 for a wildcard match, or 1 for an
-      ## exact match.
-      def fuzzy_match(mask, piece)
-        return 0 if !mask || mask == '*'    # || !piece
-        return 1 if mask == piece
-        nil
-      end
-
-      ## Matches a hostname mask against a hostname.
-      ## Returns nil for no match, 0 for a wildcard match, or 1 for an
-      ## exact match.
-      def match_hostnames(mask, host)
-        mask_pieces = (mask || '').split('.').reverse
-        host_pieces = (host || '').split('.').reverse
-        return 1 if mask && host && mask_pieces==host_pieces
-        return 0 if match_pieces(mask_pieces, host_pieces, :ignore_depth => false)
-        nil
-      end
-
-      ## Matches a path mask against a path.
-      ## Returns nil for no match, 0 for a wildcard match, or 1 for an
-      ## exact match.
-      def match_paths(mask, path)
-        mask = '/'+mask if mask && mask.index('/') != 0
-        path = '/'+path if path && path.index('/') != 0
-        mask_pieces = (mask || '*').split(%r{/})
-        path_pieces = (path || '/').split(%r{/})
-        return 1 if mask && path && mask_pieces==path_pieces
-        return 0 if match_pieces(mask_pieces, path_pieces, :ignore_depth => true)
-        nil
-      end
-
-      ## Matches arrays of URL or hostname pieces.
-      ## Returns nil for no match, 0 for a wildcard match, or 1 for an
-      ## exact match.
-      def match_pieces(mask, pieces, args)
-        ignore_depth = args[:ignore_depth]
-        return nil if !ignore_depth && mask.count > pieces.count
-        pieces.each_with_index do |piece, i|
-          return 0 if piece && mask[i] == '*'
-          return nil if mask[i] != piece
-        end
-        1
-      end
-
-    end
-
-  end
-end

data/lib/fuzzy_url/url_components.rb

@@ -1,91 +0,0 @@
-class FuzzyURL
-
-  ## FuzzyURL::URLComponents provides getting/setting of URL components
-  ## on FuzzyURL objects in hash style (e.g. `foo[:hostname]`) and
-  ## method style (e.g. `foo.hostname`).  Acceptable URL components are
-  ## :protocol, :username, :password, :hostname, :port, :path, :query,
-  ## and :fragment.
-  module URLComponents
-
-    COMPONENTS = [:protocol, :username, :password, :hostname,
-                  :port, :path, :query, :fragment]
-
-    ## Gets a URL component.
-    def [](component)
-      component_sym = component.to_sym
-      if !COMPONENTS.include?(component_sym)
-        raise ArgumentError, "#{component.inspect} is not a URL component. "+
-                             COMPONENTS.inspect
-      end
-      @components[component_sym]
-    end
-
-    ## Sets a URL component.
-    def []=(component, value)
-      component_sym = component.to_sym
-      if !COMPONENTS.include?(component_sym)
-        raise ArgumentError, "#{component.inspect} is not a URL component. "+
-                             COMPONENTS.inspect
-      end
-      @components[component_sym] = value
-    end
-
-
-    ## Get the protocol for this FuzzyURL.
-    def protocol; self[:protocol] end
-
-    ## Set the protocol for this FuzzyURL.
-    def protocol=(v); self[:protocol]=v end
-
-
-    ## Get the username for this FuzzyURL.
-    def username; self[:username] end
-
-    ## Set the username for this FuzzyURL.
-    def username=(v); self[:username]=v end
-
-
-    ## Get the password for this FuzzyURL.
-    def password; self[:password] end
-
-    ## Set the password for this FuzzyURL.
-    def password=(v); self[:password]=v end
-
-
-    ## Get the hostname for this FuzzyURL.
-    def hostname; self[:hostname] end
-
-    ## Set the hostname for this FuzzyURL.
-    def hostname=(v); self[:hostname]=v end
-
-
-    ## Get the port for this FuzzyURL.
-    def port; self[:port] end
-
-    ## Set the port for this FuzzyURL.
-    def port=(v); self[:port]=v end
-
-
-    ## Get the path for this FuzzyURL.
-    def path; self[:path] end
-
-    ## Set the path for this FuzzyURL.
-    def path=(v); self[:path]=v end
-
-
-    ## Get the query for this FuzzyURL.
-    def query; self[:query] end
-
-    ## Set the query for this FuzzyURL.
-    def query=(v); self[:query]=v end
-
-
-    ## Get the fragment for this FuzzyURL.
-    def fragment; self[:fragment] end
-
-    ## Set the fragment for this FuzzyURL.
-    def fragment=(v); self[:fragment]=v end
-
-  end
-end
-

data/lib/fuzzy_url/version.rb

@@ -1,6 +0,0 @@
-# @private
-class FuzzyURL
-  VERSION = '0.2.3'
-  VERSION_DATE = '2015-11-25'
-end
-

data/lib/fuzzy_url.rb

@@ -1,210 +0,0 @@
-require 'fuzzy_url/version'
-require 'fuzzy_url/matching'
-require 'fuzzy_url/url_components'
-require 'pp'
-
-## FuzzyURL is a class to represent URLs and URL-like things.  FuzzyURL aids
-## in the manipulation and matching of URLs by providing non-strict parsing,
-## wildcard matching, ranked matching, `#to_s`, and more.
-##
-## Example usage:
-##
-## ```
-## require 'fuzzyurl'
-## fuzzy_url = FuzzyURL.new('http://example.com/*')
-## fuzzy_url.matches?('http://example.com')        # => true
-## fuzzy_url.matches?('http://example.com/a/b/c')  # => true
-## fuzzy_url.matches?('https://example.com')       # => false
-## fuzzy_url.matches?('http://foobar.com')         # => false
-## ```
-##
-## It is important to note that FuzzyURL is not a URL validator!  It performs
-## lenient matching of URLs and URL-like things that look like the following:
-##
-## ```
-## [protocol ://] [username [: password] @] [hostname] [: port] [/ path] [? query] [# fragment]
-## ```
-##
-## In a FuzzyURL, any part of the above may be replaced with a `*` character
-## to match anything.
-##
-## In a hostname, the leftmost label of the host (e.g., the `xyz`
-## in `xyz.us.example.com`) may be replaced with a `*` character
-## (e.g., `*.us.example.com`) in order to match domains like
-## `xxx.us.example.com` and `yyy.zzz.us.example.com`, but not `us.example.com`.
-##
-## In a path, a `*` character may be placed after the last `/` path separator 
-## (e.g., `/a/b/*`) in order to match paths like `/a/b` and `/a/b/c/d`,
-## but not `/a/bcde`.
-
-class FuzzyURL
-  include FuzzyURL::Matching
-  include FuzzyURL::URLComponents
-
-
-  ## Creates a new FuzzyURL with the given URL or URL-like object of type
-  ## String, Hash, or FuzzyURL.
-  ## Acceptable hash keys are :protocol, :username, :password, :hostname,
-  ## :port, :path, :query, and :fragment.  Hash keys other than these are
-  ## ignored.
-  def initialize(url='')
-    default_components = {:protocol=>nil, :username=>nil, :password=>nil,
-                          :hostname=>nil, :port=>nil, :path=>nil,
-                          :query=>nil, :fragment=>nil}
-    case url
-    when String
-      unless hash = self.class.url_to_hash(url)
-        raise ArgumentError, "Bad url URL: #{url.inspect}"
-      end
-      @components = default_components.merge(hash)
-    when Hash, FuzzyURL
-      @components = default_components.merge(url.to_hash)
-    else
-      raise ArgumentError, "url must be a String, Hash, or FuzzyURL; got #{url.inspect}"
-    end
-  end
-
-  ## Matches the given URL string, hash, or FuzzyURL against this FuzzyURL.
-  ## Returns nil on negative match, and an integer match score otherwise.
-  ## This match score is higher for more specific matches.
-  def match(url)
-    case url
-    when String
-      self.class.match_hash(self.to_hash, self.class.url_to_hash(url))
-    when Hash, FuzzyURL
-      self.class.match_hash(self.to_hash, url.to_hash)
-    else
-      raise ArgumentError, "url must be a String, Hash, or FuzzyURL; got #{url.inspect}"
-    end
-  end
-
-  ## Matches the given URL string, hash, or FuzzyURL against this FuzzyURL.
-  ## Returns true on positive match, false otherwise.
-  def matches?(url)
-    match(url) ? true : false
-  end
-
-  ## Returns this FuzzyURL's hash form.
-  def to_hash
-    Hash[@components]
-  end
-
-  ## Returns this FuzzyURL's string form.
-  def to_s
-    self.class.hash_to_url(@components)
-  end
-
-
-  class << self
-
-    ## Given a URL, returns a hash containing :protocol, :username, :password,
-    ## :hostname, :port, :path, :query, and :fragment fields (all String
-    ##  or nil).
-    ## Accepts `*` in place of any of the above fields, or as part of hostname
-    ## or path.
-    ## Returns nil if given a malformed URL.
-    ##
-    ## Example:
-    ##
-    ## ```
-    ## FuzzyURL.url_to_hash('http://user:pass@example.com:8080/some/path/?foo=bar&baz=1#url-fragment')
-    ## # => {:protocol=>"http", :username=>"user", :password=>"pass", :hostname=>"example.com", :port=>8080, :path=>"/some/path/", :query=>"foo=bar&baz=1", :fragment=>"url-fragment"} 
-    ## ```
-
-    def url_to_hash(url)
-      if m = url.match(%r{
-            ^
-
-            (?: (\* | [a-zA-Z][A-Za-z+.-]+) ://)?    ## m[1] is protocol
-
-            (?: (\* | [a-zA-Z0-9%_.!~*'();&=+$,-]+)                 ## m[2] is username
-                (?: : (\* | [a-zA-Z0-9%_.!~*'();&=+$,-]*))?         ## m[3] is password
-                @
-            )?
-
-            ([a-zA-Z0-9\.\*\-]+?)?                   ## m[4] is hostname
-
-            (?: : (\* | \d+))?                       ## m[5] is port
-
-            (/ [^\?\#]*)?                            ## m[6] is path
-                                                     ## captures leading /
-
-            (?: \? ([^\#]*) )?                       ## m[7] is query
-
-            (?: \# (.*) )?                           ## m[8] is fragment
-
-            $
-          }x)
-
-        protocol = m[1] ? m[1].downcase : nil
-        username = m[2]
-        password = m[3]
-        hostname = m[4] ? m[4].downcase : nil
-        port     = m[5] ? (m[5] == '*' ? '*' : m[5].to_i) : nil
-        path     = m[6]
-        query    = m[7]
-        fragment = m[8]
-
-        { :protocol => protocol,
-          :username => username,
-          :password => password,
-          :hostname => hostname,
-          :port     => port,
-          :path     => path,
-          :query    => query,
-          :fragment => fragment }
-
-      else ## no match
-        nil
-      end
-    end
-
-    ## Given a hash containing :protocol, :username, :password,
-    ## :hostname, :port, :path, :query, and :fragment fields (all String
-    ## or nil), return a URL string containing these elements.
-    def hash_to_url(hash)
-      url = ''
-      url << "#{ hash[:protocol] }://" if hash[:protocol]
-      if hash[:username]
-        url << "#{hash[:username]}"
-        url << ":#{hash[:password]}" if hash[:password]
-        url << '@'
-      end
-      url << "#{hash[:hostname]}" if hash[:hostname]
-      url << ":#{hash[:port]}" if hash[:port]
-
-      ## make sure path starts with a / if it's defined
-      path = hash[:path]
-      path = "/#{path}" if path && path.index('/') != 0
-      url << "#{path}"
-
-      url << "?#{hash[:query]}" if hash[:query]
-      url << "##{hash[:fragment]}" if hash[:fragment]
-      url
-    end
-
-    ## Matches a URL mask string with a URL string.
-    ## Raises ArgumentError when given malformed URLs.
-    ## Returns true on positive match, false otherwise.
-    def matches?(mask, url)
-      match(mask, url) ? true : false
-    end
-
-    ## Matches a URL mask string with a URL string.
-    ## Raises ArgumentError when given malformed URLs.
-    ## Returns nil on negative match, and an integer match score otherwise.
-    ## This match score is higher for more specific matches.
-    def match(mask, url)
-      unless mask_hash = url_to_hash(mask)
-        raise ArgumentError, "Badly formed URL mask: #{mask.inspect}"
-      end
-      unless url_hash = url_to_hash(url)
-        raise ArgumentError, "Badly formed URL: #{url.inspect}"
-      end
-      match_hash(mask_hash, url_hash)
-    end
-
-  end # class << self
-
-end
-