pubid 2.0.0.pre.alpha.2 → 2.0.0.pre.alpha.3

data/lib/pubid/bsi/scheme.rb

@@ -1,243 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Bsi
-    class Scheme < Pubid::Scheme
-      # TYPED_STAGES_REGISTRY for native BSI types
-      TYPED_STAGES_REGISTRY = [
-        # British Standard (BS)
-        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],
-        ),
-
-        # Published Document (PD)
-        Pubid::Components::TypedStage.new(
-          code: :pubpd,
-          stage_code: :published,
-          type_code: :pd,
-          abbr: ["PD"],
-          name: "Published Document",
-          harmonized_stages: %w[60.00 60.60],
-        ),
-
-        # Publicly Available Specification (PAS)
-        Pubid::Components::TypedStage.new(
-          code: :pubpas,
-          stage_code: :published,
-          type_code: :pas,
-          abbr: ["PAS"],
-          name: "Publicly Available Specification",
-          harmonized_stages: %w[60.00 60.60],
-        ),
-
-        # National Annex (NA)
-        Pubid::Components::TypedStage.new(
-          code: :pubna,
-          stage_code: :published,
-          type_code: :na,
-          abbr: ["NA"],
-          name: "National Annex",
-          harmonized_stages: %w[60.00 60.60],
-        ),
-
-        # Draft Document (DD)
-        Pubid::Components::TypedStage.new(
-          code: :pubdd,
-          stage_code: :published,
-          type_code: :dd,
-          abbr: ["DD"],
-          name: "Draft Document",
-          harmonized_stages: %w[60.00 60.60],
-        ),
-
-        # Flex Document
-        Pubid::Components::TypedStage.new(
-          code: :pubflex,
-          stage_code: :published,
-          type_code: :flex,
-          abbr: ["Flex", "BSI Flex"],
-          name: "BSI Flex",
-          harmonized_stages: %w[60.00 60.60],
-        ),
-
-        # Handbook
-        Pubid::Components::TypedStage.new(
-          code: :pubhandbook,
-          stage_code: :published,
-          type_code: :handbook,
-          abbr: ["Handbook", "HB"],
-          name: "BSI Handbook",
-          harmonized_stages: %w[60.00 60.60],
-        ),
-
-        # Practice Guide (PP)
-        Pubid::Components::TypedStage.new(
-          code: :pubpp,
-          stage_code: :published,
-          type_code: :pp,
-          abbr: ["PP"],
-          name: "Published Practice",
-          harmonized_stages: %w[60.00 60.60],
-        ),
-
-        # British Industrial Practice (BIP)
-        Pubid::Components::TypedStage.new(
-          code: :pubbip,
-          stage_code: :published,
-          type_code: :bip,
-          abbr: ["BIP"],
-          name: "British Industrial Practice",
-          harmonized_stages: %w[60.00 60.60],
-        ),
-
-        # Aerospace/Specialized British Standard (with letter prefix)
-        Pubid::Components::TypedStage.new(
-          code: :pubaerospace,
-          stage_code: :published,
-          type_code: :aerospace,
-          abbr: ["BS A", "BS AU", "BS C", "BS M", "BS S", "BS L", "BS TA",
-                 "BS MA", "BS PL", "BS QC", "BS G", "BS HC", "BS F", "BS X", "BS B"],
-          name: "Aerospace/Specialized British Standard",
-          harmonized_stages: %w[60.00 60.60],
-        ),
-
-        # Index
-        Pubid::Components::TypedStage.new(
-          code: :pubindex,
-          stage_code: :published,
-          type_code: :index,
-          abbr: ["Index"],
-          name: "BSI Index",
-          harmonized_stages: %w[60.00 60.60],
-        ),
-
-        # Method
-        Pubid::Components::TypedStage.new(
-          code: :pubmethod,
-          stage_code: :published,
-          type_code: :method,
-          abbr: ["Method", "Methods"],
-          name: "BSI Method",
-          harmonized_stages: %w[60.00 60.60],
-        ),
-
-        # Section
-        Pubid::Components::TypedStage.new(
-          code: :pubsection,
-          stage_code: :published,
-          type_code: :section,
-          abbr: ["Section"],
-          name: "BSI Section",
-          harmonized_stages: %w[60.00 60.60],
-        ),
-
-        # DISC (Delivering Information Solutions to Customers)
-        Pubid::Components::TypedStage.new(
-          code: :pubdisc,
-          stage_code: :published,
-          type_code: :disc,
-          abbr: ["DISC"],
-          name: "DISC",
-          harmonized_stages: %w[60.00 60.60],
-        ),
-
-        # Detailed Specification (with N or C notation)
-        Pubid::Components::TypedStage.new(
-          code: :pubdetailed_spec,
-          stage_code: :published,
-          type_code: :detailed_specification,
-          abbr: ["DETAILED SPEC"],
-          name: "Detailed Specification",
-          harmonized_stages: %w[60.00 60.60],
-        ),
-
-        # Standalone Amendment
-        Pubid::Components::TypedStage.new(
-          code: :standalone_amendment,
-          stage_code: :published,
-          type_code: :amendment,
-          abbr: ["AMD"],
-          name: "Amendment",
-          harmonized_stages: %w[60.00 60.60],
-        ),
-
-        # Technical Specification
-        Pubid::Components::TypedStage.new(
-          code: :pubts,
-          stage_code: :published,
-          type_code: :ts,
-          abbr: ["TS"],
-          name: "Technical Specification",
-          harmonized_stages: %w[60.00 60.60],
-        ),
-      ].freeze
-
-      # Map type codes to identifier classes
-      IDENTIFIER_CLASS_MAP = {
-        bs: "Identifiers::BritishStandard",
-        pd: "Identifiers::PublishedDocument",
-        pas: "Identifiers::PubliclyAvailableSpecification",
-        na: "Identifiers::NationalAnnex",
-        dd: "Identifiers::DraftDocument",
-        flex: "Identifiers::Flex",
-        handbook: "Identifiers::Handbook",
-        pp: "Identifiers::PracticeGuide",
-        bip: "Identifiers::BritishIndustrialPractice",
-        aerospace: "Identifiers::AerospaceStandard",
-        index: "Identifiers::Index",
-        method: "Identifiers::Method",
-        section: "Identifiers::Section",
-        disc: "Identifiers::Disc",
-        bundled: "Identifiers::BundledIdentifier",
-        detailed_specification: "Identifiers::DetailedSpecification",
-        standalone_amendment: "Identifiers::StandaloneAmendment",
-        ts: "Identifiers::TechnicalSpecification",
-        committee_document: "Identifiers::CommitteeDocument",
-        explanatory_supplement: "Identifiers::ExplanatorySupplement",
-        supplementary_index: "Identifiers::SupplementaryIndex",
-        test_method: "Identifiers::TestMethod",
-        set: "Identifiers::Set",
-      }.freeze
-
-      # Default typed stage for when no match is found
-      DEFAULT_TYPED_STAGE = Pubid::Components::TypedStage.new(
-        code: :pubbs,
-        stage_code: :published,
-        type_code: :bs,
-        abbr: ["BS"],
-        name: "British Standard",
-        harmonized_stages: %w[60.00 60.60],
-      ).freeze
-
-      def locate_typed_stage_by_abbr(abbr)
-        abbr_str = abbr.to_s.strip
-        TYPED_STAGES_REGISTRY.find do |ts|
-          ts.abbr.include?(abbr_str)
-        end || DEFAULT_TYPED_STAGE
-      end
-
-      def locate_identifier_klass_by_type_code(type_code)
-        class_name = IDENTIFIER_CLASS_MAP[type_code.to_sym]
-        return Identifiers::BritishStandard unless class_name
-
-        # Convert string to actual class
-        class_name.split("::").reduce(Pubid::Bsi) do |mod, name|
-          mod.const_get(name)
-        end
-      end
-    end
-  end
-end

data/lib/pubid/ccsds/scheme.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Ccsds
-    class Scheme < Pubid::Scheme
-      class << self
-        def identifiers
-          [
-            Identifiers::Base,
-          ]
-        end
-
-        def supplement_identifiers
-          [
-            Identifiers::Corrigendum,
-          ]
-        end
-
-        def typed_stages
-          identifiers.flat_map { |klass| klass::TYPED_STAGES }
-        end
-
-        def supplement_typed_stages
-          supplement_identifiers.flat_map { |klass| klass::TYPED_STAGES }
-        end
-
-        def locate_typed_stage_by_abbr(abbr)
-          abbr = "" if abbr.nil?
-
-          typed_stage = (typed_stages + supplement_typed_stages).detect do |ts|
-            ts.abbr.include?(abbr)
-          end
-
-          unless typed_stage
-            raise ArgumentError,
-                  "Unknown type abbreviation: '#{abbr}'"
-          end
-
-          typed_stage
-        end
-
-        def locate_identifier_klass_by_type_code(type_code)
-          identifier_klass = (identifiers + supplement_identifiers).detect do |klass|
-            klass.type[:key].to_s == type_code.to_s
-          end
-
-          unless identifier_klass
-            raise ArgumentError,
-                  "Unknown type code: #{type_code}"
-          end
-
-          identifier_klass
-        end
-      end
-    end
-  end
-end

data/lib/pubid/cen_cenelec/scheme.rb

@@ -1,164 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module CenCenelec
-    class Scheme < Pubid::Scheme
-      # TYPED_STAGES_REGISTRY for native CEN types
-      TYPED_STAGES_REGISTRY = [
-        # European Norm (EN)
-        Pubid::Components::TypedStage.new(
-          code: :puben,
-          stage_code: :published,
-          type_code: :en,
-          abbr: ["EN"],
-          name: "European Norm",
-          harmonized_stages: %w[60.00 60.60],
-        ),
-        Pubid::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],
-        ),
-        Pubid::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],
-        ),
-
-        # Technical Specification (TS)
-        Pubid::Components::TypedStage.new(
-          code: :pubts,
-          stage_code: :published,
-          type_code: :ts,
-          abbr: ["TS"],
-          name: "Technical Specification",
-          harmonized_stages: %w[60.00 60.60],
-        ),
-        Pubid::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],
-        ),
-
-        # Technical Report (TR)
-        Pubid::Components::TypedStage.new(
-          code: :pubtr,
-          stage_code: :published,
-          type_code: :tr,
-          abbr: ["TR"],
-          name: "Technical Report",
-          harmonized_stages: %w[60.00 60.60],
-        ),
-
-        # CEN Workshop Agreement (CWA)
-        Pubid::Components::TypedStage.new(
-          code: :pubcwa,
-          stage_code: :published,
-          type_code: :cwa,
-          abbr: ["CWA"],
-          name: "CEN Workshop Agreement",
-          harmonized_stages: %w[60.00 60.60],
-        ),
-
-        # Guide
-        Pubid::Components::TypedStage.new(
-          code: :pubguide,
-          stage_code: :published,
-          type_code: :guide,
-          abbr: ["Guide"],
-          name: "Guide",
-          harmonized_stages: %w[60.00 60.60],
-        ),
-
-        # Harmonization Document (HD)
-        Pubid::Components::TypedStage.new(
-          code: :pubhd,
-          stage_code: :published,
-          type_code: :hd,
-          abbr: ["HD"],
-          name: "Harmonization Document",
-          harmonized_stages: %w[60.00 60.60],
-        ),
-
-        # European Specification (ES)
-        Pubid::Components::TypedStage.new(
-          code: :pubes,
-          stage_code: :published,
-          type_code: :es,
-          abbr: ["ES"],
-          name: "European Specification",
-          harmonized_stages: %w[60.00 60.60],
-        ),
-
-        # CEN Report (CR)
-        Pubid::Components::TypedStage.new(
-          code: :pubcr,
-          stage_code: :published,
-          type_code: :cr,
-          abbr: ["CR"],
-          name: "CEN Report",
-          harmonized_stages: %w[60.00 60.60],
-        ),
-
-        # European Prestandard (ENV)
-        Pubid::Components::TypedStage.new(
-          code: :pubenv,
-          stage_code: :published,
-          type_code: :env,
-          abbr: ["ENV"],
-          name: "European Prestandard",
-          harmonized_stages: %w[60.00 60.60],
-        ),
-      ].freeze
-
-      # Map type codes to identifier classes
-      IDENTIFIER_CLASS_MAP = {
-        en: "Identifiers::EuropeanNorm",
-        ts: "Identifiers::TechnicalSpecification",
-        tr: "Identifiers::TechnicalReport",
-        cwa: "Identifiers::CenWorkshopAgreement",
-        guide: "Identifiers::Guide",
-        hd: "Identifiers::HarmonizationDocument",
-        es: "Identifiers::EuropeanSpecification",
-        cr: "Identifiers::CenReport",
-        env: "Identifiers::EuropeanPrestandard",
-      }.freeze
-
-      # Default typed stage for when no match is found
-      DEFAULT_TYPED_STAGE = Pubid::Components::TypedStage.new(
-        code: :puben,
-        stage_code: :published,
-        type_code: :en,
-        abbr: ["EN"],
-        name: "European Norm",
-        harmonized_stages: %w[60.00 60.60],
-      ).freeze
-
-      def locate_typed_stage_by_abbr(abbr)
-        abbr_str = abbr.to_s.strip
-        TYPED_STAGES_REGISTRY.find do |ts|
-          ts.abbr.include?(abbr_str)
-        end || DEFAULT_TYPED_STAGE
-      end
-
-      def locate_identifier_klass_by_type_code(type_code)
-        class_name = IDENTIFIER_CLASS_MAP[type_code.to_sym]
-        return Identifiers::EuropeanNorm unless class_name
-
-        # Convert string to actual class
-        class_name.split("::").reduce(Pubid::CenCenelec) do |mod, name|
-          mod.const_get(name)
-        end
-      end
-    end
-  end
-end

data/lib/pubid/cie/scheme.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Cie
-    class Scheme < Pubid::Scheme
-      class << self
-        def identifiers
-          [
-            Identifiers::Standard,
-            Identifiers::Conference,
-            Identifiers::Bundle,
-            Identifiers::DualPublished,
-            Identifiers::Identical,
-            Identifiers::JointPublished,
-            Identifiers::Supplement,
-            Identifiers::TutorialBundle,
-          ]
-        end
-
-        def supplement_identifiers
-          [
-            Identifiers::Corrigendum,
-          ]
-        end
-
-        def typed_stages
-          identifiers.flat_map { |klass| klass::TYPED_STAGES }
-        end
-
-        def supplement_typed_stages
-          supplement_identifiers.flat_map { |klass| klass::TYPED_STAGES }
-        end
-
-        def locate_typed_stage_by_abbr(abbr)
-          abbr = "" if abbr.nil?
-
-          typed_stage = (typed_stages + supplement_typed_stages).detect do |ts|
-            ts.abbr.include?(abbr)
-          end
-
-          unless typed_stage
-            raise ArgumentError,
-                  "Unknown type abbreviation: '#{abbr}'"
-          end
-
-          typed_stage
-        end
-
-        def locate_identifier_klass_by_type_code(type_code)
-          identifier_klass = (identifiers + supplement_identifiers).detect do |klass|
-            klass.type[:key].to_s == type_code.to_s
-          end
-
-          unless identifier_klass
-            raise ArgumentError,
-                  "Unknown type code: #{type_code}"
-          end
-
-          identifier_klass
-        end
-      end
-    end
-  end
-end

data/lib/pubid/components/factory.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "code"
-require_relative "date"
-require_relative "edition"
-require_relative "language"
-require_relative "publisher"
-
-module Pubid
-  module Components
-    # Coerces loose primitive kwargs (matching pubid 1.x's `Identifier.create`
-    # signature) into the structured Component objects pubid 2.x expects.
-    #
-    # Used by per-flavor `.create` factories.
-    module Factory
-      # Per-kwarg coercer. Returns a Component, or an Array<Component> for
-      # collection attributes such as `languages`.
-      COERCERS = {
-        publisher: ->(v) { Publisher.new(body: v.to_s) },
-        number:    ->(v) { Code.new(value: v.to_s) },
-        part:      ->(v) { Code.new(value: v.to_s) },
-        subpart:   ->(v) { Code.new(value: v.to_s) },
-        year:      ->(v) { Date.new(year: v.to_s) },
-        edition:   ->(v) { Edition.new(number: v) },
-        language:  ->(v) { [Language.new(code: v.to_s)] },
-      }.freeze
-
-      # 1.x kwarg name → 2.x attribute name.
-      # Applied after coercion.
-      KEY_RENAMES = {
-        year: :date,
-        language: :languages,
-      }.freeze
-
-      # Convert a hash of 1.x-style primitive kwargs into a hash of 2.x-style
-      # Component-valued attributes ready for `<IdentifierClass>.new(...)`.
-      #
-      # Unknown keys pass through unchanged; nil values are dropped.
-      def self.from_hash(opts)
-        opts.each_with_object({}) do |(k, v), out|
-          next if v.nil?
-
-          target = KEY_RENAMES.fetch(k, k)
-          coercer = COERCERS[k]
-          out[target] = coercer ? coercer.call(v) : v
-        end
-      end
-    end
-  end
-end

data/lib/pubid/csa/scheme.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Csa
-    class Scheme < Pubid::Scheme
-      class << self
-        def identifiers
-          @identifiers ||= [
-            Identifiers::Standard,
-            Identifiers::Bundled,
-            Identifiers::CanadianAdopted,
-            Identifiers::CsaAdopted,
-            Identifiers::Package,
-            Identifiers::Series,
-            Identifiers::Cec,
-            Identifiers::Combined,
-          ].freeze
-        end
-
-        def supplement_identifiers
-          @supplement_identifiers ||= [].freeze
-        end
-
-        def typed_stages
-          @typed_stages ||= [].freeze
-        end
-
-        def supplement_typed_stages
-          @supplement_typed_stages ||= [].freeze
-        end
-
-        def locate_typed_stage_by_abbr(_abbr)
-          raise ArgumentError,
-                "CSA identifiers do not use typed stages"
-        end
-
-        def locate_identifier_klass_by_type_code(_type_code)
-          raise ArgumentError,
-                "CSA identifiers do not use type codes"
-        end
-      end
-    end
-  end
-end

data/lib/pubid/etsi/scheme.rb

@@ -1,42 +0,0 @@
-require "lutaml/model"
-# frozen_string_literal: true
-
-module Pubid
-  module Etsi
-    class Scheme < Lutaml::Model::Serializable
-      attribute :type, :string
-      attribute :number, :string
-      attribute :part, :string, collection: true, default: -> { [] }
-      attribute :version, :string, default: -> {}
-      attribute :edition, :string, default: -> {}
-      attribute :date, :string
-      attribute :amendment, :string, default: -> {}
-      attribute :corrigendum, :string, default: -> {}
-
-      def to_s
-        result = "ETSI #{type} #{number}"
-
-        # Add parts
-        part.each do |p|
-          result += "-#{p}"
-        end
-
-        # Add amendment or corrigendum
-        result += "/A#{amendment}" if amendment
-        result += "/C#{corrigendum}" if corrigendum
-
-        # Add version or edition
-        if version
-          result += " V#{version}"
-        elsif edition
-          result += " ed.#{edition}"
-        end
-
-        # Add date (only if present)
-        result += " (#{date})" if date
-
-        result
-      end
-    end
-  end
-end