pubid 2.0.0.pre.alpha.2 → 2.0.0.pre.alpha.4

data/lib/pubid/core/update_codes.rb

@@ -15,18 +15,24 @@ module Pubid
     #
     # Format in YAML files:
     #   plain string match: "IEC 60285-/1:1989"  →  "IEC 60285-1:1989"
-    #   regex match:        "/^NBS CIRC sup$/"  →  "NBS CIRC 24e7sup"
+    #   regex match:        "/^NBS CIRC sup$/"   →  "NBS CIRC 24e7sup"
+    #   regex with flags:   "/^nbs\\b/i"          →  "NBS"
     #
     # Plain strings use full-line anchoring (^pattern$).
-    # Regex patterns are wrapped in /.../ slashes.
+    # Regex patterns are wrapped in /.../ slashes with optional trailing flags
+    # (i = IGNORECASE, m = MULTILINE, x = EXTENDED) and applied via gsub.
     class UpdateCodes
       DATA_DIR = Pathname.new(__dir__).join("../../../data").expand_path
 
+      # Regex literal: /body/flags  where flags is optional (i, m, x).
+      REGEX_LITERAL = %r{\A/(.*)/([imx]*)\z}m
+
       class << self
         # Apply update_codes substitutions for the given flavor.
         #
         # @param code [String] identifier string to normalize
-        # @param flavor [Symbol, String] flavor name (e.g., :iso, :iec, :ieee, :nist)
+        # @param flavor [Symbol, String] flavor name
+        #   (e.g., :iso, :iec, :ieee, :nist)
         # @return [String] normalized identifier string
         #
         # @example
@@ -37,9 +43,7 @@ module Pubid
           return code if codes.nil? || codes.empty?
 
           codes.each do |from, to|
-            code = code.gsub(
-              from.match?(%r{^/.*/$}) ? Regexp.new(from[1..-2]) : /^#{Regexp.escape(from)}$/, to
-            )
+            code = code.gsub(compile_pattern(from), to.to_s)
           end
           code
         end
@@ -56,13 +60,30 @@ module Pubid
 
         # Available flavors that have update_codes files.
         #
-        # @return [Array<Symbol>] list of flavors with data/{flavor}/update_codes.yaml
+        # @return [Array<Symbol>] flavors with data/{flavor}/update_codes.yaml
         def flavors
           @flavors ||= DATA_DIR.children.select(&:directory?).map do |dir|
             dir.basename.to_s.to_sym
           end.select { |f| (DATA_DIR / f.to_s / "update_codes.yaml").exist? }
         end
 
+        # Compile a YAML key into a Regexp. Plain strings are anchored to the
+        # full line; regex literals support optional trailing flags.
+        def compile_pattern(from)
+          match = from.to_s.match(REGEX_LITERAL)
+          return /^#{Regexp.escape(from.to_s)}$/ unless match
+
+          Regexp.new(match[1], compile_options(match[2]))
+        end
+
+        def compile_options(flags)
+          options = 0
+          options |= Regexp::IGNORECASE if flags.include?("i")
+          options |= Regexp::MULTILINE if flags.include?("m")
+          options |= Regexp::EXTENDED if flags.include?("x")
+          options
+        end
+
         private
 
         def load_yaml(flavor)

data/lib/pubid/csa/identifier.rb

@@ -2,64 +2,17 @@
 
 module Pubid
   module Csa
-    class Identifier
-      # Factory that builds a CSA identifier from a hash of primitives.
-      # Default is {Identifiers::Standard}.
-      TYPE_KEY_TO_KLASS = {
-        standard:         "Standard",
-        bundled:          "Bundled",
-        canadian_adopted: "CanadianAdopted",
-        cec:              "Cec",
-        combined:         "Combined",
-        csa_adopted:      "CsaAdopted",
-        package:          "Package",
-        series:           "Series",
-      }.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 CSA type: #{type.inspect}" unless klass_name
-
-        Identifiers.const_get(klass_name)
-      end
-
-      def self.coerce_create_attrs(opts, klass:)
-        attrs = {}
-
-        if (v = opts[:code] || opts[:number])
-          attrs[:code] = Pubid::Components::Code.new(value: v.to_s)
-        end
-
-        if opts[:year]
-          year_str = opts[:year].to_s
-          attrs[:year] = year_str
-          # Preserve 4-digit year rendering (e.g. "B51:2024") rather than
-          # collapsing to "B51:24".
-          attrs[:original_year_4digit] = year_str.length == 4 unless opts.key?(:original_year_4digit)
+    # Common base class for all CSA identifiers. SingleIdentifier (and the
+    # concrete Identifiers::* types through it) descends from it, so every CSA
+    # identifier is `is_a?(Pubid::Csa::Identifier)` natively and gets the shared
+    # polymorphic `from_hash`. (The Wrapper/Composite container models are
+    # separate Lutaml::Model types, not identifiers.)
+    class Identifier < ::Pubid::Identifier
+      def self.parse(input)
+        if input.length > Pubid::MAX_INPUT_LENGTH
+          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
-        attrs[:original_year_4digit] = opts[:original_year_4digit] if opts.key?(:original_year_4digit)
-        attrs[:year_format] = opts[:year_format].to_s if opts[:year_format]
-        attrs[:year_prefix] = opts[:year_prefix].to_s if opts[:year_prefix]
-        attrs[:reaffirmation] = opts[:reaffirmation].to_s if opts[:reaffirmation]
-        attrs[:french] = opts[:french] if opts.key?(:french)
-        attrs[:has_publisher] = opts.fetch(:has_publisher, true)
-        attrs[:publisher_prefix] = opts[:publisher_prefix].to_s if opts[:publisher_prefix]
-        attrs[:series_prefix] = opts[:series_prefix].to_s if opts[:series_prefix]
-        attrs[:series] = opts[:series] if opts.key?(:series) && [true, false].include?(opts[:series])
-        attrs[:package] = opts[:package].to_s if opts[:package]
-        attrs[:no_number] = opts[:no_number].to_s if opts[:no_number]
-        attrs
-      end
-      private_class_method :resolve_create_class, :coerce_create_attrs
 
-      def self.parse(input)
         # Filter out comments
         return nil if input.start_with?("#")
 
@@ -483,9 +436,6 @@ module Pubid
       end
 
       def self.parse_external_standard(input)
-        # Ensure full Pubid is loaded (handles Scheme and all flavors)
-        require_relative "../../pubid" unless defined?(Pubid::Iso) && defined?(Pubid::Iec)
-
         # Try ISO/IEC first (most common)
         if input.match?(/^(ISO\/IEC|ISO|IEC|CEI|CEI\/IEC)\s/)
           begin

data/lib/pubid/csa/identifiers/base.rb

@@ -4,129 +4,6 @@ module Pubid
   module Csa
     module Identifiers
       class Base < SingleIdentifier
-        def to_s
-          prefix = publisher_prefix || "CSA"
-
-          # Handle code_only identifiers (empty string means no prefix)
-          if prefix == ""
-            # No prefix for code_only identifiers
-            parts = []
-          else
-            # Determine if we need space after prefix
-            # CAN/CSA- and CAN3- end with dash, so no space needed
-            needs_space = !prefix.end_with?("-")
-
-            parts = []
-            parts << prefix
-          end
-
-          # Code and year together
-          code_part = code.to_s if code
-
-          # NO. keyword
-          if no_number
-            code_part += " NO. #{no_number}"
-          end
-
-          # Series prefix and keyword (before year)
-          if series_prefix
-            code_part += " #{series_prefix} SERIES"
-          elsif series
-            # SERIES without prefix
-            code_part += " SERIES"
-          end
-
-          parts << code_part if code_part
-
-          # Year with proper format (colon or dash)
-          if year
-            # Use dash if year_format is dash, otherwise colon
-            separator = year_format == "dash" ? "-" : ":"
-            year_part = separator
-            year_part += year_prefix if year_prefix # Add M or F prefix
-            year_part += "F" if french && year_format != "dash" && !year_prefix # Only add F if no prefix
-            # Convert 4-digit year back to 2-digit for M/F prefix preservation
-            # M1983 → M83, F1983 → F83, 1983 → 83, 20xx → xx
-            # However, preserve original 4-digit format if the input was 4-digit (original_year_4digit)
-            year_str = year.to_s
-            year_part += if original_year_4digit
-                           # Preserve 4-digit format (e.g., "M1981" stays "M1981")
-                           year_str
-                         elsif year_prefix&.match?(/^[MF]$/) && year_str.length == 4 && year_str.start_with?("19")
-                           # M/F + 4-digit year (1900s) → convert to 2-digit with prefix
-                           year_str[2..3]
-                         elsif year_str.length == 4 && year_str.start_with?("20")
-                           # 2000s → just last 2 digits
-                           year_str[2..3]
-                         elsif year_str.length == 4 && year_str.start_with?("19") && !original_year_4digit
-                           # 1900s with no M/F prefix, but original was 2-digit (e.g., CAN3-Z299.0-86)
-                           # Convert back to 2-digit
-                           year_str[2..3]
-                         else
-                           # Other formats - keep as-is
-                           year_str
-                         end
-            parts[-1] += year_part
-          end
-
-          result = if prefix == ""
-                     # No prefix, just join parts
-                     parts.join(" ")
-                   elsif needs_space
-                     parts.join(" ")
-                   elsif parts.length == 2
-                     # No space after dash-ending prefix - join first two parts directly
-                     # If there are more parts after code, they should still have spaces
-                     parts.join
-                   else
-                     # More than 2 parts shouldn't happen in current design
-                     parts.join
-                   end
-
-          # Reaffirmation - preserve original format and determine spacing
-          if reaffirmation
-            # Check if year was originally 2-digit (original_year_4digit flag)
-            year_was_2digit = !original_year_4digit
-
-            # Check if reaffirmation was originally 4-digit (original_reaffirmation_4digit flag)
-            reaffirmation_was_4digit = original_reaffirmation_4digit
-
-            # Preserve original reaffirmation format
-            # If original was 4-digit, keep as 4-digit
-            # If original was 2-digit, convert from 4-digit storage back to 2-digit
-            reaffirmation_str = if reaffirmation_was_4digit
-                                  # Original was 4-digit, keep as-is
-                                  reaffirmation.to_s
-                                elsif reaffirmation.to_s.length == 4 && reaffirmation.to_s.start_with?(
-                                  "19", "20"
-                                )
-                                  # Original was 2-digit, convert 4-digit storage back to 2-digit
-                                  # (R2004) → (R04), (R1994) → (R94)
-                                  reaffirmation.to_s[2..3]
-                                else
-                                  # Already 2-digit or other format
-                                  reaffirmation.to_s
-                                end
-
-            # Determine spacing based on original formats
-            # Space needed if year is 2-digit and reaffirmation is 4-digit (original format)
-            # No space if both year and reaffirmation are 2-digit, or both are 4-digit
-            if year_was_2digit && reaffirmation_was_4digit
-              # Year was 2-digit, reaffirmation was 4-digit → add space
-              result += " (R#{reaffirmation_str})"
-            else
-              # Both 2-digit, both 4-digit, or other cases → no space
-              result += "(R#{reaffirmation_str})"
-            end
-          end
-
-          # Package (already has leading space from parser)
-          if package
-            result += package
-          end
-
-          result
-        end
       end
     end
   end

data/lib/pubid/csa/identifiers/cec.rb

@@ -20,109 +20,6 @@ module Pubid
 
           @code ||= Components::Code.new(value: "#{cec_part.value}-#{no_number.value}")
         end
-
-        def to_s
-          parts = []
-
-          # Publisher prefix (CSA, CAN/CSA-, CAN3-)
-          prefix = publisher_prefix || "CSA"
-
-          # Determine if we need space after prefix
-          # CAN/CSA- and CAN3- end with dash, so no space needed
-          needs_space = !prefix.end_with?("-")
-
-          parts << prefix unless prefix == ""
-
-          # CEC Part (C22.2, C22.3, etc.)
-          parts << cec_part.value if cec_part
-
-          # NO. notation - this is the key semantic component
-          parts << "NO."
-
-          # Number after NO.
-          parts << no_number.value if no_number
-
-          # Determine separator based on prefix ending
-          result = if prefix == ""
-                     parts.join(" ")
-                   elsif needs_space
-                     parts.join(" ")
-                   elsif parts.length <= 2
-                     # No space after dash-ending prefix (CAN/CSA-, CAN3-)
-                     # Join first two parts directly, rest with spaces
-                     parts.join
-                   else
-                     parts[0] + parts[1..].join(" ")
-                   end
-
-          # Year with proper format (colon or dash)
-          if year
-            # Use dash if year_format is dash, otherwise colon
-            separator = year_format == "dash" ? "-" : ":"
-            year_part = separator
-
-            # Convert 4-digit year back to 2-digit for display
-            year_str = year.to_s
-            display_year = if year_str.length == 4 && year_str.start_with?("20")
-                             year_str[2..3]
-                           elsif year_str.length == 4 && year_str.start_with?("19")
-                             year_str[2..3]
-                           else
-                             year_str
-                           end
-
-            # Add prefix if present
-            year_part += if year_prefix
-                           year_prefix + display_year
-                         elsif french && year_format != "dash"
-                           # Only add F if no prefix already set
-                           "F#{display_year}"
-                         else
-                           display_year
-                         end
-
-            result += year_part
-          end
-
-          # Reaffirmation - preserve original format and determine spacing
-          if reaffirmation
-            # Check if year was originally 2-digit (original_year_4digit flag)
-            year_was_2digit = !original_year_4digit
-
-            # Check if reaffirmation was originally 4-digit (original_reaffirmation_4digit flag)
-            reaffirmation_was_4digit = original_reaffirmation_4digit
-
-            # Preserve original reaffirmation format
-            # If original was 4-digit, keep as 4-digit
-            # If original was 2-digit, convert from 4-digit storage back to 2-digit
-            reaffirmation_str = if reaffirmation_was_4digit
-                                  # Original was 4-digit, keep as-is
-                                  reaffirmation.to_s
-                                elsif reaffirmation.to_s.length == 4 && reaffirmation.to_s.start_with?(
-                                  "19", "20"
-                                )
-                                  # Original was 2-digit, convert 4-digit storage back to 2-digit
-                                  # (R2004) → (R04), (R1994) → (R94)
-                                  reaffirmation.to_s[2..3]
-                                else
-                                  # Already 2-digit or other format
-                                  reaffirmation.to_s
-                                end
-
-            # Determine spacing based on original formats
-            # Space needed if year is 2-digit and reaffirmation is 4-digit (original format)
-            # No space if both year and reaffirmation are 2-digit, or both are 4-digit
-            if year_was_2digit && reaffirmation_was_4digit
-              # Year was 2-digit, reaffirmation was 4-digit → add space
-              result += " (R#{reaffirmation_str})"
-            else
-              # Both 2-digit, both 4-digit, or other cases → no space
-              result += "(R#{reaffirmation_str})"
-            end
-          end
-
-          result
-        end
       end
     end
   end

data/lib/pubid/csa/identifiers/series.rb

@@ -17,110 +17,6 @@ module Pubid
       class Series < Base
         # Series prefix (MH, RV, etc.) - optional
         attribute :series_prefix, :string
-
-        def to_s
-          result = publisher_prefix_portion
-
-          # Add code FIRST (before SERIES keyword)
-          result += code.to_s
-
-          # Add space before series prefix/SERIES keyword
-          result += " "
-
-          # Add series prefix if present
-          result += "#{series_prefix} " if series_prefix && !series_prefix.empty?
-
-          # Add SERIES keyword
-          result += "SERIES"
-
-          # Add year
-          result += year_portion
-
-          # Add language
-          result += language_portion
-
-          # Add reaffirmation
-          result += reaffirmation_portion
-
-          result
-        end
-
-        private
-
-        def publisher_prefix_portion
-          prefix = publisher_prefix || "CSA"
-
-          # Handle code_only identifiers (empty string means no prefix)
-          return "" if prefix == ""
-
-          # Determine if we need space after prefix
-          # CAN/CSA- and CAN3- end with dash, so no space needed
-          needs_space = !prefix.end_with?("-")
-
-          needs_space ? "#{prefix} " : prefix
-        end
-
-        def year_portion
-          return "" unless year
-
-          # Use dash if year_format is dash, otherwise colon
-          separator = year_format == "dash" ? "-" : ":"
-          year_part = separator
-          year_part += year_prefix if year_prefix # Add M or F prefix
-          year_part += "F" if french && year_format != "dash" && !year_prefix # Only add F if no prefix
-
-          # Convert 4-digit year back to 2-digit
-          year_str = year.to_s
-          year_part += if year_str.length == 4 && year_str.start_with?("20")
-                         year_str[2..3]
-                       else
-                         year_str
-                       end
-
-          year_part
-        end
-
-        def language_portion
-          "" # CSA doesn't use language codes in rendering
-        end
-
-        def reaffirmation_portion
-          return "" unless reaffirmation
-
-          # Check if year was originally 2-digit (original_year_4digit flag)
-          year_was_2digit = !original_year_4digit
-
-          # Check if reaffirmation was originally 4-digit (original_reaffirmation_4digit flag)
-          reaffirmation_was_4digit = original_reaffirmation_4digit
-
-          # Preserve original reaffirmation format
-          # If original was 4-digit, keep as 4-digit
-          # If original was 2-digit, convert from 4-digit storage back to 2-digit
-          reaffirmation_str = if reaffirmation_was_4digit
-                                # Original was 4-digit, keep as-is
-                                reaffirmation.to_s
-                              elsif reaffirmation.to_s.length == 4 && reaffirmation.to_s.start_with?(
-                                "19", "20"
-                              )
-                                # Original was 2-digit, convert 4-digit storage back to 2-digit
-                                # (R2004) → (R04), (R1994) → (R94)
-                                reaffirmation.to_s[2..3]
-                              else
-                                # Already 2-digit or other format
-                                reaffirmation.to_s
-                              end
-
-          # Determine spacing based on original formats
-          # Space needed if year is 2-digit and reaffirmation is 4-digit (original format)
-          # No space if both year and reaffirmation are 2-digit, or both are 4-digit
-          if year_was_2digit && reaffirmation_was_4digit
-            # Year was 2-digit, reaffirmation was 4-digit → add space
-            " (R#{reaffirmation_str})"
-          else
-            # Both 2-digit, both 4-digit, or other cases → no space
-            "(R#{reaffirmation_str})"
-          end
-        end
       end
     end
   end