pubid 1.15.17 → 2.0.0.pre.alpha.1

data/lib/pubid/oiml/identifiers/annex.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      class Annex < SupplementIdentifier
+        attribute :letter, :string # For "Annex A", "Annex B", etc.
+
+        def supplement_type
+          letter ? "Annex #{letter}" : "Annexes"
+        end
+
+        def to_s(format: nil)
+          # Determine base format from its parsed_format
+          base_format = if base_identifier.class.attributes.key?(:parsed_format) && base_identifier.parsed_format == "long"
+                          :long
+                        else
+                          :short
+                        end
+
+          # Use format parameter or annex's own parsed_format
+          annex_format = if format
+                           format
+                         elsif self.class.attributes.key?(:parsed_format) && parsed_format == "long"
+                           :long
+                         else
+                           :short
+                         end
+
+          # Annexes have different pattern than amendments
+          base_str = base_identifier.to_s(format: base_format)
+          result = base_str.sub(/:.*/, "").sub(/\s+Edition\s+\d{4}/, "").sub(
+            /\(.*\)/, ""
+          ).strip
+          if letter
+            # Specific annex: "OIML R 60 Annex A Edition 2013 (E)"
+            result += " Annex #{letter}"
+
+            result += " Edition #{year}" if year
+
+          # Supplements ALWAYS use space before language
+
+          else
+            # General annexes: "OIML R 60 Annexes Edition 2021 (E)" or "OIML R 60 Annexes:2021 (E)"
+            result += " Annexes"
+
+            if year
+              result += annex_format == :long ? " Edition #{year}" : ":#{year}"
+            elsif base_identifier.date
+              result += annex_format == :long ? " Edition #{base_identifier.date.year}" : ":#{base_identifier.date.year}"
+            end
+
+            # Supplements ALWAYS use space before language
+
+          end
+          result += " (#{language})" if language
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      class Base < Pubid::Identifier
+        attribute :publisher, :string
+        attribute :type, :string
+        attribute :code, Oiml::Components::Code
+        attribute :date, Pubid::Components::Date
+        attribute :stage, :string
+        attribute :iteration, :string
+        attribute :language, :string
+
+        def to_s
+          result = "#{publisher} #{type} #{code}"
+
+          # Add date if present
+          result += ":#{date.year}" if date
+
+          # Add draft stage if present (iteration + stage)
+          if stage || iteration
+            result += " "
+            result += iteration.to_s if iteration
+            result += stage.to_s if stage
+          end
+
+          # Add language portion if present
+          result += "(#{language})" if language
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/pubid/oiml/identifiers/basic_publication.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      class BasicPublication < SingleIdentifier
+        def type_string
+          "B"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/oiml/identifiers/document.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      class Document < SingleIdentifier
+        def type_string
+          "D"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/oiml/identifiers/expert_report.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      class ExpertReport < SingleIdentifier
+        def type_string
+          "E"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/oiml/identifiers/guide.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      class Guide < SingleIdentifier
+        def type_string
+          "G"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/oiml/identifiers/recommendation.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      class Recommendation < SingleIdentifier
+        def type_string
+          "R"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/oiml/identifiers/seminar_report.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      class SeminarReport < SingleIdentifier
+        def type_string
+          "S"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/oiml/identifiers/vocabulary.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      class Vocabulary < SingleIdentifier
+        def type_string
+          "V"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/oiml/identifiers.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      autoload :Amendment, "#{__dir__}/identifiers/amendment"
+      autoload :Annex, "#{__dir__}/identifiers/annex"
+      autoload :Base, "#{__dir__}/identifiers/base"
+      autoload :BasicPublication, "#{__dir__}/identifiers/basic_publication"
+      autoload :Document, "#{__dir__}/identifiers/document"
+      autoload :ExpertReport, "#{__dir__}/identifiers/expert_report"
+      autoload :Guide, "#{__dir__}/identifiers/guide"
+      autoload :Recommendation, "#{__dir__}/identifiers/recommendation"
+      autoload :SeminarReport, "#{__dir__}/identifiers/seminar_report"
+      autoload :Vocabulary, "#{__dir__}/identifiers/vocabulary"
+    end
+  end
+end

data/lib/pubid/oiml/parser.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Oiml
+    class Parser < Parslet::Parser
+      include ::Pubid::Parser::CommonParseRules
+      include ::Pubid::Parser::CommonParseMethods
+
+      root :identifier
+
+      # Additional basic rules not in CommonParseRules
+      rule(:colon) { str(":") }
+      rule(:lparen) { str("(") }
+      rule(:rparen) { str(")") }
+      rule(:slash) { str("/") }
+
+      # Main identifier pattern - check supplements first
+      rule(:identifier) do
+        amendment_identifier | amendment_short | annex_letter_identifier | annex_identifier | base_identifier
+      end
+
+      # Publisher - always "OIML"
+      rule(:publisher) { str("OIML").as(:publisher) >> space }
+
+      # Document type - single letter
+      rule(:doc_type) { match("[BDEGRSVX]").as(:type) >> space }
+
+      # Number with optional part and subpart
+      rule(:number_only) { digits.as(:number) }
+
+      rule(:part_number) { dash >> digits.as(:part) }
+
+      rule(:subpart_number) { dash >> digits.as(:subpart) }
+
+      rule(:full_number) do
+        (number_only >> part_number >> subpart_number) |
+          (number_only >> part_number) |
+          number_only
+      end
+
+      # Edition number - ordinal numbers
+      rule(:edition_number) do
+        (
+          str("6th") | str("5th") | str("4th") | str("3rd") |
+          str("2nd") | str("1st") |
+          (digits >> (str("th") | str("nd") | str("rd") | str("st")))
+        ).as(:edition)
+      end
+
+      # Edition text - uppercase or lowercase
+      rule(:edition_text) { str("Edition") | str("edition") }
+
+      # Edition portion - handles "6th Edition 2015" or "Edition 2013" or ", edition 1992"
+      rule(:edition_portion) do
+        (
+          (str(", ") | space) >>
+          edition_number.maybe >> space.maybe >> edition_text >> space.maybe >> year_digits.as(:year)
+        ).as(:edition_format) # Wrap entire match to capture that Edition was used
+      end
+
+      # Date - year after colon OR edition portion (with optional space before year)
+      rule(:date) do
+        edition_portion | (colon >> space.maybe >> year_digits.as(:year))
+      end
+
+      # Draft stage - WD or CD with optional iteration
+      rule(:stage_iteration) do
+        (
+          (digits >> str(".") >> digits) | # 3.1
+          digits # 1, 2, 3
+        ).as(:iteration)
+      end
+
+      rule(:stage_abbr) do
+        (str("WD") | str("CD")).as(:stage)
+      end
+
+      rule(:draft_stage) do
+        space >> stage_iteration.maybe >> stage_abbr
+      end
+
+      # Language codes
+      rule(:lang_single) do
+        match("[EFRX]") # Single letter: E, F, R, X
+      end
+
+      rule(:lang_multi) do
+        match("[a-z]").repeat(2, 2) # Two letters: en, fr, etc.
+      end
+
+      rule(:language_code) do
+        (
+          (lang_single >> slash >> lang_single) | # E/F
+          lang_single |                          # E, F
+          lang_multi                             # en, fr
+        ).as(:language)
+      end
+
+      rule(:language_with_space) do
+        space >> lparen >> language_code >> rparen >> str("").as(:space_before_lang)
+      end
+
+      rule(:language_without_space) do
+        lparen >> language_code >> rparen
+      end
+
+      rule(:language_portion) do
+        language_with_space | language_without_space
+      end
+
+      # Amendment identifier - "Amendment (YYYY) to BASE"
+      rule(:amendment_identifier) do
+        str("Amendment") >> space >> lparen >> year_digits.as(:year) >> rparen >>
+          space >> str("to") >> space >>
+          base_without_language.as(:base_identifier) >>
+          language_portion.maybe.as(:language)
+      end
+
+      # Short amendment forms - "OIML TYPE NUMBER Amendment Edition YYYY" or "Amendment: YYYY"
+      rule(:amendment_short) do
+        publisher >>
+          doc_type >>
+          full_number.as(:base_code) >>
+          space >> str("Amendment").as(:amd_marker) >>
+          (
+            (space >> edition_text >> space.maybe >> year_digits.as(:year)).as(:edition_format) |
+            (colon >> space.maybe >> year_digits.as(:year))
+          ) >>
+          language_portion.maybe.as(:language)
+      end
+
+      # Annex identifier - "BASE Annexes Edition YYYY" or "BASE Annexes:YYYY"
+      rule(:annex_identifier) do
+        base_without_language.as(:base_identifier) >>
+          space >> str("Annexes").as(:annex_marker) >>
+          (
+            (space >> edition_text >> space >> year_digits.as(:year)).as(:edition_format) |
+            (colon >> year_digits.as(:year))
+          ) >>
+          language_portion.maybe.as(:language)
+      end
+
+      # Annex with letter - "BASE Annex A Edition YYYY"
+      rule(:annex_letter_identifier) do
+        base_without_language.as(:base_identifier) >>
+          space >> str("Annex") >> space >> match("[A-Z]").as(:annex_letter) >>
+          ((space >> edition_text >> space >> year_digits.as(:year)) | (colon >> year_digits.as(:year))).maybe >>
+          language_portion.maybe.as(:language)
+      end
+
+      # Base identifier without language (for use in supplements)
+      rule(:base_without_language) do
+        publisher >>
+          doc_type >>
+          full_number >>
+          date.maybe >>
+          draft_stage.maybe
+      end
+
+      # Base identifier for recursion and standalone parsing
+      rule(:base_identifier) do
+        publisher >>
+          doc_type >>
+          full_number >>
+          date.maybe >>
+          draft_stage.maybe >>
+          language_portion.maybe
+      end
+    end
+  end
+end

data/lib/pubid/oiml/scheme.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    class Scheme < Pubid::Scheme
+      class << self
+        def identifiers
+          @identifiers ||= [
+            Identifiers::BasicPublication,
+            Identifiers::Document,
+            Identifiers::ExpertReport,
+            Identifiers::Guide,
+            Identifiers::Recommendation,
+            Identifiers::SeminarReport,
+            Identifiers::Vocabulary,
+          ].freeze
+        end
+
+        def supplement_identifiers
+          @supplement_identifiers ||= [
+            Identifiers::Amendment,
+            Identifiers::Annex,
+          ].freeze
+        end
+
+        def typed_stages
+          @typed_stages ||= [].freeze
+        end
+
+        def supplement_typed_stages
+          @supplement_typed_stages ||= [].freeze
+        end
+
+        def locate_typed_stage_by_abbr(_abbr)
+          raise ArgumentError,
+                "OIML identifiers do not use typed stages"
+        end
+
+        def locate_identifier_klass_by_type_code(_type_code)
+          raise ArgumentError,
+                "OIML identifiers do not use type codes"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/oiml/single_identifier.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    class SingleIdentifier < Identifier
+      # Base class for OIML single identifiers (non-supplements)
+      attribute :publisher, :string
+      attribute :code, Oiml::Components::Code
+      attribute :date, Pubid::Components::Date
+      attribute :edition, :string
+      attribute :stage, :string
+      attribute :iteration, :string
+      attribute :language, :string
+      attribute :parsed_format, :string, default: -> {
+        "short"
+      } # Track parsed format
+
+      # Type is determined by the subclass
+      def type
+        type_string
+      end
+
+      def to_s(format: nil)
+        # Use parsed format if not explicitly overridden
+        format ||= (parsed_format == "long" ? :long : :short)
+
+        result = "#{publisher} #{type_string} #{code}"
+
+        # Track if we're using Edition format for language spacing
+        using_edition_format = false
+
+        # Add edition/date portion
+        if edition && date
+          # Has edition number: "6th Edition 2015"
+          result += " #{edition} Edition #{date.year}"
+          using_edition_format = true
+        elsif edition
+          # Edition without year (shouldn't happen but handle it)
+          result += " #{edition}"
+          using_edition_format = true
+        elsif date
+          # Date without edition number
+          if format == :long
+            result += " Edition #{date.year}"
+            using_edition_format = true
+          else
+            result += ":#{date.year}"
+          end
+        end
+
+        # Add draft stage if present (iteration + stage)
+        if stage || iteration
+          result += " "
+          result += iteration.to_s if iteration
+          result += stage.to_s if stage
+        end
+
+        # Add language portion - depends on format
+        if language
+          result += if using_edition_format || parsed_format == "short_with_space"
+                      " (#{language})"
+                    else
+                      "(#{language})"
+                    end
+        end
+
+        result
+      end
+
+      def edition_portion
+        # Deprecated - kept for compatibility
+        # Use to_s(format: :long) instead
+        if edition && date
+          "#{edition} Edition #{date.year}"
+        elsif date
+          "Edition #{date.year}"
+        else
+          edition
+        end
+      end
+
+      # Subclasses override this
+      def type_string
+        raise NotImplementedError, "Subclasses must implement type_string"
+      end
+
+      # Subclasses override this
+    end
+  end
+end

data/lib/pubid/oiml/supplement_identifier.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    class SupplementIdentifier < Identifier
+      # Base class for OIML supplements (amendments, annexes)
+      # These wrap a base identifier like ISO amendments
+      attribute :base_identifier, Oiml::Identifier
+      attribute :year, :string
+      attribute :language, :string
+      attribute :parsed_format, :string, default: -> {
+        "short"
+      } # Track supplement's parsed format
+
+      def to_s(format: :short)
+        # Determine base format: explicit parameter takes priority, else use parsed format
+        base_format = if format && format != :short
+                        format # Use explicit override
+                      elsif base_identifier.class.attributes.key?(:parsed_format) && base_identifier.parsed_format == "long"
+                        :long
+                      else
+                        :short
+                      end
+
+        # Render base with determined format (preserves Edition vs colon)
+        base_str = base_identifier.to_s(format: base_format)
+        base_str = base_str.sub(/\s*\([^)]+\)\s*$/, "").strip # Remove language from base
+
+        result = "#{supplement_type} (#{year}) to #{base_str}"
+
+        # Supplements ALWAYS add space before their language
+        result += " (#{language})" if language
+
+        result
+      end
+
+      # Subclasses override this
+      def supplement_type
+        raise NotImplementedError, "Subclasses must implement supplement_type"
+      end
+    end
+  end
+end

data/lib/pubid/oiml/urn_generator.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def urn_type
+        return "r" unless identifier.type
+
+        identifier.type.to_s.downcase
+      end
+
+      def urn_number
+        return nil unless identifier.code
+
+        identifier.code.to_s
+      end
+
+      def urn_year
+        if identifier.date&.year
+          return identifier.date.year.to_s
+        end
+
+        nil
+      end
+
+      def urn_stage
+        identifier.stage&.to_s&.downcase
+      end
+
+      def urn_iteration
+        identifier.iteration&.to_s
+      end
+
+      def urn_language
+        identifier.language&.to_s&.downcase
+      end
+
+      def generate
+        parts = ["urn", "oiml"]
+        parts << urn_type
+        parts << urn_number if urn_number
+        parts << urn_year if urn_year
+        parts << urn_stage if urn_stage
+        parts << urn_iteration if urn_iteration
+        parts << urn_language if urn_language
+
+        parts[1] = identifier.publisher.to_s.downcase if identifier.publisher
+
+        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.to_s
+          end
+        end
+
+        parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/oiml.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    autoload :Builder, "#{__dir__}/oiml/builder"
+    autoload :Components, "#{__dir__}/oiml/components"
+    autoload :Identifier, "#{__dir__}/oiml/identifier"
+    autoload :Identifiers, "#{__dir__}/oiml/identifiers"
+    autoload :Parser, "#{__dir__}/oiml/parser"
+    autoload :Scheme, "#{__dir__}/oiml/scheme"
+    autoload :SingleIdentifier, "#{__dir__}/oiml/single_identifier"
+    autoload :SupplementIdentifier, "#{__dir__}/oiml/supplement_identifier"
+    autoload :UrnGenerator, "#{__dir__}/oiml/urn_generator"
+
+    def self.parse(identifier)
+      parser = Parser.new
+      builder = Builder.new
+
+      parsed = parser.parse(identifier)
+      builder.build(parsed)
+    end
+  end
+end
+
+# Register Uoiml flavor with the registry
+Pubid::Registry.register(:oiml, Pubid::Oiml)

data/lib/pubid/parser/common_parse_methods.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Parser
+    module CommonParseMethods
+      def array_to_str(array)
+        array.reduce(str(array.first)) do |acc, value|
+          acc | str(value)
+        end
+      end
+    end
+  end
+end