pubid 2.0.0.pre.alpha.1 → 2.0.0.pre.alpha.3

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

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require "lutaml/model"
-
-module Pubid
-  module Jis
-    module Components
-      # Represents a JIS code with series letter, number, and optional parts
-      # Examples:
-      #   A 0001          => series: "A", number: 1, parts: []
-      #   B 0060-1        => series: "B", number: 60, parts: [1]
-      #   C 61000-3-2     => series: "C", number: 61000, parts: [3, 2]
-      #   C 5401-2-001    => series: "C", number: 5401, parts: [2, 1] (with formatting)
-      class Code < Lutaml::Model::Serializable
-        attribute :series, :string    # Single letter A-Z
-        attribute :number, :integer   # Required number
-        attribute :parts, :integer, collection: true # Optional multi-level parts
-
-        # Store original string representations for formatting
-        attr_accessor :number_string, :part_strings
-
-        def initialize(series:, number:, parts: nil, number_string: nil,
-part_strings: nil)
-          @series = series
-          @number = number
-          @parts = parts || []
-          @number_string = number_string || format_number(number)
-          @part_strings = part_strings || @parts.map(&:to_s)
-        end
-
-        # Render as "SERIES NUMBER[-PART[-SUBPART[...]]]"
-        def to_s
-          result = "#{series} #{number_string}"
-          result += part_strings.map { |p| "-#{p}" }.join if part_strings&.any?
-          result
-        end
-
-        def ==(other)
-          return false unless other.is_a?(Code)
-
-          series == other.series &&
-            number == other.number &&
-            parts == other.parts
-        end
-
-        private
-
-        def format_number(num)
-          # Preserve leading zeros: pad to 4 digits if less than 1000
-          if num < 1000
-            num.to_s.rjust(4, "0")
-          else
-            num.to_s
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Jis
-    module Identifiers
-      # Base class for all JIS identifiers
-      # Provides common attributes and behavior
-      class Base < Pubid::Identifier
-        # Generate URN for this identifier
-        #
-        # @return [String] URN representation
-
-        attribute :code, Pubid::Jis::Components::Code
-        attribute :year, :integer
-        attribute :language, :string # "E" or "J"
-        attribute :all_parts, :boolean, default: -> { false }
-
-        def initialize(code: nil, series: nil, number: nil, parts: nil,
-                      year: nil, language: nil, all_parts: false)
-          if code
-            @code = code
-          elsif series && number
-            @code = Components::Code.new(
-              series: series,
-              number: number,
-              parts: parts || [],
-            )
-          end
-          @year = year
-          @language = language
-          @all_parts = all_parts
-        end
-
-        # Publisher is always JIS
-        def publisher
-          "JIS"
-        end
-
-        def all_parts?
-          all_parts == true
-        end
-
-        # Comparison with all_parts logic
-        # When either identifier has all_parts=true, compare only series and number
-        def ==(other)
-          return false unless other.is_a?(Base)
-
-          if all_parts? || other.all_parts?
-            # Compare only series and number, ignore year, parts, all_parts
-            return code.series == other.code.series &&
-                code.number == other.code.number
-          end
-
-          # Normal full comparison
-          code == other.code &&
-            year == other.year &&
-            language == other.language &&
-            all_parts == other.all_parts
-        end
-
-        # Basic string representation (override in subclasses)
-        def to_s
-          parts = [publisher, code.to_s]
-          parts << ":#{year}" if year
-          parts << "(#{language})" if language
-          parts << "（規格群）" if all_parts?
-          parts.join(" ")
-        end
-      end
-    end
-  end
-end

data/lib/pubid/jis/scheme.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Jis
-    class Scheme < Pubid::Scheme
-      class << self
-        def identifiers
-          [
-            Identifiers::Standard,
-            Identifiers::TechnicalReport,
-            Identifiers::TechnicalSpecification,
-          ]
-        end
-
-        def typed_stages
-          identifiers.flat_map { |klass| klass::TYPED_STAGES }
-        end
-
-        def locate_typed_stage_by_abbr(abbr)
-          abbr = "JIS" if abbr.nil? || abbr.to_s.empty?
-
-          typed_stage = typed_stages.detect do |ts|
-            ts.abbr.include?(abbr)
-          end
-
-          unless typed_stage
-            raise ArgumentError,
-                  "Unknown type abbreviation: '#{abbr}'"
-          end
-
-          typed_stage
-        end
-
-        def locate_identifier_klass_by_type_code(type_code)
-          identifier_klass = identifiers.detect do |klass|
-            klass.type[:key].to_s == type_code.to_s
-          end
-
-          unless identifier_klass
-            raise ArgumentError,
-                  "Unknown type code: #{type_code}"
-          end
-
-          identifier_klass
-        end
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-# 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/scheme.rb

@@ -1,199 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Nist
-    # Scheme class for NIST identifier registry
-    # Single Responsibility: Identifier class registry and series-to-class mapping
-    class Scheme < Pubid::Scheme
-      class << self
-        # Aggregate TYPED_STAGES from all identifier classes
-        # @return [Array<Components::TypedStage>] all typed stages
-        def typed_stages
-          @typed_stages ||= identifiers
-            .reject { |klass| klass == Identifiers::Base } # Skip Base fallback class
-            .flat_map(&:typed_stages)
-            .freeze
-        end
-
-        # Locate TypedStage by abbreviation
-        # @param abbr [String, Symbol] the type abbreviation
-        # @return [Components::TypedStage] the matching typed stage
-        # @raise [ArgumentError] if abbreviation not found
-        def locate_typed_stage_by_abbr(abbr)
-          abbr_str = abbr.to_s.upcase
-          typed_stages.find do |ts|
-            ts.abbr.any? { |a| a.to_s.upcase == abbr_str }
-          end || raise(ArgumentError, "Unknown type abbreviation: #{abbr}")
-        end
-
-        # Locate identifier class by type code
-        # @param type_code [String, Symbol] the type code
-        # @return [Class] the identifier class
-        # @raise [ArgumentError] if type code not found
-        def locate_identifier_klass_by_type_code(type_code)
-          type_str = type_code.to_s
-          identifiers
-            .reject { |klass| klass == Identifiers::Base } # Skip Base fallback class
-            .find do |klass|
-              klass.typed_stages.any? { |ts| ts.type_code.to_s == type_str }
-            end || raise(ArgumentError, "Unknown type code: #{type_code}")
-        end
-
-        # Locate identifier class by series and pattern
-        # @param parsed_hash [Hash] the parsed identifier data
-        # @return [Class] the identifier class
-        def locate_identifier_klass(parsed_hash)
-          series = parsed_hash[:series]&.to_s
-
-          # Handle compound series that include publisher (both space and dot separated)
-          if series&.start_with?("NBS ")
-            simple_series = series.sub("NBS ", "")
-
-            # Check for CIRC supplement
-            if simple_series == "CIRC"
-              if has_supplement?(parsed_hash)
-                return Identifiers::CircularSupplement
-              else
-                return Identifiers::Circular
-              end
-            end
-
-            # Use simple series for lookup (TYPED_STAGES abbr handles compound forms)
-            series = simple_series
-          elsif series&.start_with?("NBS.")
-            # Handle dot-separated patterns (e.g., "NBS.LCIRC" after preprocessing)
-            simple_series = series.sub("NBS.", "")
-
-            # Check for LCIRC supplement (dot-separated variant)
-            if simple_series == "LCIRC"
-              if has_supplement?(parsed_hash)
-                return Identifiers::CircularSupplement
-              else
-                return Identifiers::LetterCircular
-              end
-            end
-
-            # Check for CIRC supplement (dot-separated variant)
-            if simple_series == "CIRC"
-              if has_supplement?(parsed_hash)
-                return Identifiers::CircularSupplement
-              else
-                return Identifiers::Circular
-              end
-            end
-
-            # Use simple series for lookup
-            series = simple_series
-          elsif series&.start_with?("NIST.")
-            # Handle dot-separated NIST patterns
-            simple_series = series.sub("NIST.", "")
-
-            # Check for LCIRC supplement (dot-separated variant)
-            if simple_series == "LCIRC"
-              if has_supplement?(parsed_hash)
-                return Identifiers::CircularSupplement
-              else
-                return Identifiers::LetterCircular
-              end
-            end
-
-            # Use simple series for lookup
-            series = simple_series
-          end
-
-          # Check for CS variants (works for both compound "NBS CS" and simple "CS")
-          if series == "CS"
-            first_num = parsed_hash[:first_number]
-
-            # Check for CSM (monthly) - v#n# pattern inside first_number hash
-            if first_num.is_a?(Hash) && first_num[:volume_number] && first_num[:issue_number]
-              return Identifiers::CommercialStandardsMonthly
-            end
-
-            # Check for CS-E (emergency) - e-prefix with 3+ digits
-            # Handle Parslet::Slice by converting to string
-            first_num_str = first_num.is_a?(String) ? first_num.to_str : first_num.to_s
-
-            # Match e104 or e104 (when "e104-43" is split into first+second)
-            if /^e\d{3,}/.match?(first_num_str)
-              return Identifiers::CommercialStandardEmergency
-            end
-          end
-
-          # Look up using TYPED_STAGES registry (replaces series_to_class_map)
-          # This handles simple series, compound series (via abbr array), and all variants
-          begin
-            typed_stage = locate_typed_stage_by_abbr(series)
-            type_code = typed_stage.type_code
-            locate_identifier_klass_by_type_code(type_code)
-          rescue ArgumentError
-            # Fallback to Base for unmapped series (e.g., "AMS", "VTS")
-            Identifiers::Base
-          end
-        end
-
-        # Check if parsed hash has supplement indicators
-        def has_supplement?(parsed_hash)
-          parsed_hash[:supplement] ||
-            parsed_hash[:supplement_date_range] ||
-            parsed_hash[:supplement_date] ||
-            parsed_hash[:supplement_slash_year] ||
-            parsed_hash[:supplement_with_rev]
-        end
-
-        # All identifier classes
-        # @return [Array<Class>] list of all identifier classes
-        def identifiers
-          @identifiers ||= [
-            Identifiers::SpecialPublication,
-            Identifiers::FederalInformationProcessingStandards,
-            Identifiers::InteragencyReport,
-            Identifiers::Handbook,
-            Identifiers::TechnicalNote,
-            Identifiers::Circular,
-            Identifiers::CircularSupplement,
-            Identifiers::CrplReport,
-            Identifiers::Report,
-            Identifiers::Monograph,
-            Identifiers::MiscellaneousPublication,
-            Identifiers::GrantContractorReport,
-            Identifiers::Ncstar,
-            Identifiers::Owmwp,
-            Identifiers::Nsrds,
-            Identifiers::LetterCircular,
-            Identifiers::CommercialStandard,
-            Identifiers::CommercialStandardEmergency,
-            Identifiers::CommercialStandardsMonthly,
-            Identifiers::Base, # Fallback for unmapped series
-          ].freeze
-        end
-
-        # Check if series is valid
-        # @param series_code [String] the series code
-        # @return [Boolean] true if series is valid
-        def valid_series?(series_code)
-          VALID_SERIES.include?(series_code)
-        end
-
-        # All valid series codes (comprehensive list)
-        VALID_SERIES = [
-          # Major series with dedicated classes
-          "SP", "FIPS", "IR", "HB", "TN",
-          # Specialized series with dedicated classes
-          "CIRC", "CRPL", "CS", "CSM",
-          # Other series (use Base class)
-          "GCR", "AMS", "BSS", "BMS", "BH", "MONO", "MP",
-          "NCSTAR", "NSRDS", "CSWP", "VTS", "AI", "OWMWP",
-          "PC", "RPT", "SIBS", "TIBM", "TTB", "EAB",
-          "JPCRD", "JRES", "CIS", "HR", "IRPL", "IP",
-          "LC", "PS", "LCIRC",
-          # Compound series
-          "BRPD-CRPL-D", "CRPL-F-A", "CRPL-F-B", "CS-E",
-          "CSRC Building Block", "CSRC Use Case", "CSRC Book",
-          "ITL Bulletin", "NIST LC", "NIST PS", "NIST DCI",
-          "NIST Other", "NSRDS-NBS"
-        ].freeze
-      end
-    end
-  end
-end

data/lib/pubid/oiml/scheme.rb

@@ -1,46 +0,0 @@
-# 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/plateau/scheme.rb

@@ -1,45 +0,0 @@
-require "lutaml/model"
-# frozen_string_literal: true
-
-module Pubid
-  module Plateau
-    class Scheme < Lutaml::Model::Serializable
-      attribute :type, :string
-      attribute :number, :integer
-      attribute :annex, :integer, default: -> {}
-      attribute :edition, :string, default: -> {}
-
-      def to_s
-        result = "PLATEAU #{type_string} #{formatted_number}"
-        result += formatted_annex if annex
-        result += " #{formatted_edition}" if edition
-        result
-      end
-
-      private
-
-      def type_string
-        case type
-        when "Handbook"
-          "Handbook"
-        when "Technical Report"
-          "Technical Report"
-        else
-          type
-        end
-      end
-
-      def formatted_number
-        "#%02d" % number
-      end
-
-      def formatted_annex
-        "-#{annex}"
-      end
-
-      def formatted_edition
-        "第#{edition}版"
-      end
-    end
-  end
-end

data/lib/pubid/rendering/base.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "publisher"
-require_relative "numbering"
-require_relative "date"
-require_relative "supplement"
-require_relative "stage"
-require_relative "language"
-require_relative "format"
-
-module Pubid
-  module Rendering
-    module Base
-      include Pubid::Rendering::Publisher
-      include Pubid::Rendering::Numbering
-      include Pubid::Rendering::Date
-      include Pubid::Rendering::Supplement
-      include Pubid::Rendering::Stage
-      include Pubid::Rendering::Language
-      include Pubid::Rendering::Format
-
-      # Base rendering method to be composed by subclasses
-      # @param options [Hash] rendering options
-      # @return [String] formatted identifier string
-      def render_base(**options)
-        parts = []
-
-        # Publisher/copublisher
-        pub = maybe(:publisher)
-        if pub
-          parts << render_publisher(pub,
-                                    maybe(:copublishers), **options)
-        end
-
-        # Numbering (number, part, subpart)
-        num = maybe(:number)
-        if num
-          parts << render_numbering(num, maybe(:part),
-                                    maybe(:subpart), **options)
-        end
-
-        # Date
-        d = maybe(:date)
-        if d
-          parts << render_date(d, **options)
-        end
-
-        # Stage and type
-        stg = maybe(:stage)
-        if stg
-          parts << render_stage(stg, maybe(:type),
-                                has_copublisher: maybe(:copublishers)&.any?, **options)
-        end
-
-        # Language codes
-        langs = maybe(:languages)
-        if langs&.any?
-          parts << render_languages(langs, **options)
-        end
-
-        parts.compact.join
-      end
-
-      private
-
-      def maybe(method_name)
-        return nil unless self.class.attributes.key?(method_name)
-
-        public_send(method_name)
-      end
-    end
-  end
-end