Move code to MOI and add JuMP layer

src/ModelAnalyzer.jl

@@ -5,6 +5,8 @@
 
 module ModelAnalyzer
 
+import MathOptInterface as MOI
+
 abstract type AbstractIssue end
 
 abstract type AbstractData end
@@ -25,7 +27,7 @@
 function analyze end
 
 """
-    summarize([io::IO,] AbstractData; verbose = true, max_issues = typemax(Int), kwargs...)
+    summarize([io::IO,] AbstractData; name_source = nothing, verbose = true, max_issues = typemax(Int), kwargs...)
 
 Print a summary of the analysis results contained in `AbstractData` to the
 specified IO stream. If no IO stream is provided, it defaults to `stdout`.
@@ -41,9 +43,11 @@
 explaning the issue. In the non-verbose case it will provide just the issue
 name.
 
-    summarize([io::IO,] issue::AbstractIssue; verbose = true)
+    summarize([io::IO,] issue::AbstractIssue; name_source = nothing, verbose = true)
 
 This variant allows summarizing a single issue instance of type `AbstractIssue`.
+The model tha led to the issue can be provided to `name_source`, it will be used
+to generate the name of variables and constraints in the issue summary.
 """
 function summarize end
 
@@ -72,17 +76,23 @@
     end
 end
 
-function summarize(io::IO, issue::AbstractIssue; verbose = true)
+function summarize(
+    io::IO,
+    issue::AbstractIssue;
+    name_source = nothing,
+    verbose = true,
+)
     if verbose
-        return _verbose_summarize(io, issue)
+        return _verbose_summarize(io, issue, name_source)
     else
-        return _summarize(io, issue)
+        return _summarize(io, issue, name_source)
     end
 end
 
 function summarize(
     io::IO,
     issues::Vector{T};
+    name_source = nothing,
     verbose = true,
     max_issues = typemax(Int),
 ) where {T<:AbstractIssue}
@@ -92,7 +102,7 @@
     print(io, "\n\n## List of issues\n\n")
     for issue in first(issues, max_issues)
         print(io, " * ")
-        summarize(io, issue, verbose = verbose)
+        summarize(io, issue, verbose = verbose, name_source = name_source)
         print(io, "\n")
     end
     return
@@ -102,11 +112,82 @@
     return summarize(stdout, data; kwargs...)
 end
 
+"""
+    value(issue::AbstractIssue)
+
+Return the value associated to a particular issue. The value is a number
+with a different meaning depending on the type of issue. For example, for
+some numerical issues, it can be the coefficient value.
+"""
+function value(issue::AbstractIssue, ::Nothing)
+    return value(issue)
+end
+function value(issue::AbstractIssue, ::MOI.ModelLike)
+    return value(issue)
+end
+
+"""
+    variable(issue::AbstractIssue)
+
+Return the variable associated to a particular issue.
+"""
+function variable(issue::AbstractIssue, ::Nothing)
+    return variable(issue)
+end
+function variable(issue::AbstractIssue, ::MOI.ModelLike)
+    return variable(issue)
+end
+
+"""
+    variables(issue::AbstractIssue)
+
+Return the variables associated to a particular issue.
+"""
+function variables(issue::AbstractIssue, ::Nothing)
+    return variables(issue)
+end
+function variables(issue::AbstractIssue, ::MOI.ModelLike)
+    return variables(issue)
+end
+
+"""
+    constraint(issue::AbstractIssue)
+
+Return the constraint associated to a particular issue.
+"""
+function constraint(issue::AbstractIssue, ::Nothing)
+    return constraint(issue)
+end
+function constraint(issue::AbstractIssue, ::MOI.ModelLike)
+    return constraint(issue)
+end
+
 function _verbose_summarize end
 function _summarize end
 
+function _name(ref::MOI.VariableIndex, model::MOI.ModelLike)
+    name = MOI.get(model, MOI.VariableName(), ref)
+    if !isempty(name)
+        return name
+    end
+    return "$ref"
+end
+
+function _name(ref::MOI.ConstraintIndex, model::MOI.ModelLike)
+    name = MOI.get(model, MOI.ConstraintName(), ref)
+    if !isempty(name)
+        return name
+    end
+    return "$ref"
+end
+
+function _name(ref, ::Nothing)
+    return "$ref"
+end
+
 include("numerical.jl")
 include("feasibility.jl")
 include("infeasibility.jl")
 
+include("jump.jl")
 end

src/jump.jl

@@ -0,0 +1,79 @@
+import JuMP
+
+# struct JuMPData{T<:AbstractData} <: ModelAnalyzer.AbstractData
+#     data::T
+#     model::JuMP.Model
+# end
+
+# struct JuMPIssue{T<:AbstractIssue} <: ModelAnalyzer.AbstractIssue
+#     issue::T
+#     model::JuMP.Model
+# end
+
+function ModelAnalyzer.analyze(
+    analyzer::T,
+    model::JuMP.Model;
+    kwargs...,
+) where {T<:ModelAnalyzer.AbstractAnalyzer}
+    moi_model = JuMP.backend(model)
+    result = ModelAnalyzer.analyze(analyzer, moi_model; kwargs...)
+    # return JuMPData(result, model)
+    return result
+end
+
+function ModelAnalyzer._name(ref::MOI.VariableIndex, model::JuMP.Model)
+    jump_ref = JuMP.VariableRef(model, ref)
+    name = JuMP.name(jump_ref)
+    if !isempty(name)
+        return name
+    end
+    return "$jump_ref"
+end
+
+function ModelAnalyzer._name(ref::MOI.ConstraintIndex, model::JuMP.Model)
+    jump_ref = JuMP.constraint_ref_with_index(model, ref)
+    name = JuMP.name(jump_ref)
+    if !isempty(name)
+        return name
+    end
+    return "$jump_ref"
+end
+
+"""
+    variable(issue::ModelAnalyzer.AbstractIssue, model::JuMP.Model)
+
+Return the **JuMP** variable reference associated to a particular issue.
+"""
+function ModelAnalyzer.variable(
+    issue::ModelAnalyzer.AbstractIssue,
+    model::JuMP.Model,
+)
+    ref = ModelAnalyzer.variable(issue)
+    return JuMP.VariableRef(model, ref)
+end
+
+"""
+    variables(issue::ModelAnalyzer.AbstractIssue, model::JuMP.Model)
+
+Return the **JuMP** variable references associated to a particular issue.
+"""
+function ModelAnalyzer.variables(
+    issue::ModelAnalyzer.AbstractIssue,
+    model::JuMP.Model,
+)
+    refs = ModelAnalyzer.variables(issue)
+    return JuMP.VariableRef.(model, refs)
+end
+
+"""
+    constraint(issue::ModelAnalyzer.AbstractIssue, model::JuMP.Model)
+
+Return the **JuMP** constraint reference associated to a particular issue.
+"""
+function ModelAnalyzer.constraint(
+    issue::ModelAnalyzer.AbstractIssue,
+    model::JuMP.Model,
+)
+    ref = ModelAnalyzer.constraint(issue)
+    return JuMP.constraint_ref_with_index(model, ref)
+end