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

data/lib/pubid/bsi/identifiers/amendment.rb

@@ -6,7 +6,7 @@ module Pubid
       # Amendment Identifier
       # Contains a base identifier plus amendment parameters
       class Amendment < SingleIdentifier
-        attribute :base_identifier, ::Pubid::Identifier, polymorphic: true
+        attribute :base, ::Pubid::Identifier, polymorphic: true
         attribute :amendment_number, :string
         attribute :amendment_year, :integer
         attribute :separator, :string, default: -> { "+" }
@@ -16,17 +16,17 @@ module Pubid
         attribute :amd_suffix_form, :boolean, default: -> { false }
 
         def publisher
-          base_identifier&.publisher
+          base&.publisher
         end
 
         # Base document = the standard this amendment applies to, fully peeled.
         def base_document
-          base_identifier&.base_document || self
+          base&.base_document || self
         end
 
         # Dropping the supplement layer yields the base standard.
         def drop_supplements
-          base_identifier || self
+          base || self
         end
 
         # Uniform supplement interface (shared with Corrigendum) so callers need

data/lib/pubid/bsi/identifiers/consolidated_identifier.rb

@@ -68,6 +68,12 @@ module Pubid
           identifiers&.first&.base_document || self
         end
 
+        # The origin document. Members live in `identifiers` (not `base`), so
+        # walk the first member to its root.
+        def root
+          identifiers&.first&.root || self
+        end
+
         # Dropping the supplement layer yields the base standard alone.
         def drop_supplements
           identifiers&.first || self

data/lib/pubid/bsi/identifiers/corrigendum.rb

@@ -6,23 +6,23 @@ module Pubid
       # Corrigendum Identifier
       # Contains a base identifier plus corrigendum parameters
       class Corrigendum < SingleIdentifier
-        attribute :base_identifier, ::Pubid::Identifier, polymorphic: true
+        attribute :base, ::Pubid::Identifier, polymorphic: true
         attribute :corrigendum_number, :string
         attribute :corrigendum_year, :integer
         attribute :separator, :string, default: -> { "+" }
 
         def publisher
-          base_identifier&.publisher
+          base&.publisher
         end
 
         # Base document = the standard this corrigendum applies to, fully peeled.
         def base_document
-          base_identifier&.base_document || self
+          base&.base_document || self
         end
 
         # Dropping the supplement layer yields the base standard.
         def drop_supplements
-          base_identifier || self
+          base || self
         end
 
         # Uniform supplement interface (shared with Amendment) so callers need

data/lib/pubid/bsi/identifiers/expert_commentary.rb

@@ -10,25 +10,25 @@ module Pubid
       # 2. "ExComm" (abbreviated form)
       # 3. "ExComm (Fire)" (with optional topic suffix)
       class ExpertCommentary < SingleIdentifier
-        attribute :base_identifier, ::Pubid::Identifier, polymorphic: true
+        attribute :base, ::Pubid::Identifier, polymorphic: true
         attribute :format, :string # "full", "abbr", "abbr_with_topic"
         attribute :topic, :string # e.g., "Fire"
 
         def publisher
-          base_identifier&.publisher
+          base&.publisher
         end
 
         def number
-          base_identifier&.number
+          base&.number
         end
 
         def year
-          base_identifier&.year
+          base&.year
         end
 
         # Base document = the commented standard, fully peeled.
         def base_document
-          base_identifier&.base_document || self
+          base&.base_document || self
         end
       end
     end

data/lib/pubid/bsi/identifiers/supplement_document.rb

@@ -9,7 +9,7 @@ module Pubid
       # Forward: "BS 1000:Supplement No. 1:1972", "BS 1722-1 Supplement No. 1:1974"
       # Reverse: "Supplement No. 1 (1970) to BS 1831:1969"
       class SupplementDocument < SingleIdentifier
-        attribute :base_identifier, ::Pubid::Identifier, polymorphic: true
+        attribute :base, ::Pubid::Identifier, polymorphic: true
         attribute :supplement_number, :string
         attribute :supplement_year, :integer
         attribute :supplement_type, :string, default: -> {
@@ -21,7 +21,7 @@ module Pubid
         } # Separator before Supplement (":" or " ")
 
         def publisher
-          base_identifier&.publisher
+          base&.publisher
         end
       end
     end

data/lib/pubid/bsi/identifiers/value_added_publication.rb

@@ -12,24 +12,24 @@ module Pubid
       #   PAS 96:2017 - TC
       #   PP 7722:2006 BOOK
       class ValueAddedPublication < SingleIdentifier
-        attribute :base_identifier, ::Pubid::Identifier, polymorphic: true
+        attribute :base, ::Pubid::Identifier, polymorphic: true
         attribute :format, :string, values: ["PDF", "TC", "BOOK"]
 
-        # Delegate common attributes to base_identifier
+        # Delegate common attributes to base
         def publisher
-          base_identifier&.publisher
+          base&.publisher
         end
 
         def number
-          base_identifier&.number
+          base&.number
         end
 
         def year
-          base_identifier&.year
+          base&.year
         end
 
         def date
-          base_identifier&.date
+          base&.date
         end
       end
     end

data/lib/pubid/bsi/renderer.rb

@@ -160,13 +160,13 @@ module Pubid
       # ------------------------------------------------------------------
 
       def render_addendum_document(id, opts)
-        result = id.base_identifier.to_s(**opts)
+        result = id.base.to_s(**opts)
 
-        base_has_year = id.base_identifier.to_s =~ /:(\d{4})$/
+        base_has_year = id.base.to_s =~ /:(\d{4})$/
 
         sep = if id.separator == ":"
                 ":"
-              elsif base_has_year && id.base_identifier.to_s !~ /:\d{4}:/
+              elsif base_has_year && id.base.to_s !~ /:\d{4}:/
                 " "
               else
                 id.separator
@@ -289,7 +289,7 @@ module Pubid
       end
 
       def render_amendment(id)
-        base = id.base_identifier ? id.base_identifier.to_s : ""
+        base = id.base ? id.base.to_s : ""
 
         if id.amd_suffix_form
           # Trailing " AMD5" / " AMD AA" suffix form
@@ -471,7 +471,7 @@ module Pubid
       end
 
       def render_corrigendum(id)
-        result = id.base_identifier ? id.base_identifier.to_s : ""
+        result = id.base ? id.base.to_s : ""
         result += "#{id.separator}C"
         result += id.corrigendum_number.to_s if id.corrigendum_number
         result += ":#{id.corrigendum_year}" if id.corrigendum_year
@@ -589,7 +589,7 @@ module Pubid
       end
 
       def render_expert_commentary(id)
-        base_str = id.base_identifier.to_s
+        base_str = id.base.to_s
         base_str = base_str.sub(/ (Expert Commentary|ExComm(\s*\(.*\))?)$/, "")
 
         case id.format
@@ -895,7 +895,7 @@ module Pubid
       end
 
       def render_supplement_document(id)
-        base_str = id.base_identifier.to_s
+        base_str = id.base.to_s
 
         if id.reverse_format
           supplement_str = if id.supplement_type == "No."
@@ -998,7 +998,7 @@ module Pubid
       end
 
       def render_value_added_publication(id, opts)
-        base_str = id.base_identifier.to_s(**opts)
+        base_str = id.base.to_s(**opts)
 
         case id.format
         when "TC"

data/lib/pubid/bsi/single_identifier.rb

@@ -75,6 +75,54 @@ module Pubid
           0
         end
       end
+
+      # Annex F series groupings per "Rules for the structure and drafting
+      # of UK standards" (BSI, 2017), F.1.3-F.1.5. Each maps a `prefix`
+      # token to the broader series category.
+      SERIES_CATEGORIES = {
+        # F.1.3 Automobile
+        "AU" => :automotive,
+        # F.1.4 Aerospace
+        "A" => :aerospace, "B" => :aerospace, "C" => :aerospace,
+        "F" => :aerospace, "G" => :aerospace, "HC" => :aerospace,
+        "L" => :aerospace, "S" => :aerospace, "SP" => :aerospace,
+        "X" => :aerospace, "M" => :aerospace, "TA" => :aerospace,
+        "2A" => :aerospace, "2B" => :aerospace, "2C" => :aerospace,
+        "2F" => :aerospace, "2G" => :aerospace, "2HC" => :aerospace,
+        "2HR" => :aerospace, "2L" => :aerospace, "2M" => :aerospace,
+        "2S" => :aerospace, "2SP" => :aerospace, "2TA" => :aerospace,
+        "2X" => :aerospace, "3A" => :aerospace, "3B" => :aerospace,
+        "3F" => :aerospace, "3G" => :aerospace, "3HR" => :aerospace,
+        "3J" => :aerospace, "3L" => :aerospace, "3S" => :aerospace,
+        "3TA" => :aerospace, "4F" => :aerospace, "4L" => :aerospace,
+        "4S" => :aerospace, "5S" => :aerospace, "7S" => :aerospace,
+        # F.1.5 Marine
+        "MA" => :marine, "PL" => :marine, "QC" => :marine,
+      }.freeze
+
+      # Series accessor — semantically named alias for `prefix` per
+      # issue #252. Returns the prefix token (e.g., "AU", "MA", "2A").
+      def series
+        prefix
+      end
+
+      # Series category — one of :automotive, :aerospace, :marine, or nil
+      # when the identifier doesn't carry a recognized Annex F prefix.
+      def series_category
+        SERIES_CATEGORIES[prefix.to_s] if prefix
+      end
+
+      def automotive?
+        series_category == :automotive
+      end
+
+      def aerospace?
+        series_category == :aerospace
+      end
+
+      def marine?
+        series_category == :marine
+      end
     end
 
     # Backward-compatible alias: BSI's base class is Pubid::Bsi::Identifier.

data/lib/pubid/builder/base.rb

@@ -125,9 +125,11 @@ module Pubid
 
       def parse_date(value)
         value = value.to_s
-        if value.match?(/^\d{4}(-\d{2})?$/)
-          year, month = value.split("-")
-          Pubid::Components::Date.new(year: year, month: month || nil)
+        if value.match?(/^\d{4}(-\d{2}){0,2}$/)
+          year, month, day = value.split("-")
+          Pubid::Components::Date.new(year: year,
+                                       month: month || nil,
+                                       day: day || nil)
         elsif value.is_a?(Integer) || (value.is_a?(String) && value.match?(/^\d{4}$/))
           Pubid::Components::Date.new(year: value)
         else

data/lib/pubid/bundled_identifier.rb

@@ -52,10 +52,10 @@ stage_format_long: nil, with_date: nil)
 
       supplements.each do |supplement|
         # ISO DirectivesSupplement always uses " + " (space before)
-        # CEN-style supplements (AC, A) without base_identifier use "+" (no space before)
-        # Other ISO supplements with base_identifier use " + " (space before)
+        # CEN-style supplements (AC, A) without base use "+" (no space before)
+        # Other ISO supplements with base use " + " (space before)
         if supplement.class.name&.include?("DirectivesSupplement") ||
-            (supplement.class.attributes.key?(:base_identifier) && !supplement.base_identifier.nil?)
+            (supplement.class.attributes.key?(:base) && !supplement.base.nil?)
           result += " + #{supplement.to_s(lang: lang, lang_single: lang_single,
                                           with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date)}"
         else

data/lib/pubid/calconnect/builder.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Calconnect
+    # Builds a CalConnect identifier object from a Parslet parse tree. There is
+    # a single concrete type (Identifiers::Standard), so no type dispatch.
+    class Builder
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
+
+      def build(data)
+        Identifiers::Standard.new(
+          series: data[:series]&.to_s,
+          number: data[:number].to_s,
+          date: build_date(data),
+        )
+      end
+
+      private
+
+      # Publication date as a Pubid::Components::Date, or nil for a partial
+      # reference that omits the trailing ":YYYY" (relaton matches such refs by
+      # excluding the date). Digits are kept as strings verbatim (already
+      # zero-padded in the source, e.g. "07"/"23"); month/day are nil for the
+      # common year-only form.
+      def build_date(data)
+        return nil if data[:year].nil?
+
+        ::Pubid::Components::Date.new(
+          year: data[:year].to_s,
+          month: data[:month]&.to_s,
+          day: data[:day]&.to_s,
+        )
+      end
+    end
+  end
+end

data/lib/pubid/calconnect/identifier.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Calconnect
+    # Base class for every CalConnect identifier AND the flavor's parse entry
+    # point — mirrors Pubid::Jis::Identifier. Concrete identifiers under
+    # Pubid::Calconnect::Identifiers descend from this class, so a parsed
+    # CalConnect id is an instance of Pubid::Calconnect::Identifier and
+    # relaton-index can pass this class as `pubid_class` for from_hash/to_hash.
+    class Identifier < ::Pubid::Identifier
+      # `number` is a CalConnect-specific plain string (preserves leading zeros
+      # like "0514" and the sub-part separator, "0812-1"/"0707.1"), so it
+      # overrides the inherited Components::Code type. The publication date uses
+      # the shared Pubid::Components::Date (inherited attribute): `year` is
+      # always present, `month`/`day` only for the rare full-date form
+      # ("CC/WD 51017:2024-07-23").
+      attribute :series, :string # Optional series letter/token (A, WD, DIR, …)
+      attribute :number, :string
+      attribute :date, ::Pubid::Components::Date
+
+      # Polymorphic type map for lutaml::Model key_value (de)serialization,
+      # mapping the concrete class's polymorphic_name to its class name so a
+      # stored hash rebuilds the correct identifier type via from_hash.
+      CALCONNECT_TYPE_MAP = {
+        "pubid:calconnect:standard" => "Pubid::Calconnect::Identifiers::Standard",
+      }.freeze
+
+      # The date serializes FLAT as year/month/day string keys (nils omitted),
+      # mirroring lib/pubid/iso/identifier.rb — not as a nested "date" object —
+      # so the index row stays a shallow hash and round-trips exactly.
+      key_value do
+        map "_type", to: :_type, polymorphic_map: CALCONNECT_TYPE_MAP
+        map "series", to: :series
+        map "number", to: :number
+        map "year", with: { to: :year_to_kv, from: :year_from_kv }
+        map "month", with: { to: :month_to_kv, from: :month_from_kv }
+        map "day", with: { to: :day_to_kv, from: :day_from_kv }
+      end
+
+      # Publisher is always "CC". A plain constant (not a `publisher` method) so
+      # it doesn't shadow the inherited lutaml `publisher` attribute, which
+      # would otherwise fail serialization type validation.
+      PUBLISHER = "CC"
+
+      attr_reader :with_publisher
+
+      # Render the publication date, e.g. "2018" or "2024-07-23". Shared by the
+      # renderer and the URN generator so they always agree.
+      # Pubid::Components::Date#to_s yields the year alone, or the zero-padded
+      # "YYYY-MM-DD" when month/day are present.
+      def date_string
+        date&.to_s
+      end
+
+      # Basic string representation. Delegates to the human renderer. The
+      # printed CalConnect id carries the "CC" publisher token by default; pass
+      # with_publisher: false to drop it (and the series slash).
+      def to_s(**opts)
+        render(format: :human, **opts)
+      end
+
+      # Capture the with_publisher flag on EVERY render call (default true), so
+      # it can never leak across calls. The base `render` only forwards
+      # `:with_edition` to the renderer, so the flag is threaded via this
+      # per-call instance write (the renderer reads `id.with_publisher`).
+      def render(format: :human, with_publisher: true, **opts)
+        @with_publisher = with_publisher
+        super(format: format, **opts)
+      end
+
+      # --- date serialized flat as year/month/day (mirrors ISO) ---
+      def year_to_kv(model, doc)
+        emit_date_part(doc, "year", model.date&.year)
+      end
+
+      def month_to_kv(model, doc)
+        emit_date_part(doc, "month", model.date&.month)
+      end
+
+      def day_to_kv(model, doc)
+        emit_date_part(doc, "day", model.date&.day)
+      end
+
+      def year_from_kv(model, value) = date_for(model).year = value.to_s
+      def month_from_kv(model, value) = date_for(model).month = value.to_s
+      def day_from_kv(model, value) = date_for(model).day = value.to_s
+
+      def emit_date_part(doc, key, val)
+        return if val.nil? || val.to_s.empty?
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new(key, val.to_s))
+      end
+
+      def date_for(model)
+        model.date ||= ::Pubid::Components::Date.new
+      end
+
+      # from_hash is the shared polymorphic dispatch on Pubid::Identifier.
+      # CALCONNECT_TYPE_MAP remains as the key_value polymorphic_map.
+
+      # Parse a CalConnect identifier string into an identifier object.
+      # @param identifier [String] The CalConnect identifier string to parse
+      # @return [Identifier] The appropriate identifier object
+      # @raise [ArgumentError] If the input exceeds the maximum length
+      # @raise [RuntimeError] If parsing fails
+      def self.parse(identifier)
+        if identifier.length > Pubid::MAX_INPUT_LENGTH
+          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        Builder.build(Parser.parse(identifier))
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse CalConnect '#{identifier}': #{e.message}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Calconnect
+    module Identifiers
+      # The sole CalConnect document type. Its polymorphic_name resolves
+      # automatically to "pubid:calconnect:standard".
+      class Standard < Identifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubcc,
+            stage_code: :published,
+            type_code: :cc,
+            abbr: ["CC"],
+            name: "CalConnect Standard",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :cc,
+            web: :standard,
+            title: "CalConnect Standard",
+            short: "CC" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/calconnect/identifiers.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Calconnect
+    module Identifiers
+      autoload :Standard, "#{__dir__}/identifiers/standard"
+    end
+  end
+end

data/lib/pubid/calconnect/parser.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Calconnect
+    # Parslet grammar for CalConnect identifiers.
+    #
+    # Shape: CC[/<series>] <number>:<date>
+    #   CC 18011:2018
+    #   CC/DIR 10006:2019
+    #   CC/Adv 0707.1:2007        (dot sub-part)
+    #   CC/A 0812-1:2008          (dash sub-part)
+    #   CC/WD 51017:2024-07-23    (full ISO date)
+    class Parser < Parslet::Parser
+      rule(:digit) { match["0-9"] }
+      rule(:digits) { digit.repeat(1) }
+
+      # Publisher token
+      rule(:publisher) { str("CC") }
+
+      # Series token — an open [A-Za-z]+ set (A, WD, R, S, CD, DIR, Adv, FDS, …)
+      rule(:series) { match["A-Za-z"].repeat(1).as(:series) }
+
+      # Number — digits, preserving leading zeros, with at most one dot- or
+      # dash-delimited sub-part ("0707.1", "0812-1"). Kept as a string.
+      rule(:number) do
+        (digits >> ((str(".") | str("-")) >> digits).maybe).as(:number)
+      end
+
+      # Date after the colon: a year, optionally a full "YYYY-MM-DD". The colon
+      # hard-delimits number from date, and month+day only appear together, so
+      # the split is unambiguous.
+      rule(:date) do
+        digits.as(:year) >>
+          (str("-") >> digits.as(:month) >> str("-") >> digits.as(:day)).maybe
+      end
+
+      rule(:identifier) do
+        publisher >>
+          (str("/") >> series).maybe >>
+          str(" ") >>
+          number >>
+          (str(":") >> date).maybe
+      end
+
+      rule(:root) { identifier }
+
+      def self.parse(input)
+        new.parse(input)
+      end
+    end
+  end
+end

data/lib/pubid/calconnect/renderer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Calconnect
+    # Human-readable renderer for CalConnect identifiers.
+    #
+    # Produces the canonical printed form, e.g.:
+    #   "CC 18011:2018"
+    #   "CC/DIR 10006:2019"
+    #   "CC/WD 51017:2024-07-23"
+    #   "DIR 10006:2019"          (only when with_publisher: false)
+    #
+    # Registered as the `:human` format in the CalConnect format registry and
+    # invoked via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      PUBLISHER = "CC"
+
+      def render(**_opts)
+        id = @id
+        prefix = if with_publisher?(id)
+                   id.series ? "#{PUBLISHER}/#{id.series} " : "#{PUBLISHER} "
+                 else
+                   id.series ? "#{id.series} " : ""
+                 end
+        date = id.date_string
+        "#{prefix}#{id.number}#{":#{date}" if date}"
+      end
+
+      private
+
+      def with_publisher?(id)
+        id.respond_to?(:with_publisher) && id.with_publisher != false
+      end
+    end
+  end
+end

data/lib/pubid/calconnect/urn_generator.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Calconnect
+    # Emits CalConnect URNs of the form
+    #   urn:calconnect[:<series>]:<number>:<date>
+    # e.g. "urn:calconnect:DIR:10006:2019", "urn:calconnect:18011:2018",
+    # "urn:calconnect:WD:51017:2024-07-23".
+    #
+    # The series keeps its printed case (JIS keeps its code case likewise) so a
+    # URN reconstructs the human form losslessly — mirror in urn_parser.rb.
+    #
+    # NOTE: a *partial* (date-less) reference has NO round-trippable URN form.
+    # Both `series` and `date` are optional, and UrnParser reads the trailing
+    # segments positionally, so a date-less URN like "urn:calconnect:11001"
+    # (or "urn:calconnect:DIR:10006") is ambiguous with a series-less dated URN
+    # and does not parse back. Partial refs are matched by pubid `#exclude`,
+    # not by URN, so this generator simply omits the missing segment rather
+    # than emitting an empty ":" — callers must not rely on URN round-trip for
+    # a partial id.
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        # series and date_string are nil for a series-less or partial
+        # (date-less) id; compact drops them so no empty ":" segment appears.
+        parts = [
+          "urn", "calconnect",
+          identifier.series, identifier.number.to_s, identifier.date_string
+        ]
+        parts.compact.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/calconnect/urn_parser.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Calconnect
+    # Parses CalConnect URNs back into identifiers.
+    #
+    # UrnGenerator emits: urn:calconnect[:<series>]:<number>:<date>
+    #   urn:calconnect:18011:2018            → CC 18011:2018
+    #   urn:calconnect:DIR:10006:2019        → CC/DIR 10006:2019
+    #   urn:calconnect:WD:51017:2024-07-23   → CC/WD 51017:2024-07-23
+    #
+    # The date segment (year or full "YYYY-MM-DD") never contains a colon, so
+    # it is a single trailing part; the number precedes it, and an optional
+    # series precedes the number.
+    #
+    # This positional pop assumes a *dated* URN (the form UrnGenerator emits for
+    # a full id). A partial (date-less) reference has no round-trippable URN —
+    # see UrnGenerator — so this parser is only guaranteed for URNs produced
+    # from a full id; a date-less URN misaligns the pops and will not parse.
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        parts = split_parts(strip_namespace(urn))
+        date = parts.pop
+        number = parts.pop
+        series = parts.pop
+
+        text = +"CC"
+        text << "/#{series}" if series
+        text << " #{number}:#{date}"
+        flavor_parse(text)
+      end
+    end
+  end
+end