pubid 2.0.0.pre.alpha.7 → 2.0.0.pre.alpha.9

data/lib/pubid/adobe/parser.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Adobe
+    # Parslet grammar for Adobe identifiers.
+    #
+    # Canonical citation forms (what the renderer produces):
+    #
+    #   Adobe TN 5014                  (tech note; replaces the older
+    #                                    "Adobe Technical Note #5014")
+    #   Adobe Publication adobe-glyph-list
+    #   Adobe Publication adobe-japan1-7
+    #
+    # The parser also accepts these legacy forms for back-compat:
+    #
+    #   Adobe Technical Note #5014
+    #   Adobe Technical Note 5014
+    #   Adobe TN5014                   (no space)
+    #   ATN5014                        (short alias)
+    #   5014                           (bare number; data-repo context)
+    #   adobe-glyph-list               (bare slug)
+    class Parser < Parslet::Parser
+      include ::Pubid::Parser::CommonParseRules
+
+      root :identifier
+
+      rule(:space)  { str(" ") }
+      rule(:space?) { space.maybe }
+      rule(:hash)   { str("#") }
+      rule(:dot)    { str(".") }
+      rule(:dash)   { str("-") }
+
+      # Canonical short prefix: "Adobe TN" with optional trailing space.
+      # Matches both "Adobe TN 5014" and "Adobe TN5014".
+      rule(:tech_note_tn_prefix) do
+        str("Adobe") >> space >> str("TN") >> space?.maybe
+      end
+
+      # Legacy long prefix: "Adobe Technical Note" with optional "#".
+      rule(:tech_note_long_prefix) do
+        str("Adobe") >> space >> str("Technical") >> space >> str("Note") >>
+          (space? >> hash.maybe >> space?).maybe
+      end
+
+      # Legacy short alias: "ATN" with optional trailing space.
+      rule(:tech_note_atn_prefix) do
+        str("ATN") >> space?.maybe
+      end
+
+      rule(:tech_note_prefix) do
+        tech_note_tn_prefix | tech_note_long_prefix | tech_note_atn_prefix
+      end
+
+      rule(:digits) do
+        match("[0-9]").repeat(1)
+      end
+
+      # 4-digit tech note number, optionally followed by ".<Slug>" from
+      # the filename form. The slug is captured but not required.
+      rule(:slug_chars) do
+        match("[A-Za-z0-9_]").repeat(1)
+      end
+
+      rule(:tech_note) do
+        (tech_note_prefix >>
+          digits.as(:number) >>
+          (dot >> slug_chars.as(:slug)).maybe).as(:tech_note)
+      end
+
+      # Bare number form (e.g. when the data repo passes just "5014"
+      # extracted from a filename). Not advertised in user docs; used
+      # internally by AdobeFetcher::Docid.
+      rule(:bare_number) do
+        digits.as(:number).as(:tech_note_bare)
+      end
+
+      # "Adobe Publication " prefix. Matched literally then discarded —
+      # the publication slug/version is parsed by the inner rule.
+      rule(:publication_prefix) do
+        str("Adobe") >> space >> str("Publication") >> space
+      end
+
+      # Publication slug. Lowercase ASCII letters and digits joined by `-`.
+      # Each segment starts with a letter (so a trailing `-<digits>` is
+      # unambiguously a version suffix, not part of the slug).
+      rule(:slug_segment) do
+        match("[a-z]") >> match("[a-z0-9]").repeat
+      end
+
+      rule(:slug_inner) do
+        slug_segment >> (dash >> slug_segment).repeat
+      end
+
+      rule(:publication_with_version) do
+        (slug_inner.as(:slug) >> dash >> digits.as(:version)).as(:publication_version)
+      end
+
+      rule(:publication_slug_or_version) do
+        # Try with-version first so `adobe-japan1-7` doesn't get captured
+        # as slug `adobe-japan1-7` with no version. The flat `:slug` form
+        # is the fallback for unversioned slugs.
+        publication_with_version | slug_inner.as(:slug)
+      end
+
+      rule(:publication) do
+        # Optional "Adobe Publication " prefix. The prefix is consumed
+        # but not captured — the inner rule produces :slug or
+        # :publication_version as before.
+        publication_prefix.maybe >> publication_slug_or_version
+      end
+
+      rule(:identifier) do
+        tech_note | bare_number | publication
+      end
+
+      # Parse a string and return the raw parslet tree.
+      # @param string [String]
+      # @return [Hash]
+      def self.parse(string)
+        raise ArgumentError, ::Pubid::INPUT_TOO_LONG_MESSAGE if string.length > ::Pubid::MAX_INPUT_LENGTH
+
+        new.parse(string.strip)
+      end
+    end
+  end
+end

data/lib/pubid/adobe/renderer.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Adobe
+    # Human-readable renderer for Adobe identifiers.
+    #
+    # Produces the canonical citation forms:
+    #   "Adobe TN 5014"                       (tech note)
+    #   "Adobe Publication adobe-glyph-list"  (publication, slug)
+    #   "Adobe Publication adobe-japan1-7"    (publication, slug + version)
+    #
+    # The data repo (AdobeFetcher::Docid) overrides #to_s for publications
+    # to use the title from metadata instead of the slug, producing e.g.
+    # "Adobe Publication Adobe Glyph List". Pubid::Adobe itself is purely
+    # structural and renders slug-form citations.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **_opts)
+        id = @id
+
+        return render_tech_note(id) if id.is_a?(Identifiers::TechNote)
+        return render_publication(id) if id.is_a?(Identifiers::Publication)
+
+        raise ArgumentError, "Unknown Adobe identifier class: #{id.class}"
+      end
+
+      private
+
+      def render_tech_note(id)
+        "Adobe TN #{id.number}"
+      end
+
+      def render_publication(id)
+        rendered = "Adobe Publication #{id.slug}"
+        rendered << "-#{id.version}" if id.version
+        rendered
+      end
+    end
+  end
+end

data/lib/pubid/adobe/urn_generator.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Adobe
+    # Generates URN strings for Adobe identifiers.
+    #
+    # Format:
+    #   urn:adobe:tech-note:<number>            e.g. urn:adobe:tech-note:5014
+    #   urn:adobe:publication:<slug>[:v<ver>]   e.g. urn:adobe:publication:adobe-glyph-list
+    #                                             urn:adobe:publication:adobe-japan1:v7
+    class UrnGenerator
+      attr_reader :identifier
+
+      def initialize(identifier)
+        @identifier = identifier
+      end
+
+      def generate
+        if identifier.is_a?(Identifiers::TechNote)
+          generate_tech_note
+        elsif identifier.is_a?(Identifiers::Publication)
+          generate_publication
+        else
+          raise ArgumentError,
+                "Unknown Adobe identifier class: #{identifier.class}"
+        end
+      end
+
+      private
+
+      def generate_tech_note
+        "urn:adobe:tech-note:#{identifier.number}"
+      end
+
+      def generate_publication
+        parts = ["urn:adobe:publication", identifier.slug]
+        parts << "v#{identifier.version}" if identifier.version
+        parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/adobe/urn_parser.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Adobe
+    # Parses Adobe URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:adobe:tech-note:<number>
+    #   urn:adobe:publication:<slug>[:v<version>]
+    #
+    # Examples:
+    #   urn:adobe:tech-note:5014                  → Adobe Technical Note #5014
+    #   urn:adobe:publication:adobe-glyph-list    → adobe-glyph-list
+    #   urn:adobe:publication:adobe-japan1:v7     → adobe-japan1-7
+    class UrnParser < Pubid::UrnParser::Base
+      PREFIX = "urn:adobe:".freeze
+
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+        namespace = parts.fetch(0)
+
+        case namespace
+        when "tech-note"
+          parse_tech_note(parts)
+        when "publication"
+          parse_publication(parts)
+        else
+          raise Pubid::UrnParser::Errors::ParseError,
+                "Unknown Adobe URN namespace: #{namespace.inspect} in #{urn.inspect}"
+        end
+      end
+
+      private
+
+      def strip_namespace(urn)
+        unless urn.downcase.start_with?(PREFIX)
+          raise Pubid::UrnParser::Errors::ParseError,
+                "Invalid Adobe URN: #{urn.inspect}"
+        end
+
+        urn[PREFIX.length..]
+      end
+
+      def parse_tech_note(parts)
+        number = parts.fetch(1)
+        flavor_parse("Adobe Technical Note ##{number}")
+      end
+
+      def parse_publication(parts)
+        slug = parts.fetch(1)
+        version_seg = parts[2]
+        if version_seg&.start_with?("v")
+          flavor_parse("#{slug}-#{version_seg.sub(/\Av/, "")}")
+        else
+          flavor_parse(slug)
+        end
+      end
+
+      def split_parts(body)
+        body.split(":")
+      end
+
+      def flavor_parse(text)
+        ::Pubid::Adobe.parse(text)
+      end
+    end
+  end
+end

data/lib/pubid/adobe.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Adobe
+    extend Pubid::PrefixesSupport
+
+    # Leading identifier prefix tokens that an Adobe document id can start
+    # with. Tech notes appear as both `Adobe Technical Note #<n>` and the
+    # short alias `ATN<n>` in citations; both must route to this flavor.
+    # Named publications start with `Adobe` (e.g. `Adobe Glyph List`,
+    # `Adobe-Japan1-7`).
+    PREFIXES = ["Adobe", "ATN"].freeze
+
+    autoload :Builder,      "#{__dir__}/adobe/builder"
+    autoload :Identifier,   "#{__dir__}/adobe/identifier"
+    autoload :Identifiers,  "#{__dir__}/adobe/identifiers"
+    autoload :Parser,       "#{__dir__}/adobe/parser"
+    autoload :Renderer,     "#{__dir__}/adobe/renderer"
+    autoload :UrnGenerator, "#{__dir__}/adobe/urn_generator"
+    autoload :UrnParser,    "#{__dir__}/adobe/urn_parser"
+
+    # Parse an Adobe identifier string into an identifier object.
+    # @param identifier [String]
+    # @return [Pubid::Adobe::Identifier]
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    # with the Adobe-specific renderer.
+    Identifier.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Adobe::Renderer)
+
+    # Auto-discover identifier types from the Identifiers namespace.
+    # @return [Array<Class>]
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants
+        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
+        .select { |c| c.is_a?(Class) && c < Pubid::Identifier }
+        .reject { |c| c == Identifier }
+    end
+
+    # Lookup: type key → identifier class
+    # @param code [String, Symbol]
+    # @return [Class, nil]
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    # Lookup: type short letter (e.g. "ATN") → identifier class
+    # @param short [String]
+    # @return [Class<Identifier>]
+    def self.identifier_klass_for_short(short)
+      @by_short ||= identifier_types.to_h { |klass| [klass.type[:short].to_s, klass] }
+      @by_short.fetch(short.to_s)
+    end
+  end
+end
+
+Pubid::Registry.register(:adobe, Pubid::Adobe)

data/lib/pubid/amca/builder.rb

@@ -7,7 +7,7 @@ module Pubid
     class Builder
       attr_reader :identifier_class
 
-      def initialize(identifier_class = Identifiers::Base)
+      def initialize(identifier_class = Identifier)
         @identifier_class = identifier_class
       end
 
@@ -46,7 +46,7 @@ module Pubid
 
       # Class method to build an identifier from parsed data
       # @param parsed [Hash, Array] the parsed identifier data
-      # @return [Identifiers::Base] the constructed identifier object
+      # @return [Identifier] the constructed identifier object
       def self.build(parsed)
         new.build(parsed)
       end

data/lib/pubid/amca/identifier.rb

@@ -1,6 +1,4 @@
 # frozen_string_literal: true
 
 # Pubid::Amca::Identifier is the AMCA base class (a real Pubid::Identifier
-# subclass); its body, `.parse`, and the Identifiers::Base back-compat alias
-# live in identifiers/base.rb. This file just ensures it is loaded.
-require_relative "identifiers/base"
+# subclass); its body and `.parse` live in identifiers/base.rb. This file just ensures it is loaded.

data/lib/pubid/amca/identifiers/base.rb

@@ -3,7 +3,7 @@
 module Pubid
   module Amca
     # Base identifier class for AMCA identifiers. Canonical name
-    # Pubid::Amca::Identifier (Identifiers::Base is a back-compat alias); common
+    # Pubid::Amca::Identifier; common
     # functionality for all AMCA identifier types.
     class Identifier < ::Pubid::Identifier
       # @raise [Parslet::ParseFailed] If parsing fails
@@ -66,10 +66,5 @@ module Pubid
       end
     end
 
-    module Identifiers
-      # Backward-compatible alias: AMCA's base class used to be
-      # Pubid::Amca::Identifiers::Base. It is now Pubid::Amca::Identifier.
-      Base = Pubid::Amca::Identifier
-    end
   end
 end

data/lib/pubid/amca/identifiers/interpretation.rb

@@ -8,7 +8,7 @@ module Pubid
       # - AMCA 99 JW Interp
       # - AMCA 204 – 1
       # - ANSI/AMCA 204 Interp
-      class Interpretation < Base
+      class Interpretation < Identifier
         attr_reader :interpretation_code
 
         def initialize(code:, year: nil, copublisher: nil, suffix: nil,

data/lib/pubid/amca/identifiers/publication.rb

@@ -8,7 +8,7 @@ module Pubid
       # - AMCA Publication 211-22 (Rev. 01-23)
       # - AMCA Publication 311-16
       # - AMCA Publication 1011-03 (R2010)
-      class Publication < Base
+      class Publication < Identifier
         attr_reader :revision
 
         def initialize(code:, year:, copublisher: nil, suffix: nil,

data/lib/pubid/amca/identifiers/standard.rb

@@ -8,7 +8,7 @@ module Pubid
       # - ANSI/AMCA 210-16
       # - ANSI/AMCA Standard 99-25
       # - AMCA Standard 803-02 (R2008)
-      class Standard < Base
+      class Standard < Identifier
         def self.type
           { key: :standard, title: "Standard", short: nil }
         end

data/lib/pubid/amca/identifiers.rb

@@ -3,7 +3,6 @@
 module Pubid
   module Amca
     module Identifiers
-      autoload :Base, "#{__dir__}/identifiers/base"
       autoload :Interpretation, "#{__dir__}/identifiers/interpretation"
       autoload :Publication, "#{__dir__}/identifiers/publication"
       autoload :Standard, "#{__dir__}/identifiers/standard"

data/lib/pubid/amca/single_identifier.rb

@@ -4,7 +4,7 @@ module Pubid
   module Amca
     # Base class for single (non-supplement) ACMA identifiers
     # Includes: Standard, Publication
-    class SingleIdentifier < Identifiers::Base
+    class SingleIdentifier < Identifier
     end
   end
 end

data/lib/pubid/amca.rb

@@ -8,7 +8,7 @@ module Pubid
     # Pubid::JOINT_PREFIXES.
     PREFIXES = ["AMCA"].freeze
 
-    autoload :Identifier, "#{__dir__}/amca/identifier"
+    autoload :Identifier, "#{__dir__}/amca/identifiers/base"
     autoload :Identifiers, "#{__dir__}/amca/identifiers"
     autoload :Builder, "#{__dir__}/amca/builder"
     autoload :Parser, "#{__dir__}/amca/parser"
@@ -26,8 +26,8 @@ module Pubid
     end
 
     # Per-flavor format registry: inherits global formats, overrides :human
-    Identifiers::Base.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
-    Identifiers::Base.format_registry.register(:human, renderer: Amca::Renderer)
+    Identifier.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Amca::Renderer)
 
     # Auto-discover all identifier types from the Identifiers namespace
     # @return [Array<Class>] identifier classes that define a self.type Hash

data/lib/pubid/ashrae/builder.rb

@@ -7,7 +7,7 @@ module Pubid
     class Builder
       attr_reader :identifier_class
 
-      def initialize(identifier_class = Identifiers::Base)
+      def initialize(identifier_class = Identifier)
         @identifier_class = identifier_class
       end
 
@@ -53,7 +53,7 @@ module Pubid
 
       # Class method to build an identifier from parsed data
       # @param parsed [Hash, Array] the parsed identifier data
-      # @return [Identifiers::Base] the constructed identifier object
+      # @return [Identifier] the constructed identifier object
       def self.build(parsed)
         new.build(parsed)
       end
@@ -158,12 +158,12 @@ module Pubid
       def build_errata(parsed)
         base_attrs = extract_base_attributes(parsed)
         base_class = determine_identifier_class(base_attrs)
-        base_identifier = base_class.new(**base_attrs)
+        base = base_class.new(**base_attrs)
 
         errata_date = extract_errata_date(parsed[:errata_date])
 
         Identifiers::Errata.new(
-          base_identifier: base_identifier,
+          base: base,
           errata_date: errata_date,
         )
       end
@@ -174,10 +174,10 @@ module Pubid
       def build_interpretation(parsed)
         base_attrs = extract_base_attributes(parsed)
         base_class = determine_identifier_class(base_attrs)
-        base_identifier = base_class.new(**base_attrs)
+        base = base_class.new(**base_attrs)
 
         Identifiers::Interpretation.new(
-          base_identifier: base_identifier,
+          base: base,
         )
       end
 
@@ -187,13 +187,13 @@ module Pubid
       def build_addendum_from_identifier(parsed)
         base_attrs = extract_base_attributes(parsed)
         base_class = determine_identifier_class(base_attrs)
-        base_identifier = base_class.new(**base_attrs)
+        base = base_class.new(**base_attrs)
 
         addendum_code = extract_value(parsed[:addendum_code])
         addendum_date = extract_addendum_date(parsed[:addendum_year])
 
         Identifiers::Addendum.new(
-          base_identifier: base_identifier,
+          base: base,
           addendum_code: addendum_code,
           addendum_date: addendum_date,
         )
@@ -209,13 +209,13 @@ module Pubid
           year: extract_value(parsed[:year]),
         }
         base_class = determine_identifier_class(base_attrs)
-        base_identifier = base_class.new(**base_attrs)
+        base = base_class.new(**base_attrs)
 
         addendum_code = extract_value(parsed[:addendum_code])
         addendum_date = extract_addendum_date(parsed[:addendum_year])
 
         Identifiers::Addendum.new(
-          base_identifier: base_identifier,
+          base: base,
           addendum_code: addendum_code,
           addendum_date: addendum_date,
         )
@@ -232,13 +232,13 @@ module Pubid
           year: extract_value(parsed[:year]),
         }
         base_class = determine_identifier_class(base_attrs)
-        base_identifier = base_class.new(**base_attrs)
+        base = base_class.new(**base_attrs)
 
         addendum_code = extract_value(parsed[:addendum_code])
         addendum_date = extract_addendum_date(parsed[:addendum_year])
 
         Identifiers::Addendum.new(
-          base_identifier: base_identifier,
+          base: base,
           addendum_code: addendum_code,
           addendum_date: addendum_date,
         )
@@ -270,13 +270,13 @@ module Pubid
         end
 
         base_class = determine_identifier_class(base_attrs)
-        base_identifier = base_class.new(**base_attrs)
+        base = base_class.new(**base_attrs)
 
         addendum_code = extract_value(parsed[:addendum_code])
         addendum_date = extract_addendum_date(parsed[:addendum_year])
 
         Identifiers::Addendum.new(
-          base_identifier: base_identifier,
+          base: base,
           addendum_code: addendum_code,
           addendum_date: addendum_date,
         )
@@ -308,13 +308,13 @@ module Pubid
         end
 
         base_class = determine_identifier_class(base_attrs)
-        base_identifier = base_class.new(**base_attrs)
+        base = base_class.new(**base_attrs)
 
         addendum_code = extract_value(parsed[:addendum_code])
         addendum_date = extract_addendum_date(parsed[:addendum_year])
 
         Identifiers::Addendum.new(
-          base_identifier: base_identifier,
+          base: base,
           addendum_code: addendum_code,
           addendum_date: addendum_date,
         )
@@ -326,13 +326,13 @@ module Pubid
       def build_standard_addendum(parsed)
         base_attrs = extract_base_attributes(parsed)
         base_class = determine_identifier_class(base_attrs)
-        base_identifier = base_class.new(**base_attrs)
+        base = base_class.new(**base_attrs)
 
         addendum_code = extract_value(parsed[:addendum_code])
         addendum_date = extract_addendum_date(parsed[:addendum_year])
 
         Identifiers::Addendum.new(
-          base_identifier: base_identifier,
+          base: base,
           addendum_code: addendum_code,
           addendum_date: addendum_date,
         )
@@ -372,7 +372,7 @@ module Pubid
         end
 
         base_class = determine_identifier_class(base_attrs)
-        base_identifier = base_class.new(**base_attrs)
+        base = base_class.new(**base_attrs)
 
         # Build the addendum_codes string from first code and additional codes
         first_code = extract_value(parsed[:addendum_code])
@@ -406,7 +406,7 @@ module Pubid
         end
 
         Identifiers::CombinedAddenda.new(
-          base_identifier: base_identifier,
+          base: base,
           addendum_codes: addendum_codes_str,
         )
       end
@@ -417,12 +417,12 @@ module Pubid
       def build_addenda_package(parsed)
         base_attrs = extract_base_attributes(parsed)
         base_class = determine_identifier_class(base_attrs)
-        base_identifier = base_class.new(**base_attrs)
+        base = base_class.new(**base_attrs)
 
         package_description = extract_value(parsed[:package_description])
 
         Identifiers::AddendaPackage.new(
-          base_identifier: base_identifier,
+          base: base,
           package_description: package_description,
         )
       end

data/lib/pubid/ashrae/identifier.rb

@@ -3,7 +3,6 @@
 # The ASHRAE flavor base class is Pubid::Ashrae::Identifier — a real
 # Pubid::Identifier subclass that every concrete ASHRAE identifier descends
 # from, so `is_a?` identity and the shared polymorphic `from_hash` work natively
-# (no facade needed). Its body, `.parse`, and the Identifiers::Base back-compat
-# alias live in identifiers/base.rb; this file just ensures it is loaded when a
-# consumer references Pubid::Ashrae::Identifier directly.
-require_relative "identifiers/base"
+# (no facade needed). Its body and `.parse` live in identifiers/base.rb; this
+# file just ensures it is loaded when a consumer references
+# Pubid::Ashrae::Identifier directly.

data/lib/pubid/ashrae/identifiers/addenda_package.rb

@@ -28,7 +28,7 @@ module Pubid
         end
 
         def copublisher
-          base_identifier&.copublisher
+          base&.copublisher
         end
       end
     end

data/lib/pubid/ashrae/identifiers/addendum.rb

@@ -28,7 +28,7 @@ module Pubid
         end
 
         def copublisher
-          base_identifier&.copublisher
+          base&.copublisher
         end
       end
     end