pubid 2.0.0.alpha.10 → 2.0.0.pre.alpha.1

data/lib/pubid/rendering/base.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative "publisher"
+require_relative "numbering"
+require_relative "date"
+require_relative "supplement"
+require_relative "stage"
+require_relative "language"
+require_relative "format"
+
+module Pubid
+  module Rendering
+    module Base
+      include Pubid::Rendering::Publisher
+      include Pubid::Rendering::Numbering
+      include Pubid::Rendering::Date
+      include Pubid::Rendering::Supplement
+      include Pubid::Rendering::Stage
+      include Pubid::Rendering::Language
+      include Pubid::Rendering::Format
+
+      # Base rendering method to be composed by subclasses
+      # @param options [Hash] rendering options
+      # @return [String] formatted identifier string
+      def render_base(**options)
+        parts = []
+
+        # Publisher/copublisher
+        pub = maybe(:publisher)
+        if pub
+          parts << render_publisher(pub,
+                                    maybe(:copublishers), **options)
+        end
+
+        # Numbering (number, part, subpart)
+        num = maybe(:number)
+        if num
+          parts << render_numbering(num, maybe(:part),
+                                    maybe(:subpart), **options)
+        end
+
+        # Date
+        d = maybe(:date)
+        if d
+          parts << render_date(d, **options)
+        end
+
+        # Stage and type
+        stg = maybe(:stage)
+        if stg
+          parts << render_stage(stg, maybe(:type),
+                                has_copublisher: maybe(:copublishers)&.any?, **options)
+        end
+
+        # Language codes
+        langs = maybe(:languages)
+        if langs&.any?
+          parts << render_languages(langs, **options)
+        end
+
+        parts.compact.join
+      end
+
+      private
+
+      def maybe(method_name)
+        return nil unless self.class.attributes.key?(method_name)
+
+        public_send(method_name)
+      end
+    end
+  end
+end

data/lib/pubid/rendering/common.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Rendering
+    # Common rendering methods for identifier string representation
+    #
+    # This module extracts duplicated rendering logic across flavors
+    # to reduce code duplication and ensure consistency.
+    #
+    # == Usage
+    #
+    # Include this module in flavor-specific identifier base classes:
+    #
+    #   class Base < ::Pubid::Identifier
+    #     include Pubid::Rendering::Common
+    #
+    #     def to_s(lang: :en, lang_single: false, with_edition: false)
+    #       render_identifier(lang: lang, lang_single: lang_single, with_edition: with_edition)
+    #     end
+    #   end
+    #
+    module Common
+      # Render publisher with optional copublishers
+      #
+      # @param publisher [Components::Publisher] publisher component
+      # @param copublisher_separator [String] separator for copublishers (default: "/")
+      # @return [String] formatted publisher string
+      def render_publisher(publisher, copublisher_separator: "/")
+        return "" unless publisher
+
+        result = publisher.to_s
+        cops = publisher.is_a?(Components::Publisher) ? publisher.copublisher : nil
+        if cops&.any?
+          result += cops.map do |cp|
+            "#{copublisher_separator}#{cp}"
+          end.join
+        end
+        result
+      end
+
+      # Render stage and type abbreviations with proper separators
+      #
+      # @param stage [Components::Stage] stage component
+      # @param type [Components::Type] type component
+      # @param has_copublisher [Boolean] whether identifier has copublisher
+      # @param default_type_abbr [String] default type abbreviation to skip (default: "IS")
+      # @param stage_separator [String] separator before stage without copublisher
+      # @return [String] formatted stage/type string
+      def render_stage_type(stage, type, has_copublisher: false,
+                           default_type_abbr: "IS",
+                           stage_separator: "/")
+        result = ""
+
+        # Add stage abbreviation if present
+        if stage&.abbr
+          sep = has_copublisher ? " " : stage_separator
+          result += "#{sep}#{stage.abbr}"
+        end
+
+        # Add type abbreviation if present and not default
+        if type&.abbr && type.abbr != default_type_abbr
+          # Separator: space after stage or copublisher, slash otherwise
+          has_prefix = stage&.abbr || has_copublisher
+          sep = has_prefix ? " " : stage_separator
+          result += "#{sep}#{type.abbr}"
+        end
+
+        result
+      end
+
+      # Render number with optional parts
+      #
+      # @param number [Components::Code] primary number component
+      # @param part [Components::Code] optional part component
+      # @param subpart [Components::Code] optional subpart component
+      # @param part_separator [String] separator for parts (default: "-")
+      # @return [String] formatted numbering string
+      def render_numbering(number, part = nil, subpart = nil,
+part_separator: "-")
+        return "" unless number&.value
+
+        result = " #{number.value}"
+        result += "#{part_separator}#{part.value}" if part&.value
+        result += "#{part_separator}#{subpart.value}" if subpart&.value
+        result
+      end
+
+      # Render stage iteration (e.g., ".1" for stage iteration)
+      #
+      # @param stage_iteration [Components::Code] stage iteration component
+      # @return [String] formatted stage iteration or empty string
+      def render_stage_iteration(stage_iteration)
+        stage_iteration&.value ? ".#{stage_iteration.value}" : ""
+      end
+
+      # Render date with optional year/month/day
+      #
+      # @param date [Components::Date] date component
+      # @param include_month [Boolean] include month in output
+      # @param date_separator [String] separator for date parts (default: "-")
+      # @return [String] formatted date string or empty string
+      def render_date(date, include_month: false, date_separator: "-")
+        return "" unless date&.year
+
+        result = ":#{date.year}"
+        if date.month && include_month
+          result += "#{date_separator}#{format('%02d', date.month)}"
+          result += "#{date_separator}#{format('%02d', date.day)}" if date.day
+        end
+        result
+      end
+
+      # Render language codes
+      #
+      # @param languages [Array<Components::Language>] language components
+      # @param lang_single [Boolean] use single character format
+      # @param lang_separator [String] separator between languages (default: "/")
+      # @return [String] formatted language string or empty string
+      def render_languages(languages, lang_single: false, lang_separator: "/")
+        return "" unless languages&.any?
+
+        formatted = languages.map do |l|
+          l.to_s(lang_single: lang_single)
+        end.join(lang_separator)
+        "(#{formatted})"
+      end
+
+      # Render edition component
+      #
+      # @param edition [Components::Edition] edition component
+      # @param with_prefix [Boolean] include prefix (default: true)
+      # @return [String] formatted edition string or empty string
+      def render_edition(edition, with_prefix: true)
+        return "" unless edition
+
+        if with_prefix
+          edition.to_s
+        else
+          " #{edition}"
+        end
+      end
+
+      # Check if publisher has copublishers
+      #
+      # @param publisher [Components::Publisher] publisher component
+      # @return [Boolean] true if has copublishers
+      def publisher_has_copublisher?(publisher)
+        publisher.is_a?(Components::Publisher) && publisher.has_copublisher?
+      end
+
+      # Get publisher body/name
+      #
+      # @param publisher [Components::Publisher] publisher component
+      # @return [String] publisher body
+      def publisher_body(publisher)
+        publisher.is_a?(Components::Publisher) ? publisher.body : publisher.to_s
+      end
+
+      # Get copublishers as array
+      #
+      # @param publisher [Components::Publisher] publisher component
+      # @return [Array<String>] array of copublisher names
+      def copublishers_list(publisher)
+        return [] unless publisher.is_a?(Components::Publisher) && publisher.copublisher&.any?
+
+        publisher.copublisher.map { |cp| publisher_body(cp) }
+      end
+
+      # Render full identifier with all components
+      #
+      # This is a convenience method that combines all rendering methods
+      # in the standard order for most identifier types.
+      #
+      # @param publisher [Components::Publisher] publisher component
+      # @param stage [Components::Stage] stage component
+      # @param type [Components::Type] type component
+      # @param number [Components::Code] number component
+      # @param part [Components::Code] part component
+      # @param subpart [Components::Code] subpart component
+      # @param stage_iteration [Components::Code] stage iteration component
+      # @param date [Components::Date] date component
+      # @param edition [Components::Edition] edition component
+      # @param languages [Array<Components::Language>] language components
+      # @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
+      # @param default_type_abbr [String] default type abbreviation to skip
+      # @return [String] formatted identifier string
+      def render_full_identifier(publisher:, stage: nil, type: nil,
+                                 number: nil, part: nil, subpart: nil,
+                                 stage_iteration: nil, date: nil,
+                                 edition: nil, languages: nil,
+                                 lang: :en, lang_single: false,
+                                 with_edition: false,
+                                 default_type_abbr: "IS")
+        result = render_publisher(publisher)
+        result += render_stage_type(stage, type,
+                                    has_copublisher: publisher_has_copublisher?(
+                                      publisher,
+                                    ),
+                                    default_type_abbr: default_type_abbr)
+        result += render_numbering(number, part, subpart)
+        result += render_stage_iteration(stage_iteration) if stage_iteration
+        result += render_date(date)
+        result += render_edition(edition) if with_edition && edition
+        result += render_languages(languages, lang_single: lang_single)
+        result
+      end
+    end
+  end
+end

data/lib/pubid/rendering/context.rb

@@ -2,20 +2,30 @@
 
 module Pubid
   module Rendering
-    # Context object for flavor-specific and format-specific rendering rules
+    # Context object for flavor-specific rendering rules
+    #
+    # This encapsulates the rendering rules that vary between flavors,
+    # allowing components to render themselves correctly based on context.
+    #
+    # == Usage
+    #
+    #   context = RenderingContext.new(
+    #     stage_separator: "/",
+    #     stage_separator_with_copublisher: " ",
+    #     type_separator: "/",
+    #     type_separator_with_prefix: " ",
+    #     default_type_abbr: "IS"
+    #   )
+    #   identifier.to_s(context: context)
     #
-    # Encapsulates rendering rules that vary between flavors and between
-    # output formats (human-readable, URN, MR string). Components receive
-    # this context and render themselves accordingly — renderers and
-    # URN generators never reach into component internals.
     class RenderingContext
-      attr_reader :format, :stage_separator, :stage_separator_with_copublisher,
+      attr_reader :stage_separator, :stage_separator_with_copublisher,
                   :type_separator, :type_separator_with_prefix,
                   :default_type_abbr, :lang, :lang_single,
-                  :with_language_code, :stage_format_long, :with_date,
-                  :annotated
+                  :with_language_code, :stage_format_long, :with_date
 
-      # @param format [Symbol] output format: :human, :urn, or :mr
+      # Initialize a new rendering context
+      #
       # @param stage_separator [String] separator before stage without copublisher
       # @param stage_separator_with_copublisher [String] separator before stage with copublisher
       # @param type_separator [String] separator before type (default)
@@ -23,8 +33,7 @@ module Pubid
       # @param default_type_abbr [String] default type abbreviation to skip rendering
       # @param lang [Symbol] language for rendering (:en or :fr)
       # @param lang_single [Boolean] use single char language format
-      def initialize(format: :human,
-                     stage_separator: "/",
+      def initialize(stage_separator: "/",
                      stage_separator_with_copublisher: " ",
                      type_separator: "/",
                      type_separator_with_prefix: " ",
@@ -33,9 +42,7 @@ module Pubid
                      lang_single: false,
                      with_language_code: :none,
                      stage_format_long: false,
-                     with_date: true,
-                     annotated: false)
-        @format = format
+                     with_date: true)
         @stage_separator = stage_separator
         @stage_separator_with_copublisher = stage_separator_with_copublisher
         @type_separator = type_separator
@@ -46,19 +53,6 @@ module Pubid
         @with_language_code = with_language_code
         @stage_format_long = stage_format_long
         @with_date = with_date
-        @annotated = annotated
-      end
-
-      def urn?
-        @format == :urn
-      end
-
-      def human?
-        @format == :human
-      end
-
-      def mr?
-        @format == :mr
       end
 
       # Get the appropriate stage separator based on whether there's a copublisher
@@ -121,12 +115,6 @@ module Pubid
         )
       end
 
-      # URN rendering context: components emit URN-format fragments
-      # @return [RenderingContext] URN-specific context
-      def self.urn
-        @urn ||= new(format: :urn)
-      end
-
       # Format factory methods — replace RenderingStyle hierarchy
       def self.ref_num_short
         new(with_language_code: :single, stage_format_long: false,

data/lib/pubid/rendering/format.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Rendering
+    module Format
+      # Dispatch to appropriate format renderer
+      # @param format [Symbol] target format
+      # @return [String] formatted identifier string
+      def to_s(format = nil)
+        effective_format = determine_format(format)
+        send(:"to_#{effective_format}_style")
+      end
+
+      private
+
+      def determine_format(format)
+        return :short unless format
+        return :mr if format.to_sym == :mr
+        return :full if %i[full long].include?(format.to_sym)
+
+        :short
+      end
+    end
+  end
+end

data/lib/pubid/rendering/numbering.rb

@@ -4,39 +4,21 @@ module Pubid
   module Rendering
     module Numbering
       # Render number with optional parts and subparts
-      # @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 number [Components::Code] primary number
+      # @param part [Components::Code, nil] optional part
+      # @param subpart [Components::Code, nil] optional subpart
       # @param options [Hash] rendering options
       # @return [String] formatted numbering string
       def render_numbering(number, part = nil, subpart = nil, **options)
-        number_str = numbering_value(number)
-        return "" unless number_str
+        return "" unless number&.value
 
-        result = " #{number_str}"
+        result = " #{number.value}"
         separator = options[:part_separator] || "-"
-        [part, subpart].each do |component|
-          value = numbering_value(component)
-          result += "#{separator}#{value}" if value
-        end
+        result += "#{separator}#{part.value}" if part&.value
+        result += "#{separator}#{subpart.value}" if subpart&.value
 
         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] base identifier
+      # @param base_identifier [Identifier] base identifier
       # @param supplements [Array<Hash>] list of supplements
       # @param options [Hash] rendering options
       # @return [String] formatted supplement string
-      def render_supplements(base, supplements, **options)
-        return base.to_s(**options) unless supplements&.any?
+      def render_supplements(base_identifier, supplements, **options)
+        return base_identifier.to_s(**options) unless supplements&.any?
 
-        result = base.to_s(**options)
+        result = base_identifier.to_s(**options)
 
         supplements.each do |supp|
           result += render_single_supplement(supp, **options)

data/lib/pubid/rendering.rb

@@ -2,7 +2,10 @@
 
 module Pubid
   module Rendering
+    autoload :Base, "pubid/rendering/base"
+    autoload :Common, "pubid/rendering/common"
     autoload :Date, "pubid/rendering/date"
+    autoload :Format, "pubid/rendering/format"
     autoload :Language, "pubid/rendering/language"
     autoload :Numbering, "pubid/rendering/numbering"
     autoload :Publisher, "pubid/rendering/publisher"

data/lib/pubid/sae/builder.rb

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

data/lib/pubid/sae/components/date.rb

@@ -10,15 +10,7 @@ module Pubid
       class Date < Lutaml::Model::Serializable
         attribute :year, :integer
 
-        def present?
-          !year.nil?
-        end
-
         def to_s
-          render
-        end
-
-        def render(context: nil)
           year.to_s
         end
       end

data/lib/pubid/sae/components/type.rb

@@ -6,15 +6,11 @@ module Pubid
   module Sae
     module Components
       # Type component for SAE document types
-      # AMS, AIR, ARP, AS, MA
+      # AMS, AIR,, ARP, AS, MA
       class Type < Lutaml::Model::Serializable
         attribute :abbr, :string
 
         def to_s
-          render
-        end
-
-        def render(context: nil)
           abbr.to_s
         end
       end

data/lib/pubid/sae/identifier.rb

@@ -1,4 +1,14 @@
 # frozen_string_literal: true
 
-# Pubid::Sae::Identifier is the SAE base class (a real Pubid::Identifier
-# subclass); its body and `.parse` live in identifiers/base.rb. This file just ensures it is loaded.
+module Pubid
+  module Sae
+    class Identifier
+      def self.parse(input)
+        parsed = Parser.parse(input)
+        Builder.build(parsed)
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse SAE identifier: #{input}\n#{e.message}"
+      end
+    end
+  end
+end

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

@@ -2,46 +2,41 @@
 
 module Pubid
   module Sae
-    # 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
+    module Identifiers
+      # Base SAE Identifier
+      # Handles all SAE document types (AMS, AIR, ARP, AS, MA)
+      class Base < Pubid::Identifier
+        # Generate URN for this identifier
+        #
+        # @return [String] URN representation
 
-        if input.length > Pubid::MAX_INPUT_LENGTH
-          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
-        end
+        attribute :publisher, :string, default: -> { "SAE" }
+        attribute :type, Sae::Components::Type
+        attribute :number, Sae::Components::Code
+        attribute :date, Sae::Components::Date
 
-        parsed = Parser.parse(input)
-        Builder.build(parsed)
-      end
+        def to_s
+          parts = []
 
-      attribute :publisher, :string, default: -> { "SAE" }
-      attribute :type, Sae::Components::Type
-      attribute :number, Sae::Components::Code
-      attribute :date, Sae::Components::Date
+          # Publisher and type
+          parts << publisher if publisher
+          parts << type.to_s if type
 
-      def self.type
-        { key: :base, web: :standard, title: "Standard", short: "SAE" }
-      end
+          # Number
+          parts << number.to_s if number
 
-      def year
-        date&.year
-      end
+          result = parts.join(" ")
 
-      # 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
+          # Date
+          result += ":#{date.year}" if date
+
+          result
+        end
+
+        def year
+          date&.year
+        end
       end
     end
-
   end
 end

data/lib/pubid/sae/identifiers.rb

@@ -3,6 +3,7 @@
 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 < ::Pubid::Parser::Grammar
+    class Parser < Parslet::Parser
       rule(:space) { str(" ") }
       rule(:digit) { match["0-9"] }
       rule(:digits) { digit.repeat(1) }