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

data/lib/pubid/iec/scheme.rb

@@ -1,71 +0,0 @@
-require_relative "identifiers/international_standard"
-# frozen_string_literal: true
-require_relative "identifiers/technical_specification"
-require_relative "identifiers/technical_report"
-require_relative "identifiers/publicly_available_specification"
-require_relative "identifiers/guide"
-require_relative "identifiers/amendment"
-require_relative "identifiers/corrigendum"
-require_relative "identifiers/fragment_identifier"
-
-module Pubid
-  module Iec
-    class Scheme < Pubid::Scheme
-      class << self
-        def identifiers
-          [
-            Identifiers::InternationalStandard,
-            Identifiers::TechnicalSpecification,
-            Identifiers::TechnicalReport,
-            Identifiers::PubliclyAvailableSpecification,
-            Identifiers::Guide,
-          ]
-        end
-
-        def supplement_identifiers
-          [
-            Identifiers::Amendment,
-            Identifiers::Corrigendum,
-            Identifiers::FragmentIdentifier,
-          ]
-        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/ieee/scheme.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "typed_stages"
-
-module Pubid
-  module Ieee
-    # Scheme provides registry access for IEEE identifiers
-    # Following the proven ISO/IEC/CEN/BSI pattern
-    #
-    # This class is the single source of truth for:
-    # - TypedStage lookup by abbreviation
-    # - TypedStage lookup by IEEE draft notation
-    # - TypedStage lookup by ISO stage code
-    # - Identifier class selection based on type code
-    class Scheme < Pubid::Scheme
-      class << self
-        # Locate typed stage by abbreviation
-        # @param abbr [String, nil] stage abbreviation (e.g., "D1", "FDIS", "Std")
-        # @return [Components::TypedStage] matching typed stage
-        def locate_typed_stage_by_abbr(abbr)
-          return TypedStages::DEFAULT_TYPED_STAGE if abbr.nil? || abbr.to_s.strip.empty?
-
-          # Normalize abbreviation
-          abbr_str = abbr.to_s.strip
-
-          # Find typed stage that includes this abbreviation
-          typed_stage = TypedStages::TYPED_STAGES.find { |ts| ts.abbr.include?(abbr_str) }
-
-          # Fall back to default if not found
-          typed_stage || TypedStages::DEFAULT_TYPED_STAGE
-        end
-
-        # Locate typed stage by IEEE draft notation
-        # @param draft [String] IEEE draft notation (e.g., "D1", "D5", "P")
-        # @return [Components::TypedStage, nil] matching typed stage
-        def locate_typed_stage_by_ieee_draft(draft)
-          return nil if draft.nil? || draft.to_s.strip.empty?
-
-          draft_str = draft.to_s.strip
-
-          # Try exact match on abbreviation first
-          ts = TypedStages::TYPED_STAGES.find { |t| t.abbr.include?(draft_str) }
-          return ts if ts
-
-          # Try match on ieee_draft_equivalent
-          TypedStages::TYPED_STAGES.find { |t| t.ieee_draft_equivalent == draft_str }
-        end
-
-        # Locate typed stage by ISO stage code
-        # @param stage [String] ISO stage code (e.g., "WD", "CD", "DIS", "FDIS")
-        # @return [Components::TypedStage, nil] matching typed stage
-        def locate_typed_stage_by_iso_stage(stage)
-          return nil if stage.nil? || stage.to_s.strip.empty?
-
-          TypedStages::TYPED_STAGES.find { |ts| ts.iso_stage_equivalent == stage.to_s.strip }
-        end
-
-        # Locate identifier class by type code
-        # @param type_code [String, Symbol] type code (:standard, :draft, :std, :P, etc.)
-        # @return [Class] identifier class
-        def locate_identifier_klass_by_type_code(type_code)
-          type_str = type_code.to_s
-
-          case type_str
-          when "draft", "Draft Std", "Draft", "P"
-            # "P" indicates project draft status - maps to ProjectDraftIdentifier
-            Identifiers::ProjectDraftIdentifier
-          when "standard", "Std", "std"
-            Identifiers::Standard
-          else
-            # Default to base identifier
-            Identifiers::Base
-          end
-        end
-
-        # Get all typed stages
-        # @return [Array<Components::TypedStage>] all registered typed stages
-        def typed_stages
-          TypedStages::TYPED_STAGES
-        end
-
-        # Get default typed stage (published standard)
-        # @return [Components::TypedStage] default typed stage
-        def default_typed_stage
-          TypedStages::DEFAULT_TYPED_STAGE
-        end
-      end
-    end
-  end
-end

data/lib/pubid/iho/scheme.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Iho
-    # Scheme registry for IHO identifier types.
-    class Scheme < Pubid::Scheme
-      IDENTIFIERS = [
-        Identifiers::Standard,
-        Identifiers::Publication,
-        Identifiers::Miscellaneous,
-        Identifiers::Bibliographic,
-        Identifiers::CircularLetter,
-      ].freeze
-
-      def initialize
-        @identifiers = IDENTIFIERS
-      end
-
-      # Look up an identifier class by its IHO series letter (S/P/M/B/C).
-      # @param letter [String]
-      # @return [Class<Identifiers::Base>]
-      # @raise [KeyError] if the letter is not a known IHO series
-      def self.identifier_klass_for_type_letter(letter)
-        @by_letter ||= IDENTIFIERS.to_h { |klass| [klass.type[:short], klass] }
-        @by_letter.fetch(letter.to_s)
-      end
-    end
-  end
-end

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

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-require "lutaml/model"
-
-module Pubid
-  module Iso
-    module Identifiers
-      # Base class for ISO identifiers
-      class Base < ::Pubid::Identifier
-        # Inherit most attributes from parent
-        # ISO-specific attributes
-        attribute :stage_iteration, ::Pubid::Iso::Components::Code
-
-        # ISO rendering context singleton
-        def self.rendering_context
-          @rendering_context ||= Pubid::Rendering::RenderingContext.iso
-        end
-
-        # Render identifier using OOP approach - each component renders itself
-        #
-        # @param lang [Symbol] language for rendering (:en or :fr)
-        # @param lang_single [Boolean] use single char language format
-        # @param with_edition [Boolean] include edition in output
-        # @return [String] formatted identifier string
-        def to_s(lang: :en, lang_single: false, with_edition: false)
-          # Create rendering context with language settings
-          context = Pubid::Rendering::RenderingContext.new(
-            stage_separator: "/",
-            stage_separator_with_copublisher: " ",
-            type_separator: "/",
-            type_separator_with_prefix: " ",
-            default_type_abbr: "IS",
-            lang: lang,
-            lang_single: lang_single,
-          )
-
-          # Compose the identifier from component renderings
-          render_from_components(context: context, with_edition: with_edition)
-        end
-
-        private
-
-        # Compose identifier string by having each component render itself
-        #
-        # @param context [RenderingContext] rendering context for flavor rules
-        # @param with_edition [Boolean] include edition in output
-        # @return [String] composed identifier string
-        def render_from_components(context:, with_edition: false)
-          parts = []
-          parts << publisher.to_s
-
-          # Stage renders itself with context-aware separators
-          if stage
-            has_copub = publisher&.has_copublisher?
-            parts << stage.to_s(context: context, has_copublisher: has_copub)
-          end
-
-          # Type renders itself with context-aware separators and default handling
-          if type
-            has_prefix = stage || publisher&.has_copublisher?
-            type_render = type.to_s(context: context, has_prefix: has_prefix)
-            parts << type_render if type_render != ""
-          end
-
-          # Number renders itself
-          parts << " #{number.value}" if number&.value
-
-          # Parts render themselves
-          parts << "-#{part.value}" if part&.value
-          parts << "-#{subpart.value}" if subpart&.value
-
-          # Stage iteration renders itself
-          parts << ".#{stage_iteration.value}" if stage_iteration&.value
-
-          # Date renders itself with context
-          parts << date.to_s(context: context) if date&.year
-
-          # Edition renders itself
-          parts << " #{edition}" if with_edition && edition&.number
-
-          # Languages render themselves
-          if languages&.any?
-            parts << "(#{languages.map do |l|
-              l.to_s(lang_single: context.lang_single)
-            end.join('/')})"
-          end
-
-          parts.join
-        end
-
-        public
-
-        # V1 API compatibility - tests expect .copublishers returning array of Publisher objects
-        def copublishers
-          return [] unless publisher.copublisher&.any?
-
-          publisher.copublisher.map do |cp|
-            ::Pubid::Components::Publisher.new(body: cp)
-          end
-        end
-
-        def ==(other)
-          return false unless other.is_a?(Base)
-
-          publisher == other.publisher &&
-            type == other.type &&
-            number == other.number &&
-            part == other.part &&
-            date == other.date &&
-            stage == other.stage
-        end
-      end
-    end
-  end
-end

data/lib/pubid/iso/scheme.rb

@@ -1,193 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Iso
-    # ISO Scheme with memoized parser/builder and hash-based indexing
-    class Scheme < Pubid::Scheme
-      class << self
-        # Singleton instance for memoization
-        # @return [Pubid::Iso::Scheme] the singleton scheme instance
-        def instance
-          @instance ||= new
-        end
-
-        # Delegate class methods to singleton instance for backward compatibility
-        # @param identifier [String] the identifier string to parse
-        # @return [Identifier] the parsed identifier
-        def parse(identifier)
-          instance.parse(identifier)
-        end
-
-        # @param abbr [String, Symbol] the abbreviation to find
-        # @return [TypedStage] the matching typed stage
-        def locate_typed_stage_by_abbr(abbr)
-          instance.locate_typed_stage_by_abbr(abbr)
-        end
-
-        # @param type_code [String, Symbol] the type code to find
-        # @return [Class] the matching identifier class
-        def locate_identifier_klass_by_type_code(type_code)
-          instance.locate_identifier_klass_by_type_code(type_code)
-        end
-
-        # @param stage_code [String, Symbol] the stage code to find
-        # @return [TypedStage] the matching typed stage
-        def locate_typed_stage_by_stage_code(stage_code)
-          instance.locate_typed_stage_by_stage_code(stage_code)
-        end
-
-        # @param code [String, Symbol] the per-typed-stage code to find
-        # @return [TypedStage, nil] the matching typed stage
-        def locate_typed_stage_by_code(code)
-          instance.locate_typed_stage_by_code(code)
-        end
-
-        # @param harmonized_code [String] the harmonized stage code to find
-        # @return [TypedStage, nil] the matching typed stage
-        def locate_typed_stage_by_harmonized_code(harmonized_code)
-          instance.locate_typed_stage_by_harmonized_code(harmonized_code)
-        end
-
-        # Keep existing class methods for backward compatibility
-        # @return [Array<Class>] all base identifier classes
-        def identifiers
-          [
-            Identifiers::InternationalStandard,
-            Identifiers::TechnicalReport,
-            Identifiers::TechnicalSpecification,
-            Identifiers::Guide,
-            Identifiers::Pas,
-            Identifiers::Data,
-            Identifiers::TechnologyTrendsAssessments,
-            Identifiers::InternationalWorkshopAgreement,
-            Identifiers::InternationalStandardizedProfile,
-            Identifiers::Recommendation,
-            Identifiers::Directives,
-            Identifiers::Amendment,
-            Identifiers::Corrigendum,
-            Identifiers::Supplement,
-            Identifiers::Extract,
-            Identifiers::DirectivesSupplement,
-            Identifiers::Addendum,
-            Identifiers::TcDocument,
-          ]
-        end
-
-        def typed_stages
-          identifiers.flat_map { |klass| klass::TYPED_STAGES }.compact
-        end
-
-        def supplement_typed_stages
-          supplement_identifiers = [
-            Identifiers::Amendment,
-            Identifiers::Corrigendum,
-            Identifiers::Supplement,
-            Identifiers::Extract,
-            Identifiers::Addendum,
-          ]
-          supplement_identifiers.flat_map { |klass| klass::TYPED_STAGES }
-        end
-      end
-
-      # Initialize the scheme with identifiers
-      def initialize
-        super(
-          identifiers: self.class.identifiers,
-          supplement_identifiers: [
-            Identifiers::Amendment,
-            Identifiers::Corrigendum,
-            Identifiers::Supplement,
-            Identifiers::Extract,
-            Identifiers::Addendum,
-          ],
-        )
-      end
-
-      # Parse an ISO identifier string using memoized parser/builder
-      # @param identifier [String] the identifier string to parse
-      # @return [Identifier] the parsed identifier
-      def parse(identifier)
-        # Handle DAD/FDAD patterns that parser can't recognize
-        if match = identifier.match(/^(.+?)\/(F?DAD)\s+(\d+)(?::(\d{4}))?$/)
-          parse_dad_pattern(match)
-        else
-          # Apply legacy update_codes normalization first, before any other preprocessing
-          normalized = Core::UpdateCodes.apply(identifier, :iso)
-          # Normalize Cyrillic (Russian) identifiers to Latin equivalents
-          normalized = normalize_cyrillic(normalized)
-          parsed = parser.parse(normalized)
-          builder.build(parsed)
-        end
-      end
-
-      private
-
-      # Memoized parser instance
-      # @return [Pubid::Iso::Parser] parser instance
-      def parser
-        @parser ||= ::Pubid::Iso::Parser.new
-      end
-
-      # Memoized builder instance
-      # @return [Pubid::Iso::Builder] builder instance
-      def builder
-        @builder ||= ::Pubid::Iso::Builder.new(self)
-      end
-
-      # Normalize Cyrillic (Russian) ISO identifiers to Latin equivalents
-      # ИСО = ISO, МЭК = IEC, Руководство/Руководства = Guide,
-      # ОПМС = FDIS, ПМС = DIS, ТО = TR, ТС = TS
-      def normalize_cyrillic(identifier)
-        return identifier unless identifier.match?(/[а-яА-Я]/)
-
-        normalized = identifier.dup
-        # Remove inline comments (Russian style comments with #)
-        normalized = normalized.gsub(/\s*#\s*.*$/, "")
-        # Translate Russian abbreviations (order matters: longer first)
-        normalized = normalized.gsub("Руководства", "GUIDE")
-        normalized = normalized.gsub("Руководство", "GUIDE")
-        normalized = normalized.gsub("ИСО/МЭК", "ISO/IEC")
-        normalized = normalized.gsub("ИСО/ОПМС", "ISO/FDIS")
-        normalized = normalized.gsub("ИСО/ПМС", "ISO/DIS")
-        normalized = normalized.gsub("ИСО/ТО", "ISO/TR")
-        normalized = normalized.gsub("ИСО/ТС", "ISO/TS")
-        normalized = normalized.gsub("ИСО", "ISO")
-        normalized = normalized.gsub("МЭК", "IEC")
-        # Standalone Cyrillic stage abbreviations (after publisher replacements)
-        normalized = normalized.gsub("ТО", "TR")
-        normalized = normalized.gsub("ТС", "TS")
-        normalized = normalized.gsub("ОПМС", "FDIS")
-        normalized = normalized.gsub("ПМС", "DIS")
-        normalized.strip
-      end
-
-      # Parse DAD/FDAM pattern manually
-      # Pattern: "ISO 2631/DAD 1" or "ISO 2553/DAD 1:1987"
-      # The parser fails because it treats "/" as copublisher separator
-      def parse_dad_pattern(match)
-        base_str = match[1]          # "ISO 2631" or "ISO 2553"
-        stage_abbr = match[2]        # "DAD" or "FDAD"
-        supplement_number = match[3] # "1"
-        supplement_year = match[4]   # "1987" or nil
-
-        # Parse the base identifier normally (without supplement)
-        base_parsed = parser.parse(base_str)
-        base_identifier = builder.build(base_parsed)
-
-        # Construct the Addendum supplement manually
-        addendum = Identifiers::Addendum.new
-        addendum.base_identifier = base_identifier
-        addendum.number = Iso::Components::Code.new(number: supplement_number)
-        addendum.date = Pubid::Components::Date.new(year: supplement_year) if supplement_year
-
-        # Set typed_stage from register (uses TYPED_STAGES in Addendum class)
-        typed_stage = locate_typed_stage_by_abbr(stage_abbr)
-        addendum.typed_stage = typed_stage
-        addendum.stage = typed_stage.to_stage
-        addendum.type = typed_stage.to_type
-
-        addendum
-      end
-    end
-  end
-end

data/lib/pubid/itu/scheme.rb

@@ -1,174 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "model"
-
-module Pubid
-  module Itu
-    class Scheme < Pubid::Scheme
-      # Attribute mappings define how parsed data maps to model attributes
-      ATTRIBUTE_MAPPINGS = {
-        sector: :sector,
-        series: :series,
-        number: :number,
-        subseries: :subseries,
-        part: :part,
-        supplement: :supplement,
-        amendment: :amendment,
-        annex: :annex,
-        corrigendum: :corrigendum,
-        addendum: :addendum,
-        appendix: :appendix,
-        date: :date,
-        month: :month,
-        year: :year,
-        second_number: :second_number,
-        range_series: :range_series,
-        range_number: :range_number,
-        sg_number: :sg_number,
-      }.freeze
-
-      # Model class to use for rendering
-      def self.model_class
-        Model
-      end
-
-      # Convert parsed data to model attributes
-      def self.transform(parsed)
-        attributes = {}
-
-        # Extract sector
-        attributes[:sector] = parsed[:sector].to_s if parsed[:sector]
-
-        # Determine content based on sector
-        content = parsed[:t_content] || parsed[:r_content] || {}
-
-        # Extract series and study group
-        if content[:series].is_a?(Hash) && content[:series][:sg_number]
-          # Study groups (questions)
-          attributes[:series] = "SG#{content[:series][:sg_number]}"
-        elsif content[:series]
-          attributes[:series] = content[:series].to_s
-        end
-
-        # Extract numbering components
-        if content[:numbering]
-          numbering = content[:numbering]
-
-          # Handle numbering as array (e.g., number + subseries)
-          if numbering.is_a?(Array)
-            numbering.each do |part|
-              if part.is_a?(Hash)
-                if part[:number]
-                  attributes[:number] = part[:number].to_s
-                elsif part[:subseries]
-                  # Collect subseries parts
-                  if attributes[:subseries]
-                    attributes[:subseries] =
-                      "#{attributes[:subseries]}.#{part[:subseries]}"
-                  else
-                    attributes[:subseries] = part[:subseries].to_s
-                  end
-                elsif part[:part]
-                  attributes[:part] = part[:part].to_s
-                end
-              end
-            end
-          elsif numbering.is_a?(Hash)
-            # Handle numbering as hash
-            attributes[:number] = numbering[:number].to_s if numbering[:number]
-            if numbering[:subseries]
-              attributes[:subseries] =
-                numbering[:subseries].to_s
-            end
-            attributes[:part] = numbering[:part].to_s if numbering[:part]
-          end
-        end
-
-        # Extract supplement/amendment/etc.
-        if content[:supplement]
-          attributes[:supplement] =
-            content[:supplement].to_s
-        end
-        attributes[:amendment] = content[:amendment].to_s if content[:amendment]
-        attributes[:annex] = content[:annex].to_s if content[:annex]
-        if content[:corrigendum]
-          attributes[:corrigendum] =
-            content[:corrigendum].to_s
-        end
-        attributes[:addendum] = content[:addendum].to_s if content[:addendum]
-
-        # Handle appendix (convert Roman numerals to Arabic)
-        if content[:appendix]
-          appendix = content[:appendix].to_s
-          attributes[:appendix] = roman_to_arabic(appendix) || appendix
-        end
-
-        # Extract date
-        if content[:date]
-          date = content[:date]
-          if date[:month] && date[:year]
-            attributes[:month] = date[:month].to_s
-            attributes[:year] = date[:year].to_s
-          elsif date[:year]
-            attributes[:year] = date[:year].to_s
-          end
-        end
-
-        # Extract second number (for combined standards like G.780/Y.1351)
-        if content[:second_number]
-          second = content[:second_number]
-          second_attrs = {}
-          second_attrs[:series] = second[:series].to_s if second[:series]
-          if second[:numbering]
-            numbering = second[:numbering]
-            if numbering[:number]
-              second_attrs[:number] =
-                numbering[:number].to_s
-            end
-            if numbering[:subseries]
-              second_attrs[:subseries] = numbering[:subseries].to_s
-            end
-            second_attrs[:part] = numbering[:part].to_s if numbering[:part]
-          end
-          attributes[:second_number] = second_attrs unless second_attrs.empty?
-        end
-
-        # Extract range (for Q.400-Q.490 style)
-        if content[:range_series] && content[:range_number]
-          attributes[:range] = {
-            series: content[:range_series].to_s,
-            number: content[:range_number].to_s,
-          }
-        end
-
-        attributes
-      end
-
-      # Convert Roman numerals to Arabic numbers
-      def self.roman_to_arabic(roman)
-        return roman unless roman.match?(/^[IVXLCDM]+$/i)
-
-        roman_map = {
-          "I" => 1, "V" => 5, "X" => 10, "L" => 50,
-          "C" => 100, "D" => 500, "M" => 1000
-        }
-
-        roman = roman.upcase
-        result = 0
-        prev_value = 0
-
-        roman.reverse.each_char do |char|
-          value = roman_map[char]
-          if value < prev_value
-            result -= value
-          else
-            result += value
-          end
-          prev_value = value
-        end
-
-        result.to_s
-      end
-    end
-  end
-end