clipsruby 0.0.37 → 0.0.38

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6bdf3718a68644b1772e951c9a1056581d95b53a0d63d691d7cd434076d8877a
-  data.tar.gz: d76e7156d421d9cb0db3bd73314f061377c2972ecdafcd3eef1c480c113d4d2f
+  metadata.gz: 2d5b2eff6dfde994a41ed4226415ed61cc22f4a60164ca7f0adb14f2913ed831
+  data.tar.gz: 18f6b5748632239dac343f0b91b41620a2973699e27a9d52a2aef28bde921a0c
 SHA512:
-  metadata.gz: 4b4e7e0f16be94698e19d4b8d53bfbc07eeecbcb26e71eb9347ee2d36a9526c4a50708ca2b8cefc042b846fa81197500a1c03a46020f61ebe6111c6d715b574b
-  data.tar.gz: a29961896b77bd1cb0874bd51dc001d94b31c8b7000137b27fca0ef4820055895d69cc3302145514163a5b628791d625cb4208722feea618fb9488d25a5a049a
+  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,6 +339,36 @@ 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;
@@ -1952,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;
 
@@ -1972,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;
 	}
 }
 
@@ -4197,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);
@@ -4284,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);
@@ -4291,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.37
+  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