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

data/lib/pubid/nist/components/code.rb

@@ -1,24 +1,35 @@
 # frozen_string_literal: true
 
+require "lutaml/model"
+
 module Pubid
   module Nist
     module Components
-      # Code component for NIST identifiers.
-      #
-      # Inherits +value+ and +subpart+ from the shared Code; overrides
-      # rendering to compose compound numbers like "1234.5" (subpart
-      # joined with "." per NIST convention).
-      class Code < ::Pubid::Components::Code
+      # Code component for NIST identifiers
+      # Handles number codes like series, volume, etc.
+      class Code < Lutaml::Model::Serializable
+        attribute :number, :string
+        attribute :subpart, :string
+
         def to_s
-          result = value.to_s
+          result = number.to_s
           result += ".#{subpart}" if subpart
           result
         end
 
+        # Alias for compatibility
+        def value
+          to_s
+        end
+
+        # Backward compatibility: extract part from compound numbers like "140-2"
+        # Returns the part number if the value contains a dash, nil otherwise
         def part
-          return nil unless value&.include?("-")
+          return nil unless number&.include?("-")
 
-          parts = value.to_s.split("-")
+          # Split by last dash to handle patterns like "4-4" (just number-part)
+          # and "4-M-5" (which would return "M-5" as part)
+          parts = number.to_s.split("-")
           parts.last if parts.length > 1
         end
       end

data/lib/pubid/nist/components/edition.rb

@@ -49,22 +49,6 @@ module Pubid
           end
         end
 
-        # Identity ignores original_prefix: it records how the edition was
-        # spelled in the source ("Rev. " vs "r") for round-trip rendering
-        # only. "r1" and "Rev. 1" are the same edition.
-        def ==(other)
-          return false unless other.is_a?(self.class)
-
-          type == other.type && id == other.id &&
-            additional_text == other.additional_text
-        end
-
-        alias eql? ==
-
-        def hash
-          [self.class, type, id, additional_text].hash
-        end
-
         private
 
         # Build short format: "e2", "e2.June1908", "e2.1908", "e2.50", "r1963", "-April1909", "r1a"

data/lib/pubid/nist/components/publisher.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Nist
+    module Components
+      # Publisher component for NIST identifiers
+      # Handles NIST and NBS publishers
+      class Publisher < Lutaml::Model::Serializable
+        attribute :publisher, :string
+
+        def to_s
+          publisher
+        end
+
+        # Alias for compatibility
+        def body
+          publisher
+        end
+      end
+    end
+  end
+end

data/lib/pubid/nist/components/supplement.rb

@@ -9,19 +9,17 @@ module Pubid
       # Represents supplement notation with number, year, month, or revision
       #
       # Examples:
-      #   Supplement.new(number: "2").to_s(:short)              # => "sup2"
-      #   Supplement.new(year: "1925").to_s(:short)              # => "sup1925"
-      #   Supplement.new(number: "3", year: "1926").to_s(:short) # => "sup3/1926"
-      #   Supplement.new(month: "Jan", year: "1924").to_s(:short) # => "supJan1924"
-      #   Supplement.new(has_revision: true).to_s(:short)        # => "suprev"
+      #   Supplement.new(number: "2").to_s(:short)              # => "supp2"
+      #   Supplement.new(year: "1925").to_s(:short)              # => "supp-1925"
+      #   Supplement.new(number: "3", year: "1926").to_s(:short) # => "supp3/1926"
+      #   Supplement.new(month: "Jan", year: "1924").to_s(:short) # => "suppJan1924"
+      #   Supplement.new(has_revision: true).to_s(:short)        # => "supprev"
       class Supplement < Lutaml::Model::Serializable
         attribute :number, :string           # Supplement number (e.g., "2" in "supp2")
-        attribute :year, :string             # Year (4 digits); range START year
-        attribute :month, :string            # Month abbreviation; range START month
-        # Date ranges reuse :month/:year as the start and add the end below. A
-        # present :month_end/:year_end is what marks a value as a range, so a
-        # lone month-year supplement is just a range with no end — and :year is
-        # the single field to filter on for both.
+        attribute :year, :string             # Year (4 digits)
+        attribute :month, :string            # Month abbreviation (Jan, Feb, etc.)
+        attribute :month_start, :string       # Date range start month
+        attribute :year_start, :string        # Date range start year
         attribute :month_end, :string         # Date range end month
         attribute :year_end, :string          # Date range end year
         attribute :has_revision, :boolean, default: -> {
@@ -29,36 +27,12 @@ module Pubid
         } # "supprev" pattern
         attribute :suffix, :string # General suffix for other patterns
 
-        # Build a Supplement from the flat string the parser/builder produces
-        # ("1924" year, "Jan1924" month+year, "1" number, "A" suffix, "" bare).
-        # has_revision is supplied separately. Returns a present-but-empty
-        # Supplement for an empty/nil value so callers can distinguish a bare
-        # supplement ("sup") from no supplement (nil).
-        def self.from_raw(value, has_revision: false)
-          supp = new
-          if has_revision
-            supp.has_revision = true
-          elsif value.nil? || value.to_s.empty?
-            # bare marker: present but no isolated parts
-          elsif (m = value.to_s.match(/\A([A-Za-z]{3,9})(\d{4})\z/))
-            supp.month = m[1]
-            supp.year = m[2]
-          elsif value.to_s.match?(/\A(?:18|19|20)\d{2}\z/)
-            supp.year = value.to_s
-          elsif value.to_s.match?(/\A\d+\z/)
-            supp.number = value.to_s
-          else
-            supp.suffix = value.to_s
-          end
-          supp
-        end
-
         # Render supplement in specified format
         # @param format [:short, :mr, :long] The output format
         # @return [String] The formatted supplement representation
         def to_s(format = :short)
-          return "" if number.nil? && year.nil? && month.nil? && !has_revision &&
-            suffix.nil? && month_end.nil? && year_end.nil?
+          return "" if number.nil? && year.nil? && !has_revision && suffix.nil? &&
+            month_start.nil? && year_start.nil? && month_end.nil? && year_end.nil?
 
           case format
           when :short, :mr
@@ -70,52 +44,12 @@ module Pubid
           end
         end
 
-        # True when this supplement is a date range (start reuses month/year).
-        def range?
-          date_range?
-        end
-
-        # The text after the "sup" marker for the simple (non-range, non-rev)
-        # forms: "1924" / "Jan1924" / "1" / "A"; "" for a bare supplement. Used
-        # by URN rendering, which handles range/revision separately.
-        def value_string
-          return "" if has_revision || date_range?
-          return suffix.to_s if suffix
-          return "#{month}#{year}" if month && year
-          return "#{number}/#{year}" if number && year
-          return year.to_s if year
-          return number.to_s if number
-
-          ""
-        end
-
-        # Value equality over the isolated parts, so a structured supplement
-        # participates correctly in Identifier#== and #matches? (two supplements
-        # with the same number/year/month/range/revision are the same).
-        IDENTITY_FIELDS = %i[
-          number year month month_end year_end has_revision suffix
-        ].freeze
-
-        def ==(other)
-          return false unless other.is_a?(self.class)
-
-          IDENTITY_FIELDS.all? { |f| public_send(f) == other.public_send(f) }
-        end
-
-        alias eql? ==
-
-        def hash
-          [self.class, *IDENTITY_FIELDS.map { |f| public_send(f) }].hash
-        end
-
         private
 
-        # Build short format: "sup2", "sup1925", "sup3/1926", "supJan1924", "suprev"
-        # NIST/NBS canonical short form is single-p "sup" with the suffix
-        # attached directly (relaton-data-nist uses "sup2", "sup1940", "supA").
+        # Build short format: "supp2", "supp-1925", "supp3/1926", "suppJan1924", "supprev"
         def build_short_format
-          return "suprev" if has_revision
-          return "sup#{suffix}" if suffix
+          return "supprev" if has_revision
+          return "supp#{suffix}" if suffix
           return build_date_range_format if date_range?
           return build_month_year_format if month && year
           return build_number_year_format if number && year
@@ -138,36 +72,32 @@ module Pubid
           ""
         end
 
-        # A range is marked by the presence of an END; START reuses month/year.
-        # Months are optional, so a year-only range ("1925-1926") also counts.
         def date_range?
-          year && year_end
+          month_start && year_start && month_end && year_end
         end
 
         def build_date_range_format
-          "sup#{month}#{year}-#{month_end}#{year_end}"
+          "supp#{month_start}#{year_start}-#{month_end}#{year_end}"
         end
 
         def build_month_year_format
-          "sup#{month}#{year}"
+          "supp#{month}#{year}"
         end
 
         def build_number_year_format
-          "sup#{number}/#{year}"
+          "supp#{number}/#{year}"
         end
 
         def build_year_format
-          "sup#{year}"
+          "supp-#{year}"
         end
 
         def build_number_format
-          "sup#{number}"
+          "supp#{number}"
         end
 
         def build_long_date_range_format
-          start = [month, year].compact.join(" ")
-          finish = [month_end, year_end].compact.join(" ")
-          "Supplement #{start}-#{finish}"
+          "Supplement #{month_start} #{year_start}-#{month_end} #{year_end}"
         end
 
         def build_long_month_year_format

data/lib/pubid/nist/components.rb

@@ -7,6 +7,7 @@ module Pubid
       autoload :Edition, "#{__dir__}/components/edition"
       autoload :IssueNumber, "#{__dir__}/components/issue_number"
       autoload :Part, "#{__dir__}/components/part"
+      autoload :Publisher, "#{__dir__}/components/publisher"
       autoload :Stage, "#{__dir__}/components/stage"
       autoload :Supplement, "#{__dir__}/components/supplement"
       autoload :Translation, "#{__dir__}/components/translation"

data/lib/pubid/nist/configuration.rb

@@ -58,13 +58,7 @@ module Pubid
       private
 
       def default_series_path
-        # Prefer data/nist/series.yaml (the canonical home in the monorepo);
-        # fall back to archived-gems/pubid-nist/series.yaml for backward
-        # compat with the v1 layout.
-        monorepo = File.join(__dir__, "../../../data/nist/series.yaml")
-        return monorepo if File.exist?(monorepo)
-
-        File.join(__dir__, "../../../archived-gems/pubid-nist/series.yaml")
+        File.join(__dir__, "../../../gems/pubid-nist/series.yaml")
       end
 
       def load_series
@@ -78,10 +72,6 @@ module Pubid
       end
     end
 
-    # Raised when the NIST series YAML cannot be loaded. Included in the
-    # marker module so `rescue Pubid::Errors::Error` stays exhaustive.
-    class ConfigurationError < StandardError
-      include ::Pubid::Errors::Error
-    end
+    class ConfigurationError < StandardError; end
   end
 end