cbc-wrapper 2.9.9.3 → 2.9.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8f75c7d0096c67f7831288ba4d3980472064b6522a10bdd573b234399160963
-  data.tar.gz: 43eaa1c4a90af199583b684b8c31518fe5a194f4f8407a93e5564d16baf4ef8f
+  metadata.gz: bca684c17d92a3b6d542eee04439dc74acbade2d919781dd6271ec1e414a86bf
+  data.tar.gz: cb864b4a0a3069b1601eb0e57e42ef51f80f01ea5553a584d27e03d9033687da
 SHA512:
-  metadata.gz: 25012ff30d3ad3a30a66f8df6bbddb46af8b9d6b34621edd0e2f69aa737fc46966773f3c1e7eef312a67b580f6283276bcdbdf2872e713dfc808f7f751d2dc1b
-  data.tar.gz: 3548e2ef4c6c41f8d4df0b47314c8edb2897815899525cc1339aae5321567a2f6f740fc37bf97068add46aa2f180d568bcd096083db720bf92488a2fd83d7a63
+  metadata.gz: 9d99b8c6f5caa89fe61647ed34239e22529776eb05eebe6194da68ddbadc80ef53921d1947ee1dc25d31cfc10ff47b89bec2961c3d34572f751ab7991107da2a
+  data.tar.gz: 668e7b649e8ba559caef3192f77892f8bdcebf915001f39e12817e4fd7a377af96c5af8689aecbd2fd86d01dec1421db7a7fb8adc6a89f7769fa34532ebc30a5

data/.gitignore

@@ -7,3 +7,8 @@
 /pkg/
 /spec/reports/
 /tmp/
+/ext/cbc-wrapper/Makefile
+/ext/cbc-wrapper/mkmf.log
+ext/cbc-wrapper/*.o
+ext/cbc-wrapper/*.so
+ext/cbc-wrapper/*.bundle

data/README.md

@@ -5,6 +5,8 @@ It uses the version 2.9.9 of Cbc.
 
 ## Installation
 
+This gem requires you to have Cbc installed on your system first.
+
 Add this line to your application's Gemfile:
 
 ```ruby
@@ -19,10 +21,8 @@ Or install it yourself as:
 
     $ gem install cbc-wrapper
 
-The gem includes a version of the Coin-Or Cbc library. It downloads the library sources and
-recompiles them at installation. (curl, make and some gcc tools are needed)
-
-It also works on Heroku.
+WARNING: if you want the gem to download and compile the library sources when installing the gem,
+you will need to use a lesser version of it (2.9.9.3).
 
 ## Usage
 

data/ext/cbc-wrapper/cbc.i

@@ -4,12 +4,12 @@
 %include "carrays.i"
 
 %{
-#include "Coin_C_defines.h"
-#include "Cbc_C_Interface.h"
+#include "coin/Coin_C_defines.h"
+#include "coin/Cbc_C_Interface.h"
 %}
 
 %array_class(int, IntArray)
 %array_class(double, DoubleArray)
 
-%include "Coin_C_defines.h"
-%include "Cbc_C_Interface.h"
+%include "coin/Coin_C_defines.h"
+%include "coin/Cbc_C_Interface.h"

data/ext/cbc-wrapper/cbc_wrap.c

@@ -1851,8 +1851,8 @@ struct timeval rb_time_timeval(VALUE);
 #endif
 
 
-#include "Coin_C_defines.h"
-#include "Cbc_C_Interface.h"
+#include "coin/Coin_C_defines.h"
+#include "coin/Cbc_C_Interface.h"
 
 
 typedef int IntArray;

data/ext/cbc-wrapper/coin/Cbc_C_Interface.h

@@ -0,0 +1,381 @@
+/* $Id$ */
+/*
+  Copyright (C) 2004 International Business Machines Corporation and others.
+  All Rights Reserved.
+
+  This code is licensed under the terms of the Eclipse Public License (EPL).
+*/
+#ifndef CbcModelC_H
+#define CbcModelC_H
+
+/* include all defines and ugly stuff */
+#include "Coin_C_defines.h"
+#include <stddef.h>
+
+/*
+ * Original verison contributed by Bob Entriken,
+ * significantly updated by Miles Lubin.
+*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    /**@name Constructors and destructor
+      This is a "C" interface to Cbc.
+      The user does not need to know structure of Cbc_Model.
+    */
+    /*@{*/
+
+    /** Default Cbc_Model constructor */
+    COINLIBAPI Cbc_Model * COINLINKAGE
+    Cbc_newModel(void)
+    ;
+    /** Cbc_Model Destructor */
+    COINLIBAPI void COINLINKAGE
+    Cbc_deleteModel(Cbc_Model * model)
+    ;
+    /** Current version of Cbc */
+    COINLIBAPI const char* COINLINKAGE Cbc_getVersion(void)
+    ;
+    /*@}*/
+
+    /**@name Getting and setting model data
+     Note that problem access and modification methods,
+       such as getColLower and setColLower,
+       are *not valid* after calling Cbc_solve().
+       Therefore it is not recommended to reuse a Cbc_Model
+       object for multiple solves. A workaround is to call Cbc_clone()
+       before solving.
+     * */
+    /*@{*/
+    /** Loads a problem (the constraints on the
+        rows are given by lower and upper bounds). If a pointer is NULL then the
+        following values are the default:
+        <ul>
+        <li> <code>colub</code>: all columns have upper bound infinity
+        <li> <code>collb</code>: all columns have lower bound 0
+        <li> <code>rowub</code>: all rows have upper bound infinity
+        <li> <code>rowlb</code>: all rows have lower bound -infinity
+        <li> <code>obj</code>: all variables have 0 objective coefficient
+        </ul>
+
+     The constraint matrix is
+     given in standard compressed sparse column (without gaps).
+     <ul>
+     <li> <code>start[i]</code> stores the starting index of the ith column
+     <li> <code>index[k]</code> stores the row index of the kth nonzero element
+     <li> <code>value[k]</code> stores the coefficient of the kth nonzero element
+     </ul>
+    */
+    COINLIBAPI void COINLINKAGE
+    Cbc_loadProblem (Cbc_Model * model,  const int numcols, const int numrows,
+                     const CoinBigIndex * start, const int* index,
+                     const double* value,
+                     const double* collb, const double* colub,
+                     const double* obj,
+                     const double* rowlb, const double* rowub)
+    ;
+    /** Read an mps file from the given filename */
+    COINLIBAPI int COINLINKAGE
+    Cbc_readMps(Cbc_Model * model, const char *filename)
+    ;
+    /** Write an mps file from the given filename */
+    COINLIBAPI void COINLINKAGE
+    Cbc_writeMps(Cbc_Model * model, const char *filename)
+    ;
+    /** Provide an initial feasible solution to accelerate branch-and-bound 
+     Note that feasibility of the solution is *not* verified.
+    */
+    COINLIBAPI void COINLINKAGE
+    Cbc_setInitialSolution(Cbc_Model *model, const double * sol)
+    ;
+    /** Fills in array with problem name  */
+    COINLIBAPI void COINLINKAGE
+    Cbc_problemName(Cbc_Model * model, int maxNumberCharacters, char * array)
+    ;
+    /** Sets problem name.
+    
+      \p array must be a null-terminated string.
+    */
+    COINLIBAPI int COINLINKAGE
+    Cbc_setProblemName(Cbc_Model * model, const char * array)
+    ;
+
+    /** Number of nonzero elements in constraint matrix */
+    COINLIBAPI int COINLINKAGE
+    Cbc_getNumElements(Cbc_Model * model)
+    ;
+    /** "Column start" vector of constraint matrix. Same format as Cbc_loadProblem() */
+    COINLIBAPI const CoinBigIndex * COINLINKAGE
+    Cbc_getVectorStarts(Cbc_Model * model)
+    ;
+    /** "Row index" vector of constraint matrix */
+    COINLIBAPI const int * COINLINKAGE
+    Cbc_getIndices(Cbc_Model * model)
+    ;
+    /** Coefficient vector of constraint matrix */
+    COINLIBAPI const double * COINLINKAGE
+    Cbc_getElements(Cbc_Model * model)
+    ;
+
+    /** Maximum lenght of a row or column name */
+    COINLIBAPI size_t COINLINKAGE
+    Cbc_maxNameLength(Cbc_Model * model)
+    ;
+    /** Fill in first maxLength bytes of name array with a row name */
+    COINLIBAPI void COINLINKAGE
+    Cbc_getRowName(Cbc_Model * model, int iRow, char * name, size_t maxLength)
+    ;
+    /** Fill in first maxLength bytes of name array with a column name */
+    COINLIBAPI void COINLINKAGE
+    Cbc_getColName(Cbc_Model * model, int iColumn, char * name, size_t maxLength)
+    ;
+    /** Set the name of a column */
+    COINLIBAPI void COINLINKAGE
+    Cbc_setColName(Cbc_Model * model, int iColumn, const char * name)
+    ;
+    /** Set the name of a row */
+    COINLIBAPI void COINLINKAGE
+    Cbc_setRowName(Cbc_Model * model, int iRow, const char * name)
+    ;
+    /** Number of constraints in the model */
+    COINLIBAPI int COINLINKAGE
+    Cbc_getNumRows(Cbc_Model * model)
+    ;
+    /** Number of variables in the model */
+    COINLIBAPI int COINLINKAGE
+    Cbc_getNumCols(Cbc_Model * model)
+    ;
+    /** Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore) */
+    COINLIBAPI void COINLINKAGE
+    Cbc_setObjSense(Cbc_Model * model, double sense)
+    ;
+    /** Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore) */
+    COINLIBAPI double COINLINKAGE
+    Cbc_getObjSense(Cbc_Model * model)
+    ;
+    /** Constraint lower bounds */
+    COINLIBAPI const double* COINLINKAGE
+    Cbc_getRowLower(Cbc_Model * model)
+    ;
+    /** Set the lower bound of a single constraint */
+    COINLIBAPI void COINLINKAGE
+    Cbc_setRowLower(Cbc_Model * model, int index, double value)
+    ;
+    /** Constraint upper bounds */
+    COINLIBAPI const double* COINLINKAGE
+    Cbc_getRowUpper(Cbc_Model * model)
+    ;
+    /** Set the upper bound of a single constraint */
+    COINLIBAPI void COINLINKAGE
+    Cbc_setRowUpper(Cbc_Model * model, int index, double value)
+    ;
+    /** Objective vector */
+    COINLIBAPI const double * COINLINKAGE
+    Cbc_getObjCoefficients(Cbc_Model * model)
+    ;
+    /** Set the objective coefficient of a single variable */
+    COINLIBAPI void COINLINKAGE
+    Cbc_setObjCoeff(Cbc_Model * model, int index, double value)
+    ;
+    /** Variable lower bounds */
+    COINLIBAPI const double * COINLINKAGE
+    Cbc_getColLower(Cbc_Model * model)
+    ;
+    /** Set the lower bound of a single variable */
+    COINLIBAPI void COINLINKAGE
+    Cbc_setColLower(Cbc_Model * model, int index, double value)
+    ;
+    /** Variable upper bounds */
+    COINLIBAPI const double * COINLINKAGE
+    Cbc_getColUpper(Cbc_Model * model)
+    ;
+    /** Set the upper bound of a single variable */
+    COINLIBAPI void COINLINKAGE
+    Cbc_setColUpper(Cbc_Model * model, int index, double value)
+    ;
+    /** Determine whether the ith variable is integer restricted */
+    COINLIBAPI int COINLINKAGE
+    Cbc_isInteger(Cbc_Model * model, int i)
+    ;
+    /** Set this variable to be continuous */
+    COINLIBAPI void COINLINKAGE
+    Cbc_setContinuous(Cbc_Model * model, int iColumn)
+    ;
+    /** Set this variable to be integer */
+    COINLIBAPI void COINLINKAGE
+    Cbc_setInteger(Cbc_Model * model, int iColumn)
+    ;
+    /** Add SOS constraints to the model using row-order matrix */
+    COINLIBAPI void  COINLINKAGE
+    Cbc_addSOS(Cbc_Model * model, int numRows, const int * rowStarts,
+               const int * colIndices, const double * weights, const int type)
+    ;
+    /** Print the model */
+    COINLIBAPI void COINLINKAGE
+    Cbc_printModel(Cbc_Model * model, const char * argPrefix)
+    ;
+    /** Return a copy of this model */
+    COINLIBAPI Cbc_Model * COINLINKAGE
+    Cbc_clone(Cbc_Model * model)
+    ;
+    /*@}*/
+    /**@name Solver parameters */
+    /*@{*/
+    /** Set parameter "name" to value "value". Note that this
+     * translates directly to using "-name value" as a 
+     * command-line argument to Cbc.*/
+    COINLIBAPI void COINLINKAGE
+    Cbc_setParameter(Cbc_Model * model, const char * name, const char * value)
+    ;
+
+    
+    /*@}*/
+    /**@name Message handling.  Call backs are handled by ONE function */
+    /*@{*/
+    /** Pass in Callback function.
+     Message numbers up to 1000000 are Clp, Coin ones have 1000000 added */
+    COINLIBAPI void COINLINKAGE
+    Cbc_registerCallBack(Cbc_Model * model,
+                         cbc_callback userCallBack)
+    ;
+    /** Unset Callback function */
+    COINLIBAPI void COINLINKAGE
+    Cbc_clearCallBack(Cbc_Model * model)
+    ;
+
+    /*@}*/
+
+
+    /**@name Solving the model */
+    /*@{*/
+    /* Solve the model with Cbc (using CbcMain1).
+    */
+    COINLIBAPI int COINLINKAGE
+    Cbc_solve(Cbc_Model * model)
+    ;
+    /*@}*/
+
+
+    /**@name Accessing the solution and solution status */
+    /*@{*/
+
+    /** Sum of primal infeasibilities */
+    COINLIBAPI double COINLINKAGE
+    Cbc_sumPrimalInfeasibilities(Cbc_Model * model)
+    ;
+    /** Number of primal infeasibilities */
+    COINLIBAPI int COINLINKAGE
+    Cbc_numberPrimalInfeasibilities(Cbc_Model * model)
+    ;
+
+    /** Just check solution (for external use) - sets sum of
+        infeasibilities etc */
+    COINLIBAPI void COINLINKAGE
+    Cbc_checkSolution(Cbc_Model * model)
+    ;
+
+    /** Number of iterations */
+    COINLIBAPI int COINLINKAGE
+    Cbc_getIterationCount(Cbc_Model * model)
+    ;
+    /** Are there a numerical difficulties? */
+    COINLIBAPI int COINLINKAGE
+    Cbc_isAbandoned(Cbc_Model * model)
+    ;
+    /** Is optimality proven? */
+    COINLIBAPI int COINLINKAGE
+    Cbc_isProvenOptimal(Cbc_Model * model)
+    ;
+    /** Is infeasiblity proven (or none better than cutoff)? */
+    COINLIBAPI int COINLINKAGE
+    Cbc_isProvenInfeasible(Cbc_Model * model)
+    ;
+    /** Was continuous solution unbounded? */
+    COINLIBAPI int COINLINKAGE
+    Cbc_isContinuousUnbounded(Cbc_Model * model)
+    ;
+    /** Node limit reached? */
+    COINLIBAPI int COINLINKAGE
+    Cbc_isNodeLimitReached(Cbc_Model * model)
+    ;
+    /** Time limit reached? */
+    COINLIBAPI int COINLINKAGE
+    Cbc_isSecondsLimitReached(Cbc_Model * model)
+    ;
+    /** Solution limit reached? */
+    COINLIBAPI int COINLINKAGE
+    Cbc_isSolutionLimitReached(Cbc_Model * model)
+    ;
+    /** Are there numerical difficulties (for initialSolve) ? */
+    COINLIBAPI int COINLINKAGE
+    Cbc_isInitialSolveAbandoned(Cbc_Model * model)
+    ;
+    /** Is optimality proven (for initialSolve) ? */
+    COINLIBAPI int COINLINKAGE
+    Cbc_isInitialSolveProvenOptimal(Cbc_Model * model)
+    ;
+    /** Is primal infeasiblity proven (for initialSolve) ? */
+    COINLIBAPI int COINLINKAGE
+    Cbc_isInitialSolveProvenPrimalInfeasible(Cbc_Model * model)
+    ;
+    /** "row" solution
+     *  This is the vector A*x, where A is the constraint matrix
+     *  and x is the current solution. */
+    COINLIBAPI const double * COINLINKAGE
+    Cbc_getRowActivity(Cbc_Model * model)
+    ;
+    /** Best feasible solution vector */
+    COINLIBAPI const double * COINLINKAGE
+    Cbc_getColSolution(Cbc_Model * model)
+    ;
+    /** Objective value of best feasible solution */
+    COINLIBAPI double COINLINKAGE
+    Cbc_getObjValue(Cbc_Model * model)
+    ;
+    /** Best known bound on the optimal objective value */
+    COINLIBAPI double COINLINKAGE
+    Cbc_getBestPossibleObjValue(Cbc_Model * model)
+    ;
+    /** Number of nodes explored in B&B tree */
+    COINLIBAPI int COINLINKAGE
+    Cbc_getNodeCount(Cbc_Model * model)
+    ;
+    /** Print the solution */
+    COINLIBAPI void  COINLINKAGE
+    Cbc_printSolution(Cbc_Model * model)
+    ;
+    /** Final status of problem
+        Some of these can be found out by is...... functions
+        -1 before branchAndBound
+        0 finished - check isProvenOptimal or isProvenInfeasible to see if solution found
+        (or check value of best solution)
+        1 stopped - on maxnodes, maxsols, maxtime
+        2 difficulties so run was abandoned
+        (5 event user programmed event occurred)
+    */
+    COINLIBAPI int COINLINKAGE
+    Cbc_status(Cbc_Model * model)
+    ;
+    /** Secondary status of problem
+        -1 unset (status_ will also be -1)
+        0 search completed with solution
+        1 linear relaxation not feasible (or worse than cutoff)
+        2 stopped on gap
+        3 stopped on nodes
+        4 stopped on time
+        5 stopped on user event
+        6 stopped on solutions
+        7 linear relaxation unbounded
+        8 stopped on iteration limit
+    */
+    COINLIBAPI int COINLINKAGE
+    Cbc_secondaryStatus(Cbc_Model * model)
+    ;
+    /*@}*/
+#ifdef __cplusplus
+}
+#endif
+#endif

data/ext/cbc-wrapper/coin/Coin_C_defines.h

@@ -0,0 +1,115 @@
+/* $Id: Coin_C_defines.h 1690 2014-03-13 17:45:21Z mlubin $ */
+/*
+  Copyright (C) 2002, 2003 International Business Machines Corporation
+  and others.  All Rights Reserved.
+
+  This code is licensed under the terms of the Eclipse Public License (EPL).
+*/
+#ifndef CoinCDefine_H
+#define CoinCDefine_H
+
+/** This has #defines etc for the "C" interface to Coin.
+    If COIN_EXTERN_C defined then an extra extern C
+*/
+
+#if defined (CLP_EXTERN_C)
+#define COIN_EXTERN_C
+#define COIN_NO_SBB
+#define COIN_NO_CBC
+#endif
+#if defined (SBB_EXTERN_C)
+#define COIN_EXTERN_C
+#define COIN_NO_CLP
+#endif
+#if defined (CBC_EXTERN_C)
+#define COIN_EXTERN_C
+#define COIN_NO_CLP
+#endif
+/* We need to allow for Microsoft */
+#ifndef COINLIBAPI
+
+#if defined(CBCCINTERFACEDLL_EXPORTS) || defined(CLPMSDLL)
+#if defined (COIN_EXTERN_C)
+#   define COINLIBAPI __declspec(dllexport)
+#else
+#   define COINLIBAPI __declspec(dllexport)
+#endif
+#   define COINLINKAGE  __stdcall
+#   define COINLINKAGE_CB  __cdecl
+#else
+#if defined (COIN_EXTERN_C)
+#   define COINLIBAPI extern "C"
+#else
+#   define COINLIBAPI 
+#endif
+#   define COINLINKAGE
+#   define COINLINKAGE_CB 
+#endif
+
+#endif
+/** User does not need to see structure of model but C++ code does */
+#if defined (CLP_EXTERN_C)
+/* Real typedef for structure */
+class CMessageHandler;
+typedef struct {
+  ClpSimplex * model_;
+  CMessageHandler * handler_;
+} Clp_Simplex;
+#else
+typedef void Clp_Simplex;
+#endif
+
+#ifndef COIN_NO_CLP
+/** typedef for user call back.
+ The cvec are constructed so don't need to be const*/
+typedef  void (COINLINKAGE_CB *clp_callback) (Clp_Simplex * model,int  msgno, int ndouble,
+                            const double * dvec, int nint, const int * ivec,
+                            int nchar, char ** cvec);
+#endif
+/** User does not need to see structure of model but C++ code does */
+#if defined (SBB_EXTERN_C)
+/* Real typedef for structure */
+class Sbb_MessageHandler;
+typedef struct {
+  OsiClpSolverInterface * solver_;
+  SbbModel              * model_;
+  Sbb_MessageHandler    * handler_;
+  char                  * information_;
+} Sbb_Model;
+#else
+typedef void Sbb_Model;
+#endif
+#if defined (CBC_EXTERN_C)
+/* Real typedef for structure */
+class Cbc_MessageHandler;
+typedef struct {
+  OsiClpSolverInterface * solver_;
+  CbcModel              * model_;
+  Cbc_MessageHandler    * handler_;
+  std::vector<std::string> cmdargs_;
+} Cbc_Model;
+#else
+typedef void Cbc_Model;
+#endif
+#ifndef COIN_NO_SBB
+/** typedef for user call back.
+ The cvec are constructed so don't need to be const*/
+typedef  void (COINLINKAGE_CB *sbb_callback) (Sbb_Model * model,int  msgno, int ndouble,
+                            const double * dvec, int nint, const int * ivec,
+                            int nchar, char ** cvec);
+typedef  void (COINLINKAGE_CB *cbc_callback) (Cbc_Model * model,int  msgno, int ndouble,
+                            const double * dvec, int nint, const int * ivec,
+                            int nchar, char ** cvec);
+#endif
+#if COIN_BIG_INDEX==0
+typedef int CoinBigIndex;
+#elif COIN_BIG_INDEX==1
+typedef long CoinBigIndex;
+#else
+typedef long long CoinBigIndex;
+#endif
+/* just in case used somewhere */
+#undef COIN_NO_CLP
+#undef COIN_NO_SBB
+#undef COIN_NO_CBC
+#endif

data/ext/cbc-wrapper/extconf.rb

@@ -1,42 +1,35 @@
-require "mkmf"
-ROOT_DIR = File.dirname(File.absolute_path(__FILE__))
-
-TARBALL_PATH = "/tmp/Cbc.tgz"
-CBC_SRC_DIR = "/tmp/Cbc-2.9.9"
-CBC_INSTALL = "#{ROOT_DIR}/install"
-def install_cbc
-  system "curl -o #{TARBALL_PATH} https://www.coin-or.org/download/source/Cbc/Cbc-2.9.9.tgz"
-  Dir.chdir "/tmp" do
-    system "rm -rf #{CBC_SRC_DIR}; tar -xzf #{TARBALL_PATH}"
-    res = system "cd #{CBC_SRC_DIR} && ./configure --prefix=#{CBC_INSTALL} -C --with-pic --without-static && make -j `bash -c \"grep -c ^processor /proc/cpuinfo\"` && make install"
-    unless res
-      puts "Failed to build CBC, aborting... Cbc source is in #{CBC_SRC_DIR}"
-      exit 1
-    end
-    system "rm -rf #{CBC_SRC_DIR}"
-  end
-end
-
-install_cbc
+require 'mkmf'
 
 ## Rerun this if updated cbc version
 #  swig_cmd = find_executable "swig"
 #  current_path = File.expand_path('../', __FILE__)
-#  %x{#{swig_cmd} -ruby -I#{current_path}/install/include/coin #{current_path}/cbc.i }
+#  %x{#{swig_cmd} -ruby -I#{current_path}/coin #{current_path}/cbc.i }
+
+dir_config('cbc-wrapper')
+dir_config('cbc')
+
+succeed = true
 
 libs = %w(
   CbcSolver
 )
 
 libs.each do |lib|
-  find_library(lib, nil, "#{CBC_INSTALL}/lib")
+  unless find_library(lib, nil)
+    succeed = false
+  end
 end
 
-headers = Dir["#{CBC_INSTALL}/include/coin/*.h"].map { |h| h.split("/").last }
+headers = ["coin/Cbc_C_Interface.h", "coin/Coin_C_defines.h"]
+
 headers.each do |header|
-  find_header(header, "#{CBC_INSTALL}/include/coin")
+  unless find_header(header)
+    succeed = false
+  end
 end
 
-dir_config("cbc-wrapper")
-RPATHFLAG << " -Wl,-rpath,'$$ORIGIN/install/lib'"
-create_makefile("cbc_wrapper")
+if succeed
+  create_makefile('cbc_wrapper')
+else
+  abort "Missing some libraries or headers"
+end

data/lib/cbc-wrapper/version.rb

@@ -1,3 +1,3 @@
 module CbcWrapper
-  VERSION = "2.9.9.3"
+  VERSION = "2.9.9.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cbc-wrapper
 version: !ruby/object:Gem::Version
-  version: 2.9.9.3
+  version: 2.9.9.4
 platform: ruby
 authors:
 - Guillaume Verger
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-10-01 00:00:00.000000000 Z
+date: 2020-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -86,8 +86,9 @@ files:
 - cbc-wrapper.gemspec
 - ext/cbc-wrapper/cbc.i
 - ext/cbc-wrapper/cbc_wrap.c
+- ext/cbc-wrapper/coin/Cbc_C_Interface.h
+- ext/cbc-wrapper/coin/Coin_C_defines.h
 - ext/cbc-wrapper/extconf.rb
-- ext/cbc-wrapper/install/.gitignore
 - lib/cbc-wrapper.rb
 - lib/cbc-wrapper/version.rb
 homepage: https://github.com/gverger/cbc-wrapper
@@ -109,8 +110,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Bare wrapper around Cbc Linear Programming Solver made with SWIG

data/ext/cbc-wrapper/install/.gitignore

@@ -1,4 +0,0 @@
-# Ignore everything in this directory
-*
-# Except this file
-!.gitignore