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

data/lib/pubid/calconnect.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Pubid
+  # CalConnect (The Calendaring and Scheduling Consortium) flavor.
+  #
+  # Parses/renders the "CC …" numbering, e.g. "CC 18011:2018",
+  # "CC/DIR 10006:2019", "CC/Adv 0707.1:2007". Modeled on Pubid::Jis: a single
+  # flat identifier type (Identifiers::Standard) with no supplement layer.
+  module Calconnect
+    extend Pubid::PrefixesSupport
+
+    # Sole CalConnect publisher/leading token. Series letters (A, WD, R, S, CD,
+    # DIR, Adv, FDS) follow "CC/" and never lead a reference, so they are
+    # excluded per the PrefixesSupport inclusion policy.
+    PREFIXES = ["CC"].freeze
+
+    autoload :Builder, "#{__dir__}/calconnect/builder"
+    autoload :Identifier, "#{__dir__}/calconnect/identifier"
+    autoload :Identifiers, "#{__dir__}/calconnect/identifiers"
+    autoload :Parser, "#{__dir__}/calconnect/parser"
+    autoload :Renderer, "#{__dir__}/calconnect/renderer"
+    autoload :UrnGenerator, "#{__dir__}/calconnect/urn_generator"
+    autoload :UrnParser, "#{__dir__}/calconnect/urn_parser"
+
+    # Parse a CalConnect identifier string
+    def self.parse(identifier)
+      if identifier.length > Pubid::MAX_INPUT_LENGTH
+        raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+      end
+
+      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: Calconnect::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
+end
+
+# Register CalConnect flavor with the registry
+Pubid::Registry.register(:calconnect, Pubid::Calconnect)

data/lib/pubid/ccsds/builder.rb

@@ -47,7 +47,7 @@ module Pubid
         # If multiple corrigenda exist, we build the last one wrapping the base
         corr_numbers.reduce(base) do |current_base, cor_num|
           Identifiers::Corrigendum.new(
-            base_identifier: current_base,
+            base: current_base,
             number: cor_num,
           )
         end

data/lib/pubid/ccsds/identifier.rb

@@ -10,7 +10,7 @@ module Pubid
     #
     # Keeping the root abstract (it is never itself a serialized type, so it is
     # absent from CCSDS_TYPE_MAP) is what breaks the polymorphic recursion a
-    # supplement's `base_identifier` would otherwise hit if it pointed at a
+    # supplement's `base` would otherwise hit if it pointed at a
     # concrete type that is also its own superclass.
     class Identifier < ::Pubid::Identifier
       # CCSDS stores every code component as a plain string (the Builder passes

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

@@ -25,14 +25,14 @@ module Pubid
         # attribute (mirroring ISO), so it serializes via Base's key_value as
         # { _type, number: '1', base: {...} } with no corrigendum-specific map.
         def to_s
-          base_str = base_identifier.to_s
+          base_str = base.to_s
           "#{base_str} Cor. #{number}"
         end
 
         def ==(other)
           return false unless other.is_a?(Corrigendum)
 
-          base_identifier == other.base_identifier && number == other.number
+          base == other.base && number == other.number
         end
       end
     end

data/lib/pubid/ccsds/supplement_identifier.rb

@@ -4,28 +4,28 @@ module Pubid
   module Ccsds
     # Base class for CCSDS supplements (corrigenda, amendments, etc.).
     # Descends from the abstract root (not the concrete Base) and points
-    # `base_identifier` at the root, so the polymorphic attribute never
+    # `base` at the root, so the polymorphic attribute never
     # resolves to its own superclass — which is what prevents lutaml from
     # recursing forever while building a supplement from a hash.
     class SupplementIdentifier < Identifier
-      attribute :base_identifier, Identifier, polymorphic: true
+      attribute :base, Identifier, polymorphic: true
 
       # Serialize the supplemented identifier under "base" (matches ISO/JIS).
-      # The key stays `base_identifier` for the attribute/getter, which
+      # The key stays `base` for the attribute/getter, which
       # relaton-index's get_id_number relies on. A supplement's own code
       # attributes (number/part/edition/...) stay nil — they live inside
       # `base` — so the merged root key_value omits them here, keeping the
       # serialization lean and non-duplicated.
       key_value do
-        map "base", to: :base_identifier
+        map "base", to: :base
       end
 
       def <=>(other)
         return nil unless other.is_a?(SupplementIdentifier)
 
         # Compare base identifiers first
-        if base_identifier && other.base_identifier
-          base_cmp = base_identifier <=> other.base_identifier
+        if base && other.base
+          base_cmp = base <=> other.base
           return base_cmp unless base_cmp.zero?
         end
 

data/lib/pubid/ccsds/urn_generator.rb

@@ -91,14 +91,14 @@ module Pubid
 
         while current.is_a?(SupplementIdentifier)
           supplement_chain.unshift(current)
-          current = current.base_identifier
+          current = current.base
         end
 
         base_gen = self.class.new(current)
         base_urn = base_gen.generate_base_urn
 
-        base_identifier_part = base_urn.sub(/^urn:ccsds:/, "")
-        parts << base_identifier_part
+        base_part = base_urn.sub(/^urn:ccsds:/, "")
+        parts << base_part
 
         supplement_chain.each do |supp|
           if supp.number && !supp.number.to_s.empty?

data/lib/pubid/cen_cenelec/builder.rb

@@ -33,6 +33,22 @@ module Pubid
           return build_standalone_supplement(data)
         end
 
+        # Implicit adoption: when an EN has no explicit "IEC" prefix but
+        # the number falls in the IEC range (60000-79999), treat it as an
+        # adoption of the corresponding IEC standard. The lower ISO-only
+        # range (1-59999) is intentionally NOT mapped here — too many
+        # existing CEN publications (EN Guide N, EN N as a real CEN-assigned
+        # number) would change type. Callers who want explicit adoption
+        # can still write "EN ISO 12345".
+        # (https://github.com/pubid/pubid/issues/249)
+        # Skip when parts are present — they would be lost when we rebuild
+        # the identifier from just the base number.
+        if data[:publisher]&.to_s == "EN" && !data[:adopted_string] &&
+           data[:parts].to_a.empty? &&
+           (adopted = build_implicit_adoption(data))
+          return adopted
+        end
+
         # Extract supplements before building base identifier (only plus/bundled)
         supplements_data = extract_supplements(data)
 
@@ -56,18 +72,18 @@ module Pubid
         base_data.delete(:amendment_number)
         base_data.delete(:fragment_number)
 
-        base_identifier = locate_identifier_klass(base_data).new
-        assign_attributes(base_identifier, base_data)
+        base = locate_identifier_klass(base_data).new
+        assign_attributes(base, base_data)
 
         # Build Amendment identifier wrapping the base
         amendment = Identifiers::Amendment.new(
-          base_identifier: base_identifier,
+          base: base,
           amendment_number: data[:amendment_number].to_s,
         )
 
         # Build Fragment wrapping the amendment
         Identifiers::Fragment.new(
-          base_identifier: amendment,
+          base: amendment,
           fragment_number: data[:fragment_number].to_s,
         )
       end
@@ -207,6 +223,24 @@ module Pubid
         )
       end
 
+      # Implicit adoption by number range. Returns an AdoptedEuropeanNorm
+      # wrapping the IEC identifier that the EN number implies, or nil if the
+      # number doesn't fall in the IEC range. Limited to IEC range only —
+      # see the call site comment for why the ISO range is excluded.
+      def build_implicit_adoption(data)
+        number = data[:number].to_s
+        num_str = number.to_s.strip
+        return nil unless num_str.match?(/\A\d{1,6}\z/)
+
+        num = num_str.to_i
+        return nil unless (60_000..79_999).cover?(num)
+
+        Identifiers::AdoptedEuropeanNorm.new(
+          publisher: ["EN"],
+          adopted_identifier: Pubid::Iec.parse("IEC #{num_str}"),
+        )
+      end
+
       def build_env_adopted_identifier(data)
         # Parse the adopted identifier string
         adopted_str = data[:adopted_string]&.to_s&.strip
@@ -225,17 +259,17 @@ module Pubid
         )
       end
 
-      def wrap_with_consolidated(base_identifier, supplements_data)
+      def wrap_with_consolidated(base, supplements_data)
         supplement_ids = supplements_data.map do |supp|
           if supp[:type] == :amendment
             Identifiers::Amendment.new(
-              base_identifier: base_identifier,
+              base: base,
               amendment_number: supp[:number],
               amendment_year: supp[:year]&.to_i,
             )
           else
             corr_attrs = {
-              base_identifier: base_identifier,
+              base: base,
               corrigendum_number: supp[:number],
               corrigendum_year: supp[:year]&.to_i,
             }
@@ -245,7 +279,7 @@ module Pubid
         end
 
         Identifiers::ConsolidatedIdentifier.new(
-          identifiers: [base_identifier] + supplement_ids,
+          identifiers: [base] + supplement_ids,
         )
       end
 
@@ -294,8 +328,8 @@ module Pubid
         # Build base identifier first (without supplements)
         base_data = data.dup
         base_data.delete(:supplements)
-        base_identifier = locate_identifier_klass(base_data).new
-        assign_attributes(base_identifier, base_data)
+        base = locate_identifier_klass(base_data).new
+        assign_attributes(base, base_data)
 
         # Get the first supplement (slash means only one supplement)
         supp_array = data[:supplements]
@@ -305,13 +339,13 @@ module Pubid
         # Build appropriate supplement identifier
         if supp_data[:amd_number]
           Identifiers::Amendment.new(
-            base_identifier: base_identifier,
+            base: base,
             amendment_number: supp_data[:amd_number].to_s,
             amendment_year: supp_data[:amd_year]&.to_i,
           )
         else
           corr_attrs = {
-            base_identifier: base_identifier,
+            base: base,
             corrigendum_number: supp_data[:cor_number]&.to_s,
             corrigendum_year: (supp_data[:cor_year] || supp_data[:year])&.to_i,
           }

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

@@ -6,12 +6,12 @@ module Pubid
       # Amendment Identifier
       # Contains a base identifier plus amendment parameters
       class Amendment < Base
-        attribute :base_identifier, Base, polymorphic: true
+        attribute :base, Base, polymorphic: true
         attribute :amendment_number, :string
         attribute :amendment_year, :integer
 
         def publisher
-          base_identifier&.publisher
+          base&.publisher
         end
       end
     end

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

@@ -28,6 +28,12 @@ module Pubid
         def type
           identifiers&.first&.type
         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
       end
     end
   end

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

@@ -6,13 +6,13 @@ module Pubid
       # Corrigendum Identifier
       # Contains a base identifier plus corrigendum parameters
       class Corrigendum < Base
-        attribute :base_identifier, Base, polymorphic: true
+        attribute :base, Base, polymorphic: true
         attribute :corrigendum_number, :string
         attribute :corrigendum_year, :integer
         attribute :corrigendum_month, :string
 
         def publisher
-          base_identifier&.publisher
+          base&.publisher
         end
       end
     end

data/lib/pubid/cen_cenelec/identifiers/european_norm.rb

@@ -6,29 +6,86 @@ module Pubid
       # European Norm (EN) identifier
       class EuropeanNorm < SingleIdentifier
         TYPED_STAGES = [
+          # Published (puben): 60.00-60.60 + publication milestones (65.xx)
           Components::TypedStage.new(
             code: :puben,
             stage_code: :published,
             type_code: :en,
             abbr: ["EN"],
             name: "European Norm",
-            harmonized_stages: %w[60.00 60.60],
+            harmonized_stages: %w[60.00 60.55 60.60 65.31 65.51 65.62],
           ),
+          # Preliminary (pwien): proposal/WI stages
+          Components::TypedStage.new(
+            code: :pwien,
+            stage_code: :preliminary,
+            type_code: :en,
+            abbr: ["pWI EN"],
+            name: "Preliminary Work Item EN",
+            harmonized_stages: %w[00.60 10.98 10.99 20.60],
+          ),
+          # Proposal (pren): working draft stages + split/merge interruption end
           Components::TypedStage.new(
             code: :pren,
             stage_code: :proposal,
             type_code: :en,
             abbr: ["prEN"],
             name: "Proposal European Norm",
-            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.98 30.99],
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.97 30.98 30.99],
           ),
+          # Final Proposal (fpren): enquiry stages
           Components::TypedStage.new(
             code: :fpren,
             stage_code: :final_proposal,
             type_code: :en,
             abbr: ["FprEN"],
             name: "Final Proposal European Norm",
-            harmonized_stages: %w[40.00 40.20 40.60 40.92 40.98 40.99],
+            harmonized_stages: %w[40.00 40.20 40.60 40.92 40.97 40.98 40.99],
+          ),
+          # Formal Vote (fven): COCOR + FV dispatch stages
+          Components::TypedStage.new(
+            code: :fven,
+            stage_code: :formal_vote,
+            type_code: :en,
+            abbr: ["FV prEN"],
+            name: "Formal Vote EN",
+            harmonized_stages: %w[43.20 43.60 43.97 43.98 45.97 45.98 45.99],
+          ),
+          # Vote (ven): enquiry/vote stages
+          Components::TypedStage.new(
+            code: :ven,
+            stage_code: :vote,
+            type_code: :en,
+            abbr: ["vEN"],
+            name: "Vote EN",
+            harmonized_stages: %w[50.20 50.60 50.97 50.98],
+          ),
+          # Review (rven): 2-year review stages
+          Components::TypedStage.new(
+            code: :rven,
+            stage_code: :review,
+            type_code: :en,
+            abbr: ["rvEN"],
+            name: "Review EN",
+            harmonized_stages: %w[90.00 90.20 90.60 90.92 90.93 90.98],
+          ),
+          # Reactivation (racen): re-activation stage
+          Components::TypedStage.new(
+            code: :racen,
+            stage_code: :reactivation,
+            type_code: :en,
+            abbr: ["racEN"],
+            name: "Re-activated EN",
+            harmonized_stages: %w[96.60],
+          ),
+          # Withdrawn (wden): withdrawal stage
+          Components::TypedStage.new(
+            code: :wden,
+            stage_code: :withdrawn,
+            type_code: :en,
+            abbr: ["wdEN"],
+            name: "Withdrawn EN",
+            harmonized_stages: %w[99.60],
           ),
         ].freeze
 

data/lib/pubid/cen_cenelec/identifiers/fragment.rb

@@ -6,11 +6,11 @@ module Pubid
       # Fragment Identifier - wraps an Amendment with a fragment number
       # Example: "EN 60038 AMD1 FRAG2" = Fragment 2 of Amendment 1 to EN 60038
       class Fragment < Base
-        attribute :base_identifier, Amendment
+        attribute :base, Amendment
         attribute :fragment_number, :string
 
         def publisher
-          base_identifier&.base_identifier&.publisher
+          base&.base&.publisher
         end
       end
     end

data/lib/pubid/cen_cenelec/renderer.rb

@@ -190,8 +190,8 @@ module Pubid
 
       # Amendment: "EN 196-3:2005/A1:2008"
       def render_amendment(id)
-        result = if id.base_identifier
-                   "#{id.base_identifier}/A#{id.amendment_number}"
+        result = if id.base
+                   "#{id.base}/A#{id.amendment_number}"
                  else
                    "/A#{id.amendment_number}"
                  end
@@ -201,8 +201,8 @@ module Pubid
 
       # Corrigendum: "EN 60038/AC1:2012"
       def render_corrigendum(id)
-        if id.base_identifier
-          result = id.base_identifier.to_s
+        if id.base
+          result = id.base.to_s
           result += "/AC"
           result += id.corrigendum_number if id.corrigendum_number && !id.corrigendum_number.empty?
         else
@@ -245,7 +245,7 @@ module Pubid
 
       # Fragment: "EN 60038 AMD1 FRAG2"
       def render_fragment(id)
-        "#{id.base_identifier} FRAG#{id.fragment_number}"
+        "#{id.base} FRAG#{id.fragment_number}"
       end
 
       # EuropeanPrestandard: "ENV ISO 8601" or falls through to SingleIdentifier

data/lib/pubid/cen_cenelec/supplement_identifier.rb

@@ -5,27 +5,27 @@ require "lutaml/model"
 module Pubid
   module CenCenelec
     class SupplementIdentifier < Identifiers::Base
-      attribute :base_identifier, Identifiers::Base, polymorphic: true
+      attribute :base, Identifiers::Base, polymorphic: true
       attribute :number, Components::Code
       attribute :date, Components::Date
       attribute :stage, Components::Stage
       attribute :type, Components::Type
       attribute :typed_stage, Components::TypedStage
 
-      # Delegate methods to base_identifier for convenient access
+      # Delegate methods to base for convenient access
       def publisher
-        base_identifier&.publisher
+        base&.publisher
       end
 
       def copublishers
-        base_identifier&.copublishers
+        base&.copublishers
       end
 
       def <=>(other)
         return nil unless other.is_a?(SupplementIdentifier)
 
         # Compare base identifiers first
-        base_cmp = base_identifier <=> other.base_identifier
+        base_cmp = base <=> other.base
         return base_cmp unless base_cmp.zero?
 
         # Then compare numbers

data/lib/pubid/cen_cenelec/urn_generator.rb

@@ -78,7 +78,7 @@ module Pubid
       def generate_supplement_urn
         parts = ["urn", "cen"]
 
-        base_id = maybe(:base_identifier)
+        base_id = maybe(:base)
         if base_id
           base_gen = self.class.new(base_id)
           base_urn = base_gen.generate_base_urn