pubid-ieee 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9302100f8fc58e3b1c356d866a982f830a8c3331257ee7069e9c1160d347abe7
+  data.tar.gz: bd327f07a78a631284ea36d0962ff6ecbbe3dbb917e25152643b43e6882202a3
+SHA512:
+  metadata.gz: 24de2e26b1e31b1547f0f557cbc3ddc0414a7a5dc37bc0c8ca31e697cfb11a214372e9923c23e26f2221822752a0556be5183e097ee79ba3ce6b2d614cd55c5b
+  data.tar.gz: 828523c08cd2bcca2229e00120f2c309cae15281f9984123574b0e8eb575c988bc0dfc2d91711a33c8e6234023f3313e2c2b5ce21ced35d9c8b810052c5e4f7f

data/LICENSE.txt

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2018, Ribose
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.adoc

@@ -0,0 +1,127 @@
+= IEEE publication identifiers ("IEEE PubID")
+
+== Purpose
+
+Implements a mechanism to parse and utilize IEEE publication identifers.
+
+== Historic identifier patterns
+
+There are at least two major "pattern series" of identifiers due to historical reasons: old (type I) and new (type II).
+This implementation attempts to support both types of publication identifier patterns.
+
+== Use cases to support
+
+* analyze a pattern of type I idetifier
+* parse type II idetifier into components
+* generate a filename from the components similar to type I pattern
+
+== Elements of the PubID
+
+=== Publisher
+
+|===
+| Name | Abbrev
+
+| Institute of Electrical and Electronics Engineers
+| IEEE
+
+|===
+
+=== Report number
+
+`{number}` - is a set of one or more digits and optional letters
+
+=== Part
+
+`{part}` - is a set of digits and optional letters; starts with a digit; if a letter or letters are present then they are in the end; optional
+
+=== Subpart
+
+`{subpart}` - is a set of digits and optional letters; optional, many subparts are possible
+
+=== Year
+
+`{year}` - is a set of 4 digits; optional
+
+=== Corrigendum & Amendment
+
+`{cor}` - is a corrigendum or an amendments with the pattern `Cor {cornum}-{year}` or `Amd {cornum}:{year}` where {cornum} is a set of digits; optional
+
+== Type I pattern
+
+[source]
+----
+{publisher} {type} {series} {number}{part}.{subpart}{year} {edition}/{conform}/{correction}
+----
+
+* `{publisher}` IEEE
+* `{type}` one of the values: `Standard`, `Std`, `Draft`, `Draft Standard`, `Draft Supplement` ^*^
+* `{series}` one of the values: `ISO/IEC`, `ISO/IEC/IEEE` ^*^
+* `{number}` set of digits optionally prefixed with uppercase letter and optionally suffixed  with letter
+* `{part}` from 1 to 2 digits prefixed with `.` or `-` and optionally suffixed with up to 4 letters ^*^
+* `{subpart}` 1 digit optionally suffixed with a letter ^*^
+* `{year}` 4 digits prefixed with `-`, `:`, ` - `, or breakspace ^*^
+* `{edition}` prefix `Edition` followed by a reference in brackets or prefix `First edition` followed by date in format `YYYY-MM-DD` ^*^
+* `{conform}` prefix `Conformance` followed by 2 digits, dash, and 4 digits year ^*^
+* `{correction}` prefix `Cor` optionally followed by breakspace, or prefix `Amd` followed by `.`, followed by from 1 to 2 digits, dash and 4 digits year ^*^
+
+(*) - optional
+
+An identifier can be composed of 2 other identifiers with breakspace delimiter. Only the first identifier needs to cnatain puplisher, for the secont it's optional
+
+Following RegEx expression parses 100% of identifiers from the type I https://xml2rfc.tools.ietf.org/public/rfc/bibxml-ieee/[dataset]:
+[source,regex]
+
+----
+{
+  ^IEEE\s
+  ((?<type1>Standard|Std|Draft(\sStandard|\sSupplement)?)\s)?
+  ((?<series>ISO\/IEC(\/IEEE)?)\s)?
+  (?<number1>[A-Z]?\d+[[:alpha:]]?)
+  ([.-](?<part1>\d{1,2}(?!\d)[[:alpha:]]{0,4}))?
+  (\.(?<subpart1>\d[[:alpha:]]?))?
+  (?<year1>([-:]|\s-\s|,\s)\d{4})?
+  (\s(IEEE\s(?<type2>Std)\s)?(?<number2>[A-Z]?\d+[[:alpha:]]?)
+    ([.-](?<part2>\d{1,2}(?!\d)[[:alpha:]]{0,4}))?
+    ([.](?<subpart2>\d[[:alpha:]]?))?
+    (?<year2>([-:.]|_-|\s-\s|,\s)\d{4})?)?
+  (\s(?<edition>Edition(\s\([^)]+\))?|First\sedition\s[\d-]+))?
+  (\/(?<conform>Conformance\d{2})-(?<confyear>\d{4}))?
+  (\/(?<correction>(Cor\s?|(Amd\.)\d{1,2})
+    (?<coryear>(:|-|:-)\d{4}))?$
+}x
+----
+
+== Pasing PubID elements from type II identifiers
+
+To parse PubID elements from the type II pattern identifiers we can use a RegEx expression:
+
+[source,regex]
+----
+{
+  ^IEEE\s(?<number1>\w+(\.[A-Z]\d|\sHBK)?)
+  (?<part1>(\.|\s)\d{1,4}[[:alpha:],]{0,7}|-\d?[A-Z]+|-\d(?=[-.]))?
+  (?<subpart11>\.\d{1,3}[a-z]?|-\d{5}[a-z]?|-\d+(?=[-:_]))?
+  (?<subpart12>\.\d|-\d+(?=-))?
+  (?<year1>([-:.]|_-|\s-)\d{4})?
+  (\/(?<number2>([A-Z]?\d+[a-z]?|Conformance\d+))
+    ((\.|-)(?<part2>\d{1,3}[a-z]?)(?!\d))?
+    (\.(?<subpart21>\d{1,2}))?)?
+  (\/(?<number3>\d+)(\.(?<part3>\d))?)?
+  (?<year2>([-:.]|_-|\s-)\d{4})?
+  ((\/|_|-|\s\/)(?<correction>(Cor|(?i)Amd(?-i))(\s|\.|\.\s)?\d{1,2})
+    (?<coryear>(:|-|:-|_[A-Z][a-z]{2}_)\d{4}(-\d{4})?)?)?$
+}x
+----
+
+This RegEx expession covers 99% of the identifiers from the type II bibxml-ieee https://xml2rfc.tools.ietf.org/public/rfc/bibxml-ieee-new/[dataset].
+
+== File name generator
+
+For type I identifiers file names are generated by replacing symbols `/`, `\`, `,`, `'`, `"`, `(`, `)`, and breakspace with symbol `_`. Sequences of multiple sybols `_` should be squized to one symbol.
+
+For type II identifiers it needs to parse PubID elements than join the elements in order:
+
+----
+IEEE.{number1}_{part1}.{subpart11}.{subpart12}-{year1}_{number2}_{part2}.{subpart21}_{number3}_{part3}-{year2}_{correction}-{coryear}
+----

data/lib/pubid/ieee/errors.rb

@@ -0,0 +1,6 @@
+module Pubid::Ieee
+  module Errors
+    class ParseError < StandardError; end
+    class ParseTypeError < StandardError; end
+  end
+end

data/lib/pubid/ieee/identifier/base.rb

@@ -0,0 +1,311 @@
+require 'date'
+require "yaml"
+
+UPDATE_CODES = YAML.load_file(File.join(File.dirname(__FILE__), "../../../../update_codes.yaml"))
+
+module Pubid::Ieee
+  module Identifier
+    class Base < Pubid::Core::Identifier::Base
+      attr_accessor :number, :publisher, :copublisher, :stage, :part, :subpart,
+                    :edition, :draft, :redline, :year, :month, :type, :alternative,
+                    :draft_status, :revision, :adoption_year, :amendment, :supersedes,
+                    :corrigendum, :corrigendum_comment, :reaffirmed, :incorporates,
+                    :supplement, :proposal, :iso_identifier, :iso_amendment
+
+      def initialize(publisher: "IEEE", number: nil, stage: nil, subpart: nil, edition: nil,
+                     draft: nil, redline: nil, month: nil, revision: nil,
+                     iso_identifier: nil, type: :std, alternative: nil, draft_status: nil, adoption_year: nil,
+                     amendment: nil, supersedes: nil, corrigendum: nil, corrigendum_comment: nil, reaffirmed: nil,
+                     incorporates: nil, supplement: nil, proposal: nil, iso_amendment: nil, **opts)
+
+        super(**opts.merge(number: number, publisher: publisher))#.merge(amendments: amendments, corrigendums: corrigendums))
+
+        @edition = edition if edition
+
+        @proposal = @number.to_s[0] == "P"
+        @revision = revision
+        if iso_identifier
+          @iso_identifier = Pubid::Iso::Identifier.parse(iso_identifier)
+        elsif draft# && type != :p
+          @type = Type.new(:draft)
+        elsif type
+          if type.is_a?(Symbol)
+            @type = Type.new(type)
+          else
+            @type = Type.parse(type)
+          end
+        else
+          @type = Type.new
+        end
+
+        @stage = stage
+        @subpart = subpart
+        @draft = draft
+        @redline = redline
+        @month = month
+        @revision = revision
+        @amendment = amendment
+        @corrigendum = corrigendum
+        @corrigendum_comment = corrigendum_comment
+        @alternative = alternative
+        @draft_status = draft_status
+        @adoption_year = adoption_year
+        @supersedes = supersedes
+        @reaffirmed = reaffirmed
+        @incorporates = incorporates
+        @supplement = supplement
+        @proposal = proposal
+        @iso_amendment = iso_amendment
+      end
+
+      def self.type
+        { key: :std, title: "Standard" }
+      end
+
+      # convert parameters comes from parser to
+      def set_values(hash)
+        hash.each { |key, value| send("#{key}=", value.is_a?(Parslet::Slice) && value.to_s || value) }
+      end
+
+      def self.add_missing_bracket(code)
+        code.count("(") > code.count(")") ? "#{code})" : code
+      end
+
+      def self.update_old_code(code)
+        UPDATE_CODES.each do |from, to|
+          code = code.gsub(from.match?(/^\/.*\/$/) ? Regexp.new(from[1..-2]) : /^#{Regexp.escape(from)}$/, to)
+        end
+        code
+      end
+
+
+      def self.parse(code)
+        parsed = Parser.new.parse(update_old_code(code))
+        transform(parsed)
+
+      rescue Parslet::ParseFailed => failure
+        raise Pubid::Ieee::Errors::ParseError, "#{failure.message}\ncause: #{failure.parse_failure_cause.ascii_tree}"
+      end
+
+      def self.transform(params)
+        identifier_params = params.map do |k, v|
+          get_transformer_class.new.apply(k => v)
+        end.inject({}, :merge)
+
+        Identifier.create(**Identifier.convert_parser_parameters(**identifier_params))
+      end
+
+      def self.get_transformer_class
+        Transformer
+      end
+
+      # @param [:short, :full] format
+      def to_s(format = :short, with_trademark: false)
+        if @iso_identifier
+          "#{@iso_identifier.to_s(format: :ref_num_short)}#{iso_amendment}#{dual_identifier}"
+        else
+          "#{identifier(format)}#{with_trademark ? trademark(@number) : ''}#{parameters}#{adoption}"
+        end
+      end
+
+      def trademark(number)
+        %w(802 2030).include?(number.to_s) ? "\u00AE" : "\u2122"
+      end
+
+      def iso_amendment
+
+      end
+
+      def dual_identifier
+        @number ? " (#{identifier})#{parameters}" : "#{identifier}#{parameters}"
+      end
+
+      def publisher
+        "#{@publisher}#{copublisher} " if @publisher && @number
+      end
+
+      def identifier(format = :short)
+        "#{publisher}#{draft_status(format)}#{type(format)}#{number}#{part}"\
+          "#{subpart}#{year}#{revision_date}"
+      end
+
+      def parameters
+        "#{corrigendum}#{draft}#{edition}#{alternative}#{supersedes}"\
+        "#{reaffirmed}#{incorporates}#{supplement}#{revision}#{amendment}#{redline}"
+      end
+
+      def copublisher
+        return "" unless @copublisher
+
+        if @copublisher.is_a?(Array)
+          @copublisher&.map { |c| "/#{c}" }&.join
+        else
+          "/#{@copublisher}"
+        end
+      end
+
+      def part
+        "#{@part}" if @part
+      end
+
+      def subpart
+        @subpart if @subpart && !@subpart.to_s.empty?
+      end
+
+      def type(format)
+        return unless @type
+
+        @type.to_s(@publisher != "IEEE" ? :alternative : format)
+      end
+
+      def year
+        return "" if @month
+        return "" unless @year
+
+        if @corrigendum_comment
+          @corrigendum_comment.year
+        elsif @reaffirmed && @reaffirmed.key?(:reaffirmation_of)
+          @reaffirmed[:reaffirmation_of].year
+        else
+          "-#{@year}"
+        end
+      end
+
+      def alternative
+        if @alternative
+          if @alternative.is_a?(Array)
+            " (#{@alternative.map { |a| self.class.new(**Identifier.convert_parser_parameters(**a)) }.join(', ')})"
+          else
+            " (#{self.class.new(**Identifier.convert_parser_parameters(**@alternative))})"
+          end
+        end
+      end
+
+      def edition
+        return "" unless @edition
+
+        result = ""
+        if @edition[:version]
+          result += @edition[:version] == "First" ? " Edition 1.0 " : " Edition #{@edition[:version]} "
+        end
+
+        if @edition[:year]
+          result += if @edition[:version]
+                      "#{@edition[:year]}"
+                    else
+                      " #{@edition[:year]} Edition"
+                    end
+        end
+
+        if @edition[:month]
+          month = @edition[:month]
+          month = Date.parse(@edition[:month]).month if month.to_i.zero?
+          result += "-#{sprintf('%02d', month)}"
+        end
+        result += "-#{@edition[:day]}" if @edition[:day]
+        result
+      end
+
+      def draft
+        return "" unless @draft
+
+        @draft = Identifier.merge_parameters(@draft) if @draft.is_a?(Array)
+
+        result = "/D#{@draft[:version].is_a?(Array) ? @draft[:version].join('D') : @draft[:version]}"
+        result += ".#{@draft[:revision]}" if @draft[:revision]
+        result += ", #{@draft[:month]}" if @draft[:month]
+        result += " #{@draft[:day]}," if @draft[:day]
+        result += " #{@draft[:year]}" if @draft[:year]
+        result
+      end
+
+      def draft_status(format)
+        "#{@draft_status} " if @draft_status && format == :full
+      end
+
+      def revision
+        " (Revision of #{@revision.join(' and ')})" if @revision
+      end
+
+      def revision_date
+        return nil unless @month
+        ", #{@month} #{@year}"
+      end
+
+      def amendment
+        return unless @amendment || @iso_amendment
+
+        if @iso_amendment
+          if @iso_amendment[:year]
+            return "/Amd#{@iso_amendment[:version]}-#{@iso_amendment[:year]}"
+          else
+            return "/Amd#{@iso_amendment[:version]}"
+          end
+        end
+
+        return " (Amendment to #{@amendment})" unless @amendment.is_a?(Array)
+
+        result = " (Amendment to #{@amendment.first} as amended by "
+        result += if @amendment.length > 2
+                    "#{@amendment[1..-2].map(&:to_s).join(', ')}, and #{@amendment[-1]}"
+                  else
+                    @amendment.last.to_s
+                  end
+
+        "#{result})"
+      end
+
+      def redline
+        " - Redline" if @redline
+      end
+
+      def adoption
+        if @adoption_year
+          adoption_id = dup
+          adoption_id.year = @adoption_year
+          " (Adoption of #{adoption_id.identifier})"
+        end
+      end
+
+      def supersedes
+        return unless @supersedes
+
+        if @supersedes.length > 2
+          " (Supersedes #{@supersedes.join(', ')})"
+        else
+          " (Supersedes #{@supersedes.join(' and ')})"
+        end
+      end
+
+      def corrigendum
+        if @corrigendum.nil?
+          (@year && @corrigendum_comment && "/Cor 1-#{@year}") || ""
+        else
+          if @corrigendum[:year]
+            "/Cor #{@corrigendum[:version]}-#{@corrigendum[:year]}"
+          else
+            "/Cor #{@corrigendum[:version]}"
+          end
+        end
+      end
+
+      def reaffirmed
+        return unless @reaffirmed
+
+        return " (Reaffirmed #{@year})" if @reaffirmed.key?(:reaffirmation_of)
+
+        " (Reaffirmed #{@reaffirmed[:year]})" if @reaffirmed[:year]
+      end
+
+      def incorporates
+        # " (Supersedes #{@supersedes.join(', ')})"
+
+        " (Incorporates #{@incorporates.join(', and ')})" if @incorporates
+      end
+
+      def supplement
+        " (Supplement to #{@supplement})" if @supplement
+      end
+    end
+  end
+end

data/lib/pubid/ieee/identifier.rb

@@ -0,0 +1,46 @@
+module Pubid::Ieee
+  module Identifier
+    class << self
+      include Pubid::Core::Identifier
+
+      def parse(*args)
+        Base.parse(*args)
+      end
+
+      def convert_parser_parameters(type_status: nil, parameters: nil,
+                                         organizations: { publisher: "IEEE" }, **args)
+        res = [organizations, type_status, parameters].inject({}) do |result, data|
+          result.merge(
+            case data
+            when Hash
+              data.transform_values do |v|
+                (v.is_a?(Array) && v.first.is_a?(Hash) && merge_parameters(v)) || v
+              end
+            when Array
+              merge_parameters(data)
+            else
+              {}
+            end
+          )
+        end
+        res.merge(args)
+      end
+
+      def merge_parameters(params)
+        return params unless params.is_a?(Array)
+
+        result = {}
+        params.each do |item|
+          item.each do |key, value|
+            if result.key?(key)
+              result[key] = result[key].is_a?(Array) ? result[key] << value : [result[key], value]
+            else
+              result[key] = value
+            end
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/pubid/ieee/parser.rb

@@ -0,0 +1,399 @@
+require "pubid-iso"
+
+module Pubid::Ieee
+  class Parser < Parslet::Parser
+    rule(:digits) do
+      match('\d').repeat(1)
+    end
+
+    rule(:space) { str(" ") }
+    rule(:space?) { space.maybe }
+    rule(:comma) { str(", ") }
+    rule(:comma?) { comma.maybe }
+    rule(:comma_space) { comma | space }
+    rule(:dash) { str("-") }
+    rule(:dot) { str(".") }
+    rule(:words_digits) { match('[\dA-Za-z]').repeat(1) }
+    rule(:words) { match("[A-Za-z]").repeat(1) }
+    rule(:words?) { words.maybe }
+    rule(:year_digits) { (str("19") | str("20")) >> match('\d').repeat(2, 2) }
+
+    rule(:month_digits) do
+      match('\d').repeat(2, 2)
+    end
+
+    rule(:day_digits) do
+      match('\d').repeat(2, 2)
+    end
+
+    rule(:year) do
+      # -2014, April 2015
+      dash >> year_digits.as(:adoption_year) >> publication_date |
+        (dot | dash) >> year_digits.as(:year) >> str("(E)").maybe
+    end
+
+    rule(:organization) do
+      str("IEEE") | str("AIEE") | str("ANSI") | str("ASA") | str("NCTA") |
+        str("IEC") | str("ISO") | str("ASTM") | str("NACE") | str("NSF")
+    end
+
+    rule(:number) do
+      str("D").absent? >> ((digits | match("[A-Z]")).repeat(1) >> match("[a-z]").maybe).as(:number)
+    end
+
+    rule(:type) do
+      str("Std") | str("STD") | str("Standard")
+    end
+
+    rule(:comma_month_year) do
+      comma >> words.as(:month) >> space >> year_digits.as(:year)
+    end
+
+    rule(:edition) do
+      (comma >> year_digits.as(:year) >> str(" Edition")) |
+        ((space | dash) >> str("Edition ") >> (digits >> dot >> digits).as(:version) >> (str(" - ") | space) >>
+        year_digits.as(:year) >> (dash >>
+          month_digits.as(:month)).maybe) |
+        #, February 2018 (E)
+        (comma_month_year >> str("(E)")) |
+        # (comma_month_year >> space? >> str("(E)")) |
+        # comma_month_year |
+        # First edition 2002-11-01
+        space >> str("First").as(:version) >>
+        str(" edition ") >>
+          year_digits.as(:year) >> dash >>
+          month_digits.as(:month) >> (dash >>
+          day_digits.as(:day)).maybe
+
+    end
+
+    rule(:draft_status) do
+      (str("Active Unapproved") | str("Unapproved") | str("Approved")).as(:draft_status)
+    end
+
+    rule(:draft_prefix) do
+      space? >> str("/") | str("_") | dash | space
+    end
+
+    rule(:draft_date) do
+      ((space? >> comma | space) >> words.as(:month)).maybe >>
+        (
+          ((space >> digits.as(:day)).maybe >> comma >> year_digits.as(:year)) |
+            (comma_space >> match('\d').repeat(2, 4).as(:year))
+        )
+    end
+
+    rule(:draft_version) do
+      # for D1D2
+      (str("D") >> digits.as(:version)).repeat(2) |
+      # for DD3, D3Q
+      (str("D") >> words_digits.as(:version)).repeat(1, 1)
+    end
+
+    rule(:draft) do
+      # /D14, April 2020
+      # /D7 November, 2019
+      (draft_prefix >> draft_version >>
+        ((dot | str("r")) >> (digits >> words?).as(:revision)).maybe >>
+        draft_date.maybe).as(:draft)
+    end
+
+    rule(:part) do
+      ((dot | dash) >> words_digits).as(:part)
+    end
+
+    rule(:subpart) do
+      (dot | dash) >> match('[\da-z]').repeat(1)
+    end
+
+    rule(:part_subpart_year) do
+      # 802.15.22.3-2020
+      # 1073.1.1.1-2004
+      (part >> subpart.repeat(2, 2).as(:subpart) >> year) |
+        # C57.12.00-1993
+        (part >> subpart.as(:subpart) >> year) |
+        # N42.44-2008
+        # 1244-5.2000
+        # 11073-40102-2020
+        # C37.0781-1972
+        (part >> year) |
+        # C57.19.101
+        (part >> subpart.as(:subpart)) |
+        # IEC 62525-Edition 1.0 - 2007
+        edition.as(:edition) |
+        # IEEE P11073-10101
+        # IEEE P11073-10420/D4D5
+        # IEEE Unapproved Draft Std P11073-20601a/D13, Jan 2010
+        # XXX: hack to avoid being partially parsed by year
+        (dash >> match('[\dA-Za-z]').repeat(5, 6)).as(:part) |
+        # 581.1978
+        year |
+        # 61691-6
+        part
+    end
+
+    rule(:dual_pubids) do
+      space? >>
+        (
+          (str("(") >> (iso_identifier >> iso_parameters).as(:alternative) >> str(")") |
+            str("(") >> (parameters(organizations >> space?).as(:alternative) >> str(", ").maybe).repeat(1) >> str(")")) |
+          ((str("and ") | str("/ ") | space) >> identifier_no_params.as(:alternative)) |
+          (str("/") >> identifier_with_organization.as(:alternative)) |
+          # should have an organization when no brackets
+          identifier_with_organization.as(:alternative)
+        )
+    end
+
+    rule(:dual_pubid_without_parameters) do
+      space? >>
+        (
+          (str("(") >> (iso_identifier >> iso_parameters).as(:alternative) >> str(")") |
+            str("(") >> (identifier_no_params.as(:alternative) >> str(", ").maybe).repeat(1) >> str(")"))# |
+          #identifier_no_params.as(:alternative)
+        )
+    end
+
+    rule(:revision) do
+      (str("Revision ") >> (str("of") | str("to")) >> space >>
+        (identifier_without_dual_pubids.as(:identifier) >> str(" and ").maybe).repeat(1)
+      ).as(:revision)
+    end
+
+    rule(:previous_amendments) do
+      # IEEE P802.3bp/D3.4, April 2016 (Amendment of IEEE Std 802.3-2015 as amended by IEEE Std 802.3bw-2015,
+      # IEEE Std 802.3by-201X, and IEEE Std 802.3bq-201X)
+      str(",").maybe >> str(" as amended by ") >>
+        (identifier_inside_brackets.as(:identifier) >> (str(", ") >> str("and ").maybe).maybe).repeat(1)
+    end
+
+    # match everything before "," or ")" or " as"
+    rule(:identifier_inside_brackets) do
+      ((str(" as") | str(")") | str(",")).absent? >> any).repeat(1) >>
+        (str(", ") >> year_digits >> str(" Edition")).maybe
+    end
+
+    rule(:amendment) do
+      (str("Amendment ") >> (str("of") | str("to")) >> space >>
+        identifier_inside_brackets.as(:identifier) >> previous_amendments.maybe).as(:amendment)
+    end
+
+    rule(:number_prefix) do
+      ((str("No") | str("no")) >> (str(". ") | dot | space)).maybe
+    end
+
+    rule(:redline) do
+      str(" - ") >> str("Redline").as(:redline)
+    end
+
+    rule(:publication_date) do
+      comma_month_year
+    end
+
+    rule(:supersedes) do
+      (str("Supersedes ") >> (identifier_without_dual_pubids.as(:identifier) >>
+        (str(" and ") | str(" ")).maybe).repeat(1)).as(:supersedes)
+    end
+
+    rule(:incorporates) do
+      (
+        match("[Ii]") >> (str("ncorporates ") | str("ncorporating ")) >>
+          (identifier_without_dual_pubids.as(:identifier) >> str(", and ").maybe).repeat(1)
+      ).as(:incorporates)
+    end
+
+    rule(:supplement) do
+      (str("Supplement") >> str("s").maybe >> str(" to ") >> identifier_without_dual_pubids.as(:identifier)).as(:supplement)
+    end
+
+    rule(:additional_parameters) do
+      (space? >> str("(") >> (
+        (reaffirmed | revision | amendment | supersedes | corrigendum_comment| incorporates | supplement) >>
+          ((str("/") | str(",")) >> space?).maybe).repeat >> str(")").maybe
+      ).repeat >> redline.maybe
+    end
+
+    # Hack to exclude dual_pubids parsing for revisions and supersedes
+    # otherwise extra identifiers parsed as dual PubIDs to the main identifier
+    def parameters(atom, without_dual_pubids: false, skip_parameters: false)
+      atom >>
+        ((draft_status >> space).maybe >> (str("Draft ").maybe >>
+          type.as(:type) >> space.maybe).maybe).as(:type_status) >>
+        number_prefix >> number >>
+        (
+          # IEEE P2410-D4, July 2019
+          (draft |
+            part_subpart_year.maybe >> corrigendum.maybe >> draft.maybe >> iso_amendment.maybe
+          ) >>
+            if skip_parameters
+              str("")
+            else
+              publication_date.maybe
+            end >>
+            if skip_parameters
+              str("")
+            else
+              edition.as(:edition).maybe
+            end >>
+            # dual-PubIDs
+            ((without_dual_pubids && str("")) || dual_pubids.maybe) >>
+            if skip_parameters
+              str("")
+            else
+              additional_parameters.maybe
+            end
+        ).as(:parameters)
+    end
+
+    rule(:reaffirmed) do
+      (
+        (str("Reaffirmed ") >> year_digits.as(:year) |
+          str("Reaffirmation of ") >> identifier.as(:identifier).as(:reaffirmation_of))
+      ).as(:reaffirmed)
+    end
+
+    rule(:corrigendum_prefix) do
+      (str("_") | str("/") | str("-")) >> str("Cor") >> (str("-") | dot.maybe >> space?)
+    end
+
+    rule(:corrigendum) do
+      # IEEE 1672-2006/Cor 1-2008
+      (
+        corrigendum_prefix >> digits.as(:version) >> ((dash | str(":")) >> year_digits.as(:year)).maybe
+      ).as(:corrigendum)
+    end
+
+    rule(:corrigendum_comment) do
+      ((str("Corrigendum to ") | str("Corrigenda ") >> (str("to ") | str("of "))) >>
+        identifier.as(:identifier)).as(:corrigendum_comment)
+    end
+
+    rule(:iso_amendment_prefix) do
+      str("/") >> str("Amd")
+    end
+
+    rule(:iso_amendment) do
+      # IEEE 1672-2006/Cor 1-2008
+      (iso_amendment_prefix >> digits.as(:version) >> (dash >> year_digits.as(:year)).maybe).as(:iso_amendment)
+    end
+
+    rule(:organizations) do
+      (organization.as(:publisher) >> (str("/") >> space? >> organization.as(:copublisher)).repeat)
+        .as(:organizations)
+    end
+
+    rule(:identifier_with_organization) do
+      parameters(organizations >> space?)
+    end
+
+    rule(:identifier_with_org_no_params) do
+      iso_identifier | parameters(organizations >> space?, skip_parameters: true)
+    end
+
+    rule(:identifier_no_params) do
+      parameters((organizations >> space).maybe, skip_parameters: true, without_dual_pubids: true)
+    end
+
+    rule(:iso_part) do
+      (str("-") | str("/")) >> str(" ").maybe >>
+        # (str("-") >> iso_parser.stage).absent? >>
+        ((match('\d') | str("A")) >>
+          ((str("-") >> iso_parser.typed_stage).absent? >>
+          (match['\d[A-Z]'] | str("-"))).repeat).as(:part)
+    end
+
+    rule(:iso_part_stage_iteration) do
+      iso_part >>
+      (str("-") >> iso_parser.typed_stage.as(:stage)) >> iso_parser.iteration.maybe
+    end
+
+    rule(:iso_stage_part_iteration) do
+      # don't consume draft from IEEE format
+      ((str("-") | str("/")) >> (str("D") >> digits).absent? >> (iso_parser.typed_stage.as(:stage) | iso_parser.stage.as(:stage))) >>
+        iso_part.maybe >> iso_parser.iteration.maybe
+    end
+
+    # add rule when don't have stage
+    #
+    rule(:iso_part_iteration) do
+      iso_part >> iso_parser.iteration.maybe
+    end
+
+    rule(:iso_part_stage_iteration_matcher) do
+      # consumes "/"
+      iso_stage_part_iteration |
+      iso_part_stage_iteration |
+      iso_part_iteration
+
+    end
+
+    rule(:iso_identifier) do
+      # Pubid::Iso::Parser.new.identifier.as(:iso_identifier)
+        # Withdrawn e.g: WD/ISO 10360-5:2000
+        # for French and Russian PubIDs starting with Guide type
+      ((iso_parser.guide_prefix.as(:type) >> str(" ")).maybe >>
+      (iso_parser.typed_stage.as(:stage) >> str(" ")).maybe >>
+        iso_parser.originator >> ((str(" ") | str("/")) >>
+      # for ISO/FDIS
+      (iso_parser.type | iso_parser.typed_stage.as(:stage))).maybe >>
+      # for ISO/IEC WD TS 25025
+      str(" ").maybe >> ((iso_parser.typed_stage.as(:stage) | iso_parser.stage.as(:stage) | iso_parser.type) >> str(" ")).maybe >>
+        (str("P").maybe >> iso_parser.digits).as(:number) >>
+      # for identifiers like ISO 5537/IDF 26
+      (str("|") >> (str("IDF") >> str(" ") >> digits).as(:joint_document)).maybe >>
+        iso_part_stage_iteration_matcher.maybe >>
+      (str(" ").maybe >> str(":") >> iso_parser.year).maybe >>
+      # stage before amendment
+      (
+      # stage before corrigendum
+      iso_parser.supplement.maybe) >>
+        iso_parser.language.maybe).as(:iso_identifier)
+    end
+
+    rule(:iso_parameters) do
+      iso_amendment.maybe >> (dual_pubid_without_parameters.maybe >>
+        (publication_date >> space? >> str("(E)").maybe).maybe >>
+        edition.as(:edition).maybe >> draft.maybe >> additional_parameters).as(:parameters)
+    end
+
+    rule(:identifier_before_edition) do
+      ((str(" Edition")).absent? >> any).repeat(1)
+    end
+
+    rule(:identifier) do
+      iso_or_ieee_identifier
+      # (identifier_before_edition.as(:iso_identifier).as(:iso_identifier) >> iso_parameters) |
+    end
+
+    rule(:ieee_without_prefix) do
+      (str("IEEE").as(:publisher).as(:organizations) >> space) >>
+        digits.as(:number) >> str(".").absent? >> year.as(:parameters)
+    end
+
+    rule(:iso_or_ieee_identifier) do
+      ieee_without_prefix |
+        (iso_identifier >> iso_parameters) |
+        # (iso identifier) >> space >> (ieee identifier) ?
+        iso_identifier >> space >> parameters((organizations >> space).maybe) | iso_identifier |
+        parameters((organizations >> space).maybe)
+    end
+
+    rule(:parameters_with_optional_organizations) do
+      parameters((organizations >> space).maybe)
+    end
+
+    rule(:identifier_without_dual_pubids) do
+      iso_identifier >> iso_parameters |
+      parameters((organizations >> space).maybe, without_dual_pubids: true)
+    end
+
+    rule(:identifier_without_parameters) do
+      parameters((organizations >> space).maybe, skip_parameters: true)
+    end
+
+    rule(:root) { identifier }
+
+    def iso_parser
+      Pubid::Iso::Parser.new
+    end
+  end
+end

data/lib/pubid/ieee/transformer.rb

@@ -0,0 +1,40 @@
+module Pubid::Ieee
+  class Transformer < Parslet::Transform
+    rule(month: simple(:month), year: simple(:year)) do |date|
+      update_month_year(date[:month], date[:year])
+    end
+
+    rule(month: simple(:month), year: simple(:year), day: simple(:day)) do |date|
+      update_month_year(date[:month], date[:year]).merge({ day: date[:day] })
+    end
+
+    rule(identifier: subtree(:identifier)) do |data|
+      if data[:identifier].is_a?(Parslet::Slice)
+        Identifier::Base.transform(Identifier.convert_parser_parameters(**Parser.new.iso_or_ieee_identifier.parse(data[:identifier].to_s)))
+      else
+        Identifier::Base.transform(Identifier.convert_parser_parameters(**data[:identifier]))
+      end
+    end
+
+    def self.update_month_year(month, year)
+      { year: if year.length == 2
+                case year.to_i
+                when 0..25 then "20#{year}"
+                when 26..99 then "19#{year}"
+                end
+              else
+                year
+              end,
+        month: Date.parse(month).strftime("%B") }
+    end
+
+    rule(type: simple(:type)) do
+      { type: case type
+        when "Standard"
+          :std
+        else
+          type
+        end }
+    end
+  end
+end

data/lib/pubid/ieee/type.rb

@@ -0,0 +1,42 @@
+module Pubid::Ieee
+  class Type
+    attr_accessor :type
+
+    TYPE_NAMES = {
+      std: {
+        long: "Standard",
+        full: "Std ",
+        short: "Std ",
+        match: %w[STD Std Standard],
+        alternative: "",
+      },
+      draft: {
+        full: "Draft Std ",
+        short: "Draft Std ",
+        match: %w[Draft],
+        alternative: "Draft ",
+      },
+    }.freeze
+
+    # Create new type
+    # @param type [Symbol]
+    def initialize(type = :std)
+      type = type.to_s.downcase.to_sym unless type.is_a?(Symbol)
+
+      raise Errors::WrongTypeError, "#{type} type is not available" unless TYPE_NAMES.key?(type)
+
+      @type = type
+    end
+
+    def self.parse(type_string)
+      TYPE_NAMES.each do |type, values|
+        return new(type) if values[:match].include?(type_string)
+      end
+      raise Errors::ParseTypeError, "Cannot parse '#{type_string}' type"
+    end
+
+    def to_s(format = :short)
+      TYPE_NAMES[type][format]
+    end
+  end
+end

data/lib/pubid/ieee/version.rb

@@ -0,0 +1,5 @@
+module Pubid
+  module Ieee
+    VERSION = "0.1.1".freeze
+  end
+end

data/lib/pubid/ieee.rb

@@ -0,0 +1,19 @@
+require "parslet"
+
+module Pubid
+  module Ieee
+
+  end
+end
+
+require_relative "ieee/errors"
+require_relative "ieee/parser"
+require_relative "ieee/transformer"
+require_relative "ieee/type"
+require_relative "ieee/identifier"
+require_relative "ieee/identifier/base"
+
+config = Pubid::Core::Configuration.new
+config.default_type = Pubid::Ieee::Identifier::Base
+config.types = [Pubid::Ieee::Identifier::Base]
+Pubid::Ieee::Identifier.set_config(config)

data/lib/pubid-ieee.rb

@@ -0,0 +1 @@
+require_relative "pubid/ieee"

data/update_codes.yaml

@@ -0,0 +1,53 @@
+IEEE Unapproved Draft Std PC37.110/D911Oct 07: IEEE Unapproved Draft Std PC37.110/D711, Oct 07
+IEEE C57.139/D14June 2010: IEEE C57.139/D14, June 2010
+IEEE P1653.5/D7d1 November, 2019: IEEE P1653.5/D7.1 November, 2019
+IEEE P1017/D062012: P1017/D062012, Jun 2012
+IEEP62.42.1/D3, October 2014: IEEE P62.42.1/D3, October 2014
+IEEE P802.11ajD8.0, August 2017: IEEE P802.11aj/D8.0, August 2017
+IEEE P802.11ajD9.0, November 2017: IEEE P802.11aj/D9.0, November 2017
+"IEC 62529:2012(E) (IEEE Std 1641-2010": IEC 62529:2012(E) (IEEE Std 1641-2010)
+"IEC 62529:2012(E) (IEEE Std 1641-2010 - Redline": IEC 62529:2012(E) (IEEE Std 1641-2010) - Redline
+IEEE IEEE P1453/D3, June 2011: IEEE P1453/D3, June 2011
+AIEE No 1E -1957: AIEE No 1E-1957
+A.I.E.E. No. 15 May-1928: AIEE No 15-192805
+AIEE No 45 -1951: AIEE No 45-1951
+AIEE No. 2-June 1929: AIEE No 2-192906
+AIEE No. 25-1952 (Supercedes AIEE No. 25-1945): AIEE No 25-1952 (Supercedes AIEE No. 25-1945)
+AIEE No.1-1962 (Supersedes June 1957 issue): AIEE No 1-1962 (Supersedes AIEE No 1-195706)
+AIEE Nos 72 and 73 - 1932: AIEE No 72-1932 and AIEE No 73-1932
+EEE Std 1671.1-2017 (Revision of IEEE Std 1671.1‐2009): IEEE Std 1671.1-2017 (Revision of IEEE Std 1671.1-2009)
+EEE Std 1671.1-2017 (Revision of IEEE Std 1671.1-2009): IEEE Std 1671.1-2017 (Revision of IEEE Std 1671.1-2009)
+EEE Std 488.2-1992: IEEE Std 488.2-1992
+EEE Std 802.3br-2016 (Amendment to IEEE Std 802.3-2015 as amended by IEEE St802.3bw-2015, IEEE Std 802.3by-2016, IEEE Std 802.3bq-2016, and IEEE Std 802.3bp-2016): IEEE Std 802.3br-2016 (Amendment to IEEE Std 802.3-2015 as amended by IEEE Std 802.3bw-2015, IEEE Std 802.3by-2016, IEEE Std 802.3bq-2016, and IEEE Std 802.3bp-2016)
+IEEE Std 336-2010 (Revision of EEE Std 336-2005): IEEE Std 336-2010 (Revision of IEEE Std 336-2005)
+IEEE Std 356-2020 (Revision of IEEE Std 356?2010): IEEE Std 356-2020 (Revision of IEEE Std 356-2010)
+IEEE Std 356-2020 (Revision of IEEE Std 356?2010) - Redline: IEEE Std 356-2020 (Revision of IEEE Std 356-2010) - Redline
+IEEE Std Std 1139-2008: IEEE Std 1139-2008
+IEEE/ ASTM SI 10-2010 (Revision of IEEE/ASTM SI 10-2002): IEEE/ASTM SI 10-2010 (Revision of IEEE/ASTM SI 10-2002)
+"IEEE Std 24748-3:2012": IEEE 24748-3:2012
+"ISO/IEC/IEEE P24765/D3:2017": ISO/IEC/IEEE P24765:2017/D3
+ISO/IEC/IEEE FDIS P24765 FDIS, October 2016: ISO/IEC/IEEE FDIS P24765, October 2016
+ISO/IEC/IEEE P15289 FDIS, February 2019: ISO/IEC/IEEE FDIS P15289, February 2019
+ISO/IEC/IEEE P26515 FDIS, May 2018: ISO/IEC/IEEE FDIS P26515, May 2018
+IEEE Std Std 1139-2008: IEEE Std 1139-2008
+IEC/IEEE P60214-2, FDIS 2018: IEC/IEEE FDIS P60214-2-2018(E)
+IEC/IEEE P62582-6, FDIS 2018: IEC/IEEE FDIS P62582-6-2018(E)
+ISO/IEC DIS P26511.2, May 2017: ISO/IEC DIS P26511-2, May 2017
+ISO/IEC/IEEE P90003_FDIS, August 2018: ISO/IEC/IEEE FDIS P90003, August 2018
+ISO/IEC/IEEE P29119-1/FDIS, September 2021: ISO/IEC/IEEE FDIS P29119-1, September 2021
+ISO/IEC/IEEE/ P12207-2/D3_FDIS, July 2020: ISO/IEC/IEEE FDIS P12207-2/D3, July 2020
+ISO/IEC/IEEE/ P21841/FDIS, April 2019: ISO/IEC/IEEE FDIS P21841, April 2019
+ISO/IEC/IEEE/ P24748-3/DIS, August 2019: ISO/IEC/IEEE DIS P24748-3, August 2019
+IEEE Std 1018-2013 (Revison of IEEE Std 1018-2004): IEEE Std 1018-2013 (Revision of IEEE Std 1018-2004)
+IEEE Std 1018-2013 (Revison of IEEE Std 1018-2004) - Redline: IEEE Std 1018-2013 (Revision of IEEE Std 1018-2004) - Redline
+IEEE SId 342-1973 (ANSI C37.0731-1973): IEEE Std 342-1973 (ANSI C37.0731-1973)
+P1484.12.3/D1, September2019: IEEE P1484.12.3/D1, September 2019
+P1073.1.3.4/D3.0: IEEE P1073.1.3.4/D3.0
+P1936.1, 2020: IEEE P1936.1, January 2020
+P20000-2, D1 December 2012: IEEE P20000-2/D1, December 2012
+ISO/IEC/IEEE 8802-22.2:2015/Amd.2:2017(E): ISO/IEC/IEEE 8802-22:2015/Amd.2:2017(E)
+IEEE 1070-1995: IEEE No 1070-1995
+IEEE 278-1967: IEEE No 278-1967
+IEEE 730-1989: IEEE No 730-1989
+IEEE 751-1991: IEEE No 751-1991
+IEEE 1023-2020 (Revision of IEEE Std 1023-2004): IEEE No 1023-2020 (Revision of IEEE Std 1023-2004)

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: pubid-ieee
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Ribose Inc.
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2023-05-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: lightly
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pubid-iso
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.2
+description: Library to generate, parse and manipulate IEEE PubID.
+email:
+- open.source@ribose.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.adoc
+- LICENSE.txt
+files:
+- LICENSE.txt
+- README.adoc
+- lib/pubid-ieee.rb
+- lib/pubid/ieee.rb
+- lib/pubid/ieee/errors.rb
+- lib/pubid/ieee/identifier.rb
+- lib/pubid/ieee/identifier/base.rb
+- lib/pubid/ieee/parser.rb
+- lib/pubid/ieee/transformer.rb
+- lib/pubid/ieee/type.rb
+- lib/pubid/ieee/version.rb
+- update_codes.yaml
+homepage: https://github.com/metanorma/pubid-ieee
+licenses:
+- BSD-2-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: Library to generate, parse and manipulate IEEE PubID.
+test_files: []