pubid 2.0.0.pre.alpha.8 → 2.0.0.pre.alpha.11

data/lib/pubid/identifier_metadata.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   # Machine-readable metadata for identifier classes
   # Provides a standardized way to describe identifier types for:

data/lib/pubid/idf/builder.rb

@@ -32,7 +32,7 @@ module Pubid
 
       def cast(type, value)
         case type
-        when :base_identifier
+        when :base
           build(value)
         when :publisher
           Components::Publisher.new(body: value)
@@ -41,9 +41,9 @@ module Pubid
           number = parts.shift
           part = parts.shift
           subpart = parts.size.positive? ? parts.join("-") : nil
-          code_hash = { number: Components::Code.new(value: number) }
-          code_hash[:part] = Components::Code.new(value: part) if part
-          code_hash[:subpart] = Components::Code.new(value: subpart) if subpart
+          code_hash = { number: number }
+          code_hash[:part] = part if part
+          code_hash[:subpart] = subpart if subpart
           code_hash
         when :type_with_stage
           iteration = value.to_s.match(/(\d+)$/)

data/lib/pubid/idf/identifier.rb

@@ -7,6 +7,15 @@ module Pubid
     class Identifier < ::Pubid::Identifier
       attribute :typed_stage, Components::TypedStage
 
+      # `number`/`part`/`subpart` are declared here rather than inherited as a
+      # Components::Code: IDF 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 to_s(**opts)
         render(format: :human, **opts)
       end
@@ -21,11 +30,11 @@ module Pubid
       def number_portion(lang_single: false)
         [
           # Directives may not have a number
-          (number ? " #{number.value}" : ""),
+          (number ? " #{number}" : ""),
 
           # Parts and subparts are optional
-          (part ? "-#{part.value}" : ""),
-          (subpart ? "-#{subpart.value}" : ""),
+          (part ? "-#{part}" : ""),
+          (subpart ? "-#{subpart}" : ""),
 
           # Stage iteration is optional
           (stage_iteration ? ".#{stage_iteration.number}" : ""),
@@ -53,16 +62,16 @@ module Pubid
       end
 
       def self.parse(string)
-        if string.length > Pubid::MAX_INPUT_LENGTH
-          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        unless string.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
         end
 
-        parsed = Pubid::Idf::Parser.new.parse(string)
-        if parsed.nil? || parsed.empty?
-          raise Pubid::Idf::Parser::ParseError,
-                "Invalid identifier format"
+        if string.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
+        parsed = Pubid::Idf::Parser.new.parse(string)
         Pubid::Idf::Builder.new.build(parsed)
       end
     end

data/lib/pubid/idf/parser.rb

@@ -4,7 +4,7 @@ require "parslet"
 
 module Pubid
   module Idf
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       include ::Pubid::Parser::CommonParseRules
       include ::Pubid::Parser::CommonParseMethods
 
@@ -117,7 +117,7 @@ module Pubid
       # IDF 148-1:2008 / COR 1:2009
       # IDF 140-1:2007 / AMD1:2012 (no space between AMD and 1)
       rule(:supplement_identifier_no_third) do
-        identifier_publisher_no_third.as(:base_identifier) >>
+        identifier_publisher_no_third.as(:base) >>
           space? >> str("/") >> space? >>
           supplement_type_with_stage >>
           space.maybe >> second_part
@@ -130,7 +130,7 @@ module Pubid
       # # ISO/IEC 13818-1:2015/Amd 3:2016/Cor 1:2017
       # # ISO/IEC 19794-7:2014/Amd 1:2015/CD Cor 1
       # rule(:supplement_supplement_identifier) do
-      #   supplement_identifier_no_third.as(:base_identifier) >>
+      #   supplement_identifier_no_third.as(:base) >>
       #     str("/") >> supplement_type_with_stage >>
       #     # digits.as(:stage_iteration).maybe >>
       #     space? >> second_part >> third_part

data/lib/pubid/idf/renderer.rb

@@ -43,9 +43,9 @@ module Pubid
         lang_single = opts[:lang_single] || false
 
         [
-          (id.number ? " #{id.number.render(context:)}" : ""),
-          (id.part ? "-#{id.part.render(context:)}" : ""),
-          (id.subpart ? "-#{id.subpart.render(context:)}" : ""),
+          (id.number ? " #{id.number}" : ""),
+          (id.part ? "-#{id.part}" : ""),
+          (id.subpart ? "-#{id.subpart}" : ""),
           (id.stage_iteration ? ".#{id.stage_iteration.render(context:)}" : ""),
           (id.date ? ":#{id.date.render(context:)}" : ""),
           language_portion(id, lang_single: lang_single),
@@ -70,12 +70,12 @@ module Pubid
         with_edition = opts[:with_edition] || false
 
         [
-          id.base_identifier.to_s(lang: lang, lang_single: lang_single,
+          id.base.to_s(lang: lang, lang_single: lang_single,
                                    with_edition: with_edition),
           "/",
           id.typed_stage.abbreviation,
           " ",
-          id.number.render(context:),
+          id.number,
           (id.date ? ":#{id.date.render(context:)}" : ""),
         ].join
       end

data/lib/pubid/idf/supplement_identifier.rb

@@ -12,15 +12,15 @@ module Pubid
     # SingleIdentifier (which is for base documents only).
     #
     # Architecture Note:
-    # - Supplements have a base_identifier attribute (recursive structure)
+    # - Supplements have a base attribute (recursive structure)
     # - Supplements share the to_s rendering pattern
     # - Supplements inherit typed_stage from base Identifier class
     class SupplementIdentifier < Identifier
-      attribute :base_identifier, Identifier
+      attribute :base, Identifier
 
       # Render supplement identifier as string.
       #
-      # Format: "base_identifier/ABBREVIATION number:year"
+      # Format: "base/ABBREVIATION number:year"
       # Example: "IDF 125:1988/AMD 1:2023"
       #
       # @param lang [Symbol] Language (default: :en)

data/lib/pubid/idf/urn_generator.rb

@@ -38,7 +38,7 @@ module Pubid
           end
 
           if identifier.number
-            parts << identifier.number.render(context: URN_CONTEXT)
+            parts << identifier.number
           end
         end
 

data/lib/pubid/idf.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Idf
     extend Pubid::PrefixesSupport
@@ -18,8 +19,13 @@ module Pubid
     autoload :UrnParser, "#{__dir__}/idf/urn_parser"
 
     def self.parse(identifier)
+      unless identifier.is_a?(String)
+        raise Pubid::Errors::InvalidInputError,
+              Pubid::INPUT_NOT_A_STRING_MESSAGE
+      end
+
       if identifier.length > Pubid::MAX_INPUT_LENGTH
-        raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
       end
 
       parser = Parser.new

data/lib/pubid/iec/builder.rb

@@ -9,6 +9,11 @@ module Pubid
           return Identifiers::WorkingDocument
         end
 
+        # Check for technical group (committee identifier, no document number)
+        if parsed_hash[:technical_committee] && !parsed_hash[:wd_number]
+          return Identifiers::TechnicalGroup
+        end
+
         # Check for working document
         if parsed_hash[:technical_committee] && parsed_hash[:wd_number]
           return Identifiers::WorkingDocument
@@ -24,15 +29,15 @@ module Pubid
 
       def build(parsed_hash)
         # Handle sheet_supplement_identifier pattern:
-        # {base_identifier: {...}, sheet_number: ..., sheet_year: ..., type_with_stage: "COR", number_with_part: "1", date: "1995"}
+        # {base: {...}, sheet_number: ..., sheet_year: ..., type_with_stage: "COR", number_with_part: "1", date: "1995"}
         # This is a Corrigendum/Amendment wrapping a SheetIdentifier
-        if parsed_hash[:base_identifier] && (parsed_hash[:sheet_number] || parsed_hash[:sheet_year]) && parsed_hash[:type_with_stage]
+        if parsed_hash[:base] && (parsed_hash[:sheet_number] || parsed_hash[:sheet_year]) && parsed_hash[:type_with_stage]
           # Extract sheet info first
           sheet_number = parsed_hash.delete(:sheet_number)
           sheet_year = parsed_hash.delete(:sheet_year)
 
           # Build the base identifier (IEC 60695-2-1 with /1:1994 -> SheetIdentifier)
-          base_parsed = parsed_hash[:base_identifier].dup
+          base_parsed = parsed_hash[:base].dup
           base_parsed[:sheet_number] = sheet_number
           base_parsed[:sheet_year] = sheet_year if sheet_year
           sheet_id = wrap_with_sheet(build(base_parsed), sheet_number,
@@ -54,7 +59,7 @@ module Pubid
           supplement = identifier_class.new
           supp_attrs = identifier_class.attributes
           if supp_attrs.key?(:number)
-            supplement.number = Components::Code.new(value: supplement_number.to_s)
+            supplement.number = supplement_number.to_s
           end
           if supplement_date && supp_attrs.key?(:date)
             supplement.date = cast(:date, supplement_date)
@@ -68,10 +73,10 @@ module Pubid
           return wrap_with_supplement(sheet_id, supplement)
         end
 
-        # Handle sheet_identifier pattern: {base_identifier: {...}, sheet_number: ..., sheet_year: ...}
-        if parsed_hash[:base_identifier] && (parsed_hash[:sheet_number] || parsed_hash[:sheet_year])
+        # Handle sheet_identifier pattern: {base: {...}, sheet_number: ..., sheet_year: ...}
+        if parsed_hash[:base] && (parsed_hash[:sheet_number] || parsed_hash[:sheet_year])
           # Build the base identifier first
-          base_id = build(parsed_hash[:base_identifier])
+          base_id = build(parsed_hash[:base])
           # Wrap with SheetIdentifier
           sheet_number = parsed_hash.delete(:sheet_number)
           sheet_year = parsed_hash.delete(:sheet_year)
@@ -105,8 +110,8 @@ module Pubid
           fragment_edition = parsed_hash.delete(:edition)
 
           # Build the base identifier (Amendment/Corrigendum) directly
-          if parsed_hash[:base_identifier]
-            base_id = build(parsed_hash[:base_identifier])
+          if parsed_hash[:base]
+            base_id = build(parsed_hash[:base])
             return wrap_with_fragment(base_id, fragment_number,
                                       fragment_edition, fragment_typed_stage)
           end
@@ -146,7 +151,15 @@ module Pubid
 
         assign_attributes(identifier, parsed_hash)
 
-        # Detect rendering style from parsed abbreviation
+        # Detect rendering style from parsed abbreviation.
+        #
+        # UNREACHABLE TODAY: no IEC identifier class declares a
+        # `rendering_style` attribute, so this whole block never runs. Its
+        # `original_abbr` reads below are therefore NOT a live consumer of that
+        # field — which is why `original_abbr` can be left nil on both the parse
+        # and the from_hash paths (see Identifier.published_typed_stage). The
+        # long-vs-short stage spelling is already collapsed: "…/Amd 1:2017"
+        # renders back as "…/AMD1:2017". Do not treat this as working code.
         if identifier.class.attributes.key?(:rendering_style) && identifier.typed_stage
           ts = identifier.typed_stage
 
@@ -235,10 +248,10 @@ module Pubid
       end
 
       # Wrap identifier with FragmentIdentifier for /FRAGN notation
-      def wrap_with_fragment(base_identifier, fragment_number,
+      def wrap_with_fragment(base, fragment_number,
       edition_data = nil, typed_stage = nil)
         fragment = Identifiers::FragmentIdentifier.new(
-          base_identifier: base_identifier,
+          base: base,
           fragment_number: fragment_number,
         )
 
@@ -254,25 +267,25 @@ module Pubid
       end
 
       # Wrap identifier with SheetIdentifier for /N:YEAR notation
-      def wrap_with_sheet(base_identifier, sheet_number, sheet_year)
+      def wrap_with_sheet(base, sheet_number, sheet_year)
         # Only pass year if it's present
         year_value = sheet_year&.to_s
 
         Identifiers::SheetIdentifier.new(
-          base_identifier: base_identifier,
+          base: base,
           sheet_number: sheet_number.to_s,
           year: year_value,
         )
       end
 
       # Wrap base identifier with supplement (Amendment/Corrigendum)
-      def wrap_with_supplement(base_identifier, supplement)
-        supplement.base_identifier = base_identifier
+      def wrap_with_supplement(base, supplement)
+        supplement.base = base
         supplement
       end
 
       # Wrap identifier with ConsolidatedIdentifier for +AMD chains
-      def wrap_with_consolidated(base_identifier, supplements_data)
+      def wrap_with_consolidated(base, supplements_data)
         supplements = supplements_data.filter_map do |supp|
           type = supp[:supplement_type].to_s
           number = supp[:supplement_number].to_s
@@ -283,43 +296,43 @@ module Pubid
 
           if type == "AMD"
             Identifiers::Amendment.new(
-              number: Components::Code.new(value: number),
+              number: number,
               date: date_component,
             )
           elsif type == "COR"
             Identifiers::Corrigendum.new(
-              number: Components::Code.new(value: number),
+              number: number,
               date: date_component,
             )
           end
         end
 
         Identifiers::ConsolidatedIdentifier.new(
-          identifiers: [base_identifier] + supplements,
+          identifiers: [base] + supplements,
         )
       end
 
       # Wrap identifier with VapIdentifier for one or more VAP codes
       # (e.g. "CSV" or "EXV-CMV").
-      def wrap_with_vap(base_identifier, vap_suffix_data)
+      def wrap_with_vap(base, vap_suffix_data)
         vap = vap_suffix_data.to_s.split("-")
 
         # Extract edition - need to go deep for ConsolidatedIdentifier
         edition = nil
-        if base_identifier.is_a?(Identifiers::ConsolidatedIdentifier)
+        if base.is_a?(Identifiers::ConsolidatedIdentifier)
           # Edition is on the first identifier (base document)
-          base_first = base_identifier.identifiers.first
+          base_first = base.identifiers.first
           if base_first && base_first.class.attributes.key?(:edition)
             edition = base_first.edition
             base_first.edition = nil
           end
-        elsif base_identifier.class.attributes.key?(:edition)
-          edition = base_identifier.edition
-          base_identifier.edition = nil
+        elsif base.class.attributes.key?(:edition)
+          edition = base.edition
+          base.edition = nil
         end
 
         Identifiers::VapIdentifier.new(
-          base_identifier: base_identifier,
+          base: base,
           vap: vap,
           edition: edition,
         )
@@ -339,7 +352,7 @@ module Pubid
 
       def cast(type, value)
         case type
-        when :base_identifier
+        when :base
           # If it has a base identifier, we need to build a supplement
           # We assume that the base identifier is already a valid Identifier object
           build(value)
@@ -356,7 +369,7 @@ module Pubid
             end
           end
 
-        when :technical_committee, :wd_number, :wd_stage, :wd_language, :wp_stage, :wp_type
+        when :technical_committee, :subcommittee, :wd_number, :wd_stage, :wd_language, :wp_stage, :wp_type
           # Working document/programme fields - just return as string
           value.to_s
 
@@ -366,15 +379,14 @@ module Pubid
 
         when :number
           # Plain number for sub-org identifiers (CA, IECQ CS, IECQ OD)
-          # Just return as Code component
-          { number: Components::Code.new(value: value.to_s) }
+          { number: value.to_s }
 
         when :number_with_part
           # "60038" (no part)
           # or "60038-1" ('1' is part)
           # or "60038-1-2" ('1' is part, '2' is subpart)
           # or "29110-5-1-1" ('5' is part, '1-1' is subpart)
-          parse_number_with_part(value, code_class: Components::Code)
+          parse_number_with_part(value)
 
         when :type_with_stage
           # "WD"
@@ -400,6 +412,11 @@ module Pubid
         when :date
           parse_date(value)
 
+        when :undated_marker
+          # ISO/IEC undated reference (e.g. "IEC 60050:--") — explicit
+          # publication-date slot with no year; round-trips via date.render.
+          { date: Pubid::Components::Date.new(undated: true) }
+
         when :edition
           # Coerce to String: the parsed value may be a Parslet::Slice, which
           # Edition.number (Type::Value) would store verbatim and serialize as a

data/lib/pubid/iec/components.rb

@@ -3,7 +3,6 @@
 module Pubid
   module Iec
     module Components
-      autoload :Code, "#{__dir__}/components/code"
       autoload :ConsolidatedAmendment, "#{__dir__}/components/consolidated_amendment"
       autoload :Publisher, "#{__dir__}/components/publisher"
       autoload :Sheet, "#{__dir__}/components/sheet"