pubid 2.0.0.alpha.10 → 2.0.0.pre.alpha.1

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

@@ -8,26 +8,39 @@ module Pubid
       # - AMCA Publication 211-22 (Rev. 01-23)
       # - AMCA Publication 311-16
       # - AMCA Publication 1011-03 (R2010)
-      class Publication < Identifier
-        attribute :number, :string
+      class Publication < Base
+        attr_reader :revision
 
-        # Was a hand-written keyword initializer assigning ivars directly,
-        # which bypassed lutaml entirely. Three things broke as a result: no
-        # `_type` was emitted (so Identifier.from_hash could not route back to
-        # this class), the `publisher` default never materialised, and
-        # `revision` was a plain attr_reader that to_hash dropped. Removing it
-        # — and making `revision` a real attribute — is the AIEE/IRE/NESC
-        # migration applied here; the builder already calls `new(**attributes)`
-        # exactly as it does for Standard, which never had this problem.
-        attribute :revision, :string
-
-        key_value do
-          map "revision", to: :revision
+        def initialize(code:, year:, copublisher: nil, suffix: nil,
+reaffirmed: nil, revision: nil)
+          @code = Components::Code.new(value: code.to_s)
+          @year = Components::Date.new(year: year.to_s) if year
+          @copublisher = copublisher
+          @suffix = suffix
+          @reaffirmed = reaffirmed
+          @revision = revision
         end
 
         def self.type
           { key: :publication, title: "Publication", short: nil }
         end
+
+        def type
+          Publication.type
+        end
+
+        # @return [String] the rendered publication identifier
+        def to_s
+          parts = []
+          parts << @copublisher if @copublisher
+          parts << "Publication"
+          parts << @code.to_s
+          parts << "-#{@year}" if @year
+          parts << " (Rev. #{@revision})" if @revision
+          parts << " (#{@reaffirmed})" if @reaffirmed && !@revision
+
+          parts.join(" ").squeeze(" ")
+        end
       end
     end
   end

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

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

data/lib/pubid/amca/identifiers.rb

@@ -3,6 +3,7 @@
 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/parser.rb

@@ -4,7 +4,7 @@ module Pubid
   module Amca
     # Parser class for ACMA identifiers
     # Single Responsibility: Parsing ACMA identifier syntax
-    class Parser < ::Pubid::Parser::Grammar
+    class Parser < Parslet::Parser
       # Basic building blocks
       rule(:space) { str(" ") }
       rule(:space?) { space.maybe }

data/lib/pubid/amca/scheme.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Amca
+    # Scheme class for ACMA identifier configuration
+    class Scheme < Pubid::Scheme
+      def initialize
+        @identifiers = [
+          Identifiers::Standard,
+          Identifiers::Publication,
+          Identifiers::Interpretation,
+        ].freeze
+      end
+    end
+  end
+end

data/lib/pubid/amca/single_identifier.rb

@@ -4,7 +4,30 @@ module Pubid
   module Amca
     # Base class for single (non-supplement) ACMA identifiers
     # Includes: Standard, Publication
-    class SingleIdentifier < Identifier
+    class SingleIdentifier < Identifiers::Base
+      def to_s
+        parts = []
+        parts << copublisher if copublisher
+        # type is a hash, get the title
+        t = self.class.attributes.key?(:type) ? type : nil
+        if t.is_a?(Hash) && t[:title]
+          parts << t[:title].to_s
+        end
+        parts << code.to_s
+        parts << "-#{year}" if year
+
+        result = parts.compact.join(" ")
+
+        # Handle additional copublisher after year (e.g., /ASHRAE 51-16)
+        if copublisher&.include?("/") && year
+          type_title = t.is_a?(Hash) ? t[:title].to_s : ""
+          result = "#{copublisher} #{type_title} #{code}-#{year}"
+        end
+
+        result += " (#{reaffirmed})" if reaffirmed
+
+        result
+      end
     end
   end
 end

data/lib/pubid/amca/urn_generator.rb

@@ -4,9 +4,9 @@ module Pubid
   module Amca
     class UrnGenerator < Pubid::UrnGenerator::Base
       def urn_number
-        return nil unless identifier.number
+        return nil unless identifier.code
 
-        identifier.number.to_s
+        identifier.code.to_s
       end
 
       def urn_year
@@ -28,8 +28,7 @@ module Pubid
       end
 
       def urn_type
-        (identifier.class.respond_to?(:type) ? identifier.class.type : nil)
-          &.to_s&.downcase
+        identifier.type&.to_s&.downcase
       end
 
       def generate

data/lib/pubid/amca.rb

@@ -2,68 +2,21 @@
 
 module Pubid
   module Amca
-    extend Pubid::PrefixesSupport
-
-    # AMCA publisher token; the ANSI/AMCA joint form comes from
-    # Pubid::JOINT_PREFIXES.
-    PREFIXES = ["AMCA"].freeze
-
-    autoload :Identifier, "#{__dir__}/amca/identifiers/base"
+    autoload :Identifier, "#{__dir__}/amca/identifier"
     autoload :Identifiers, "#{__dir__}/amca/identifiers"
     autoload :Builder, "#{__dir__}/amca/builder"
     autoload :Parser, "#{__dir__}/amca/parser"
-    autoload :Renderer, "#{__dir__}/amca/renderer"
+    autoload :Scheme, "#{__dir__}/amca/scheme"
     autoload :SingleIdentifier, "#{__dir__}/amca/single_identifier"
     autoload :UrnGenerator, "#{__dir__}/amca/urn_generator"
-    autoload :UrnParser, "#{__dir__}/amca/urn_parser"
 
     # Parse an ACMA identifier string into an identifier object
     # @param identifier [String] The ACMA identifier string to parse
     # @return [Pubid::Amca::Identifier] The appropriate identifier object
-    # @raise [Pubid::Errors::ParseError] If parsing fails
+    # @raise [Parslet::ParseFailed] If parsing fails
     def self.parse(identifier)
       Identifier.parse(identifier)
     end
-
-    # Per-flavor format registry: inherits global formats, overrides :human
-    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
-    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.singleton_methods(false).include?(:type) }
-        .select { |c| c.type.is_a?(Hash) }
-    end
-
-    # Build typed stage index from identifier types
-    # @return [Array<Pubid::Components::TypedStage>] all typed stages
-    def self.all_typed_stages
-      @all_typed_stages ||= identifier_types.flat_map do |klass|
-        if klass.const_defined?(:TYPED_STAGES)
-          klass.const_get(:TYPED_STAGES)
-        else
-          []
-        end
-      end
-    end
-
-    # Lookup: type code -> identifier class
-    # @param code [String, Symbol] the type key to find
-    # @return [Class, nil] the matching identifier class
-    def self.locate_type(code)
-      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
-    end
-
-    # Lookup: abbreviation -> typed stage
-    # @param abbr [String, Symbol] the abbreviation to find
-    # @return [Pubid::Components::TypedStage, nil] the matching typed stage
-    def self.locate_stage(abbr)
-      abbr_str = abbr.to_s.upcase
-      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
-    end
   end
 
   # Register this flavor with the Pubid registry

data/lib/pubid/ansi/builder.rb

@@ -3,11 +3,9 @@
 module Pubid
   module Ansi
     class Builder < Pubid::Builder::Base
-      def build(data)
-        data = flatten_array(data) if data.is_a?(Array)
-        identifier = default_identifier_class.new
-        assign_attributes(identifier, data)
-        identifier
+      def initialize(scheme)
+        @scheme = scheme
+        super(Identifiers::Standard)
       end
 
       private
@@ -36,8 +34,8 @@ module Pubid
           main_number = main_and_parts[0]
           part_number = main_and_parts[1]
           {
-            number: main_number,
-            part: part_number,
+            number: Components::Code.new(value: main_number),
+            part: part_number ? Components::Code.new(value: part_number) : nil,
           }.compact
         when :date
           Components::Date.new(year: value.to_s)

data/lib/pubid/ansi/identifier.rb

@@ -4,27 +4,9 @@ module Pubid
   module Ansi
     # Base ANSI identifier class
     class Identifier < ::Pubid::Identifier
-      # `number`/`part`/`subpart` are declared here rather than inherited as a
-      # Components::Code: ANSI stores a bare string in every one of them.
-      # Declaring on this class is safe because its body lives in this one file
-      # and is never reopened, so every subclass body opens after it has run
-      # (lutaml deep-dups the parent attribute table at class-definition time).
-      attribute :number, :string
-      attribute :part, :string
-      attribute :subpart, :string
-
       def self.parse(string)
-        unless string.is_a?(String)
-          raise Pubid::Errors::InvalidInputError,
-                Pubid::INPUT_NOT_A_STRING_MESSAGE
-        end
-
-        if string.length > Pubid::MAX_INPUT_LENGTH
-          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
-        end
-
         parsed = Pubid::Ansi::Parser.new.parse(string)
-        Pubid::Ansi::Builder.new.build(parsed)
+        Pubid::Ansi::Builder.new(Pubid::Ansi::Scheme).build(parsed)
       end
     end
   end

data/lib/pubid/ansi/identifiers/american_national_standard.rb

@@ -4,8 +4,7 @@ module Pubid
       # American National Standard identifier
       class AmericanNationalStandard < SingleIdentifier
         def self.type
-          { key: :ans, web: :american_national_standard,
-            title: "American National Standard", short: "ANS" }
+          { key: :ans, title: "American National Standard", short: "ANS" }
         end
       end
     end

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

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
 
+require_relative "american_national_standard"
+
 module Pubid
   module Ansi
     module Identifiers
       # American National Standard identifier
       class Standard < SingleIdentifier
         def self.type
-          { key: :ans, web: :standard,
-            title: "American National Standard", short: "ANS" }
+          { key: :ans, title: "American National Standard", short: "ANS" }
         end
       end
     end

data/lib/pubid/ansi/parser.rb

@@ -4,7 +4,7 @@ module Pubid
   module Ansi
     # Parser for ANSI (American National Standards Institute) identifiers
     # Examples: ANSI X3.4-1986, ANSI C63.4-2014, ANSI/ISO 9899:1990
-    class Parser < ::Pubid::Parser::Grammar
+    class Parser < Parslet::Parser
       include ::Pubid::Parser::CommonParseRules
       include ::Pubid::Parser::CommonParseMethods
 

data/lib/pubid/ansi/scheme.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ansi
+    # Scheme configuration for ANSI identifiers
+    IDENTIFIER_TYPES = [
+      Identifiers::Standard,
+    ].freeze
+
+    Scheme = Pubid::Scheme.new(
+      identifiers: IDENTIFIER_TYPES,
+      supplement_identifiers: [],
+    )
+  end
+end

data/lib/pubid/ansi/single_identifier.rb

@@ -8,8 +8,37 @@ module Pubid
       #
       # @return [String] URN representation
 
-      def to_s(**opts)
-        render(format: :human, **opts)
+      def to_s(lang: :en)
+        [].tap do |parts|
+          parts << publisher_portion
+          parts << number_portion
+        end.compact.join(" ").tap do |s|
+          s << language_portion if languages&.any?
+        end
+      end
+
+      def publisher_portion
+        if copublishers&.any?
+          # ANSI/ISO 9899
+          ([publisher] + copublishers).map(&:body).join("/")
+        else
+          # ANSI X3.4
+          publisher.body
+        end
+      end
+
+      def number_portion
+        [
+          number.value,
+          (part ? "-#{part.value}" : ""),
+          (date ? ":#{date.year}" : ""),
+        ].join
+      end
+
+      def language_portion
+        return "" unless languages&.any?
+
+        "(#{languages.map(&:code).join(',')})"
       end
     end
   end

data/lib/pubid/ansi/urn_generator.rb

@@ -3,6 +3,41 @@
 module Pubid
   module Ansi
     class UrnGenerator < Pubid::UrnGenerator::Base
+      def urn_number
+        return nil unless identifier.number
+
+        identifier.number.value.to_s
+      end
+
+      def urn_part
+        return nil unless identifier.part
+
+        "-#{identifier.part.value}"
+      end
+
+      def urn_subpart
+        return nil unless identifier.subpart
+
+        "-#{identifier.subpart.value}"
+      end
+
+      def urn_year
+        if identifier.date&.year
+          return identifier.date.year.to_s
+        end
+
+        identifier.year&.to_s
+      end
+
+      def urn_edition
+        return nil unless identifier.edition
+
+        num = identifier.edition.number
+        return nil unless num
+
+        "ed.#{num}"
+      end
+
       def urn_typed_stage
         return nil unless identifier.typed_stage
 
@@ -22,12 +57,12 @@ module Pubid
         parts << urn_typed_stage if urn_typed_stage
 
         if identifier.publisher
-          parts[1] = identifier.publisher.render(context: URN_CONTEXT)
+          parts[1] = identifier.publisher.body.to_s.downcase
         end
 
         if identifier.copublishers&.any?
-          copubs = identifier.copublishers.map { |cp| cp.render(context: URN_CONTEXT) }
-          parts[1] = "#{parts[1]}-#{copubs.join('-')}"
+          copubs = identifier.copublishers.map(&:body)
+          parts[1] = "#{parts[1]}-#{copubs.join('-').downcase}"
         end
 
         if identifier.languages&.any?

data/lib/pubid/ansi.rb

@@ -2,64 +2,23 @@
 
 module Pubid
   module Ansi
-    extend Pubid::PrefixesSupport
-
-    # ANSI publisher token; ANSI/ASHRAE and ANSI/AMCA joint forms come from
-    # Pubid::JOINT_PREFIXES. Parser::ORGANIZATIONS are co-publishers, not
-    # leading ANSI tokens, so they are excluded.
-    PREFIXES = ["ANSI"].freeze
-
     autoload :Builder, "#{__dir__}/ansi/builder"
     autoload :Identifier, "#{__dir__}/ansi/identifier"
-    autoload :Identifiers, "#{__dir__}/ansi/identifiers"
+    autoload :Identifiers, "#{__dir__}/ansi/identifiers/standard"
     autoload :Parser, "#{__dir__}/ansi/parser"
-    autoload :Renderer, "#{__dir__}/ansi/renderer"
+    autoload :Scheme, "#{__dir__}/ansi/scheme"
     autoload :SingleIdentifier, "#{__dir__}/ansi/single_identifier"
     autoload :UrnGenerator, "#{__dir__}/ansi/urn_generator"
-    autoload :UrnParser, "#{__dir__}/ansi/urn_parser"
 
     # Parse an ANSI identifier string
     # @param identifier [String] the identifier string to parse
     # @return [Identifier] the parsed identifier
-    # Delegate to the class method rather than repeating the parser/builder
-    # sequence, so the input guards live in one place and the two entry points
-    # cannot drift apart.
     def self.parse(identifier)
-      Identifier.parse(identifier)
-    end
-
-    # Per-flavor format registry: inherits global formats, overrides :human
-    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
-    Identifier.format_registry.register(:human, renderer: Ansi::Renderer)
-
-    # Auto-discover all identifier types from the Identifiers namespace
-    # @return [Array<Class>] identifier classes that define a self.type Hash
-    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.singleton_methods(false).include?(:type) }
-        .select { |c| c.type.is_a?(Hash) }
-    end
-
-    # ANSI does not define typed stages; typed_stage lookup is not used by
-    # the builder. Provided here for API consistency with other flavors.
-    # @return [Array] always empty for ANSI
-    def self.all_typed_stages
-      []
-    end
-
-    # Lookup: type code -> identifier class
-    # @param code [String, Symbol] the type key to find
-    # @return [Class, nil] the matching identifier class
-    def self.locate_type(code)
-      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
-    end
+      parser = Parser.new
+      builder = Builder.new(Scheme)
 
-    # Lookup: abbreviation -> typed stage
-    # @param _abbr [String, Symbol] unused; ANSI has no typed stages
-    # @return [nil] always nil for ANSI
-    def self.locate_stage(_abbr)
-      nil
+      parsed = parser.parse(identifier)
+      builder.build(parsed)
     end
   end
 end

data/lib/pubid/api/builder.rb

@@ -1,57 +1,84 @@
 # frozen_string_literal: true
 
+require_relative "components/code"
+require_relative "identifiers/bulletin"
+require_relative "identifiers/mpms"
+require_relative "identifiers/recommended_practice"
+require_relative "identifiers/specification"
+require_relative "identifiers/standard"
+require_relative "identifiers/technical_report"
+require_relative "identifiers/continuous_operations_standard"
+require_relative "identifiers/publication"
+require_relative "identifiers/typeless_standard"
+
 module Pubid
   module Api
-    class Builder < Pubid::Builder::Base
-      TYPE_CLASS_MAP = {
-        "BULL" => Identifiers::Bulletin,
-        "MPMS" => Identifiers::Mpms,
-        "RP" => Identifiers::RecommendedPractice,
-        "SPEC" => Identifiers::Specification,
-        "STD" => Identifiers::Standard,
-        "TR" => Identifiers::TechnicalReport,
-        "COS" => Identifiers::ContinuousOperationsStandard,
-        "PUBL" => Identifiers::Publication,
-      }.freeze
-
-      private
-
-      def default_identifier_class
-        Identifiers::TypelessStandard
-      end
+    class Builder
+      def build(parsed_hash)
+        # Determine identifier class based on type
+        identifier_class = case parsed_hash[:type]&.to_s
+                           when "BULL"
+                             Identifiers::Bulletin
+                           when "MPMS"
+                             Identifiers::Mpms
+                           when "RP"
+                             Identifiers::RecommendedPractice
+                           when "SPEC"
+                             Identifiers::Specification
+                           when "STD"
+                             Identifiers::Standard
+                           when "TR"
+                             Identifiers::TechnicalReport
+                           when "COS"
+                             Identifiers::ContinuousOperationsStandard
+                           when "PUBL"
+                             Identifiers::Publication
+                           else
+                             # No type = typeless standard
+                             Identifiers::TypelessStandard
+                           end
 
-      def select_class(data)
-        TYPE_CLASS_MAP[data[:type]&.to_s] || default_identifier_class
-      end
+        identifier = identifier_class.new
 
-      def cast(key, value)
-        case key
-        # `:type` is consumed only by select_class for dispatch; it is not an
-        # identifier attribute (the concrete class is pinned by `_type`). Drop it
-        # so the raw Parslet::Slice never lands in the inherited :type attribute.
-        when :type then nil
-        when :reaffirmation
-          value.is_a?(Hash) ? (value[:year] || value).to_s : value.to_s
-        # Every remaining key is a bare scalar. `:chapter` is a PARSE-TREE key
-        # and keeps its name in the grammar; the ATTRIBUTE it feeds is `number`
-        # (see handle_key below), which this branch retyped from
-        # Components::Code to :string — so it now casts like the rest.
-        when :number, :chapter, :part, :section, :subsection, :year
-          value.to_s
-        else
-          super
+        # Number (for non-MPMS)
+        if parsed_hash[:number]
+          identifier.code = Components::Code.new(value: parsed_hash[:number].to_s)
+        end
+
+        # Part
+        if parsed_hash[:part]
+          identifier.part = parsed_hash[:part].to_s
+        end
+
+        # MPMS-specific attributes
+        if parsed_hash[:chapter]
+          identifier.chapter = parsed_hash[:chapter].to_s
         end
-      end
 
-      # Route the MPMS chapter into the `number` attribute. The shared
-      # assign_attributes loop uses the parse-tree key as the setter name and
-      # silently skips a key that is not an attribute, so without this the
-      # chapter would simply vanish once `attribute :chapter` was removed.
-      def handle_key(identifier, key, value)
-        return super unless key.to_sym == :chapter
+        if parsed_hash[:section]
+          identifier.section = parsed_hash[:section].to_s
+        end
+
+        if parsed_hash[:subsection]
+          identifier.subsection = parsed_hash[:subsection].to_s
+        end
+
+        # Year
+        if parsed_hash[:year]
+          identifier.year = parsed_hash[:year].to_s
+        end
+
+        # Reaffirmation (nested hash with year inside)
+        if parsed_hash[:reaffirmation]
+          reaffirm_data = parsed_hash[:reaffirmation]
+          identifier.reaffirmation = if reaffirm_data.is_a?(Hash) && reaffirm_data[:year]
+                                       reaffirm_data[:year].to_s
+                                     else
+                                       reaffirm_data.to_s
+                                     end
+        end
 
-        identifier.number = value
-        true
+        identifier
       end
     end
   end