pubid 2.0.2 → 2.0.4

data/lib/pubid/iso/identifier.rb

@@ -135,8 +135,10 @@ module Pubid
         map "languages", to: :languages
         # publisher emitted only when the primary isn't the type default;
         # copublishers (the other bodies) as an array, omitted when empty.
-        map "publisher", with: { to: :publisher_to_kv, from: :publisher_from_kv }
-        map "copublishers", with: { to: :copublishers_to_kv, from: :copublishers_from_kv }
+        map "publisher",
+            with: { to: :publisher_to_kv, from: :publisher_from_kv }
+        map "copublishers",
+            with: { to: :copublishers_to_kv, from: :copublishers_from_kv }
         map "locality", to: :locality
         # `type` and generic `stage` are fully derived from `typed_stage`
         # (builder sets them via to_type/to_stage), so we serialize only the
@@ -169,8 +171,10 @@ module Pubid
         # instead of falling back. The IEC twin (iec/identifier.rb) was
         # migrated at the time; ISO was missed.
         ts = (model.class.const_defined?(:TYPED_STAGES) &&
-              model.class::TYPED_STAGES.find { |t| t.code.to_s == value.to_s }) ||
-             Pubid::Iso.locate_stage_by_code(value)
+              model.class::TYPED_STAGES.find do |t|
+                t.code.to_s == value.to_s
+              end) ||
+          Pubid::Iso.locate_stage_by_code(value)
         return unless ts
 
         # The renderer prefers `original_abbr` (the parsed surface form); without
@@ -196,7 +200,7 @@ module Pubid
         return if v.nil? || v.to_s.empty?
 
         doc.add_child(Lutaml::KeyValue::DataModel::Element.new("stage_iteration",
-                                                                v.to_s))
+                                                               v.to_s))
       end
 
       def stage_iteration_from_kv(model, value)
@@ -219,7 +223,11 @@ module Pubid
       # --- date serialized flat as year/month/day ---
       def year_to_kv(model, doc) = emit_date_part(doc, "year", model.date&.year)
       def year_from_kv(model, value) = date_for(model).year = value.to_s
-      def month_to_kv(model, doc) = emit_date_part(doc, "month", model.date&.month)
+
+      def month_to_kv(model, doc)
+        emit_date_part(doc, "month", model.date&.month)
+      end
+
       def month_from_kv(model, value) = date_for(model).month = value.to_s
       def day_to_kv(model, doc) = emit_date_part(doc, "day", model.date&.day)
       def day_from_kv(model, value) = date_for(model).day = value.to_s
@@ -252,7 +260,8 @@ module Pubid
         pub = model.publisher&.publisher
         return if pub.nil? || pub == model.class.default_publisher&.publisher
 
-        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("publisher", pub))
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("publisher",
+                                                               pub))
       end
 
       def publisher_from_kv(model, value)
@@ -264,7 +273,8 @@ module Pubid
         return unless cp&.any?
 
         doc.add_child(
-          Lutaml::KeyValue::DataModel::Element.new("copublishers", cp.map(&:to_s)),
+          Lutaml::KeyValue::DataModel::Element.new("copublishers",
+                                                   cp.map(&:to_s)),
         )
       end
 
@@ -304,10 +314,10 @@ module Pubid
         when :mr_string
           Pubid::Parsers::MrString.parse(string)
         else
-          # R1 parser swap: the baked PG artifact is the identifier
-          # parser of record; the Builder consumes the same attribute
-          # hash it always has.
-          parsed = Pubid::Parg::Backend.parse(:iso, string)
+          # The baked PG artifact parses through the grammar's declared
+          # bindings: the Builder consumes the typed bound map (every
+          # capture bound by name, supplement layers position-scoped).
+          parsed = Pubid::Parg::Model.bound(:iso, string)
           Pubid::Iso::Builder.new.build(parsed)
         end
       end

data/lib/pubid/iso/normalizer.rb

@@ -7,7 +7,7 @@ module Pubid
     # update_codes regex rewrites, and the DAD/FDAM pattern that the PEG
     # parser cannot recognize because it treats "/" as a copublisher separator.
     class Normalizer
-      DAD_PATTERN = /^(.+?)\/(F?DAD)\s+(\d+)(?::(\d{4}))?$/.freeze
+      DAD_PATTERN = /^(.+?)\/(F?DAD)\s+(\d+)(?::(\d{4}))?$/
 
       class << self
         # Apply all normalizations to an identifier string and return the
@@ -29,8 +29,9 @@ module Pubid
         def parse_with_builder(string)
           # R2 ingestion hook: normalized strings reach the model through
           # the same parser of record as Identifier.parse (the baked PG
-          # artifact), so every Tier-3 normalization feeds one grammar.
-          parsed = Pubid::Parg::Backend.parse(:iso, string)
+          # artifact's bindings), so every Tier-3 normalization feeds one
+          # grammar.
+          parsed = Pubid::Parg::Model.bound(:iso, string)
           Pubid::Iso.builder.build(parsed)
         end
 
@@ -71,7 +72,7 @@ module Pubid
           supplement_number = match[3] # "1"
           supplement_year = match[4]   # "1987" or nil
 
-          base_parsed = Pubid::Parg::Backend.parse(:iso, base_str)
+          base_parsed = Pubid::Parg::Model.bound(:iso, base_str)
           base = Pubid::Iso.builder.build(base_parsed)
 
           addendum = Identifiers::Addendum.new

data/lib/pubid/iso/urn_parser.rb

@@ -437,9 +437,14 @@ module Pubid
           base_hash[:languages] = languages.join("/")
         end
 
-        # Build supplements recursively (forward order: first supplement wraps base,
-        # second wraps first, etc. -- matching URN left-to-right semantics)
-        supplements.each do |supp|
+        # Build supplements (forward order: first supplement wraps base,
+        # second wraps first, etc. -- matching URN left-to-right
+        # semantics). Each layer captures into the bound hash's
+        # position-scoped prefix (supp_ / supp2_ / supp3_), the same
+        # names the grammar binds, so the builder peels the wrappers the
+        # same way for both parse paths.
+        supplements.each_with_index do |supp, index|
+          prefix = index.zero? ? "supp_" : "supp#{index + 1}_"
           # A bare language token with no supplement identity names the BASE
           # document: wrapping it would build a supplement with no type,
           # number or base attribute, and a plain standard drops its base —
@@ -499,11 +504,11 @@ typed_stage
             supp_hash[:languages] = supp[:languages].join("/")
           end
 
-          # Wrap current identifier with supplement
-          base_hash = {
-            base: base_hash,
-            **supp_hash,
-          }
+          # Layer the supplement onto the flat bound hash under its
+          # position-scoped prefix
+          supp_hash.each do |key, value|
+            base_hash[:"#{prefix}#{key}"] = value
+          end
         end
 
         # all_parts belongs on the outermost identifier (after any supplement wrapping)

data/lib/pubid/jis/CLAUDE.md

@@ -0,0 +1,36 @@
+# JIS flavor notes
+
+## WES lives in the JIS flavor (relaton-jis#18)
+
+- WES (Japan Welding Engineering Society) ids — `WES 7700-1:2019`,
+  `WES 7301:2020R` — parse as `Identifiers::WeldingEngineeringStandard`
+  (`_type: pubid:jis:welding-engineering-standard`). JSA Webdesk sells WES next
+  to JIS and relaton crawls both into one `relaton-data-jis` index, so a
+  separate `Pubid::Wes` flavor was rejected.
+- **Grammar**: `data/parg/jis.json` is `identifier = wes_identifier /
+  jis_identifier`. The WES branch is `"WES" space number parts …` with the same
+  tail as JIS (year, `R`, language, 規格群, supplements, SYMBOL) and binds a
+  `wes` capture, which the builder keys on. `JIS WES 7700` and `WES X 7700`
+  are rejected: the JIS prefix and a series letter belong only to JIS. The
+  source of record is pubid/pubid-grammar; the artifact was rebaked here with
+  parsanol **1.3.114** — the PATH `parsanol` shim may be a newer version, so
+  bake with the 1.3.114 gem's `exe/parsanol` and check `compiler_version`.
+- **`series` is nil** for WES (JIS keeps its `""`-coerced String), so the hash
+  carries no `series` key. `number` is the bare number (`"7700"`), the index
+  key.
+- **"WES" is the root, not a publisher**: `publisher_prefix` is nil, `code`
+  is `"WES 7700-1"`, so `to_s(with_publisher: false)` still prints `WES …`,
+  also as the base of a supplement. The URN is `urn:jis:WES 7700-1:2019`;
+  `UrnParser` does not prepend `JIS ` to a code that starts with `WES `.
+- `PREFIXES` includes `"WES"`, so `Pubid.parse("WES …")` routes to JIS.
+
+## Equality includes the class
+
+- `Identifier#==` requires `other.instance_of?(self.class)`: `JIS TR X
+  0014:1999` is not `JIS X 0014:1999` (3 such pairs are in the published
+  index), and `WES 7700` is never a JIS standard. `#matches?` follows, since it
+  compares `exclude(…)` results with `==`.
+- `SupplementIdentifier#==` also compares `symbol` and `reaffirmed?`:
+  `…/AMD 3:2025R SYMBOL 65700` is not `…/AMD 3:2025`.
+- The all-parts match is `===` (`Pubid::AllParts`), not `==`, and is
+  unchanged.

data/lib/pubid/jis/builder.rb

@@ -37,26 +37,26 @@ module Pubid
 
       def build_single_identifier(data)
         attrs = {
-          series: data[:series].to_s,
           number: data[:number].to_s,
           parts: extract_part_strings(data[:parts]),
           year: data[:year]&.to_i,
           language: data[:language]&.to_s,
           reaffirmed: (true if data[:reaffirmed]),
         }
+        # A WES id carries no series letter, so its series stays nil.
+        wes = Identifiers::WeldingEngineeringStandard
+        return wes.new(**attrs) if data[:wes]
 
-        # Determine identifier class from type
-        type = data[:type]&.to_s
-        klass = case type
-                when "TR"
-                  Identifiers::TechnicalReport
-                when "TS"
-                  Identifiers::TechnicalSpecification
-                else
-                  Identifiers::JapaneseIndustrialStandard
-                end
+        jis_class_for_type(data[:type]&.to_s)
+          .new(series: data[:series].to_s, **attrs)
+      end
 
-        klass.new(**attrs)
+      def jis_class_for_type(type)
+        case type
+        when "TR" then Identifiers::TechnicalReport
+        when "TS" then Identifiers::TechnicalSpecification
+        else Identifiers::JapaneseIndustrialStandard
+        end
       end
 
       def build_amendment(data)

data/lib/pubid/jis/identifier.rb

@@ -43,6 +43,8 @@ module Pubid
         "pubid:jis:amendment" => "Pubid::Jis::Identifiers::Amendment",
         "pubid:jis:corrigendum" => "Pubid::Jis::Identifiers::Corrigendum",
         "pubid:jis:explanation" => "Pubid::Jis::Identifiers::Explanation",
+        "pubid:jis:welding-engineering-standard" =>
+          "Pubid::Jis::Identifiers::WeldingEngineeringStandard",
       }.freeze
 
       key_value do
@@ -63,6 +65,12 @@ module Pubid
       # would otherwise fail serialization type validation.
       PUBLISHER = "JIS"
 
+      # The token the human render prints before the designation, and drops
+      # for `to_s(with_publisher: false)`; nil when the designation has none.
+      def publisher_prefix
+        PUBLISHER
+      end
+
       def reaffirmed?
         reaffirmed == true
       end
@@ -88,8 +96,10 @@ module Pubid
         result
       end
 
+      # The class is part of the identity: "JIS TR X 0014:1999" is not
+      # "JIS X 0014:1999", and "WES 7700" is not a JIS standard.
       def ==(other)
-        return false unless other.is_a?(Identifier)
+        return false unless other.instance_of?(self.class)
 
         series == other.series &&
           number == other.number &&

data/lib/pubid/jis/identifiers/welding_engineering_standard.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jis
+    module Identifiers
+      # Japan Welding Engineering Society standard. JSA sells WES next to JIS,
+      # so it parses through the JIS flavor, but the id carries no series
+      # letter and no JIS prefix.
+      # Examples: WES 7700-1:2019, WES 7301:2020R
+      class WeldingEngineeringStandard < SingleIdentifier
+        PUBLISHER = "WES"
+
+        def type_prefix
+          nil
+        end
+
+        # "WES" is the root of the designation, not a publisher token, so
+        # `to_s(with_publisher: false)` keeps it.
+        def publisher_prefix
+          nil
+        end
+
+        def code
+          result = "#{PUBLISHER} #{number}"
+          result += parts.map { |p| "-#{p}" }.join if parts&.any?
+          result
+        end
+
+        def mr_publisher
+          PUBLISHER.downcase
+        end
+      end
+    end
+  end
+end

data/lib/pubid/jis/identifiers.rb

@@ -13,6 +13,8 @@ module Pubid
       autoload :TechnicalReport, "#{__dir__}/identifiers/technical_report"
       autoload :TechnicalSpecification,
                "#{__dir__}/identifiers/technical_specification"
+      autoload :WeldingEngineeringStandard,
+               "#{__dir__}/identifiers/welding_engineering_standard"
     end
   end
 end

data/lib/pubid/jis/renderer.rb

@@ -44,7 +44,7 @@ module Pubid
       def render_single(id)
         with_pub = with_publisher?(id)
         parts = []
-        parts << PUBLISHER if with_pub
+        parts << id.publisher_prefix if with_pub && id.publisher_prefix
         parts << id.type_prefix if id.class.method_defined?(:type_prefix) && id.type_prefix
         result = parts.join(" ")
         result += " " if result.length.positive?

data/lib/pubid/jis/supplement_identifier.rb

@@ -38,12 +38,12 @@ module Pubid
       end
 
       def ==(other)
-        return false unless other.is_a?(SupplementIdentifier)
-        return false unless other.class == self.class
+        return false unless other.instance_of?(self.class)
 
-        base == other.base &&
-          number == other.number &&
-          year == other.year
+        # A supplement carries its own reaffirmation and SYMBOL clause.
+        %i[base number year reaffirmed? symbol].all? do |field|
+          public_send(field) == other.public_send(field)
+        end
       end
     end
   end

data/lib/pubid/jis/urn_parser.rb

@@ -9,12 +9,13 @@ module Pubid
     #
     # Examples:
     # - urn:jis:X 0201:1997 → JIS X 0201:1997
+    # - urn:jis:WES 7700-1:2019 → WES 7700-1:2019 (the code carries its root)
     class UrnParser < Pubid::UrnParser::Base
       def parse_urn(urn)
         body = strip_namespace(urn)
         parts = split_parts(body)
         code, year = parts
-        text = "JIS #{code}"
+        text = code.to_s.start_with?("WES ") ? code.dup : "JIS #{code}"
         text += ":#{year}" if year
         flavor_parse(text)
       end

data/lib/pubid/jis.rb

@@ -5,9 +5,10 @@ module Pubid
   module Jis
     extend Pubid::PrefixesSupport
 
-    # Sole JIS publisher token (see the parser's `jis_prefix` rule). Document
+    # The JIS publisher token, and WES, the root of a Japan Welding
+    # Engineering Society id (the grammar's `wes_identifier` rule). Document
     # types (TR/TS) follow the JIS prefix and are excluded.
-    PREFIXES = ["JIS"].freeze
+    PREFIXES = ["JIS", "WES"].freeze
 
     autoload :Builder, "#{__dir__}/jis/builder"
     autoload :Identifier, "#{__dir__}/jis/identifier"

data/lib/pubid/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pubid
-  VERSION = "2.0.2"
+  VERSION = "2.0.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pubid
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.0.4
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-11-01 00:00:00.000000000 Z
+date: 2026-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -28,22 +28,16 @@ dependencies:
   name: parsanol
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.3.114
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: 1.3.122
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.3.114
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: 1.3.122
 description: PubID is a Ruby library for parsing and generating international publication
   identifiers (PubIDs). It provides a simple and flexible API for working with PubIDs,
   allowing developers to easily create, manipulate, and validate PubIDs in their applications.
@@ -103,6 +97,7 @@ files:
 - data/parg/ire.parg
 - data/parg/isbn.json
 - data/parg/iso.json
+- data/parg/iso.parg
 - data/parg/itu.json
 - data/parg/jcgm.json
 - data/parg/jis.json
@@ -792,6 +787,7 @@ files:
 - lib/pubid/jcgm/urn_generator.rb
 - lib/pubid/jcgm/urn_parser.rb
 - lib/pubid/jis.rb
+- lib/pubid/jis/CLAUDE.md
 - lib/pubid/jis/builder.rb
 - lib/pubid/jis/identifier.rb
 - lib/pubid/jis/identifiers.rb
@@ -803,6 +799,7 @@ files:
 - lib/pubid/jis/identifiers/standard.rb
 - lib/pubid/jis/identifiers/technical_report.rb
 - lib/pubid/jis/identifiers/technical_specification.rb
+- lib/pubid/jis/identifiers/welding_engineering_standard.rb
 - lib/pubid/jis/parser.rb
 - lib/pubid/jis/renderer.rb
 - lib/pubid/jis/single_identifier.rb