pubid 1.15.19 → 2.0.0.pre.alpha.2

data/lib/pubid/cen_cenelec/identifiers/cen_report.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module CenCenelec
+    module Identifiers
+      class CenReport < SingleIdentifier
+        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            code: :pubcr,
+            stage_code: :published,
+            type_code: :cr,
+            abbr: ["CR"],
+            name: "CEN Report",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :cr, title: "CEN Report", short: "CR" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cen_cenelec/identifiers/cen_workshop_agreement.rb

@@ -0,0 +1,27 @@
+require "lutaml/model"
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    module Identifiers
+      class CenWorkshopAgreement < SingleIdentifier
+        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            code: :pubcwa,
+            stage_code: :published,
+            type_code: :cwa,
+            abbr: ["CWA"],
+            name: "CEN Workshop Agreement",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :cwa, title: "CEN Workshop Agreement", short: "CWA" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cen_cenelec/identifiers/cenelec_harmonization_document.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module CenCenelec
+    module Identifiers
+      class CenelecHarmonizationDocument < SingleIdentifier
+        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            code: :pubhd,
+            stage_code: :published,
+            type_code: :hd,
+            abbr: ["HD"],
+            name: "CENELEC Harmonization Document",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :hd, title: "CENELEC Harmonization Document", short: "HD" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cen_cenelec/identifiers/consolidated_identifier.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    module Identifiers
+      # Consolidated Identifier - contains base document plus supplements
+      # Example: "EN 196-3:2005+A1:2008" = [EN 196-3:2005, Amendment(base + params)]
+      class ConsolidatedIdentifier < Base
+        attribute :identifiers, Base, polymorphic: true, collection: true
+
+        def to_s
+          identifiers.map.with_index do |id, idx|
+            if idx.zero?
+              # First identifier renders normally
+              id.to_s
+            elsif id.is_a?(Amendment)
+              # Supplements render with "+" prefix (bundled/consolidated format)
+              result = "+A#{id.amendment_number}"
+              result += ":#{id.amendment_year}" if id.amendment_year
+              result
+            # Only render the amendment portion, not the full id.to_s
+            elsif id.is_a?(Corrigendum)
+              # Only render the corrigendum portion
+              result = "+AC"
+              result += id.corrigendum_number if id.corrigendum_number && !id.corrigendum_number.empty?
+              if id.corrigendum_year
+                result += ":#{id.corrigendum_year}"
+                result += "-#{id.corrigendum_month}" if id.corrigendum_month && !id.corrigendum_month.empty?
+              end
+              result
+            else
+              # Other identifiers (should not happen in typical bundles) render with +
+              "+#{id}"
+            end
+          end.compact.join
+        end
+
+        # Delegate to first identifier (base document)
+        def publisher
+          identifiers&.first&.publisher
+        end
+
+        def number
+          identifiers&.first&.number
+        end
+
+        def year
+          identifiers&.first&.year
+        end
+
+        def parts
+          identifiers&.first&.parts
+        end
+
+        def type
+          identifiers&.first&.type
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    module Identifiers
+      # Corrigendum Identifier
+      # Contains a base identifier plus corrigendum parameters
+      class Corrigendum < Base
+        attribute :base_identifier, Base, polymorphic: true
+        attribute :corrigendum_number, :string
+        attribute :corrigendum_year, :integer
+        attribute :corrigendum_month, :string
+
+        def to_s
+          if base_identifier
+            result = base_identifier.to_s
+            result += "/AC"
+            result += corrigendum_number if corrigendum_number && !corrigendum_number.empty?
+          else
+            result = "/AC#{corrigendum_number}"
+          end
+          if corrigendum_year
+            result += ":#{corrigendum_year}"
+            result += "-#{corrigendum_month}" if corrigendum_month && !corrigendum_month.empty?
+          end
+          result
+        end
+
+        def publisher
+          base_identifier&.publisher
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cen_cenelec/identifiers/european_norm.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    module Identifiers
+      # European Norm (EN) identifier
+      class EuropeanNorm < SingleIdentifier
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            code: :puben,
+            stage_code: :published,
+            type_code: :en,
+            abbr: ["EN"],
+            name: "European Norm",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+          Components::TypedStage.new(
+            code: :pren,
+            stage_code: :proposal,
+            type_code: :en,
+            abbr: ["prEN"],
+            name: "Proposal European Norm",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.98 30.99],
+          ),
+          Components::TypedStage.new(
+            code: :fpren,
+            stage_code: :final_proposal,
+            type_code: :en,
+            abbr: ["FprEN"],
+            name: "Final Proposal European Norm",
+            harmonized_stages: %w[40.00 40.20 40.60 40.92 40.98 40.99],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :en, title: "European Norm", short: "EN" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cen_cenelec/identifiers/european_prestandard.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module CenCenelec
+    module Identifiers
+      class EuropeanPrestandard < SingleIdentifier
+        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+        attribute :adopted_identifier, Pubid::Identifier, polymorphic: true
+
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            code: :pubenv,
+            stage_code: :published,
+            type_code: :env,
+            abbr: ["ENV"],
+            name: "European Prestandard",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :env, title: "European Prestandard", short: "ENV" }
+        end
+
+        def to_s(lang: :en, lang_single: false)
+          if adopted_identifier
+            "ENV #{adopted_identifier}"
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cen_cenelec/identifiers/european_specification.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module CenCenelec
+    module Identifiers
+      class EuropeanSpecification < SingleIdentifier
+        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            code: :pubes,
+            stage_code: :published,
+            type_code: :es,
+            abbr: ["ES"],
+            name: "European Specification",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :es, title: "European Specification", short: "ES" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cen_cenelec/identifiers/fragment.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    module Identifiers
+      # Fragment Identifier - wraps an Amendment with a fragment number
+      # Example: "EN 60038 AMD1 FRAG2" = Fragment 2 of Amendment 1 to EN 60038
+      class Fragment < Base
+        attribute :base_identifier, Amendment
+        attribute :fragment_number, :string
+
+        def to_s
+          "#{base_identifier} FRAG#{fragment_number}"
+        end
+
+        def publisher
+          base_identifier&.base_identifier&.publisher
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cen_cenelec/identifiers/guide.rb

@@ -0,0 +1,27 @@
+require "lutaml/model"
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    module Identifiers
+      class Guide < SingleIdentifier
+        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            code: :pubguide,
+            stage_code: :published,
+            type_code: :guide,
+            abbr: ["Guide"],
+            name: "Guide",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :guide, title: "Guide", short: "Guide" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cen_cenelec/identifiers/harmonization_document.rb

@@ -0,0 +1,27 @@
+require "lutaml/model"
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    module Identifiers
+      class HarmonizationDocument < SingleIdentifier
+        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            code: :pubhd,
+            stage_code: :published,
+            type_code: :hd,
+            abbr: ["HD"],
+            name: "Harmonization Document",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :hd, title: "Harmonization Document", short: "HD" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cen_cenelec/identifiers/technical_report.rb

@@ -0,0 +1,27 @@
+require "lutaml/model"
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    module Identifiers
+      class TechnicalReport < SingleIdentifier
+        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            code: :pubtr,
+            stage_code: :published,
+            type_code: :tr,
+            abbr: ["TR"],
+            name: "Technical Report",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :tr, title: "Technical Report", short: "TR" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cen_cenelec/identifiers/technical_specification.rb

@@ -0,0 +1,35 @@
+require "lutaml/model"
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    module Identifiers
+      class TechnicalSpecification < SingleIdentifier
+        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            code: :pubts,
+            stage_code: :published,
+            type_code: :ts,
+            abbr: ["TS"],
+            name: "Technical Specification",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+          Components::TypedStage.new(
+            code: :prts,
+            stage_code: :proposal,
+            type_code: :ts,
+            abbr: ["prTS"],
+            name: "Proposal Technical Specification",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.98 30.99],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :ts, title: "Technical Specification", short: "TS" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cen_cenelec/identifiers.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    module Identifiers
+      autoload :AdoptedEuropeanNorm,
+               "#{__dir__}/identifiers/adopted_european_norm"
+      autoload :Amendment, "#{__dir__}/identifiers/amendment"
+      autoload :Base, "#{__dir__}/identifiers/base"
+      autoload :CENelecHarmonizationDocument,
+               "#{__dir__}/identifiers/cenelec_harmonization_document"
+      autoload :CenReport, "#{__dir__}/identifiers/cen_report"
+      autoload :CenWorkshopAgreement,
+               "#{__dir__}/identifiers/cen_workshop_agreement"
+      autoload :ConsolidatedIdentifier,
+               "#{__dir__}/identifiers/consolidated_identifier"
+      autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
+      autoload :EuropeanNorm, "#{__dir__}/identifiers/european_norm"
+      autoload :EuropeanPrestandard,
+               "#{__dir__}/identifiers/european_prestandard"
+      autoload :EuropeanSpecification,
+               "#{__dir__}/identifiers/european_specification"
+      autoload :Fragment, "#{__dir__}/identifiers/fragment"
+      autoload :Guide, "#{__dir__}/identifiers/guide"
+      autoload :HarmonizationDocument,
+               "#{__dir__}/identifiers/harmonization_document"
+      autoload :TechnicalReport, "#{__dir__}/identifiers/technical_report"
+      autoload :TechnicalSpecification,
+               "#{__dir__}/identifiers/technical_specification"
+    end
+  end
+end

data/lib/pubid/cen_cenelec/parser.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module CenCenelec
+    class Parser < Parslet::Parser
+      rule(:digit) { match["0-9"] }
+      rule(:digits) { digit.repeat(1) }
+      rule(:space) { str(" ") }
+      rule(:dash) { str("-") }
+      rule(:slash) { str("/") }
+      rule(:plus) { str("+") }
+      rule(:colon) { str(":") }
+
+      # Publishers
+      rule(:en) { str("EN") }
+      rule(:cen) { str("CEN") }
+      rule(:clc) { str("CLC") }
+      rule(:cwa) { str("CWA") }
+      rule(:hd) { str("HD") }
+      rule(:es) { str("ES") }
+      rule(:cr) { str("CR") }
+      rule(:env) { str("ENV") }
+
+      # Adopted organizations (ISO, IEC)
+      rule(:iso) { str("ISO") }
+      rule(:iec) { str("IEC") }
+      rule(:cispr) { str("CISPR") }
+
+      # Publisher (can be combined like EN/CLC or CEN/CLC)
+      rule(:publisher) do
+        (cwa | hd | es | cr | env).as(:publisher) |
+          (en.as(:publisher) >> (slash >> clc.as(:copublisher)).maybe) |
+          (cen.as(:publisher) >> (slash >> clc.as(:copublisher)).maybe) |
+          (clc.as(:publisher) >> (slash >> cen.as(:copublisher)).maybe) |
+          en.as(:publisher)
+      end
+
+      # Stage prefixes captured as type_with_stage for proper lookup
+      rule(:stage_prefix) { (str("FprEN") | str("prEN")).as(:type_with_stage) }
+
+      # Type
+      rule(:type) do
+        (str("Guide") | str("GUIDE") | str("TR") | str("TS")).as(:type)
+      end
+
+      # Number
+      rule(:number) { digits.as(:number) }
+
+      # Part (can be multi-level like 1-2 or 80-12)
+      rule(:part) { dash >> match["0-9-"].repeat(1).as(:part) }
+      rule(:parts) { part.repeat(0).as(:parts) }
+
+      # Year
+      rule(:year) { colon >> digit.repeat(4, 4).as(:year) }
+
+      # Month support for dates like 2016-11
+      rule(:month_digits) do
+        (
+          str("01") | str("02") | str("03") | str("04") |
+          str("05") | str("06") | str("07") | str("08") |
+          str("09") | str("10") | str("11") | str("12")
+        ).as(:month)
+      end
+
+      rule(:year_with_month) do
+        colon >> digit.repeat(4, 4).as(:year) >> dash >> month_digits
+      end
+
+      rule(:date) { year_with_month | year }
+
+      # Amendment (+A1:2008 or +A11:2020 or /A2:2019 or /A1 without year)
+      rule(:amendment) do
+        (plus.as(:amd_sep_plus) | slash.as(:amd_sep_slash)) >>
+          str("A") >> digits.as(:amd_number) >>
+          (colon >> digit.repeat(4, 4).as(:amd_year)).maybe
+      end
+
+      # Corrigendum (+AC:2009 or +AC1:2008 or +AC2:2009 or /AC1:2005 or /AC:2016-11 with month)
+      rule(:corrigendum) do
+        (plus.as(:amd_sep_plus) | slash.as(:amd_sep_slash)) >>
+          str("AC") >> digits.maybe.as(:cor_number) >>
+          (year_with_month | (colon >> digit.repeat(4, 4).as(:year))).maybe
+      end
+
+      # Supplements (amendments and corrigenda)
+      rule(:supplement) { (amendment | corrigendum).as(:supplement) }
+      rule(:supplements) { supplement.repeat(0).as(:supplements) }
+
+      # Edition (ED2, ED3, etc.)
+      rule(:edition) { space >> str("ED") >> digits.as(:edition) }
+
+      # Fragment identifier (EN 60038 AMD1 FRAG2)
+      rule(:fragment_identifier) do
+        (stage_prefix | publisher) >>
+          space >> number >> parts >>
+          space >> str("AMD") >> digits.as(:amendment_number) >>
+          space >> str("FRAG") >> digits.as(:fragment_number)
+      end
+
+      # Adopted standard as opaque string - must start with org name
+      rule(:adopted_org_prefix) do
+        str("ISO") | str("IEC") | str("CISPR")
+      end
+
+      rule(:adopted_string) do
+        # Must start with organization name
+        (adopted_org_prefix >> (supplement.absent? >> edition.absent? >> match("[^\n]")).repeat(0)).as(:adopted_string)
+      end
+
+      # Identifier
+      rule(:identifier) do
+        fragment_identifier |
+          ((stage_prefix | publisher) >>
+            (space >> adopted_string).maybe >>
+            ((space >> type) | (slash >> type)).maybe >>
+            (space >> number >> parts >>
+            year.maybe).maybe >>
+            supplements >>
+            edition.maybe)
+      end
+
+      rule(:root) { identifier }
+
+      def self.parse(input)
+        # Normalize special dash characters
+        normalized = input.gsub(/[\u2011\u00AD]/, "-")
+
+        # Remove trailing hash symbols
+        normalized = normalized.gsub(/#.*$/, "").strip
+
+        # Filter out parenthetical notes (case-insensitive, multiple patterns)
+        normalized = normalized.gsub(/\s*\([^)]*corrigendum[^)]*\)/i, "")
+
+        # Normalize dash to slash in publisher combinations
+        normalized = normalized.gsub("CEN-CLC", "CEN/CLC")
+          .gsub("CLC-CEN", "CLC/CEN")
+          .gsub("GUIDE", "Guide")
+        new.parse(normalized)
+      end
+    end
+  end
+end