RubyGems - facter - Versions diffs - 3.12.2.cfacter.20181217 → 4.0.7.pre - Mend

facter 3.12.2.cfacter.20181217 → 4.0.7.pre

Files changed (1564) hide show

data/ext/facter/facter/lib/src/ruby/aggregate_resolution.cc DELETED

@@ -1,249 +0,0 @@
-#include <internal/ruby/aggregate_resolution.hpp>
-#include <internal/ruby/chunk.hpp>
-#include <leatherman/locale/locale.hpp>
-// Mark string for translation (alias for leatherman::locale::format)
-using leatherman::locale::_;
-using namespace std;
-using namespace leatherman::ruby;
-namespace facter { namespace ruby {
-    aggregate_resolution::aggregate_resolution()
-    {
-        auto const& ruby = api::instance();
-        _self = ruby.nil_value();
-        _block = ruby.nil_value();
-    }
-    VALUE aggregate_resolution::define()
-    {
-        auto const& ruby = api::instance();
-        // Define the Resolution class
-        VALUE klass = ruby.rb_define_class_under(ruby.lookup({"Facter", "Core"}), "Aggregate", *ruby.rb_cObject);
-        ruby.rb_define_alloc_func(klass, alloc);
-        ruby.rb_define_method(klass, "chunk", RUBY_METHOD_FUNC(ruby_chunk), -1);
-        ruby.rb_define_method(klass, "aggregate", RUBY_METHOD_FUNC(ruby_aggregate), 0);
-        resolution::define(klass);
-        return klass;
-    }
-    VALUE aggregate_resolution::create()
-    {
-        auto const& ruby = api::instance();
-        return ruby.rb_class_new_instance(0, nullptr, ruby.lookup({"Facter", "Core", "Aggregate"}));
-    }
-    VALUE aggregate_resolution::value()
-    {
-        auto const& ruby = api::instance();
-        // If given an aggregate block, build a hash and call the block
-        if (!ruby.is_nil(_block)) {
-            volatile VALUE result = ruby.rb_hash_new();
-            for (auto& chunk : _chunks) {
-                ruby.rb_hash_aset(
-                    result,
-                    chunk.first,
-                    chunk.second.value(*this));
-            }
-            return ruby.rb_funcall(_block, ruby.rb_intern("call"), 1, result);
-        }
-        // Otherwise perform a default aggregation by doing a deep merge
-        volatile VALUE merged = ruby.nil_value();
-        for (auto& chunk : _chunks) {
-            volatile VALUE value = chunk.second.value(*this);
-            if (ruby.is_nil(merged)) {
-                merged = value;
-                continue;
-            }
-            merged = deep_merge(ruby, merged, value);
-        }
-        return merged;
-    }
-    VALUE aggregate_resolution::find_chunk(VALUE name)
-    {
-        auto const& ruby = api::instance();
-        if (ruby.is_nil(name)) {
-            return ruby.nil_value();
-        }
-        if (!ruby.is_symbol(name)) {
-            ruby.rb_raise(*ruby.rb_eTypeError, _("expected chunk name to be a Symbol").c_str());
-        }
-        auto it = _chunks.find(name);
-        if (it == _chunks.end()) {
-            return ruby.nil_value();
-        }
-        return it->second.value(*this);
-    }
-    void aggregate_resolution::define_chunk(VALUE name, VALUE options)
-    {
-        auto const& ruby = api::instance();
-        // A block is required
-        if (!ruby.rb_block_given_p()) {
-            ruby.rb_raise(*ruby.rb_eArgError, _("a block must be provided").c_str());
-        }
-        if (!ruby.is_symbol(name)) {
-            ruby.rb_raise(*ruby.rb_eTypeError, _("expected chunk name to be a Symbol").c_str());
-        }
-        volatile VALUE dependencies = ruby.nil_value();
-        volatile VALUE block = ruby.rb_block_proc();
-        if (!ruby.is_nil(options))
-        {
-            ID require_id = ruby.rb_intern("require");
-            ruby.hash_for_each(options, [&](VALUE key, VALUE value) {
-                if (!ruby.is_symbol(key)) {
-                    ruby.rb_raise(*ruby.rb_eTypeError, _("expected a Symbol for options key").c_str());
-                }
-                ID key_id = ruby.rb_to_id(key);
-                if (key_id == require_id) {
-                    if (ruby.is_array((value))) {
-                        ruby.array_for_each(value, [&](VALUE element) {
-                            if (!ruby.is_symbol(element)) {
-                                ruby.rb_raise(*ruby.rb_eTypeError, _("expected a Symbol or Array of Symbol for require option").c_str());
-                            }
-                            return true;
-                        });
-                    } else if (!ruby.is_symbol(value)) {
-                        ruby.rb_raise(*ruby.rb_eTypeError, _("expected a Symbol or Array of Symbol for require option").c_str());
-                    }
-                    dependencies = value;
-                } else {
-                    ruby.rb_raise(*ruby.rb_eArgError, _("unexpected option {1}", ruby.rb_id2name(key_id)).c_str());
-                }
-                return true;
-            });
-        }
-        auto it = _chunks.find(name);
-        if (it == _chunks.end()) {
-            it = _chunks.emplace(make_pair(name, ruby::chunk(dependencies, block))).first;
-        }
-        it->second.dependencies(dependencies);
-        it->second.block(block);
-    }
-    VALUE aggregate_resolution::alloc(VALUE klass)
-    {
-        auto const& ruby = api::instance();
-        // Create a resolution and wrap with a Ruby data object
-        unique_ptr<aggregate_resolution> r(new aggregate_resolution());
-        VALUE self = r->_self = ruby.rb_data_object_alloc(klass, r.get(), mark, free);
-        ruby.register_data_object(self);
-        // Release the smart pointer; ownership is now with Ruby's GC
-        r.release();
-        return self;
-    }
-    void aggregate_resolution::mark(void* data)
-    {
-        // Mark all VALUEs contained in the aggregate resolution
-        auto const& ruby = api::instance();
-        auto instance = reinterpret_cast<aggregate_resolution*>(data);
-        // Mark the base first
-        instance->resolution::mark();
-        // Mark the aggregate block
-        ruby.rb_gc_mark(instance->_block);
-        // Mark the chunks
-        for (auto& kvp : instance->_chunks) {
-            ruby.rb_gc_mark(kvp.first);
-            kvp.second.mark();
-        }
-    }
-    void aggregate_resolution::free(void* data)
-    {
-        auto instance = reinterpret_cast<aggregate_resolution*>(data);
-        // Unregister the data object
-        auto const& ruby = api::instance();
-        ruby.unregister_data_object(instance->_self);
-        // Delete the aggregate resolution
-        delete instance;
-    }
-    VALUE aggregate_resolution::ruby_chunk(int argc, VALUE* argv, VALUE self)
-    {
-        auto const& ruby = api::instance();
-        if (argc == 0 || argc > 2) {
-            ruby.rb_raise(*ruby.rb_eArgError, _("wrong number of arguments ({1} for 2)", argc).c_str());
-        }
-        ruby.to_native<aggregate_resolution>(self)->define_chunk(argv[0], argc > 1 ? argv[1] : ruby.nil_value());
-        return self;
-    }
-    VALUE aggregate_resolution::ruby_aggregate(VALUE self)
-    {
-        auto const& ruby = api::instance();
-        // A block is required
-        if (!ruby.rb_block_given_p()) {
-            ruby.rb_raise(*ruby.rb_eArgError, _("a block must be provided").c_str());
-        }
-        ruby.to_native<aggregate_resolution>(self)->_block = ruby.rb_block_proc();
-        return self;
-    }
-    VALUE aggregate_resolution::ruby_merge_hashes(VALUE obj, VALUE context, int argc, VALUE argv[])
-    {
-        api const* ruby = reinterpret_cast<api const*>(context);
-        if (argc != 3) {
-            ruby->rb_raise(*ruby->rb_eArgError, _("wrong number of arguments ({1} for 3)", argc).c_str());
-        }
-        // Recurse on left and right
-        return deep_merge(*ruby, argv[1], argv[2]);
-    }
-    VALUE aggregate_resolution::deep_merge(api const& ruby, VALUE left, VALUE right)
-    {
-        volatile VALUE result = ruby.nil_value();
-        if (ruby.is_hash(left) && ruby.is_hash(right)) {
-            result = ruby.rb_block_call(left, ruby.rb_intern("merge"), 1, &right, RUBY_METHOD_FUNC(ruby_merge_hashes), reinterpret_cast<VALUE>(&ruby));
-        } else if (ruby.is_array(left) && ruby.is_array(right)) {
-            result = ruby.rb_funcall(left, ruby.rb_intern("+"), 1, right);
-        } else if (ruby.is_nil(right)) {
-            result = left;
-        } else if (ruby.is_nil(left)) {
-            result = right;
-        } else if (ruby.is_nil(left) && ruby.is_nil(right)) {
-            result = ruby.nil_value();
-        } else {
-            // Let the user know we couldn't merge the chunks
-            volatile VALUE inspect_left = ruby.rb_funcall(left, ruby.rb_intern("inspect"), 0);
-            volatile VALUE inspect_right = ruby.rb_funcall(right, ruby.rb_intern("inspect"), 0);
-            volatile VALUE class_left = ruby.rb_funcall(ruby.rb_funcall(left, ruby.rb_intern("class"), 0), ruby.rb_intern("to_s"), 0);
-            volatile VALUE class_right = ruby.rb_funcall(ruby.rb_funcall(right, ruby.rb_intern("class"), 0), ruby.rb_intern("to_s"), 0);
-            ruby.rb_raise(*ruby.rb_eRuntimeError, _("cannot merge {1}:{2} and {3}:{4}",
-                    ruby.rb_string_value_ptr(&inspect_left),
-                    ruby.rb_string_value_ptr(&class_left),
-                    ruby.rb_string_value_ptr(&inspect_right),
-                    ruby.rb_string_value_ptr(&class_right)).c_str());
-        }
-        return result;
-    }
-}}  // namespace facter::ruby

data/ext/facter/facter/lib/src/ruby/chunk.cc DELETED

@@ -1,136 +0,0 @@
-#include <internal/ruby/chunk.hpp>
-#include <internal/ruby/aggregate_resolution.hpp>
-#include <leatherman/locale/locale.hpp>
-// Mark string for translation (alias for leatherman::locale::format)
-using leatherman::locale::_;
-using namespace std;
-using namespace leatherman::ruby;
-namespace facter { namespace ruby {
-    chunk::chunk(VALUE dependencies, VALUE block) :
-        _dependencies(dependencies),
-        _block(block),
-        _resolved(false),
-        _resolving(false)
-    {
-        auto const& ruby = api::instance();
-        _value = ruby.nil_value();
-    }
-    chunk::chunk(chunk&& other)
-    {
-        *this = move(other);
-    }
-    chunk& chunk::operator=(chunk&& other)
-    {
-        _dependencies = other._dependencies;
-        _block = other._block;
-        _value = other._value;
-        _resolved = other._resolved;
-        _resolving = other._resolving;
-        return *this;
-    }
-    VALUE chunk::value(aggregate_resolution& resolution)
-    {
-        auto const& ruby = api::instance();
-        // Prevent cycles by raising an exception
-        if (_resolving) {
-            ruby.rb_raise(*ruby.rb_eRuntimeError, _("chunk dependency cycle detected").c_str());
-        }
-        if (_resolved) {
-            return _value;
-        }
-        _resolving = true;
-        volatile VALUE value = ruby.nil_value();
-        int tag = 0;
-        {
-            // Declare all C++ objects here
-            vector<VALUE> values;
-            value = ruby.protect(tag, [&]{
-                // Do not declare any C++ objects inside the protect
-                // Their destructors will not be invoked if there is a Ruby exception
-                if (ruby.is_symbol(_dependencies)) {
-                    values.push_back(resolution.find_chunk(_dependencies));
-                    ruby.rb_gc_register_address(&values[0]);
-                } else if (ruby.is_array(_dependencies)) {
-                    // Resize the vector now to ensure it is fully allocated before registering with GC
-                    values.resize(ruby.num2size_t(ruby.rb_funcall(_dependencies, ruby.rb_intern("size"), 0)), ruby.nil_value());
-                    for (auto& v : values) {
-                        ruby.rb_gc_register_address(&v);
-                    }
-                    int i = 0;
-                    ruby.array_for_each(_dependencies, [&](VALUE element) {
-                        values[i++] = resolution.find_chunk(element);
-                        return true;
-                    });
-                }
-                // Call the block to get this chunk's value
-                return ruby.rb_funcallv(_block, ruby.rb_intern("call"), values.size(), values.data());
-            });
-            // Unregister all the values from the GC
-            for (auto& v : values) {
-                ruby.rb_gc_unregister_address(&v);
-            }
-        }
-        _resolving = false;
-        if (!tag) {
-            _value = value;
-            _resolved = true;
-            return _value;
-        }
-        // Now that the above block has exited, it's safe to jump to the given tag
-        ruby.rb_jump_tag(tag);
-        return ruby.nil_value();
-    }
-    VALUE chunk::dependencies() const
-    {
-        return _dependencies;
-    }
-    void chunk::dependencies(VALUE dependencies)
-    {
-        auto const& ruby = api::instance();
-        _dependencies = dependencies;
-        _value = ruby.nil_value();
-        _resolved = false;
-    }
-    VALUE chunk::block() const
-    {
-        return _block;
-    }
-    void chunk::block(VALUE block)
-    {
-        auto const& ruby = api::instance();
-        _block = block;
-        _value = ruby.nil_value();
-        _resolved = false;
-    }
-    void chunk::mark() const
-    {
-        auto const& ruby = api::instance();
-        ruby.rb_gc_mark(_dependencies);
-        ruby.rb_gc_mark(_block);
-        ruby.rb_gc_mark(_value);
-    }
-}}  // namespace facter::ruby

data/ext/facter/facter/lib/src/ruby/confine.cc DELETED

@@ -1,84 +0,0 @@
-#include <internal/ruby/confine.hpp>
-#include <internal/ruby/module.hpp>
-#include <algorithm>
-using namespace std;
-using namespace leatherman::ruby;
-namespace facter { namespace ruby {
-    confine::confine(VALUE fact, VALUE expected, VALUE block) :
-        _fact(fact),
-        _expected(expected),
-        _block(block)
-    {
-    }
-    confine::confine(confine&& other)
-    {
-        *this = move(other);
-    }
-    confine& confine::operator=(confine&& other)
-    {
-        _fact = other._fact;
-        _expected = other._expected;
-        _block = other._block;
-        return *this;
-    }
-    bool confine::suitable(module& facter) const
-    {
-        auto const& ruby = api::instance();
-        // If given a fact, either call the block or check the values
-        if (!ruby.is_nil(_fact)) {
-            // Rather than calling facter.fact_value, we call through the Ruby API to get the fact value the same way Ruby Facter did
-            // This enables users to alter the behavior of confines during testing, like this:
-            // Facter.fact(:name).expects(:value).returns 'overrride'
-            volatile VALUE fact = ruby.rb_funcall(facter.self(), ruby.rb_intern("fact"), 1, _fact);
-            if (ruby.is_nil(fact)) {
-                return false;
-            }
-            // Get the value of the fact
-            volatile VALUE value = facter.normalize(ruby.rb_funcall(fact, ruby.rb_intern("value"), 0));
-            if (ruby.is_nil(value)) {
-                return false;
-            }
-            // Pass the value to the block if given one
-            if (!ruby.is_nil(_block)) {
-                volatile VALUE result = ruby.rb_funcall(_block, ruby.rb_intern("call"), 1, value);
-                return !ruby.is_nil(result) && !ruby.is_false(result);
-            }
-            // Otherwise, if it's an array, search for the value
-            if (ruby.is_array(_expected)) {
-                bool found = false;
-                ruby.array_for_each(_expected, [&](VALUE expected_value) {
-                    expected_value = facter.normalize(expected_value);
-                    found = ruby.equals(facter.normalize(expected_value), value);
-                    return !found;
-                });
-                return found;
-            }
-            // Compare the value directly
-            return ruby.case_equals(facter.normalize(_expected), value);
-        }
-        // If we have only a block, execute it
-        if (!ruby.is_nil(_block)) {
-            volatile VALUE result = ruby.rb_funcall(_block, ruby.rb_intern("call"), 0);
-            return !ruby.is_nil(result) && !ruby.is_false(result);
-        }
-        return false;
-    }
-    void confine::mark() const
-    {
-        // Mark all VALUEs contained in the confine
-        auto const& ruby = api::instance();
-        ruby.rb_gc_mark(_fact);
-        ruby.rb_gc_mark(_expected);
-        ruby.rb_gc_mark(_block);
-    }
-}}  // namespace facter::ruby