FI Microsoft/bond/master => lokitoth/bond/master

.travis.yml

@@ -0,0 +1,92 @@
+sudo: false
+language: csharp
+os:
+    - linux
+    - osx
+cache:
+    directories:
+        - compiler/.cabal-sandbox
+        - cs/packages
+env:
+    - BOND_LANG=cpp-clang
+    - BOND_LANG=cpp-gcc
+    - BOND_LANG=cs
+    - BOND_LANG=py-clang
+    - BOND_LANG=py-gcc
+    - BOND_GHC_VERSION=-7.8.4
+    - BOND_GHC_VERSION=-7.6.3
+addons:
+  apt:
+    sources:
+        - boost-latest
+        - ubuntu-toolchain-r-test
+        - hvr-ghc
+    packages:
+        - g++-4.8
+        - libboost1.55-all-dev
+        - cabal-install-1.22
+        - ghc-7.8.4
+        - ghc-7.6.3
+        - ghc
+matrix:
+  exclude:
+    # linux VM is too small to build C++ unit tests with g++
+    - os: linux
+      env: BOND_LANG=cpp-gcc
+    # linux C++ build/test already includes Python
+    - os: linux
+      env: BOND_LANG=py-clang
+    # don't test non-default versions of GHC on OSX
+    - os: osx
+      env: BOND_GHC_VERSION=-7.8.4
+    - os: osx
+      env: BOND_GHC_VERSION=-7.6.3
+    # on OS X g++ and clang++ are the same compiler
+    - os: osx
+      env: BOND_LANG=cpp-gcc
+    - os: osx
+      env: BOND_LANG=py-gcc
+
+before_install:
+    # select C++ compiler
+    - export CXX="clang++" CC="clang"
+    - if [[ $BOND_LANG == *gcc ]]; then export CXX="g++-4.8" CC="gcc-4.8"; fi
+    # linux prereqisite packages
+    - if [ "$TRAVIS_OS_NAME" == "linux" ]; then wget --no-check-certificate https://www.cmake.org/files/v3.2/cmake-3.2.3-Linux-x86_64.tar.gz; fi
+    - if [ "$TRAVIS_OS_NAME" == "linux" ]; then tar -xzvf cmake-3.2.3-Linux-x86_64.tar.gz; fi
+    - if [ "$TRAVIS_OS_NAME" == "linux" ]; then export PATH=$PWD/cmake-3.2.3-Linux-x86_64/bin:$PATH; fi
+    # OS X prerequisite packages
+    - if [ "$TRAVIS_OS_NAME" == "osx" ]; then brew update; fi
+    - if [ "$TRAVIS_OS_NAME" == "osx" ]; then brew install ghc cabal-install; fi
+    - if [ "$TRAVIS_OS_NAME" == "osx" ] && [[ $BOND_LANG == py* ]]; then brew unlink boost; fi
+    - if [ "$TRAVIS_OS_NAME" == "osx" ] && [[ $BOND_LANG == py* ]]; then brew install boost boost-python; fi
+    # nunit installation
+    - if [ "$BOND_LANG" == "cs" ]; then travis_retry nuget install NUnit.Runners -version 2.6.4; fi
+    - export PATH=/opt/cabal/1.22/bin:/opt/ghc/${BOND_GHC_VERSION#?}/bin:$PATH
+    - cabal update
+    - cabal install happy
+
+before_script:
+    # restore nuget packages for solution
+    - if [ "$BOND_LANG" == "cs" ]; then travis_retry nuget restore cs/cs.sln; fi
+
+script:
+    - mkdir build && cd build
+    - cmake ..
+    - if [ "$BOND_LANG" == "cs" ]; then make --jobs 2 DESTDIR=$HOME install; fi
+    - if [ "$BOND_LANG" == "cs" ]; then export BOND_COMPILER_PATH=$HOME/usr/local/bin; fi
+    - if [[ $BOND_LANG == cpp* ]]; then make --jobs 2 check; fi
+    - if [ "$TRAVIS_OS_NAME" == "linux" ]; then export BOND_PYTHON_TARGETS="python_unit_test python_extension" BOND_PYTHON_TESTS=python_unit_test; fi
+    - if [ "$TRAVIS_OS_NAME" == "osx" ]; then export BOND_PYTHON_TARGETS="python_compatibility_test python_unit_test python_extension compatibility_test" BOND_PYTHON_TESTS=".*python.*"; fi
+    - if [[ $BOND_LANG == py* ]]; then make $BOND_PYTHON_TARGETS; fi
+    - if [[ $BOND_LANG == py* ]]; then ctest --tests-regex $BOND_PYTHON_TESTS --output-on-failure; fi
+    - if [ "$BOND_GHC_VERSION" != "" ]; then make gbc-tests; fi
+    - cd ..
+    - if [ "$BOND_LANG" == "cs" ]; then xbuild /p:Configuration=Debug cs/cs.sln; fi
+    - if [ "$BOND_LANG" == "cs" ]; then xbuild /p:Configuration=Fields cs/cs.sln; fi
+    - if [ "$BOND_LANG" == "cs" ]; then mono NUnit.Runners.2.6.4/tools/nunit-console.exe -framework=mono-4.5 -labels cs/test/core/bin/debug/net45/Properties/Bond.UnitTest.dll cs/test/core/bin/debug/net45/Fields/Bond.UnitTest.dll cs/test/internal/bin/debug/net45/Bond.InternalTest.dll; fi
+    - if [ "$BOND_GHC_VERSION" != "" ]; then cd compiler; fi
+    - if [ "$BOND_GHC_VERSION" != "" ]; then ../build/compiler/build/gbc-tests/gbc-tests; fi
+
+before_cache:
+    - if [ "$BOND_GHC_VERSION" != "" ]; then rm -rf compiler/.cabal-sandbox; fi

CMakeLists.txt

@@ -22,11 +22,14 @@ include (PythonTest)
 
 add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} -C ${CMAKE_CFG_INTDIR} --output-on-failure)
 
-add_subdirectory (compiler)
+add_subfolder (compiler "compiler")
 add_subdirectory (cpp)
+add_subfolder (doc "doc")
 add_python_subdirectory (python)
 add_subdirectory (examples)
 
+add_dependencies (check gbc-tests)
+
 install (DIRECTORY
     cpp/inc/bond
     cpp/generated/bond

README.md

@@ -1,3 +1,6 @@
+[![Build Status](https://travis-ci.org/Microsoft/bond.svg?branch=master)](https://travis-ci.org/Microsoft/bond)
+[![NuGet](https://img.shields.io/nuget/v/Bond.CSharp.svg?style=flat)](https://www.nuget.org/packages/Bond.CSharp/)
+
 Bond
 ====
 
@@ -8,9 +11,9 @@ Microsoft in high scale services.
 
 Bond is published on GitHub at [https://github.com/Microsoft/bond/](https://github.com/Microsoft/bond/).
 
-For details, see the User's Manuals for [C++](http://Microsoft.github.io/bond/manual/bond_cpp.html), [C#](http://Microsoft.github.io/bond/manual/bond_cs.html) and [Python](http://Microsoft.github.io/bond/manual/bond_py.html).
+For details, see the User's Manuals for [C++](https://Microsoft.github.io/bond/manual/bond_cpp.html), [C#](https://Microsoft.github.io/bond/manual/bond_cs.html) and [Python](https://Microsoft.github.io/bond/manual/bond_py.html).
 
-For a discussion how Bond compares to similar frameworks see [Why Bond](http://Microsoft.github.io/bond/why_bond.html).
+For a discussion how Bond compares to similar frameworks see [Why Bond](https://Microsoft.github.io/bond/why_bond.html).
 
 Dependencies
 ------------
@@ -21,7 +24,7 @@ The Bond repository uses Git submodules and should be cloned with the
     git clone --recursive https://github.com/Microsoft/bond.git
 
 In order to build Bond you will need CMake (2.8.12+), Haskell (ghc 7.4+ and 
-cabal-install 1.20+) and Boost (1.54+). The core Bond C++ library can be used 
+cabal-install 1.18+) and Boost (1.54+). The core Bond C++ library can be used 
 with C++03 compilers, although Python support, unit tests and various examples 
 require some C++11 features.
 
@@ -67,6 +70,8 @@ packages are needed:
         libboost-test-dev \
         libboost-python-dev
 
+    cabal install happy
+
 Running the following command in the build directory will build and execute all 
 the tests and examples:
 
@@ -77,22 +82,24 @@ assuming you have enough memory)
 
 ### OS X
 
-- Install XCode 6.1
-- Install CMake ([http://www.cmake.org/download/](http://www.cmake.org/download/))
-- Install Haskell Platform ([http://haskell.org/platform/](http://haskell.org/platform/))
+Install XCode and then run the following command to install required packages 
+using Homebrew ([http://brew.sh/](http://brew.sh/)):
 
-Update cabal to the latest version:
-
-    cabal update
-    cabal install cabal-install
+    brew install \
+        cmake \
+        ghc \
+        cabal-install \
+        boost \
+        boost-python
 
-Install Boost using Homebrew ([http://brew.sh/](http://brew.sh/)):
+(boost-python is optional and only needed for Python support)
 
-    brew install boost boost-python
+Update cabal package database and install `happy` (only needed for tests): 
 
-(boost-python is optional and only needed for Python support)
+    cabal update
+    cabal install happy
 
-Bond can be built on OS X using either standard *nix makefiles or XCode. In 
+Bond can be built on OS X using either standard \*nix makefiles or XCode. In 
 order to generate and build makefiles, in the root `bond` directory run:
 
     mkdir build
@@ -101,31 +108,48 @@ order to generate and build makefiles, in the root `bond` directory run:
     make
     sudo make install
 
-Alternatively you can use the CMake application to generate either *nix 
-makefiles or XCode project into a directory of your choice (it doesn't have to 
-be called `build`).
+Alternatively you can generate XCode project by passing `-G Xcode` option to 
+cmake:
 
-You can build and run unit tests by building the `check` target in XCode or 
-by running make in the build directory:
+    cmake -G Xcode ..
+
+You can build and run unit tests by building the `check` target in XCode or by 
+running make in the build directory:
 
     make --jobs 8 check
 
+Note that if you are using Homebrew's Python, you'll need to build
+boost-python from source:
+
+    brew install --build-from-source boost-python
+
+and tell cmake the location of Homebrew's libpython by setting `PYTHON_LIBRARY` 
+variable, e.g.:
+
+    cmake .. -DPYTHON_LIBRARY=/usr/local/Cellar/python/2.7.9/Frameworks/Python.framework/Versions/2.7/lib/libpython2.7.dylib
+
 ### Windows
 
-- Install Visual Studio 2013
-- Install CMake ([http://www.cmake.org/download/](http://www.cmake.org/download/))
-- Install Haskell Platform ([http://haskell.org/platform/](http://haskell.org/platform/))
+[![Build Status](https://ci.appveyor.com/api/projects/status/github/Microsoft/bond?svg=true&branch=master)](https://ci.appveyor.com/project/sapek/bond/branch/master)
+
+Install the following tools:
+
+- Visual Studio 2013 or 2015
+- CMake ([http://www.cmake.org/download/](http://www.cmake.org/download/))
+- Haskell Platform ([http://haskell.org/platform/](http://haskell.org/platform/))
 
+If you are building on a network behind a proxy, set the environment variable 
+`HTTP_PROXY`, e.g.:
 
-Update cabal to the latest version (if behind a proxy, set environment variable 
-`HTTP_PROXY=http://proxy:port` before running cabal):
+    set HTTP_PROXY=http://your-proxy-name:80
+
+Update cabal package database:
 
     cabal update
-    cabal install cabal-install
 
 Now you are ready to build the C# version of Bond. Open the solution file 
 `cs\cs.sln` in Visual Studio 2013 and build as usual. The C# unit tests can 
-also be run from with the solution.
+also be run from within the solution.
 
 The C++ and Python versions of Bond additionally require:
 
@@ -134,30 +158,39 @@ The C++ and Python versions of Bond additionally require:
 
 You may need to set the environment variables `BOOST_ROOT` and `BOOST_LIBRARYDIR` 
 to specify where Boost and its pre-built libraries for your environment can be 
-found. The core Bond library and most examples only require Boost headers. The 
+found, e.g.: 
+
+    set BOOST_ROOT=D:\boost_1_57_0
+    set BOOST_LIBRARYDIR=D:\boost_1_57_0\lib64-msvc-12.0
+
+The core Bond library and most examples only require Boost headers. The 
 pre-built libraries are only needed for unit tests and Python support. If Boost
 or Python libraries are not found on the system then some tests and examples will 
 not be built.
 
-In order to configure C++/Python project run `cmake-gui`, select the root of 
-this repository as the source code directory and some other directory as the 
-target for generated project files and build binaries. Now press Generate and 
-select desired target build environment. This configuration step has to be 
-performed only once. From now on you can use the generated solution `bond.sln`.
+In order to configure solution for Visual Studio 2013 run the following 
+commands from the root `bond` directory:
 
-IMPORTANT: Bond unit tests are very large. If you are building using the Visual 
-Studio toolchain you have to select 64-bit tools by setting the following 
-environment variable:
+    mkdir build
+    cd build
+    cmake -G "Visual Studio 12 2013 Win64" ..
 
-For Visual Studio 2012:
+Instead of `cmake` you can also use `cmake-gui` and specify configuration 
+settings in the UI. This configuration step has to be performed only once. From 
+now on you can use the generated solution `build\bond.sln` from Visual Studio 
+or build from command line using `cmake`:
 
-    set _IsNativeEnvironment=true
+    set PreferredToolArchitecture=x64
+    cmake --build . --target
+    cmake --build . --target INSTALL
 
-For Visual Studio 2013:
+In order to build and execute the unit tests and examples run:
 
-    set PreferredToolArchitecture=x64
+    cmake --build . --target check -- /maxcpucount:8
 
-In order to run unit tests on the Debug build, execute the following command in 
-the build directory:
+Setting `PreferredToolArchitecture=x64` selects the 64-bit toolchain which 
+dramatically improves build speed (Bond unit tests are too big to build with 
+32-bit tools). This variable works for Visual Studio 2013 or 2015. For VS 2012 set the 
+following variable instead:
 
-    ctest -C Debug
+    set _IsNativeEnvironment=true