pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/cie/builder.rb

@@ -0,0 +1,524 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Cie
+    # Builder transforms parsed data into CIE identifier objects
+    # Single Responsibility: Object construction from parse tree
+    class Builder
+      def initialize
+        # Builder doesn't need scheme for CIE (simpler than ISO/IEC)
+      end
+
+      # Build identifier from parsed hash
+      def build(parsed_hash, original_string: nil)
+        # Determine identifier class based on parsed content
+        identifier_class = determine_class(parsed_hash)
+
+        # Supplement / Corrigendum wrap a nested base.
+        if identifier_class == Cie::Identifiers::Corrigendum
+          return build_corrigendum(parsed_hash)
+        end
+        if identifier_class == Cie::Identifiers::Supplement
+          return build_supplement(parsed_hash)
+        end
+
+        # Extract attributes with style detection
+        attributes = extract_attributes(parsed_hash)
+
+        # For Bundle, parse each comma-separated member and hoist a shared base.
+        if parsed_hash[:bundle_items] && original_string
+          attributes.merge!(build_bundle(original_string))
+        end
+
+        # `extract_attributes` builds one attribute hash for every CIE type,
+        # but the types do not share one attribute set — only Standard,
+        # DualPublished and Identical declare `s_prefix`, while Conference,
+        # Bundle, Proceedings and TutorialBundle do not. lutaml used to drop
+        # the surplus key without a word; the constructor now refuses it, so
+        # the builder has to stop offering it.
+        attributes = attributes.select do |key, _|
+          identifier_class.attributes.key?(key)
+        end
+
+        # Construct identifier
+        identifier_class.new(**attributes)
+      end
+
+      private
+
+      # Build a Bundle's attributes from its printed form. Parse each member,
+      # then — since a CIE bundle is the parts of one supplement of one standard
+      # — hoist the shared base and keep only the differing supplement
+      # number/part in each doc. If the members don't share a base (not seen in
+      # practice, but the grammar allows it), keep each doc's own base instead.
+      def build_bundle(original_string)
+        members = split_bundle_members(original_string)
+        shared = common_base(members)
+        return { ids: members } unless shared
+
+        ids = members.map do |m|
+          Cie::Identifiers::Supplement.new(number: m.number, part: m.part)
+        end
+        { base: shared, ids: ids }
+      end
+
+      # The publisher prefix is written once, so only the first item carries
+      # "CIE "; prepend it to the rest before parsing each member.
+      def split_bundle_members(original_string)
+        original_string.split(",").each_with_index.map do |item, i|
+          ref = i.zero? ? item.strip : "CIE #{item.strip}"
+          Cie::Identifier.parse(ref)
+        end
+      end
+
+      # The base shared by every member, or nil if they differ (or any is
+      # base-less). Compared by canonical hash so structural equality holds.
+      def common_base(members)
+        bases = members.map(&:base)
+        return nil if bases.any?(&:nil?)
+
+        first = bases.first.to_hash
+        bases.all? { |b| b.to_hash == first } ? bases.first : nil
+      end
+
+      # Supplement: nest the base Standard (the stage/year/language belong to
+      # the base), keep only the -SPN number/part on the wrapper.
+      def build_supplement(parsed_hash)
+        a = extract_attributes(parsed_hash)
+        base = Cie::Identifiers::Standard.new(
+          number: a[:base_number],
+          stage: a[:stage],
+          s_prefix: a.fetch(:s_prefix, false),
+          language: a[:language],
+          year: a[:year],
+          style: "current", # supplements always use the colon style
+        )
+        Cie::Identifiers::Supplement.new(
+          base: base,
+          number: a[:supplement_number],
+          part: a[:supplement_part],
+        )
+      end
+
+      # Corrigendum: nest the base (a Standard, or a Supplement when the base
+      # itself carries -SPN), keep only the /CorN number/year on the wrapper.
+      def build_corrigendum(parsed_hash)
+        a = extract_attributes(parsed_hash)
+        base_std = Cie::Identifiers::Standard.new(
+          number: a[:base_number],
+          year: a[:base_year],
+          style: "current",
+        )
+        base = if a[:base_supplement]
+                 Cie::Identifiers::Supplement.new(
+                   base: base_std,
+                   number: a[:base_supplement],
+                   part: a[:base_supplement_part],
+                 )
+               else
+                 base_std
+               end
+        Cie::Identifiers::Corrigendum.new(
+          base: base,
+          number: a[:cor_number],
+          year: a[:cor_year],
+        )
+      end
+
+      # Determine which identifier class to use
+      def determine_class(parsed_hash)
+        # Tutorial Bundle (special text format)
+        if parsed_hash[:bundle_number] && !parsed_hash[:first_number]
+          return Cie::Identifiers::TutorialBundle
+        end
+
+        # Bundle (comma-separated)
+        if parsed_hash[:bundle_items]
+          return Cie::Identifiers::Bundle
+        end
+
+        # Corrigendum (/CorN)
+        if parsed_hash[:cor_number]
+          return Cie::Identifiers::Corrigendum
+        end
+
+        # Supplement (-SPN)
+        if parsed_hash[:supplement_number] && !parsed_hash[:cor_number]
+          return Cie::Identifiers::Supplement
+        end
+
+        # Proceedings paper (x-prefixed or standalone)
+        if parsed_hash[:paper_code]
+          return Cie::Identifiers::Proceedings
+        end
+
+        # Conference (x-prefix)
+        if parsed_hash[:conference]
+          return Cie::Identifiers::Conference
+        end
+
+        # Dual published with IEC
+        if parsed_hash[:iec_identifier]
+          return Cie::Identifiers::DualPublished
+        end
+
+        # Identical with ISO
+        if parsed_hash[:iso_reference]
+          return Cie::Identifiers::Identical
+        end
+
+        # Joint with copublisher (ISO, IEC, or ISO/CIE)
+        if parsed_hash[:copublisher]
+          return Cie::Identifiers::JointPublished
+        end
+
+        # Standard (default)
+        Cie::Identifiers::Standard
+      end
+
+      # Extract attributes from parsed hash
+      def extract_attributes(parsed_hash)
+        attributes = {}
+
+        # Extract year and date separator from wrapped date format
+        year_value = nil
+        date_sep = nil
+
+        # Handle the new wrapped formats from parser
+        if parsed_hash[:date_then_lang]
+          # date_then_lang: { current_date: { year: ... } } or { legacy_date: { year: ... } }, language: ...
+          date_data = parsed_hash[:date_then_lang]
+          if date_data[:current_date]
+            year_value = extract_value(date_data[:current_date][:year])
+            date_sep = "colon"
+          elsif date_data[:legacy_date]
+            year_value = extract_value(date_data[:legacy_date][:year])
+            date_sep = "dash"
+          end
+          # Extract language from date_then_lang if present
+          if date_data[:language_paren_year]
+            lang_data = date_data[:language_paren_year]
+            lang_code = extract_value(lang_data[:lang_code])
+            trans_year = extract_value(lang_data[:trans_year])
+            lang_format = "paren_year"
+            if lang_code
+              lang_attrs = { code: lang_code, format: lang_format }
+              lang_attrs[:translation_year] = trans_year if trans_year
+              attributes[:language] = Components::Language.new(**lang_attrs)
+            end
+          elsif date_data[:language_paren]
+            lang_data = date_data[:language_paren]
+            lang_code = extract_value(lang_data[:lang_code])
+            lang_format = "paren"
+            if lang_code
+              lang_attrs = { code: lang_code, format: lang_format }
+              attributes[:language] = Components::Language.new(**lang_attrs)
+            end
+          elsif date_data[:language_slash]
+            lang_data = date_data[:language_slash]
+            lang_code = extract_value(lang_data[:lang_code])
+            lang_format = "slash"
+            if lang_code
+              lang_attrs = { code: lang_code, format: lang_format }
+              attributes[:language] = Components::Language.new(**lang_attrs)
+            end
+          end
+        elsif parsed_hash[:lang_before]
+          # lang_before: { language: ..., current_date/legacy_date: ... }
+          lang_data = parsed_hash[:lang_before]
+          if lang_data[:language_paren]
+            lang_info = lang_data[:language_paren]
+            lang_code = extract_value(lang_info[:lang_code])
+            lang_format = "paren"
+            if lang_code
+              lang_attrs = { code: lang_code, format: lang_format }
+              attributes[:language] = Components::Language.new(**lang_attrs)
+            end
+          elsif lang_data[:language_slash]
+            lang_info = lang_data[:language_slash]
+            lang_code = extract_value(lang_info[:lang_code])
+            lang_format = "slash"
+            if lang_code
+              lang_attrs = { code: lang_code, format: lang_format }
+              attributes[:language] = Components::Language.new(**lang_attrs)
+            end
+          end
+          # Extract date from lang_before
+          if lang_data[:current_date]
+            year_value = extract_value(lang_data[:current_date][:year])
+            date_sep = "colon"
+          elsif lang_data[:legacy_date]
+            year_value = extract_value(lang_data[:legacy_date][:year])
+            date_sep = "dash"
+          end
+        elsif parsed_hash[:current_date]
+          year_value = extract_value(parsed_hash[:current_date][:year])
+          date_sep = "colon"
+        elsif parsed_hash[:legacy_date]
+          year_value = extract_value(parsed_hash[:legacy_date][:year])
+          date_sep = "dash"
+        elsif parsed_hash[:year]
+          # Direct year (for joint patterns or legacy_code_with_year)
+          year_value = extract_value(parsed_hash[:year])
+
+          # For joint patterns, infer separator based on copublisher
+          if parsed_hash[:copublisher]
+            copub = extract_value(parsed_hash[:copublisher])
+            # IEC uses dash, ISO uses colon (by convention for modern docs)
+            date_sep = copub == "IEC" ? "dash" : "colon"
+          elsif parsed_hash[:trailing_lang]
+            # If trailing_lang exists, this came from legacy_code_with_year
+            # which uses dash as the year separator (parsed as NUMBER-YEAR)
+            date_sep = "dash"
+          else
+            # Default: infer from year value (pre-2001 = dash, post-2001 = colon)
+            year_int = year_value.to_i
+            date_sep = year_int <= 2001 ? "dash" : "colon"
+          end
+        elsif parsed_hash[:slash_year]
+          # Slash-year format (legacy): /1998
+          year_value = extract_value(parsed_hash[:slash_year])
+          date_sep = "slash" # Special format for identical identifiers
+        end
+
+        # Style is the sole separator field (no date_separator):
+        #   colon -> current (":")   dash -> legacy ("-")   slash -> slash ("/")
+        style = case date_sep
+                when "colon" then "current"
+                when "dash" then "legacy"
+                when "slash" then "slash"
+                else detect_style_fallback(parsed_hash)
+                end
+        attributes[:style] = style
+
+        # Set year if present
+        attributes[:year] = year_value if year_value
+
+        # Extract code (flat number/part/iteration/part_separator on the
+        # identifier; the code's style is the identifier's own `style`).
+        if parsed_hash[:number]
+          attributes[:number] = extract_value(parsed_hash[:number])
+          if parsed_hash[:part]
+            attributes[:part] = extract_value(parsed_hash[:part])
+          end
+          if parsed_hash[:iteration]
+            attributes[:iteration] = extract_value(parsed_hash[:iteration])
+          end
+
+          # Detect part separator from parser markers
+          if parsed_hash[:slash_sep]
+            attributes[:part_separator] = "slash"
+          elsif parsed_hash[:dash_sep]
+            attributes[:part_separator] = "dash"
+          end
+        end
+
+        # Conference number (separate from regular code)
+        if parsed_hash[:conf_number]
+          attributes[:number] =
+            extract_value(parsed_hash[:conf_number])
+        end
+
+        # Proceedings paper: the paper itself is the document, so its identity
+        # (code + running number, e.g. "OP01") is the flat +number+ for both
+        # surface forms. The x-form's parent conference goes to
+        # +conference+; the standalone form keeps its +page+ range.
+        if parsed_hash[:paper_code]
+          attributes[:number] =
+            "#{extract_value(parsed_hash[:paper_code])}" \
+            "#{extract_value(parsed_hash[:paper_number])}"
+          if parsed_hash[:conf_number]
+            attributes[:conference] =
+              extract_value(parsed_hash[:conf_number])
+          end
+        end
+        if parsed_hash[:page_range]
+          attributes[:page] = extract_value(parsed_hash[:page_range])
+        end
+
+        # Conference /slug variant (opaque, verbatim)
+        if parsed_hash[:variant]
+          attributes[:variant] = extract_value(parsed_hash[:variant])
+        end
+
+        # D-series marker
+        attributes[:d_prefix] = true if parsed_hash[:d_prefix]
+
+        # Extract language (direct lang_code for slash_colon format)
+        lang_code = nil
+        lang_format = nil
+        trans_year = nil
+
+        if parsed_hash[:language_paren_year]
+          lang_data = parsed_hash[:language_paren_year]
+          lang_code = extract_value(lang_data[:lang_code])
+          trans_year = extract_value(lang_data[:trans_year])
+          lang_format = "paren_year"
+        elsif parsed_hash[:language_paren]
+          lang_data = parsed_hash[:language_paren]
+          lang_code = extract_value(lang_data[:lang_code])
+          lang_format = "paren"
+        elsif parsed_hash[:language_slash]
+          lang_data = parsed_hash[:language_slash]
+          lang_code = extract_value(lang_data[:lang_code])
+          lang_format = "slash"
+        elsif parsed_hash[:lang_code]
+          # Direct lang_code from identical_with_iso or standard_with_language_year patterns
+          # Format: /E:2001 (with colon)
+          lang_code = extract_value(parsed_hash[:lang_code])
+          # Check if colon was present in the pattern
+          if parsed_hash[:lang_colon]
+            lang_format = "slash_colon" # /E:YYYY format
+          else
+            # This shouldn't happen with preprocessing, but default to slash
+            lang_format = "slash"
+          end
+        end
+
+        if lang_code
+          lang_attrs = { code: lang_code, format: lang_format }
+          lang_attrs[:translation_year] = trans_year if trans_year
+          attributes[:language] = Components::Language.new(**lang_attrs)
+        end
+
+        # Extract S prefix flag
+        attributes[:s_prefix] = parsed_hash[:s_prefix] ? true : false
+
+        # Extract stage
+        if parsed_hash[:stage]
+          attributes[:stage] =
+            extract_value(parsed_hash[:stage])
+        end
+
+        # Extract doc type
+        if parsed_hash[:doc_type]
+          attributes[:doc_type] =
+            extract_value(parsed_hash[:doc_type])
+        end
+
+        # Extract copublisher info
+        if parsed_hash[:copublisher]
+          attributes[:copublisher] = extract_value(parsed_hash[:copublisher])
+        end
+
+        # Extract ISO reference (for identical identifiers)
+        if parsed_hash[:iso_reference]
+          attributes[:iso_reference] =
+            extract_value(parsed_hash[:iso_reference])
+        end
+
+        # Extract IEC identifier (for dual published)
+        if parsed_hash[:iec_identifier]
+          attributes[:iec_identifier] =
+            extract_value(parsed_hash[:iec_identifier])
+        end
+
+        # Extract supplement data
+        if parsed_hash[:supplement_number]
+          attributes[:supplement_number] =
+            extract_value(parsed_hash[:supplement_number])
+          if parsed_hash[:supplement_part]
+            attributes[:supplement_part] =
+              extract_value(parsed_hash[:supplement_part])
+          end
+          if parsed_hash[:base_number]
+            attributes[:base_number] =
+              extract_value(parsed_hash[:base_number])
+          end
+        end
+
+        # Extract corrigendum data
+        if parsed_hash[:cor_number]
+          attributes[:cor_number] = extract_value(parsed_hash[:cor_number])
+          attributes[:cor_year] = extract_value(parsed_hash[:cor_year])
+          attributes[:base_number] = extract_value(parsed_hash[:base_number])
+          attributes[:base_year] = extract_value(parsed_hash[:base_year])
+          if parsed_hash[:base_supplement]
+            attributes[:base_supplement] =
+              extract_value(parsed_hash[:base_supplement])
+          end
+          if parsed_hash[:base_supplement_part]
+            attributes[:base_supplement_part] =
+              extract_value(parsed_hash[:base_supplement_part])
+          end
+        end
+
+        # Extract amendment (on conference)
+        if parsed_hash[:amd_number]
+          attributes[:amendment_number] =
+            extract_value(parsed_hash[:amd_number])
+        end
+
+        # Tutorial bundle: the ordinal is the bundle's own `number` (also its
+        # relaton-index key). A comma-list bundle instead keys via its `ids`
+        # members through #root, so it needs no stored number.
+        if parsed_hash[:bundle_number]
+          attributes[:number] = extract_value(parsed_hash[:bundle_number])
+        end
+
+        # Extract trailing language from legacy_code_with_year
+        if parsed_hash[:trailing_lang].is_a?(Hash)
+          lang_data = parsed_hash[:trailing_lang]
+          # trailing_lang contains language_paren_year hash
+          if lang_data[:language_paren_year]
+            lang_info = lang_data[:language_paren_year]
+            lang_code = extract_value(lang_info[:lang_code])
+            trans_year = extract_value(lang_info[:trans_year])
+            if lang_code
+              lang_attrs = { code: lang_code, format: "paren_year" }
+              lang_attrs[:translation_year] = trans_year if trans_year
+              attributes[:language] = Components::Language.new(**lang_attrs)
+            end
+          end
+        end
+
+        attributes
+      end
+
+      # Detect style from date separator
+      def detect_style(parsed_hash)
+        # Check for current_date or legacy_date wrapper
+        if parsed_hash[:current_date]
+          return "current"
+        elsif parsed_hash[:legacy_date]
+          return "legacy"
+        end
+
+        # Fallback
+        detect_style_fallback(parsed_hash)
+      end
+
+      # Fallback style detection based on year
+      def detect_style_fallback(parsed_hash)
+        # Fallback: year-based heuristic
+        if parsed_hash[:year]
+          year = extract_value(parsed_hash[:year]).to_i
+          return year <= 2001 ? "legacy" : "current"
+        elsif parsed_hash[:current_date] && parsed_hash[:current_date][:year]
+          year = extract_value(parsed_hash[:current_date][:year]).to_i
+          return year <= 2001 ? "legacy" : "current"
+        elsif parsed_hash[:legacy_date] && parsed_hash[:legacy_date][:year]
+          year = extract_value(parsed_hash[:legacy_date][:year]).to_i
+          return year <= 2001 ? "legacy" : "current"
+        end
+
+        # Default to current
+        "current"
+      end
+
+      # Extract value from parsed element
+      def extract_value(value)
+        return nil if value.nil?
+        return nil if value.is_a?(Array) && value.empty?
+
+        if value.is_a?(Array)
+          joined = value.join
+          return joined.length.positive? ? joined : nil
+        end
+
+        str_value = value.to_s.strip
+        str_value.length.positive? ? str_value : nil
+      end
+    end
+  end
+end

data/lib/pubid/cie/components/language.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Cie
+    module Components
+      # Language component for CIE identifiers
+      # Handles three distinct language formats:
+      # 1. Slash-prefix: /E, /F, /G (legacy, no year)
+      # 2. Slash with colon and year: /E:2001 (slash_colon)
+      # 3. Parenthetical: (DE), (ES), (en)
+      # 4. Translation year: (RU-2021)
+      class Language < Lutaml::Model::Serializable
+        attribute :code, :string              # "E", "DE", "RU", "en"
+        attribute :format, :string            # "slash", "slash_colon", "paren", "paren_year"
+        attribute :translation_year, :string  # "2021" in "(RU-2021)"
+
+        def to_s
+          case format
+          when "slash"
+            "/#{code}"                          # /E, /F, /G (no year)
+          when "slash_colon"
+            "/#{code}"                          # /E (colon and year handled by Identical)
+          when "paren"
+            "(#{code})"                         # (DE), (ES), (en)
+          when "paren_year"
+            " (#{code}-#{translation_year})" # (RU-2021)
+          else
+            "(#{code})" # Default to paren
+          end
+        end
+
+        # Parse language string with format detection
+        def self.parse(lang_str)
+          return nil if lang_str.nil? || lang_str.strip.empty?
+
+          # Detect slash format
+          if lang_str.start_with?("/")
+            new(code: lang_str[1..], format: "slash")
+          # Detect paren with year
+          elsif lang_str.match?(/\(([A-Z]{2})-(\d{4})\)/)
+            match = lang_str.match(/\(([A-Z]{2})-(\d{4})\)/)
+            new(code: match[1], translation_year: match[2],
+                format: "paren_year")
+          # Detect simple paren
+          elsif lang_str.match?(/\(([A-Za-z]{2,3})\)/)
+            match = lang_str.match(/\(([A-Za-z]{2,3})\)/)
+            new(code: match[1], format: "paren")
+          else
+            # Default: treat as code
+            new(code: lang_str, format: "paren")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cie/identifier.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Cie
+    # Base Identifier class for CIE.
+    #
+    # Inherits the shared Pubid::Identifier contract (format_registry, render,
+    # to_urn, exclude, hash, eql?) while allowing CIE-specific attributes.
+    #
+    # +style+ is the sole number<->year separator field (there is no separate
+    # date_separator): "current" -> ":", "legacy" -> "-", "slash" -> "/".
+    # It defaults to "current" (the dominant value), so canonicalize_hash drops
+    # it from the majority of rows and from_hash restores it.
+    class Identifier < ::Pubid::Identifier
+      attribute :style, :string, default: -> { "current" }
+
+      def self.parse(input)
+        unless input.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if input.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        parsed = Parser.parse(input)
+        builder = Builder.new
+        builder.build(parsed, original_string: input)
+      end
+    end
+  end
+end

data/lib/pubid/cie/identifiers/bundle.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Cie
+    module Identifiers
+      # Bundle identifier for CIE: a comma-separated list of sibling documents,
+      # each a full CIE identifier (typically a Supplement).
+      # Example: CIE 198-SP1.1:2011,198-SP1.2:2011,198-SP1.3:2011,198-SP1.4:2011
+      #
+      # A CIE bundle is the parts of one supplement of one standard, so its
+      # members share a base document. That shared +base+ is hoisted to the
+      # bundle and the +ids+ carry only what differs (supplement number/part);
+      # #root walks +base+ to the origin standard for the relaton-index key.
+      # (Defensive: if members ever don't share a base, each id keeps its own
+      # and +base+ is nil — see Builder#build_bundle.)
+      class Bundle < SingleIdentifier
+        attribute :base, Identifier, polymorphic: true
+        attribute :ids, Identifier, polymorphic: true, collection: true
+
+        # The origin document: the shared base's root, else the first member's.
+        def root
+          (base || ids&.first)&.root || self
+        end
+
+        # The printed form writes the publisher once: the first member keeps its
+        # "CIE " prefix, the rest are bare. A base-less member is re-based onto
+        # the bundle's shared base for rendering.
+        def to_s(**opts)
+          return "" unless ids&.any?
+
+          result = ids.each_with_index.map do |id, i|
+            member = id.base ? id : rebased(id)
+            i.zero? ? member.to_s : member.to_s.delete_prefix("CIE ")
+          end.join(",")
+
+          annotate_plain_render(result, **opts)
+        end
+
+        private
+
+        # Attach the bundle's shared base to a base-less member for rendering.
+        def rebased(id)
+          Supplement.new(base: base, number: id.number, part: id.part)
+        end
+      end
+    end
+  end
+end