facter 3.9.6.cfacter.20180612 → 3.11.0.cfacter.20180319

data/ext/facter/leatherman/json_container/inc/leatherman/json_container/json_container.hpp

@@ -20,6 +20,9 @@ namespace rapidjson {
 }  // namespace rapidjson
 
 namespace leatherman { namespace json_container {
+    // Constants
+    constexpr size_t DEFAULT_LEFT_PADDING { 4 };
+
     // Errors
 
     /// Parent error class.
@@ -139,9 +142,13 @@ namespace leatherman { namespace json_container {
         /// Throw a data_key_error in case the specified key is unknown.
         std::string toString(const std::vector<JsonContainerKey>& keys) const;
 
+        // TODO: Refactor this to use a default parameter of DEFAULT_LEFT_PADDING
+        // for left_padding to remove the empty-argument variant.
         std::string toPrettyString(size_t left_padding) const;
         std::string toPrettyString() const;
 
+        std::string toPrettyJson(size_t left_padding = DEFAULT_LEFT_PADDING) const;
+
         /// Return true if the root is an empty JSON array or an empty
         /// JSON object, false otherwise.
         bool empty() const;

data/ext/facter/leatherman/json_container/src/json_container.cc

@@ -3,6 +3,7 @@
 
 #include <rapidjson/document.h>
 #include <rapidjson/stringbuffer.h>
+#include <rapidjson/prettywriter.h>
 #include <rapidjson/writer.h>
 #include <rapidjson/allocators.h>
 #include <rapidjson/rapidjson.h>
@@ -12,7 +13,6 @@ using leatherman::locale::_;
 
 namespace leatherman { namespace json_container {
 
-    const size_t DEFAULT_LEFT_PADDING { 4 };
     const size_t LEFT_PADDING_INCREMENT { 2 };
 
     //
@@ -146,6 +146,15 @@ namespace leatherman { namespace json_container {
         return toPrettyString(DEFAULT_LEFT_PADDING);
     }
 
+    std::string JsonContainer::toPrettyJson(size_t left_padding) const {
+        rapidjson::StringBuffer buffer;
+        rapidjson::PrettyWriter<rapidjson::StringBuffer> writer { buffer };
+        writer.SetIndent(' ', left_padding);
+        auto& jval = *getValueInJson();
+        jval.Accept(writer);
+        return buffer.GetString();
+    }
+
     // capacity
 
     bool JsonContainer::empty() const {

data/ext/facter/leatherman/json_container/tests/json_container_test.cc

@@ -16,7 +16,7 @@ static const std::string JSON = "{\"foo\" : {\"bar\" : 2},"
                                 "               }"
                                 "}";
 
-namespace leatherman { namespace json_container {
+using namespace leatherman::json_container;
 
 TEST_CASE("JsonContainer::JsonContainer - passing JSON string", "[data]") {
     std::string json_value {};
@@ -149,7 +149,7 @@ TEST_CASE("JsonContainer::get for object entries", "[data]") {
     }
 
     SECTION("it can get the root object") {
-      REQUIRE(data.get<JsonContainer>().get<int>("goo") == 1);
+        REQUIRE(data.get<JsonContainer>().get<int>("goo") == 1);
     }
 
     SECTION("it should behave correctly given a null value") {
@@ -355,7 +355,7 @@ TEST_CASE("JsonContainer::get for object entries", "[data]") {
 
         SECTION("array with values of different types") {
             JsonContainer a { "[ 1, \"foo\", true, [2.718, 3.14], 42, 42.0, "
-                              "{\"spam\":\"eggs\"} ]" };
+                "{\"spam\":\"eggs\"} ]" };
 
             SECTION("boolean") {
                 REQUIRE(a.get<bool>(2));
@@ -511,6 +511,152 @@ TEST_CASE("JsonContainer::toPrettyString", "[data]") {
     }
 }
 
+TEST_CASE("JsonContainer::toPrettyJson", "[data]") {
+    SECTION("it pretty prints valid json") {
+        SECTION("a null value") {
+            std::string EXPECTED_OUTPUT = "null";
+
+            JsonContainer data(EXPECTED_OUTPUT);
+            auto pretty_json = data.toPrettyJson();
+            REQUIRE(pretty_json == EXPECTED_OUTPUT);
+        }
+
+        SECTION("a double") {
+            std::string EXPECTED_OUTPUT = "42.5";
+
+            JsonContainer data(EXPECTED_OUTPUT);
+            auto pretty_json = data.toPrettyJson();
+            REQUIRE(pretty_json == EXPECTED_OUTPUT);
+        }
+
+        SECTION("a bool") {
+            std::string EXPECTED_OUTPUT = "true";
+
+            JsonContainer data(EXPECTED_OUTPUT);
+            auto pretty_json = data.toPrettyJson();
+            REQUIRE(pretty_json == EXPECTED_OUTPUT);
+        }
+
+        SECTION("an int") {
+            std::string EXPECTED_OUTPUT = "42";
+
+            JsonContainer data(EXPECTED_OUTPUT);
+            auto pretty_json = data.toPrettyJson();
+            REQUIRE(pretty_json == EXPECTED_OUTPUT);
+        }
+
+        SECTION("a string") {
+            std::string EXPECTED_OUTPUT = "\"string\"";
+
+            JsonContainer data(EXPECTED_OUTPUT);
+            auto pretty_json = data.toPrettyJson();
+            REQUIRE(pretty_json == EXPECTED_OUTPUT);
+        }
+
+        SECTION("a simple array") {
+            std::string EXPECTED_OUTPUT =
+              "[\n"
+              "    null,\n"
+              "    42.5,\n"
+              "    true,\n"
+              "    42,\n"
+              "    \"string\"\n"
+              "]";
+
+            JsonContainer data(EXPECTED_OUTPUT);
+            auto pretty_json = data.toPrettyJson();
+            REQUIRE(pretty_json == EXPECTED_OUTPUT);
+        }
+
+        SECTION("a simple object") {
+            std::string EXPECTED_OUTPUT =
+              "{\n"
+              "    \"null-key\": null,\n"
+              "    \"double-key\": 42.5,\n"
+              "    \"bool-key\": true,\n"
+              "    \"int-key\": 42,\n"
+              "    \"string-key\": \"string\"\n"
+              "}";
+
+            JsonContainer data(EXPECTED_OUTPUT);
+            auto pretty_json = data.toPrettyJson();
+            REQUIRE(pretty_json == EXPECTED_OUTPUT);
+        }
+
+        SECTION("a nested object") {
+            std::string EXPECTED_OUTPUT =
+              "{\n"
+              "    \"object-key\": {\n"
+              "        \"null-key\": null,\n"
+              "        \"double-key\": 42.5,\n"
+              "        \"bool-key\": true,\n"
+              "        \"int-key\": 42,\n"
+              "        \"string-key\": \"string\"\n"
+              "    },\n"
+              "    \"array-key\": [\n"
+              "        null,\n"
+              "        42.5,\n"
+              "        true,\n"
+              "        42,\n"
+              "        \"string\"\n"
+              "    ]\n"
+              "}";
+
+            JsonContainer data(EXPECTED_OUTPUT);
+            auto pretty_json = data.toPrettyJson();
+            REQUIRE(pretty_json == EXPECTED_OUTPUT);
+        }
+
+        SECTION("a nested array") {
+            std::string EXPECTED_OUTPUT =
+              "[\n"
+              "    {\n"
+              "        \"null-key\": null,\n"
+              "        \"double-key\": 42.5,\n"
+              "        \"bool-key\": true,\n"
+              "        \"int-key\": 42,\n"
+              "        \"string-key\": \"string\"\n"
+              "    },\n"
+              "    [\n"
+              "        null,\n"
+              "        42.5,\n"
+              "        true,\n"
+              "        42,\n"
+              "        \"string\"\n"
+              "    ]\n"
+              "]";
+
+            JsonContainer data(EXPECTED_OUTPUT);
+            auto pretty_json = data.toPrettyJson();
+            REQUIRE(pretty_json == EXPECTED_OUTPUT);
+        }
+    }
+
+    SECTION("handles variable padding") {
+        std::string EXPECTED_OUTPUT =
+          "{\n"
+          "  \"object-key\": {\n"
+          "    \"null-key\": null,\n"
+          "    \"double-key\": 42.5,\n"
+          "    \"bool-key\": true,\n"
+          "    \"int-key\": 42,\n"
+          "    \"string-key\": \"string\"\n"
+          "  },\n"
+          "  \"array-key\": [\n"
+          "    null,\n"
+          "    42.5,\n"
+          "    true,\n"
+          "    42,\n"
+          "    \"string\"\n"
+          "  ]\n"
+          "}";
+
+        JsonContainer data(EXPECTED_OUTPUT);
+        auto pretty_json = data.toPrettyJson(2);
+        REQUIRE(pretty_json == EXPECTED_OUTPUT);
+    }
+}
+
 TEST_CASE("JsonContainer::empty", "[data]") {
     SECTION("works correctly for an empty JsonContainer instance") {
         JsonContainer data {};
@@ -754,8 +900,8 @@ TEST_CASE("JsonContainer::set", "[data]") {
 TEST_CASE("JsonContainer::keys", "[data]") {
     SECTION("It returns a vector of keys") {
         JsonContainer data { "{ \"a\" : 1, "
-                             " \"b\" : 2, "
-                             " \"c\\u0000null\" : 2}" };
+            " \"b\" : 2, "
+                " \"c\\u0000null\" : 2}" };
         std::vector<std::string> expected_keys { "a", "b", { "c\0null", 6 } };
 
         REQUIRE(data.keys() == expected_keys);
@@ -907,7 +1053,7 @@ TEST_CASE("JsonContainer::type", "[data]") {
 
 TEST_CASE("JsonContainer::type for arrays entries", "[data]") {
     JsonContainer data { "[false, -42, 3.14, \"spam\", {\"foo\" : [3, true]}, "
-                         "[1, 2, 3, 4] ]" };
+        "[1, 2, 3, 4] ]" };
 
     SECTION("root entry") {
         SECTION("array") {
@@ -981,5 +1127,3 @@ TEST_CASE("JsonContainer::type for arrays entries", "[data]") {
         }
     }
 }
-
-}}  // namespace leatherman::json_container

data/ext/facter/leatherman/locale/CMakeLists.txt

@@ -1,8 +1,5 @@
 if (LEATHERMAN_USE_LOCALES)
     find_package(Boost 1.54 REQUIRED COMPONENTS locale system)
-    if (BOOST_STATIC AND LEATHERMAN_USE_ICU)
-        find_package(ICU COMPONENTS i18n uc)
-    endif()
 else()
     find_package(Boost 1.54 REQUIRED regex)
 endif()
@@ -10,10 +7,6 @@ endif()
 add_leatherman_includes(${Boost_INCLUDE_DIRS})
 add_leatherman_deps(${Boost_LIBRARIES})
 
-if (ICU_LIBRARIES)
-    add_leatherman_deps(${ICU_LIBRARIES})
-endif()
-
 if (LEATHERMAN_USE_LOCALES AND BOOST_STATIC AND APPLE)
     # Boost.Locale relies on libiconv; if not using shared boost libraries
     # we need to include the dependency ourselves. So far this is only a

data/ext/facter/leatherman/locales/leatherman.pot

@@ -6,7 +6,7 @@
 #, fuzzy
 msgid ""
 msgstr ""
-"Project-Id-Version: leatherman 1.2.2\n"
+"Project-Id-Version: leatherman 1.4.0\n"
 "Report-Msgid-Bugs-To: docs@puppet.com\n"
 "POT-Creation-Date: \n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
@@ -203,12 +203,7 @@ msgid "{1}: {2} ({3})."
 msgstr ""
 
 #: execution/src/posix/execution.cc
-msgid "select call failed"
-msgstr ""
-
-#: execution/src/posix/execution.cc
-#: execution/src/windows/execution.cc
-msgid "child i/o failed."
+msgid "select call failed waiting for child i/o"
 msgstr ""
 
 #. debug
@@ -267,15 +262,11 @@ msgid "waitpid failed"
 msgstr ""
 
 #: execution/src/posix/execution.cc
-msgid "sigaction failed"
-msgstr ""
-
-#: execution/src/posix/execution.cc
-msgid "failed to setup timer"
+msgid "sigaction failed while setting up timeout"
 msgstr ""
 
 #: execution/src/posix/execution.cc
-msgid "setitimer failed"
+msgid "setitimer failed while setting up timeout"
 msgstr ""
 
 #. debug
@@ -353,6 +344,10 @@ msgstr ""
 msgid "{1} pipe i/o failed: {2}."
 msgstr ""
 
+#: execution/src/windows/execution.cc
+msgid "child i/o failed."
+msgstr ""
+
 #. error
 #: execution/src/windows/execution.cc
 msgid "failed to wait for child process i/o: {1}."

data/ext/facter/leatherman/logging/src/logging.cc

@@ -75,6 +75,7 @@ namespace leatherman { namespace logging {
         _dst << endl;
     }
 
+    // cppcheck-suppress passedByValue
     void setup_logging(ostream &dst, string locale, string domain, bool use_locale)
     {
         // Remove existing sinks before adding a new one
@@ -149,6 +150,7 @@ namespace leatherman { namespace logging {
         g_error_logged = false;
     }
 
+    // cppcheck-suppress passedByValue
     void on_message(function<bool(log_level, string const&)> callback)
     {
         g_callback = callback;

data/ext/facter/leatherman/util/tests/timer.cc

@@ -1,7 +1,7 @@
 #include <catch.hpp>
 #include <leatherman/util/timer.hpp>
 
-namespace leatherman { namespace util {
+using namespace leatherman::util;
 
 SCENARIO("Using Timer", "[util]") {
     SECTION("can instantiate") {
@@ -37,5 +37,3 @@ SCENARIO("Using Timer", "[util]") {
         REQUIRE_NOTHROW(t.elapsed_milliseconds());
     }
 }
-
-}}  // namespace leatherman::util

data/ext/facter/leatherman/vendor/nowide/doc/Doxyfile

@@ -114,7 +114,7 @@ FULL_PATH_NAMES        = YES
 # If left blank the directory from which doxygen is run is used as the
 # path to strip.
 
-STRIP_FROM_PATH        = ../../..
+STRIP_FROM_PATH        = ../include
 
 # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of
 # the path mentioned in the documentation of a class, which tells
@@ -123,7 +123,7 @@ STRIP_FROM_PATH        = ../../..
 # definition is used. Otherwise one should specify the include paths that
 # are normally passed to the compiler using the -I flag.
 
-STRIP_FROM_INC_PATH    = ../../..
+STRIP_FROM_INC_PATH    = ../include
 
 # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
 # (but less readable) file names. This can be useful is your file systems
@@ -581,7 +581,7 @@ WARN_LOGFILE           =
 # directories like "/usr/src/myproject". Separate the files or directories
 # with spaces.
 
-INPUT                  = ../../../boost/nowide/ \
+INPUT                  =  ../include/boost/nowide ../include/boost/nowide/integration \ 
                          .
 
 # This tag can be used to specify the character encoding of the source files
@@ -1349,7 +1349,7 @@ SEARCH_INCLUDES        = YES
 # contain include files that are not input files but should be processed by
 # the preprocessor.
 
-INCLUDE_PATH           =
+INCLUDE_PATH           = ../include
 
 # You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
 # patterns (like *.h and *.hpp) to filter out the header-files in the

data/ext/facter/leatherman/vendor/nowide/doc/LICENSE_1_0.txt

@@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

data/ext/facter/leatherman/vendor/nowide/doc/main.txt

@@ -22,6 +22,7 @@ Table of Contents:
 - \ref using
     - \ref using_standard
     - \ref using_custom
+    - \ref using_integration
 - \ref technical 
     - \ref technical_imple 
     - \ref technical_cio 
@@ -32,7 +33,7 @@ Table of Contents:
 \section main What is Boost.Nowide
 
 Boost.Nowide is a library implemented by Artyom Beilis
-that make cross platform Unicode aware programming
+that makes cross platform Unicode aware programming
 easier.
 
 The library provides an implementation of standard C and C++ library
@@ -45,22 +46,22 @@ requiring to use Wide API.
 \subsection main_the_problem The Problem
 
 Consider a simple application that splits a big file into chunks, such that 
-they can be sent by e-mail. It requires doing few very simple taks:
+they can be sent by e-mail. It requires doing a few very simple tasks:
 
 - Access command line arguments: <code>int main(int argc,char **argv)</code>
-- Open a input file, open several output files: <code>std::fstream::open(char const *,std::ios::openmode m)</code>
+- Open an input file, open several output files: <code>std::fstream::open(char const *,std::ios::openmode m)</code>
 - Remove the files in case of fault: <code>std::remove(char const *file)</code>
-- Print a progress report into console: <code>std::cout << file_name </code>
+- Print a progress report onto the console: <code>std::cout << file_name </code>
 
-Unfortunately it is impossible to implement this simple task in a plain C++
-if the file names contain non-ASCII characters
+Unfortunately it is impossible to implement this simple task in plain C++
+if the file names contain non-ASCII characters.
 
 The simple program that uses the API would work on the systems that use UTF-8
 internally -- the vast majority of Unix-Line operating systems: Linux, Mac OS X, 
 Solaris, BSD. But it would fail on files like <code>War and Peace - Война и мир - מלחמה ושלום.zip</code>
-under Microsoft Windows because the native Windows Unicode aware API is Wide-API - UTF-16.
+under Microsoft Windows because the native Windows Unicode aware API is Wide-API -- UTF-16.
 
-This, such a trivial task is very hard to implement in a cross platform manner.
+This incredibly trivial task is very hard to implement in a cross platform manner.
 
 \subsection main_the_solution The Solution
 
@@ -70,14 +71,14 @@ makes Unicode aware programming easier.
 The library provides:
 
 - Easy to use functions for converting UTF-8 to/from UTF-16
-- A class to fixing \c argc, \c argc and \c env \c main parameters to use UTF-8
+- A class to make the \c argc, \c argc and \c env parameters of \c main use UTF-8
 - UTF-8 aware functions
     - \c stdio.h functions:
         - \c fopen
         - \c freopen
         - \c remove
         - \c rename
-    - \c stdlib.h functions
+    - \c stdlib.h functions:
         - \c system
         - \c getenv
         - \c setenv
@@ -95,13 +96,13 @@ The library provides:
 
 \subsection main_wide Why Not Narrow and Wide? 
 
-Why not to provide both Wide and Narrow implementations so the
-developer can choose to use Wide characters on Unix-Like platforms
+Why not provide both Wide and Narrow implementations so the
+developer can choose to use Wide characters on Unix-like platforms?
 
 Several reasons:
 
 - \c wchar_t is not really portable, it can be 2 bytes, 4 bytes or even 1 byte making Unicode aware programming harder
-- Standard C and C++ library uses narrow strings for OS interactions. This library follows this general rule. There is
+- The C and C++ standard libraries use narrow strings for OS interactions. This library follows the same general rule. There is
   no such thing as <code>fopen(wchar_t const *,wchar_t const *)</code> in the standard library, so it is better
   to stick to the standards rather than re-implement Wide API in "Microsoft Windows Style"
 
@@ -114,12 +115,12 @@ Several reasons:
 \section using Using The Library
 \subsection using_standard Standard Features
 
-The library is mostly header only library, only console I/O requires separate compilation under Windows.
+The library is mostly header only, only console I/O requires separate compilation under Windows.
 
-As a developer you are expected to to \c boost::nowide functions instead of the function avalible in the
+As a developer you are expected to use \c boost::nowide functions instead of the functions available in the
 \c std namespace.
 
-For example, Unicode unaware implementation of line counter:
+For example, here is a Unicode unaware implementation of a line counter:
 \code
 #include <fstream>
 #include <iostream>
@@ -133,7 +134,7 @@ int main(int argc,char **argv)
 
     std::ifstream f(argv[1]);
     if(!f) {
-        std::cerr << "Can't open a file " << argv[1] << std::endl;
+        std::cerr << "Can't open " << argv[1] << std::endl;
         return 1;
     }
     int total_lines = 0;
@@ -147,7 +148,7 @@ int main(int argc,char **argv)
 }
 \endcode
 
-To make this program handle Unicode properly we do the following changes:
+To make this program handle Unicode properly, we do the following changes:
 
 
 \code
@@ -166,7 +167,7 @@ int main(int argc,char **argv)
     boost::nowide::ifstream f(argv[1]); // argv[1] - is UTF-8
     if(!f) {
         // the console can display UTF-8
-        boost::nowide::cerr << "Can't open a file " << argv[1] << std::endl;
+        boost::nowide::cerr << "Can't open " << argv[1] << std::endl;
         return 1;
     }
     int total_lines = 0;
@@ -181,30 +182,30 @@ int main(int argc,char **argv)
 }
 \endcode
 
-This is very simple and straight forward approach helps writing Unicode aware programs.
+This very simple and straightforward approach helps writing Unicode aware programs.
     
 \subsection using_custom Custom API
 
-Of course this simple set of functions does not cover all needs. However if you need
-to access Wide API from Windows application using UTF-8 encoding internally you can use
+Of course, this simple set of functions does not cover all needs. If you need
+to access Wide API from a Windows application that uses UTF-8 internally you can use
 functions like \c boost::nowide::widen and \c boost::nowide::narrow.
 
-For example
+For example:
 \code
 CopyFileW(  boost::nowide::widen(existing_file).c_str(),
             boost::nowide::widen(new_file).c_str(),
             TRUE);
 \endcode
 
-So the conversion is done at the last stage and you continue using
-UTF-8 strings anywhere and only at glue points you switch to 
-Wide API.
+The conversion is done at the last stage, and you continue using UTF-8 
+strings everywhere else. You only switch to the Wide API at glue points.
 
 \c boost::nowide::widen returns \c std::string. Sometimes
-it is convenient to prevent allocation and use on stack buffers
-if possible. Boot.Nowide provides \c boost::nowide::basic_stackstring class.
+it is useful to prevent allocation and use on-stack buffers
+instead. Boost.Nowide provides the \c boost::nowide::basic_stackstring
+class for this purpose.
 
-Such that the example above can be rewritten as:
+The example above could be rewritten as:
 
 \code
 boost::nowide::basic_stackstring<wchar_t,char,64> wexisting_file,wnew_file;
@@ -216,25 +217,31 @@ if(!wexisting_file.convert(existing_file) || !wnew_file.convert(new_file)) {
 CopyFileW(wexisting_file.c_str(),wnew_file.c_str(),TRUE);
 \endcode
 
-\note There are convenience typedefs \c stackstring, \c wstackstring, \c short_stackstring and \c wshort_stackstring
-that use buffers of size 256 or 16 characters, and if the string is longer, they fall-back to memory
-allocation
+\note There are a few convenience typedefs: \c stackstring and \c wstackstring using
+256-character buffers, and \c short_stackstring and \c wshort_stackstring using 16-character
+buffers. If the string is longer, they fall back to memory allocation.
 
-\subsection using_windows_h windows.h header
+\subsection using_windows_h The windows.h header
 
 The library does not include the \c windows.h in order to prevent namespace pollution with numerous
-defines and types. The library rather defines the prototypes to the Win32 API functions.
+defines and types. Instead, the library defines the prototypes of the Win32 API functions.
+
+However, you may request to use the \c windows.h header by defining \c BOOST_NOWIDE_USE_WINDOWS_H 
+before including any of the Boost.Nowide headers
+
+\subsection using_integration Integration with Boost.Filesystem
+
+Boost.Filesystem supports selection of narrow encoding. Unfortunatelly the default narrow encoding on Windows isn't UTF-8, you can enable UTF-8 as default encoding on Boost.Filesystem
+by calling `boost::nowide::nowide_filesystem()` in the beginning of your program 
 
-However if you may request to use original \c windows.h header by setting \c BOOST_NOWIDE_USE_WINDOWS_H 
-define before including any of the Boost.Nowide headers
 
 \section technical Technical Details
 \subsection technical_imple Windows vs POSIX
 
-The library provide UTF-8 aware functions for Microsoft Windows in  \c boost::nowide namespace that usually lay in \c std:: namespace,
-for example \c std::fopen goes to \c boost::nowide::fopen. 
+For Microsoft Windows, the library provides UTF-8 aware variants of some \c std:: functions in the \c boost::nowide namespace.
+For example, \c std::fopen becomes \c boost::nowide::fopen. 
 
-Under POSIX platforms the boost::nowide::fopen and all other functions are aliases to standard library functions:
+Under POSIX platforms, the functions in boost::nowide are aliases of their standard library counterparts:
 
 \code
 namespace boost {
@@ -253,25 +260,26 @@ using std::fopen
 
 \subsection technical_cio Console I/O
 
-Console I/O implemented as wrapper over ReadConsoleW/WriteConsoleW unless
-the stream is not "atty" like a pipe than ReadFile/WriteFile is used.
+Console I/O is implemented as a wrapper around ReadConsoleW/WriteConsoleW
+(used when the stream goes to the "real" console) and ReadFile/WriteFile
+(used when the stream was piped/redirected).
 
 This approach eliminates a need of manual code page handling. If TrueType
-fonts are used the Unicode aware input and output would work.
+fonts are used the Unicode aware input and output works as intended.
 
 \section qna Q & A
 
-<b>Q: Why the library does not convert the string from Locale's encoding not UTF-8 and wise versa on POSIX systems</b>
+<b>Q: Why doesn't the library convert the string to/from the locale's encoding (instead of UTF-8) on POSIX systems?</b>
 
 A: It is inherently incorrect
 to convert strings to/from locale encodings on POSIX platforms.
 
-You can create a file named "\xFF\xFF.txt" (invalid UTF-8), remove it, pass its name as a parameter to program 
-and it would work whether the current locale is UTF-8 locale or not.
-Also changing the locale from let's say \c en_US.UTF-8 to \c en_US.ISO-8859-1 would not magically change all
-files in OS or the strings a user may pass to the program (which is different on Windows)
+You can create a file named "\xFF\xFF.txt" (invalid UTF-8), remove it, pass its name as a parameter to a program 
+and it would work whether the current locale is UTF-8 or not.
+Also, changing the locale from let's say \c en_US.UTF-8 to \c en_US.ISO-8859-1 would not magically change all
+files in the OS or the strings a user may pass to the program (which is different on Windows)
 
-POSIX OSs treat strings as \c NUL terminated cookies.
+POSIX OSs treat strings as \c NULL terminated cookies.
 
 So altering their content according to the locale would
 actually lead to incorrect behavior.
@@ -283,21 +291,21 @@ For example, this is a naive implementation of a standard program "rm"
 
 int main(int argc,char **argv)
 {
-   for(int i=1;i<argc;i++)
-     std::remove(argv[i]);
-   return 0;
+    for(int i=1;i<argc;i++)
+        std::remove(argv[i]);
+    return 0;
 }
 \endcode
 
 It would work with ANY locale and changing the strings would
 lead to incorrect behavior.
 
-The meaning of a locale under POSIX and Windows paltforms
+The meaning of a locale under POSIX and Windows platforms
 is different and has very different effects.
 
 \subsection standalone_version Standalone Version
 
-It is possible to use Nowide library without dependency on the huge Boost project. There is a standalone version that all the functionality is placed in \c nowide namespace instead of \c boost::nowide. The example above would look like
+It is possible to use Nowide library without having the huge Boost project as a dependency. There is a standalone version that has all the functionality in the \c nowide namespace instead of \c boost::nowide. The example above would look like
 
 \code
 #include <nowide/args.hpp>
@@ -337,7 +345,7 @@ The upstream sources can be found at GitHub: <a href="https://github.com/artyom-
 
 You can download the latest sources there:
 
-- Standard Version: <a href="../boost_nowide.zip">boost_nowide.zip</a>
+- Standard Version: <a href="https://github.com/artyom-beilis/nowide/archive/master.zip">nowide-master.zip</a>
 - Standalone Boost independent version <a href="../nowide_standalone.zip">nowide_standalone.zip</a>
 
 */