pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/identifier_metadata.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Pubid
+  # Machine-readable metadata for identifier classes
+  # Provides a standardized way to describe identifier types for:
+  # - Index search and lookup
+  # - File naming conventions
+  # - Cross-references between flavors
+  # - Automated documentation generation
+  module IdentifierMetadata
+    class Metadata
+      attr_reader :flavor, :identifier_class, :type_key, :title, :short, :abbr,
+                  :base_class, :supplement_class, :stage_codes, :machine_codes
+
+      def initialize(flavor:, identifier_class:, type_key:, title:, short: nil,
+                     abbr: [], base_class: nil, supplement_class: nil,
+                     stage_codes: [], machine_codes: {}, **extra_metadata)
+        @flavor = flavor
+        @identifier_class = identifier_class
+        @type_key = type_key
+        @title = title
+        @short = short
+        @abbr = Array(abbr)
+        @base_class = base_class
+        @supplement_class = supplement_class
+        @stage_codes = Array(stage_codes)
+        @machine_codes = machine_codes
+        @extra_metadata = extra_metadata
+      end
+
+      # Fully qualified class name
+      def qualified_class_name
+        "#{flavor.capitalize}::#{identifier_class}"
+      end
+
+      # Machine-readable slug for file naming
+      def slug
+        "#{flavor}-#{type_key}".downcase.gsub(/[^a-z0-9]+/, "-")
+      end
+
+      # URN-style identifier for this type
+      def urn
+        "urn:pubid:#{flavor}:type:#{type_key}"
+      end
+
+      # Check if this identifier type matches a code
+      def matches_code?(code)
+        return false if code.nil?
+
+        code_str = code.to_s.downcase.strip
+        @abbr.map(&:to_s).map(&:downcase).include?(code_str) ||
+          @type_key.to_s.downcase == code_str
+      end
+
+      # Additional metadata accessors
+      def [](key)
+        @extra_metadata[key]
+      end
+
+      def to_h
+        {
+          flavor: @flavor,
+          identifier_class: @identifier_class,
+          type_key: @type_key,
+          title: @title,
+          short: @short,
+          abbr: @abbr,
+          base_class: @base_class,
+          supplement_class: @supplement_class,
+          stage_codes: @stage_codes,
+          machine_codes: @machine_codes,
+          slug: slug,
+          urn: urn,
+          qualified_class_name: qualified_class_name,
+        }.merge(@extra_metadata)
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+    end
+
+    module ClassMethods
+      # Define metadata for an identifier class
+      # @param attrs [Hash] Metadata attributes
+      def define_metadata(**attrs)
+        flavor = attrs.fetch(:flavor) do
+          # Extract flavor from class name (e.g., "Pubid::Iso::Identifiers::Foo" -> "iso")
+          name.to_s.split("::")[1..2]&.join("/")&.downcase || "unknown"
+        end
+
+        # Extract class name (e.g., "Pubid::Iso::Identifiers::Foo" -> "Foo")
+        identifier_class = name.to_s.split("::")&.last
+
+        @metadata = Metadata.new(
+          flavor: flavor,
+          identifier_class: identifier_class,
+          **attrs,
+        )
+      end
+
+      # Get the metadata for this class
+      # @return [Metadata, nil]
+      def metadata
+        @metadata ||= if superclass.is_a?(Class) && superclass.ancestors.include?(Pubid::IdentifierMetadata)
+                        superclass.metadata
+                      end
+      end
+
+      # Get the type key from metadata
+      # @return [Symbol, nil]
+      def type_key
+        metadata&.type_key
+      end
+
+      # Get the title from metadata
+      # @return [String, nil]
+      def type_title
+        metadata&.title
+      end
+    end
+
+    module InstanceMethods
+      # Get metadata for this instance's class
+      # @return [Metadata, nil]
+      def metadata
+        self.class.metadata
+      end
+
+      # Get the type key for this identifier
+      # @return [Symbol, nil]
+      def type_key
+        self.class.type_key
+      end
+
+      # Get the machine-readable slug
+      # @return [String, nil]
+      def slug
+        metadata&.slug
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.include(InstanceMethods)
+    end
+  end
+end

data/lib/pubid/idf/builder.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Idf
+    class Builder < Pubid::Builder::Base
+      LANG_CHAR_MAP = {
+        "R" => "ru",
+        "F" => "fr",
+        "E" => "en",
+        "A" => "ar",
+        "S" => "es",
+        "D" => "de",
+      }.freeze
+
+      def build(parsed_hash)
+        typed_stage = Pubid::Idf.locate_stage(parsed_hash[:type_with_stage])
+        identifier = Pubid::Idf.locate_type(typed_stage.type_code).new
+
+        if type_with_stage_fr = parsed_hash.delete(:type_with_stage_fr)
+          parsed_hash[:type_with_stage] = type_with_stage_fr
+        end
+
+        assign_attributes(identifier, parsed_hash)
+        identifier
+      end
+
+      private
+
+      def default_identifier_class
+        Identifiers::InternationalStandard
+      end
+
+      def cast(type, value)
+        case type
+        when :base
+          build(value)
+        when :publisher
+          Components::Publisher.new(body: value)
+        when :number_with_part
+          parts = value.to_s.split("-")
+          number = parts.shift
+          part = parts.shift
+          subpart = parts.size.positive? ? parts.join("-") : nil
+          code_hash = { number: number }
+          code_hash[:part] = part if part
+          code_hash[:subpart] = subpart if subpart
+          code_hash
+        when :type_with_stage
+          iteration = value.to_s.match(/(\d+)$/)
+          value = value.to_s.sub(iteration.to_s, "")
+          typed_stage = Pubid::Idf.locate_stage(value || "")
+          {
+            stage: typed_stage.to_stage,
+            type: typed_stage.to_type,
+            typed_stage: typed_stage,
+          }
+        when :date
+          value = value.to_s
+          if value.match?(/^\d{4}(-\d{2})?$/)
+            year, month = value.split("-")
+            Components::Date.new(year: year, month: month || nil)
+          elsif value.is_a?(Integer) || (value.is_a?(String) && value.match?(/^\d{4}$/))
+            Components::Date.new(year: value)
+          else
+            raise ArgumentError, "Invalid date format: #{value.inspect}"
+          end
+        when :languages
+          value = value.to_s.gsub("/", ",")
+          value.split(",").map do |lang|
+            lang = lang.strip
+            lang = LANG_CHAR_MAP[lang] if lang.length == 1
+            Components::Language.new(code: lang)
+          end
+        when :all_parts
+          Components::Locality.new(all_parts: true)
+        else
+          raise ArgumentError, "Unknown type: #{type}"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/idf/identifier.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Pubid
+  # Identifier that
+  module Idf
+    # An IDF identifier has no copublisher
+    class Identifier < ::Pubid::Identifier
+      attribute :typed_stage, Components::TypedStage
+
+      # `number`/`part`/`subpart` are declared here rather than inherited as a
+      # Components::Code: IDF stores a bare string in every one of them.
+      # Declaring on this class is safe because its body lives in this one file
+      # and is never reopened, so every subclass body opens after it has run
+      # (lutaml deep-dups the parent attribute table at class-definition time).
+      attribute :number, :string
+      attribute :part, :string
+      attribute :subpart, :string
+
+      def to_s(**opts)
+        render(format: :human, **opts)
+      end
+
+      def publisher_portion(lang: :en)
+        [
+          publisher.body,
+          (typed_stage.abbreviation.empty? ? "" : "/#{typed_stage.abbreviation}"),
+        ].join
+      end
+
+      def number_portion(lang_single: false)
+        [
+          # Directives may not have a number
+          (number ? " #{number}" : ""),
+
+          # Parts and subparts are optional
+          (part ? "-#{part}" : ""),
+          (subpart ? "-#{subpart}" : ""),
+
+          # Stage iteration is optional
+          (stage_iteration ? ".#{stage_iteration.number}" : ""),
+
+          # Date is optional
+          (date ? ":#{date.year}" : ""),
+
+          # Languages are optional
+          language_portion(lang_single: lang_single),
+        ].join
+      end
+
+      # Returns a string representation of the languages
+      # :single returns single-char language codes
+      def language_portion(lang_single: false)
+        return "" unless languages&.any?
+
+        [
+          "(",
+          languages.map do |lang|
+            lang.to_s(lang_single: lang_single)
+          end.join(lang_single ? "/" : ","),
+          ")",
+        ].join
+      end
+
+      def self.parse(string)
+        unless string.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if string.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        parsed = Pubid::Idf::Parser.new.parse(string)
+        Pubid::Idf::Builder.new.build(parsed)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Idf
+    module Identifiers
+      class Amendment < SupplementIdentifier
+        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            code: :published,
+            abbr: ["AMD"],
+            short_abbr: "AMD",
+            long_abbr: "AMD",
+            type_code: :amd,
+            stage_code: :published,
+            name: "Amendment",
+          ),
+        ].freeze
+
+        def self.type
+          { key: :amd,
+            web: :amendment, title: "Amendment", short: "AMD" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Idf
+    module Identifiers
+      class Corrigendum < SupplementIdentifier
+        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            code: :published,
+            abbr: ["COR"],
+            short_abbr: "COR",
+            long_abbr: "COR",
+            type_code: :cor,
+            stage_code: :published,
+            name: "Corrigendum",
+          ),
+        ].freeze
+
+        def self.type
+          { key: :cor,
+            web: :corrigendum, title: "Corrigendum", short: "COR" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/idf/identifiers/international_standard.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Idf
+    module Identifiers
+      # International Standard Identifier
+      class InternationalStandard < SingleIdentifier
+        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            code: :pwiis,
+            stage_code: :pwi,
+            type_code: :is,
+            abbr: ["PWI"],
+            name: "Proposed Work Item for International Standard",
+            harmonized_stages: %w[00.00 00.20 00.60 00.92 00.93 00.98 00.99],
+          ),
+          Components::TypedStage.new(
+            code: :isnp,
+            stage_code: :np,
+            type_code: :is,
+            abbr: ["NP", "NWIP"],
+            name: "New Work Item Proposal for International Standard",
+            harmonized_stages: %w[10.00 10.20 10.60 10.92 10.93 10.98],
+          ),
+          Components::TypedStage.new(
+            code: :awiis,
+            stage_code: :awi,
+            type_code: :is,
+            abbr: ["AWI"],
+            name: "Approved Work Item for International Standard",
+            harmonized_stages: %w[10.99 20.00],
+          ),
+          Components::TypedStage.new(
+            code: :wdis,
+            stage_code: :wd,
+            type_code: :is,
+            abbr: ["WD"],
+            name: "Working Draft for International Standard",
+            harmonized_stages: %w[20.20 20.60 20.92 20.93 20.98 20.99],
+          ),
+          Components::TypedStage.new(
+            code: :cdis,
+            stage_code: :cd,
+            type_code: :is,
+            abbr: ["CD"],
+            name: "Committee Draft for International Standard",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.93 30.98 30.99],
+          ),
+          Components::TypedStage.new(
+            code: :fcdis,
+            stage_code: :fcd,
+            type_code: :is,
+            abbr: ["FCD"],
+            name: "Final Committee Draft for International Standard",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.93 30.98 30.99],
+          ),
+          Components::TypedStage.new(
+            code: :dis,
+            stage_code: :dis,
+            type_code: :is,
+            abbr: ["DIS", "FPD"],
+            name: "Draft International Standard",
+            harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 40.98 40.99],
+          ),
+          Components::TypedStage.new(
+            code: :fdis,
+            stage_code: :fdis,
+            type_code: :is,
+            abbr: ["FDIS"],
+            name: "Final Draft International Standard",
+            harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+          ),
+          Components::TypedStage.new(
+            code: :prfis,
+            stage_code: :prf,
+            type_code: :is,
+            abbr: ["PRF", "Fpr"],
+            name: "Proof International Standard",
+            harmonized_stages: %w[60.00],
+          ),
+          Components::TypedStage.new(
+            code: :is,
+            stage_code: :published,
+            type_code: :is,
+            abbr: [""],
+            name: "International Standard",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+          Components::TypedStage.new(
+            code: :wdr,
+            stage_code: :wdr,
+            type_code: :is,
+            abbr: ["WDR"],
+            name: "Proposed for Withdrawal",
+            harmonized_stages: %w[90.92],
+          ),
+          Components::TypedStage.new(
+            code: :wda,
+            stage_code: :wda,
+            type_code: :is,
+            abbr: ["WDA"],
+            name: "Withdrawal Approved",
+            harmonized_stages: %w[90.93],
+          ),
+          Components::TypedStage.new(
+            code: :wdar,
+            stage_code: :wdar,
+            type_code: :is,
+            abbr: ["WDAR"],
+            name: "Withdrawal Archived",
+            harmonized_stages: %w[95.99],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :is,
+            web: :international_standard, title: "International Standard", short: nil }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/idf/identifiers/reviewed_method.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Idf
+    module Identifiers
+      class ReviewedMethod < SingleIdentifier
+        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            code: :pwirm,
+            stage_code: :pwi,
+            type_code: :rm,
+            abbr: ["PWI RM"],
+            name: "Proposed Work Item for Reviewed Method",
+            harmonized_stages: %w[00.00 00.20 00.60 00.92 00.93 00.98 00.99],
+          ),
+          Components::TypedStage.new(
+            code: :nprm,
+            stage_code: :np,
+            type_code: :rm,
+            abbr: ["NP RM"],
+            name: "New Work Item Proposal for Reviewed Method",
+            harmonized_stages: %w[10.00 10.20 10.60 10.92 10.93 10.98],
+          ),
+
+          Components::TypedStage.new(
+            code: :awirm,
+            stage_code: :awi,
+            type_code: :rm,
+            abbr: ["AWI RM"],
+            name: "Approved Work Item for Reviewed Method",
+            harmonized_stages: %w[10.99 20.00],
+          ),
+
+          Components::TypedStage.new(
+            code: :wdrm,
+            stage_code: :wd,
+            type_code: :rm,
+            abbr: ["WD RM"],
+            name: "Working Draft Reviewed Method",
+            harmonized_stages: %w[20.20 20.60 20.92 20.93 20.98 20.99],
+          ),
+
+          Components::TypedStage.new(
+            code: :cdrm,
+            stage_code: :cd,
+            type_code: :rm,
+            abbr: ["CD RM"],
+            name: "Committee Draft Reviewed Method",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.93 30.98 30.99],
+          ),
+          Components::TypedStage.new(
+            code: :pdrm,
+            stage_code: :cd,
+            type_code: :rm,
+            abbr: ["PDRM"],
+            name: "Proposed Draft Reviewed Method",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.93 30.98 30.99],
+          ),
+
+          Components::TypedStage.new(
+            code: :drm,
+            type_code: :rm,
+            abbr: ["DRM"],
+            name: "Draft Reviewed Method",
+            harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 40.98 40.99],
+          ),
+          Components::TypedStage.new(
+            code: :fdrm,
+            type_code: :rm,
+            abbr: ["FDRM"],
+            name: "Final Draft Reviewed Method",
+            harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+          ),
+
+          Components::TypedStage.new(
+            code: :prfrm,
+            stage_code: :prf,
+            type_code: :rm,
+            abbr: ["PRF RM"],
+            name: "Proof Reviewed Method",
+            harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+          ),
+          Components::TypedStage.new(
+            code: :pubrm,
+            stage_code: :published,
+            type_code: :rm,
+            abbr: ["RM"],
+            name: "Published Reviewed Method",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :rm,
+            web: :reviewed_method, title: "Reviewed Method", short: "RM" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/idf/identifiers.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Idf
+    module Identifiers
+      autoload :Amendment, "#{__dir__}/identifiers/amendment"
+      autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
+      autoload :InternationalStandard,
+               "#{__dir__}/identifiers/international_standard"
+      autoload :ReviewedMethod, "#{__dir__}/identifiers/reviewed_method"
+    end
+  end
+end