clipsruby 0.0.36 → 0.0.38

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50cc209eb6a473cd3a980b8d551079a4db6632f86afbc43bff8a582a89efb2cf
-  data.tar.gz: 2e2dd6648850df2dc496111334e68aebb9048fb2f823a6b6ddd865449cb34254
+  metadata.gz: 2d5b2eff6dfde994a41ed4226415ed61cc22f4a60164ca7f0adb14f2913ed831
+  data.tar.gz: 18f6b5748632239dac343f0b91b41620a2973699e27a9d52a2aef28bde921a0c
 SHA512:
-  metadata.gz: 9bf9b814174620c68ee826d8051f09bb4d3e989537f4dcce642ba84a651b9dcdfa5acb403378865e05429b1dd03019e07568163c121a58e05368bc664ebd96e4
-  data.tar.gz: e3690e9f5b2f28203366e75d845d06dc3ad22173db4ed0a0cdb0ff7246cb0b31f804fc60fde0b6e2be58b29b074f3692ade5f3da6c4f947a2acfc40b1ab1ae21
+  metadata.gz: 634dd08bc164e971d4484e18a2fadc51a56e7b7976994b3cfb3bad903445157da9b6bc1ef4dc424faacef0a68217f774c6c3ec9f9fd717c3d579df04d0e6525e
+  data.tar.gz: b31052a98c2238d3d97bf6938193202ca6b05333286e61500000da33dd4baaeddc915b5bd53c53cf989c366bcc51d5469428632766ad625e616249f9eb996655

data/README.md

@@ -494,6 +494,16 @@ CLIPS::Environment::Defclass.defmodule_name(defclass)
 defclass.defmodule_name
 ```
 
+### `CLIPS::Environment::Defclass.defmodule`
+### `CLIPS::Environment::Defclass#defmodule`
+
+Returns the defmodule in which the defclass is defined
+
+```ruby
+CLIPS::Environment::Defclass.defmodule(defclass)
+defclass.defmodule
+```
+
 ### `CLIPS::Environment::Defclass.get_instance_list`
 ### `CLIPS::Environment::Defclass#get_instance_list`
 
@@ -582,6 +592,16 @@ CLIPS::Environment::Defrule.defmodule_name(defrule)
 defrule.defmodule_name
 ```
 
+### `CLIPS::Environment::Defrule.defmodule`
+### `CLIPS::Environment::Defrule#defmodule`
+
+Returns the defmodule in which the defrule is defined
+
+```ruby
+CLIPS::Environment::Defrule.defmodule(defrule)
+defrule.defmodule
+```
+
 ### `CLIPS::Environment::Defrule.is_deletable`
 ### `CLIPS::Environment::Defrule#is_deletable`
 
@@ -846,6 +866,16 @@ CLIPS::Environment::Deftemplate.defmodule_name(deftemplate)
 deftemplate.defmodule_name
 ```
 
+### `CLIPS::Environment::Deftemplate.defmodule`
+### `CLIPS::Environment::Deftemplate#defmodule`
+
+Returns the defmodule in which the deftemplate is defined
+
+```ruby
+CLIPS::Environment::Deftemplate.defmodule(deftemplate)
+deftemplate.defmodule
+```
+
 ### `CLIPS::Environment::Deftemplate.slot_names`
 ### `CLIPS::Environment::Deftemplate#slot_names`
 

data/ext/clipsruby/clipsruby.c

@@ -1,6 +1,24 @@
 #include "clips.h"
 #include "ruby.h"
 
+void environment_free(void *data)
+{
+	DestroyEnvironment((Environment*) data);
+}
+
+size_t environment_size(const void *data)
+{
+	return MemUsed((Environment*) data);
+}
+
+static const rb_data_type_t Environment_type = {
+	.function = {
+		.dfree = environment_free,
+		.dsize = environment_size
+	},
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
 size_t deffacts_size(const void *data)
 {
 	return sizeof(Deffacts);
@@ -133,6 +151,36 @@ static VALUE clips_environment_deftemplate_static_defmodule_name(VALUE self, VAL
 	return clips_environment_deftemplate_defmodule_name(rbDeftemplate);
 }
 
+static VALUE clips_environment_deftemplate_defmodule(VALUE self)
+{
+	Deftemplate *template;
+	const char *defmoduleName;
+	Defmodule *defmodule = NULL;
+	Environment *env;
+
+	VALUE rbEnvironment = rb_iv_get(self, "@environment");
+	TypedData_Get_Struct(rbEnvironment, Environment, &Environment_type, env);
+
+	TypedData_Get_Struct(self, Deftemplate, &Deftemplate_type, template);
+	
+	defmoduleName = DeftemplateModule(template);
+
+	if (defmoduleName != NULL) {
+		defmodule = FindDefmodule(env, defmoduleName);
+	}
+
+	if (defmodule != NULL) {
+		return TypedData_Wrap_Struct(rb_const_get(CLASS_OF(rbEnvironment), rb_intern("Defmodule")), &Defmodule_type, defmodule);
+	} else {
+		return Qnil;
+	}
+}
+
+static VALUE clips_environment_deftemplate_static_defmodule(VALUE self, VALUE rbDeftemplate)
+{
+	return clips_environment_deftemplate_defmodule(rbDeftemplate);
+}
+
 static VALUE clips_environment_defrule_defmodule_name(VALUE self)
 {
 	Defrule *rule;
@@ -147,24 +195,36 @@ static VALUE clips_environment_defrule_static_defmodule_name(VALUE self, VALUE r
 	return clips_environment_defrule_defmodule_name(rbDefrule);
 }
 
-void environment_free(void *data)
+static VALUE clips_environment_defrule_defmodule(VALUE self)
 {
-	DestroyEnvironment((Environment*) data);
+	Defrule *rule;
+	const char *defmoduleName;
+	Defmodule *defmodule = NULL;
+	Environment *env;
+
+	VALUE rbEnvironment = rb_iv_get(self, "@environment");
+	TypedData_Get_Struct(rbEnvironment, Environment, &Environment_type, env);
+
+	TypedData_Get_Struct(self, Defrule, &Defrule_type, rule);
+	
+	defmoduleName = DefruleModule(rule);
+
+	if (defmoduleName != NULL) {
+		defmodule = FindDefmodule(env, defmoduleName);
+	}
+
+	if (defmodule != NULL) {
+		return TypedData_Wrap_Struct(rb_const_get(CLASS_OF(rbEnvironment), rb_intern("Defmodule")), &Defmodule_type, defmodule);
+	} else {
+		return Qnil;
+	}
 }
 
-size_t environment_size(const void *data)
+static VALUE clips_environment_defrule_static_defmodule(VALUE self, VALUE rbDefrule)
 {
-	return MemUsed((Environment*) data);
+	return clips_environment_defrule_defmodule(rbDefrule);
 }
 
-static const rb_data_type_t Environment_type = {
-	.function = {
-		.dfree = environment_free,
-		.dsize = environment_size
-	},
-	.flags = RUBY_TYPED_FREE_IMMEDIATELY
-};
-
 static VALUE clips_environment_facts(VALUE self)
 {
 	Environment *env;
@@ -279,13 +339,49 @@ static VALUE clips_environment_defclass_static_defmodule_name(VALUE self, VALUE
 	return clips_environment_defclass_defmodule_name(rbDefclass);
 }
 
+static VALUE clips_environment_defclass_defmodule(VALUE self)
+{
+	Defclass *class;
+	const char *defmoduleName;
+	Defmodule *defmodule = NULL;
+	Environment *env;
+
+	VALUE rbEnvironment = rb_iv_get(self, "@environment");
+	TypedData_Get_Struct(rbEnvironment, Environment, &Environment_type, env);
+
+	TypedData_Get_Struct(self, Defclass, &Defclass_type, class);
+	
+	defmoduleName = DefclassModule(class);
+
+	if (defmoduleName != NULL) {
+		defmodule = FindDefmodule(env, defmoduleName);
+	}
+
+	if (defmodule != NULL) {
+		return TypedData_Wrap_Struct(rb_const_get(CLASS_OF(rbEnvironment), rb_intern("Defmodule")), &Defmodule_type, defmodule);
+	} else {
+		return Qnil;
+	}
+}
+
+static VALUE clips_environment_defclass_static_defmodule(VALUE self, VALUE rbDefclass)
+{
+	return clips_environment_defclass_defmodule(rbDefclass);
+}
+
 static VALUE clips_environment_defclass_pp_form(VALUE self)
 {
 	Defclass *defclass;
+	const char *pp_form;
 
 	TypedData_Get_Struct(self, Defclass, &Defclass_type, defclass);
 
-	return rb_str_new2(DefclassPPForm(defclass));
+	pp_form = DefclassPPForm(defclass);
+	if (pp_form == NULL) {
+		return Qnil;
+	} else {
+		return rb_str_new2(pp_form);
+	}
 }
 
 static VALUE clips_environment_defclass_static_pp_form(VALUE self, VALUE rbDefclass)
@@ -1946,6 +2042,7 @@ static VALUE clips_environment_fact_static_index(VALUE self, VALUE rbFact)
 
 static VALUE clips_environment_find_defrule(VALUE self, VALUE defrule_name)
 {
+	VALUE rbDefrule;
 	Environment *env;
 	Defrule *rule;
 
@@ -1966,7 +2063,9 @@ static VALUE clips_environment_find_defrule(VALUE self, VALUE defrule_name)
 	if (rule == NULL) {
 		return Qnil;
 	} else {
-		return TypedData_Wrap_Struct(rb_const_get(CLASS_OF(self), rb_intern("Defrule")), &Defrule_type, rule);
+		rbDefrule = TypedData_Wrap_Struct(rb_const_get(CLASS_OF(self), rb_intern("Defrule")), &Defrule_type, rule); 
+		rb_iv_set(rbDefrule, "@environment", self);
+		return rbDefrule;
 	}
 }
 
@@ -4191,6 +4290,8 @@ 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", clips_environment_deftemplate_static_defmodule, 1);
+	rb_define_method(rbDeftemplate, "defmodule", clips_environment_deftemplate_defmodule, 0);
 	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);
@@ -4278,6 +4379,8 @@ void Init_clipsruby(void)
 	rb_define_method(rbDefrule, "salience", clips_environment_defrule_salience, 0);
 	rb_define_singleton_method(rbDefrule, "defmodule_name", clips_environment_defrule_static_defmodule_name, 1);
 	rb_define_method(rbDefrule, "defmodule_name", clips_environment_defrule_defmodule_name, 0);
+	rb_define_singleton_method(rbDefrule, "defmodule", clips_environment_defrule_static_defmodule, 1);
+	rb_define_method(rbDefrule, "defmodule", clips_environment_defrule_defmodule, 0);
 
 	VALUE rbDefclass = rb_define_class_under(rbEnvironment, "Defclass", rb_cObject);
 	rb_define_alloc_func(rbDefclass, defclass_alloc);
@@ -4285,6 +4388,8 @@ void Init_clipsruby(void)
 	rb_define_method(rbDefclass, "name", clips_environment_defclass_name, 0);
 	rb_define_singleton_method(rbDefclass, "defmodule_name", clips_environment_defclass_static_defmodule_name, 1);
 	rb_define_method(rbDefclass, "defmodule_name", clips_environment_defclass_defmodule_name, 0);
+	rb_define_singleton_method(rbDefclass, "defmodule", clips_environment_defclass_static_defmodule, 1);
+	rb_define_method(rbDefclass, "defmodule", clips_environment_defclass_defmodule, 0);
 	rb_define_singleton_method(rbDefclass, "pp_form", clips_environment_defclass_static_pp_form, 1);
 	rb_define_method(rbDefclass, "pp_form", clips_environment_defclass_pp_form, 0);
 	rb_define_singleton_method(rbDefclass, "get_instance_list", clips_environment_defclass_static_get_instance_list, -1);

metadata

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