dcc 0.2.0 → 0.2.1

data/lib/dcc/builder/session.rb

@@ -25,32 +25,32 @@ module Dcc
 
       # Top-level DSL methods. Each opens a nested container that captures
       # subsequent setter calls via instance_eval.
-      def administrative_data(**attrs, &block)
+      def administrative_data(**attrs, &)
         apply_attrs(@administrative_in_progress, attrs)
-        instance_eval(&block) if block_given?
+        instance_eval(&) if block_given?
         @administrative_in_progress
       end
 
-      def core_data(**attrs, &block)
+      def core_data(**attrs, &)
         cd = new_core_data
         apply_attrs(cd, attrs)
         @administrative_in_progress.core_data = cd
-        instance_eval(&block) if block_given?
+        instance_eval(&) if block_given?
         cd
       end
 
-      def items(**attrs, &block)
+      def items(**attrs, &)
         items_obj = new_items
         apply_attrs(items_obj, attrs)
         @administrative_in_progress.items = items_obj
-        instance_eval(&block) if block_given?
+        instance_eval(&) if block_given?
         items_obj
       end
 
-      def item(**attrs, &block)
+      def item(**attrs, &)
         it = new_item
         apply_attrs(it, attrs)
-        instance_eval(&block) if block_given?
+        instance_eval(&) if block_given?
         (@items_in_progress ||= []) << it
         # Wire into the open items container if present.
         if @administrative_in_progress&.items
@@ -60,14 +60,14 @@ module Dcc
         it
       end
 
-      def measurement_results(**_attrs, &block)
-        instance_eval(&block) if block_given?
+      def measurement_results(**_attrs, &)
+        instance_eval(&) if block_given?
       end
 
-      def measurement_result(**attrs, &block)
+      def measurement_result(**attrs, &)
         mr = new_measurement_result
         apply_attrs(mr, attrs)
-        instance_eval(&block) if block_given?
+        instance_eval(&) if block_given?
         @results_in_progress << mr
         mr
       end
@@ -130,7 +130,9 @@ module Dcc
       def apply_attrs(target, attrs)
         attrs.each do |k, v|
           setter = :"#{k}="
-          target.public_send(setter, v) if Dcc::TypeGuards.has_attribute?(target, setter)
+          target.public_send(setter, v) if Dcc::TypeGuards.has_attribute?(
+            target, setter
+          )
         end
       end
 
@@ -167,4 +169,4 @@ module Dcc
       end
     end
   end
-end
+end

data/lib/dcc/builder.rb

@@ -23,12 +23,12 @@ module Dcc
       # @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)
+      def call(version: 3, &)
         ::Dcc.load_all!
         session = Session.new(version: version)
-        session.instance_eval(&block) if block_given?
+        session.instance_eval(&) if block_given?
         session.build
       end
     end
   end
-end
+end

data/lib/dcc/cli/cli.rb

@@ -1,7 +1,6 @@
 # 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)
@@ -27,7 +26,8 @@ module Dcc
         true
       end
 
-      desc "validate SCHEMA FILE", "Validate a DCC XML against XSD, Schematron, or both"
+      desc "validate SCHEMA FILE",
+           "Validate a DCC XML against XSD, Schematron, or both"
       long_desc <<~DESC
         Validates the given DCC XML file.
 
@@ -37,20 +37,21 @@ module Dcc
           $ dcc validate all cert.xml
       DESC
       method_option :version, type: :string, default: "auto",
-                    desc: "Schema version (e.g. '3.3.0', 'auto')"
+                              desc: "Schema version (e.g. '3.3.0', 'auto')"
       method_option :format, type: :string, default: "text",
-                    enum: %w[text json yaml]
+                             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 "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)))
+              .merge(::Dcc::Validate::Schematron.call(Dcc.parse(xml)))
           else
             abort "Unknown validation target: #{schema} (expected xsd|schematron|all)"
           end
@@ -58,17 +59,18 @@ module Dcc
         exit(1) unless result.ok?
       end
 
-      desc "convert FORMAT FILE", "Convert a DCC XML file to json / yaml / csv / html"
+      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"
+                             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)
+          when "json" then ::Dcc::Convert::Json.call(Dcc.parse(xml))
+          when "yaml" then ::Dcc::Convert::Yaml.call(Dcc.parse(xml))
+          when "html" then ::Dcc::Convert::Html.call(xml)
           else
             abort "Format not yet implemented: #{format}"
           end
@@ -80,19 +82,24 @@ module Dcc
         end
       end
 
-      desc "extract TARGET FILE", "Extract embedded files or quantities from a DCC"
+      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"
+                             desc: "Write extracted payload to PATH"
       method_option :ring, type: :string,
-                    enum: %w[administrativeData measurementResults comment document]
+                           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[:ring]
+            files = files.select do |f|
+              f.ring.to_s == options[:ring]
+            end
+          end
           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)
@@ -106,7 +113,7 @@ module Dcc
 
       desc "inspect FILE", "Show a human-readable summary of a DCC"
       method_option :format, type: :string, default: "text",
-                    enum: %w[text json yaml]
+                             enum: %w[text json yaml]
       def inspect(file)
         Cli.ensure_loaded!
         dcc = Dcc.parse(File.read(file))
@@ -116,7 +123,7 @@ module Dcc
 
       desc "diff FILE1 FILE2", "Compare two DCC files structurally"
       method_option :format, type: :string, default: "text",
-                    enum: %w[text json]
+                             enum: %w[text json]
       def diff(file1, file2)
         Cli.ensure_loaded!
         dcc1 = Dcc.parse(File.read(file1))
@@ -125,6 +132,17 @@ module Dcc
         ::Dcc::Cli::Formatters.print(diff, format: options[:format])
       end
 
+      desc "serve", "Start the DCC web validator (http://localhost:4567)"
+      method_option :port, type: :numeric, default: 4567, desc: "Port"
+      method_option :bind, type: :string, default: "0.0.0.0",
+                           desc: "Bind address"
+      def serve
+        require "dcc/server"
+        ::Dcc.load_all!
+        puts "Starting DCC Validator on http://localhost:#{options[:port]}"
+        ::Dcc::Server::App.run!(port: options[:port], bind: options[:bind])
+      end
+
       desc "version", "Print the dcc gem version"
       def version
         puts "dcc #{::Dcc::VERSION}"
@@ -146,4 +164,4 @@ module Dcc
       end
     end
   end
-end
+end

data/lib/dcc/cli/formatters.rb

@@ -1,12 +1,30 @@
 # frozen_string_literal: true
 
-require "tty-table"
-
 module Dcc
   module Cli
     # `Dcc::Cli::Formatters` picks the right text/JSON/YAML representation
     # of a result model and prints it.
     module Formatters
+      # Goes to stderr, so a piped `extract files` still yields clean data.
+      TTY_TABLE_HINT = "note: install tty-table for aligned output " \
+                       "(gem install tty-table)"
+
+      # `tty-table` is optional. It pulls in eight further gems to prettify
+      # one command, which every library user would otherwise install just
+      # to parse XML. Loaded on first use, and its absence falls back to the
+      # plain renderer rather than raising the way `Dcc::Server` does.
+      def self.table_available?
+        return @table_available unless @table_available.nil?
+
+        begin
+          require "tty-table"
+          @table_available = true
+        rescue ::LoadError
+          @table_available = false
+        end
+        @table_available
+      end
+
       module_function
 
       def print(object, format: "text")
@@ -14,7 +32,7 @@ module Dcc
         when "json" then puts object.to_json
         when "yaml" then puts object.to_yaml
         else
-          puts object.to_s
+          puts object
         end
       end
 
@@ -24,6 +42,14 @@ module Dcc
           return
         end
 
+        unless table_available?
+          # Hint first: a stderr that raises is caught by the rescue below,
+          # which re-runs the renderer. Printing first would duplicate it.
+          warn TTY_TABLE_HINT
+          print_files_plain(files)
+          return
+        end
+
         # TTY::Table calls ioctl which fails on StringIO / pipes. Fall back
         # to a plain-text rendering when stdout isn't a real terminal.
         if $stdout.is_a?(::IO) && !$stdout.tty?
@@ -34,7 +60,8 @@ module Dcc
         table = ::TTY::Table.new(
           ["Index", "Name", "File Name", "MIME", "Ring", "Size"],
           files.each_with_index.map do |f, i|
-            [i, f.name.to_s, f.file_name.to_s, f.mime_type.to_s, f.ring, f.data.bytesize]
+            [i, f.name.to_s, f.file_name.to_s, f.mime_type.to_s, f.ring,
+             f.data.bytesize]
           end,
         )
         puts table.render
@@ -45,8 +72,9 @@ module Dcc
 
       def print_files_plain(files)
         # Widths
-        widths = ["Index".size, "Name".size, "File Name".size, "MIME".size, "Ring".size, "Size".size]
-        rows = files.each_with_index.map do |f, i|
+        widths = ["Index".size, "Name".size, "File Name".size, "MIME".size,
+                  "Ring".size, "Size".size]
+        files.each_with_index.map do |f, i|
           [
             i.to_s,
             f.name.to_s,
@@ -74,4 +102,4 @@ module Dcc
       end
     end
   end
-end
+end

data/lib/dcc/cli.rb

@@ -4,4 +4,4 @@
 module Dcc
   module Cli
   end
-end
+end

data/lib/dcc/context_configuration.rb

@@ -34,7 +34,8 @@ module Dcc
     # @param registry [Lutaml::Model::TypeRegistry, nil] custom registry.
     # @param fallback_to [Array<Symbol>] fallback chain for type lookup.
     # @param substitutions [Array<Hash{from_type:, to_type:}>] type substitutions.
-    def create_context(id:, registry: nil, fallback_to: [context_id], substitutions: [])
+    def create_context(id:, registry: nil, fallback_to: [context_id],
+                       substitutions: [])
       normalized_id = ::Dcc::ContextOptions.normalize_context_reference(id)
       return populate_context! if normalized_id == context_id
 

data/lib/dcc/context_options.rb

@@ -13,7 +13,8 @@ module Dcc
     # @param register [Symbol, String, nil] deprecated alias for `context:`.
     # @param default_context [Symbol, nil] returned when neither is given.
     # @param warning_source [String] caller name for deprecation warnings.
-    def normalize_context_option(context:, register:, default_context:, warning_source:)
+    def normalize_context_option(context:, register:, default_context:,
+                                 warning_source:)
       raise_if_conflicting!(context, register)
       return normalize_context_reference(register) || default_context if register
       return default_context unless context_specified?(context)
@@ -29,7 +30,8 @@ module Dcc
       return reference.to_sym if reference.is_a?(String)
       return reference.id.to_sym if reference.is_a?(::Lutaml::Xml::Namespace)
 
-      raise ArgumentError, "Unsupported context/register reference: #{reference.inspect}"
+      raise ArgumentError,
+            "Unsupported context/register reference: #{reference.inspect}"
     end
 
     def context_specified?(context)

data/lib/dcc/convert/csv.rb

@@ -7,7 +7,8 @@ module Dcc
     # `Dcc::Convert::Csv` flattens a parsed DCC into a tabular CSV with
     # one row per measurement quantity.
     module Csv
-      HEADERS = %w[result_name quantity_name quantity_type value unit uncertainty coverage_factor].freeze
+      HEADERS = %w[result_name quantity_name quantity_type value unit
+                   uncertainty coverage_factor].freeze
 
       class << self
         # @param dcc [Lutaml::Model::Serializable]
@@ -31,7 +32,8 @@ module Dcc
 
         def collect_quantities(dcc)
           rows = []
-          return rows unless Dcc::TypeGuards.has_attribute?(dcc, :measurement_results)
+          return rows unless Dcc::TypeGuards.has_attribute?(dcc,
+                                                            :measurement_results)
 
           Array(dcc.measurement_results.measurement_result).each do |mr|
             mr_name = name_of(mr)
@@ -53,7 +55,9 @@ module Dcc
           walk_quantities(Array(data.quantity), mr_name, result_name, rows)
           Array(data.list).each do |list|
             walk_quantities(Array(list.quantity), mr_name, result_name, rows)
-            Array(list.list).each { |sub| walk_data(sub, mr_name, result_name, rows) }
+            Array(list.list).each do |sub|
+              walk_data(sub, mr_name, result_name, rows)
+            end
           end
         end
 
@@ -63,10 +67,10 @@ module Dcc
           end
         end
 
-        def push_quantity(q, mr_name, result_name, kind, rows)
+        def push_quantity(q, mr_name, _result_name, kind, rows)
           rows << [
             mr_name, name_of(q), kind,
-            value_of(q), unit_of(q), uncertainty_of(q), k_factor_of(q),
+            value_of(q), unit_of(q), uncertainty_of(q), k_factor_of(q)
           ]
         end
 
@@ -74,11 +78,21 @@ module Dcc
           return "" unless node && Dcc::TypeGuards.has_attribute?(node, :name)
           return "" unless node.name
 
-          content = Dcc::TypeGuards.has_attribute?(node.name, :content) ? node.name.content : []
+          content = if Dcc::TypeGuards.has_attribute?(node.name,
+                                                      :content)
+                      node.name.content
+                    else
+                      []
+                    end
           first = Array(content).first
           return "" unless first
 
-          vals = Dcc::TypeGuards.has_attribute?(first, :value) ? first.value : []
+          vals = if Dcc::TypeGuards.has_attribute?(first,
+                                                   :value)
+                   first.value
+                 else
+                   []
+                 end
           Array(vals).first.to_s
         end
 
@@ -87,7 +101,11 @@ module Dcc
           return reals.first.value.to_s if reals.any?
 
           lists = Array(q.real_list_xml_list)
-          return lists.first.value_xml_list.map(&:to_s).join("; ") if lists.any?
+          # Serialized rather than mapped over: BigDecimal#to_s renders 0.072
+          # as "0.72e-1", which is not what the document said.
+          if lists.any?
+            return ::Dcc::Type::DecimalXmlList.serialize(lists.first.value_xml_list)
+          end
 
           ""
         end
@@ -126,4 +144,4 @@ module Dcc
       end
     end
   end
-end
+end

data/lib/dcc/convert/html.rb

@@ -1,127 +1,43 @@
 # frozen_string_literal: true
 
+require "liquid"
+
 module Dcc
   module Convert
-    # `Dcc::Convert::Html` renders a parsed DCC into a human-readable HTML
-    # report with collapsible sections per administrative section and
-    # measurement result.
     module Html
-      class << self
-        # @param dcc [Lutaml::Model::Serializable]
-        # @return [Dcc::Convert::Result]
-        def call(dcc)
-          payload = <<~HTML
-            <!DOCTYPE html>
-            <html lang="en">
-            <head>
-              <meta charset="utf-8">
-              <title>DCC Report #{escape(unique_identifier_of(dcc))}</title>
-              <style>
-                body { font-family: -apple-system, system-ui, sans-serif; margin: 2rem; }
-                h1, h2, h3 { color: #333; }
-                section { margin-bottom: 1.5rem; padding: 1rem; border: 1px solid #eee; border-radius: 4px; }
-                table { border-collapse: collapse; }
-                th, td { border: 1px solid #ddd; padding: 0.5rem 1rem; text-align: left; }
-                th { background: #f5f5f5; }
-              </style>
-            </head>
-            <body>
-              <h1>Digital Calibration Certificate</h1>
-              #{summary_table(dcc)}
-              #{administrative_section(dcc)}
-              #{measurement_section(dcc)}
-            </body>
-            </html>
-          HTML
+      TEMPLATE_PATH = File.expand_path("templates/report.liquid",
+                                       __dir__).freeze
 
+      class << self
+        def call(dcc_or_xml, lang: nil)
+          if dcc_or_xml.is_a?(::String)
+            xml = dcc_or_xml
+            hash = ::Dcc::Convert::Json.xml_to_hash(xml)
+            schema_version = hash["schemaVersion"]
+            source_class = "xml"
+          else
+            xml = dcc_or_xml.to_xml
+            hash = ::Dcc::Convert::Json.xml_to_hash(xml)
+            schema_version = dcc_or_xml.schema_version.to_s
+            source_class = dcc_or_xml.class.name
+          end
+          rendered = render_template(hash, lang: lang)
           ::Dcc::Convert::Result.new(
             format: :html,
-            payload: payload,
-            source_class: dcc.class.name,
-            schema_version: dcc.schema_version.to_s,
+            payload: rendered,
+            source_class: source_class,
+            schema_version: schema_version,
           )
         end
 
         private
 
-        def summary_table(dcc)
-          <<~HTML
-            <section>
-              <h2>Identity</h2>
-              <table>
-                <tr><th>Schema version</th><td>#{escape(dcc.schema_version)}</td></tr>
-                <tr><th>Unique identifier</th><td>#{escape(unique_identifier_of(dcc))}</td></tr>
-                <tr><th>Country</th><td>#{escape(country_of(dcc))}</td></tr>
-              </table>
-            </section>
-          HTML
-        end
-
-        def administrative_section(dcc)
-          return "" unless Dcc::TypeGuards.has_attribute?(dcc, :administrative_data) && dcc.administrative_data
-
-          admin = dcc.administrative_data
-          items = Dcc::TypeGuards.has_attribute?(admin, :items) && admin.items ? Array(admin.items.item) : []
-          <<~HTML
-            <section>
-              <h2>Items (#{items.size})</h2>
-              <ul>
-                #{items.map { |i| "<li>#{escape(name_of(i))}</li>" }.join("\n")}
-              </ul>
-            </section>
-          HTML
-        end
-
-        def measurement_section(dcc)
-          return "" unless Dcc::TypeGuards.has_attribute?(dcc, :measurement_results) && dcc.measurement_results
-
-          mrs = Array(dcc.measurement_results.measurement_result)
-          <<~HTML
-            <section>
-              <h2>Measurement Results (#{mrs.size})</h2>
-              <ul>
-                #{mrs.map { |mr| "<li>#{escape(name_of(mr))}</li>" }.join("\n")}
-              </ul>
-            </section>
-          HTML
-        end
-
-        def unique_identifier_of(dcc)
-          Dcc::TypeGuards.has_attribute?(dcc, :administrative_data) &&
-            Dcc::TypeGuards.has_attribute?(dcc.administrative_data, :core_data) &&
-            dcc.administrative_data.core_data &&
-            dcc.administrative_data.core_data.unique_identifier.to_s
-        end
-
-        def country_of(dcc)
-          Dcc::TypeGuards.has_attribute?(dcc, :administrative_data) &&
-            Dcc::TypeGuards.has_attribute?(dcc.administrative_data, :core_data) &&
-            dcc.administrative_data.core_data &&
-            dcc.administrative_data.core_data.country_code_iso_3166_1.to_s
-        end
-
-        def name_of(node)
-          return "" unless node && Dcc::TypeGuards.has_attribute?(node, :name)
-          return "" unless node.name
-
-          content = Dcc::TypeGuards.has_attribute?(node.name, :content) ? node.name.content : []
-          first = Array(content).first
-          return "" unless first
-
-          vals = Dcc::TypeGuards.has_attribute?(first, :value) ? first.value : []
-          Array(vals).first.to_s
-        end
-
-        def escape(s)
-          return "" if s.nil?
-
-          s.to_s
-            .gsub("&", "&amp;")
-            .gsub("<", "&lt;")
-            .gsub(">", "&gt;")
-            .gsub('"', "&quot;")
+        def render_template(hash, lang:)
+          template = ::Liquid::Template.parse(File.read(TEMPLATE_PATH))
+          template.render({ "dcc" => hash, "page_lang" => lang },
+                          filters: [::Dcc::Convert::LiquidFilters])
         end
       end
     end
   end
-end
+end

data/lib/dcc/convert/json.rb

@@ -45,18 +45,21 @@ module Dcc
             return hash
           end
 
+          grouped = {}
           children.each do |child|
             name = child.name.to_s.split(":").last
-            value = element_to_hash(child)
-            if hash.key?(name)
-              hash[name] = Array(hash[name]) << value
-            else
-              hash[name] = value
-            end
+            grouped[name] ||= []
+            grouped[name] << child
           end
+
+          grouped.each do |name, child_list|
+            values = child_list.map { |c| element_to_hash(c) }
+            hash[name] = values.size == 1 ? values.first : values
+          end
+          hash["_text"] = combined_text unless combined_text.empty?
           hash
         end
       end
     end
   end
-end
+end

data/lib/dcc/convert/liquid_filters.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Dcc
+  module Convert
+    module LiquidFilters
+      def dcc_text(content, lang = nil)
+        return "" if content.nil? || content == ""
+
+        case content
+        when ::String
+          content
+        when ::Hash
+          content["_text"] || content[:_text] || content.to_s
+        when ::Array
+          if lang
+            entry = content.find do |c|
+              c.is_a?(::Hash) && (c["lang"] == lang || c[:lang] == lang)
+            end
+            return dcc_text(entry, lang) if entry
+          end
+          first = content.find { |c| c.is_a?(::Hash) }
+          first ? (first["_text"] || first[:_text] || "") : ""
+        else
+          content.to_s
+        end
+      end
+
+      def dcc_initials(name)
+        return "?" if name.nil? || name.empty?
+
+        parts = name.split
+        return parts.first[0..0].upcase if parts.size == 1
+
+        (parts.first[0] + parts.last[0]).upcase
+      end
+
+      def dcc_count(obj)
+        return 0 if obj.nil?
+
+        case obj
+        when ::Array then obj.size
+        when ::Hash then 1
+        else 1
+        end
+      end
+
+      def dcc_items(obj)
+        return [] if obj.nil?
+
+        case obj
+        when ::Array then obj
+        when ::Hash then [obj]
+        else [obj]
+        end
+      end
+    end
+  end
+end