file-uri 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a6a645851a1f2159e72eafaefd02f0d740bead9e
+  data.tar.gz: 0aa68c3ae8150ac81653498069c7fab57693db65
+SHA512:
+  metadata.gz: bb872d4478f27ec8c8a63e36499db67742c271e1431a34c1770bf86b96bf7a0492727a5d1ecafb656452ffaa1f1b82f50f0e2dbae1700e15b5c5bf1b2f409b54
+  data.tar.gz: 71ec8ecde2ea8631276db2475f3b9b3de89cec206e4c41999348c6ceb3153de322e12bcfa1a56a596547460f7e7375752a68da5c5fcb49d43486b4d244c0e547

data/lib/file-uri-common.rb

@@ -0,0 +1,73 @@
+require 'uri/generic'
+
+module URI
+  module File
+
+    COMPONENT = %i[
+      scheme
+      userinfo host port
+      path
+      query
+      fragment
+    ]
+
+    def self.build(args)
+      tmp = Util.make_components_hash(self, args)
+      super(tmp)
+    end
+
+    ##
+    # localhost:
+    #
+    #  * true  => 'file://localhost/' is local, 'file://example.com/' is non-local
+    #  * false => 'file://localhost/' is non-local
+    #
+    def local? localhost: true
+      if host && !host.empty?
+        return localhost && (host.downcase == LOCALHOST)
+      elsif path.start_with? DBL_SLASH
+        return false
+      end
+      true
+    end
+
+    ##
+    # localhost:
+    #
+    #  * true  => 'file://localhost/' is local, 'file://example.com/' is non-local
+    #  * false => 'file://localhost/' is non-local
+    #
+    def to_file_path localhost: true
+      raise "no local path for non-local URI #{to_s}" unless local?(localhost: localhost)
+      path
+    end
+
+    ##
+    # localhost:
+    #
+    #  * true  => 'file://localhost/' is local, 'file://example.com/' is non-local
+    #  * false => 'file://localhost/' is non-local
+    #
+    def to_unc localhost: true
+      if host && !host.empty?
+        unless localhost && (host.downcase == LOCALHOST)
+          unc = DBL_BACKSLASH + host
+          unc += COLON + port if port
+          unc += path.gsub(%r[/], BACKSLASH)
+          return unc
+        end
+      elsif path.start_with? DBL_SLASH
+        return path.gsub(%r[/], BACKSLASH)
+      end
+      raise "no UNC conversion for local URI #{to_s}"
+    end
+
+    COLON = ?:.freeze
+    SLASH = ?/.freeze
+    DBL_SLASH     = '//'.freeze
+    BACKSLASH     = '\\'.freeze
+    DBL_BACKSLASH = '\\\\'.freeze
+    LOCALHOST     = 'localhost'.freeze
+
+  end
+end

data/lib/file-uri.rb

@@ -0,0 +1,30 @@
+require 'uri/generic'
+require_relative 'file-uri-common'
+
+module URI
+  class CoreFile < Generic
+    include File
+
+    def initialize(scheme,
+                   userinfo, host, port, registry,
+                   path, opaque,
+                   query,
+                   fragment,
+                   parser = DEFAULT_PARSER,
+                   arg_check = false)
+      # detect UNC-type paths ("file:////server/Share/dir/file.ext")
+      if !host && path && path =~ %r[\A//+]
+        path = path.sub(%r[\A/+], DBL_SLASH)
+        host = ''
+      # ...urgh
+      elsif path && path =~ %r[\A/+]
+        path = path.sub(%r[\A/+], SLASH)
+      end
+      super(scheme, userinfo, host, port, registry, path, opaque, query, fragment, parser, arg_check)
+    end
+
+  end
+
+  @@schemes['FILE'] = CoreFile
+
+end

data/lib/file-uri/win.rb

@@ -0,0 +1,68 @@
+# encoding: UTF-8
+
+require 'uri/generic'
+require_relative '../file-uri-common'
+
+module URI
+  class WinFile < Generic
+    include File
+
+    def fixup path
+      path.gsub(%r[\A/([A-Z]):?(?=/|\z)]i, '/\1:')
+    end
+    private :fixup
+
+    def scrub path
+      path.gsub(%r[\A/?([A-Z]):?(?=/|\z)|:]i) {|m| $1 ? "#{$1}:" : SPECIAL }
+    end
+    private :scrub
+
+    def initialize(scheme,
+                   userinfo, host, port, registry,
+                   path, opaque,
+                   query,
+                   fragment,
+                   parser = DEFAULT_PARSER,
+                   arg_check = false)
+      # detect Windows drive letter absolute paths ("file:c:/dir/file.ext")
+      if !path && opaque && opaque =~ %r[\A[A-Z]:?(?=\z|/)]i
+        path = fixup(SLASH + opaque)
+        path += SLASH if path.length == 3
+        opaque = nil
+      # detect Windows-style drive letter authorities ("file://c:/dir/file.ext")
+      elsif host && host =~ %r[\A[A-Z]\z]i
+        path = SLASH + host + COLON + fixup(path)
+        host = nil
+      # detect UNC-type paths ("file:////server/Share/dir/file.ext")
+      elsif !host && path && path =~ %r[\A//+]
+        path = path.sub(%r[\A/+], DBL_SLASH).gsub(COLON, SPECIAL)
+        host = ''
+      # ...urgh
+      elsif path && path =~ %r[\A//+]
+        path = fixup(path.sub(%r[\A//+], SLASH))
+      else
+        path = fixup(path) if path
+      end
+      super(scheme, userinfo, host, port, registry, path, opaque, query, fragment, parser, arg_check)
+    end
+
+    ##
+    # localhost:
+    #
+    #  * true  => 'file://localhost/' is local, 'file://example.com/' is non-local
+    #  * false => 'file://localhost/' is non-local
+    #
+    def to_file_path localhost: true
+      raise "no local path for non-local URI #{to_s}" unless local?(localhost: localhost)
+      path = scrub(@path)
+      #path = path.gsub(SLASH, File::SEPARATOR)
+      path
+    end
+
+    SPECIAL = "\u{F03A}".freeze
+
+  end
+
+  @@schemes['FILE'] = WinFile
+
+end

data/test/test-file-uri.rb

@@ -0,0 +1,100 @@
+require 'test/unit'
+$VERBOSE = true
+
+
+require_relative '../lib/file-uri'
+class Test_file_uri < Test::Unit::TestCase
+
+  # 'file' URIs that are valid and are always treated as local
+  def test_valid_local_uris
+    [
+      ['file:///path/to/file',     '/path/to/file'],
+      ['file:/short/path/to/file', '/short/path/to/file'],
+    ].each do |str, path|
+      uri = URI.parse(str)
+      assert_kind_of( URI::File, uri )
+      assert_equal( path,  uri.path )
+      # these depend on it being a URI::File object
+      assert_equal( true, uri.local? )
+      assert_equal( path, uri.to_file_path )
+    end
+  end
+
+  # 'file' URIs that are valid and encode UNC strings in the path
+  # (i.e. non-local)
+  def test_valid_unc_uris
+    [
+      ['file:////example.com/Share/dir/file.ext',  '//example.com/Share/dir/file.ext', '\\\\example.com\\Share\\dir\\file.ext'],
+      ['file://///example.com/Share/dir/file.ext', '//example.com/Share/dir/file.ext', '\\\\example.com\\Share\\dir\\file.ext'],
+
+      ['file:////localhost/Share/dir/file.ext',    '//localhost/Share/dir/file.ext',   '\\\\localhost\\Share\\dir\\file.ext'],
+      ['file://///localhost/Share/dir/file.ext',   '//localhost/Share/dir/file.ext',   '\\\\localhost\\Share\\dir\\file.ext'],
+    ].each do |str, path, unc|
+      uri = URI.parse(str)
+      assert_kind_of( URI::File, uri )
+      assert_equal( path, uri.path )
+
+      assert_equal( false, uri.local?(localhost: false) )
+      assert_equal( false, uri.local?(localhost: true) )
+      assert_equal( false, uri.local? )
+
+      assert_raise(RuntimeError) { uri.to_file_path(localhost: false) }
+      assert_raise(RuntimeError) { uri.to_file_path(localhost: true) }
+      assert_raise(RuntimeError) { uri.to_file_path }
+
+      assert_equal( unc, uri.to_unc(localhost: false) )
+      assert_equal( unc, uri.to_unc(localhost: true) )
+      assert_equal( unc, uri.to_unc )
+    end
+  end
+
+  # 'file' URIs that are valid and non-local
+  def test_valid_nonlocal_uris
+    [
+      ['file://example.com/Share/dir/file.ext', 'example.com', '/Share/dir/file.ext', '\\\\example.com\\Share\\dir\\file.ext'],
+      ['file://example.com/Share/dir/file.ext', 'example.com', '/Share/dir/file.ext', '\\\\example.com\\Share\\dir\\file.ext'],
+    ].each do |str, host, path, unc|
+      uri = URI.parse(str)
+      assert_kind_of( URI::File, uri )
+      assert_equal( path, uri.path )
+      assert_equal( host, uri.host )
+
+      assert_equal( false, uri.local?(localhost: false) )
+      assert_equal( false, uri.local?(localhost: true) )
+      assert_equal( false, uri.local? )
+
+      assert_raise(RuntimeError) { uri.to_file_path(localhost: false) }
+      assert_raise(RuntimeError) { uri.to_file_path(localhost: true) }
+      assert_raise(RuntimeError) { uri.to_file_path }
+
+      assert_equal( unc, uri.to_unc(localhost: false) )
+      assert_equal( unc, uri.to_unc(localhost: true) )
+      assert_equal( unc, uri.to_unc )
+    end
+  end
+
+  # 'file' URIs that are valid and use the "localhost" authority
+  # (i.e. sometimes local, sometimes non-local)
+  def test_valid_localhost_uris
+    [
+      ['file://localhost/path/to/file', '/path/to/file', '\\\\localhost\\path\\to\\file'],
+    ].each do |str, path, unc|
+      uri = URI.parse(str)
+      assert_kind_of( URI::File, uri )
+      assert_equal( path, uri.path )
+
+      assert_equal( false, uri.local?(localhost: false) )
+      assert_equal( true,  uri.local?(localhost: true) )
+      assert_equal( true,  uri.local? )
+
+      assert_raise(RuntimeError) { uri.to_file_path(localhost: false) }
+      assert_equal( path, uri.to_file_path(localhost: true) )
+      assert_equal( path, uri.to_file_path )
+
+      assert_equal( unc, uri.to_unc(localhost: false) )
+      assert_raise(RuntimeError) { uri.to_unc(localhost: true) }
+      assert_raise(RuntimeError) { uri.to_unc }
+    end
+  end
+
+end

data/test/test-win-file-uri.rb

@@ -0,0 +1,114 @@
+require 'test/unit'
+$VERBOSE = true
+
+
+require_relative '../lib/file-uri/win'
+class Test_win_file_uri < Test::Unit::TestCase
+
+  # 'file' URIs that are valid and are always treated as local
+  def test_valid_local_uris
+    [
+      # POSIX-style
+      ['file:///path/to/file',     '/path/to/file',      '/path/to/file'],
+      ['file:/short/path/to/file', '/short/path/to/file','/short/path/to/file'],
+      # drive letter
+      ['file:///c:/path/to/file',  '/c:/path/to/file',   'c:/path/to/file'],
+      ['file:///c/path/to/file',   '/c:/path/to/file',   'c:/path/to/file'],
+      # no slash
+      ['file:c:/path/to/file',     '/c:/path/to/file',   'c:/path/to/file'],
+      ['file:c/path/to/file',      '/c:/path/to/file',   'c:/path/to/file'],
+      # cheeky authority
+      ['file://c:/path/to/file',   '/c:/path/to/file',   'c:/path/to/file'],
+      ['file://c/path/to/file',    '/c:/path/to/file',   'c:/path/to/file'],
+      # stinky colon
+      ['file:///c:/path:to/file',  '/c:/path:to/file',   "c:/path\u{F03A}to/file"],
+    ].each do |str, path, file|
+      uri = URI.parse(str)
+      assert_kind_of( URI::File, uri )
+      assert_equal( path,  uri.path )
+      # these depend on it being a URI::File object
+      assert_equal( true, uri.local? )
+      assert_equal( file, uri.to_file_path )
+    end
+  end
+
+  # 'file' URIs that are valid and encode UNC strings in the path
+  # (i.e. non-local)
+  def test_valid_unc_uris
+    [
+      ['file:////example.com/Share/dir/file.ext',  '//example.com/Share/dir/file.ext', '\\\\example.com\\Share\\dir\\file.ext'],
+      ['file://///example.com/Share/dir/file.ext', '//example.com/Share/dir/file.ext', '\\\\example.com\\Share\\dir\\file.ext'],
+
+      ['file:////localhost/Share/dir/file.ext',    '//localhost/Share/dir/file.ext',   '\\\\localhost\\Share\\dir\\file.ext'],
+      ['file://///localhost/Share/dir/file.ext',   '//localhost/Share/dir/file.ext',   '\\\\localhost\\Share\\dir\\file.ext'],
+    ].each do |str, path, unc|
+      uri = URI.parse(str)
+      assert_kind_of( URI::File, uri )
+      assert_equal( path, uri.path )
+
+      assert_equal( false, uri.local?(localhost: false) )
+      assert_equal( false, uri.local?(localhost: true) )
+      assert_equal( false, uri.local? )
+
+      assert_raise(RuntimeError) { uri.to_file_path(localhost: false) }
+      assert_raise(RuntimeError) { uri.to_file_path(localhost: true) }
+      assert_raise(RuntimeError) { uri.to_file_path }
+
+      assert_equal( unc, uri.to_unc(localhost: false) )
+      assert_equal( unc, uri.to_unc(localhost: true) )
+      assert_equal( unc, uri.to_unc )
+    end
+  end
+
+  # 'file' URIs that are valid and non-local
+  def test_valid_nonlocal_uris
+    [
+      ['file://example.com/Share/dir/file.ext', 'example.com', '/Share/dir/file.ext', '\\\\example.com\\Share\\dir\\file.ext'],
+      ['file://example.com/Share/dir/file.ext', 'example.com', '/Share/dir/file.ext', '\\\\example.com\\Share\\dir\\file.ext'],
+    ].each do |str, host, path, unc|
+      uri = URI.parse(str)
+      assert_kind_of( URI::File, uri )
+      assert_equal( path, uri.path )
+      assert_equal( host, uri.host )
+
+      assert_equal( false, uri.local?(localhost: false) )
+      assert_equal( false, uri.local?(localhost: true) )
+      assert_equal( false, uri.local? )
+
+      assert_raise(RuntimeError) { uri.to_file_path(localhost: false) }
+      assert_raise(RuntimeError) { uri.to_file_path(localhost: true) }
+      assert_raise(RuntimeError) { uri.to_file_path }
+
+      assert_equal( unc, uri.to_unc(localhost: false) )
+      assert_equal( unc, uri.to_unc(localhost: true) )
+      assert_equal( unc, uri.to_unc )
+    end
+  end
+
+  # 'file' URIs that are valid and use the "localhost" authority
+  # (i.e. sometimes local, sometimes non-local)
+  def test_valid_localhost_uris
+    [
+      ['file://localhost/path/to/file',    '/path/to/file',    '\\\\localhost\\path\\to\\file',     '/path/to/file'],
+      ['file://localhost/c:/path/to/file', '/c:/path/to/file', '\\\\localhost\\c:\\path\\to\\file', 'c:/path/to/file'], # FIXME - bad spec in UNC
+      ['file://localhost/path/to:file',    '/path/to:file',    '\\\\localhost\\path\\to:file',      "/path/to\u{F03A}file"],
+    ].each do |str, path, unc, file|
+      uri = URI.parse(str)
+      assert_kind_of( URI::File, uri )
+      assert_equal( path, uri.path )
+
+      assert_equal( false, uri.local?(localhost: false) )
+      assert_equal( true,  uri.local?(localhost: true) )
+      assert_equal( true,  uri.local? )
+
+      assert_raise(RuntimeError) { uri.to_file_path(localhost: false) }
+      assert_equal( file, uri.to_file_path(localhost: true) )
+      assert_equal( file, uri.to_file_path )
+
+      assert_equal( unc, uri.to_unc(localhost: false) )
+      assert_raise(RuntimeError) { uri.to_unc(localhost: true) }
+      assert_raise(RuntimeError) { uri.to_unc }
+    end
+  end
+
+end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: file-uri
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Matthew Kerwin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-06 00:00:00.000000000 Z
+dependencies: []
+description: |
+  == file-uri – the "file" URI Scheme
+
+  Adds explicit handling for 'file' URIs to the 'uri' library.
+
+  See the documentation at http://phluid61.github.io/file-uri/
+email:
+- matthew@kerwin.net.au
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/file-uri-common.rb
+- lib/file-uri.rb
+- lib/file-uri/win.rb
+- test/test-file-uri.rb
+- test/test-win-file-uri.rb
+homepage: http://phluid61.github.com/file-uri
+licenses:
+- ISC
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.7
+signing_key: 
+specification_version: 4
+summary: 'file-uri : the "file" URI Scheme'
+test_files:
+- test/test-win-file-uri.rb
+- test/test-file-uri.rb