pubid 2.0.0.pre.alpha.8 → 2.0.0.pre.alpha.11

data/lib/pubid/renderers/directives_renderer.rb

@@ -50,15 +50,15 @@ module Pubid
         ann = context.annotated
         parts = []
         if @id.number
-          parts << annotate(@id.number.render(context:), "docnumber",
+          parts << annotate(render_component(@id.number, context), "docnumber",
                             annotated: ann)
         end
         if @id.part
-          parts << " #{annotate(@id.part.render(context:), 'part', 
+          parts << " #{annotate(render_component(@id.part, context), 'part', 
                                 annotated: ann)}"
         end
         if @id.subpart
-          parts << "-#{annotate(@id.subpart.render(context:), 'part', 
+          parts << "-#{annotate(render_component(@id.subpart, context), 'part', 
                                 annotated: ann)}"
         end
         if @id.stage_iteration

data/lib/pubid/renderers/human_readable.rb

@@ -3,7 +3,9 @@
 module Pubid
   module Renderers
     class HumanReadable < Base
-      def render(context:, with_edition: false)
+      # `**_opts` absorbs render flags that only some flavors honour (e.g. the
+      # IEEE-specific `:trademark`), so the shared renderer tolerates them.
+      def render(context:, with_edition: false, **_opts)
         parts = []
         parts << render_publisher_and_stage(context)
         parts << render_number_portion(context)
@@ -39,15 +41,15 @@ module Pubid
         ann = context.annotated
         parts = []
         if @id.number
-          parts << annotate(@id.number.render(context:), "docnumber",
+          parts << annotate(render_component(@id.number, context), "docnumber",
                             annotated: ann)
         end
         if @id.part
-          parts << "-#{annotate(@id.part.render(context:), 'part', 
+          parts << "-#{annotate(render_component(@id.part, context), 'part', 
                                 annotated: ann)}"
         end
         if @id.subpart
-          parts << "-#{annotate(@id.subpart.render(context:), 'part', 
+          parts << "-#{annotate(render_component(@id.subpart, context), 'part', 
                                 annotated: ann)}"
         end
         if @id.stage_iteration

data/lib/pubid/renderers/mr_string.rb

@@ -2,14 +2,62 @@
 
 module Pubid
   module Renderers
+    # Machine-readable string renderer.
+    #
+    # Produces a lossless, dot-separated, all-lowercase, filename-safe slug:
+    #
+    #   iso 9001:2015                       -> iso.9001.2015
+    #   iso/iec 17031-1:2020                -> iso-iec.17031-1.2020
+    #   iso 1234-1-2-3:2020                 -> iso.1234-1-2-3.2020
+    #   iso/tr 14627:2017                   -> iso.tr.14627.2017
+    #   iso 16634:--                        -> iso.16634.--
+    #   iso 9001:2015/amd 1:2020            -> iso.9001.2015_amd.1.2020
+    #   iso/iec 13818-1:2015/amd 3:2016/cor 1:2017
+    #                                       -> iso-iec.13818-1.2015_amd.3.2016_cor.1.2017
+    #
+    # The renderer recurses into a supplement's `base` (one level per
+    # `mr_supplement_suffix`) so chained Cor-Amd-IS structures render fully,
+    # instead of every supplement layer collapsing onto its own
+    # type/number/year and dropping the base (issue #142).
+    #
+    # Character set is restricted to [a-z0-9.-] plus `_` (supplement
+    # separator), so `to_mr_string` doubles as a filesystem-/URL-safe slug.
+    # `Identifier#to_slug` delegates here; NIST is the one flavor that
+    # overrides `to_slug` because its MR shape is fixed by the pubid standard
+    # and stays uppercase.
     class MrString < Base
+      SEPARATOR_SUPPLEMENT = "_"
+
+      # The flat MR segments, in order, as the hook each one reads. A hook
+      # returning nil contributes no segment, so a flavor fills only the slots
+      # its identity actually uses — `mr_volume` (ECMA) is nil everywhere else.
+      SEGMENTS = %i[
+        mr_publisher
+        mr_type
+        mr_number_with_part
+        mr_year
+        mr_edition
+        mr_volume
+        mr_languages
+        mr_all_parts
+      ].freeze
+
       def render(context: nil, **)
-        parts = []
-        parts << @id.mr_publisher
-        parts << @id.mr_type
-        parts << @id.mr_number_with_part
-        parts << @id.mr_year
-        parts.compact.join(".")
+        suffix = @id.mr_supplement_suffix
+
+        if suffix
+          base = @id.base
+          head = base ? self.class.new(base).render : ""
+          head.empty? ? suffix : "#{head}#{SEPARATOR_SUPPLEMENT}#{suffix}"
+        else
+          render_flat(@id)
+        end
+      end
+
+      private
+
+      def render_flat(id)
+        SEGMENTS.filter_map { |hook| id.public_send(hook) }.join(".")
       end
     end
   end

data/lib/pubid/renderers/supplement_renderer.rb

@@ -6,7 +6,7 @@ module Pubid
       def render(context:, with_edition: false)
         parts = []
 
-        base_str = @id.base_identifier.to_s(
+        base_str = @id.base.to_s(
           with_edition: with_edition,
           stage_format_long: context.stage_format_long,
           with_date: context.with_date,

data/lib/pubid/renderers.rb

@@ -2,6 +2,7 @@
 
 module Pubid
   module Renderers
+    autoload :Annotator, "pubid/renderers/annotator"
     autoload :Base, "pubid/renderers/base"
     autoload :DirectivesRenderer, "pubid/renderers/directives_renderer"
     autoload :GuideRenderer, "pubid/renderers/guide_renderer"

data/lib/pubid/rendering/numbering.rb

@@ -4,21 +4,39 @@ module Pubid
   module Rendering
     module Numbering
       # Render number with optional parts and subparts
-      # @param number [Components::Code] primary number
-      # @param part [Components::Code, nil] optional part
-      # @param subpart [Components::Code, nil] optional subpart
+      # @param number [Components::Code, String, nil] primary number
+      # @param part [Components::Code, String, nil] optional part
+      # @param subpart [Components::Code, String, nil] optional subpart
       # @param options [Hash] rendering options
       # @return [String] formatted numbering string
       def render_numbering(number, part = nil, subpart = nil, **options)
-        return "" unless number&.value
+        number_str = numbering_value(number)
+        return "" unless number_str
 
-        result = " #{number.value}"
+        result = " #{number_str}"
         separator = options[:part_separator] || "-"
-        result += "#{separator}#{part.value}" if part&.value
-        result += "#{separator}#{subpart.value}" if subpart&.value
+        [part, subpart].each do |component|
+          value = numbering_value(component)
+          result += "#{separator}#{value}" if value
+        end
 
         result
       end
+
+      private
+
+      # `number`/`part`/`subpart` are a Components::Code on ::Pubid::Identifier
+      # but a plain :string in a growing number of flavors, so read the value
+      # through whichever shape the caller holds. Returns nil for an absent or
+      # empty component, which is what suppresses the segment.
+      def numbering_value(component)
+        return nil if component.nil?
+
+        value = component.respond_to?(:value) ? component.value : component
+        return nil if value.nil? || value.to_s.empty?
+
+        value.to_s
+      end
     end
   end
 end

data/lib/pubid/rendering/supplement.rb

@@ -4,14 +4,14 @@ module Pubid
   module Rendering
     module Supplement
       # Render supplement identifiers (amendment, corrigendum, addendum, etc.)
-      # @param base_identifier [Identifier] base identifier
+      # @param base [Identifier] base identifier
       # @param supplements [Array<Hash>] list of supplements
       # @param options [Hash] rendering options
       # @return [String] formatted supplement string
-      def render_supplements(base_identifier, supplements, **options)
-        return base_identifier.to_s(**options) unless supplements&.any?
+      def render_supplements(base, supplements, **options)
+        return base.to_s(**options) unless supplements&.any?
 
-        result = base_identifier.to_s(**options)
+        result = base.to_s(**options)
 
         supplements.each do |supp|
           result += render_single_supplement(supp, **options)

data/lib/pubid/rendering.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Rendering
     autoload :Date, "pubid/rendering/date"

data/lib/pubid/sae/builder.rb

@@ -10,7 +10,7 @@ module Pubid
       private
 
       def default_identifier_class
-        Identifiers::Base
+        Identifier
       end
 
       def cast(type, value)

data/lib/pubid/sae/identifier.rb

@@ -1,6 +1,4 @@
 # frozen_string_literal: true
 
 # Pubid::Sae::Identifier is the SAE base class (a real Pubid::Identifier
-# subclass); its body, `.parse`, and the Identifiers::Base back-compat alias
-# live in identifiers/base.rb. This file just ensures it is loaded.
-require_relative "identifiers/base"
+# subclass); its body and `.parse` live in identifiers/base.rb. This file just ensures it is loaded.

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

@@ -2,16 +2,22 @@
 
 module Pubid
   module Sae
-    # Base SAE Identifier. Canonical name Pubid::Sae::Identifier (Identifiers::Base
-    # is a back-compat alias). SAE has a single identifier class that IS the
+    # Base SAE Identifier. Canonical name Pubid::Sae::Identifier. SAE has a single identifier class that IS the
     # document type, so this class is both the base and the only concrete type.
     # Handles all SAE document types (AMS, AIR, ARP, AS, MA).
     class Identifier < ::Pubid::Identifier
       def self.parse(input)
+        unless input.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if input.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
         parsed = Parser.parse(input)
         Builder.build(parsed)
-      rescue Parslet::ParseFailed => e
-        raise "Failed to parse SAE identifier: #{input}\n#{e.message}"
       end
 
       attribute :publisher, :string, default: -> { "SAE" }
@@ -26,12 +32,16 @@ module Pubid
       def year
         date&.year
       end
-    end
 
-    module Identifiers
-      # Backward-compatible alias: SAE's base class used to be
-      # Pubid::Sae::Identifiers::Base. It is now Pubid::Sae::Identifier.
-      Base = Pubid::Sae::Identifier
+      # SAE encodes the document class (AS, ARP, AMS, AIR, J, …) in `type.abbr`,
+      # not in `typed_stage.type_code`, so the generic mr_type returns nil.
+      # Losslessness requires the type letter to appear in MR — without it,
+      # `SAE J300` and `SAE AS300` would collide on `SAE.300.<year>`.
+      # Lowercased to match the all-lowercase MR convention (issue #142).
+      def mr_type
+        type&.abbr&.to_s&.downcase
+      end
     end
+
   end
 end

data/lib/pubid/sae/identifiers.rb

@@ -3,7 +3,6 @@
 module Pubid
   module Sae
     module Identifiers
-      autoload :Base, "#{__dir__}/identifiers/base"
     end
   end
 end

data/lib/pubid/sae/parser.rb

@@ -4,7 +4,7 @@ require "parslet"
 
 module Pubid
   module Sae
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       rule(:space) { str(" ") }
       rule(:digit) { match["0-9"] }
       rule(:digits) { digit.repeat(1) }

data/lib/pubid/sae.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Sae
     extend Pubid::PrefixesSupport
@@ -10,7 +11,7 @@ module Pubid
 
     autoload :Builder, "#{__dir__}/sae/builder"
     autoload :Components, "#{__dir__}/sae/components"
-    autoload :Identifier, "#{__dir__}/sae/identifier"
+    autoload :Identifier, "#{__dir__}/sae/identifiers/base"
     autoload :Identifiers, "#{__dir__}/sae/identifiers"
     autoload :Parser, "#{__dir__}/sae/parser"
     autoload :Renderer, "#{__dir__}/sae/renderer"
@@ -62,5 +63,5 @@ end
 Pubid::Registry.register(:sae, Pubid::Sae)
 
 # Per-flavor format registry: inherits global formats, overrides :human
-Pubid::Sae::Identifiers::Base.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
-Pubid::Sae::Identifiers::Base.format_registry.register(:human, renderer: Pubid::Sae::Renderer)
+Pubid::Sae::Identifier.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
+Pubid::Sae::Identifier.format_registry.register(:human, renderer: Pubid::Sae::Renderer)

data/lib/pubid/schema/declaration.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Schema
+    # A loaded flavor declaration (schema/{flavor}.yaml).
+    class Declaration
+      attr_reader :flavor, :schema_version, :prefixes, :identifier_types
+
+      def initialize(flavor:, schema_version:, prefixes:, identifier_types:)
+        @flavor = flavor
+        @schema_version = schema_version
+        @prefixes = prefixes.freeze
+        @identifier_types = identifier_types.map(&:freeze).freeze
+        freeze
+      end
+
+      # Own tokens plus joint/co-publication tokens from
+      # schema/core/joint_prefixes.yaml - mirrors the runtime
+      # Pubid::{Flavor}.prefixes contract (see PrefixesSupport).
+      def merged_prefixes
+        (prefixes + Loader.joint_prefixes_for(flavor)).freeze
+      end
+
+      def type_for(key)
+        identifier_types.find { |type| type.key == key }
+      end
+
+      def types_count
+        identifier_types.size
+      end
+    end
+  end
+end

data/lib/pubid/schema/error.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Schema
+    # Base error for schema loading and lookup failures.
+    class Error < StandardError; end
+
+    # Raised when a flavor declaration file cannot be found.
+    class NotFoundError < Error; end
+
+    # Raised when a declaration file violates the format contract.
+    class InvalidError < Error; end
+  end
+end

data/lib/pubid/schema/identifier_type.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Schema
+    # One identifier type declaration (e.g. iso "amendment", iec "vap").
+    class IdentifierType
+      attr_reader :key, :title, :short, :abbr, :typed_stages
+
+      def initialize(key:, title:, short: nil, abbr: [], typed_stages: [])
+        @key = key
+        @title = title
+        @short = short
+        @abbr = abbr.freeze
+        @typed_stages = typed_stages.map(&:freeze).freeze
+        freeze
+      end
+
+      def typed_stage_for_abbr(candidate)
+        typed_stages.find { |stage| stage.matches_abbr?(candidate) }
+      end
+    end
+  end
+end

data/lib/pubid/schema/loader.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Schema
+    # Loads and validates flavor declarations from schema/. Declarations
+    # are memoized and deeply frozen; loading is lazy per flavor so the
+    # parse hot path pays no boot cost.
+    class Loader
+      SCHEMA_ROOT = File.expand_path("../../../schema", __dir__).freeze
+      CORE_DIR = File.join(SCHEMA_ROOT, "core").freeze
+
+      class << self
+        def for(flavor)
+          flavor = flavor.to_s
+          declarations[flavor] ||= build_declaration(flavor)
+        end
+
+        def joint_prefixes_for(flavor)
+          joint_prefixes[flavor.to_s] || [].freeze
+        end
+
+        # Full joint-prefix map (flavor key => tokens) from
+        # schema/core/joint_prefixes.yaml.
+        def joint_prefixes_map
+          joint_prefixes
+        end
+
+        def loaded_flavors
+          declarations.keys.sort
+        end
+
+        private
+
+        def declarations
+          @declarations ||= {}
+        end
+
+        def joint_prefixes
+          @joint_prefixes ||= load_joint_prefixes
+        end
+
+        def load_joint_prefixes
+          path = File.join(CORE_DIR, "joint_prefixes.yaml")
+          data = YAML.safe_load_file(path)
+          data.fetch("joint_prefixes")
+            .transform_values(&:freeze)
+            .freeze
+        rescue Errno::ENOENT, KeyError => e
+          raise InvalidError, "cannot load #{path}: #{e.message}"
+        end
+
+        def build_declaration(flavor)
+          path = declaration_path(flavor)
+          data = YAML.safe_load_file(path)
+          validate!(flavor, path, data)
+          Declaration.new(
+            flavor: data.fetch("flavor"),
+            schema_version: data.fetch("schema_version"),
+            prefixes: data.fetch("prefixes"),
+            identifier_types: parse_identifier_types(data),
+          ).freeze
+        end
+
+        def declaration_path(flavor)
+          path = File.join(SCHEMA_ROOT, "#{flavor}.yaml")
+          unless File.exist?(path)
+            raise NotFoundError, "no declaration for #{flavor} at #{path}"
+          end
+
+          path
+        end
+
+        def parse_identifier_types(data)
+          data.fetch("identifier_types")
+            .map { |entry| parse_identifier_type(entry) }
+        end
+
+        def parse_identifier_type(entry)
+          IdentifierType.new(
+            key: entry.fetch("key"),
+            title: entry.fetch("title"),
+            short: entry["short"],
+            abbr: entry["abbr"] || [],
+            typed_stages: parse_typed_stages(entry),
+          )
+        end
+
+        def parse_typed_stages(entry)
+          (entry["typed_stages"] || []).map { |stage| parse_typed_stage(stage) }
+        end
+
+        def parse_typed_stage(stage)
+          TypedStage.new(
+            stage_code: stage.fetch("stage_code"),
+            type_code: stage["type_code"],
+            abbr: stage.fetch("abbr"),
+            name: stage["name"],
+            harmonized_stages: stage["harmonized_stages"] || [],
+          )
+        end
+
+        def validate!(flavor, path, data)
+          raise InvalidError, "#{path}: not a mapping" unless data.is_a?(Hash)
+
+          %w[flavor schema_version prefixes identifier_types].each do |key|
+            next if data.key?(key)
+
+            raise InvalidError, "#{path}: missing required key #{key}"
+          end
+          return unless data["flavor"] != flavor
+
+          raise InvalidError, "#{path}: flavor/file mismatch"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/schema/typed_stage.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Schema
+    # One typed stage entry of an identifier type declaration.
+    class TypedStage
+      attr_reader :stage_code, :type_code, :abbr, :name, :harmonized_stages
+
+      def initialize(stage_code:, type_code: nil, abbr: [], name: nil,
+                     harmonized_stages: [])
+        @stage_code = stage_code
+        @type_code = type_code
+        @abbr = abbr.freeze
+        @name = name
+        @harmonized_stages = harmonized_stages.freeze
+        freeze
+      end
+
+      def matches_abbr?(candidate)
+        abbr.include?(candidate)
+      end
+    end
+  end
+end

data/lib/pubid/schema.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Pubid
+  # Single source of truth declarations (schema/ directory). TODO 03 of the
+  # SSOT restructure: loader and value objects. TODO 04-07 make the runtime
+  # a consumer of these declarations (registry bridge, prefixes, metadata).
+  module Schema
+    autoload :Error, "pubid/schema/error"
+    autoload :NotFoundError, "pubid/schema/error"
+    autoload :InvalidError, "pubid/schema/error"
+    autoload :TypedStage, "pubid/schema/typed_stage"
+    autoload :IdentifierType, "pubid/schema/identifier_type"
+    autoload :Declaration, "pubid/schema/declaration"
+    autoload :Loader, "pubid/schema/loader"
+
+    class << self
+      # Pubid::Schema.for("iso") => frozen Pubid::Schema::Declaration
+      def for(flavor)
+        Loader.for(flavor)
+      end
+    end
+  end
+end

data/lib/pubid/tgpp/builder.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Tgpp
+    class Builder
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
+
+      def build(data)
+        identifier_class(data[:type]).new(
+          number: data[:number].to_s,
+          suffix: data[:suffix]&.to_s,
+          parts: extract_part_strings(data[:parts]),
+          release: data[:release]&.to_s,
+          version: data[:version]&.to_s,
+        )
+      end
+
+      private
+
+      def identifier_class(type)
+        if type.to_s == "TR"
+          Identifiers::TechnicalReport
+        else
+          Identifiers::TechnicalSpecification
+        end
+      end
+
+      # parts_data is an array of `{ part: "1" }` hashes (or a single hash for a
+      # one-level part); return the part numbers as strings.
+      def extract_part_strings(parts_data)
+        case parts_data
+        when Array then parts_data.filter_map { |h| h[:part]&.to_s }
+        when Hash then [parts_data[:part]&.to_s].compact
+        else []
+        end
+      end
+    end
+  end
+end