cfacter 3.11.0.rc.20180314

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

@@ -0,0 +1,46 @@
+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()
+
+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
+    # problem on Mac OS X.
+    add_leatherman_deps(iconv)
+endif()
+
+leatherman_dependency(util)
+
+add_leatherman_headers(inc/leatherman)
+
+if (LEATHERMAN_USE_LOCALES)
+    add_leatherman_library(src/locale.cc)
+    if (GETTEXT_ENABLED)
+        # This test relies on translation .mo files being generated.
+        # Projects that don't support localization yet still need
+        # tests to pass, so only enable these tests if gettext is
+        # available.
+        add_leatherman_test(tests/locale.cc)
+    endif()
+else()
+    add_leatherman_library(disabled/locale.cc)
+endif()
+
+add_leatherman_test(tests/format.cc)
+
+if (LEATHERMAN_USE_LOCALES AND BUILDING_LEATHERMAN)
+    project(leatherman_locale)
+    add_subdirectory(locales)
+endif()

data/ext/facter/leatherman/locale/disabled/locale.cc

@@ -0,0 +1,38 @@
+#include <leatherman/locale/locale.hpp>
+
+namespace leatherman { namespace locale {
+
+    using namespace std;
+
+    const std::locale get_locale(string const& id, string const& domain, vector<string> const& paths)
+    {
+        // std::locale is not supported on these platforms
+        throw runtime_error("leatherman::locale::get_locale is not supported on this platform");
+    }
+
+    void clear_domain(string const& domain)
+    {
+        throw runtime_error("leatherman::locale::clear_domain is not supported on this platform");
+    }
+
+    string translate(string const& msg, string const& domain)
+    {
+        return msg;
+    }
+
+    string translate_p(string const& context, string const& msg, string const& domain)
+    {
+        return msg;
+    }
+
+    string translate_n(string const& single, string const& plural, int n, string const& domain)
+    {
+        return n == 1 ? single : plural;
+    }
+
+    string translate_np(string const& context, string const& single, string const& plural, int n, string const& domain)
+    {
+        return n == 1 ? single : plural;
+    }
+
+}}  // namespace leatherman::locale

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

@@ -0,0 +1,263 @@
+/**
+* @file
+* Declares utility functions for setting the locale.
+*
+* Boost.Locale is not available on all platforms. This header is implemented
+* so that it can switch between using boost::locale::format and boost::format
+* (without localization) by defining LEATHERMAN_I18N. Because these classes
+* do not use the same substitution characters, but gettext replacement relies
+* on matching a string, specify that both "%N%" (Boost.Format) and "{N}"
+* (Boost.Locale) should be considered substitution characters when using
+* leatherman::locale::format, and "{N}" should be preferred. When i18n is
+* disabled, it will regex replace "{(\d+)}" to "%\1%" for use with Boost.Format.
+*/
+#pragma once
+#include <locale>
+#include <vector>
+#include <functional>
+
+#ifdef LEATHERMAN_I18N
+#include <boost/locale/format.hpp>
+#else
+#include <boost/format.hpp>
+#include <boost/regex.hpp>
+// Unset PROJECT_NAME so we only create a single locale.
+#undef PROJECT_NAME
+#define PROJECT_NAME ""
+#undef PROJECT_DIR
+#define PROJECT_DIR
+#endif
+
+namespace leatherman { namespace locale {
+
+    /**
+     * Gets a locale object for the specified locale id.
+     * @param id The locale ID, defaults to a UTF-8 compatible system default.
+     * @param domain The catalog domain to use for i18n via gettext.
+     * @param paths Search paths for localization files.
+     * @return The locale. If a locale for the specified domain already exists, it returns
+     * the same locale until clear_domain is called for that domain.
+     * Throws boost::locale::conv::conversion_error if the system locale is invalid or
+     * the catalog for the specified language can't be used with the system locale encoding.
+     *
+     * Unsafe to use with GCC on AIX or Solaris, as std::locale is busted.
+     */
+    const std::locale get_locale(std::string const& id = "",
+                                 std::string const& domain = PROJECT_NAME,
+                                 std::vector<std::string> const& paths = {PROJECT_DIR});
+
+    /**
+     * Clears the locale for a specific domain.
+     * WARNING: This may invalidate existing references, so only use for testing.
+     * @param domain The catalog domain to clear.
+     */
+    void clear_domain(std::string const& domain = PROJECT_NAME);
+
+    /**
+     * Translate text using the locale initialized by this library.
+     * If localization encounters an error, the original message will be returned.
+     * @param msg The string to translate.
+     * @param domain The catalog domain to use for i18n via gettext.
+     * @return The translated string.
+     */
+    std::string translate(std::string const& msg, std::string const& domain = PROJECT_NAME);
+
+    /**
+     * Translate text in a given context using the locale initialized by this library.
+     * Context can be used to disambiguate the same word used multiple different ways.
+     * If localization encounters an error, the original message will be returned.
+     * @param context The context string.
+     * @param msg The string to translate.
+     * @param domain The catalog domain to use for i18n via gettext.
+     * @return The translated string.
+     */
+    std::string translate_p(std::string const& context, std::string const& msg, std::string const& domain = PROJECT_NAME);
+
+    /**
+     * Translate plural text using the locale initialized by this library.
+     * If localization encounters an error, the `single` message will be returned for n == 1,
+     * and the `plural` message will be returned for all other values of n.
+     * @param single The singuar form to translate.
+     * @param plural The plural form to translate.
+     * @param n Number of items, used to choose singular or plural.
+     * @param domain The catalog domain to use for i18n via gettext.
+     * @return The translated string.
+     */
+    std::string translate_n(std::string const& single, std::string const& plural, int n, std::string const& domain = PROJECT_NAME);
+
+    /**
+     * Translate plural text in a given context using the locale initialized by this library.
+     * Context can be used to disambiguate the same word used multiple different ways.
+     * If localization encounters an error, the `single` message will be returned for n == 1,
+     * and the `plural` message will be returned for all other values of n.
+     * @param context The context string.
+     * @param single The singuar form to translate.
+     * @param plural The plural form to translate.
+     * @param n Number of items, used to choose singular or plural.
+     * @param domain The catalog domain to use for i18n via gettext.
+     * @return The translated string.
+     */
+    std::string translate_np(std::string const& context, std::string const& single, std::string const& plural, int n, std::string const& domain = PROJECT_NAME);
+
+    namespace {
+        /*
+         * Anonymous namespace, limiting access to current namespace
+         */
+
+        /**
+         * Translates and formats text using the locale initialized by this library.
+         * @param trans The translation function.
+         * @param args Format arguments.
+         * @return The string generated by translating the format string, then applying the arguments.
+         */
+        template <typename... TArgs>
+        std::string format_common(std::function<std::string(const std::string&)>&& trans, TArgs... args)
+        {
+            // Create and apply formatter here, as we want to guarantee the lifetime of the arguments.
+            // boost::locale::format doesn't make copies, and a common gotcha is using temporary arguments
+            // to build up the formatter.
+            // Technique for the one-liner explained at http://florianjw.de/en/variadic_templates.html.
+            static const std::string domain{PROJECT_NAME};
+#ifdef LEATHERMAN_I18N
+            boost::locale::format form{trans(domain)};
+            (void) std::initializer_list<int>{ ((void)(form % args), 0)... };
+            return form.str(get_locale("", domain));
+#else
+            // When locales are disabled, use boost::format, which expects %N% style formatting
+            static const boost::regex match{"\\{(\\d+)\\}"};
+            static const std::string repl{"%\\1%"};
+            boost::format form{boost::regex_replace(trans(domain), match, repl)};
+            (void) std::initializer_list<int>{ ((void)(form % args), 0)... };
+            return form.str();
+#endif
+        }
+    }
+
+    /**
+     * Translates and formats text using the locale initialized by this library.
+     * Use the default domain, i.e. PROJECT_NAME.
+     * Replaces the use of boost::format with a variadic function call.
+     * Specialized to the PROJECT_NAME domain.
+     * @param fmt The format string.
+     * @param args Format arguments.
+     * @return The string generated by translating the format string, then applying the arguments.
+     */
+    template <typename... TArgs>
+    std::string format(std::string const& fmt, TArgs... args)
+    {
+        auto trans = [&fmt](const std::string& domain) {return translate(fmt, domain);};
+        return format_common(std::move(trans), std::forward<TArgs>(args)...);
+    }
+
+    /**
+     * Translates and formats text using the locale initialized by this library
+     * Alias for format(...); Convenience function for adding i18n support.
+     * @param fmt The format string.
+     * @param args Format arguments.
+     * @return The string generated by translating the format string, then applying the arguments.
+     */
+    template<typename... TArgs>
+    inline std::string _(std::string const& fmt, TArgs&&... args)
+    {
+        return format(std::forward<decltype(fmt)>(fmt), std::forward<TArgs>(args)...);
+    }
+
+    /**
+     * Translates and formats text in a given context using the locale initialized by this library.
+     * Use the default domain, i.e. PROJECT_NAME.
+     * Replaces the use of boost::format with a variadic function call.
+     * Specialized to the PROJECT_NAME domain.
+     * @param context The context string.
+     * @param fmt The format string.
+     * @param args Format arguments.
+     * @return The string generated by translating the format string, then applying the arguments.
+     */
+    template <typename... TArgs>
+    std::string format_p(std::string const& context, std::string const& fmt, TArgs... args)
+    {
+        auto trans = [&context, &fmt](const std::string& domain) {return translate_p(context, fmt, domain);};
+        return format_common(std::move(trans), std::forward<TArgs>(args)...);
+    }
+
+    /**
+     * Translates and formats text using the locale initialized by this library
+     * Alias for format_p(...); Convenience function for adding i18n support.
+     * @param context The context string.
+     * @param fmt The format string.
+     * @param args Format arguments.
+     * @return The string generated by translating the format string, then applying the arguments.
+     */
+    template<typename... TArgs>
+    inline std::string p_(std::string const& context, std::string const& fmt, TArgs&&... args)
+    {
+        return format_p(std::forward<decltype(context)>(context), std::forward<decltype(fmt)>(fmt), std::forward<TArgs>(args)...);
+    }
+
+    /**
+     * Translates and formats plural text using the locale initialized by this library.
+     * Use the default domain, i.e. PROJECT_NAME.
+     * Replaces the use of boost::format with a variadic function call.
+     * Specialized to the PROJECT_NAME domain.
+     * @param single The singular format string.
+     * @param plural The plural format string.
+     * @param n Number of items, used to choose singular or plural.
+     * @param args Format arguments.
+     * @return The string generated by translating the format string, then applying the arguments.
+     */
+    template <typename... TArgs>
+    std::string format_n(std::string const& single, std::string const& plural, int n, TArgs... args)
+    {
+        auto trans = [&single, &plural, n](const std::string& domain) {return translate_n(single, plural, n, domain);};
+        return format_common(std::move(trans), std::forward<TArgs>(args)...);
+    }
+
+    /**
+     * Translates and formats plural text using the locale initialized by this library.
+     * Alias for format_n(...); Convenience function for adding i18n support.
+     * @param single The singular format string.
+     * @param plural The plural format string.
+     * @param n Number of items, used to choose singular or plural.
+     * @param args Format arguments.
+     * @return The string generated by translating the format string, then applying the arguments.
+     */
+    template<typename... TArgs>
+    inline std::string n_(std::string const& single, std::string const& plural, int n, TArgs&&... args)
+    {
+        return format_n(std::forward<decltype(single)>(single), std::forward<decltype(plural)>(plural), std::forward<decltype(n)>(n), std::forward<TArgs>(args)...);
+    }
+
+    /**
+     * Translates and formats plural text in a given context using the locale initialized by this library.
+     * Replaces the use of boost::format with a variadic function call.
+     * Use the default domain, i.e. PROJECT_NAME.
+     * Specialized to the PROJECT_NAME domain.
+     * @param context The context string.
+     * @param single The singular format string.
+     * @param plural The plural format string.
+     * @param n Number of items, used to choose singular or plural.
+     * @param args Format arguments.
+     * @return The string generated by translating the format string, then applying the arguments.
+     */
+    template <typename... TArgs>
+    std::string format_np(std::string const& context, std::string const& single, std::string const& plural, int n, TArgs... args)
+    {
+        auto trans = [&context, &single, &plural, n](const std::string& domain) {return translate_np(context, single, plural, n, domain);};
+        return format_common(std::move(trans), std::forward<TArgs>(args)...);
+    }
+
+    /**
+     * Translates and formats plural text in a given context using the locale initialized by this library.
+     * Alias for format_np(...); Convenience function for adding i18n support.
+     * @param context The context string.
+     * @param single The singular format string.
+     * @param plural The plural format string.
+     * @param n Number of items, used to choose singular or plural.
+     * @param args Format arguments.
+     * @return The string generated by translating the format string, then applying the arguments.
+     */
+    template<typename... TArgs>
+    inline std::string np_(std::string const& context, std::string const& single, std::string const& plural, int n, TArgs&&... args)
+    {
+        return format_np(std::forward<decltype(context)>(context), std::forward<decltype(single)>(single), std::forward<decltype(plural)>(plural), std::forward<decltype(n)>(n), std::forward<TArgs>(args)...);
+    }
+}}  // namespace leatherman::locale

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

@@ -0,0 +1,6 @@
+if (LEATHERMAN_TOPLEVEL)
+    gettext_templates(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/../tests/locale.cc)
+endif()
+gettext_compile(${CMAKE_CURRENT_SOURCE_DIR} share/locale)
+SET_DIRECTORY_PROPERTIES(PROPERTIES CLEAN_NO_CUSTOM TRUE)
+

data/ext/facter/leatherman/locale/locales/fr.po

@@ -0,0 +1,40 @@
+# French translations for leatherman_locale package.
+# Copyright (C) 2016 Puppet <docs@puppet.com>
+# This file is distributed under the same license as the leatherman_locale package.
+# Automatically generated, 2016.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: leatherman_locale \n"
+"Report-Msgid-Bugs-To: docs@puppet.com\n"
+"POT-Creation-Date: \n"
+"PO-Revision-Date: \n"
+"Last-Translator: Automatically generated\n"
+"Language-Team: none\n"
+"Language: fr\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=2; plural=(n > 1);\n"
+
+#: locale/locales/../tests/locale.cc
+msgid "requesting {1,number}."
+msgstr "demande {1,number}."
+
+#: locale/locales/../tests/locale.cc
+msgctxt "foo"
+msgid "requesting {1,number}."
+msgstr "demandé {1,number}."
+
+#: locale/locales/../tests/locale.cc
+msgid "requesting {1,number} item."
+msgid_plural "requesting {1,number} items."
+msgstr[0] "demande {1,number} objet."
+msgstr[1] "demande {1,number} objets."
+
+#: locale/locales/../tests/locale.cc
+msgctxt "foo"
+msgid "requesting {1,number} item."
+msgid_plural "requesting {1,number} items."
+msgstr[0] "demandé {1,number} objet."
+msgstr[1] "demandé {1,number} objets."

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

@@ -0,0 +1,41 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR Puppet <docs@puppet.com>
+# This file is distributed under the same license as the leatherman_locale package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: leatherman_locale \n"
+"Report-Msgid-Bugs-To: docs@puppet.com\n"
+"POT-Creation-Date: \n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"Language: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=INTEGER; plural=EXPRESSION;\n"
+
+#: locale/locales/../tests/locale.cc
+msgid "requesting {1,number}."
+msgstr ""
+
+#: locale/locales/../tests/locale.cc
+msgctxt "foo"
+msgid "requesting {1,number}."
+msgstr ""
+
+#: locale/locales/../tests/locale.cc
+msgid "requesting {1,number} item."
+msgid_plural "requesting {1,number} items."
+msgstr[0] ""
+msgstr[1] ""
+
+#: locale/locales/../tests/locale.cc
+msgctxt "foo"
+msgid "requesting {1,number} item."
+msgid_plural "requesting {1,number} items."
+msgstr[0] ""
+msgstr[1] ""

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

@@ -0,0 +1,95 @@
+#include <leatherman/locale/locale.hpp>
+#include <leatherman/util/environment.hpp>
+#include <map>
+
+// boost includes are not always warning-clean. Disable warnings that
+// cause problems before including the headers, then re-enable the warnings.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#include <boost/locale.hpp>
+#pragma GCC diagnostic pop
+
+namespace leatherman { namespace locale {
+
+    using namespace std;
+    static map<string, std::locale> g_locales;
+
+    const std::locale get_locale(string const& id, string const& domain, vector<string> const& paths)
+    {
+        auto it = g_locales.find(domain);
+        if (it != g_locales.end()) {
+            return it->second;
+        }
+
+        // The system default locale is set with id == "", except on Windows boost::locale's
+        // generator uses a compatible UTF-8 equivalent. Using boost results in UTF-8 being
+        // the default on all platforms.
+        boost::locale::generator gen;
+
+        if (!domain.empty()) {
+            // Setup so we can find installed locales. Expects a default path unless
+            // an environment variable is specified.
+#ifdef LEATHERMAN_LOCALE_VAR
+            string locale_path;
+            if (util::environment::get(LEATHERMAN_LOCALE_VAR, locale_path)) {
+                gen.add_messages_path(locale_path+'/'+LEATHERMAN_LOCALE_INSTALL);
+            }
+#else
+            gen.add_messages_path(LEATHERMAN_LOCALE_INSTALL);
+#endif
+            for (auto& path : paths) {
+                gen.add_messages_path(path);
+            }
+            gen.add_messages_domain(domain);
+        }
+
+        // Ensure creating and adding a new locale is thread-safe.
+        try {
+            return g_locales.insert(make_pair(domain, gen(id))).first->second;
+        } catch(boost::locale::conv::conversion_error &e) {
+            return g_locales.insert(make_pair(domain, std::locale())).first->second;
+        }
+    }
+
+    void clear_domain(string const& domain)
+    {
+        g_locales.erase(domain);
+    }
+
+    string translate(string const& msg, string const& domain)
+    {
+        try {
+            return boost::locale::translate(msg).str(get_locale("", domain));
+        } catch (exception const&) {
+            return msg;
+        }
+    }
+
+    string translate_p(string const& context, string const& msg, string const& domain)
+    {
+        try {
+            return boost::locale::translate(context, msg).str(get_locale("", domain));
+        } catch (exception const&) {
+            return msg;
+        }
+    }
+
+    string translate_n(string const& single, string const& plural, int n, string const& domain)
+    {
+        try {
+            return boost::locale::translate(single, plural, n).str(get_locale("", domain));
+        } catch (exception const&) {
+            return n == 1 ? single : plural;
+        }
+    }
+
+    string translate_np(string const& context, string const& single, string const& plural, int n, string const& domain)
+    {
+        try {
+            return boost::locale::translate(context, single, plural, n).str(get_locale("", domain));
+        } catch (exception const&) {
+            return n == 1 ? single : plural;
+        }
+    }
+
+}}  // namespace leatherman::locale