clipsruby 0.0.22 → 0.0.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4f7a174c8ca0889553334a3a6ad54580624d7d92695e3483aa44a130627b3fcb
-  data.tar.gz: a31141c4ce2490c74218316c89d08342dab315d5c35016c8dd488c2a344f8ae7
+  metadata.gz: 1efd15213fd7f558c0b75e64869e6518a12c1c55da8d6d94bf306235f4879a67
+  data.tar.gz: b30352c0431948b03849579a92a0e96dde42368f6e78b051adc2f02b68c8c4c8
 SHA512:
-  metadata.gz: 863a626437f0c4583e0f35618b4fd29c461b579833970e08999202dc35c2ac306a61b5eb3d029551187c7791d7b7fb22cb3d400d4106dea3c30eb1f1eccd7e73
-  data.tar.gz: aa4858ed68e383ff113accafb0f4652d4453448e93e6ecfa5c55a5903263925ae4ed114401158cb8d08b291a85eaf82891df0020a0b8f74cd9fbabdb228f4cec
+  metadata.gz: 5e55eac1476475ecb1f5b5b998cab1aa108dc0fcbe86905565c3b9256c4855ac796cdd9a28602289dec062c9481ac6340d17c7d22b98b1baf2b0b9e3f338136a
+  data.tar.gz: 31c41a7c633cc0707bdfc77e9e9c5b97b2d97d75f8202ce0d7450f7366ec9ee0e2939bcd91d7c228d3d96459ff516eb6f81959981cb1414b53f8c8ee514c6dea

data/README.md

@@ -514,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`
 
@@ -555,6 +571,66 @@ CLIPS::Environment::Deftemplate.assert_hash(deftemplate, foo: :bar)
 deftemplate.assert_hash(foo: :bar)
 ```
 
+### `CLIPS::Environment::Deftemplate.defmodule_name`
+### `CLIPS::Environment::Deftemplate#defmodule_name`
+
+Returns the name of the defmodule in which the deftemplate is defined
+
+```ruby
+CLIPS::Environment::Deftemplate.defmodule_name(deftemplate)
+deftemplate.defmodule_name
+```
+
+### `CLIPS::Environment::Deftemplate.slot_names`
+### `CLIPS::Environment::Deftemplate#slot_names`
+
+Returns the slot names of a deftemplate as symbols
+
+```ruby
+CLIPS::Environment::Deftemplate.slot_names(deftemplate)
+deftemplate.slot_names
+```
+
+### `CLIPS::Environment::Deftemplate.is_deletable`
+### `CLIPS::Environment::Deftemplate#is_deletable`
+
+Returns a boolean whether the Deftemplate is deletable or not
+
+```ruby
+CLIPS::Environment::Deftemplate.is_deletable(deftemplate)
+deftemplate.is_deletable
+```
+
+### `CLIPS::Environment::Deftemplate.slot_allowed_values`
+### `CLIPS::Environment::Deftemplate#slot_allowed_values`
+
+Returns the allowed values for the slot of a deftemplate as symbols
+
+```ruby
+CLIPS::Environment::Deftemplate.slot_allowed_values(deftemplate, :foo)
+deftemplate.slot_allowed_values('bar')
+```
+
+### `CLIPS::Environment::Deftemplate.slot_default_value`
+### `CLIPS::Environment::Deftemplate#slot_default_value`
+
+Returns the default value(s) for the slot of a deftemplate as symbols
+
+```ruby
+CLIPS::Environment::Deftemplate.slot_default_value(deftemplate, :foo)
+deftemplate.slot_default_value('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

@@ -96,6 +96,21 @@ static VALUE clips_environment_fact_static_deftemplate_name(VALUE self, VALUE rb
 	return clips_environment_fact_deftemplate_name(rbFact);
 }
 
+static VALUE clips_environment_deftemplate_defmodule_name(VALUE self)
+{
+	Deftemplate *template;
+
+	TypedData_Get_Struct(self, Deftemplate, &Deftemplate_type, template);
+
+	return ID2SYM(rb_intern(DeftemplateModule(template)));
+}
+
+static VALUE clips_environment_deftemplate_static_defmodule_name(VALUE self, VALUE rbDeftemplate)
+{
+	return clips_environment_deftemplate_defmodule_name(rbDeftemplate);
+}
+
+
 void environment_free(void *data)
 {
 	DestroyEnvironment((Environment*) data);
@@ -736,6 +751,31 @@ static VALUE clips_environment_static_add_udf(int argc, VALUE *argv, VALUE klass
 	return _clips_environment_add_udf(environment, method_name, clips_function_name);
 }
 
+static VALUE clips_environment_deftemplate_slot_names(VALUE self)
+{
+	Deftemplate *template;
+	Environment *env;
+	CLIPSValue value;
+	VALUE out;
+
+	VALUE rbEnvironment = rb_iv_get(self, "@environment");
+
+	TypedData_Get_Struct(self, Deftemplate, &Deftemplate_type, template);
+	TypedData_Get_Struct(rbEnvironment, Environment, &Environment_type, env);
+
+	DeftemplateSlotNames(template, &value);
+
+	CLIPSValue_to_VALUE(&value, &out, &rbEnvironment);
+
+	return out;
+}
+
+static VALUE clips_environment_deftemplate_static_slot_names(VALUE self, VALUE rbDeftemplate)
+{
+	return clips_environment_deftemplate_slot_names(rbDeftemplate);
+}
+
+
 static VALUE clips_environment_run(int argc, VALUE *argv, VALUE environment) {
 	VALUE integer;
 	Environment *env;
@@ -1195,6 +1235,71 @@ static VALUE clips_environment_fact_static_get_slot(VALUE self, VALUE rbFact, VA
 	return clips_environment_fact_get_slot(rbFact, slot_name);
 }
 
+static VALUE clips_environment_deftemplate_slot_allowed_values(VALUE self, VALUE slot_name)
+{
+	Deftemplate *template;
+	CLIPSValue slot_allowed_values;
+	VALUE rbEnvironment = rb_iv_get(self, "@environment");
+
+	TypedData_Get_Struct(self, Deftemplate, &Deftemplate_type, template);
+
+	switch (TYPE(slot_name)) {
+		case T_STRING:
+			DeftemplateSlotAllowedValues(template, StringValueCStr(slot_name), &slot_allowed_values);
+			break;
+		case T_SYMBOL:
+			DeftemplateSlotAllowedValues(template, rb_id2name(SYM2ID(slot_name)), &slot_allowed_values);
+			break;
+                default:
+			rb_warn("slot name must be string or symbol in call to slot_allowed_values!");
+			return Qnil;
+        }
+
+	VALUE out;
+
+	CLIPSValue_to_VALUE(&slot_allowed_values, &out, &rbEnvironment);
+
+	return out;
+}
+
+static VALUE clips_environment_deftemplate_static_slot_allowed_values(VALUE self, VALUE rbDeftemplate, VALUE slot_name)
+{
+	return clips_environment_deftemplate_slot_allowed_values(rbDeftemplate, slot_name);
+}
+
+static VALUE clips_environment_deftemplate_slot_default_value(VALUE self, VALUE slot_name)
+{
+	Deftemplate *template;
+	CLIPSValue slot_default_value;
+	VALUE rbEnvironment = rb_iv_get(self, "@environment");
+
+	TypedData_Get_Struct(self, Deftemplate, &Deftemplate_type, template);
+
+	switch (TYPE(slot_name)) {
+		case T_STRING:
+			DeftemplateSlotDefaultValue(template, StringValueCStr(slot_name), &slot_default_value);
+			break;
+		case T_SYMBOL:
+			DeftemplateSlotDefaultValue(template, rb_id2name(SYM2ID(slot_name)), &slot_default_value);
+			break;
+                default:
+			rb_warn("slot name must be string or symbol in call to slot_default_value!");
+			return Qnil;
+        }
+
+	VALUE out;
+
+	CLIPSValue_to_VALUE(&slot_default_value, &out, &rbEnvironment);
+
+	return out;
+}
+
+static VALUE clips_environment_deftemplate_static_slot_default_value(VALUE self, VALUE rbDeftemplate, VALUE slot_name)
+{
+	return clips_environment_deftemplate_slot_default_value(rbDeftemplate, slot_name);
+}
+
+
 static VALUE clips_environment_fact_retract(VALUE self)
 {
 	Fact *fact;
@@ -1664,7 +1769,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)
@@ -1739,6 +1911,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;
@@ -1785,6 +1981,24 @@ static VALUE clips_environment_defrule_static_is_deletable(VALUE self, VALUE rbD
 	return clips_environment_defrule_is_deletable(rbDefrule);
 }
 
+static VALUE clips_environment_deftemplate_is_deletable(VALUE self)
+{
+	Deftemplate *deftemplate;
+
+	TypedData_Get_Struct(self, Deftemplate, &Deftemplate_type, deftemplate);
+
+	if (DeftemplateIsDeletable(deftemplate)) {
+		return Qtrue;
+	} else {
+		return Qfalse;
+	}
+}
+
+static VALUE clips_environment_deftemplate_static_is_deletable(VALUE self, VALUE rbDeftemplate)
+{
+	return clips_environment_deftemplate_is_deletable(rbDeftemplate);
+}
+
 static VALUE clips_environment_defrule_has_breakpoint(VALUE self)
 {
 	Defrule *defrule;
@@ -1896,6 +2110,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);
 
@@ -1914,6 +2130,16 @@ void Init_clipsruby(void)
 	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);
+	rb_define_singleton_method(rbDeftemplate, "defmodule_name", clips_environment_deftemplate_static_defmodule_name, 1);
+	rb_define_method(rbDeftemplate, "defmodule_name", clips_environment_deftemplate_defmodule_name, 0);
+	rb_define_singleton_method(rbDeftemplate, "slot_names", clips_environment_deftemplate_static_slot_names, 1);
+	rb_define_method(rbDeftemplate, "slot_names", clips_environment_deftemplate_slot_names, 0);
+	rb_define_singleton_method(rbDeftemplate, "is_deletable", clips_environment_deftemplate_static_is_deletable, 1);
+	rb_define_method(rbDeftemplate, "is_deletable", clips_environment_deftemplate_is_deletable, 0);
+	rb_define_singleton_method(rbDeftemplate, "slot_allowed_values", clips_environment_deftemplate_static_slot_allowed_values, 2);
+	rb_define_method(rbDeftemplate, "slot_allowed_values", clips_environment_deftemplate_slot_allowed_values, 1);
+	rb_define_singleton_method(rbDeftemplate, "slot_default_value", clips_environment_deftemplate_static_slot_default_value, 2);
+	rb_define_method(rbDeftemplate, "slot_default_value", clips_environment_deftemplate_slot_default_value, 1);
 
 	VALUE rbDefmodule = rb_define_class_under(rbEnvironment, "Defmodule", rb_cObject);
 	rb_define_alloc_func(rbDefmodule, defmodule_alloc);
@@ -1925,6 +2151,8 @@ 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);

metadata

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