pubid 1.15.17 → 2.0.0.pre.alpha.1

data/lib/pubid/csa/urn_generator.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Csa
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def urn_publisher_prefix
+        return nil unless identifier.publisher_prefix
+
+        identifier.publisher_prefix.to_s.downcase
+      end
+
+      def urn_number
+        return nil unless identifier.code
+
+        identifier.code.value.to_s
+      end
+
+      def urn_no_number
+        "no.#{identifier.no_number}" if identifier.no_number
+      end
+
+      def urn_series
+        "series.#{identifier.series}" if identifier.series
+      end
+
+      def urn_series_prefix
+        "series.#{identifier.series_prefix}" if identifier.series_prefix
+      end
+
+      def urn_year_csa
+        return nil unless identifier.year
+
+        year = identifier.year.to_s
+        year = year[-2..] if year.length == 4 && year.start_with?("20")
+        year
+      end
+
+      def urn_reaffirmation
+        "reaff.#{identifier.reaffirmation}" if identifier.reaffirmation
+      end
+
+      def urn_package
+        "pkg.#{identifier.package}" if identifier.package
+      end
+
+      def urn_year_format
+        "format.dash" if identifier.year_format == "dash"
+      end
+
+      def urn_french
+        "french" if identifier.french
+      end
+
+      def generate
+        parts = ["urn", "csa"]
+
+        prefix = urn_publisher_prefix || "csa"
+        parts << prefix
+
+        parts << urn_number if urn_number
+        parts << urn_no_number if urn_no_number
+        parts << urn_series if urn_series
+        parts << urn_series_prefix if urn_series_prefix
+
+        year = urn_year_csa
+        if year
+          year = "#{identifier.year_prefix}#{year}" if identifier.year_prefix
+          parts << year
+        end
+
+        parts << urn_reaffirmation if urn_reaffirmation
+        parts << urn_package if urn_package
+        parts << urn_year_format if urn_year_format
+        parts << urn_french if urn_french
+
+        parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/csa/wrapper_identifier.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Csa
+    # WrapperIdentifier is the base class for all CSA identifiers that wrap other identifiers
+    # Examples:
+    #   - CanadianAdoptedIdentifier: CAN/{wrapped_identifier}
+    #   - CsaAdoptedIdentifier: CSA {ISO/IEC/CISPR identifier}
+    #
+    # The wrapper pattern allows proper MODEL-DRIVEN architecture where adoptions
+    # are objects that contain other identifier objects, not string prefixes.
+    class WrapperIdentifier < Lutaml::Model::Serializable
+      # The wrapped identifier (recursively parsed)
+      # Use attr_accessor since it can be any identifier object (CSA, ISO, IEC, etc.)
+      attr_accessor :wrapped_identifier
+
+      # Reaffirmation year (common across wrappers)
+      attribute :reaffirmation, :string
+
+      # Year format tracking (for compatibility)
+      attribute :year_format, :string
+
+      # Subclasses MUST implement to_s
+      def to_s
+        raise NotImplementedError, "Subclasses must implement to_s method"
+      end
+    end
+  end
+end

data/lib/pubid/csa.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Csa
+    autoload :Builder, "#{__dir__}/csa/builder"
+    autoload :Identifier, "#{__dir__}/csa/identifier"
+    autoload :Identifiers, "#{__dir__}/csa/identifiers"
+    autoload :Parser, "#{__dir__}/csa/parser"
+    autoload :Scheme, "#{__dir__}/csa/scheme"
+    autoload :SingleIdentifier, "#{__dir__}/csa/single_identifier"
+    autoload :UrnGenerator, "#{__dir__}/csa/urn_generator"
+    autoload :WrapperIdentifier, "#{__dir__}/csa/wrapper_identifier"
+    autoload :CompositeIdentifier, "#{__dir__}/csa/composite_identifier"
+    autoload :Components, "#{__dir__}/csa/components"
+
+    def self.parse(identifier_string)
+      Identifier.parse(identifier_string)
+    end
+  end
+
+  # Register this flavor with the Pubid registry
+end
+
+# Register Ucsa flavor with the registry
+Pubid::Registry.register(:csa, Pubid::Csa)

data/lib/pubid/etsi/builder.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Etsi
+    class Builder
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
+
+      def build(data)
+        # Check if supplements are present
+        if data[:supplements]
+          build_with_supplements(data)
+        else
+          build_etsi_standard(data)
+        end
+      end
+
+      private
+
+      def build_with_supplements(data)
+        # Build base identifier first (without supplements)
+        base_data = data.dup
+        base_data.delete(:supplements)
+        base = build_etsi_standard(base_data)
+
+        # Process supplements - create supplement objects wrapping the base
+        supplements_array = data[:supplements]
+        supplements_array = [supplements_array] unless supplements_array.is_a?(Array)
+
+        # Build supplements recursively - each wraps the previous
+        supplements_array.reduce(base) do |current_base, supp|
+          if supp[:amendment]
+            Identifiers::Amendment.new(
+              base: current_base,
+              number: supp[:amendment][:number].to_i,
+            )
+          elsif supp[:corrigendum]
+            Identifiers::Corrigendum.new(
+              base: current_base,
+              number: supp[:corrigendum][:number].to_i,
+            )
+          else
+            current_base # Skip unknown supplement types
+          end
+        end
+      end
+
+      def build_etsi_standard(data)
+        # Build components
+        code = build_code(data)
+        version = build_version(data)
+        date = build_date(data)
+
+        Identifiers::EtsiStandard.new(
+          type: data[:type].to_s,
+          code: code,
+          version: version,
+          date: date,
+        )
+      end
+
+      def build_code(data)
+        number_data = data[:number]
+
+        # Extract number string based on format
+        number = if number_data.is_a?(Hash)
+                   # Captured format
+                   if number_data[:gsm_prefix]
+                     # GSM with space: "GSM 11.14"
+                     "GSM #{number_data[:main]}.#{number_data[:sub]}"
+                   elsif number_data[:main] && number_data[:sub]
+                     # Dotted format: "11.40"
+                     "#{number_data[:main]}.#{number_data[:sub]}"
+                   elsif number_data[:prefix1]
+                     # Complex format: "ABC 123" or "ABC-DEF 123"
+                     prefix = number_data[:prefix1].to_s
+                     prefix += "-#{number_data[:prefix2]}" if number_data[:prefix2]
+                     "#{prefix} #{number_data[:num]}"
+                   else
+                     # Simple with capture
+                     number_data[:num].to_s
+                   end
+                 else
+                   number_data.to_s
+                 end
+
+        parts = extract_parts(data[:parts])
+
+        Components::Code.new(
+          number: number,
+          minor: data[:minor]&.to_s,
+          parts: parts,
+        )
+      end
+
+      def build_version(data)
+        # Handle both version and edition
+        if data[:version]
+          Components::Version.new(version: data[:version].to_s,
+                                  is_edition: false)
+        elsif data[:edition]
+          Components::Version.new(version: data[:edition].to_s,
+                                  is_edition: true)
+        else
+          Components::Version.new(version: "1.0.0", is_edition: false)
+        end
+      end
+
+      def build_date(data)
+        Pubid::Components::Date.new(
+          year: data[:year].to_s,
+          month: data[:month].to_s,
+        )
+      end
+
+      def extract_parts(parts_data)
+        return [] unless parts_data
+
+        parts = []
+        if parts_data.is_a?(Array)
+          parts_data.each do |part_hash|
+            parts << part_hash[:part].to_s if part_hash[:part]
+          end
+        elsif parts_data.is_a?(Hash) && parts_data[:part]
+          parts << parts_data[:part].to_s
+        end
+
+        parts
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Etsi
+    module Components
+      # Represents an ETSI code with complex number formats
+      # Handles three variants:
+      #   Simple: 012, 123, 456
+      #   GSM: GSM 02.01, 02.01
+      #   Complex: ABC 123, ABC-DEF 123
+      class Code < Lutaml::Model::Serializable
+        attribute :number, :string  # Main number (can contain dots, letters, etc.)
+        attribute :minor, :string   # Optional minor part
+        attribute :parts, :string, collection: true # Parts array
+
+        def initialize(number:, minor: nil, parts: nil)
+          @number = number
+          @minor = minor
+          @parts = parts || []
+        end
+
+        # Render code with space for minor and dash-separated parts
+        def to_s
+          result = number.to_s
+          result += " #{minor}" if minor
+          result += parts.map { |p| "-#{p}" }.join if parts&.any?
+          result
+        end
+
+        def ==(other)
+          return false unless other.is_a?(Code)
+
+          number == other.number &&
+            minor == other.minor &&
+            parts == other.parts
+        end
+      end
+    end
+  end
+end

data/lib/pubid/etsi/components/version.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Etsi
+    module Components
+      # Represents an ETSI version string
+      # Format: V1.2.3, V2.0.0, or ed.1
+      class Version < Lutaml::Model::Serializable
+        attribute :version, :string # e.g., "1.1.1", "2.0.0", "1"
+        attribute :is_edition, :boolean, default: -> {
+          false
+        } # true for ed.N format
+
+        def initialize(version:, is_edition: false)
+          @version = version
+          @is_edition = is_edition
+        end
+
+        def to_s
+          if is_edition
+            "ed.#{version}"
+          else
+            "V#{version}"
+          end
+        end
+
+        def ==(other)
+          return false unless other.is_a?(Version)
+
+          version == other.version && is_edition == other.is_edition
+        end
+      end
+    end
+  end
+end

data/lib/pubid/etsi/components.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Etsi
+    module Components
+      autoload :Code, "#{__dir__}/components/code"
+      autoload :Version, "#{__dir__}/components/version"
+    end
+  end
+end

data/lib/pubid/etsi/identifier.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Etsi
+    class Identifier
+      def self.parse(identifier)
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse ETSI identifier '#{identifier}': #{e.message}"
+      end
+    end
+  end
+end

data/lib/pubid/etsi/identifiers/amendment.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Etsi
+    module Identifiers
+      # ETSI Amendment
+      # Format: {base}/A{number}
+      class Amendment < SupplementIdentifier
+        def supplement_notation
+          "A#{number}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Etsi
+    module Identifiers
+      # Base class for all ETSI identifiers
+      class Base < Pubid::Identifier
+        # Generate URN for this identifier
+        #
+        # @return [String] URN representation
+        attribute :type, :string
+        attribute :code, Pubid::Etsi::Components::Code
+        attribute :version, Pubid::Etsi::Components::Version
+        attribute :date, Pubid::Components::Date
+
+        def publisher
+          "ETSI"
+        end
+
+        def to_s
+          result = "#{publisher} #{type} #{code}"
+          result += " #{version} (#{date.year}-#{date.month.to_s.rjust(2,
+                                                                       '0')})"
+          result
+        end
+
+        def ==(other)
+          return false unless other.is_a?(Base)
+
+          type == other.type &&
+            code == other.code &&
+            version == other.version &&
+            date == other.date
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Etsi
+    module Identifiers
+      # ETSI Corrigendum
+      # Format: {base}/C{number}
+      class Corrigendum < SupplementIdentifier
+        def supplement_notation
+          "C#{number}"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/etsi/identifiers/etsi_standard.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Etsi
+    module Identifiers
+      # Single class for all ETSI standard types
+      # Type is passed as parameter: EN, ES, EG, TS, ETR, ETS, I-ETS, TBR, TCRTR, NET, GR, GS, SR, TR, GTS
+      # Format: ETSI TYPE CODE VERSION (DATE)
+      # Examples:
+      #   ETSI GS ZSM 012 V1.1.1 (2022-12)
+      #   ETSI GR ZSM 009-3 V1.1.1 (2023-08)
+      #   ETSI GTS GSM 02.01 V5.5.0 (1999-01)
+      class EtsiStandard < Base
+        # Type is stored in @type attribute from Base
+        # All rendering handled by Base class
+      end
+    end
+  end
+end

data/lib/pubid/etsi/identifiers/supplement_identifier.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Etsi
+    module Identifiers
+      # Base class for ETSI supplements (Amendment, Corrigendum)
+      class SupplementIdentifier < Base
+        attribute :base, Pubid::Etsi::Identifiers::Base
+        attribute :number, :integer
+
+        # Inherit attributes from base
+        def type
+          base.type
+        end
+
+        def code
+          base.code
+        end
+
+        def version
+          base.version
+        end
+
+        def date
+          base.date
+        end
+
+        # Render as: ETSI TYPE CODE/SUPPLEMENTS VERSION (DATE)
+        # When multiple supplements are present, they appear in order: /A1/C1
+        def to_s
+          supplement_notations = collect_supplement_notations(self, [])
+          # Get the actual base ETSI standard (not supplements)
+          actual_base = find_actual_base(base)
+          code_with_supplements = "#{actual_base.code}#{supplement_notations.join}"
+          "#{actual_base.publisher} #{actual_base.type} #{code_with_supplements} #{actual_base.version} (#{actual_base.date.year}-#{actual_base.date.month.to_s.rjust(
+            2, '0'
+          )})"
+        end
+
+        # Recursively collect supplement notations from the supplement chain
+        def collect_supplement_notations(current_supplement, notations)
+          if current_supplement.is_a?(SupplementIdentifier)
+            # Add this supplement's notation at the beginning (because supplements wrap from outside in)
+            notations.unshift("/#{current_supplement.supplement_notation}")
+            # Continue collecting from the base if it's also a supplement
+            if current_supplement.base.is_a?(SupplementIdentifier)
+              collect_supplement_notations(current_supplement.base, notations)
+            else
+              notations
+            end
+          else
+            notations
+          end
+        end
+
+        # Find the actual base ETSI standard (not supplements)
+        def find_actual_base(current_base)
+          if current_base.is_a?(SupplementIdentifier)
+            find_actual_base(current_base.base)
+          else
+            current_base
+          end
+        end
+
+        def supplement_notation
+          raise NotImplementedError
+        end
+
+        def ==(other)
+          return false unless other.is_a?(SupplementIdentifier)
+          return false unless other.class == self.class
+
+          base == other.base && number == other.number
+        end
+
+        # Include supplement notation in serialization
+        def base_hash
+          hash = super
+          # ETSI supplements need the type (e.g., "ETS", "TR") from the base document
+          if base.class.attributes.key?(:type) && base.type
+            hash[:type] =
+              base.type
+          end
+          hash[:supplement_notation] = supplement_notation
+          hash[:supplement_type] = self.class.name.split("::").last.downcase
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/pubid/etsi/identifiers.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Etsi
+    module Identifiers
+      autoload :Amendment, "#{__dir__}/identifiers/amendment"
+      autoload :Base, "#{__dir__}/identifiers/base"
+      autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
+      autoload :EtsiStandard, "#{__dir__}/identifiers/etsi_standard"
+      autoload :SupplementIdentifier,
+               "#{__dir__}/identifiers/supplement_identifier"
+    end
+  end
+end