clipsruby 0.0.21 → 0.0.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e26c6a3eb9602ca2ab8d3aa497b95b19d404640fa281aac5544310a01040b62
-  data.tar.gz: 56000c5e564e43d907daf53fd0476113448e0a27377b36ad41cd1a04202f1c03
+  metadata.gz: 994b076d823d294b992d1621ec327e72cd415602c744d3214b16e15b6624dcbd
+  data.tar.gz: 864a892fb3405400362b6ceeea13d24f3c22bf4508f4013b14c6f3a6dd102e4f
 SHA512:
-  metadata.gz: 8a7ec9525ec36621cba6fb7c75bb89f2406dcdb13237b478e2a98b2d9b7af202b79fae1e65779fc48b1ab89ef490a66cb68343c48144cb8d857fab3c4a1eaaf4
-  data.tar.gz: 5d45dcb799e1c829f76d5f20a41b05817f9d0a57ab7d72827b45b871a38755f9f695fd5fb9d62a1c899fe83b993a29cd42870b194a651b92461ac846d67bde04
+  metadata.gz: 0a2bbd8b165667a1a2b07b19b8099ec0dfae9ccbf4b669d469421f5db66c53840a00a0855f07479b272e030b0fb06430f28382340af1e3efe60af13858542ca4
+  data.tar.gz: 918c4ffd67a5623d761805e4f60920c4ac250e321cb33fca2f61ad26ff5ac28b4cc92acaaeaa1478e8110c3697d719a9c8e69da5da96fcda88d5b2a4d078bef0

data/README.md

@@ -332,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`
 
@@ -504,6 +514,22 @@ CLIPS::Environment::Defmodule.get_fact_list(defmodule)
 defmodule.get_fact_list
 ```
 
+### `CLIPS::Environment.get_deftemplate_list`
+### `CLIPS::Environment#get_deftemplate_list`
+
+Return an array of Deftemplate names as symbols in the environment. Pass an argument of a
+symbol, string, or Defmodule object in order to only get Deftemplates
+in that Defmodule. If you do not, it will return all Deftemplate names in all modules.
+
+```ruby
+CLIPS::Environment.get_deftemplate_list
+env.get_deftemplate_list
+CLIPS::Environment.get_deftemplate_list(:MAIN)
+env.get_deftemplate_list(:MAIN)
+CLIPS::Environment.get_deftemplate_list(defmodule)
+env.get_deftemplate_list(defmodule)
+```
+
 ### `CLIPS::Environment.find_deftemplate`
 ### `CLIPS::Environment#find_deftemplate`
 
@@ -534,6 +560,27 @@ 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::Defmodule.get_deftemplate_list`
+### `CLIPS::Environment::Defmodule#get_deftemplate_list`
+
+Return an array of Deftemplate names as symboles in the Defmodule
+
+```ruby
+CLIPS::Environment::Defmodule.get_deftemplate_list(defmodule)
+defmodule.get_deftemplate_list
+```
+
 ### `CLIPS::Environment.find_deffacts`
 ### `CLIPS::Environment#find_deffacts`
 

data/ext/clipsruby/clipsruby.c

@@ -62,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;
@@ -408,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;
@@ -1586,7 +1664,74 @@ static VALUE clips_environment_static_get_fact_list(int argc, VALUE *argv, VALUE
 	CLIPSValue_to_VALUE(&value, &out, &rbEnvironment);
 
 	return out;
+}
+
+static VALUE clips_environment_get_deftemplate_list(int argc, VALUE *argv, VALUE rbEnvironment) {
+	VALUE defmodule_or_defmodule_name;
+	Environment *env;
+	Defmodule *module;
+	CLIPSValue value;
+	VALUE out;
+
+	TypedData_Get_Struct(rbEnvironment, Environment, &Environment_type, env);
+
+	rb_scan_args(argc, argv, "01", &defmodule_or_defmodule_name);
+	switch (TYPE(defmodule_or_defmodule_name)) {
+		case T_NIL:
+			module = NULL;
+			break;
+		case T_STRING:
+		case T_SYMBOL:
+			TypedData_Get_Struct(
+				clips_environment_find_defmodule(rbEnvironment, defmodule_or_defmodule_name),
+				Defmodule, &Defmodule_type, module);
+			break;
+		case T_DATA:
+			TypedData_Get_Struct(defmodule_or_defmodule_name, Defmodule, &Defmodule_type, module);
+			break;
+                default:
+			rb_warn("defmodule name must be a symbol or string");
+			return Qnil;
+        }
+	GetDeftemplateList(env, &value, module);
+
+	CLIPSValue_to_VALUE(&value, &out, &rbEnvironment);
+
+	return out;
+}
+
+static VALUE clips_environment_static_get_deftemplate_list(int argc, VALUE *argv, VALUE klass) {
+	VALUE rbEnvironment, defmodule_or_defmodule_name;
+	Environment *env;
+	Defmodule *module;
+	CLIPSValue value;
+	VALUE out;
+
+	rb_scan_args(argc, argv, "11", &rbEnvironment, &defmodule_or_defmodule_name);
 
+	TypedData_Get_Struct(rbEnvironment, Environment, &Environment_type, env);
+	switch (TYPE(defmodule_or_defmodule_name)) {
+		case T_NIL:
+			module = NULL;
+			break;
+		case T_STRING:
+		case T_SYMBOL:
+			TypedData_Get_Struct(
+				clips_environment_find_defmodule(rbEnvironment, defmodule_or_defmodule_name),
+				Defmodule, &Defmodule_type, module);
+			break;
+		case T_DATA:
+			TypedData_Get_Struct(defmodule_or_defmodule_name, Defmodule, &Defmodule_type, module);
+			break;
+                default:
+			rb_warn("defmodule name must be a symbol or string");
+			return Qnil;
+        }
+	GetDeftemplateList(env, &value, module);
+
+	CLIPSValue_to_VALUE(&value, &out, &rbEnvironment);
+
+	return out;
 }
 
 static VALUE clips_environment_defmodule_name(VALUE self)
@@ -1661,6 +1806,30 @@ static VALUE clips_environment_defmodule_static_get_fact_list(VALUE self, VALUE
 	return clips_environment_defmodule_get_fact_list(rbDefmodule);
 }
 
+static VALUE clips_environment_defmodule_get_deftemplate_list(VALUE self)
+{
+	Defmodule *module;
+	Environment *env;
+	CLIPSValue value;
+	VALUE out;
+
+	VALUE rbEnvironment = rb_iv_get(self, "@environment");
+
+	TypedData_Get_Struct(self, Defmodule, &Defmodule_type, module);
+	TypedData_Get_Struct(rbEnvironment, Environment, &Environment_type, env);
+
+	GetDeftemplateList(env, &value, module);
+
+	CLIPSValue_to_VALUE(&value, &out, &rbEnvironment);
+
+	return out;
+}
+
+static VALUE clips_environment_defmodule_static_get_deftemplate_list(VALUE self, VALUE rbDefmodule)
+{
+	return clips_environment_defmodule_get_deftemplate_list(rbDefmodule);
+}
+
 static VALUE clips_environment_defrule_name(VALUE self)
 {
 	Defrule *defrule;
@@ -1818,6 +1987,8 @@ 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, "get_deftemplate_list", clips_environment_static_get_deftemplate_list, -1);
+	rb_define_method(rbEnvironment, "get_deftemplate_list", clips_environment_get_deftemplate_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);
 
@@ -1834,6 +2005,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);
@@ -1845,9 +2018,13 @@ void Init_clipsruby(void)
 	rb_define_method(rbDefmodule, "set_current", clips_environment_defmodule_set_current, 0);
 	rb_define_singleton_method(rbDefmodule, "get_fact_list", clips_environment_defmodule_static_get_fact_list, 1);
 	rb_define_method(rbDefmodule, "get_fact_list", clips_environment_defmodule_get_fact_list, 0);
+	rb_define_singleton_method(rbDefmodule, "get_deftemplate_list", clips_environment_defmodule_static_get_deftemplate_list, 1);
+	rb_define_method(rbDefmodule, "get_deftemplate_list", clips_environment_defmodule_get_deftemplate_list, 0);
 
 	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);

metadata

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