pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/idf/parser.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Idf
+    class Parser < ::Pubid::Parser::Grammar
+      include ::Pubid::Parser::CommonParseRules
+      include ::Pubid::Parser::CommonParseMethods
+
+      # We need to sort by length to match longest first because that's how Parslet works
+      TYPED_STAGES = Pubid::Idf.all_typed_stages
+        .map(&:abbr).flatten.sort_by(&:length).reverse
+      TYPED_STAGES_SUPPLEMENTS = Pubid::Idf.all_typed_stages
+        .select { |ts| %w[amd cor].include?(ts.type_code.to_s) }
+        .map(&:abbr).flatten.sort_by(&:length).reverse
+
+      root :identifier
+
+      rule(:identifier) do
+        supplement_identifier |
+          identifier_publisher
+      end
+
+      # IDF 125A:1988
+      rule(:prefix_sole_publisher) do
+        str("IDF").as(:publisher)
+      end
+
+      rule(:number_with_part) do
+        (number >> part_and_subpart.maybe).as(:number_with_part)
+      end
+
+      # IDF identifiers can contain alphanumeric characters
+      # IDF 125A:1988
+      rule(:number) do
+        match('\w').repeat(1, 5)
+      end
+
+      rule(:date) do
+        (year_digits >>
+          (dash >> month_digits).maybe >>
+          (dash >> day_digits).maybe
+        ).as(:date)
+      end
+
+      rule(:part_and_subpart) do
+        # IDF 80-1:2001
+        # the "space?" needed to handle "ISO/TS 10303- 1751:2014"
+        dash >> space? >>
+          # matches a part
+          match('\w').repeat >>
+          # matches a subpart, e.g. "A01" or "1-2" (yes we treat {5}-{1-1} as part and subpart)
+          (dash >> match('\w').repeat).repeat.maybe
+      end
+
+      rule(:all_parts) do
+        str("(all parts)").as(:all_parts)
+      end
+
+      rule(:type_with_stage) do
+        # IDF/RM 82:2004
+        # IDF/RM 254:2022
+        array_to_str(TYPED_STAGES).as(:type_with_stage) >>
+          (match('\d').as(:stage_iteration) >> space).maybe
+      end
+
+      rule(:language) do
+        # IDF/RM 82:2004(en,fr)
+        str("(") >>
+          (
+            # parse 2-char language codes: ru,en,fr,de,ar,es
+            (match["a-z"].repeat(1) >> str(",").maybe) |
+            # parse single language codes: R/E/F
+            (match["EFARDS"] >> str("/").maybe)
+          ).repeat.as(:languages) >>
+          str(")")
+      end
+
+      rule(:stage_iteration) do
+        # "ISO 11243.1"
+        str(".") >> match('\d').as(:stage_iteration)
+      end
+
+      rule(:second_part) do
+        number_with_part >>
+          stage_iteration.maybe >>
+          space? >> (
+            # :2005-02
+            str(":") >> date
+          ).maybe
+      end
+
+      rule(:third_part) do
+        # End of the identifier, we can have language, or all parts
+        space? >> language.maybe >> all_parts.maybe
+      end
+
+      # prefix sole publishers with type and stage
+      # IDF/RM 82:2004
+      rule(:identifier_publisher) do
+        identifier_publisher_no_third >> third_part
+      end
+
+      rule(:identifier_publisher_no_third) do
+        prefix_sole_publisher >> space? >> str("/").maybe >>
+          type_with_stage.maybe >>
+          space.maybe >>
+          second_part
+      end
+
+      rule(:supplement_type_with_stage) do
+        # "AMD" or "COR"
+        array_to_str(TYPED_STAGES_SUPPLEMENTS).as(:type_with_stage)
+      end
+
+      # IDF 148-1:2008 / COR 1:2009
+      # IDF 140-1:2007 / AMD1:2012 (no space between AMD and 1)
+      rule(:supplement_identifier_no_third) do
+        identifier_publisher_no_third.as(:base) >>
+          space? >> str("/") >> space? >>
+          supplement_type_with_stage >>
+          space.maybe >> second_part
+      end
+
+      rule(:supplement_identifier) do
+        supplement_identifier_no_third >> third_part
+      end
+
+      # # ISO/IEC 13818-1:2015/Amd 3:2016/Cor 1:2017
+      # # ISO/IEC 19794-7:2014/Amd 1:2015/CD Cor 1
+      # rule(:supplement_supplement_identifier) do
+      #   supplement_identifier_no_third.as(:base) >>
+      #     str("/") >> supplement_type_with_stage >>
+      #     # digits.as(:stage_iteration).maybe >>
+      #     space? >> second_part >> third_part
+      # end
+
+      rule(:dash) do
+        str("-") | str("‑") | str("‐")
+      end
+    end
+  end
+end

data/lib/pubid/idf/renderer.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Idf
+    # Human-readable renderer for IDF identifiers.
+    #
+    # Produces strings like:
+    #   "IDF 125:1988"
+    #   "IDF/AMD 1:2023"
+    #   "IDF 125:1988/AMD 1:2023"
+    #
+    # The renderer is registered as the `:human` format in the IDF format
+    # registry and invoked via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+
+        case id
+        when SupplementIdentifier
+          render_supplement(id, opts, context)
+        else
+          render_single(id, opts, context)
+        end
+      end
+
+      private
+
+      def render_single(id, opts, context)
+        [
+          publisher_portion(id, context),
+          number_portion(id, opts, context),
+        ].join
+      end
+
+      def publisher_portion(id, context)
+        [
+          id.publisher.render(context:),
+          (id.typed_stage.abbreviation.empty? ? "" : "/#{id.typed_stage.abbreviation}"),
+        ].join
+      end
+
+      def number_portion(id, opts, context)
+        lang_single = opts[:lang_single] || false
+
+        [
+          (id.number ? " #{id.number}" : ""),
+          (id.part ? "-#{id.part}" : ""),
+          (id.subpart ? "-#{id.subpart}" : ""),
+          (id.stage_iteration ? ".#{id.stage_iteration.render(context:)}" : ""),
+          (id.date ? ":#{id.date.render(context:)}" : ""),
+          language_portion(id, lang_single: lang_single),
+        ].join
+      end
+
+      def language_portion(id, lang_single: false)
+        return "" unless id.languages&.any?
+
+        [
+          "(",
+          id.languages.map do |lang|
+            lang.to_s(lang_single: lang_single)
+          end.join(lang_single ? "/" : ","),
+          ")",
+        ].join
+      end
+
+      def render_supplement(id, opts, context)
+        lang = opts[:lang] || :en
+        lang_single = opts[:lang_single] || false
+        with_edition = opts[:with_edition] || false
+
+        [
+          id.base.to_s(lang: lang, lang_single: lang_single,
+                                   with_edition: with_edition),
+          "/",
+          id.typed_stage.abbreviation,
+          " ",
+          id.number,
+          (id.date ? ":#{id.date.render(context:)}" : ""),
+        ].join
+      end
+    end
+  end
+end

data/lib/pubid/idf/single_identifier.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Idf
+    # Base class for single IDF identifiers (base documents)
+    #
+    # This class provides common attributes for all base document types
+    # like InternationalStandard and ReviewedMethod.
+    #
+    # Supplement identifiers (amendments, corrigenda) should NOT inherit
+    # from this class - they should inherit directly from Identifier.
+    #
+    # Note: The type attribute is inherited from the base Identifier class.
+    # Concrete classes should add their own default value like:
+    #   attribute :type, Components::Type, default: -> { self.class.type[:key] }
+    class SingleIdentifier < Identifier
+    end
+  end
+end

data/lib/pubid/idf/supplement_identifier.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Idf
+    # Base class for supplement identifiers (amendments, corrigenda).
+    #
+    # This class provides common attributes and behavior for all supplement
+    # identifier types. Supplements wrap a base identifier and add additional
+    # information like amendment/corrigendum number and date.
+    #
+    # Supplement identifiers should inherit from this class, not from
+    # SingleIdentifier (which is for base documents only).
+    #
+    # Architecture Note:
+    # - Supplements have a base attribute (recursive structure)
+    # - Supplements share the to_s rendering pattern
+    # - Supplements inherit typed_stage from base Identifier class
+    class SupplementIdentifier < Identifier
+      attribute :base, Identifier
+
+      # Render supplement identifier as string.
+      #
+      # Format: "base/ABBREVIATION number:year"
+      # Example: "IDF 125:1988/AMD 1:2023"
+      #
+      # @param lang [Symbol] Language (default: :en)
+      # @param lang_single [Boolean] Use single-char language codes (default: false)
+      # @param with_edition [Boolean] Include edition (default: false)
+      # @return [String] String representation of supplement
+      def to_s(**opts)
+        render(format: :human, **opts)
+      end
+    end
+  end
+end

data/lib/pubid/idf/urn_generator.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Idf
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def urn_type
+        return nil unless identifier.type
+
+        identifier.type.abbr.to_s.downcase
+      end
+
+      def generate
+        parts = ["urn", "idf"]
+        parts << urn_number if urn_number
+        parts << urn_part if urn_part
+        parts << urn_subpart if urn_subpart
+        parts << urn_year if urn_year
+        parts << urn_edition if urn_edition
+        parts << urn_type if urn_type
+
+        if identifier.publisher
+          parts[1] = identifier.publisher.render(context: URN_CONTEXT)
+        end
+
+        if identifier.copublishers&.any?
+          copubs = identifier.copublishers.map { |cp| cp.render(context: URN_CONTEXT) }
+          parts[1] = "#{parts[1]}-#{copubs.join('-')}"
+        end
+
+        if identifier.languages&.any?
+          parts << identifier.languages.map(&:code).join(",")
+        end
+
+        if identifier.is_a?(SupplementIdentifier)
+          if identifier.typed_stage
+            supp_type = identifier.typed_stage.type_code.to_s
+            parts << supp_type if supp_type
+          end
+
+          if identifier.number
+            parts << identifier.number
+          end
+        end
+
+        parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/idf/urn_parser.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Idf
+    # Parses IDF URNs back into identifiers.
+    #
+    # UrnGenerator emits: `urn:idf:{number}:{year}:` with a trailing empty
+    # field (a known quirk of the generator).
+    #
+    # Examples:
+    # - urn:idf:87:2019: → IDF 87:2019
+    # - urn:idf:100:     → IDF 100
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body).reject(&:empty?)
+
+        number, year = parts
+        text = "IDF #{number}"
+        text += ":#{year}" if year
+        flavor_parse(text)
+      end
+    end
+  end
+end

data/lib/pubid/idf.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Idf
+    extend Pubid::PrefixesSupport
+
+    # Sole IDF publisher token (see the parser's `prefix_sole_publisher` rule).
+    PREFIXES = ["IDF"].freeze
+
+    autoload :Builder, "#{__dir__}/idf/builder"
+    autoload :Identifier, "#{__dir__}/idf/identifier"
+    autoload :Identifiers, "#{__dir__}/idf/identifiers"
+    autoload :Parser, "#{__dir__}/idf/parser"
+    autoload :Renderer, "#{__dir__}/idf/renderer"
+    autoload :SingleIdentifier, "#{__dir__}/idf/single_identifier"
+    autoload :SupplementIdentifier, "#{__dir__}/idf/supplement_identifier"
+    autoload :UrnGenerator, "#{__dir__}/idf/urn_generator"
+    autoload :UrnParser, "#{__dir__}/idf/urn_parser"
+
+    def self.parse(identifier)
+      unless identifier.is_a?(String)
+        raise Pubid::Errors::InvalidInputError,
+              Pubid::INPUT_NOT_A_STRING_MESSAGE
+      end
+
+      if identifier.length > Pubid::MAX_INPUT_LENGTH
+        raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+      end
+
+      parser = Parser.new
+      builder = Builder.new
+
+      parsed = parser.parse(identifier)
+      builder.build(parsed)
+    end
+
+    # Build an IDF identifier from a parse-tree hash (used by ISO joint-identifier
+    # parsing). This is the public seam: callers should never reach into
+    # `Idf::Builder` directly.
+    # @param hash [Hash] parse tree for the joint identifier
+    # @return [Pubid::Idf::Identifier]
+    def self.build_from_parse(hash)
+      Builder.new.build(hash)
+    end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Idf::Renderer)
+
+    # Auto-discover all identifier types from the Identifiers namespace
+    # @return [Array<Class>] identifier classes that define a self.type Hash
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants
+        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
+        .select { |c| c.is_a?(Class) && c.singleton_methods(false).include?(:type) }
+        .select { |c| c.type.is_a?(Hash) }
+    end
+
+    # Build typed stage index from identifier types
+    # @return [Array<Pubid::Components::TypedStage>] all typed stages
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        if klass.const_defined?(:TYPED_STAGES)
+          klass.const_get(:TYPED_STAGES)
+        else
+          []
+        end
+      end
+    end
+
+    # Lookup: type code -> identifier class
+    # @param code [String, Symbol] the type key to find
+    # @return [Class, nil] the matching identifier class
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    # Lookup: abbreviation -> typed stage
+    # @param abbr [String, Symbol] the abbreviation to find
+    # @return [Pubid::Components::TypedStage, nil] the matching typed stage
+    def self.locate_stage(abbr)
+      abbr_str = abbr.to_s.upcase
+      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
+    end
+  end
+end
+
+# Register Uidf flavor with the registry
+Pubid::Registry.register(:idf, Pubid::Idf)