pubid 1.15.19 → 2.0.0.pre.alpha.2

data/lib/pubid/cie/builder.rb

@@ -0,0 +1,399 @@
+# 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)
+
+        # Extract attributes with style detection
+        attributes = extract_attributes(parsed_hash)
+
+        # For Bundle identifier, store original string
+        if parsed_hash[:bundle_items] && original_string
+          attributes[:identifiers_string] = original_string
+        end
+
+        # Construct identifier
+        identifier_class.new(**attributes)
+      end
+
+      private
+
+      # 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
+
+        # 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
+
+        # Detect style from date separator
+        style = if date_sep == "colon"
+                  "current"
+                else
+                  (date_sep == "dash" ? "legacy" : detect_style_fallback(parsed_hash))
+                end
+        attributes[:style] = style
+
+        # Set year and separator if present
+        attributes[:year] = year_value if year_value
+        attributes[:date_separator] = date_sep if date_sep
+
+        # Extract code
+        if parsed_hash[:number]
+          code_attrs = { number: extract_value(parsed_hash[:number]),
+                         style: style }
+          if parsed_hash[:part]
+            code_attrs[:part] =
+              extract_value(parsed_hash[:part])
+          end
+          if parsed_hash[:iteration]
+            code_attrs[:iteration] =
+              extract_value(parsed_hash[:iteration])
+          end
+
+          # Detect part separator from parser markers
+          if parsed_hash[:slash_sep]
+            code_attrs[:part_separator] = "slash"
+          elsif parsed_hash[:dash_sep]
+            code_attrs[:part_separator] = "dash"
+          end
+
+          attributes[:code] = Components::Code.new(**code_attrs)
+        end
+
+        # Conference number (separate from regular code)
+        if parsed_hash[:conf_number]
+          attributes[:conference_number] =
+            extract_value(parsed_hash[:conf_number])
+        end
+
+        # 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
+
+        # Extract bundle data
+        if parsed_hash[:bundle_number]
+          attributes[:bundle_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/code.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Cie
+    module Components
+      # Code component for CIE identifiers
+      # Handles number-part-iteration with style awareness
+      class Code < Lutaml::Model::Serializable
+        attribute :number, :string        # "013", "170", "198"
+        attribute :part, :string          # "1", "2", "3"
+        attribute :iteration, :string     # "1" in "006.1"
+        attribute :style, :string         # "legacy" or "current"
+        attribute :part_separator, :string # "slash" or "dash" (preserves original)
+
+        def to_s
+          result = number
+
+          # Handle part AND iteration together (e.g., "19/2.1")
+          if part && iteration
+            # Use slash for part, then dot for iteration
+            result += "/#{part}.#{iteration}"
+          # Handle iteration only (e.g., "006.1", "13.3")
+          elsif iteration
+            result += ".#{iteration}"
+          # Handle part only (separator depends on part_separator or style)
+          elsif part
+            # Use part_separator if explicitly set (preserves original)
+            # Otherwise fall back to style-based separator
+            separator = case part_separator
+                        when "slash"
+                          "/"
+                        when "dash"
+                          "-"
+                        else
+                          # Legacy: slash "/" (e.g., "170/1")
+                          # Current: dash "-" (e.g., "170-1")
+                          style == "legacy" ? "/" : "-"
+                        end
+            result += "#{separator}#{part}"
+          end
+
+          result
+        end
+
+        # Parse code string with style detection
+        def self.parse(code_str, style: :current)
+          return nil if code_str.nil? || code_str.strip.empty?
+
+          # Detect iteration format (dot separator)
+          if code_str.include?(".")
+            parts = code_str.split(".")
+            new(number: parts[0], iteration: parts[1], style: style)
+          # Detect part with separator
+          elsif code_str.include?("/")
+            parts = code_str.split("/")
+            new(number: parts[0], part: parts[1], style: "legacy",
+                part_separator: "slash")
+          elsif code_str.include?("-")
+            parts = code_str.split("-", 2) # Limit to 2 parts
+            new(number: parts[0], part: parts[1], style: "current",
+                part_separator: "dash")
+          # Simple number
+          else
+            new(number: code_str, style: style)
+          end
+        end
+      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,71 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Cie
+    # Base Identifier class for CIE
+    # Provides parse() entry point
+    class Identifier < Lutaml::Model::Serializable
+      attribute :style, :string # "legacy" or "current"
+
+      # Parse CIE identifier string
+      def self.parse(input)
+        parsed = Parser.parse(input)
+        builder = Builder.new
+        builder.build(parsed, original_string: input)
+      end
+
+      # Factory that builds a CIE identifier from a hash of primitives.
+      # Dispatch on `:type` to a SingleIdentifier subclass; default is
+      # {Identifiers::Standard}.
+      TYPE_KEY_TO_KLASS = {
+        standard:        "Standard",
+        conference:      "Conference",
+        bundle:          "Bundle",
+        joint_published: "JointPublished",
+        dual_published:  "DualPublished",
+        identical:       "Identical",
+        tutorial_bundle: "TutorialBundle",
+      }.freeze
+
+      def self.create(type: nil, **opts)
+        klass = resolve_create_class(type)
+        klass.new(**coerce_create_attrs(opts, klass: klass))
+      end
+
+      def self.resolve_create_class(type)
+        return Identifiers::Standard if type.nil?
+
+        klass_name = TYPE_KEY_TO_KLASS[type.to_sym]
+        raise ArgumentError, "Unknown CIE type: #{type.inspect}" unless klass_name
+
+        Identifiers.const_get(klass_name)
+      end
+
+      def self.coerce_create_attrs(opts, klass:)
+        attrs = {}
+        attrs[:year] = opts[:year].to_s if opts[:year]
+        attrs[:date_separator] = opts[:date_separator].to_s if opts[:date_separator]
+
+        if (v = opts[:code] || opts[:number])
+          attrs[:code] = Pubid::Cie::Components::Code.new(
+            number:         v.to_s,
+            part:           opts[:part]&.to_s,
+            iteration:      opts[:iteration]&.to_s,
+            style:          opts[:style]&.to_s,
+            part_separator: opts[:part_separator]&.to_s,
+          )
+        end
+
+        # Standard-only attributes
+        if klass.attributes.key?(:s_prefix) && opts.key?(:s_prefix)
+          attrs[:s_prefix] = opts[:s_prefix]
+        end
+        if klass.attributes.key?(:stage) && opts[:stage]
+          attrs[:stage] = opts[:stage].to_s
+        end
+        attrs
+      end
+      private_class_method :resolve_create_class, :coerce_create_attrs
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Cie
+    module Identifiers
+      # Bundle identifier for CIE
+      # Handles comma-separated supplement lists
+      # Example: CIE 198-SP1.1:2011,198-SP1.2:2011,198-SP1.3:2011,198-SP1.4:2011
+      class Bundle < SingleIdentifier
+        attribute :identifiers_string, :string # Store as string for now
+
+        def to_s
+          identifiers_string || ""
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Cie
+    module Identifiers
+      # Conference identifier for CIE
+      # Handles x-prefix conference proceedings
+      # Example: CIE x038:2013, CIE x038:2013 Amendment 1
+      class Conference < SingleIdentifier
+        attribute :conference_number, :string
+        attribute :amendment_number, :string
+
+        def to_s
+          result = "CIE x#{conference_number}"
+
+          # Date with separator
+          if year
+            separator = date_separator == "colon" ? ":" : "-"
+            result += "#{separator}#{year}"
+          end
+
+          # Amendment if present
+          result += " Amendment #{amendment_number}" if amendment_number
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Cie
+    module Identifiers
+      # Corrigendum identifier for CIE
+      # Handles /CorN notation with recursive base parsing
+      # Examples: CIE 232:2019/Cor1:2020, CIE 198-SP1.4:2011/Cor1:2013
+      class Corrigendum < SupplementIdentifier
+        attribute :base_number, :string
+        attribute :base_year, :string
+        attribute :base_supplement, :string       # If base is a supplement
+        attribute :base_supplement_part, :string  # Part of supplement
+        attribute :cor_number, :string
+        attribute :cor_year, :string
+
+        def to_s
+          # Build base identifier string
+          result = "CIE #{base_number}"
+
+          # Add supplement notation if base is a supplement
+          if base_supplement
+            result += "-SP#{base_supplement}"
+            result += ".#{base_supplement_part}" if base_supplement_part
+          end
+
+          # Add base year with colon
+          result += ":#{base_year}" if base_year
+
+          # Add corrigendum with slash and colon
+          result += "/Cor#{cor_number}:#{cor_year}"
+
+          result
+        end
+      end
+    end
+  end
+end