pubid 1.15.21 → 2.0.0.alpha.10

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Components
+      # Code component for BSI flavor
+      class Code < Pubid::Components::Code
+      end
+    end
+  end
+end

data/lib/pubid/bsi/components/date.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Components
+      # Date component for BSI flavor
+      class Date < Pubid::Components::Date
+      end
+    end
+  end
+end

data/lib/pubid/bsi/components/publisher.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Components
+      # Publisher component for BSI flavor
+      class Publisher < Pubid::Components::Publisher
+      end
+    end
+  end
+end

data/lib/pubid/bsi/components/type.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Components
+      # Type component for BSI flavor
+      class Type < Pubid::Components::Type
+      end
+    end
+  end
+end

data/lib/pubid/bsi/identifier.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# Pubid::Bsi::Identifier is the BSI base class (a real Pubid::Identifier
+# subclass); its body, `.parse` (including the IEC-delegation logic), and the
+# SingleIdentifier back-compat alias live in single_identifier.rb. This file
+# just ensures it is loaded when a consumer references Pubid::Bsi::Identifier.

data/lib/pubid/bsi/identifiers/addendum_document.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # Addendum Document Identifier
+      # Contains a base identifier plus addendum parameters
+      # Supports various formats:
+      # "BS 1501-2 Addendum No. 1:1973"
+      # "BS 1902-2.3:Addendum No. 1:1976"
+      # "BS 2000-0:Addendum 1:1983"
+      # "BS 6034:1981:Addendum No. 1:1986"
+      class AddendumDocument < SingleIdentifier
+        attribute :base, ::Pubid::Identifier, polymorphic: true
+        attribute :addendum_number, :string
+        attribute :addendum_year, :integer
+        attribute :addendum_type, :string, default: -> {
+          "No."
+        } # "No." or empty for "Addendum N"
+        attribute :separator, :string, default: -> {
+          ":"
+        } # Separator before Addendum (":" or " ")
+
+        def publisher
+          base&.publisher
+        end
+      end
+    end
+  end
+end

data/lib/pubid/bsi/identifiers/adopted_european_norm.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # AdoptedEuropeanNorm wraps CEN identifiers
+      # Example: "BS EN 10077-1:2006" where EN 10077-1:2006 is a CEN identifier object
+      # Example: "BS EN ISO 8601:2019" where EN ISO 8601:2019 is a CEN AdoptedEuropeanNorm wrapping ISO
+      class AdoptedEuropeanNorm < BritishStandard
+        attribute :adopted_identifier, ::Pubid::Identifier, polymorphic: true # CEN object
+        attribute :edition, :string
+        attribute :translation_lang, :string
+        attribute :translation_upper, :string
+        attribute :translation_suffix_type, :string # "version" or "Translation"
+        attribute :reaffirmation_year, :string # For "(R2004)" notation
+        attribute :expert_commentary, :boolean
+        attribute :expert_commentary_topic, :string
+
+        # Override self.type to return nil so this polymorphic wrapper is not
+        # registered as a base type. Inherits `:bs` from BritishStandard which
+        # would otherwise shadow it in Bsi.locate_type(:bs) auto-discovery.
+        # AdoptedEuropeanNorm is constructed explicitly by the builder, not
+        # selected by type-code lookup.
+        def self.type
+          nil
+        end
+
+        # Walk to the adopted document for the relaton-index key.
+        #
+        # The `#number` delegation below is not enough on its own: a
+        # "DD ENV ISO 11079:1999" adopts a CenCenelec EuropeanPrestandard,
+        # which is ITSELF a wrapper around the ISO standard, so the delegation
+        # returned that wrapper's own (nil) number and the chain died one level
+        # short. `#root` recurses, so it reaches the ISO standard however many
+        # adoption layers sit in between.
+        def root
+          adopted_identifier ? adopted_identifier.root : self
+        end
+
+        # Delegate common methods to adopted identifier
+        def number
+          adopted_identifier&.number
+        end
+
+        def year
+          adopted_identifier&.year if adopted_identifier&.methods&.include?(:year)
+        end
+
+        def date
+          adopted_identifier&.date if adopted_identifier&.methods&.include?(:date)
+        end
+
+        def parts
+          adopted_identifier&.parts if adopted_identifier&.methods&.include?(:parts)
+        end
+
+        def part
+          adopted_identifier&.part if adopted_identifier&.methods&.include?(:part)
+        end
+
+        def subpart
+          adopted_identifier&.subpart if adopted_identifier&.methods&.include?(:subpart)
+        end
+      end
+    end
+  end
+end

data/lib/pubid/bsi/identifiers/adopted_international_standard.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # AdoptedInternationalStandard wraps ISO/IEC identifiers directly
+      # Example: "BS ISO 8601:2019" where ISO 8601:2019 is an ISO identifier object
+      # Example: "BS IEC 62600:2020" where IEC 62600:2020 is an IEC identifier object
+      class AdoptedInternationalStandard < BritishStandard
+        attribute :adopted_identifier, ::Pubid::Identifier, polymorphic: true # ISO/IEC object
+        attribute :edition, :string
+        attribute :translation_lang, :string
+        attribute :translation_upper, :string
+        attribute :translation_suffix_type, :string # "version" or "Translation"
+        attribute :reaffirmation_year, :string # For "(R2004)" notation
+        attribute :expert_commentary, :boolean
+        attribute :expert_commentary_topic, :string
+
+        # Override self.type to return nil so this polymorphic wrapper is not
+        # registered as a base type. Inherits `:bs` from BritishStandard which
+        # would otherwise shadow it in Bsi.locate_type(:bs) auto-discovery.
+        # AdoptedInternationalStandard is constructed explicitly by the builder,
+        # not selected by type-code lookup.
+        def self.type
+          nil
+        end
+
+        # Delegate common methods to adopted identifier
+        def number
+          adopted_identifier&.number
+        end
+
+        def year
+          adopted_identifier&.year if adopted_identifier&.methods&.include?(:year)
+        end
+
+        def date
+          adopted_identifier&.date if adopted_identifier&.methods&.include?(:date)
+        end
+
+        def parts
+          adopted_identifier&.parts if adopted_identifier&.methods&.include?(:parts)
+        end
+
+        def part
+          adopted_identifier&.part if adopted_identifier&.methods&.include?(:part)
+        end
+      end
+    end
+  end
+end

data/lib/pubid/bsi/identifiers/aerospace_standard.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # AerospaceStandard handles BSI aerospace and specialized standards
+      # with letter prefixes indicating domain categorization.
+      #
+      # Categorization includes:
+      # - Aircraft (A, B, C, F, G, HC, L, S, SP, X)
+      # - Methods related to aircraft (M)
+      # - Marine (MA)
+      # - Polyester (PL)
+      # - Aerospace materials (TA for Titanium-Aluminium alloys)
+      # - Automotive (AU)
+      # - Multi-letter prefixes (2A, 2B, 2C, 2F, 2G, 2HC, 2HR, 2L, 2M, 2S, 2SP, 2TA, 2X, etc.)
+      #
+      # Examples:
+      #   BS A 109:2024       # Aircraft (A prefix)
+      #   BS AU 145e:2018     # Automotive (AU prefix) with letter suffix
+      #   BS M 38:1971        # Methods (M prefix)
+      #   BS 2A 293:2005      # Multi-letter prefix (2A)
+      #   BS SP 113:1954      # Specification (SP prefix)
+      #   BS TA 40:1971       # Titanium-Aluminium (TA prefix)
+      class AerospaceStandard < SingleIdentifier
+        attribute :prefix, :string
+
+        # Single-letter aerospace/specialized prefixes
+        SINGLE_LETTER_PREFIXES = %w[
+          A B C F G L M S X
+          AU HC MA PL QC SP TA
+        ].freeze
+
+        # Multi-letter prefixes (number + letter combination)
+        MULTI_LETTER_PREFIXES = %w[
+          2A 2B 2C 2F 2G 2HC 2HR 2L 2M 2S 2SP 2TA 2X
+          3A 3B 3F 3G 3HR 3J 3L 3S 3TA
+          4F 4L 4S
+          5S 7S
+        ].freeze
+
+        ALL_PREFIXES = (SINGLE_LETTER_PREFIXES + MULTI_LETTER_PREFIXES).freeze
+
+        # TYPED_STAGES for aerospace standards (published by default)
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubas,
+            stage_code: :published,
+            type_code: :aerospace,
+            abbr: ["BS"],
+            name: "Aerospace/Specialized Standard",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :aerospace,
+            web: :aerospace_standard, title: "Aerospace/Specialized Standard",
+            short: "BS" }
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # Amendment Identifier
+      # Contains a base identifier plus amendment parameters
+      class Amendment < SingleIdentifier
+        attribute :base, ::Pubid::Identifier, polymorphic: true
+        attribute :amendment_number, :string
+        attribute :amendment_year, :integer
+        attribute :separator, :string, default: -> { "+" }
+        # true for the trailing " AMD5" / " AMD AA" suffix form, false for the
+        # compact "+A5" / "/A5" join form. Distinguishes the two when no year is
+        # present (previously the presence of a year was a reliable proxy).
+        attribute :amd_suffix_form, :boolean, default: -> { false }
+
+        def publisher
+          base&.publisher
+        end
+
+        # Base document = the standard this amendment applies to, fully peeled.
+        def base_document
+          base&.base_document || self
+        end
+
+        # Dropping the supplement layer yields the base standard.
+        def drop_supplements
+          base || self
+        end
+
+        # Uniform supplement interface (shared with Corrigendum) so callers need
+        # not special-case the class.
+        def supplement_type
+          :amendment
+        end
+
+        def supplement_number
+          amendment_number
+        end
+
+        def supplement_year
+          amendment_year
+        end
+      end
+    end
+  end
+end

data/lib/pubid/bsi/identifiers/british_industrial_practice.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # British Industrial Practice (BIP)
+      # Examples: "BIP 2225:2022", "BIP 0142:2014", "BIP 0009:2020"
+      class BritishIndustrialPractice < SingleIdentifier
+        attribute :date, Bsi::Components::Date
+
+        def self.type
+          {
+            short: "BIP",
+            full: "British Industrial Practice",
+          }
+        end
+
+      end
+    end
+  end
+end

data/lib/pubid/bsi/identifiers/british_standard.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # British Standard (BS) identifier
+      class BritishStandard < SingleIdentifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubbs,
+            stage_code: :published,
+            type_code: :bs,
+            abbr: ["BS"],
+            name: "British Standard",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :drbs,
+            stage_code: :draft,
+            type_code: :bs,
+            abbr: ["Draft BS", "DBS"],
+            name: "Draft British Standard",
+            harmonized_stages: %w[30.00 30.20 30.60 40.00 40.20 40.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :bs,
+            web: :british_standard, title: "British Standard", short: "BS" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/bsi/identifiers/bundled_identifier.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # BundledIdentifier represents multiple standards published together
+      # Examples:
+      #   BS SP 10 & 11:1949
+      #   BS 2SP 68 to BS 2SP 71:1973
+      #   BS SP 13; 14; 15 and 16:1949
+      #   BS 4048:Parts 1 and 2:1966
+      class BundledIdentifier < SingleIdentifier
+        attribute :identifiers, ::Pubid::Identifier, collection: true, 
+                                                     polymorphic: true
+        attribute :separators, :string, collection: true # Separators between identifiers
+        attribute :common_year, Bsi::Components::Date # Year applied to all if present
+        attribute :bundle_type, :string # "Parts", "Sections", or nil for regular bundles
+
+        def <=>(other)
+          return nil unless other.is_a?(BundledIdentifier)
+
+          # Compare first identifier
+          identifiers.first <=> other.identifiers.first
+        end
+
+        # A bundle carries no number of its own — each member holds one — so
+        # `root.number`, the key relaton-index sorts and bsearches on, was "".
+        # Walk to the first member, the shape ConsolidatedIdentifier already
+        # uses. Members of one bundle are consecutive numbers of a single
+        # series, so the bundle files under the first, and `<=>` above orders
+        # bundles by that same member.
+        def root
+          identifiers&.first ? identifiers.first.root : self
+        end
+      end
+    end
+  end
+end

data/lib/pubid/bsi/identifiers/committee_document.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # CommitteeDocument represents BSI committee draft documents
+      # Format: YY/NNNNNNNN DC (2-digit year, 8-digit number, DC suffix)
+      #
+      # Examples:
+      #   14/30300822 DC
+      #   21/30445138 DC
+      #   24/30300822 DC
+      class CommitteeDocument < SingleIdentifier
+        # The 8-digit document number lives in the `number` inherited from
+        # SingleIdentifier (a Bsi::Components::Code). It used to be a separate
+        # `document_number` :string, which left `number` nil — so `root.number`,
+        # the key relaton-index sorts and bsearches on, was "".
+        #
+        # The duplicate is DELETED rather than mirrored into `number`: keeping
+        # both would emit the same digits twice in `to_hash`, and a derived
+        # `#number` method is not available here because `number` is a lutaml
+        # attribute, whose generated accessor such a method would collide with.
+        # Nothing is retyped — the inherited attribute is already a Code.
+
+        # TYPED_STAGES for committee documents (draft by default)
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :draft_committee,
+            stage_code: :draft,
+            type_code: :committee_document,
+            abbr: ["DC"],
+            name: "Draft Committee Document",
+            harmonized_stages: %w[30.00 30.20 30.60 40.00 40.20 40.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :committee_document, title: "Committee Document", short: "DC" }
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # Consolidated Identifier - contains base document plus supplements
+      # Example: "BS 4592-0:2006+A1:2012" = [BS 4592-0:2006, Amendment 1:2012]
+      class ConsolidatedIdentifier < SingleIdentifier
+        attribute :identifiers, ::Pubid::Identifier, polymorphic: true,
+                                                     collection: true
+
+        def to_urn
+          base = identifiers&.first
+          return nil unless base
+
+          urn = base.to_urn if base.class.method_defined?(:to_urn)
+          return urn unless urn
+
+          # Append supplement info to URN
+          identifiers[1..].each do |id|
+            if id.is_a?(Amendment)
+              urn += ":amd:#{id.amendment_number}"
+              urn += ":#{id.amendment_year}" if id.amendment_year
+            elsif id.is_a?(Corrigendum)
+              urn += ":cor:#{id.corrigendum_number}"
+              urn += ":#{id.corrigendum_year}" if id.corrigendum_year
+            end
+          end
+          urn
+        end
+
+        # Delegate to first identifier (base document)
+        def publisher
+          identifiers&.first&.publisher
+        end
+
+        def number
+          identifiers&.first&.number
+        end
+
+        def year
+          base = identifiers&.first
+          base.year if base&.class&.attributes&.key?(:year)
+        end
+
+        def date
+          base = identifiers&.first
+          base.date if base&.class&.attributes&.key?(:date)
+        end
+
+        def parts
+          base = identifiers&.first
+          base.parts if base&.class&.attributes&.key?(:parts)
+        end
+
+        def part
+          base = identifiers&.first
+          base.part if base&.class&.attributes&.key?(:part)
+        end
+
+        def type
+          base = identifiers&.first
+          base.type if base&.class&.attributes&.key?(:type)
+        end
+
+        # Base document = the wrapped standard (first entry), fully peeled.
+        def base_document
+          identifiers&.first&.base_document || self
+        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
+
+        # Dropping the supplement layer yields the base standard alone.
+        def drop_supplements
+          identifiers&.first || self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # Corrigendum Identifier
+      # Contains a base identifier plus corrigendum parameters
+      class Corrigendum < SingleIdentifier
+        attribute :base, ::Pubid::Identifier, polymorphic: true
+        attribute :corrigendum_number, :string
+        attribute :corrigendum_year, :integer
+        attribute :separator, :string, default: -> { "+" }
+
+        def publisher
+          base&.publisher
+        end
+
+        # Base document = the standard this corrigendum applies to, fully peeled.
+        def base_document
+          base&.base_document || self
+        end
+
+        # Dropping the supplement layer yields the base standard.
+        def drop_supplements
+          base || self
+        end
+
+        # Uniform supplement interface (shared with Amendment) so callers need
+        # not special-case the class.
+        def supplement_type
+          :corrigendum
+        end
+
+        def supplement_number
+          corrigendum_number
+        end
+
+        def supplement_year
+          corrigendum_year
+        end
+      end
+    end
+  end
+end

data/lib/pubid/bsi/identifiers/detailed_specification.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # Detailed Specification identifier with N or C notation
+      # Examples: "BS 9074 N002:1974", "BS 9300 C155-168:1971"
+      class DetailedSpecification < SingleIdentifier
+        attribute :spec_code, Components::Code
+
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :detailed_spec,
+            stage_code: :published,
+            type_code: :detailed_specification,
+            abbr: ["DETAILED SPEC"],
+            name: "Detailed Specification",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          {
+            key: :detailed_specification,
+            title: "Detailed Specification",
+            short: "DETAILED SPEC",
+          }
+        end
+
+      end
+    end
+  end
+end

data/lib/pubid/bsi/identifiers/disc.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # DISC (Delivering Information Solutions to Customers) identifier
+      # Examples: "DISC PD 2000-2:1997", "DISC PD 3004:1998"
+      class Disc < SingleIdentifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :disc,
+            stage_code: :published,
+            type_code: :disc,
+            abbr: ["DISC"],
+            name: "DISC",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :disc, title: "DISC", short: "DISC" }
+        end
+
+      end
+    end
+  end
+end

data/lib/pubid/bsi/identifiers/draft_document.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # Draft Document (DD) identifier
+      class DraftDocument < SingleIdentifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubdd,
+            stage_code: :published,
+            type_code: :dd,
+            abbr: ["DD"],
+            name: "Draft Document",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :dd,
+            web: :draft_document, title: "Draft Document", short: "DD" }
+        end
+
+      end
+    end
+  end
+end