uri-ni 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 602b4c24ac2df2c79fc1a49a609097b79cddcc1c093a59c4d6fb145879eb2912
+  data.tar.gz: cf4a624236856b43a2dbb64ebe7a48e12d92289c9fe6c4c6cee5ad9aae5c86af
+SHA512:
+  metadata.gz: 42bfd075838370ed2a2c2098d3249b7587d148c49da3ace39019448aec20937d3c2a6f0c53b456490c1cacaf3c3d9d026329e9f1a6929d7eaa3a728f3a7df618
+  data.tar.gz: 16f3de0b2522d6fae59499151b4942b0c1cdb0174a5196ab534685209e9a23b462306b5f2b37c00281dbe518000717cbf6db717638e39f9951052d9baf0b9346

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+Gemfile.lock
+
+# rspec failure tracking
+.rspec_status
+.\#*
+\#*\#

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,6 @@
+---
+language: ruby
+cache: bundler
+rvm:
+  - 2.5.5
+before_install: gem install bundler -v 2.1.2

data/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in uri-ni.gemspec
+gemspec
+
+# not sure why we put these in both places
+gem "rake", "~> 12.0"
+gem "rspec", "~> 3.0"

data/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -0,0 +1,108 @@
+# URI::NI - RFC6920 Named Identifiers
+
+This module implements the `ni:` URI scheme from [RFC
+6920](https://tools.ietf.org/html/rfc6920).
+
+```ruby
+require 'uri'
+require 'uri-ni' # or 'uri/ni', if you prefer
+
+ni = URI::NI.compute 'some data'
+# => #<URI::NI ni:///sha-256;EweZDmulyhRes16ZGCqb7EZTG8VN32VqYCx4D6AkDe4>
+ni.hexdigest
+# => "1307990e6ba5ca145eb35e99182a9bec46531bc54ddf656a602c780fa0240dee"
+```
+
+This of course corresponds to:
+
+```bash
+$ echo -n some data | sha256sum
+1307990e6ba5ca145eb35e99182a9bec46531bc54ddf656a602c780fa0240dee  -
+```
+
+This works as expected:
+
+```ruby
+ni = URI('ni:///sha-256;4wwup6dvg7fBqXXdwkKGtnXnFOu7xyzNXwQBcwIxq1c')
+# => #<URI::NI ni:///sha-256;4wwup6dvg7fBqXXdwkKGtnXnFOu7xyzNXwQBcwIxq1c>
+```
+
+RFC 6920 [specifies a
+registry](https://www.iana.org/assignments/named-information/named-information.xhtml)
+for algorithm designators. Of that list, `sha-256`, `sha-384` and
+`sha-512` are implemented. Eventually I will get around to doing the
+SHA-3 digests as well as the truncated SHA-256 ones. Implemented but
+_not_ in the registry are `md5`, `sha-1` and `rmd-160`. Really these
+identifiers only matter when you are trying to `compute` a new
+digest. For instance you can do this:
+
+```ruby
+ni = URI('ni:///lol;wut')
+# => #<URI::NI ni:///lol;wut>
+```
+
+…and the parser won't complain. But, if you then tried to take this
+result and compute a new digest with it:
+
+```ruby
+ni
+# => #<URI::NI ni:///lol;wut>
+ni.compute 'derp'
+ArgumentError: lol is not a supported digest algorithm.
+```
+
+Similarly, the digest component of the URI can be anything going in to
+the parser, but only base64 is valid for subsequent manipulation:
+
+```
+ni.digest = '$#!%$%'
+ArgumentError: Data $#!%$% is not in base64
+```
+
+In addition to computing new digest URIs, this module will return the
+interesting part of its contents in binary, base64, hexadecimal, and
+(with a soft dependency), [base32](https://rubygems.org/gems/base32).
+
+Finally, this module will also reuse any extant `Digest::Instance`
+object as long as it is in the inventory, and furthermore the
+`compute` method takes a block:
+
+```ruby
+ctx = Digest::SHA256.new
+# => #<Digest::SHA256: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855>
+ctx << 'hello world'
+# => #<Digest::SHA256: b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9>
+ni = URI::NI.compute ctx
+# => #<URI::NI ni:///sha-256;uU0nuZNNPgilLlLX2n2r-sSE7-N6U4DukIj3rOLvzek>
+ni.hexdigest
+# => "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"
+ni = URI::NI.compute do |ctx|
+  ctx << 'hello world'
+end
+# => #<URI::NI ni:///sha-256;uU0nuZNNPgilLlLX2n2r-sSE7-N6U4DukIj3rOLvzek>
+```
+
+## Documentation
+
+Generated and deposited [in the usual
+place](http://www.rubydoc.info/github/doriantaylor/rb-uri-ni/master).
+
+## Installation
+
+You know how to do this:
+
+    $ gem install uri-ni
+
+Or, [download it off rubygems.org](https://rubygems.org/gems/uri-ni).
+
+## Contributing
+
+Bug reports and pull requests are welcome at
+[the GitHub repository](https://github.com/doriantaylor/rb-uri-ni).
+
+## Copyright & License
+
+©2019 [Dorian Taylor](https://doriantaylor.com/)
+
+This software is provided under
+the [Apache License, 2.0](https://www.apache.org/licenses/LICENSE-2.0).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "uri/ni"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/uri/ni/version.rb

@@ -0,0 +1,11 @@
+# we need this or what follows it complains
+require 'uri/generic'
+
+module URI
+  class NI < Generic
+    VERSION = "0.1.0"
+  end
+
+  # might as well put this here
+  @@schemes['NI'] = NI
+end

data/lib/uri/ni.rb

@@ -0,0 +1,374 @@
+require 'uri/ni/version'
+require 'uri'
+require 'uri/generic'
+
+require 'digest'
+require 'base64'
+require 'stringio'
+
+class URI::NI < URI::Generic
+  private
+
+  # URI.rb has rfc2396 not 3986 so let's make an authority pattern
+  AUTHORITY = "(#{URI::PATTERN::USERINFO}@)?(#{URI::PATTERN::HOST})?" \
+    "(?::(#{URI::PATTERN::PORT}))?".freeze
+
+  AUTH_RE = /^#{AUTHORITY}$/o.freeze
+  HOST_RE = /^#{URI::PATTERN::HOST}?$/o.freeze
+
+  # this is slightly more relaxed than rfc 6920, allowing for an empty
+  # value for the digest such that we can initialize ni:///algo and compute
+  ALG_VAL = "([#{URI::PATTERN::UNRESERVED}]+)" \
+    "(?:;([#{URI::PATTERN::UNRESERVED}]*))?".freeze
+
+  PATH    = "/(?:#{ALG_VAL})?".freeze
+  PATH_RE = /^(?:#{PATH})?$/o.freeze
+
+  # put it together
+  PATTERN =
+    "^([NnIi])://#{AUTHORITY}/#{ALG_VAL}(?:\\?#{URI::PATTERN::QUERY})?$".freeze
+
+  # and bake it
+  REGEXP = Regexp.new(PATTERN).freeze
+
+  # map these onto upstream properties
+  COMPONENT = %i[scheme userinfo host port path query]
+
+  DIGESTS = {
+    "md5":     Digest::MD5,
+    "rmd-160": Digest::RMD160,
+    "sha-1":   Digest::SHA1,
+    "sha-256": Digest::SHA256,
+    "sha-384": Digest::SHA384,
+    "sha-512": Digest::SHA512,
+  }
+
+  # resolve first against digest length and then class
+  DIGEST_REV = {
+    64 => { Digest::SHA512 => :"sha-512", Digest::SHA2   => :"sha-512" },
+    48 => { Digest::SHA384 => :"sha-384", Digest::SHA2   => :"sha-384" },
+    32 => { Digest::SHA256 => :"sha-256", Digest::SHA2   => :"sha-256" },
+    20 => { Digest::RMD160 => :"rmd-160", Digest::SHA1   => :"sha-1"   },
+    16 => { Digest::MD5    => :md5 },
+  }
+
+  def algo_for ctx, algo = nil
+    raise NotImplementedError, "Unknown digest type #{ctx.class}" unless
+      d = DIGEST_REV[ctx.digest_length] and d[ctx.class]
+    raise ArgumentError,
+      "algorithm #{algo} does not match digest type #{ctx.class}" if
+      algo and algo != d[ctx.class]
+    d[ctx.class]
+  end
+
+  def raw_digest
+    PATH_RE.match(path).captures[1] || ''
+  end
+
+  def assert_authority authority = nil
+    authority ||= self.authority
+    m = AUTH_RE.match(authority) or raise ArgumentError,
+      "Invalid authority #{authority}"
+    m.captures
+  end
+
+  def assert_path path = nil
+    path ||= self.path
+    m = PATH_RE.match(path) or raise ArgumentError,
+      "Path #{path} does not match constraint"
+    m.captures
+  end
+
+  protected
+
+  # holy crap you can override these?
+
+  # our host can be an empty string
+  def check_host host
+    !!HOST_RE.match(host)
+  end
+
+  # our path has constraints
+  def check_path path
+    !!PATH_RE.match(path)
+  end
+
+  # make sure the host is always set to the empty string
+  def set_host v
+    @host = v.to_s
+  end
+
+  public
+
+  # Compute an RFC6920 URI from a data source.
+  # @param data [#to_s, IO, Digest, nil]
+  # @param algorithm [Symbol] See algorithms
+  def self.compute data = nil, algorithm: :"sha-256", blocksize: 65536,
+      authority: nil, query: nil, &block
+
+    build({ scheme: 'ni' }).compute data, algorithm: algorithm,
+      blocksize: blocksize, authority: authority, query: query, &block
+  end
+
+  def compute data = nil, algorithm: nil, blocksize: 65536,
+      authority: nil, query: nil, &block
+
+    # enforce block size
+    raise ArgumentError,
+      "Blocksize must be an integer >0, not #{blocksize}" unless
+      blocksize.is_a? Integer and blocksize > 0
+
+    # special case for when the data is a digest
+    ctx = nil
+    if data.is_a? Digest::Instance
+      algorithm ||= algo_for data, algorithm
+      ctx  = data
+      data = nil # unset data
+    else
+      # make sure we're all on the same page hurr
+      self.algorithm = algorithm ||= self.algorithm
+      raise ArgumentError,
+        "#{algorithm} is not a supported digest algorithm." unless
+        ctx = DIGESTS[algorithm]
+      ctx = ctx.new
+    end
+
+    # deal with authority component
+    if authm = AUTH_RE.match(authority.to_s)
+      userinfo, host, port = authm.captures
+      set_userinfo userinfo
+      set_host     host.to_s
+      set_port     port
+    end
+
+    # coerce data to something non-null
+    data = data.to_s if (data.class.ancestors & [String, IO, NilClass]).empty?
+    if data
+      data = StringIO.new data unless data.is_a? IO
+
+      # give us a default block
+      block ||= -> x, y { x << y } # unless block_given?
+
+      while buf = data.read(blocksize)
+        block.call ctx, buf
+      end
+    elsif block
+      block.call ctx, nil
+    end
+
+    self.set_path("/#{algorithm};" +
+      ctx.base64digest.gsub(/[+\/]/, ?+ => ?-, ?/ => ?_).gsub(/=/, ''))
+
+    self
+  end
+
+  # Display the available algorithms.
+  #
+  # @return [Array] containing the symbols representing the available
+  #  digest algorithms.
+  def self.algorithms
+    DIGESTS.keys.sort
+  end
+
+  # Obtain the algorithm of the digest. May be nil.
+  #
+  # @return [Symbol, nil]
+  def algorithm
+    algo = assert_path.first
+    return algo.to_sym if algo
+  end
+
+  # Set the algorithm of the digest. Will croak if the path is malformed.
+  #
+  # @return [Symbol, nil] the old algorithm
+  def algorithm= algo
+    a, b = assert_path
+    self.path   = "/#{algo}"
+    self.digest = b if b
+    a.to_sym if a
+  end
+
+  # Obtain the authority (userinfo@host:port) if present.
+  #
+  # @return [String, nil] the authority
+  def authority
+    out = userinfo ? "#{userinfo}@#{host}" : host
+    out += "#{out}:#{port}" if port
+    out
+  end
+
+  # Set the authority of the URI.
+  #
+  # @return [String, nil] the old authority
+  def authority= authority
+    old = self.authority
+    u, h, p = assert_authority authority unless authority.nil?
+    set_userinfo u
+    set_host     h
+    set_port     p
+    old
+  end
+
+  # Return the digest in the hash. Optionally takes a +radix:+
+  # argument to specify binary, base64, base32, or hexadecimal
+  # representations. Another optional flag will return alternative
+  # representations for each: base64url (vanilla base64 is canonical),
+  # base32 in lowercase (uppercase is canonical), hexadecimal in
+  # uppercase (lowercase is canonical). The binary representation
+  # naturally has no alternative form. Base64/base32 values will be
+  # appropriately padded.
+  #
+  # @param radix [256, 64, 32, 16] The radix of the representation
+  # @param alt [false, true] Return the alternative representation
+  # @return [String] The digest of the URI in the given representation
+  #
+  def digest radix: 256, alt: false
+    case radix
+    when 256
+      # XXX do not use urlsafe_decode64; it will complain if the
+      # thingies aren't aligned
+      Base64.decode64(raw_digest.tr('-_', '+/'))
+    when 64
+      b64digest alt: alt
+    when 32
+      b32digest alt: alt
+    when 16
+      hexdigest alt: alt
+    else
+      raise ArgumentError, "Radix must be 16, 32, 64, 256, not #{radix}"
+    end
+  end
+
+  # Set the digest to the data. Data may either be a
+  # +Digest::Instance+ or a base64 string. String representations will
+  # be normalized to {https://tools.ietf.org/html/rfc3548#section-4
+  # RFC 3548} base64url, i.e. +\+/+ will be replaced with +-_+ and
+  # padding (+=+) will be removed. +Digest::Instance+ objects will
+  # just be run through #compute, with all that entails.
+  def digest= data
+    a = assert_path.first
+    case data
+    when Digest::Instance
+      compute data
+    when String
+      raise ArgumentError, "Data #{data} is not in base64" unless
+        /^[0-9A-Za-z+\/_-]*=*$/.match(data)
+      data = data.tr('+/', '-_').tr('=', '')
+      self.path = a ? "/#{a};#{data}" : "/;#{data}"
+    when nil
+      self.path = a ? "/#{a}" : ?/
+    else
+      raise ArgumentError,
+        "Data must be a string or Digest::Instance, not #{data.class}"
+    end
+
+    data
+  end
+
+  # Return the digest in its hexadecimal notation. Optionally give
+  # +alt:+ a truthy value to return an alternate (uppercase)
+  # representation.
+  #
+  # @param alt [false, true] Return the alternative representation
+  # @return [String] The hexadecimal digest
+  #
+  def hexdigest alt: false
+    str = digest.unpack('H*').first
+    return str.upcase if alt
+    str
+  end
+
+  # Return the digest in its base32 notation. Optionally give
+  # +alt:+ a truthy value to return an alternate (lowercase)
+  # representation. Note this method requires
+  #
+  # @param alt [false, true] Return the alternative representation
+  # @return [String] The base32 digest
+  #
+  def b32digest alt: false
+    require 'base32'
+    ret = Base32.encode(digest).gsub(/=+/, '')
+    return ret.downcase if alt
+    ret.upcase
+  end
+
+  # Return the digest in its base64 notation. Optionally give
+  # +alt:+ a truthy value to return an alternate (URL-safe)
+  # representation.
+  #
+  # @param alt [false, true] Return the alternative representation
+  # @return [String] The base64 digest
+  #
+  def b64digest alt: false
+    ret = raw_digest
+    return ret.gsub(/[-_]/, ?- => ?+, ?_ => ?/) unless alt
+    ret
+  end
+
+  # Returns a +/.well-known/...+, either HTTPS or HTTP URL, given the
+  # contents of the +ni:+ URI.
+  #
+  # @param authority [#to_s, URI] Override the authority part of the URI
+  # @param https [true, false] whether the URL is to be HTTPS.
+  # @return [URI::HTTPS, URI::HTTP]
+  #
+  def to_www https: true, authority: nil
+    a, d = assert_path
+    components = {
+      scheme:   "http#{https ? ?s : ''}",
+      userinfo: userinfo,
+      host:     host,
+      port:     port,
+      path:     "/.well-known/ni/#{a}/#{d}",
+      query:    query,
+      fragment: fragment,
+    }
+
+    if authority
+      uhp = []
+      if authority.is_a? URI
+        raise ArgumentError, "Bad authority #{authority}" unless
+          %i[userinfo host port].all? {|c| authority.respond_to? c }
+        uhp = [authority.userinfo, authority.host, authority.port]
+        uhp[2] = nil if authority.port == authority.class::DEFAULT_PORT
+      else
+        authority = authority.to_s
+        uhp = AUTH_RE.match(authority) or raise ArgumentError,
+          "Invalid authority #{authority}"
+        uhp = uhp.captures
+      end
+      components[:userinfo] = uhp[0]
+      components[:host]     = uhp[1]
+      components[:port]     = uhp[2]
+    end
+
+    # pick the class
+    cls = https ? URI::HTTPS : URI::HTTP
+
+    # `normalize` should do this but doesn't
+    components[:port] = nil if
+      components[:port] and components[:port] == cls::DEFAULT_PORT
+
+    cls.build(components).normalize
+  end
+
+  # Unconditionally returns an HTTPS URL.
+  #
+  # @param authority [#to_s, URI] Override the authority part of the URI
+  # @return [URI::HTTPS]
+  #
+  def to_https authority: nil
+    # note we don't simply alias this
+    to_www authority: authority
+  end
+
+  # Unconditionally returns an HTTP URL.
+  #
+  # @param authority [#to_s, URI] Override the authority part of the URI
+  # @return [URI::HTTP]
+  #
+  def to_http authority: nil
+    to_www https: false, authority: authority
+  end
+
+end

data/lib/uri-ni.rb

@@ -0,0 +1 @@
+require 'uri/ni'

data/uri-ni.gemspec

@@ -0,0 +1,36 @@
+# -*- mode: enh-ruby -*-
+require_relative 'lib/uri/ni/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'uri-ni'
+  spec.version       = URI::NI::VERSION
+  spec.authors       = ['Dorian Taylor']
+  spec.email         = ['code@doriantaylor.com']
+  spec.license       = 'Apache-2.0'
+  spec.homepage      = 'https://github.com/doriantaylor/rb-uri-ni'
+  spec.summary       = 'URI handler for RFC6920 ni:/// URIs'
+  spec.description = <<-DESC
+  DESC
+
+  spec.metadata['homepage_uri'] = spec.homepage
+
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      f.match(%r{^(test|spec|features)/})
+    end
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  # ruby
+  spec.required_ruby_version = Gem::Dependency.new('>= 2.3.0')
+
+  # dev/test dependencies
+  spec.add_development_dependency 'bundler', '~> 2'
+  # bundler put these in the gemfile i dunno wtf
+  #spec.add_development_dependency 'rake',    '~> 12.0'
+  #spec.add_development_dependency 'rspec',   '~> 3.0'
+
+  # we need uri and digest and base64 but those are all in core
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: uri-ni
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dorian Taylor
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-01-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+description: ''
+email:
+- code@doriantaylor.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/uri-ni.rb
+- lib/uri/ni.rb
+- lib/uri/ni/version.rb
+- uri-ni.gemspec
+homepage: https://github.com/doriantaylor/rb-uri-ni
+licenses:
+- Apache-2.0
+metadata:
+  homepage_uri: https://github.com/doriantaylor/rb-uri-ni
+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: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: URI handler for RFC6920 ni:/// URIs
+test_files: []