dcc 0.2.0 → 0.2.2

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,25 +82,25 @@ module Dcc
         end
       end
 
-      desc "extract TARGET FILE", "Extract embedded files or quantities from a DCC"
+      desc "extract TARGET FILE",
+           "Extract embedded files or formulae 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]
+      # `repeatable` and not `type: :array`: with an array type Thor lets a
+      # second `-v` overwrite the first, so `-v T=42 -v R0=1` would silently
+      # drop T. PTB's CLI accumulates, and so must this.
+      method_option :variable, type: :string, aliases: "-v", repeatable: true,
+                               banner: "NAME=VALUE",
+                               desc: "Override a formula variable (repeatable; NAME=V1,V2 for a list)"
       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
+        when "files" then extract_files(dcc)
+        when "formulae" then extract_formulae(dcc)
         else
           abort "Unknown extract target: #{target}"
         end
@@ -106,7 +108,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 +118,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 +127,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}"
@@ -143,7 +156,120 @@ module Dcc
             $stdout.write(payload)
           end
         end
+
+        def extract_files(dcc)
+          files = ::Dcc::Extract::File.each(dcc)
+          if options[:ring]
+            files = files.select { |f| f.ring.to_s == options[:ring] }
+          end
+          return ::Dcc::Cli::Formatters.print_files(files) unless options[:index]
+
+          index = options[:index].to_i
+          file = files[index] || abort("No file at index #{index}")
+          output_to(file.data, options[:output], file.file_name)
+        end
+      end
+
+      no_commands do
+        def extract_formulae(dcc)
+          variables = parse_variables(options[:variable])
+          formulae = ::Dcc::Extract::Formula.call(dcc)
+          check_overrides(formulae, variables)
+          print_formulae(formulae, variables)
+        rescue ::Dcc::ExtractionError => e
+          abort e.message
+        end
+
+        # The evaluator slices bindings down to the names a formula
+        # actually references, so a mistyped -v reaches nothing and the
+        # run still reports success with plausible default numbers.
+        # `decimal_or_abort` already aborts on a malformed -v; an
+        # override that lands nowhere is the same class of mistake.
+        def check_overrides(formulae, variables)
+          unknown = variables.keys - formulae.flat_map(&:variables)
+          return if unknown.empty?
+
+          abort "No formula references #{unknown.join(', ')}"
+        end
+      end
+
+      no_commands do
+        def parse_variables(assignments)
+          Array(assignments).each_with_object({}) do |assignment, variables|
+            name, values = split_assignment(assignment)
+            variables[name] = override_value(values)
+          end
+        end
+
+        # `-v T=42` is a scalar and broadcasts across the document's lists;
+        # only `-v T=1,2` is a list, and a list has to match every other
+        # list's length. Wrapping a lone value in an array made `-v R0=1`
+        # a one-element list that collided with the document's own.
+        def override_value(values)
+          decimals = values.map { |v| decimal_or_abort(v) }
+          decimals.size == 1 ? decimals.first : decimals
+        end
+      end
+
+      no_commands do
+        # `split(",", -1)` keeps trailing empty fields, so `T=42,` reaches
+        # validation instead of silently losing the empty entry.
+        def split_assignment(assignment)
+          name, values = assignment.split("=", 2)
+          if name.nil? || name.empty? || values.nil? || values.empty?
+            abort "#{assignment} is not a valid NAME=value"
+          end
+
+          [name, values.split(",", -1)]
+        end
+
+        # Validated here, at the command line, not where the value is used.
+        # The evaluator only coerces variables the formula references, so a
+        # bad `-v` for an unreferenced variable — or any `-v` against a
+        # document with no formulae — would otherwise pass in silence.
+        #
+        # Delegates rather than calling BigDecimal itself: a second
+        # coercion site is exactly the drift the single boundary exists to
+        # prevent, even when it starts out agreeing.
+        def decimal_or_abort(value)
+          ::Dcc::Extract::Formula::Quantity.decimal(value)
+        rescue ::Dcc::ExtractionError
+          abort "#{value} is not a valid decimal value"
+        end
+      end
+
+      no_commands do
+        def print_formulae(formulae, variables)
+          return puts("No formulae found.") if formulae.empty?
+
+          # `map`, deliberately, not `all?` with a block: `all?`
+          # short-circuits, and stopping at the first failure is exactly
+          # the bug this is fixing.
+          printed = formulae.map { |formula| print_formula(formula, variables) }
+          exit(1) unless printed.all?
+        end
+      end
+
+      no_commands do
+        # Evaluates before printing the header. A header printed ahead
+        # of a failure leaves a truncated record on stdout that reads
+        # like a formula with no values. One formula that cannot be
+        # evaluated is reported on stderr and the rest still print.
+        def print_formula(formula, variables)
+          values = formula.evaluate(variables)
+          puts formula
+          values.each { |value| puts "  #{value.to_s('F')}" }
+          true
+        rescue ::Dcc::ExtractionError => e
+          # `$stderr.puts`, not `warn`: Kernel#warn prints nothing when
+          # warnings are off, so `RUBYOPT=-W0` would leave the user with
+          # exit 1 and no explanation at all. The cop's own rationale —
+          # "to allow such output to be disabled" — is the thing this
+          # message must not permit.
+          $stderr.puts "#{formula}: #{e.message}" # rubocop:disable Style/StderrPuts
+          false
+        end
       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