furi 0.0.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 208063d16947ce85a4d80a12bd3834cb26c0f6ab
-  data.tar.gz: ab3eff6b787f0df3e04781908477bb69d3924333
+SHA256:
+  metadata.gz: 37ea1203ca474e34d99624eb7e7cf43935197a4cec1a0a49e110b8674f5a1cec
+  data.tar.gz: 5ef6f167bd64ac72f6a8b78324c871a88734f06e39faecd4e7aaee1abe5a2f0a
 SHA512:
-  metadata.gz: 500c3e4bb3ed0866c0cef1ca68794d9d82e9d2b679bb1590f69e14428bb1020a64d5c357c166e25b0c522902b670e5138269e649f395455f48acc4bca50785eb
-  data.tar.gz: bae87908fe1a04c26d1073d569199adda1645bc25f561ec0aa9b2e05943e55d0993223c3d329335c07afcac8c814e87c2a738573a2837be2996cb38339e3078f
+  metadata.gz: db8b15ea5e9d25852df4be4e83a67bf60d8ed85d703fba1fa7a1ee28fbe7d2e547dc4ea182d52ef396316f92ef3634264750b4d76d0016c51c6a9afe78b19e11
+  data.tar.gz: 9617142f8e989e885c8bd17a874fa221b6df1f2bea1398a786e9291f4d87d9d6ae4913f8904c3273902b8c0a1d008b0ec3f0aa8918aef34d9d5538fca93a0861

data/.github/workflows/ci.yml

@@ -0,0 +1,19 @@
+name: CI
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: [2.4, 2.5, 2.6, 2.7, 3.0]
+    name: Ruby ${{ matrix.ruby }}
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - run: bundle exec rake

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# v0.2.3
+
+* Ruby 3.0 support #2
+* Escaping special characters in anchor
+

data/Gemfile

@@ -1,4 +1,11 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in furi.gemspec
 gemspec
+
+gem "pry-byebug", "~> 3.9"
+gem "rake", "~> 13.0"
+gem "rspec", "~> 3.10"
+gem "bump"

data/README.md

@@ -1,12 +1,19 @@
 # Furi
 
-TODO: Write a gem description
+[![Gem Version](https://badge.fury.io/rb/furi.svg)](https://badge.fury.io/rb/furi)
+[![Build Status](https://github.com/bogdan/furi/workflows/CI/badge.svg?branch=master)](https://github.com/bogdan/furi/actions)
+[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fbogdan%2Ffuri.svg?type=shield)](https://app.fossa.io/projects/git%2Bgithub.com%2Fbogdan%2Ffuri?ref=badge_shield)
+
+Furi is a Friendly URI parsing library.
+Furi's philosophy is to make any operation possible in ONE LINE OF CODE.
+
+If there is an operation that takes more than one line of code to do with Furi, this is considered a terrible bug and you should create an issue.
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
-```ruby
+``` ruby
 gem 'furi'
 ```
 
@@ -20,12 +27,112 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+I'll say it again: any operation should take exacly one line of code!
+Here are basic:
+
+### Utility Methods
+
+Parsing the URI fragments:
+
+``` ruby
+Furi.host("http://gusiev.com") # => "gusiev.com"
+Furi.port("http://gusiev.com") # => nil
+Furi.port!("http://gusiev.com") # => 80
+```
+
+Updating the URI parts:
+
+``` ruby
+Furi.update("http://gusiev.com", protocol: '') # => "//gusiev.com"
+Furi.update("http://gusiev.com?source=google", query: {email: "a@b.com"})
+    # => "http://gusiev.com?source=google&email=a@b.com"
+Furi.replace("http://gusiev.com?source=google", query: {email: "a@b.com"})
+    # => "http://gusiev.com?email=a@b.com"
+
+Furi.defaults("http://gusiev.com", subdomain: 'www') # => "http://www.gusiev.com"
+Furi.defaults("http://blog.gusiev.com", subdomain: 'www') # => "http://blog.gusiev.com"
+```
+
+Building an URI from initial parts:
+
+``` ruby
+Furi.build(protocol: '//', host: 'gusiev.com', path: '/assets/application.js')
+    # => "//gusiev.com/assets/application.js"
+```
+
+### Working with Object
+
+``` ruby
+uri = Furi.parse("gusiev.com")
+    # => #<Furi::Uri "gusiev.com">
+
+uri.port     # => nil
+uri.port!    # => 80
+uri.path     # => nil
+uri.path!    # => '/'
+uri.subdomain ||= 'www'
+uri.protocol = "//" # protocol abstract URL
+```
+
+### Processing Query String
+
+``` ruby
+uri = Furi.parse("/?person[first_name]=Bogdan&person[last_name]=Gusiev")
+
+uri.query_string # => "person[first_name]=Bogdan&person[last_name]=Gusiev"
+uri.query_tokens # => [person[first_name]=Bogdan, person[last_name]=Gusiev]
+uri.query # => {person: {first_name: Bogdan, last_name: 'Gusiev'}}
+
+uri.merge_query(person: {email: 'a@b.com'})
+    # => {person: {email: 'a@b.com', first_name: Bogdan, last_name: 'Gusiev'}}
+
+uri.merge_query(person: {email: 'a@b.com'})
+    # => {person: {email: 'a@b.com', first_name: Bogdan, last_name: 'Gusiev'}}
+```
+
+## Reference
+
+```
+                location                                            resource
+                    |                                                ___|___
+             _______|_______                                        /       \
+            /               \                                      /         \
+           /             authority                             request        \
+          /        __________|_________                           |            \
+         /        /                    \                    ______|______       \
+        /    userinfo                hostinfo              /             \       \
+       /       __|___                ___|___              /               \       \
+      /       /      \              /       \            /                 \       \
+     /   username  password       host      port       path               query   anchor
+    /      __|___   __|__    ______|______   |  _________|__________     ____|____   |
+   /      /      \ /     \  /             \ / \/                    \   /         \ / \
+   http://username:zhongguo@www.example.com:80/hello/world/article.html?name=bogdan#info
+    \_/                     \_/  \___/  \_/    \__________/\     /  \_/
+     |                       |     |     |           |      \___/    |
+  protocol             subdomain   | domainzone  directory    |   extension
+                                   |     |                 filename  |
+                             domainname  /                     \_____/
+                                    \___/                         |
+                                      |                          file
+                                    domain
+```
+
+Originated from [URI.js](http://medialize.github.io/URI.js/about-uris.html) parsing library.
+Giving credit...
+
+## TODO
+
+* Improve URI.join algorithm to match the one used in Addressable library
+* Implement filename
+* Encoding/Decoding special characters:
+  * path
+  * query
+  * fragment
 
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/furi/fork )
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create a new Pull Request
+Contribute in the way you want. Branch names and other bla-bla-bla do not matter.
+
+## License
+
+[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fbogdan%2Ffuri.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fbogdan%2Ffuri?ref=badge_large)

data/Rakefile

@@ -1,2 +1,8 @@
+# frozen_string_literal: true
+
 require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
 
+task default: :spec

data/furi.gemspec

@@ -1,7 +1,6 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'furi/version'
+# frozen_string_literal: true
+
+require_relative "lib/furi/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "furi"
@@ -9,17 +8,17 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Bogdan Gusiev"]
   spec.email         = ["agresso@gmail.com"]
   spec.summary       = %q{Make URI processing as easy as it should be}
-  spec.description   = %q{The phylosophy of this gem is to make any URI modification or parsing operation to take only one line of code and never more}
-  spec.homepage      = ""
+  spec.description   = %q{The philosophy of this gem is to make any URI modification or parsing operation to take only one line of code and never more}
+  spec.homepage      = "https://github.com/bogdan/furi"
   spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
 
-  spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
 
-  spec.add_development_dependency "bundler", "~> 1.7"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec"
-  spec.add_development_dependency "byebug"
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.require_paths = ["lib"]
 end

data/lib/furi.rb

@@ -3,49 +3,73 @@ require "uri"
 
 module Furi
 
-  PARTS =  [
-    :anchor, :protocol, :query_string,
-    :path, :hostname, :port, :username, :password
+  autoload :QueryToken, 'furi/query_token'
+  autoload :Uri, 'furi/uri'
+  autoload :Utils, 'furi/utils'
+
+  ESSENTIAL_PARTS =  [
+    :anchor, :protocol, :query_tokens,
+    :path, :host, :port, :username, :password
+  ]
+  COMBINED_PARTS = [
+    :hostinfo, :userinfo, :authority, :ssl, :domain, :domainname,
+    :domainzone, :request, :location, :query,
+    :directory, :extension, :file
   ]
+  PARTS = ESSENTIAL_PARTS + COMBINED_PARTS
+
   ALIASES = {
-    protocol: [:schema],
+    protocol: [:schema, :scheme],
     anchor: [:fragment],
+    host: [:hostname],
+    username: [:user],
+    request: [:request_uri]
   }
 
-  DELEGATES = [:port!]
-
-  PORT_MAPPING = {
-    "http" => 80,
-    "https" => 443,
-    "ftp" => 21,
-    "tftp" => 69,
-    "sftp" => 22,
-    "ssh" => 22,
-    "svn+ssh" => 22,
-    "telnet" => 23,
-    "nntp" => 119,
-    "gopher" => 70,
-    "wais" => 210,
-    "ldap" => 389,
-    "prospero" => 1525
+  DELEGATES = [:port!, :host!, :path!, :home_page?]
+
+  PROTOCOLS = {
+    "http" => {port: 80, ssl: false},
+    "https" => {port: 443, ssl: true},
+    "ftp" => {port: 21},
+    "tftp" => {port: 69},
+    "sftp" => {port: 22},
+    "ssh" => {port: 22, ssl: true},
+    "svn" => {port: 3690},
+    "svn+ssh" => {port: 22, ssl: true},
+    "telnet" => {port: 23},
+    "nntp" => {port: 119},
+    "gopher" => {port: 70},
+    "wais" => {port: 210},
+    "ldap" => {port: 389},
+    "prospero" => {port: 1525},
+    "file" => {port: nil},
+    "postgres" => {port: 5432},
+    "mysql" => {port: 3306},
+    "mailto" => {port: nil}
   }
 
-  class Expressions
-    attr_accessor :protocol
 
-    def initialize
-      @protocol = /^[a-z][a-z0-9.+-]*$/i
-    end
-  end
+  SSL_MAPPING = {
+    'http' => 'https',
+    'ftp' => 'sftp',
+    'svn' => 'svn+ssh',
+  }
 
-  def self.expressions
-    Expressions.new
-  end
+  WEB_PROTOCOL = ['http', 'https']
+
+  ROOT = '/'
 
-  def self.parse(argument)
-    Uri.new(argument)
+  # Parses a given string and return an URL object
+  # Optionally accepts parts to update the parsed URL object
+  def self.parse(argument, parts = nil)
+    Uri.new(argument).update(parts)
   end
 
+  # Builds an URL from given parts
+  #
+  #   Furi.build(path: "/dashboard", host: 'example.com', protocol: "https")
+  #     # => "https://example.com/dashboard"
   def self.build(argument)
     Uri.new(argument).to_s
   end
@@ -53,14 +77,119 @@ module Furi
   class << self
     (PARTS + ALIASES.values.flatten + DELEGATES).each do |part|
       define_method(part) do |string|
-        Uri.new(string).send(part)
+        Uri.new(string)[part]
       end
     end
   end
 
+  # Replaces a given URL string with given parts
+  #
+  #   Furi.update("http://gusiev.com", protocol: 'https', subdomain: 'www')
+  #     # => "https://www.gusiev.com"
   def self.update(string, parts)
     parse(string).update(parts).to_s
   end
+  class << self
+    alias :merge :update
+  end
+
+  # Puts the default values for given URL that are not defined
+  #
+  #   Furi.defaults("gusiev.com/hello.html", protocol: 'http', path: '/index.html')
+  #     # => "http://gusiev.com/hello.html"
+  def self.defaults(string, parts)
+    parse(string).defaults(parts).to_s
+  end
+
+  # Replaces a given URL string with given parts.
+  # Same as update but works different for URL query parameter:
+  # replaces newly specified parameters instead of merging to existing ones
+  #
+  #   Furi.update("/hello.html?a=1", host: 'gusiev.com', query: {b: 2})
+  #     # => "gusiev.com/hello.html?a=1&b=2"
+  #
+  def self.replace(string, parts)
+    parse(string).replace(parts).to_s
+  end
+
+
+
+  # Parses a query into nested paramters hash using a rack convension with square brackets.
+  #
+  #   Furi.parse_query("a[]=1&a[]=2")       # => {a: [1,2]}
+  #   Furi.parse_query("p[email]=a&a[two]=2") # => {a: {one: 1, two: 2}}
+  #   Furi.parse_query("p[one]=1&a[two]=2") # => {a: {one: 1, two: 2}}
+  #   Furi.serialize({p: {name: 'Bogdan Gusiev', email: 'bogdan@example.com', data: {one: 1, two: 2}}})
+  #     # => "p%5Bname%5D=Bogdan&p%5Bemail%5D=bogdan%40example.com&p%5Bdata%5D%5Bone%5D=1&p%5Bdata%5D%5Btwo%5D=2"
+  def self.parse_query(query)
+    return Furi::Utils.stringify_keys(query) if query.is_a?(Hash)
+
+    params = {}
+    query_tokens(query).each do |token|
+      parse_query_token(params, token.name, token.value)
+    end
+
+    return params
+  end
+
+  # Parses query key/value pairs from query string and returns them raw
+  # without organising them into hashes and without normalising them.
+  #
+  #   Furi.query_tokens("a=1&b=2").map {|k,v| "#{k} -> #{v}"}  # => ['a -> 1', 'b -> 2']
+  #   Furi.query_tokens("a=1&a=1&a=2").map {|k,v| "#{k} -> #{v}"}  # => ['a -> 1', 'a -> 1', 'a -> 2']
+  #   Furi.query_tokens("name=Bogdan&email=bogdan%40example.com") # => [name=Bogdan, email=bogdan@example.com]
+  #   Furi.query_tokens("a[one]=1&a[two]=2") # => [a[one]=1, a[two]=2]
+  def self.query_tokens(query)
+    case query
+    when Enumerable, Enumerator
+      query.map do |token|
+        QueryToken.parse(token)
+      end
+    when nil, ''
+      []
+    when String
+      query.gsub(/\A\?/, '').split(/[&;] */n, -1).map do |p|
+        QueryToken.parse(p)
+      end
+    else
+      raise QueryParseError, "can not parse #{query.inspect} query tokens"
+    end
+  end
+
+  # Serializes query parameters into query string.
+  # Optionaly accepts a basic name space.
+  #
+  #   Furi.serialize({a: 1, b: 2}) # => "a=1&b=2"
+  #   Furi.serialize({a: [1,2]}) # => "a[]=1&a[]=2"
+  #   Furi.serialize({a: {b: 1, c:2}}) # => "a[b]=1&a[c]=2"
+  #   Furi.serialize({name: 'Bogdan', email: 'bogdan@example.com'}, "person")
+  #     # => "person[name]=Bogdan&person[email]=bogdan%40example.com"
+  #
+  def self.serialize(query, namespace = nil)
+    serialize_tokens(query, namespace).join("&")
+  end
+
+  def self.join(*uris)
+    uris.map do |uri|
+      Furi.parse(uri)
+    end.reduce do |memo, uri|
+      memo.send(:join, uri)
+    end
+  end
+
+  class Error < StandardError
+  end
+
+  class FormattingError < Error
+  end
+
+  class ParseError < Error
+  end
+
+  class QueryParseError < Error
+  end
+
+  protected
 
   def self.serialize_tokens(query, namespace = nil)
     case query
@@ -77,13 +206,13 @@ module Furi
       result
     when Array
       if namespace.nil? || namespace.empty?
-        raise ArgumentError, "Can not serialize Array without namespace"
+        raise FormattingError, "Can not serialize Array without namespace"
       end
 
       namespace = "#{namespace}[]"
       query.map do |item|
         if item.is_a?(Array)
-          raise ArgumentError, "Can not serialize #{item.inspect} as element of an Array"
+          raise FormattingError, "Can not serialize #{item.inspect} as element of an Array"
         end
         serialize_tokens(item, namespace)
       end
@@ -96,37 +225,6 @@ module Furi
     end
   end
 
-  def self.parse_nested_query(qs)
-
-    params = {}
-    query_tokens(qs).each do |token|
-      parse_query_token(params, token.name, token.value)
-    end
-
-    return params
-  end
-
-  def self.query_tokens(query)
-    if query.is_a?(Array)
-      query.map do |token|
-        case token
-        when QueryToken
-          token
-        when String
-          QueryToken.parse(token)
-        when Array
-          QueryToken.new(*token)
-        else
-          raise ArgumentError, "Can not parse query token #{token.inspect}"
-        end
-      end
-    else
-      (query || '').split(/[&;] */n).map do |p|
-        QueryToken.parse(p)
-      end
-    end
-  end
-
   def self.parse_query_token(params, name, value)
     name =~ %r(\A[\[\]]*([^\[\]]+)\]*)
     namespace = $1 || ''
@@ -140,14 +238,14 @@ module Furi
     elsif after == "[]"
       current ||= []
       unless current.is_a?(Array)
-        raise TypeError, "expected Array (got #{current.class}) for param `#{namespace}'"
+        raise QueryParseError, "expected Array (got #{current.class}) for param `#{namespace}'"
       end
       current << value
     elsif after =~ %r(^\[\]\[([^\[\]]+)\]$) || after =~ %r(^\[\](.+)$)
       child_key = $1
       current ||= []
       unless current.is_a?(Array)
-        raise TypeError, "expected Array (got #{current.class}) for param `#{namespace}'"
+        raise QueryParseError, "expected Array (got #{current.class}) for param `#{namespace}'"
       end
       if current.last.is_a?(Hash) && !current.last.key?(child_key)
         parse_query_token(current.last, child_key, value)
@@ -157,7 +255,7 @@ module Furi
     else
       current ||= {}
       unless current.is_a?(Hash)
-        raise TypeError, "expected Hash (got #{current.class}) for param `#{namespace}'"
+        raise QueryParseError, "expected Hash (got #{current.class}) for param `#{namespace}'"
       end
       current = parse_query_token(current, after, value)
     end
@@ -166,228 +264,4 @@ module Furi
     return params
   end
 
-  def self.serialize(string, namespace = nil)
-    serialize_tokens(string, namespace).join("&")
-  end
-
-  class QueryToken
-    attr_reader :name, :value
-
-    def self.parse(token)
-      k,v = token.split('=', 2).map { |s| ::URI.decode_www_form_component(s) }
-      new(k,v)
-    end
-
-    def initialize(name, value)
-      @name = name
-      @value = value
-    end
-
-    def to_a
-      [name, value]
-    end
-
-    def to_s
-      "#{::URI.encode_www_form_component(name.to_s)}=#{::URI.encode_www_form_component(value.to_s)}"
-    end
-
-    def inspect
-      [name, value].join('=')
-    end
-  end
-
-  class Uri
-
-    attr_reader(*PARTS)
-
-    ALIASES.each do |origin, aliases|
-      aliases.each do |aliaz|
-        define_method(aliaz) do
-          send(origin)
-        end
-
-        define_method(:"#{aliaz}=") do |*args|
-          send(:"#{origin}=", *args)
-        end
-      end
-    end
-
-    def initialize(argument)
-      case argument
-      when String
-        parse_uri_string(argument)
-      when Hash
-        update(argument)
-      end
-    end
-
-    def update(parts)
-      parts.each do |part, value|
-        send(:"#{part}=", value)
-      end
-      self
-    end
-
-    def merge(parts)
-      parts.each do |part, value|
-        
-      end
-    end
-
-    def userinfo
-      if username
-        [username, password].compact.join(":")
-      elsif password
-        raise FormattingError, "can not build URI with password but without username"
-      else
-        nil
-      end
-    end
-
-    def host
-      if hostname
-        [hostname, explicit_port].compact.join(":")
-      elsif port
-        raise FormattingError, "can not build URI with port but without hostname"
-      else
-        nil
-      end
-    end
-
-    def host=(string)
-      @port = nil
-      if string.include?(":")
-        string, @port = string.split(":", 2)
-        @port = @port.to_i
-      end
-      @hostname = string.empty? ? nil : string
-    end
-
-    def to_s
-      result = []
-      if protocol
-        result.push(protocol.empty? ? "//" : "#{protocol}://")
-      end
-      if userinfo
-        result << userinfo
-      end
-      result << host if host
-      result << path
-      if query_string
-        result << "?" << query_string
-      end
-      if anchor
-        result << "#" << anchor
-      end
-      result.join
-    end
-
-    def query
-      return @query if query_level?
-      @query = Furi.parse_nested_query(@query_string)
-    end
-
-
-    def query=(value)
-      @query = nil
-      case value
-      when String
-        @query_string = value
-      when Array
-        @query = Furi.query_tokens(value)
-      when Hash
-        @query = value
-      when nil
-      else
-        raise ArgumentError, 'Query can only be Hash or String'
-      end
-    end
-
-    def hostname=(hostname)
-      @hostname = hostname
-    end
-
-    def port=(port)
-      @port = port.to_i
-      if @port == 0
-        raise ArgumentError, "port should be an Integer > 0"
-      end
-      @port
-    end
-
-    def username=(username)
-      @username = username
-    end
-
-    def password=(password)
-      @password = password
-    end
-
-    def protocol=(protocol)
-      @protocol = protocol ? protocol.gsub(%r{:/?/?\Z}, "") : nil
-    end
-
-    def query_string
-      return @query_string unless query_level?
-      Furi.serialize(@query)
-    end
-
-    def expressions
-      Furi.expressions
-    end
-
-    def port!
-      port || default_port
-    end
-
-    def default_port
-      protocol ? PORT_MAPPING[protocol] : nil
-    end
-    
-    protected
-
-    def query_level?
-      !!@query
-    end
-
-    def explicit_port
-      port == default_port ? nil : port
-    end
-
-    def parse_uri_string(string)
-      string, *@anchor = string.split("#")
-      @anchor = @anchor.empty? ? nil : @anchor.join("#")
-      if string.include?("?")
-        string, query_string = string.split("?", 2)
-        @query_string = query_string
-      end
-
-      if string.include?("://")
-        @protocol, string = string.split(":", 2)
-        @protocol = '' if @protocol.empty?
-      end
-      if string.start_with?("//")
-        @protocol ||= ''
-        string = string[2..-1]
-      end
-      parse_authority(string)
-    end
-
-    def parse_authority(string)
-      if string.include?("/")
-        string, @path = string.split("/", 2)
-        @path = "/" + @path
-      end
-
-      if string.include?("@")
-        userinfo, string = string.split("@", 2)
-        @username, @password = userinfo.split(":", 2)
-      end
-      self.host = string
-    end
-
-  end
-
-  class FormattingError < StandardError
-  end
 end