dcc 0.2.0

data/lib/dcc/base/software_list.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Dcc
+  module Base
+    # `dcc:softwareListType` — collection of `dcc:software`.
+    module SoftwareList
+      def self.included(klass)
+        klass.class_eval do
+          attribute :id, :string
+          attribute :ref_id, :string
+          attribute :ref_type, :string
+          attribute :software, :software, collection: true
+
+          xml do
+            namespace ::Dcc::Namespace::Dcc
+            element "softwareList"
+            ordered
+            map_attribute "id", to: :id
+            map_attribute "refId", to: :ref_id
+            map_attribute "refType", to: :ref_type
+            map_element "software", to: :software
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dcc/base/statement.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Dcc
+  module Base
+    # `dcc:statementMetaDataType` — generic statement block used for conformity,
+    # traceability, validity range, etc. Carries a refType classifier.
+    module Statement
+      def self.included(klass)
+        klass.class_eval do
+          attribute :id, :string
+          attribute :ref_id, :string
+          attribute :ref_type, :string
+          attribute :country_code_iso_3166_1, ::Dcc::Type::IsoCountryCode
+          attribute :convention, :string
+          attribute :traceable, :boolean
+          attribute :norm, :text
+          attribute :reference, :text
+          attribute :declaration, :text
+          attribute :valid, :boolean
+          attribute :ref_id_statement, :string
+          attribute :date, :date
+          attribute :period, :string
+          attribute :non_si_unit, :string
+          attribute :non_si_definition, :text
+
+          xml do
+            namespace ::Dcc::Namespace::Dcc
+            element "statement"
+            ordered
+            map_attribute "id", to: :id
+            map_attribute "refId", to: :ref_id
+            map_attribute "refType", to: :ref_type
+            map_element "countryCodeISO3166_1", to: :country_code_iso_3166_1
+            map_element "convention", to: :convention
+            map_element "traceable", to: :traceable
+            map_element "norm", to: :norm
+            map_element "reference", to: :reference
+            map_element "declaration", to: :declaration
+            map_element "valid", to: :valid
+            map_element "refId", to: :ref_id_statement
+            map_element "date", to: :date
+            map_element "period", to: :period
+            map_element "nonSIUnit", to: :non_si_unit
+            map_element "nonSIDefinition", to: :non_si_definition
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dcc/base/statement_list.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Dcc
+  module Base
+    # `dcc:statementListType` — collection of `dcc:statement`.
+    module StatementList
+      def self.included(klass)
+        klass.class_eval do
+          attribute :id, :string
+          attribute :ref_id, :string
+          attribute :ref_type, :string
+          attribute :statement, :statement, collection: true
+
+          xml do
+            namespace ::Dcc::Namespace::Dcc
+            element "statements"
+            ordered
+            map_attribute "id", to: :id
+            map_attribute "refId", to: :ref_id
+            map_attribute "refType", to: :ref_type
+            map_element "statement", to: :statement
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dcc/base/string_with_lang.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Dcc
+  module Base
+    # `dcc:stringWithLangType` — single localized string with an optional
+    # `xml:lang` attribute. Used inside `dcc:textType` and many other types.
+    module StringWithLang
+      def self.included(klass)
+        klass.class_eval do
+          attribute :value, :string, collection: true
+          attribute :lang, :string
+
+          xml do
+            namespace ::Dcc::Namespace::Dcc
+            element "content"
+            mixed_content
+            map_content to: :value
+            map_attribute "lang", to: :lang
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dcc/base/text.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Dcc
+  module Base
+    # `dcc:textType` — multilingual text container. Holds interleaved
+    # `dcc:content` (localized text), `dcc:file` (byteData), and
+    # `dcc:formula` elements per the v3.3.0 XSD content model.
+    module Text
+      def self.included(klass)
+        klass.class_eval do
+          attribute :id, :string
+          attribute :ref_id, :string
+          attribute :ref_type, :string
+          attribute :content, :content, collection: true
+          attribute :file, :byteData, collection: true
+          attribute :formula, :formula, collection: true
+
+          xml do
+            namespace ::Dcc::Namespace::Dcc
+            element "text"
+            ordered
+            map_attribute "id", to: :id
+            map_attribute "refId", to: :ref_id
+            map_attribute "refType", to: :ref_type
+            map_element "content", to: :content
+            map_element "file", to: :file
+            map_element "formula", to: :formula
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dcc/base/used_method.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Dcc
+  module Base
+    # `dcc:usedMethodType` — calibration method with name/description/norm.
+    module UsedMethod
+      def self.included(klass)
+        klass.class_eval do
+          attribute :id, :string
+          attribute :ref_id, :string
+          attribute :ref_type, :string
+          attribute :name, :text
+          attribute :description, :text
+          attribute :norm, :text, collection: true
+
+          xml do
+            namespace ::Dcc::Namespace::Dcc
+            element "usedMethod"
+            ordered
+            map_attribute "id", to: :id
+            map_attribute "refId", to: :ref_id
+            map_attribute "refType", to: :ref_type
+            map_element "name", to: :name
+            map_element "description", to: :description
+            map_element "norm", to: :norm
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dcc/base/used_method_list.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Dcc
+  module Base
+    # `dcc:usedMethodListType` — collection of `dcc:usedMethod`.
+    module UsedMethodList
+      def self.included(klass)
+        klass.class_eval do
+          attribute :id, :string
+          attribute :ref_id, :string
+          attribute :ref_type, :string
+          attribute :used_method, :usedMethod, collection: true
+
+          xml do
+            namespace ::Dcc::Namespace::Dcc
+            element "usedMethods"
+            ordered
+            map_attribute "id", to: :id
+            map_attribute "refId", to: :ref_id
+            map_attribute "refType", to: :ref_type
+            map_element "usedMethod", to: :used_method
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dcc/base/xml_blob.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Dcc
+  module Base
+    # `dcc:xmlType` — opaque wildcard XML payload (`xs:any namespace="##other"`).
+    module XmlBlob
+      def self.included(klass)
+        klass.class_eval do
+          attribute :raw, :string
+
+          xml do
+            namespace ::Dcc::Namespace::Dcc
+            element "xml"
+            map_all to: :raw
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dcc/base.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# `Dcc::Base` hosts version-agnostic XML mapping modules for every DCC element
+# type. Each module follows the `self.included(klass)` pattern from mml so the
+# version wrapper classes (`Dcc::V2::*`, `Dcc::V3::*`) can mix them in and add
+# version-specific extras.
+#
+# Inside `class_eval` blocks, constants resolve from `Dcc::Base`'s lexical
+# scope, so always use fully-qualified names (e.g. `::Dcc::Namespace::Dcc`).
+module Dcc
+  module Base
+    autoload :Text, "dcc/base/text"
+    autoload :StringWithLang, "dcc/base/string_with_lang"
+    autoload :ByteData, "dcc/base/byte_data"
+    autoload :Formula, "dcc/base/formula"
+    autoload :Mathml, "dcc/base/mathml"
+    autoload :RichContent, "dcc/base/rich_content"
+    autoload :XmlBlob, "dcc/base/xml_blob"
+    autoload :Comment, "dcc/base/comment"
+    autoload :EquipmentClass, "dcc/base/equipment_class"
+    autoload :Contact, "dcc/base/contact"
+    autoload :ContactNotStrict, "dcc/base/contact_not_strict"
+    autoload :Location, "dcc/base/location"
+    autoload :HashType, "dcc/base/hash_type"
+    autoload :Identifications, "dcc/base/identifications"
+    autoload :Identification, "dcc/base/identification"
+    autoload :Software, "dcc/base/software"
+    autoload :SoftwareList, "dcc/base/software_list"
+    autoload :RefTypeDefinition, "dcc/base/ref_type_definition"
+    autoload :RefTypeDefinitionList, "dcc/base/ref_type_definition_list"
+    autoload :CoreData, "dcc/base/core_data"
+    autoload :Item, "dcc/base/item"
+    autoload :ItemList, "dcc/base/item_list"
+    autoload :CalibrationLaboratory, "dcc/base/calibration_laboratory"
+    autoload :RespPerson, "dcc/base/resp_person"
+    autoload :RespPersonList, "dcc/base/resp_person_list"
+    autoload :Statement, "dcc/base/statement"
+    autoload :StatementList, "dcc/base/statement_list"
+    autoload :MeasuringEquipment, "dcc/base/measuring_equipment"
+    autoload :MeasuringEquipmentList, "dcc/base/measuring_equipment_list"
+    autoload :UsedMethod, "dcc/base/used_method"
+    autoload :UsedMethodList, "dcc/base/used_method_list"
+    autoload :InfluenceCondition, "dcc/base/influence_condition"
+    autoload :InfluenceConditionList, "dcc/base/influence_condition_list"
+    autoload :Condition, "dcc/base/condition"
+    autoload :Result, "dcc/base/result"
+    autoload :ResultList, "dcc/base/result_list"
+    autoload :Data, "dcc/base/data"
+    autoload :Quantity, "dcc/base/quantity"
+    autoload :List, "dcc/base/list"
+    autoload :MeasurementResult, "dcc/base/measurement_result"
+    autoload :MeasurementResultList, "dcc/base/measurement_result_list"
+    autoload :MeasurementMetaData, "dcc/base/measurement_meta_data"
+    autoload :MeasurementMetaDataList, "dcc/base/measurement_meta_data_list"
+    autoload :AdministrativeData, "dcc/base/administrative_data"
+    autoload :DigitalCalibrationCertificate, "dcc/base/digital_calibration_certificate"
+  end
+end

data/lib/dcc/builder/dsl.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Dcc
+  module Builder
+    # Placeholder module — the DSL is implemented directly on `Session`.
+    # Kept for future expansion (e.g. shared mixins for V2 vs V3 DSL).
+    module Dsl
+    end
+  end
+end

data/lib/dcc/builder/session.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module Dcc
+  module Builder
+    # A builder session tracks the current container (administrative_data,
+    # items, measurement_results) and produces a fully populated
+    # Dcc::V2::DigitalCalibrationCertificate or Dcc::V3::DigitalCalibrationCertificate
+    # on `build`.
+    class Session
+      def initialize(version: 3)
+        @version = version
+        case version
+        when 2 then ::Dcc::V2.load_all!
+        when 3 then ::Dcc::V3.load_all!
+        else
+          raise ::Dcc::UnknownVersionError,
+                "Unsupported DCC version: #{version.inspect}"
+        end
+        @administrative_in_progress = new_administrative_data
+        @results_in_progress = []
+        @items_in_progress = []
+      end
+
+      attr_reader :version
+
+      # Top-level DSL methods. Each opens a nested container that captures
+      # subsequent setter calls via instance_eval.
+      def administrative_data(**attrs, &block)
+        apply_attrs(@administrative_in_progress, attrs)
+        instance_eval(&block) if block_given?
+        @administrative_in_progress
+      end
+
+      def core_data(**attrs, &block)
+        cd = new_core_data
+        apply_attrs(cd, attrs)
+        @administrative_in_progress.core_data = cd
+        instance_eval(&block) if block_given?
+        cd
+      end
+
+      def items(**attrs, &block)
+        items_obj = new_items
+        apply_attrs(items_obj, attrs)
+        @administrative_in_progress.items = items_obj
+        instance_eval(&block) if block_given?
+        items_obj
+      end
+
+      def item(**attrs, &block)
+        it = new_item
+        apply_attrs(it, attrs)
+        instance_eval(&block) if block_given?
+        (@items_in_progress ||= []) << it
+        # Wire into the open items container if present.
+        if @administrative_in_progress&.items
+          current = @administrative_in_progress.items.item
+          @administrative_in_progress.items.item = Array(current) + [it]
+        end
+        it
+      end
+
+      def measurement_results(**_attrs, &block)
+        instance_eval(&block) if block_given?
+      end
+
+      def measurement_result(**attrs, &block)
+        mr = new_measurement_result
+        apply_attrs(mr, attrs)
+        instance_eval(&block) if block_given?
+        @results_in_progress << mr
+        mr
+      end
+
+      # CoreData convenience setters
+      def unique_identifier(value)
+        ensure_core_data.unique_identifier = value
+      end
+
+      def country_code(value)
+        ensure_core_data.country_code_iso_3166_1 = value
+      end
+
+      def used_lang(value)
+        cd = ensure_core_data
+        cd.used_lang_code_iso_639_1 = Array(cd.used_lang_code_iso_639_1) + [value]
+      end
+
+      def mandatory_lang(value)
+        cd = ensure_core_data
+        cd.mandatory_lang_code_iso_639_1 = Array(cd.mandatory_lang_code_iso_639_1) + [value]
+      end
+
+      def begin_performance_date(value)
+        ensure_core_data.begin_performance_date = value
+      end
+
+      def end_performance_date(value)
+        ensure_core_data.end_performance_date = value
+      end
+
+      # @return [Dcc::V2::DigitalCalibrationCertificate, Dcc::V3::DigitalCalibrationCertificate]
+      def build
+        validate_required_sections!
+        dcc = new_digital_calibration_certificate
+        dcc.schema_version = @version == 2 ? "2.3.0" : "3.3.0"
+        dcc.administrative_data = @administrative_in_progress
+        dcc.measurement_results = new_measurement_results
+        dcc.measurement_results.measurement_result = @results_in_progress
+        dcc
+      end
+
+      private
+
+      def ensure_core_data
+        @administrative_in_progress.core_data ||= new_core_data
+      end
+
+      def validate_required_sections!
+        unless @administrative_in_progress&.core_data
+          raise ::Dcc::BuilderError,
+                "administrative_data.core_data is required"
+        end
+        return if @administrative_in_progress.items
+
+        raise ::Dcc::BuilderError,
+              "administrative_data.items is required"
+      end
+
+      def apply_attrs(target, attrs)
+        attrs.each do |k, v|
+          setter = :"#{k}="
+          target.public_send(setter, v) if Dcc::TypeGuards.has_attribute?(target, setter)
+        end
+      end
+
+      def version_module
+        @version == 2 ? ::Dcc::V2 : ::Dcc::V3
+      end
+
+      def new_digital_calibration_certificate
+        version_module::DigitalCalibrationCertificate.new
+      end
+
+      def new_administrative_data
+        version_module::AdministrativeData.new
+      end
+
+      def new_core_data
+        version_module::CoreData.new
+      end
+
+      def new_items
+        version_module::ItemList.new
+      end
+
+      def new_item
+        version_module::Item.new
+      end
+
+      def new_measurement_results
+        version_module::MeasurementResultList.new
+      end
+
+      def new_measurement_result
+        version_module::MeasurementResult.new
+      end
+    end
+  end
+end

data/lib/dcc/builder.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# `Dcc::Builder` provides a programmatic DSL for constructing DCC documents.
+#
+# @example
+#   dcc = Dcc.build(version: 3) do
+#     administrative_data do
+#       core_data do
+#         unique_identifier "urn:uuid:abc-123"
+#         country_code "DE"
+#         used_lang "en"
+#         mandatory_lang "en"
+#       end
+#     end
+#     measurement_results { }
+#   end
+module Dcc
+  module Builder
+    autoload :Session, "dcc/builder/session"
+    autoload :Dsl, "dcc/builder/dsl"
+
+    class << self
+      # @param version [Integer, nil] major DCC version (default: 3).
+      # @yield [Dcc::Builder::Session] builder session.
+      # @return [Dcc::V2::DigitalCalibrationCertificate, Dcc::V3::DigitalCalibrationCertificate]
+      def call(version: 3, &block)
+        ::Dcc.load_all!
+        session = Session.new(version: version)
+        session.instance_eval(&block) if block_given?
+        session.build
+      end
+    end
+  end
+end

data/lib/dcc/cli/cli.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "thor"
+require "tty-table"
+
+# `Dcc::Cli::Cli` is the Thor-based command-line interface. Each subcommand
+# (validate, convert, extract, signature, transform, inspect, diff, issue)
+# corresponds to a feature service exposed by the gem.
+module Dcc
+  module Cli
+    autoload :Formatters, "dcc/cli/formatters"
+
+    class Cli < Thor
+      package_name "dcc"
+
+      class << self
+        # Lazy-load the model contexts the first time a CLI command runs.
+        # This avoids autoload side effects when users just want the gem
+        # library (no CLI).
+        def ensure_loaded!
+          ::Dcc::V3.load_all!
+          ::Dcc::V2.load_all!
+        end
+      end
+
+      def self.exit_on_failure?
+        true
+      end
+
+      desc "validate SCHEMA FILE", "Validate a DCC XML against XSD, Schematron, or both"
+      long_desc <<~DESC
+        Validates the given DCC XML file.
+
+        Examples:
+          $ dcc validate xsd cert.xml
+          $ dcc validate schematron cert.xml
+          $ dcc validate all cert.xml
+      DESC
+      method_option :version, type: :string, default: "auto",
+                    desc: "Schema version (e.g. '3.3.0', 'auto')"
+      method_option :format, type: :string, default: "text",
+                    enum: %w[text json yaml]
+      def validate(schema, file)
+        Cli.ensure_loaded!
+        xml = File.read(file)
+        version = options[:version]
+        result =
+          case schema
+          when "xsd"        then ::Dcc::Validate::Xsd.call(xml, version: version)
+          when "schematron" then ::Dcc::Validate::Schematron.call(Dcc.parse(xml))
+          when "all"
+            ::Dcc::Validate::Xsd.call(xml, version: version)
+                   .merge(::Dcc::Validate::Schematron.call(Dcc.parse(xml)))
+          else
+            abort "Unknown validation target: #{schema} (expected xsd|schematron|all)"
+          end
+        ::Dcc::Cli::Formatters.print(result, format: options[:format])
+        exit(1) unless result.ok?
+      end
+
+      desc "convert FORMAT FILE", "Convert a DCC XML file to json / yaml / csv / html"
+      method_option :output, type: :string, banner: "PATH",
+                    desc: "Write output to a file instead of stdout"
+      def convert(format, file)
+        Cli.ensure_loaded!
+        xml = File.read(file)
+        dcc = Dcc.parse(xml)
+        result =
+          case format
+          when "json" then ::Dcc::Convert::Json.call(dcc)
+          when "yaml" then ::Dcc::Convert::Yaml.call(dcc)
+          else
+            abort "Format not yet implemented: #{format}"
+          end
+        output = result.to_s
+        if options[:output]
+          File.write(options[:output], output)
+        else
+          $stdout.puts(output)
+        end
+      end
+
+      desc "extract TARGET FILE", "Extract embedded files or quantities from a DCC"
+      method_option :index, type: :numeric, desc: "Index of the file to extract"
+      method_option :output, type: :string, banner: "PATH",
+                    desc: "Write extracted payload to PATH"
+      method_option :ring, type: :string,
+                    enum: %w[administrativeData measurementResults comment document]
+      def extract(target, file)
+        Cli.ensure_loaded!
+        dcc = Dcc.parse(File.read(file))
+        case target
+        when "files"
+          files = ::Dcc::Extract::File.each(dcc)
+          files = files.select { |f| f.ring.to_s == options[:ring] } if options[:ring]
+          if options[:index]
+            f = files[options[:index].to_i] || abort("No file at index #{options[:index]}")
+            output_to(f.data, options[:output], f.file_name)
+          else
+            ::Dcc::Cli::Formatters.print_files(files)
+          end
+        else
+          abort "Unknown extract target: #{target}"
+        end
+      end
+
+      desc "inspect FILE", "Show a human-readable summary of a DCC"
+      method_option :format, type: :string, default: "text",
+                    enum: %w[text json yaml]
+      def inspect(file)
+        Cli.ensure_loaded!
+        dcc = Dcc.parse(File.read(file))
+        report = ::Dcc::Inspect::Report.call(dcc)
+        ::Dcc::Cli::Formatters.print(report, format: options[:format])
+      end
+
+      desc "diff FILE1 FILE2", "Compare two DCC files structurally"
+      method_option :format, type: :string, default: "text",
+                    enum: %w[text json]
+      def diff(file1, file2)
+        Cli.ensure_loaded!
+        dcc1 = Dcc.parse(File.read(file1))
+        dcc2 = Dcc.parse(File.read(file2))
+        diff = ::Dcc::Diff.call(dcc1, dcc2)
+        ::Dcc::Cli::Formatters.print(diff, format: options[:format])
+      end
+
+      desc "version", "Print the dcc gem version"
+      def version
+        puts "dcc #{::Dcc::VERSION}"
+      end
+
+      no_commands do
+        def output_to(payload, path, file_name)
+          if path
+            File.binwrite(path, payload)
+            say "Wrote #{payload.bytesize} bytes to #{path}"
+          elsif file_name
+            File.binwrite(file_name, payload)
+            say "Wrote #{payload.bytesize} bytes to #{file_name}"
+          else
+            $stdout.binmode
+            $stdout.write(payload)
+          end
+        end
+      end
+    end
+  end
+end