pubid 2.0.24 → 2.0.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd50bd4f50c75670cd2212192f3b267c7b246e0bd46b3d7c8a8d191c3d57ed2d
-  data.tar.gz: 99718c01c70282d9c28a62064c822b2c86f4856a9d3097f6ca7e67c930221789
+  metadata.gz: e4c2df973dfad39ae259a1f12504977716b523133f7ba6e98f86dc1359274206
+  data.tar.gz: c4c7e18a50914f61ca002b3ce53d00b4b7dcdfdcac33168b34e6109f8f6b2890
 SHA512:
-  metadata.gz: dd66c8243817ea77c54956e963cb1ea469c90728ea3e84336c18fb7c010beb961c069242a5acb439892b99d2ae1a4e44f4a6877cab56a986eefd6b0a5784907a
-  data.tar.gz: 74f3abb03d7785b95678b05ce0615fe16e21c2ebb67228014424c254e95ab3e37dc17dd86bbb71dcd6b8279152ed620ac386ecda4b3f2b429feb4acec8967b33
+  metadata.gz: 1224c069ca1bc1caa4ca1968252a4686dff6a99ac99b167e65546a800f0b1067e88e807dbb87da80db18744bdde4a1c3aee630da35d4610cefa7d36d52a055fc
+  data.tar.gz: d9091695721ae3b73953f550b5515b598c7328875fc1c679f549e339d0de2daa517ed0412bcf33fe3c04568cd1522a0635f9033ba79983981cacbc04dbedd1cf

data/lib/pubid/jis/CLAUDE.md

@@ -29,6 +29,41 @@
   `UrnParser` does not prepend `JIS ` to a code that starts with `WES `.
 - `PREFIXES` includes `"WES"`, so `Pubid.parse("WES …")` routes to JIS.
 
+## WES `(E)` before the year, `WES TR`, `WES TS` (relaton-jis#18)
+
+- JSA Webdesk lists 14 WES ids that the grammar does not read:
+  `WES 1112(E):2022`, `WES TR 2032:2024`, `WES TS 2816(E):2015`.
+- **A Ruby shim reads them, not the grammar.** `Parser.ingest` cuts
+  the `TR`/`TS` token and a `(E)`/`(J)` that comes before `:year`, and
+  binds them as `wes_type` and `wes_language`. Other input passes unchanged.
+  The hand-off `pubid__pubid-grammar__jis-wes-language-tr-ts` asks
+  pubid-grammar to bind the same two captures. After that lands, re-vendor
+  `jis.json`, re-pin `parg_reaffirmed_spec.rb`, and delete the shim. The
+  builder does not change.
+- **`WES TR`/`WES TS` are classes**: `WeldingEngineeringTechnicalReport`
+  and `…TechnicalSpecification` < `WeldingEngineeringStandard`, with
+  `WES_TYPE` in `code` (`WES TR 2032`) and in `mr_type`. Class-strict `==`
+  keeps them apart from `WES 2032` and `JIS TR Z 2032`.
+- **`language_before_year`** records where the source put the language. It
+  is spelling only (`equality_ignored`, a `langfirst` facet in the pubid
+  URN): `WES 1112(E):2022 == WES 1112:2022(E)`, and each renders as written.
+  The language itself is identity, so the `(E)` edition is not the Japanese
+  one. JIS ids never set the flag; `JIS X 0208(E):1997` still fails.
+- The pubid URN schema now places `language` and the supplement ordinal
+  (`core: [["number", :int]]`; an `EXPL` number is the atom `n`). Before,
+  every `(E)` id and every supplement raised in `to_pubid_urn`, and no
+  supplement was in the fixture corpus to show it.
+- **`Builder` reads both parse shapes.** The typed bindings
+  (`Parg::Model.bound`) carry a supplement flat (`amd_type`, …); the raw
+  tree (`Parg::Backend.parse`) nests it under `:amendment`/`:explanation`/
+  `:corrigendum`. `flatten_supplement` folds the nested form. Before, the
+  tree path dropped every supplement silently (`…/AMD 1:2000` built as the
+  bare base). `typed_binding_parity_spec.rb` found it when the first
+  supplement entered the pass corpus.
+- **The shim lives in `Parser.ingest`** and returns `[face, bindings]`.
+  `typed_binding_parity_spec.rb` calls it on the tree path too and merges
+  the bindings, as `Identifier.parse` does.
+
 ## Equality includes the class
 
 - `Identifier#==` requires `other.instance_of?(self.class)`: `JIS TR X

data/lib/pubid/jis/builder.rb

@@ -8,6 +8,7 @@ module Pubid
       end
 
       def build(data)
+        data = flatten_supplement(data)
         # Handle supplement case first; the SYMBOL clause (if any) attaches to
         # the outermost identifier, be it the base or the supplement. The
         # bindings bind the supplement's fields flat (amd_type/amd_number/…),
@@ -29,6 +30,19 @@ module Pubid
 
       private
 
+      SUPPLEMENT_KEYS = %i[amendment explanation corrigendum].freeze
+
+      # The typed bindings carry a supplement's fields flat (amd_type, …).
+      # The raw parse tree nests them under :amendment, :explanation or
+      # :corrigendum. Read both shapes, or the tree path drops the
+      # supplement.
+      def flatten_supplement(data)
+        key = SUPPLEMENT_KEYS.find { |k| data[k].is_a?(Hash) }
+        return data unless key
+
+        data.except(key).merge(data[key].compact)
+      end
+
       # nil => no SYMBOL clause; "" => bare "SYMBOL" keyword; otherwise value.
       def attach_symbol(identifier, data)
         identifier.symbol = data[:symbol_value].to_s if data[:symbol_present]
@@ -44,13 +58,30 @@ module Pubid
           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]
+        return build_wes(data, attrs) if data[:wes]
 
         jis_class_for_type(data[:type]&.to_s)
           .new(series: data[:series].to_s, **attrs)
       end
 
+      # `wes_type` ("TR"/"TS") picks the WES class. `wes_language` is a
+      # language printed before the year ("WES 1112(E):2022").
+      def build_wes(data, attrs)
+        attrs = attrs.merge(wes_language_attrs(data)) if data[:wes_language]
+        Identifiers::WeldingEngineeringStandard
+          .class_for_type(data[:wes_type]&.to_s).new(**attrs)
+      end
+
+      def wes_language_attrs(data)
+        if data[:language]
+          raise Pubid::Errors::ParseError.new(
+            "a WES id carries one language, not two", nil
+          )
+        end
+
+        { language: data[:wes_language].to_s, language_before_year: true }
+      end
+
       def jis_class_for_type(type)
         case type
         when "TR" then Identifiers::TechnicalReport

data/lib/pubid/jis/identifier.rb

@@ -21,6 +21,11 @@ module Pubid
       attribute :parts, :string, collection: true # Optional multi-level parts
       attribute :year, :integer
       attribute :language, :string # "E" or "J"
+      # A WES id can print its language before the year ("WES 1112(E):2022")
+      # or after it ("WES 1112:2022(E)"). This records the source position.
+      # It is spelling only, so `==` does not read it.
+      attribute :language_before_year, :boolean
+      equality_ignored :language_before_year
       # Reaffirmation (再確認): a trailing "R" on the year marks an edition
       # that was reaffirmed without revision (e.g. ":2019R").
       attribute :reaffirmed, :boolean
@@ -45,6 +50,10 @@ module Pubid
         "pubid:jis:explanation" => "Pubid::Jis::Identifiers::Explanation",
         "pubid:jis:welding-engineering-standard" =>
           "Pubid::Jis::Identifiers::WeldingEngineeringStandard",
+        "pubid:jis:welding-engineering-technical-report" =>
+          "Pubid::Jis::Identifiers::WeldingEngineeringTechnicalReport",
+        "pubid:jis:welding-engineering-technical-specification" =>
+          "Pubid::Jis::Identifiers::WeldingEngineeringTechnicalSpecification",
       }.freeze
 
       key_value do
@@ -54,6 +63,7 @@ module Pubid
         map "parts", to: :parts
         map "year", to: :year
         map "language", to: :language
+        map "language_before_year", to: :language_before_year
         map "reaffirmed", to: :reaffirmed
         # render_empty keeps a bare "SYMBOL" (empty-string value) in the hash so
         # it round-trips distinctly from "no symbol" (nil).
@@ -75,6 +85,17 @@ module Pubid
         reaffirmed == true
       end
 
+      def language_before_year?
+        language_before_year == true
+      end
+
+      # The ":year[R]" and "(lang)" tail, in the order the source used.
+      def year_and_language
+        year_part = year ? ":#{year_with_reaffirmation}" : ""
+        lang_part = language ? "(#{language})" : ""
+        language_before_year? ? lang_part + year_part : year_part + lang_part
+      end
+
       # Render a year with its reaffirmation marker, e.g. "2019R".
       def year_with_reaffirmation
         "#{year}#{'R' if reaffirmed?}"
@@ -184,10 +205,9 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        identifier = ::Pubid.utf8_input(identifier)
-
-        parsed = Pubid::Parg::Model.bound(:jis, identifier)
-        Builder.build(parsed)
+        face, bindings = Parser.ingest(::Pubid.utf8_input(identifier))
+        parsed = Pubid::Parg::Model.bound(:jis, face)
+        Builder.build(parsed.merge(bindings))
       end
     end
   end

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

@@ -6,9 +6,20 @@ module Pubid
       # 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
+      # Examples: WES 7700-1:2019, WES 7301:2020R, WES 1112(E):2022
       class WeldingEngineeringStandard < SingleIdentifier
         PUBLISHER = "WES"
+        # The type token after the WES root: "TR", "TS", or nil.
+        WES_TYPE = nil
+
+        # The WES class for a type token ("TR", "TS" or nil).
+        def self.class_for_type(type)
+          case type
+          when "TR" then WeldingEngineeringTechnicalReport
+          when "TS" then WeldingEngineeringTechnicalSpecification
+          else WeldingEngineeringStandard
+          end
+        end
 
         def type_prefix
           nil
@@ -20,8 +31,12 @@ module Pubid
           nil
         end
 
+        def wes_type
+          self.class::WES_TYPE
+        end
+
         def code
-          result = "#{PUBLISHER} #{number}"
+          result = [PUBLISHER, wes_type, number].compact.join(" ")
           result += parts.map { |p| "-#{p}" }.join if parts&.any?
           result
         end
@@ -29,6 +44,10 @@ module Pubid
         def mr_publisher
           PUBLISHER.downcase
         end
+
+        def mr_type
+          wes_type&.downcase
+        end
       end
     end
   end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jis
+    module Identifiers
+      # WES technical report. The type token follows the WES root.
+      # Example: WES TR 2032:2024
+      class WeldingEngineeringTechnicalReport < WeldingEngineeringStandard
+        WES_TYPE = "TR"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jis
+    module Identifiers
+      # WES technical specification. The type token follows the WES root.
+      # Examples: WES TS 2816:2015, WES TS 2816(E):2015
+      class WeldingEngineeringTechnicalSpecification <
+            WeldingEngineeringStandard
+        WES_TYPE = "TS"
+      end
+    end
+  end
+end

data/lib/pubid/jis/identifiers.rb

@@ -15,6 +15,11 @@ module Pubid
                "#{__dir__}/identifiers/technical_specification"
       autoload :WeldingEngineeringStandard,
                "#{__dir__}/identifiers/welding_engineering_standard"
+      autoload :WeldingEngineeringTechnicalReport,
+               "#{__dir__}/identifiers/welding_engineering_technical_report"
+      autoload :WeldingEngineeringTechnicalSpecification,
+               "#{__dir__}/identifiers/" \
+               "welding_engineering_technical_specification"
     end
   end
 end

data/lib/pubid/jis/parser.rb

@@ -2,7 +2,37 @@
 
 module Pubid
   module Jis
+    # The JIS grammar is the vendored artifact data/parg/jis.json. This class
+    # holds only the Ruby ingestion in front of it.
     class Parser
+      # A WES type token or a language before the year. Full-width forms
+      # are accepted, as in the grammar.
+      WES_SHIM = /
+        \A(?<root>WES[ 　])
+        (?:(?<type>TR|TS)[ 　])?
+        (?<number>\d+(?:[-ｰ]\d+)*)
+        (?:[(（](?<lang>[EJ])[)）](?=[:：]))?
+      /x
+
+      # The vendored grammar (pubid-grammar artifacts/jis.json) reads neither
+      # "WES TR 2032" nor "WES 1112(E):2022". Until it does, cut those tokens
+      # from the input and bind them as `wes_type` and `wes_language`, the
+      # captures the grammar is to bind (hand-off
+      # pubid__pubid-grammar__jis-wes-language-tr-ts). Other input passes
+      # unchanged.
+      # @param input [String]
+      # @return [Array(String, Hash)] the input for the grammar, the bindings
+      #   to merge into what the grammar binds
+      def self.ingest(input)
+        match = WES_SHIM.match(input)
+        return [input, {}] unless match && (match[:type] || match[:lang])
+
+        bindings = {}
+        bindings[:wes_type] = match[:type] if match[:type]
+        bindings[:wes_language] = match[:lang] if match[:lang]
+        rest = input[match.end(0)..]
+        ["#{match[:root]}#{match[:number]}#{rest}", bindings]
+      end
     end
   end
 end

data/lib/pubid/jis/pubid_urn_schema.rb

@@ -13,17 +13,28 @@ module Pubid
       atom "parts", "part", kind: :list
       atom "year", "year", kind: :int
       atom "reaffirmed", "reaffirmed", kind: :bool
+      atom "language", "lang"
+      # Where a WES id prints its language: "WES 1112(E):2022" against
+      # "WES 1112:2022(E)". Spelling only.
+      facet "language_before_year", "langfirst", kind: :bool
 
       type "pubid:jis:all-parts", "all"
-      type "pubid:jis:amendment", "amd"
-      type "pubid:jis:corrigendum", "cor"
-      type "pubid:jis:explanation", "e"
+      # A supplement's number is its Integer ordinal. The document it
+      # supplements comes first, along +base+. An explanation can have no
+      # number ("…/EXPL"), so its number is an atom.
+      supplement = [["number", :int]]
+      type "pubid:jis:amendment", "amd", core: supplement
+      type "pubid:jis:corrigendum", "cor", core: supplement
+      type "pubid:jis:explanation", "e", core: [],
+                                         atoms: [["number", "n", :int]]
       type "pubid:jis:identifier", "id"
       type "pubid:jis:japanese-industrial-standard", "jis"
       type "pubid:jis:standard", "std"
       type "pubid:jis:technical-report", "tr"
       type "pubid:jis:technical-specification", "ts"
       type "pubid:jis:welding-engineering-standard", "wes"
+      type "pubid:jis:welding-engineering-technical-report", "westr"
+      type "pubid:jis:welding-engineering-technical-specification", "wests"
     end
   end
 end

data/lib/pubid/jis/renderer.rb

@@ -49,8 +49,7 @@ module Pubid
         result = parts.join(" ")
         result += " " if result.length.positive?
         result += id.code.to_s
-        result += ":#{id.year_with_reaffirmation}" if id.year
-        result += "(#{id.language})" if id.language
+        result += id.year_and_language
         result += id.symbol_suffix
         result
       end

data/lib/pubid/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pubid
 version: !ruby/object:Gem::Version
-  version: 2.0.24
+  version: 2.0.25
 platform: ruby
 authors:
 - Ribose Inc.
@@ -897,6 +897,8 @@ files:
 - 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/identifiers/welding_engineering_technical_report.rb
+- lib/pubid/jis/identifiers/welding_engineering_technical_specification.rb
 - lib/pubid/jis/parser.rb
 - lib/pubid/jis/pubid_urn_schema.rb
 - lib/pubid/jis/renderer.rb