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

data/lib/pubid/iec/builder.rb

@@ -1,21 +1,25 @@
+require_relative "../components/publisher"
 # frozen_string_literal: true
+require_relative "../components/code"
+require_relative "../components/date"
 
 module Pubid
   module Iec
     class Builder < Pubid::Builder::Base
+      def initialize(scheme)
+        @scheme = scheme
+      end
+
       def locate_identifier_klass(parsed_hash)
         # Check for working programme
         if parsed_hash[:wp_stage]
+          require_relative "identifiers/working_document"
           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]
+          require_relative "identifiers/working_document"
           return Identifiers::WorkingDocument
         end
 
@@ -23,21 +27,20 @@ module Pubid
         # :type_with_stage will be nil if it is an IS.
         typed_stage = locate_typed_stage(parsed_hash[:type_with_stage])
 
-        Pubid::Iec.locate_type(typed_stage.type_code) ||
-          raise(ArgumentError, "Unknown type code: #{typed_stage.type_code}")
+        @scheme.locate_identifier_klass_by_type_code(typed_stage.type_code)
       end
 
       def build(parsed_hash)
         # Handle sheet_supplement_identifier pattern:
-        # {base: {...}, sheet_number: ..., sheet_year: ..., type_with_stage: "COR", number_with_part: "1", date: "1995"}
+        # {base_identifier: {...}, 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] && (parsed_hash[:sheet_number] || parsed_hash[:sheet_year]) && parsed_hash[:type_with_stage]
+        if parsed_hash[:base_identifier] && (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].dup
+          base_parsed = parsed_hash[:base_identifier].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,
@@ -52,8 +55,7 @@ module Pubid
 
           # Locate the supplement identifier class
           typed_stage = locate_typed_stage(supplement_type)
-          identifier_class = Pubid::Iec.locate_type(typed_stage.type_code) ||
-            raise(ArgumentError, "Unknown type code: #{typed_stage.type_code}")
+          identifier_class = @scheme.locate_identifier_klass_by_type_code(typed_stage.type_code)
 
           # Create the supplement identifier
           supplement = identifier_class.new
@@ -73,10 +75,10 @@ module Pubid
           return wrap_with_supplement(sheet_id, supplement)
         end
 
-        # Handle sheet_identifier pattern: {base: {...}, sheet_number: ..., sheet_year: ...}
-        if parsed_hash[:base] && (parsed_hash[:sheet_number] || parsed_hash[:sheet_year])
+        # Handle sheet_identifier pattern: {base_identifier: {...}, sheet_number: ..., sheet_year: ...}
+        if parsed_hash[:base_identifier] && (parsed_hash[:sheet_number] || parsed_hash[:sheet_year])
           # Build the base identifier first
-          base_id = build(parsed_hash[:base])
+          base_id = build(parsed_hash[:base_identifier])
           # Wrap with SheetIdentifier
           sheet_number = parsed_hash.delete(:sheet_number)
           sheet_year = parsed_hash.delete(:sheet_year)
@@ -94,11 +96,14 @@ module Pubid
 
         if is_fragment
           # For FRAG typed stages, look up the fragment's own typed stage
-          fragment_typed_stage = Pubid::Iec.locate_stage(parsed_hash[:type_with_stage])
-
-          # FRAGC is a rendering notation, not a typed stage abbreviation;
-          # fall back to the canonical "FRAG" typed stage
-          fragment_typed_stage ||= Pubid::Iec.locate_stage("FRAG")
+          begin
+            fragment_typed_stage = @scheme.locate_typed_stage_by_abbr(
+              parsed_hash[:type_with_stage].to_s,
+            )
+          rescue ArgumentError
+            # FRAGC is a rendering notation, not a typed stage abbreviation
+            fragment_typed_stage = @scheme.locate_typed_stage_by_abbr("FRAG")
+          end
 
           # For FRAG/FRAGC, we need to build the base Amendment/Corrigendum
           # then wrap it with FragmentIdentifier
@@ -110,8 +115,8 @@ module Pubid
           fragment_edition = parsed_hash.delete(:edition)
 
           # Build the base identifier (Amendment/Corrigendum) directly
-          if parsed_hash[:base]
-            base_id = build(parsed_hash[:base])
+          if parsed_hash[:base_identifier]
+            base_id = build(parsed_hash[:base_identifier])
             return wrap_with_fragment(base_id, fragment_number,
                                       fragment_edition, fragment_typed_stage)
           end
@@ -151,16 +156,9 @@ module Pubid
 
         assign_attributes(identifier, parsed_hash)
 
-        # 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.
+        # Detect rendering style from parsed abbreviation
         if identifier.class.attributes.key?(:rendering_style) && identifier.typed_stage
+          require_relative "rendering_style"
           ts = identifier.typed_stage
 
           # Detect IEC format from parsed abbreviation
@@ -181,7 +179,7 @@ module Pubid
           with_language_code = if langs&.any?
                                  # Check if original_code was single-char (E, F, R, A, S, D)
                                  first_lang = langs.first
-                                 if first_lang.is_a?(::Pubid::Components::Language) && first_lang.original_code && first_lang.original_code.length == 1
+                                 if first_lang.is_a?(Components::Language) && first_lang.original_code && first_lang.original_code.length == 1
                                    :single
                                  else
                                    :iso # 2-char codes (en, fr, ru, ar, es, de)
@@ -204,7 +202,7 @@ module Pubid
 
         # After building base identifier, apply wrappers
         if fragment_type_data && fragment_number_data
-          frag_ts = Pubid::Iec.locate_stage("FRAG")
+          frag_ts = @scheme.locate_typed_stage_by_abbr("FRAG")
           identifier = wrap_with_fragment(identifier, fragment_number_data.to_s,
                                           nil, frag_ts)
         end
@@ -231,27 +229,13 @@ module Pubid
         end
       end
 
-      # The IEC builder's own `build` method drives identifier construction
-      # (it locates the right class per parsed hash), so the parent class's
-      # `@identifier_class` slot is never read. Provide a placeholder so
-      # `Builder.new` doesn't fail with NotImplementedError.
-      def default_identifier_class
-        Identifiers::InternationalStandard
-      end
-
-      # Look up a typed stage by abbreviation via the self-describing
-      # `Pubid::Iec` module instead of an injected scheme instance.
-      def locate_typed_stage(typed_stage_string)
-        typed_stage_string = "" if typed_stage_string.nil?
-        Pubid::Iec.locate_stage(typed_stage_string) ||
-          raise(ArgumentError, "Unknown type abbreviation: '#{typed_stage_string}'")
-      end
-
       # Wrap identifier with FragmentIdentifier for /FRAGN notation
-      def wrap_with_fragment(base, fragment_number,
-      edition_data = nil, typed_stage = nil)
+      def wrap_with_fragment(base_identifier, fragment_number,
+edition_data = nil, typed_stage = nil)
+        require_relative "identifiers/fragment_identifier"
+
         fragment = Identifiers::FragmentIdentifier.new(
-          base: base,
+          base_identifier: base_identifier,
           fragment_number: fragment_number,
         )
 
@@ -267,25 +251,31 @@ module Pubid
       end
 
       # Wrap identifier with SheetIdentifier for /N:YEAR notation
-      def wrap_with_sheet(base, sheet_number, sheet_year)
+      def wrap_with_sheet(base_identifier, sheet_number, sheet_year)
+        require_relative "identifiers/sheet_identifier"
+
         # Only pass year if it's present
         year_value = sheet_year&.to_s
 
         Identifiers::SheetIdentifier.new(
-          base: base,
+          base_identifier: base_identifier,
           sheet_number: sheet_number.to_s,
           year: year_value,
         )
       end
 
       # Wrap base identifier with supplement (Amendment/Corrigendum)
-      def wrap_with_supplement(base, supplement)
-        supplement.base = base
+      def wrap_with_supplement(base_identifier, supplement)
+        supplement.base_identifier = base_identifier
         supplement
       end
 
       # Wrap identifier with ConsolidatedIdentifier for +AMD chains
-      def wrap_with_consolidated(base, supplements_data)
+      def wrap_with_consolidated(base_identifier, supplements_data)
+        require_relative "identifiers/consolidated_identifier"
+        require_relative "identifiers/amendment"
+        require_relative "identifiers/corrigendum"
+
         supplements = supplements_data.filter_map do |supp|
           type = supp[:supplement_type].to_s
           number = supp[:supplement_number].to_s
@@ -308,32 +298,35 @@ module Pubid
         end
 
         Identifiers::ConsolidatedIdentifier.new(
-          identifiers: [base] + supplements,
+          identifiers: [base_identifier] + supplements,
         )
       end
 
-      # Wrap identifier with VapIdentifier for one or more VAP codes
-      # (e.g. "CSV" or "EXV-CMV").
-      def wrap_with_vap(base, vap_suffix_data)
-        vap = vap_suffix_data.to_s.split("-")
+      # Wrap identifier with VapIdentifier for CSV/CMV/RLV/SER suffix
+      def wrap_with_vap(base_identifier, vap_suffix_data)
+        require_relative "identifiers/vap_identifier"
+        require_relative "identifiers/consolidated_identifier"
+        require_relative "components/vap_suffix"
+
+        vap_suffix = Components::VapSuffix.new(code: vap_suffix_data.to_s)
 
         # Extract edition - need to go deep for ConsolidatedIdentifier
         edition = nil
-        if base.is_a?(Identifiers::ConsolidatedIdentifier)
+        if base_identifier.is_a?(Identifiers::ConsolidatedIdentifier)
           # Edition is on the first identifier (base document)
-          base_first = base.identifiers.first
+          base_first = base_identifier.identifiers.first
           if base_first && base_first.class.attributes.key?(:edition)
             edition = base_first.edition
             base_first.edition = nil
           end
-        elsif base.class.attributes.key?(:edition)
-          edition = base.edition
-          base.edition = nil
+        elsif base_identifier.class.attributes.key?(:edition)
+          edition = base_identifier.edition
+          base_identifier.edition = nil
         end
 
         Identifiers::VapIdentifier.new(
-          base: base,
-          vap: vap,
+          base_identifier: base_identifier,
+          vap_suffix: vap_suffix,
           edition: edition,
         )
       end
@@ -344,15 +337,9 @@ module Pubid
         super
       end
 
-      # IEC normalizes em/en dashes to hyphens but preserves slashes and
-      # spaces, which can be semantically meaningful in IEC identifiers.
-      def normalize_number_with_part(value)
-        value.to_s.tr(Parser::DASH_CHARS.join, "-")
-      end
-
       def cast(type, value)
         case type
-        when :base
+        when :base_identifier
           # 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)
@@ -369,7 +356,7 @@ module Pubid
             end
           end
 
-        when :technical_committee, :subcommittee, :wd_number, :wd_stage, :wd_language, :wp_stage, :wp_type
+        when :technical_committee, :wd_number, :wd_stage, :wd_language, :wp_stage, :wp_type
           # Working document/programme fields - just return as string
           value.to_s
 
@@ -387,7 +374,28 @@ module Pubid
           # 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)
+
+          # Split the number into parts
+          normalized_value = value.to_s.tr(Parser::DASH_CHARS.join, "-")
+
+          parts = normalized_value.split("-")
+          number = parts.shift # The first part is always the number
+          part = parts.shift # The second part is the part, if present
+          subpart = parts.any? ? parts.join("-") : nil # The remaining parts form the subpart, if present
+
+          part = convert_roman_to_integer(part)
+
+          code_hash = { number: Components::Code.new(value: number) }
+
+          if part
+            code_hash[:part] = Components::Code.new(value: part)
+          end
+
+          if subpart
+            code_hash[:subpart] = Components::Code.new(value: subpart)
+          end
+
+          code_hash
 
         when :type_with_stage
           # "WD"
@@ -408,22 +416,13 @@ module Pubid
           }
         when :stage_iteration
           # "1" or "2"
-          Pubid::Components::Iteration.new(number: value.to_s)
+          Components::Code.new(value: value.to_s)
 
         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
-          # !ruby/object:Parslet::Slice node — unloadable by the index reader's
-          # YAML.safe_load(permitted_classes: [Symbol]).
-          Pubid::Components::Edition.new(number: value&.to_s)
+          Pubid::Components::Edition.new(number: value)
 
         when :sheet_number
           value.to_s
@@ -435,8 +434,7 @@ module Pubid
           parse_languages(value)
 
         when :all_parts
-          # Set all_parts boolean attribute directly on identifier (matches ISO builder)
-          true
+          Pubid::Components::Locality.new(all_parts: true)
 
         when :database
           # Database flag - return true if DB suffix present
@@ -446,7 +444,8 @@ module Pubid
         when :joint_identifier
           case value[:publisher]
           when "ISO"
-            Pubid::Iso.build_from_parse(value)
+            require_relative "../iso/builder"
+            Iso::Builder.new(Iso::Scheme).build(value)
           end
 
         else

data/lib/pubid/iec/components/code.rb

@@ -1,34 +1,57 @@
+require "lutaml/model"
 # frozen_string_literal: true
 
 module Pubid
   module Iec
     module Components
-      # Code component for IEC identifiers.
-      #
-      # Inherits +value+ and +prefix+ from the shared Code; overrides
-      # rendering to place the prefix (e.g. "TR", "TS") before the value.
-      class Code < ::Pubid::Components::Code
+      class Code < Lutaml::Model::Serializable
+        attribute :prefix, :string, default: -> {}
+        attribute :number, :string
+        attribute :part, :string, default: -> {}
+
+        def initialize(value: nil, number: nil, prefix: nil, part: nil)
+          # Support both 'value' (for convenience) and 'number' (explicit)
+          @number = value || number
+          @prefix = prefix
+          @part = part
+        end
+
         def to_s
           result = ""
           result += "#{prefix} " if prefix
-          result += value.to_s
+          result += number
+          result += "-#{part}" if part
           result
         end
 
-        alias full_code to_s
+        def full_code
+          to_s
+        end
 
         # Parse IEC code formats:
         # - "60034" (just number)
+        # - "60034-1" (number with part)
         # - "TR 61000" (with prefix)
         # - "TS 62443" (with prefix)
         def self.parse(string)
           parts = string.strip.split(" ", 2)
 
           if parts.size == 2
-            new(prefix: parts[0], value: parts[1])
+            # Has prefix: "TR 61000-1-2"
+            prefix = parts[0]
+            number_part = parts[1]
           else
-            new(value: parts[0])
+            # No prefix: "60034-1"
+            prefix = nil
+            number_part = parts[0]
           end
+
+          # Split number and part
+          number_parts = number_part.split("-", 2)
+          number = number_parts[0]
+          part = number_parts[1]
+
+          new(prefix: prefix, number: number, part: part)
         end
       end
     end

data/lib/pubid/iec/components/publisher.rb

@@ -4,7 +4,7 @@ require "lutaml/model"
 module Pubid
   module Iec
     module Components
-      class Publisher < ::Pubid::Components::Publisher
+      class Publisher < Lutaml::Model::Serializable
         PUBLISHERS = {
           "IEC" => "International Electrotechnical Commission",
           "ISO/IEC" => "ISO/IEC Joint Technical Committee",