uuid-ncname 0.2.5 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0eaed682c9e65dd5d15a576fcc62b0f234cc70481017aaac64eef84afe3bb6ea
-  data.tar.gz: f55eadabe095625c795d7cefda9e2cedc9643d383d0e1ecd17b375f3897b99ac
+  metadata.gz: 471f6d4d6e5124454b7bcc1a7ab46fc3f6fbf6951f4ba988c80a9b04f0051be1
+  data.tar.gz: 03265d39a6f8b4c38ad9d86ddab9753563216c4ac3421a5cff9f38f1e536d4e1
 SHA512:
-  metadata.gz: 9f060166823eb018f830787177ad331d2e530d5036341802e8ae5b49c6f4a2e661ee8e8a273573bca44ab24904a33b754f7efcbe196e174c998a9a97958514fa
-  data.tar.gz: e9fbb9c79c496bf639eef5d500e07f9b8f7207739a04c36aea1d6035fb56ddbd5581d8f33b63058a074f4fa35e5d23a9982315f2b14d3533b939f2f9fee89d5c
+  metadata.gz: 311e0f9856467d875782d37ac759ec2479d74276ad2ec427588954ab22335e233d69f2d32e6ceaf20a24e91eba8a2cd780721f89f5a829c7acf346ab78b20401
+  data.tar.gz: d9458bc9b998ac9fb0d5450e66a73d49bbc5bd546250d221045c4b17361cc9a02fa9a0c9b2dbf012686e4bc0c60336635b6946e7f531a8ba80900336e24affa9

data/.gitignore

@@ -8,6 +8,8 @@ syntax: glob
 /spec/reports/
 /tmp/
 *.gem
+\#*
+.\#*
 
 # rspec failure tracking
 .rspec_status

data/.yardopts

@@ -0,0 +1,5 @@
+--protected
+--no-private
+--hide-void-return
+--markup markdown
+--readme README.md

data/README.md

@@ -7,19 +7,17 @@ require 'uuidtools'
 uu = UUIDTools::UUID.random_create
 # => #<UUID:0x3fff0e597ef8 UUID:df521e0a-9d57-4f04-9a95-fc2888decc5a>
 
-# see below about this :version parameter
-
-nc64 = UUID::NCName.to_ncname uu, version: 1
+nc64 = UUID::NCName.to_ncname uu
 # => "E31IeCp1X8EqV_CiI3sxaJ"
 
-nc32 = UUID::NCName.to_ncname_32 uu, version: 1
+nc32 = UUID::NCName.to_ncname_32 uu
 # => "E35jb4cu5k7yevfp4fcen5tc2j"
 
-orig = UUID::NCName.from_ncname nc64, version: 1
+orig = UUID::NCName.from_ncname nc64
 # => "df521e0a-9d57-4f04-9a95-fc2888decc5a"
 
-orig == UUID::NCName.from_ncname nc32, version: 1 # => true
-orig == uu.to_s                                   # => true
+orig == UUID::NCName.from_ncname nc32 # => true
+orig == uu.to_s                       # => true
 
 # then you can turn it back into an object or whatever
 uu == UUIDTools::UUID.parse(orig)     # => true
@@ -27,69 +25,12 @@ uu == UUIDTools::UUID.parse(orig)     # => true
 
 ## Description
 
-The purpose of this module is to devise an alternative representation
+The purpose of this module is to [devise an alternative
+representation](https://datatracker.ietf.org/doc/html/draft-taylor-uuid-ncname)
 of the [UUID](http://tools.ietf.org/html/rfc4122) which conforms to
-the constraints of various other identifiers such as NCName, and create an
-[isomorphic](http://en.wikipedia.org/wiki/Isomorphism) mapping between
-them.
-
-## _FORMAT DEPRECATION NOTICE_
-
-After careful consideration, I have decided to change the UUID-NCName
-format in a minor yet incompatible way. In particular, I have moved
-the nybble containing
-the [`variant`](https://tools.ietf.org/html/rfc4122#section-4.1.1) to
-the very end of the identifier, whereas it previously was mixed into
-the middle somewhere.
-
-This can be considered an application
-of [Postel's Law](https://en.wikipedia.org/wiki/Postel%27s_law), based
-on the assumption that these identifiers will be generated through
-other methods, and potentially naïvely. Like the `version` field, the
-`variant` field has a limited acceptable range of values. If, for
-example, one were to attempt to generate a conforming identifier by
-simply generating a random Base32 or Base64 string, it will be
-difficult to ensure that the `variant` field will indeed conform when
-the identifier is converted to a standard UUID. By moving the
-`variant` field out to the end of the identifier, everything between
-the `version` and `variant` bookends can be generated randomly without
-any further consideration, like so:
-
-```ruby
-B64_ALPHA = ('A'..'Z').to_a + ('a'..'z').to_a + ('0'..'9').to_a + %w(- _)
-
-def make_cheapo_b64_uuid_ncname
-  vals = (1..20).map { rand 64 }               # generate the content
-  vals.push(rand(4) + 8)                       # last digit is special
-  'E' + vals.map { |v| B64_ALPHA[v] }.join('') # 'E' for UUID v4
-end
-
-# voilà:
-
-cheap = make_cheapo_b64_uuid_ncname
-# => "EXSVv8ezPbSKWoKOkBNWKL"
-
-# now try changing it to a standard UUID:
-
-UUID::NCName.from_ncname cheap, version: 1
-# => "5d256ff1-eccf-46d2-b296-a0a3a404d58a"
-```
-
-Furthermore, since the default behaviour is to align the bits of the
-last byte to the size of the encoding symbol, and since the `variant`
-bits are masked, a compliant RFC4122 UUID will _always_ end with `I`,
-`J`, `K`, or `L`, in _both_ Base32 (case-insensitive) and Base64
-variants.
-
-Since I have already released this gem prior to this format change, I
-have added a `:version` parameter to both `to_ncname` and
-`from_ncname`. The version, as of 0.2.4, now defaults to `1`, the
-current one, but will still issue a warning if not explicitly
-set. Later I will finally remove the warning. This should ensure that
-any code written during the transition produces the correct results.
-
-> Unless you have to support identifiers generated from version 0.1.3
-> or older, you should be running these methods with `version: 1`.
+the constraints of various other identifiers such as NCName, and
+create an [isomorphic](http://en.wikipedia.org/wiki/Isomorphism)
+mapping between them.
 
 ## Rationale & Method
 
@@ -198,6 +139,62 @@ representation should be adequate for placeholder symbols in just
 about any programming language, save for those which do not permit
 identifiers as long as 26 characters (which are extremely scarce).
 
+## _FORMAT DEPRECATION NOTICE_
+
+After careful consideration, I have decided to change the UUID-NCName
+format in a minor yet incompatible way. In particular, I have moved
+the nybble containing
+the [`variant`](https://tools.ietf.org/html/rfc4122#section-4.1.1) to
+the very end of the identifier, whereas it previously was mixed into
+the middle somewhere.
+
+This can be considered an application
+of [Postel's Law](https://en.wikipedia.org/wiki/Postel%27s_law), based
+on the assumption that these identifiers will be generated through
+other methods, and potentially naïvely. Like the `version` field, the
+`variant` field has a limited acceptable range of values. If, for
+example, one were to attempt to generate a conforming identifier by
+simply generating a random Base32 or Base64 string, it will be
+difficult to ensure that the `variant` field will indeed conform when
+the identifier is converted to a standard UUID. By moving the
+`variant` field out to the end of the identifier, everything between
+the `version` and `variant` bookends can be generated randomly without
+any further consideration, like so:
+
+```ruby
+B64_ALPHA = ('A'..'Z').to_a + ('a'..'z').to_a + ('0'..'9').to_a + %w(- _)
+
+def make_cheapo_b64_uuid_ncname
+  vals = (1..20).map { rand 64 }               # generate the content
+  vals.push(rand(4) + 8)                       # last digit is special
+  'E' + vals.map { |v| B64_ALPHA[v] }.join('') # 'E' for UUID v4
+end
+
+# voilà:
+
+cheap = make_cheapo_b64_uuid_ncname
+# => "EXSVv8ezPbSKWoKOkBNWKL"
+
+# now try changing it to a standard UUID:
+
+UUID::NCName.from_ncname cheap, version: 1
+# => "5d256ff1-eccf-46d2-b296-a0a3a404d58a"
+```
+
+Furthermore, since the default behaviour is to align the bits of the
+last byte to the size of the encoding symbol, and since the `variant`
+bits are masked, a compliant RFC4122 UUID will _always_ end with `I`,
+`J`, `K`, or `L`, in _both_ Base32 (case-insensitive) and Base64
+variants.
+
+Since I have already released this gem prior to this format change, I
+have added a `:version` parameter to both `to_ncname` and
+`from_ncname`. This parameter, which controls the compact UUID spec
+behaviour, defaults to `1`, as of the _module_ version 0.2.4.
+
+> Unless you have to support identifiers generated from version 0.1.3
+> or older, you should be running these methods with `version: 1`.
+
 ## Documentation
 
 Generated and deposited

data/lib/uuid/ncname/version.rb

@@ -6,5 +6,5 @@ unless Module.const_defined? 'UUID'
 end
 
 module UUID::NCName
-  VERSION = "0.2.5"
+  VERSION = "0.4.0"
 end

data/lib/uuid/ncname.rb

@@ -3,11 +3,20 @@ require "uuid/ncname/version"
 
 require 'base64'
 require 'base32'
+require 'base58'
 
 module UUID::NCName
 
   private
 
+  MATCH = /^([A-Pa-p]) # zero-width boundary and version bookend
+  ([2-7A-Za-z]{24}|[-0-9A-Z_a-z]{20}| # base32 and 64
+  (?:[1-9A-HJ-NP-Za-km-z]{15}_{6}|[1-9A-HJ-NP-Za-km-z]{16}_{5}|
+  [1-9A-HJ-NP-Za-km-z]{17}_{4}|[1-9A-HJ-NP-Za-km-z]{18}___|
+  [1-9A-HJ-NP-Za-km-z]{19}__|[1-9A-HJ-NP-Za-km-z]{20}_|
+  [1-9A-HJ-NP-Za-km-z]{21})) # base58 with underscore pad
+  ([-0-9A-Z_a-z])$/x.freeze # lax variant bookend and zero-width boundary
+
   ENCODE = {
     32 => -> (bin, align = true) {
       if align
@@ -18,7 +27,15 @@ module UUID::NCName
 
       out = ::Base32.encode bin
 
-      out.downcase[0, 25]
+      out.downcase[0, 25] # clip off the padding
+    },
+    58 => -> (bin, _) {
+      variant = bin[-1].ord >> 4
+      # note the bitcoin alphabet is the one used in draft-msporny-base58
+      out = ::Base58.binary_to_base58(bin.chop, :bitcoin)
+      # we need to pad base58 with underscores because it is variable length
+      out + (?_ * (21 - out.length)) +
+        encode_version(variant) # encode_version does variant too
     },
     64 => -> (bin, align = true) {
       if align
@@ -29,10 +46,11 @@ module UUID::NCName
 
       out = ::Base64.urlsafe_encode64 bin
 
-      out[0, 21]
+      out[0, 21] # clip off the padding
     },
   }
 
+  # note the version symbol is already removed
   DECODE = {
     32 => -> (str, align = true) {
       str = str.upcase[0, 25] + 'A======'
@@ -41,6 +59,14 @@ module UUID::NCName
 
       out.pack 'C*'
     },
+    58 => -> (str, _) {
+      variant = decode_version(str[-1]) << 4
+      # warn str
+      str = str.chop.tr ?_, ''
+      # warn str
+      # warn ::Base58.base58_to_binary(str, :bitcoin).length
+      ::Base58.base58_to_binary(str, :bitcoin) + variant.chr.b
+    },
     64 => -> (str, align = true) {
       str = str[0, 21] + 'A=='
       out = ::Base64.urlsafe_decode64(str).unpack 'C*'
@@ -54,6 +80,7 @@ module UUID::NCName
 
   FORMAT = {
     str: -> bin { UUF % bin.unpack('C*') },
+    urn: -> bin { "urn:uuid:#{UUF % bin.unpack('C*')}" },
     hex: -> bin { bin.unpack 'H*' },
     b64: -> bin { ::Base64.strict_encode64 bin },
     bin: -> bin { bin },
@@ -102,7 +129,10 @@ module UUID::NCName
       -> (version, data) {
         version &= 0xf
 
+        # warn data.length
+
         list = data.unpack 'N4'
+        # warn list.inspect
         variant = (list[3] & 0xf0) << 24
         list[3] >>= 8
         list[3] |= ((list[2] & 0xff) << 24)
@@ -116,14 +146,25 @@ module UUID::NCName
     ],
   ]
 
-  def self.encode_version version
-    ((version & 15) + 65).chr
+  def self.encode_version version, radix = 64
+    offset = radix == 32 ? 97 : 65
+    ((version & 15) + offset).chr
   end
 
   def self.decode_version version
     (version.upcase.ord - 65) % 16
   end
 
+  def self.assert_version version
+    version = 1 unless version
+    raise ArgumentError, "version #{version.inspect} is not an integer" unless
+      version.respond_to? :to_i
+    version = version.to_i
+    raise ArgumentError, "there is no version #{version}" unless
+      TRANSFORM[version]
+    version
+  end
+
   def self.warn_version version
     if version.nil?
       warn 'Set an explicit :version to remove this warning. See documentation.'
@@ -137,6 +178,27 @@ module UUID::NCName
 
   public
 
+  # This error gets thrown when a UUID-NCName token can't be
+  # positively determined to be one version or the other.
+  class AmbiguousToken < ArgumentError
+
+    # @return [String] The ambiguous token
+    attr_reader :token
+    # @return [String] The UUID when decoded using version 0
+    attr_reader :v0
+    # @return [String] The UUID when decoded using version 1
+    attr_reader :v1
+
+    # @param token [#to_s] The token in question
+    # @param v0 [#to_s] UUID decoded with decoding scheme version 0
+    # @param v1 [#to_s] UUID decoded with decoding scheme version 1
+
+    def initialize token, v0: nil, v1: nil
+      @v0 = v0 || from_ncname(token, version: 0)
+      @v1 = v1 || from_ncname(token, version: 1)
+    end
+  end
+
   # Converts a UUID (or object that when converted to a string looks
   # like a UUID) to an NCName. By default it produces the Base64
   # variant.
@@ -149,9 +211,7 @@ module UUID::NCName
   #
   # @param version [0, 1] An optional formatting version, where 0 is
   #  the naïve original version and 1 moves the `variant` nybble out
-  #  to the end of the identifier. You will be warned for the time
-  #  being if you do not set this parameter explicitly. The default
-  #  version is 1.
+  #  to the end of the identifier. The default version is 1.
   # 
   # @param align [true, false] Optional directive to treat the
   #  terminating character as aligned to the numerical base of the
@@ -162,18 +222,21 @@ module UUID::NCName
   #  range of the letters A through P in (the RFC 3548/4648
   #  representations of) both Base32 and Base64. When `version` is 1
   #  and the terminating character is aligned, RFC4122-compliant UUIDs
-  #  will always terminate with I, J, K, or L. Defaults to `true`.
+  #  will always terminate with `I`, `J`, `K`, or `L`. Defaults to
+  #  `true`.
   # 
   # @return [String] The NCName-formatted UUID.
-
+  #
   def self.to_ncname uuid, radix: 64, version: nil, align: true
-    raise 'Radix must be either 32 or 64' unless [32, 64].include? radix
+    raise 'Radix must be either 32, 58, or 64' unless
+      [32, 58, 64].include? radix
     raise 'UUID must be something stringable' if uuid.nil? or
       not uuid.respond_to? :to_s
-    raise 'Align must be true or false' unless [true, false].include? align
+    align = !!align # coerce to a boolean
 
     # XXX remove this when appropriate
-    version = warn_version(version)
+    # version = warn_version(version)
+    version = assert_version version
 
     uuid = uuid.to_s
     bin  = nil
@@ -195,9 +258,9 @@ module UUID::NCName
     raise 'Binary representation of UUID is shorter than 16 bytes' if
       bin.length < 16
 
-    uuidver, content = TRANSFORM[version][0].call bin[0, 16]
+    uuidver, content = TRANSFORM[version].first.call bin[0, 16]
 
-    encode_version(uuidver) + ENCODE[radix].call(content, align)
+    encode_version(uuidver, radix) + ENCODE[radix].call(content, align)
   end
 
   # Converts an NCName-encoded UUID back to its canonical
@@ -207,9 +270,10 @@ module UUID::NCName
   # @param ncname [#to_s] an NCName-encoded UUID, either a
   #  22-character (Base64) variant, or a 26-character (Base32) variant.
   # 
-  # @param radix [nil, 32, 64] Optional radix; will use heuristic if omitted.
+  # @param radix [nil, 32, 58, 64] Optional radix; will use a heuristic
+  #  if omitted.
   #
-  # @param format [:str, :hex, :b64, :bin] An optional formatting
+  # @param format [:str, :urn, :hex, :b64, :bin] An optional formatting
   #  parameter; defaults to `:str`, the canonical string representation.
   #
   # @param version [0, 1] See ::to_ncname. Defaults to 1.
@@ -218,12 +282,12 @@ module UUID::NCName
   #  Setting this parameter to `nil`, the default, will cause the
   #  decoder to detect the alignment state from the identifier.
   #
-  # @param validate [false, true] Check that the ninth octet is
-  # correctly masked _after_ decoding.
+  # @param validate [false, true] Check that the ninth (the variant)
+  #  octet is correctly masked _after_ decoding.
   #
   # @return [String, nil] The corresponding UUID or nil if the input
   #  is malformed.
-
+  #
   def self.from_ncname ncname,
       radix: nil, format: :str, version: nil, align: nil, validate: false
     raise 'Format must be symbol-able' unless format.respond_to? :to_sym
@@ -232,34 +296,31 @@ module UUID::NCName
       [true, false, nil].include? align
 
     # XXX remove this when appropriate
-    version = warn_version version
+    # version = warn_version version
+    version = assert_version version
 
     return unless ncname and ncname.respond_to? :to_s
 
     ncname = ncname.to_s.strip.gsub(/\s+/, '')
-    match  = /^([A-Za-z])([0-9A-Za-z_-]{21,})$/.match(ncname) or return
+    match  = MATCH.match(ncname) or return
+    return if align and !/[A-Pa-p]$/.match? ncname # MATCH is lax
 
+    # determine the radix from the input
     if radix
-      raise "Radix must be 32 or 64, not #{radix}" unless [32, 64].any? radix
-      return unless { 32 => 26, 64 => 22 }[radix] == ncname.length
+      raise ArgumentError, "Radix must be 32, 58, or 64, not #{radix}" unless
+        [32, 58, 64].any? radix
+      return unless { 32 => 26, 58 => 23, 64 => 22 }[radix] == ncname.length
     else
-      len = ncname.length
-
-      if ncname =~ /[_-]/
-        radix = 64
-      elsif len >= 26
-        radix = 32
-      elsif len >= 22
-        radix = 64
-      else
-        # uh will this ever get executed now that i put in that return?
-        raise "Not sure what to do with an identifier of length #{len}."
-      end
+      radix = { 26 => 32, 23 => 58, 22 => 64}[ncname.length] or
+        raise ArgumentError,
+        "Not sure what to do with an identifier of length #{ncname.length}."
     end
 
-    uuidver, content = match.captures
+    # note MATCH separates the variant
+    uuidver, *content = match.captures
+    content = content.join
 
-    align   = !!(content =~ /[A-Pa-p]$/) if align.nil?
+    align   = !!(/[A-Pa-p]$/.match? content) if align.nil?
     uuidver = decode_version uuidver
     content = DECODE[radix].call content, align
 
@@ -280,7 +341,7 @@ module UUID::NCName
   # @param align [true, false] See ::to_ncname.
   #
   # @return [String] The Base64-encoded NCName
-
+  #
   def self.to_ncname_64 uuid, version: nil, align: true
     to_ncname uuid, version: version, align: align
   end
@@ -297,9 +358,42 @@ module UUID::NCName
   #
   # @return [String, nil] The corresponding UUID or nil if the input
   #  is malformed.
-
+  #
   def self.from_ncname_64 ncname, format: :str, version: nil, align: nil
-    from_ncname ncname, radix: 64, format: format
+    from_ncname ncname,
+      radix: 64, format: format, version: version, align: align
+  end
+
+  # Shorthand for conversion to the Base58 version
+  #
+  # @param uuid [#to_s] The UUID
+  # 
+  # @param version [0, 1] See ::to_ncname.
+  # 
+  # @param align [true, false] See ::to_ncname.
+  #
+  # @return [String] The Base58-encoded NCName
+  #
+  def self.to_ncname_58 uuid, version: nil, align: true
+    to_ncname uuid, radix: 58, version: version, align: align
+  end
+
+  # Shorthand for conversion from the Base58 version
+  #
+  # @param ncname [#to_s] The Base58 variant of the NCName-encoded UUID
+  #
+  # @param format [:str, :hex, :b64, :bin] The format
+  # 
+  # @param version [0, 1] See ::to_ncname.
+  # 
+  # @param align [true, false] See ::to_ncname.
+  #
+  # @return [String, nil] The corresponding UUID or nil if the input
+  #  is malformed.
+  #
+  def self.from_ncname_58 ncname, format: :str, version: nil, align: nil
+    from_ncname ncname,
+      radix: 58, format: format, version: version, align: align
   end
 
   # Shorthand for conversion to the Base32 version
@@ -311,7 +405,7 @@ module UUID::NCName
   # @param align [true, false] See ::to_ncname.
   #
   # @return [String] The Base32-encoded NCName
-
+  #
   def self.to_ncname_32 uuid, version: nil, align: true
     to_ncname uuid, radix: 32, version: version, align: align
   end
@@ -328,9 +422,10 @@ module UUID::NCName
   #
   # @return [String, nil] The corresponding UUID or nil if the input
   #  is malformed.
-
+  #
   def self.from_ncname_32 ncname, format: :str, version: nil, align: nil
-    from_ncname ncname, radix: 32, format: format
+    from_ncname ncname,
+      radix: 32, format: format, version: version, align: align
   end
 
   # Test if the given token is a UUID NCName, with a hint to its
@@ -340,30 +435,37 @@ module UUID::NCName
   # `false` if the token is invalid, otherwise it returns `0` or `1`
   # for the guessed version.
   #
-  # @note Version 1 tokens always end with I, J, K, or L (with base32
-  # being case-insensitive), so tokens that end in something else will
-  # be version 0.
+  # @note Version 1 tokens always end with `I`, `J`, `K`, or `L` (with
+  #  base32 being case-insensitive), so tokens that end in something
+  #  else will always be version 0.
   #
   # @param token [#to_s] The token to test
   #
+  # @param strict [false, true]
+  #
   # @return [false, 0, 1]
-  def self.valid? token
+  #
+  def self.valid? token, strict: false
     token = token.to_s
-    if /^[A-Pa-p](?:[0-9A-Za-z_-]{21}|[2-7A-Za-z]{25})$/.match token
+    if MATCH.match? token
       # false is definitely version zero but true is only maybe version 1
       version = /^(?:.{21}[I-L]|.{25}[I-Li-l])$/.match(token) ? 1 : 0
 
       # try decoding with validation on 
       uu = from_ncname token, version: version, validate: true
 
-      if version == 1 and !uu
-        # try version zero
-        uu = from_ncname token, version: 0, validate: true
-        # either zero or invalid
-        uu ? 0 : false
-      else
-        version
+      # note that version 1 will always return something because the
+      # method of detecting it is a version 1 also happens to be the
+      # method of determining whether or not it is valid.
+      return false unless uu
+
+      if version == 1 and strict
+        # but we can also check if the input is a valid version 0
+        u0 = from_ncname token, version: 0, validate: true
+        raise AmbiguousToken.new(token, v0: u0, v1: uu) if u0
       end
+
+      version
     else
       false
     end

data/uuid-ncname.gemspec

@@ -27,15 +27,16 @@ DESC
   spec.require_paths = ["lib"]
 
   # we use named parameters
-  spec.required_ruby_version = '~> 2.0'
+  spec.required_ruby_version = '>= 2.0'
 
   # surprisingly do not need this
   # spec.add_runtime_dependency 'uuidtools', '~> 2.1.5'
   spec.add_runtime_dependency 'base32',    '~> 0.3.2'
+  spec.add_runtime_dependency 'base58',    '~> 0.2.3'
 
-  spec.add_development_dependency 'bundler', '~> 1.16'
-  spec.add_development_dependency 'rake',    '~> 10.0'
-  spec.add_development_dependency 'rspec',   '~> 3.0'
+  spec.add_development_dependency 'bundler', '~> 2.2'
+  spec.add_development_dependency 'rake',    '~> 13.0'
+  spec.add_development_dependency 'rspec',   '~> 3.10'
 
   # only need it for testing, who knew
   # spec.add_development_dependency 'uuidtools', '~> 2.1.5'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: uuid-ncname
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.4.0
 platform: ruby
 authors:
 - Dorian Taylor
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2019-11-19 00:00:00.000000000 Z
+date: 2021-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base32
@@ -24,48 +24,62 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.3.2
+- !ruby/object:Gem::Dependency
+  name: base58
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.3
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '2.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.10'
 description: |
   This module creates an isomorphic representation of a UUID which is
   guaranteed to fit into the grammar of the XML NCName construct, which
@@ -81,6 +95,7 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
+- ".yardopts"
 - Gemfile
 - LICENSE
 - README.md
@@ -95,13 +110,13 @@ homepage: https://github.com/doriantaylor/rb-uuid-ncname
 licenses:
 - Apache-2.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - "~>"
+  - - ">="
     - !ruby/object:Gem::Version
       version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
@@ -110,8 +125,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.2.22
+signing_key:
 specification_version: 4
 summary: Format a UUID as a valid NCName.
 test_files: []