pubid 1.15.21 → 2.0.0.alpha.10

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

@@ -0,0 +1,40 @@
+# 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
+
+        # 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
+
+        # The origin document. Members live in `identifiers` (not `base`), so
+        # walk the first member to its root.
+        def root
+          identifiers&.first&.root || self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    module Identifiers
+      # Corrigendum Identifier
+      # Contains a base identifier plus corrigendum parameters
+      class Corrigendum < Base
+        attribute :base, Base, polymorphic: true
+        attribute :corrigendum_number, :string
+        attribute :corrigendum_year, :integer
+        attribute :corrigendum_month, :string
+
+        def publisher
+          base&.publisher
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    module Identifiers
+      # European Norm (EN) identifier
+      class EuropeanNorm < SingleIdentifier
+        TYPED_STAGES = [
+          # Published (puben): 60.00-60.60 + publication milestones (65.xx)
+          Components::TypedStage.new(
+            code: :puben,
+            stage_code: :published,
+            type_code: :en,
+            abbr: ["EN"],
+            name: "European Norm",
+            harmonized_stages: %w[60.00 60.55 60.60 65.31 65.51 65.62],
+          ),
+          # Preliminary (pwien): proposal/WI stages
+          Components::TypedStage.new(
+            code: :pwien,
+            stage_code: :preliminary,
+            type_code: :en,
+            abbr: ["pWI EN"],
+            name: "Preliminary Work Item EN",
+            harmonized_stages: %w[00.60 10.98 10.99 20.60],
+          ),
+          # Proposal (pren): working draft stages + split/merge interruption end
+          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.97 30.98 30.99],
+          ),
+          # Final Proposal (fpren): enquiry stages
+          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.97 40.98 40.99],
+          ),
+          # Formal Vote (fven): COCOR + FV dispatch stages
+          Components::TypedStage.new(
+            code: :fven,
+            stage_code: :formal_vote,
+            type_code: :en,
+            abbr: ["FV prEN"],
+            name: "Formal Vote EN",
+            harmonized_stages: %w[43.20 43.60 43.97 43.98 45.97 45.98 45.99],
+          ),
+          # Vote (ven): enquiry/vote stages
+          Components::TypedStage.new(
+            code: :ven,
+            stage_code: :vote,
+            type_code: :en,
+            abbr: ["vEN"],
+            name: "Vote EN",
+            harmonized_stages: %w[50.20 50.60 50.97 50.98],
+          ),
+          # Review (rven): 2-year review stages
+          Components::TypedStage.new(
+            code: :rven,
+            stage_code: :review,
+            type_code: :en,
+            abbr: ["rvEN"],
+            name: "Review EN",
+            harmonized_stages: %w[90.00 90.20 90.60 90.92 90.93 90.98],
+          ),
+          # Reactivation (racen): re-activation stage
+          Components::TypedStage.new(
+            code: :racen,
+            stage_code: :reactivation,
+            type_code: :en,
+            abbr: ["racEN"],
+            name: "Re-activated EN",
+            harmonized_stages: %w[96.60],
+          ),
+          # Withdrawn (wden): withdrawal stage
+          Components::TypedStage.new(
+            code: :wden,
+            stage_code: :withdrawn,
+            type_code: :en,
+            abbr: ["wdEN"],
+            name: "Withdrawn EN",
+            harmonized_stages: %w[99.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :en,
+            web: :european_norm, title: "European Norm", short: "EN" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# 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,
+            web: :european_prestandard, title: "European Prestandard", short: "ENV" }
+        end
+
+        # An "ENV ISO 11079:1999" is a WRAPPER: the whole document identity
+        # lives on the nested `adopted_identifier`, and this class carries no
+        # number of its own, so `root.number` — the key relaton-index sorts and
+        # bsearches on — was "". Walk to the adopted document instead.
+        #
+        # The chain reached further than this flavor: Bsi's
+        # `AdoptedEuropeanNorm#number` delegates INTO this class, so a
+        # "DD ENV ISO 11079:1999" keyed "" for the same reason.
+        #
+        # This is deliberately `#root` and not a `#number` method. `number` is a
+        # lutaml attribute in this hierarchy, and a method of that name collides
+        # with the generated accessor and corrupts attribute resolution
+        # hierarchy-wide (the IEEE landmine in CLAUDE.md). `#root` is a plain
+        # method on ::Pubid::Identifier, and walking a wrapper's member is its
+        # documented shape — ConsolidatedIdentifier already walks
+        # `identifiers.first.root`.
+        def root
+          adopted_identifier ? adopted_identifier.root : self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# 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,
+            web: :european_specification, title: "European Specification", short: "ES" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# 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, Amendment
+        attribute :fragment_number, :string
+
+        def publisher
+          base&.base&.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,28 @@
+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,
+            web: :harmonization_document, title: "Harmonization Document", short: "HD" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+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,
+            web: :technical_report, title: "Technical Report", short: "TR" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+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,
+            web: :technical_specification, 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 < ::Pubid::Parser::Grammar
+      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