pubid 1.15.18 → 2.0.0.pre.alpha.1

data/lib/pubid/urn_generator/base.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Pubid
+  module UrnGenerator
+    # Base class for all flavor-specific URN generators.
+    # Provides template methods for common URN parts.
+    # Flavors subclass and override only what differs.
+    class Base
+      attr_reader :identifier
+
+      def initialize(identifier)
+        @identifier = identifier
+      end
+
+      def generate
+        parts = ["urn", urn_namespace]
+        parts << urn_publisher if urn_publisher
+        parts << urn_type if urn_type
+        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_language if urn_language
+        parts.join(":")
+      end
+
+      # Template methods — override in subclasses
+
+      def urn_namespace
+        flavor_name.downcase
+      end
+
+      def urn_publisher
+        pub = maybe(:publisher)
+        return nil unless pub
+
+        pub.to_s.downcase
+      end
+
+      def urn_type
+        nil
+      end
+
+      def urn_number
+        val = maybe(:number) || maybe(:code)
+        return nil unless val
+
+        val.is_a?(Components::Code) ? val.value.to_s : val.to_s
+      end
+
+      def urn_part
+        val = maybe(:part)
+        return nil unless val
+
+        "-#{val.is_a?(Components::Code) ? val.value : val}"
+      end
+
+      def urn_subpart
+        val = maybe(:subpart)
+        return nil unless val
+
+        "-#{val.is_a?(Components::Code) ? val.value : val}"
+      end
+
+      def urn_year
+        date = maybe(:date)
+        if date
+          year = date.is_a?(Components::Date) ? date.year : date.to_s
+          return year.to_s if year
+        end
+        if maybe(:year)
+          return identifier.year.to_s
+        end
+
+        nil
+      end
+
+      def urn_edition
+        ed = maybe(:edition)
+        return nil unless ed
+
+        num = ed.is_a?(Components::Edition) ? ed.number : ed
+        return nil unless num
+
+        "ed.#{num}"
+      end
+
+      def urn_language
+        langs = maybe(:languages)
+        return nil unless langs&.any?
+
+        langs.map(&:code).join(",")
+      end
+
+      def maybe(method_name)
+        return nil unless identifier.class.attributes.key?(method_name)
+
+        identifier.public_send(method_name)
+      end
+
+      private
+
+      def flavor_name
+        parts = identifier.class.name.split("::")
+        parts[1] || "unknown"
+      end
+    end
+  end
+end

data/lib/pubid/utils/string_normalizer.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Utils
+    # String normalization utilities for PubID parsing and rendering
+    #
+    # This module provides centralized string manipulation methods
+    # to reduce duplication and improve consistency.
+    #
+    # == Usage
+    #
+    #   Pubid::Utils::StringNormalizer.normalize_dashes(str)
+    #   Pubid::Utils::StringNormalizer.normalize_whitespace(str)
+    #   Pubid::Utils::StringNormalizer.split_compound_number(str)
+    #
+    class StringNormalizer
+      # Unicode dash characters that should be normalized to ASCII hyphen
+      DASH_CHARS = ["-", "‑", "‐", "–", "—"].freeze
+
+      # Whitespace characters to normalize to single space
+      WHITESPACE_CHARS = [" ", "\t", "\n", "\r", "\u00A0"].freeze
+
+      class << self
+        # Normalize all dash characters to ASCII hyphen
+        #
+        # @param str [String, nil] input string
+        # @return [String] normalized string with ASCII hyphens
+        #
+        # @example Normalize unicode dashes
+        #   StringNormalizer.normalize_dashes("ISO‑9001") # => "ISO-9001"
+        #   StringNormalizer.normalize_dashes("ISO–9001") # => "ISO-9001"
+        #
+        def normalize_dashes(str)
+          return str if str.nil?
+
+          str.tr(DASH_CHARS.join, "-")
+        end
+
+        # Normalize whitespace to single space and strip
+        #
+        # @param str [String, nil] input string
+        # @return [String] normalized string with single spaces
+        #
+        # @example Normalize whitespace
+        #   StringNormalizer.normalize_whitespace("ISO  9001") # => "ISO 9001"
+        #   StringNormalizer.normalize_whitespace("ISO\t9001") # => "ISO 9001"
+        #
+        def normalize_whitespace(str)
+          return "" if str.nil?
+
+          str.gsub(/[#{WHITESPACE_CHARS.join}]+/, " ").strip
+        end
+
+        # Clean and uppercase abbreviation
+        #
+        # @param str [String, nil] input string
+        # @return [String] cleaned and uppercased abbreviation
+        #
+        # @example Clean abbreviation
+        #   StringNormalizer.clean_abbr("  amd  ") # => "AMD"
+        #   StringNormalizer.clean_abbr("Amd") # => "AMD"
+        #
+        def clean_abbr(str)
+          return "" if str.nil?
+
+          normalize_whitespace(str).upcase
+        end
+
+        # Split compound number (e.g., "800-53-1" -> ["800", "53", "1"])
+        #
+        # @param str [String] input string
+        # @param separators [Array<String>] separators to split on
+        # @return [Array<String>] split parts
+        #
+        # @example Split compound numbers
+        #   StringNormalizer.split_compound_number("800-53-1")
+        #   # => ["800", "53", "1"]
+        #   StringNormalizer.split_compound_number("800/53")
+        #   # => ["800", "53"]
+        #
+        def split_compound_number(str, separators: ["-", "/"])
+          return [] unless str
+
+          normalized = normalize_dashes(str)
+          normalized.split(/[#{separators.join}]/).reject(&:empty?)
+        end
+
+        # Extract numeric suffix from string
+        #
+        # @param str [String] input string
+        # @return [Array<String, nil>] [number, suffix] or [nil, nil]
+        #
+        # @example Extract number and suffix
+        #   StringNormalizer.extract_number_suffix("800-53r5") # => ["53", "r5"]
+        #   StringNormalizer.extract_number_suffix("ISO") # => [nil, nil]
+        #
+        def extract_number_suffix(str)
+          return [nil, nil] unless str
+
+          match = str.match(/^(\D+)?(\d+)([a-zA-Z]+)?$/)
+          return [nil, nil] unless match
+
+          number = match[2]
+          suffix = match[3]
+          [number, suffix]
+        end
+
+        # Join parts with proper separator, skipping nils
+        #
+        # @param parts [Array] parts to join
+        # @param separator [String] separator between parts
+        # @return [String] joined string
+        #
+        # @example Join parts
+        #   StringNormalizer.join_parts(["ISO", "9001", nil, "2015"], " ")
+        #   # => "ISO 9001 2015"
+        #   StringNormalizer.join_parts(["ISO", nil, "9001"], "-")
+        #   # => "ISO-9001"
+        #
+        def join_parts(parts, separator: "")
+          parts.compact.join(separator)
+        end
+
+        # Truncate string to max length with ellipsis
+        #
+        # @param str [String] input string
+        # @param max_length [Integer] maximum length
+        # @param ellipsis [String] ellipsis string (default: "...")
+        # @return [String] truncated string
+        #
+        # @example Truncate string
+        #   StringNormalizer.truncate("International Standard", 15)
+        #   # => "International ..."
+        #   StringNormalizer.truncate("ISO", 10)
+        #   # => "ISO"
+        #
+        def truncate(str, max_length:, ellipsis: "...")
+          return str if str.nil? || str.length <= max_length
+
+          str[0...(max_length - ellipsis.length)] + ellipsis
+        end
+
+        # Convert to title case (first letter of each word uppercase)
+        #
+        # @param str [String] input string
+        # @return [String] title cased string
+        #
+        # @example Title case
+        #   StringNormalizer.title_case("international standard")
+        #   # => "International Standard"
+        #   StringNormalizer.title_case("ISO/TR")
+        #   # => "ISO/TR"  # Preserves existing caps
+        #
+        def title_case(str)
+          return "" if str.nil?
+
+          str.split.map do |word|
+            if word.upcase == word # Preserve acronyms
+              word
+            else
+              word.capitalize
+            end
+          end.join(" ")
+        end
+
+        # Check if string is blank (nil, empty, or only whitespace)
+        #
+        # @param str [String] input string
+        # @return [Boolean] true if blank
+        #
+        # @example Check blank
+        #   StringNormalizer.blank?(nil) # => true
+        #   StringNormalizer.blank?("") # => true
+        #   StringNormalizer.blank?("  ") # => true
+        #   StringNormalizer.blank?("ISO") # => false
+        #
+        def blank?(str)
+          str.nil? || str.to_s.strip.empty?
+        end
+
+        # Safe to_s method that handles nil
+        #
+        # @param str [String, nil] input string
+        # @return [String] string or empty string
+        #
+        # @example Safe to_s
+        #   StringNormalizer.to_s(nil) # => ""
+        #   StringNormalizer.to_s("ISO") # => "ISO"
+        #
+        def to_s(str)
+          str.nil? ? "" : str.to_s
+        end
+      end
+    end
+  end
+end

data/lib/pubid/utils.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Utils
+    autoload :StringNormalizer, "pubid/utils/string_normalizer"
+  end
+end

data/lib/pubid/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Pubid
-  VERSION = "1.15.18".freeze
+  VERSION = "2.0.0.pre.alpha.1"
 end

data/lib/pubid.rb

@@ -1,15 +1,139 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require_relative "pubid/lutaml/no_store_registration"
+require "parslet"
+
 module Pubid
-end
+  # Registry for tracking all loaded flavors
+  class Registry
+    @flavors = {}
+
+    class << self
+      attr_reader :flavors
+
+      # Register a flavor with the registry
+      # @param name [String, Symbol] Flavor name (e.g., :iso, :iec)
+      # @param flavor_module [Module] The flavor module (e.g., Pubid::Iso)
+      def register(name, flavor_module)
+        @flavors[name.to_s.downcase] = flavor_module
+      end
+
+      # Get all registered flavor names
+      # @return [Array<String>] Array of flavor names
+      def flavor_names
+        @flavors.keys.sort
+      end
+
+      # Get flavor module by name
+      # @param name [String, Symbol] Flavor name
+      # @return [Module, nil] The flavor module or nil if not found
+      def get(name)
+        @flavors[name.to_s.downcase]
+      end
+
+      # Check if a flavor is registered
+      # @param name [String, Symbol] Flavor name
+      # @return [Boolean]
+      def registered?(name)
+        @flavors.key?(name.to_s.downcase)
+      end
+    end
+  end
+
+  autoload :Parser, "pubid/parser"
+  autoload :Components, "pubid/components"
+  autoload :BundledIdentifier, "pubid/bundled_identifier"
+  autoload :Identifier, "pubid/identifier"
+  autoload :IdentifierMetadata, "pubid/identifier_metadata"
+  autoload :IdentifierRegistry, "pubid/identifier_registry"
+  autoload :Rendering, "pubid/rendering"
+  autoload :Renderers, "pubid/renderers"
+  autoload :FormatDetector, "pubid/format_detector"
+  autoload :FormatRegistry, "pubid/format_registry"
+  autoload :Scheme, "pubid/scheme"
 
-require_relative "pubid/registry"
-
-require "pubid-core"
-require "pubid-iso"
-require "pubid-ieee"
-require "pubid-nist"
-require "pubid-iec"
-require "pubid-cen"
-require "pubid-bsi"
-require "pubid-ccsds"
-require "pubid-itu"
-require "pubid-jis"
+  autoload :UrnGenerator, "pubid/urn_generator/base"
+  autoload :Builder, "pubid/builder/base"
+  autoload :Utils, "pubid/utils"
+  autoload :Version, "pubid/version"
+  autoload :Core, "pubid/core"
+
+  # Require all flavor modules
+  autoload :Amca, "pubid/amca"
+  autoload :Ansi, "pubid/ansi"
+  autoload :Api, "pubid/api"
+  autoload :Ashrae, "pubid/ashrae"
+  autoload :Asme, "pubid/asme"
+  autoload :Astm, "pubid/astm"
+  autoload :Bsi, "pubid/bsi"
+  autoload :Ccsds, "pubid/ccsds"
+  autoload :CenCenelec, "pubid/cen_cenelec"
+  autoload :Cie, "pubid/cie"
+  autoload :Csa, "pubid/csa"
+  autoload :Etsi, "pubid/etsi"
+  autoload :Idf, "pubid/idf"
+  autoload :Iec, "pubid/iec"
+  autoload :Ieee, "pubid/ieee"
+  autoload :Iho, "pubid/iho"
+  autoload :Iso, "pubid/iso"
+  autoload :Itu, "pubid/itu"
+  autoload :Jcgm, "pubid/jcgm"
+  autoload :Jis, "pubid/jis"
+  autoload :Nist, "pubid/nist"
+  autoload :Oiml, "pubid/oiml"
+  autoload :Plateau, "pubid/plateau"
+  autoload :Export, "pubid/export"
+  autoload :Sae, "pubid/sae"
+
+  # Format infrastructure (loaded eagerly so Pubid::Renderers / Pubid::Parsers are always available)
+  require "pubid/renderers/base"
+  require "pubid/renderers/mr_string"
+  require "pubid/renderers/urn"
+  require "pubid/parsers/base"
+  require "pubid/parsers/mr_string"
+
+  # Initialize global format registry
+  Identifier.format_registry = FormatRegistry.new
+  Identifier.format_registry.register(:human, renderer: Renderers::HumanReadable)
+  Identifier.format_registry.register(:mr_string, renderer: Renderers::MrString)
+  Identifier.format_registry.register(:urn, renderer: Renderers::Urn)
+
+  # Unified parse entry point with auto-detection
+  #
+  # @param string [String] The identifier string to parse
+  # @param format [Symbol] :auto, :human, :mr_string, or :urn
+  # @return [Identifier] The parsed identifier
+  def self.parse(string, format: :auto)
+    format = FormatDetector.detect(string) if format == :auto
+
+    case format
+    when :mr_string
+      Parsers::MrString.parse(string)
+    when :urn
+      # URN auto-detection: extract flavor from URN namespace
+      # e.g., "urn:iso:std:..." → Pubid::Iso
+      flavor = detect_flavor_from_urn(string)
+      flavor_module = Registry.get(flavor)
+      unless flavor_module
+        raise ArgumentError,
+              "Unknown flavor in URN: #{flavor}"
+      end
+
+      urn_parser = flavor_module.const_get(:UrnParser)
+      urn_parser.parse(string)
+    else
+      # Default to MR string parser for MR format, human-readable otherwise
+      # The MR string parser converts to human-readable and delegates to flavor.parse
+      raise ArgumentError,
+            "No flavor specified. Use Pubid::Iso.parse() or another flavor-specific parse method."
+    end
+  end
+
+  def self.detect_flavor_from_urn(urn)
+    # urn:iso:std:... → "iso"
+    # urn:iec:std:... → "iec"
+    parts = urn.downcase.split(":")
+    parts[1] # The namespace part after "urn"
+  end
+end

data/lib/tasks/docs.rake

@@ -0,0 +1,37 @@
+# frozen_string_literal
+
+require_relative "../../lib/pubid/core/pattern_doc_generator"
+
+namespace :docs do
+  desc "Generate identifier pattern reference docs"
+  task :patterns do
+    output_dir = File.join(__dir__, "..", "..", "docs", "identifier-patterns")
+    FileUtils.mkdir_p(output_dir)
+
+    flavors = Dir[File.join(__dir__, "..", "..", "lib", "pubid",
+                            "*")].select do |d|
+      File.directory?(d)
+    end
+      .map do |d|
+      File.basename(d)
+    end
+      .reject do |f|
+      %w[core components rendering
+         parser serializable utils].include?(f)
+    end
+
+    flavors.each do |flavor|
+      puts "Generating docs for #{flavor}..."
+      generator = Pubid::Core::PatternDocGenerator.new(flavor)
+      content = generator.generate
+      File.write(File.join(output_dir, "#{flavor}.md"), content)
+    end
+
+    # Generate cross-flavor comparison table
+    puts "Generating cross-flavor comparison..."
+    table = Pubid::Core::PatternDocGenerator.generate_cross_flavor_table(flavors)
+    File.write(File.join(output_dir, "README.md"), table)
+
+    puts "Done. Generated docs for #{flavors.length} flavors in #{output_dir}/"
+  end
+end

data/lib/tasks/export.rake

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "json"
+
+namespace :export do
+  desc "Export library metadata as JSON for the PubID website"
+  task :website_data do
+    require "pubid/export"
+    data = Pubid::Export::Exporter.export_all
+    output_path = File.expand_path("website-data.json", __dir__)
+    File.write(output_path, JSON.pretty_generate(data))
+    puts "Exported #{data.keys.size} flavors to #{output_path}"
+    data.each do |flavor, fd|
+      count = fd[:identifier_types]&.size || 0
+      puts "  #{flavor}: #{count} identifier types"
+    end
+  end
+
+  desc "Audit library data against website publishers"
+  task :audit do
+    require "pubid/export"
+    data = Pubid::Export::Exporter.export_all
+
+    # Parse website publishers to extract doc type keys
+    # For now, read the generated JSON and provide a summary
+    auditor = Pubid::Export::Auditor.new(data)
+
+    # Build a minimal website representation from the generated data itself
+    # (in production, this would parse the website's publishers.ts)
+    {}
+    summary = data.transform_values do |fd|
+      { "doc_types" => fd[:identifier_types].map { |t| { "key" => t[:key] } } }
+    end
+
+    results = auditor.audit(summary)
+    puts auditor.summary(results)
+  end
+end