clipsruby 0.0.20 → 0.0.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed56e2c48e4ab0971ac56242518c127aa04368c3e2d6d1102f734ce577d89a54
-  data.tar.gz: ca7df6a8e9eb6711ed51b14e3db1ee799e887fe0d5b90755705b14672c57bd57
+  metadata.gz: 4f7a174c8ca0889553334a3a6ad54580624d7d92695e3483aa44a130627b3fcb
+  data.tar.gz: a31141c4ce2490c74218316c89d08342dab315d5c35016c8dd488c2a344f8ae7
 SHA512:
-  metadata.gz: 2017fc2246a1869a5971e3cd6c9471e8903c1435e71cb0735c729d2e3165be97a6bc6d48373a2b9e4b3d1343854a5ebd681a70934b81a78c7a8654c65db9bbfd
-  data.tar.gz: 59734c2c151c11125d8c114f9aaae1b62f869969e272f3b97de7d37ba1c908b577c091fffe000c161484d5536795f20eab66f19cf53842c90bb969c58aa266cb
+  metadata.gz: 863a626437f0c4583e0f35618b4fd29c461b579833970e08999202dc35c2ac306a61b5eb3d029551187c7791d7b7fb22cb3d400d4106dea3c30eb1f1eccd7e73
+  data.tar.gz: aa4858ed68e383ff113accafb0f4652d4453448e93e6ecfa5c55a5903263925ae4ed114401158cb8d08b291a85eaf82891df0020a0b8f74cd9fbabdb228f4cec

data/README.md

@@ -162,7 +162,7 @@ A light wrapper around the CLIPS find-fact function. Accepts a fact set template
 returns the first Facts in the environment that match as Ruby objects.
 
 ```ruby
-CLIPS::Environment.find_facts(env, "(?f my_deftemplate)")
+CLIPS::Environment.find_fact(env, "(?f my_deftemplate)")
 env.find_fact("(?f my_deftemplate)")
 CLIPS::Environment.find_fact(env, "(?f my_deftemplate)", "(eq ?f:b \"asdf\")")
 env.find_fact("(?f my_deftemplate)", "(= ?f:a 1)")
@@ -302,6 +302,16 @@ CLIPS::Environment.set_current_module(env, defmodule)
 env.set_current_module(defmodule)
 ```
 
+### `CLIPS::Environment::Fact.pp_form`
+### `CLIPS::Environment::Fact#pp_form`
+
+Returns a pretty printed string representation of the Fact
+
+```ruby
+CLIPS::Environment::Fact.pp_form(fact)
+fact.pp_form
+```
+
 ### `CLIPS::Environment::Fact.to_h`
 ### `CLIPS::Environment::Fact#to_h`
 
@@ -322,6 +332,16 @@ CLIPS::Environment::Fact.index(fact)
 fact.index
 ```
 
+### `CLIPS::Environment::Fact.deftemplate`
+### `CLIPS::Environment::Fact#deftemplate`
+
+Returns the Deftemplate object for a fact
+
+```ruby
+CLIPS::Environment::Fact.deftemplate(fact)
+fact.deftemplate
+```
+
 ### `CLIPS::Environment::Fact.deftemplate_name`
 ### `CLIPS::Environment::Fact#deftemplate_name`
 
@@ -494,6 +514,77 @@ CLIPS::Environment::Defmodule.get_fact_list(defmodule)
 defmodule.get_fact_list
 ```
 
+### `CLIPS::Environment.find_deftemplate`
+### `CLIPS::Environment#find_deftemplate`
+
+Finds a deftemplate by name and returns a CLIPS::Environment::Deftemplate object
+
+```ruby
+CLIPS::Environment.find_deftemplate(:a)
+env.find_deftemplate("foo")
+```
+
+### `CLIPS::Environment::Deftemplate.name`
+### `CLIPS::Environment::Deftemplate#name`
+
+Returns the name of a deftemplate as a symbol
+
+```ruby
+CLIPS::Environment::Deftemplate.name(deftemplate)
+deftemplate.name
+```
+
+### `CLIPS::Environment::Deftemplate.pp_form`
+### `CLIPS::Environment::Deftemplate#pp_form`
+
+Returns a pretty printed string representation of the Deftemplate
+
+```ruby
+CLIPS::Environment::Deftemplate.pp_form(deftemplate)
+deftemplate.pp_form
+```
+
+### `CLIPS::Environment::Deftemplate.assert_hash`
+### `CLIPS::Environment::Deftemplate#assert_hash`
+
+Asserts a hash in the clips environment that a Deftemplate is defined in.
+Returns the Fact object that was just asserted
+
+```ruby
+CLIPS::Environment::Deftemplate.assert_hash(deftemplate, foo: :bar)
+deftemplate.assert_hash(foo: :bar)
+```
+
+### `CLIPS::Environment.find_deffacts`
+### `CLIPS::Environment#find_deffacts`
+
+Finds a deffacts by name and returns a CLIPS::Environment::Deffacts object
+
+```ruby
+CLIPS::Environment.find_deffacts(:a)
+env.find_deffacts("foo")
+```
+
+### `CLIPS::Environment::Deffacts.name`
+### `CLIPS::Environment::Deffacts#name`
+
+Returns the name of a deffacts as a symbol
+
+```ruby
+CLIPS::Environment::Deffacts.name(deffacts)
+deffacts.name
+```
+
+### `CLIPS::Environment::Deffacts.pp_form`
+### `CLIPS::Environment::Deffacts#pp_form`
+
+Returns a pretty printed string representation of the Deffacts
+
+```ruby
+CLIPS::Environment::Deffacts.pp_form(deffacts)
+deffacts.pp_form
+```
+
 ## Running the tests
 
 Simply do `rake compile` and then `rake test` in order to run the tests.

data/ext/clipsruby/clipsruby.c

@@ -1,6 +1,18 @@
 #include "clips.h"
 #include "ruby.h"
 
+size_t deffacts_size(const void *data)
+{
+	return sizeof(Deffacts);
+}
+
+static const rb_data_type_t Deffacts_type = {
+	.function = {
+		.dsize = deffacts_size
+	},
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
 size_t deftemplate_size(const void *data)
 {
 	return sizeof(Deftemplate);
@@ -50,6 +62,26 @@ static const rb_data_type_t Fact_type = {
 	.flags = RUBY_TYPED_FREE_IMMEDIATELY
 };
 
+static VALUE clips_environment_fact_deftemplate(VALUE self)
+{
+	VALUE rbDeftemplate, rbEnvironment;
+	Fact *fact;
+	Deftemplate *template;
+
+	TypedData_Get_Struct(self, Fact, &Fact_type, fact);
+
+	template = FactDeftemplate(fact);
+	rbEnvironment = rb_iv_get(self, "@environment");
+	rbDeftemplate = TypedData_Wrap_Struct(rb_const_get(rb_obj_class(rbEnvironment), rb_intern("Deftemplate")), &Deftemplate_type, template);
+	rb_iv_set(rbDeftemplate, "@environment", rbEnvironment);
+	return rbDeftemplate;
+}
+
+static VALUE clips_environment_fact_static_deftemplate(VALUE self, VALUE rbFact)
+{
+	return clips_environment_fact_deftemplate(rbFact);
+}
+
 static VALUE clips_environment_fact_deftemplate_name(VALUE self)
 {
 	Fact *fact;
@@ -103,6 +135,11 @@ VALUE defmodule_alloc(VALUE self)
 	return TypedData_Wrap_Struct(self, &Defmodule_type, NULL);
 }
 
+VALUE deffacts_alloc(VALUE self)
+{
+	return TypedData_Wrap_Struct(self, &Deffacts_type, NULL);
+}
+
 VALUE deftemplate_alloc(VALUE self)
 {
 	return TypedData_Wrap_Struct(self, &Deftemplate_type, NULL);
@@ -391,6 +428,64 @@ static VALUE clips_environment_static_assert_hash(VALUE self, VALUE environment,
 	return clips_environment_assert_hash(environment, deftemplate_name, hash);
 }
 
+static VALUE clips_environment_deftemplate_assert_hash(VALUE self, VALUE hash)
+{
+	const char *cdeftemplate_name;
+
+	Environment *env;
+	Deftemplate *template;
+
+	VALUE rbEnvironment = rb_iv_get(self, "@environment");
+	TypedData_Get_Struct(self, Deftemplate, &Deftemplate_type, template);
+	TypedData_Get_Struct(rbEnvironment, Environment, &Environment_type, env);
+
+	cdeftemplate_name = DeftemplateName(template);
+
+	FactBuilder *fb = CreateFactBuilder(env, cdeftemplate_name);
+	switch (FBError(env))
+	{
+		case FBE_NO_ERROR:
+			break;
+		case FBE_DEFTEMPLATE_NOT_FOUND_ERROR:
+			rb_warn("Could not assert fact; deftemplate not found!");
+			return Qnil;
+		case FBE_IMPLIED_DEFTEMPLATE_ERROR:
+			rb_warn("Could not assert fact; cannot use assert_hash to create non-deftemplated facts!");
+			return Qnil;
+	}
+	void *args[2] = { (void *)fb, (void *)env };
+	rb_hash_foreach(hash, _clips_environment_assert_hash, (VALUE)args);
+	Fact *fact = FBAssert(fb);
+	FBDispose(fb);
+
+	switch (FBError(env))
+	{
+		case FBE_NO_ERROR:
+			break;
+		case FBE_NULL_POINTER_ERROR:
+			rb_warn("Could not assert fact. This might be a bug in clipsruby!");
+			return Qnil;
+		case FBE_COULD_NOT_ASSERT_ERROR:
+			rb_warn("Could not assert fact. Pattern matching of a fact or instance is already occurring.");
+			return Qnil;
+		case FBE_RULE_NETWORK_ERROR:
+			rb_warn("Could not assert fact. An error occurs while the assertion was being processed in the rule network.");
+			return Qnil;
+	}
+
+	VALUE rb_fact =
+		TypedData_Wrap_Struct(rb_const_get(CLASS_OF(rbEnvironment), rb_intern("Fact")), &Fact_type, fact);
+
+	rb_iv_set(rb_fact, "@environment", rbEnvironment);
+
+	return rb_fact;
+}
+
+static VALUE clips_environment_deftemplate_static_assert_hash(VALUE self, VALUE deftemplate, VALUE hash)
+{
+	return clips_environment_deftemplate_assert_hash(deftemplate, hash);
+}
+
 static void CLIPSValue_to_VALUE(CLIPSValue *from, VALUE *value, VALUE *rbEnvironment)
 {
 	Environment *env;
@@ -1255,6 +1350,65 @@ static VALUE clips_environment_static_find_defrule(VALUE self, VALUE rbEnvironme
 	return clips_environment_find_defrule(rbEnvironment, defrule_name);
 }
 
+static VALUE clips_environment_find_deffacts(VALUE self, VALUE deffacts_name)
+{
+	Environment *env;
+	Deffacts *deffacts;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	switch (TYPE(deffacts_name)) {
+		case T_STRING:
+			deffacts = FindDeffacts(env, StringValueCStr(deffacts_name));
+			break;
+		case T_SYMBOL:
+			deffacts = FindDeffacts(env, rb_id2name(SYM2ID(deffacts_name)));
+			break;
+                default:
+			rb_warn("deffacts name must be a symbol or string");
+			return Qnil;
+        }
+
+	if (deffacts == NULL) {
+		return Qnil;
+	} else {
+		return TypedData_Wrap_Struct(rb_const_get(CLASS_OF(self), rb_intern("Deffacts")), &Deffacts_type, deffacts);
+	}
+}
+
+static VALUE clips_environment_static_find_deffacts(VALUE self, VALUE rbEnvironment, VALUE deffacts_name)
+{
+	return clips_environment_find_deffacts(rbEnvironment, deffacts_name);
+}
+
+static VALUE clips_environment_deffacts_name(VALUE self)
+{
+	Deffacts *deffacts;
+
+	TypedData_Get_Struct(self, Deffacts, &Deffacts_type, deffacts);
+
+	return ID2SYM(rb_intern(DeffactsName(deffacts)));
+}
+
+static VALUE clips_environment_deffacts_static_name(VALUE self, VALUE rbDeffacts)
+{
+	return clips_environment_deffacts_name(rbDeffacts);
+}
+
+static VALUE clips_environment_deffacts_pp_form(VALUE self)
+{
+	Deffacts *deffacts;
+
+	TypedData_Get_Struct(self, Deffacts, &Deffacts_type, deffacts);
+
+	return rb_str_new2(DeffactsPPForm(deffacts));
+}
+
+static VALUE clips_environment_deffacts_static_pp_form(VALUE self, VALUE rbDeffacts)
+{
+	return clips_environment_deffacts_pp_form(rbDeffacts);
+}
+
 static VALUE clips_environment_get_current_module(VALUE self)
 {
 	Environment *env;
@@ -1392,6 +1546,58 @@ static VALUE clips_environment_deftemplate_static_pp_form(VALUE self, VALUE rbDe
 	return clips_environment_deftemplate_pp_form(rbDeftemplate);
 }
 
+static VALUE clips_environment_fact_pp_form(int argc, VALUE *argv, VALUE self)
+{
+	Fact *fact;
+	VALUE ignore_defaults, toReturn;
+	Environment *env;
+
+	TypedData_Get_Struct(self, Fact, &Fact_type, fact);
+	VALUE rbEnvironment = rb_iv_get(self, "@environment");
+	TypedData_Get_Struct(rbEnvironment, Environment, &Environment_type, env);
+	StringBuilder *sb = CreateStringBuilder(env, 0);
+
+	rb_scan_args(argc, argv, "01", &ignore_defaults);
+
+	if (ignore_defaults == Qtrue) {
+		FactPPForm(fact, sb, true);
+	} else {
+		FactPPForm(fact, sb, false);
+	}
+
+	toReturn = rb_str_new2(sb->contents);
+
+	SBDispose(sb);
+
+	return toReturn;
+}
+
+static VALUE clips_environment_fact_static_pp_form(int argc, VALUE *argv, VALUE klass)
+{
+	Fact *fact;
+	VALUE self, ignore_defaults, toReturn;
+	Environment *env;
+
+	rb_scan_args(argc, argv, "11", &self, &ignore_defaults);
+
+	TypedData_Get_Struct(self, Fact, &Fact_type, fact);
+	VALUE rbEnvironment = rb_iv_get(self, "@environment");
+	TypedData_Get_Struct(rbEnvironment, Environment, &Environment_type, env);
+	StringBuilder *sb = CreateStringBuilder(env, 0);
+
+	if (ignore_defaults == Qtrue) {
+		FactPPForm(fact, sb, true);
+	} else {
+		FactPPForm(fact, sb, false);
+	}
+
+	toReturn = rb_str_new2(sb->contents);
+
+	SBDispose(sb);
+
+	return toReturn;
+}
+
 static VALUE clips_environment_get_fact_list(int argc, VALUE *argv, VALUE rbEnvironment) {
 	VALUE defmodule_or_defmodule_name;
 	Environment *env;
@@ -1690,6 +1896,15 @@ void Init_clipsruby(void)
 	rb_define_method(rbEnvironment, "set_current_module", clips_environment_set_current_module, 1);
 	rb_define_singleton_method(rbEnvironment, "get_fact_list", clips_environment_static_get_fact_list, -1);
 	rb_define_method(rbEnvironment, "get_fact_list", clips_environment_get_fact_list, -1);
+	rb_define_singleton_method(rbEnvironment, "find_deffacts", clips_environment_static_find_deffacts, 2);
+	rb_define_method(rbEnvironment, "find_deffacts", clips_environment_find_deffacts, 1);
+
+	VALUE rbDeffacts = rb_define_class_under(rbEnvironment, "Deffacts", rb_cObject);
+	rb_define_alloc_func(rbDeffacts, deffacts_alloc);
+	rb_define_singleton_method(rbDeffacts, "name", clips_environment_deffacts_static_name, 1);
+	rb_define_method(rbDeffacts, "name", clips_environment_deffacts_name, 0);
+	rb_define_singleton_method(rbDeffacts, "pp_form", clips_environment_deffacts_static_pp_form, 1);
+	rb_define_method(rbDeffacts, "pp_form", clips_environment_deffacts_pp_form, 0);
 
 	VALUE rbDeftemplate = rb_define_class_under(rbEnvironment, "Deftemplate", rb_cObject);
 	rb_define_alloc_func(rbDeftemplate, deftemplate_alloc);
@@ -1697,6 +1912,8 @@ void Init_clipsruby(void)
 	rb_define_method(rbDeftemplate, "name", clips_environment_deftemplate_name, 0);
 	rb_define_singleton_method(rbDeftemplate, "pp_form", clips_environment_deftemplate_static_pp_form, 1);
 	rb_define_method(rbDeftemplate, "pp_form", clips_environment_deftemplate_pp_form, 0);
+	rb_define_singleton_method(rbDeftemplate, "assert_hash", clips_environment_deftemplate_static_assert_hash, 2);
+	rb_define_method(rbDeftemplate, "assert_hash", clips_environment_deftemplate_assert_hash, 1);
 
 	VALUE rbDefmodule = rb_define_class_under(rbEnvironment, "Defmodule", rb_cObject);
 	rb_define_alloc_func(rbDefmodule, defmodule_alloc);
@@ -1711,6 +1928,8 @@ void Init_clipsruby(void)
 
 	VALUE rbFact = rb_define_class_under(rbEnvironment, "Fact", rb_cObject);
 	rb_define_alloc_func(rbFact, fact_alloc);
+	rb_define_singleton_method(rbFact, "deftemplate", clips_environment_fact_static_deftemplate, 1);
+	rb_define_method(rbFact, "deftemplate", clips_environment_fact_deftemplate, 0);
 	rb_define_singleton_method(rbFact, "deftemplate_name", clips_environment_fact_static_deftemplate_name, 1);
 	rb_define_method(rbFact, "deftemplate_name", clips_environment_fact_deftemplate_name, 0);
 	rb_define_singleton_method(rbFact, "to_h", clips_environment_fact_static_to_h, 1);
@@ -1725,6 +1944,8 @@ void Init_clipsruby(void)
 	rb_define_method(rbFact, "modify", clips_environment_fact_modify, 1);
 	rb_define_singleton_method(rbFact, "index", clips_environment_fact_static_index, 1);
 	rb_define_method(rbFact, "index", clips_environment_fact_index, 0);
+	rb_define_singleton_method(rbFact, "pp_form", clips_environment_fact_static_pp_form, -1);
+	rb_define_method(rbFact, "pp_form", clips_environment_fact_pp_form, -1);
 
 	VALUE rbDefrule = rb_define_class_under(rbEnvironment, "Defrule", rb_cObject);
 	rb_define_alloc_func(rbDefrule, defrule_alloc);

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: clipsruby
 version: !ruby/object:Gem::Version
-  version: 0.0.20
+  version: 0.0.22
 platform: ruby
 authors:
 - Ryan Johnston
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-10 00:00:00.000000000 Z
+date: 2024-09-13 00:00:00.000000000 Z
 dependencies: []
 description: Calling the CLIPS programming language from within Ruby
 email: mrryanjohnston@gmail.com