chemicalml 0.2.0 → 0.3.0

data/lib/chemicalml/convention/unit_dictionary/constraints/unit_list_must_have_namespace.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module UnitDictionary
+      module Constraints
+        # A `<unitList>` element MUST have a `namespace` attribute
+        # whose value is a valid URI defining the scope within which
+        # the unit ids are unique. SHOULD end with `/` or `#`.
+        class UnitListMustHaveNamespace < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A `<unitList>` element MUST have a `namespace` attribute whose value is a valid URI defining the scope within which the unit ids are unique. SHOULD end with `/` or `#`.'
+          applies_to Chemicalml::Cml::Role::UnitList
+          def check_node(node, path)
+            violations = []
+            ns = node.namespace.to_s
+            if ns.empty?
+              violations << violation(path: path.join('/'),
+                                      message: 'unitList must have a namespace attribute')
+            elsif !ns.end_with?('/', '#')
+              violations << violation(path: path.join('/'),
+                                      message: "unitList namespace #{ns.inspect} should end with / or #",
+                                      severity: :warning)
+            end
+            violations
+          end
+
+          private
+
+          def unit_list?(node)
+            node.is_a?(Chemicalml::Cml::Role::UnitList)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/unit_dictionary/constraints/unit_must_contain_definition.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module UnitDictionary
+      module Constraints
+        # A `<unit>` element MUST contain a single `<definition>`
+        # child element with XHTML content.
+        class UnitMustContainDefinition < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A `<unit>` element MUST contain a single `<definition>` child element with XHTML content.'
+          applies_to Chemicalml::Cml::Role::Unit
+          def check_node(node, path)
+            return [] unless node.definition.to_s.strip.empty?
+
+            [violation(path: path.join('/'),
+                       message: "unit #{node.id.inspect} must contain a single definition child")]
+          end
+
+          private
+
+          def unit?(node)
+            node.is_a?(Chemicalml::Cml::Role::Unit)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/unit_dictionary/constraints/unit_must_have_id.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module UnitDictionary
+      module Constraints
+        # A `<unit>` element MUST have an `id` attribute, unique
+        # within the unitList.
+        class UnitMustHaveId < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A `<unit>` element MUST have an `id` attribute, unique within the unitList.'
+          applies_to Chemicalml::Cml::Role::Unit
+          def check_node(node, path)
+            return [] unless node.id.to_s.empty?
+
+            [violation(path: path.join('/'),
+                       message: 'unit must have an id attribute unique within the unitList')]
+          end
+
+          private
+
+          def unit?(node)
+            node.is_a?(Chemicalml::Cml::Role::Unit)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/unit_dictionary/constraints/unit_must_have_multiplier_or_constant_to_si.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module UnitDictionary
+      module Constraints
+        # A `<unit>` element MUST have at least one of `multiplierToSI`
+        # or `constantToSI` — to define the conversion to the parent
+        # SI unit. Per the unit-dictionary convention spec.
+        class UnitMustHaveMultiplierOrConstantToSi < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A `<unit>` element MUST have at least one of `multiplierToSI` or `constantToSI` — to define the conversion to the parent SI unit. Per the unit-dictionary convention spec.'
+          applies_to Chemicalml::Cml::Role::Unit
+
+          def check_node(node, _path)
+            has_multiplier = !node.multiplier_to_si.to_s.strip.empty?
+            has_constant = !node.constant_to_si.to_s.strip.empty?
+            return [] if has_multiplier || has_constant
+
+            [violation(path: yield_path(node),
+                       message: "unit #{node.id.inspect} must have at least one of " \
+                                'multiplierToSI or constantToSI to convert to parent SI')]
+          end
+
+          private
+
+          def yield_path(node)
+            id = node.node_id
+            id ? "unit[#{id}]" : 'unit'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/unit_dictionary/constraints/unit_must_have_parent_si.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module UnitDictionary
+      module Constraints
+        # A `<unit>` element MUST have a `parentSI` attribute — a
+        # QName referencing the SI unit it derives from. Per the
+        # unit-dictionary convention spec.
+        class UnitMustHaveParentSi < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A `<unit>` element MUST have a `parentSI` attribute — a QName referencing the SI unit it derives from. Per the unit-dictionary convention spec.'
+          applies_to Chemicalml::Cml::Role::Unit
+
+          def check_node(node, _path)
+            return [] unless node.parent_si.to_s.strip.empty?
+
+            [violation(path: yield_path(node),
+                       message: "unit #{node.id.inspect} must have a parentSI attribute " \
+                                '(QName referencing the parent SI unit)')]
+          end
+
+          private
+
+          def yield_path(node)
+            id = node.node_id
+            id ? "unit[#{id}]" : 'unit'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/unit_dictionary/constraints/unit_must_have_symbol_and_unit_type.rb

@@ -8,22 +8,22 @@ module Chemicalml
         # at least one of `multiplierToSI`/`constantToSI`, and
         # `unitType` per the unit-dictionary convention.
         class UnitMustHaveSymbolAndUnitType < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'Every unit MUST have `id`, `title`, `symbol`, `parentSI`, at least one of `multiplierToSI`/`constantToSI`, and `unitType` per the unit-dictionary convention.'
+          applies_to Chemicalml::Cml::Role::Unit
           REQUIRED = %i[title symbol parent_si unit_type].freeze
 
           def check_node(node, path)
-            return [] unless unit?(node)
-
             violations = []
             REQUIRED.each do |attr|
               val = node.public_send(attr)
               next unless val.to_s.empty?
 
-              violations << violation(path: path.join("/"),
+              violations << violation(path: path.join('/'),
                                       message: "unit must have #{attr} (id=#{node.id.inspect})")
             end
 
             unless has_si_conversion?(node)
-              violations << violation(path: path.join("/"),
+              violations << violation(path: path.join('/'),
                                       message: "unit must have multiplierToSI or constantToSI (id=#{node.id.inspect})")
             end
 

data/lib/chemicalml/convention/unit_dictionary/constraints/unit_must_have_title.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module UnitDictionary
+      module Constraints
+        # A `<unit>` element MUST have a `title` attribute (the full
+        # human-readable name of the unit). Per the unit-dictionary
+        # convention spec.
+        class UnitMustHaveTitle < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A `<unit>` element MUST have a `title` attribute (the full human-readable name of the unit). Per the unit-dictionary convention spec.'
+          applies_to Chemicalml::Cml::Role::Unit
+
+          def check_node(node, _path)
+            return [] unless node.title.to_s.strip.empty?
+
+            [violation(path: yield_path(node),
+                       message: "unit #{node.id.inspect} must have a title attribute " \
+                                '(the full human-readable name of the unit)')]
+          end
+
+          private
+
+          def yield_path(node)
+            id = node.node_id
+            id ? "unit[#{id}]" : 'unit'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/unit_dictionary/constraints/unit_parent_si_should_resolve.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module UnitDictionary
+      module Constraints
+        # A `<unit>`'s `parentSI` attribute SHOULD reference a unit
+        # that exists in a built-in dictionary (typically the SI
+        # dictionary). Catches typos like `parentSI="si:metr"`.
+        #
+        # Cross-component check parallel to UnitUnitTypeShouldResolve
+        # and the molecular convention's DictRefShouldResolve.
+        class UnitParentSiShouldResolve < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = "A `<unit>`'s `parentSI` attribute SHOULD reference a unit that exists in a built-in dictionary (typically the SI dictionary). Catches typos like `parentSI=\"si:metr\"`."
+          applies_to Chemicalml::Cml::Role::Unit
+
+          def check_node(node, _path)
+            parent_si = node.parent_si.to_s.strip
+            return [] if parent_si.empty?
+            return [] if resolves?(parent_si)
+
+            [violation(path: yield_path(node),
+                       message: "unit #{node.id.inspect} parentSI #{parent_si.inspect} does not " \
+                                'resolve against any built-in unit dictionary',
+                       severity: :warning,
+                       value: parent_si)]
+          end
+
+          private
+
+          def resolves?(parent_si)
+            !Chemicalml::Dictionary::Registry.lookup(parent_si).nil?
+          rescue StandardError
+            false
+          end
+
+          def yield_path(node)
+            id = node.node_id
+            id ? "unit[#{id}]" : 'unit'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/unit_dictionary/constraints/unit_unit_type_should_resolve.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module UnitDictionary
+      module Constraints
+        # A `<unit>`'s `unitType` attribute SHOULD reference a unitType
+        # that exists in a built-in unitType-dictionary. Catches typos
+        # like `unitType="unitType:lenght"` (misspelled).
+        #
+        # The lookup uses the dictionary registry, which inspects every
+        # built-in dictionary. Cross-component check parallel to
+        # DictRefShouldResolve in the molecular convention.
+        class UnitUnitTypeShouldResolve < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = "A `<unit>`'s `unitType` attribute SHOULD reference a unitType that exists in a built-in unitType-dictionary. Catches typos like `unitType=\"unitType:lenght\"` (misspelled)."
+          applies_to Chemicalml::Cml::Role::Unit
+
+          def check_node(node, _path)
+            unit_type = node.unit_type.to_s.strip
+            return [] if unit_type.empty?
+            return [] if resolves?(unit_type)
+
+            [violation(path: yield_path(node),
+                       message: "unit #{node.id.inspect} unitType #{unit_type.inspect} does not " \
+                                'resolve against any built-in unitType-dictionary',
+                       severity: :warning,
+                       value: unit_type)]
+          end
+
+          private
+
+          def resolves?(unit_type)
+            !Chemicalml::Dictionary::Registry.lookup(unit_type).nil?
+          rescue StandardError
+            false
+          end
+
+          def yield_path(node)
+            id = node.node_id
+            id ? "unit[#{id}]" : 'unit'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/unit_dictionary/constraints.rb

@@ -5,7 +5,25 @@ module Chemicalml
     module UnitDictionary
       module Constraints
         autoload :UnitMustHaveSymbolAndUnitType,
-                 "chemicalml/convention/unit_dictionary/constraints/unit_must_have_symbol_and_unit_type"
+                 'chemicalml/convention/unit_dictionary/constraints/unit_must_have_symbol_and_unit_type'
+        autoload :UnitMustHaveId,
+                 'chemicalml/convention/unit_dictionary/constraints/unit_must_have_id'
+        autoload :UnitMustContainDefinition,
+                 'chemicalml/convention/unit_dictionary/constraints/unit_must_contain_definition'
+        autoload :UnitListMustHaveNamespace,
+                 'chemicalml/convention/unit_dictionary/constraints/unit_list_must_have_namespace'
+        autoload :UnitListMustContainAtLeastOneUnit,
+                 'chemicalml/convention/unit_dictionary/constraints/unit_list_must_contain_at_least_one_unit'
+        autoload :UnitMustHaveTitle,
+                 'chemicalml/convention/unit_dictionary/constraints/unit_must_have_title'
+        autoload :UnitMustHaveParentSi,
+                 'chemicalml/convention/unit_dictionary/constraints/unit_must_have_parent_si'
+        autoload :UnitMustHaveMultiplierOrConstantToSi,
+                 'chemicalml/convention/unit_dictionary/constraints/unit_must_have_multiplier_or_constant_to_si'
+        autoload :UnitUnitTypeShouldResolve,
+                 'chemicalml/convention/unit_dictionary/constraints/unit_unit_type_should_resolve'
+        autoload :UnitParentSiShouldResolve,
+                 'chemicalml/convention/unit_dictionary/constraints/unit_parent_si_should_resolve'
       end
     end
   end

data/lib/chemicalml/convention/unit_dictionary.rb

@@ -8,9 +8,9 @@ module Chemicalml
     module UnitDictionary
       extend Base
 
-      autoload :Constraints, "chemicalml/convention/unit_dictionary/constraints"
+      autoload :Constraints, 'chemicalml/convention/unit_dictionary/constraints'
 
-      QNAME = "convention:unit-dictionary".freeze
+      QNAME = 'convention:unit-dictionary'
       NAMESPACE_URI = "#{Chemicalml::Convention::CONVENTION_NAMESPACE}unit-dictionary".freeze
 
       def self.qname
@@ -22,6 +22,15 @@ module Chemicalml
       end
 
       register Constraints::UnitMustHaveSymbolAndUnitType
+      register Constraints::UnitMustHaveId
+      register Constraints::UnitMustContainDefinition
+      register Constraints::UnitListMustHaveNamespace
+      register Constraints::UnitListMustContainAtLeastOneUnit
+      register Constraints::UnitMustHaveTitle
+      register Constraints::UnitMustHaveParentSi
+      register Constraints::UnitMustHaveMultiplierOrConstantToSi
+      register Constraints::UnitUnitTypeShouldResolve
+      register Constraints::UnitParentSiShouldResolve
     end
   end
 end

data/lib/chemicalml/convention/unit_type_dictionary/constraints/unit_type_id_must_match_pattern.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module UnitTypeDictionary
+      module Constraints
+        # A `<unitType>` `id` MUST match `[A-Za-z][A-Za-z0-9._-]*`.
+        class UnitTypeIdMustMatchPattern < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A `<unitType>` `id` MUST match `[A-Za-z][A-Za-z0-9._-]*`.'
+          applies_to Chemicalml::Cml::Role::UnitType
+          PATTERN = /\A[A-Za-z][A-Za-z0-9._-]*\z/
+
+          def check_node(node, path)
+            id = node.id.to_s
+            return [] if id.empty?
+            return [] if id.match?(PATTERN)
+
+            [violation(path: path.join('/'),
+                       message: "unitType id #{id.inspect} must match [A-Za-z][A-Za-z0-9._-]*")]
+          end
+
+          private
+
+          def unit_type?(node)
+            node.is_a?(Chemicalml::Cml::Role::UnitType)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/unit_type_dictionary/constraints/unit_type_list_must_contain_at_least_one_unit_type.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module UnitTypeDictionary
+      module Constraints
+        # A `<unitTypeList>` MUST contain one or more `<unitType>`
+        # children.
+        class UnitTypeListMustContainAtLeastOneUnitType < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A `<unitTypeList>` MUST contain one or more `<unitType>` children.'
+          applies_to Chemicalml::Cml::Role::UnitTypeList
+          def check_node(node, path)
+            return [] if (node.unit_types || []).length.positive?
+
+            [violation(path: path.join('/'),
+                       message: 'unitTypeList must contain at least one unitType child')]
+          end
+
+          private
+
+          def unit_type_list?(node)
+            node.is_a?(Chemicalml::Cml::Role::UnitTypeList)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/unit_type_dictionary/constraints/unit_type_list_must_have_namespace.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module UnitTypeDictionary
+      module Constraints
+        # A `<unitTypeList>` MUST have a `namespace` attribute (valid
+        # URI, SHOULD end with `/` or `#`).
+        class UnitTypeListMustHaveNamespace < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A `<unitTypeList>` MUST have a `namespace` attribute (valid URI, SHOULD end with `/` or `#`).'
+          applies_to Chemicalml::Cml::Role::UnitTypeList
+          def check_node(node, path)
+            violations = []
+            ns = node.namespace.to_s
+            if ns.empty?
+              violations << violation(path: path.join('/'),
+                                      message: 'unitTypeList must have a namespace attribute')
+            elsif !ns.end_with?('/', '#')
+              violations << violation(path: path.join('/'),
+                                      message: "unitTypeList namespace #{ns.inspect} should end with / or #",
+                                      severity: :warning)
+            end
+            violations
+          end
+
+          private
+
+          def unit_type_list?(node)
+            node.is_a?(Chemicalml::Cml::Role::UnitTypeList)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/unit_type_dictionary/constraints/unit_type_must_contain_definition.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module UnitTypeDictionary
+      module Constraints
+        # A `<unitType>` MUST contain a single `<definition>` child
+        # with XHTML content.
+        class UnitTypeMustContainDefinition < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A `<unitType>` MUST contain a single `<definition>` child with XHTML content.'
+          applies_to Chemicalml::Cml::Role::UnitType
+          def check_node(node, path)
+            return [] unless node.definition.to_s.strip.empty?
+
+            [violation(path: path.join('/'),
+                       message: "unitType #{node.id.inspect} must contain a single definition child")]
+          end
+
+          private
+
+          def unit_type?(node)
+            node.is_a?(Chemicalml::Cml::Role::UnitType)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/unit_type_dictionary/constraints/unit_type_must_have_id_and_name.rb

@@ -7,17 +7,17 @@ module Chemicalml
         # Every unitType MUST have an `id` and a `name` attribute per
         # the unitType-dictionary convention.
         class UnitTypeMustHaveIdAndName < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'Every unitType MUST have an `id` and a `name` attribute per the unitType-dictionary convention.'
+          applies_to Chemicalml::Cml::Role::UnitType
           def check_node(node, path)
-            return [] unless unit_type?(node)
-
             violations = []
             if node.id.to_s.empty?
-              violations << violation(path: path.join("/"),
-                                      message: "unitType must have an id")
+              violations << violation(path: path.join('/'),
+                                      message: 'unitType must have an id')
             end
             if node.name.to_s.empty?
-              violations << violation(path: path.join("/"),
-                                      message: "unitType must have a name")
+              violations << violation(path: path.join('/'),
+                                      message: 'unitType must have a name')
             end
             violations
           end

data/lib/chemicalml/convention/unit_type_dictionary/constraints.rb

@@ -5,7 +5,15 @@ module Chemicalml
     module UnitTypeDictionary
       module Constraints
         autoload :UnitTypeMustHaveIdAndName,
-                 "chemicalml/convention/unit_type_dictionary/constraints/unit_type_must_have_id_and_name"
+                 'chemicalml/convention/unit_type_dictionary/constraints/unit_type_must_have_id_and_name'
+        autoload :UnitTypeIdMustMatchPattern,
+                 'chemicalml/convention/unit_type_dictionary/constraints/unit_type_id_must_match_pattern'
+        autoload :UnitTypeMustContainDefinition,
+                 'chemicalml/convention/unit_type_dictionary/constraints/unit_type_must_contain_definition'
+        autoload :UnitTypeListMustHaveNamespace,
+                 'chemicalml/convention/unit_type_dictionary/constraints/unit_type_list_must_have_namespace'
+        autoload :UnitTypeListMustContainAtLeastOneUnitType,
+                 'chemicalml/convention/unit_type_dictionary/constraints/unit_type_list_must_contain_at_least_one_unit_type'
       end
     end
   end

data/lib/chemicalml/convention/unit_type_dictionary.rb

@@ -8,9 +8,9 @@ module Chemicalml
     module UnitTypeDictionary
       extend Base
 
-      autoload :Constraints, "chemicalml/convention/unit_type_dictionary/constraints"
+      autoload :Constraints, 'chemicalml/convention/unit_type_dictionary/constraints'
 
-      QNAME = "convention:unitType-dictionary".freeze
+      QNAME = 'convention:unitType-dictionary'
       NAMESPACE_URI = "#{Chemicalml::Convention::CONVENTION_NAMESPACE}unitType-dictionary".freeze
 
       def self.qname
@@ -22,6 +22,10 @@ module Chemicalml
       end
 
       register Constraints::UnitTypeMustHaveIdAndName
+      register Constraints::UnitTypeIdMustMatchPattern
+      register Constraints::UnitTypeMustContainDefinition
+      register Constraints::UnitTypeListMustHaveNamespace
+      register Constraints::UnitTypeListMustContainAtLeastOneUnitType
     end
   end
 end

data/lib/chemicalml/convention/validation_report.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    # Value object wrapping the violations returned by `validate`.
+    # Gives callers severity-based views without losing the raw array
+    # (still exposed as `#violations`).
+    #
+    # Constructed by `Convention.validate_report` (new API) —
+    # `Convention.validate` keeps its array return shape so existing
+    # callers don't break.
+    class ValidationReport
+      attr_reader :violations
+
+      def initialize(violations)
+        @violations = violations.to_a.freeze
+      end
+
+      def errors
+        @errors ||= violations.select(&:error?).freeze
+      end
+
+      def warnings
+        @warnings ||= violations.select(&:warning?).freeze
+      end
+
+      def ok?
+        errors.empty?
+      end
+
+      def has_warnings?
+        warnings.any?
+      end
+
+      def size
+        violations.length
+      end
+
+      def +(other)
+        return other if other.nil?
+
+        raise ArgumentError, "cannot combine ValidationReport with #{other.class}" unless other.is_a?(ValidationReport)
+
+        ValidationReport.new(violations + other.violations)
+      end
+
+      def ==(other)
+        other.is_a?(ValidationReport) && violations == other.violations
+      end
+      alias eql? ==
+
+      def hash
+        violations.hash
+      end
+
+      def to_s
+        "#{size} violation(s): #{errors.length} error(s), #{warnings.length} warning(s)"
+      end
+
+      # Human-readable multi-line summary. Suitable for CLI output
+      # and logging. Each violation is rendered with severity, path,
+      # and message (and value when present).
+      #
+      # @return [String]
+      def summary
+        return 'OK — no violations' if ok? && !has_warnings?
+
+        lines = []
+        lines << "Errors: #{errors.size}, Warnings: #{warnings.size}"
+        unless errors.empty?
+          lines << ''
+          lines << 'Errors:'
+          errors.each { |v| lines << "  ERROR #{v.path}: #{v.message}#{value_suffix(v)}" }
+        end
+        unless warnings.empty?
+          lines << ''
+          lines << 'Warnings:'
+          warnings.each { |v| lines << "  WARN  #{v.path}: #{v.message}#{value_suffix(v)}" }
+        end
+        lines.join("\n")
+      end
+
+      private
+
+      def value_suffix(violation)
+        violation.value.nil? ? '' : " (value=#{violation.value.inspect})"
+      end
+    end
+  end
+end