clipsruby 0.0.31 → 0.0.33

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e60b635195b3e8fb7375f1f93d4fa5c8459c6eb5c3ed22e9e189029382e74da8
-  data.tar.gz: a641f8b2fbbdeca662101ab05ad0dbd6b8fe4688c2ad6ba73f04a2de93badacc
+  metadata.gz: eebbbd0b179f769e1bc079a0cedda8a3ba5198a83347bfb37abc48d6edfe8d41
+  data.tar.gz: 9adb9650801d7a7bbd290aac1f3c6666dfe6e2527b2fc022dc6285dfad6756f1
 SHA512:
-  metadata.gz: e7a266cd73117d6497c4c93d141311ceaaaff17550ba753af0eaa98c8051cac3b0ea44d36c4d796da5982354ba417b38a937a49e68992add8e290cbbb22811ab
-  data.tar.gz: 82822e678d0342232792fc5ffb8d451e54d2e9e8cce877bdf5d8fa231c045a2477621c82d9b6d17967502d8135b6a5d1049a3539b6f8b84b82669bc4b493c312
+  metadata.gz: 840d6111ab2c3b27d764a2bf2dea8b88b447f4730345e1e54ef22f0e3aa64edb21ee362e9c57088cbffc29d561106e28fbfd25acee381ef1d819d3297ae6a279
+  data.tar.gz: 4cd8587d33b239d66093cebdf12efda954adc37c620c1112a35295771f7ea3ccc74415e2a7303d7581fe0494c577f9200512f7a59d898c4e8077105b7157d099

data/README.md

@@ -155,6 +155,16 @@ fact = CLIPS::Environment.assert_hash(env, :my_deftemplate, a: 1, b: "asdf", c:
 fact2 = env.assert_hash(:my_deftemplate, d: 4.5, e: :asdf)
 ```
 
+### `CLIPS::Environment.make_instance`
+### `CLIPS::Environment#make_instance`
+
+Make a string as an Instance in the CLIPS environment.
+
+```ruby
+instance = CLIPS::Environment.make_instance(env, "(of USER)")
+instance2 = env.make_instance("(of USER)")
+```
+
 ### `CLIPS::Environment.find_fact`
 ### `CLIPS::Environment#find_fact`
 
@@ -404,6 +414,86 @@ CLIPS::Environment::Fact.modify(fact, bar: 123)
 fact.modify(foo: "my new foo!")
 ```
 
+### `CLIPS::Environment::Instance.unmake`
+### `CLIPS::Environment::Instance#unmake`
+
+Unmakes an instance in the environment, deleting it.
+
+```ruby
+CLIPS::Environment::Instance.unmake(instance)
+instance.unmake
+```
+
+### `CLIPS::Environment::Instance.delete`
+### `CLIPS::Environment::Instance#delete`
+
+Deletes an instance in the environment.
+
+```ruby
+CLIPS::Environment::Instance.delete(instance)
+instance.delete
+```
+
+### `CLIPS::Environment::Instance.name`
+### `CLIPS::Environment::Instance#name`
+
+Returns the name of an Instance as a symbol
+
+```ruby
+CLIPS::Environment::Instance.name(instance)
+instance.name
+```
+
+### `CLIPS::Environment::Instance.pp_form`
+### `CLIPS::Environment::Instance#pp_form`
+
+Returns a pretty printed string representation of an Instance
+
+```ruby
+CLIPS::Environment::Instance.pp_form(instance)
+instance.pp_form
+```
+
+### `CLIPS::Environment::Instance._class`
+### `CLIPS::Environment::Instance#_class`
+
+Returns the Defclass of an Instance
+
+```ruby
+CLIPS::Environment::Instance._class(instance)
+instance._class
+```
+
+### `CLIPS::Environment::Defclass.name`
+### `CLIPS::Environment::Defclass#name`
+
+Returns the name of an Defclass as a symbol
+
+```ruby
+CLIPS::Environment::Defclass.name(defclass)
+defclass.name
+```
+
+### `CLIPS::Environment::Defclass.pp_form`
+### `CLIPS::Environment::Defclass#pp_form`
+
+Returns a pretty printed string representation of an Defclass
+
+```ruby
+CLIPS::Environment::Defclass.pp_form(defclass)
+defclass.pp_form
+```
+
+### `CLIPS::Environment::Defclass.defmodule_name`
+### `CLIPS::Environment::Defclass#defmodule_name`
+
+Returns the name of the defmodule in which the defclass is defined
+
+```ruby
+CLIPS::Environment::Defclass.defmodule_name(defclass)
+defclass.defmodule_name
+```
+
 ### `CLIPS::Environment.find_defrule`
 ### `CLIPS::Environment#find_defrule`
 
@@ -424,6 +514,16 @@ CLIPS::Environment::Defrule.name(defrule)
 defrule.name
 ```
 
+### `CLIPS::Environment::Defrule.defmodule_name`
+### `CLIPS::Environment::Defrule#defmodule_name`
+
+Returns the name of the defmodule in which the defrule is defined
+
+```ruby
+CLIPS::Environment::Defrule.defmodule_name(defrule)
+defrule.defmodule_name
+```
+
 ### `CLIPS::Environment::Defrule.is_deletable`
 ### `CLIPS::Environment::Defrule#is_deletable`
 

data/ext/clipsruby/clipsruby.c

@@ -37,7 +37,6 @@ static const rb_data_type_t Defmodule_type = {
 	.flags = RUBY_TYPED_FREE_IMMEDIATELY
 };
 
-
 size_t defrule_size(const void *data)
 {
 	return sizeof(Defrule);
@@ -50,6 +49,18 @@ static const rb_data_type_t Defrule_type = {
 	.flags = RUBY_TYPED_FREE_IMMEDIATELY
 };
 
+size_t defclass_size(const void *data)
+{
+	return sizeof(Defclass);
+}
+
+static const rb_data_type_t Defclass_type = {
+	.function = {
+		.dsize = defclass_size
+	},
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
 size_t fact_size(const void *data)
 {
 	return sizeof(Fact);
@@ -62,6 +73,18 @@ static const rb_data_type_t Fact_type = {
 	.flags = RUBY_TYPED_FREE_IMMEDIATELY
 };
 
+size_t instance_size(const void *data)
+{
+	return sizeof(Instance);
+}
+
+static const rb_data_type_t Instance_type = {
+	.function = {
+		.dsize = instance_size
+	},
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
 static VALUE clips_environment_fact_deftemplate(VALUE self)
 {
 	VALUE rbDeftemplate, rbEnvironment;
@@ -110,6 +133,19 @@ static VALUE clips_environment_deftemplate_static_defmodule_name(VALUE self, VAL
 	return clips_environment_deftemplate_defmodule_name(rbDeftemplate);
 }
 
+static VALUE clips_environment_defrule_defmodule_name(VALUE self)
+{
+	Defrule *rule;
+
+	TypedData_Get_Struct(self, Defrule, &Defrule_type, rule);
+
+	return ID2SYM(rb_intern(DefruleModule(rule)));
+}
+
+static VALUE clips_environment_defrule_static_defmodule_name(VALUE self, VALUE rbDefrule)
+{
+	return clips_environment_defrule_defmodule_name(rbDefrule);
+}
 
 void environment_free(void *data)
 {
@@ -160,6 +196,11 @@ VALUE deftemplate_alloc(VALUE self)
 	return TypedData_Wrap_Struct(self, &Deftemplate_type, NULL);
 }
 
+VALUE defclass_alloc(VALUE self)
+{
+	return TypedData_Wrap_Struct(self, &Defclass_type, NULL);
+}
+
 VALUE defrule_alloc(VALUE self)
 {
 	return TypedData_Wrap_Struct(self, &Defrule_type, NULL);
@@ -170,6 +211,11 @@ VALUE fact_alloc(VALUE self)
 	return TypedData_Wrap_Struct(self, &Fact_type, NULL);
 }
 
+VALUE instance_alloc(VALUE self)
+{
+	return TypedData_Wrap_Struct(self, &Instance_type, NULL);
+}
+
 VALUE environment_alloc(VALUE self)
 {
 	return TypedData_Wrap_Struct(self, &Environment_type, CreateEnvironment());
@@ -205,6 +251,199 @@ static VALUE clips_environment_static_assert_string(VALUE self, VALUE rbEnvironm
 	return clips_environment_assert_string(rbEnvironment, string);
 }
 
+static VALUE clips_environment_defclass_name(VALUE self)
+{
+	Defclass *defclass;
+
+	TypedData_Get_Struct(self, Defclass, &Defclass_type, defclass);
+
+	return ID2SYM(rb_intern(DefclassName(defclass)));
+}
+
+static VALUE clips_environment_defclass_static_name(VALUE self, VALUE rbDefclass)
+{
+	return clips_environment_defclass_name(rbDefclass);
+}
+
+static VALUE clips_environment_defclass_defmodule_name(VALUE self)
+{
+	Defclass *defclass;
+
+	TypedData_Get_Struct(self, Defclass, &Defclass_type, defclass);
+
+	return ID2SYM(rb_intern(DefclassModule(defclass)));
+}
+
+static VALUE clips_environment_defclass_static_defmodule_name(VALUE self, VALUE rbDefclass)
+{
+	return clips_environment_defclass_defmodule_name(rbDefclass);
+}
+
+static VALUE clips_environment_defclass_pp_form(VALUE self)
+{
+	Defclass *defclass;
+
+	TypedData_Get_Struct(self, Defclass, &Defclass_type, defclass);
+
+	return rb_str_new2(DefclassPPForm(defclass));
+}
+
+static VALUE clips_environment_defclass_static_pp_form(VALUE self, VALUE rbDefclass)
+{
+	return clips_environment_defclass_pp_form(rbDefclass);
+}
+
+static VALUE clips_environment_make_instance(VALUE self, VALUE string)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Instance *instance = MakeInstance(env, StringValueCStr(string));
+
+	if (instance == NULL) {
+		return Qnil;
+	}
+
+	VALUE rb_instance =
+		TypedData_Wrap_Struct(rb_const_get(CLASS_OF(self), rb_intern("Instance")), &Instance_type, instance);
+
+	rb_iv_set(rb_instance, "@environment", self);
+
+	return rb_instance;
+}
+
+static VALUE clips_environment_static_make_instance(VALUE self, VALUE rbEnvironment, VALUE string)
+{
+	return clips_environment_make_instance(rbEnvironment, string);
+}
+
+static VALUE clips_environment_instance_unmake(VALUE self)
+{
+	Instance *instance;
+
+	TypedData_Get_Struct(self, Instance, &Instance_type, instance);
+
+	switch (UnmakeInstance(instance)) {
+		case UIE_NO_ERROR:
+			break;
+		case UIE_NULL_POINTER_ERROR:
+			rb_warn("could not unmake instance; null pointer error. This could be a bug in clipsruby!");
+			return Qfalse;
+		case UIE_COULD_NOT_DELETE_ERROR:
+			rb_warn("could not unmake instance! is pattern matching currently happening with this instance?");
+			return Qfalse;
+		case UIE_DELETED_ERROR:
+			rb_warn("could not unmake instance! instance is already deleted");
+			return Qfalse;
+		case UIE_RULE_NETWORK_ERROR:
+			rb_warn("could not unmake instance! An error occurs while the unmaking was being processed in the rule network");
+			return Qfalse;
+        }
+
+	return Qtrue;
+}
+
+static VALUE clips_environment_instance_static_unmake(VALUE self, VALUE rbInstance)
+{
+	return clips_environment_instance_unmake(rbInstance);
+}
+
+static VALUE clips_environment_instance_delete(VALUE self)
+{
+	Instance *instance;
+
+	TypedData_Get_Struct(self, Instance, &Instance_type, instance);
+
+	switch (DeleteInstance(instance)) {
+		case UIE_NO_ERROR:
+			break;
+		case UIE_NULL_POINTER_ERROR:
+			rb_warn("could not delete instance; null pointer error. This could be a bug in clipsruby!");
+			return Qfalse;
+		case UIE_COULD_NOT_DELETE_ERROR:
+			rb_warn("could not delete instance! is pattern matching currently happening with this instance?");
+			return Qfalse;
+		case UIE_DELETED_ERROR:
+			rb_warn("could not delete instance! instance is already deleted");
+			return Qfalse;
+		case UIE_RULE_NETWORK_ERROR:
+			rb_warn("could not delete instance! An error occurs while the unmaking was being processed in the rule network");
+			return Qfalse;
+        }
+
+	return Qtrue;
+}
+
+static VALUE clips_environment_instance_static_delete(VALUE self, VALUE rbInstance)
+{
+	return clips_environment_instance_delete(rbInstance);
+}
+
+static VALUE clips_environment_instance_class(VALUE self)
+{
+	Defclass *defclass;
+	Instance *instance;
+	VALUE rbEnvironment, rb_defclass;
+
+	rbEnvironment = rb_iv_get(self, "@environment");
+
+	TypedData_Get_Struct(self, Instance, &Instance_type, instance);
+
+	defclass = InstanceClass(instance);
+
+	rb_defclass =
+		TypedData_Wrap_Struct(rb_const_get(rb_obj_class(rbEnvironment), rb_intern("Defclass")), &Defclass_type, defclass);
+
+	rb_iv_set(rb_defclass, "@environment", rbEnvironment);
+
+	return rb_defclass;
+}
+
+static VALUE clips_environment_instance_static_class(VALUE self, VALUE rbInstance)
+{
+	return clips_environment_instance_class(rbInstance);
+}
+
+static VALUE clips_environment_instance_name(VALUE self)
+{
+	Instance *instance;
+
+	TypedData_Get_Struct(self, Instance, &Instance_type, instance);
+
+	return ID2SYM(rb_intern(InstanceName(instance)));
+}
+
+static VALUE clips_environment_instance_static_name(VALUE self, VALUE rbInstance)
+{
+	return clips_environment_instance_name(rbInstance);
+}
+
+static VALUE clips_environment_instance_pp_form(VALUE self)
+{
+	Environment *env;
+	Instance *instance;
+	StringBuilder *sb;
+	VALUE toReturn;
+
+	VALUE rbEnvironment = rb_iv_get(self, "@environment");
+	TypedData_Get_Struct(rbEnvironment, Environment, &Environment_type, env);
+	sb = CreateStringBuilder(env, 0);
+
+	TypedData_Get_Struct(self, Instance, &Instance_type, instance);
+
+	InstancePPForm(instance, sb);
+	toReturn = rb_str_new2(sb->contents);
+	SBDispose(sb);
+
+	return toReturn;
+}
+
+static VALUE clips_environment_instance_static_pp_form(VALUE self, VALUE rbInstance)
+{
+	return clips_environment_instance_pp_form(rbInstance);
+}
+
 static VALUE clips_environment_build(VALUE self, VALUE string)
 {
 	Environment *env;
@@ -3219,6 +3458,8 @@ void Init_clipsruby(void)
 	rb_define_method(rbEnvironment, "unwatch_focus", clips_environment_unwatch_focus, 0);
 	rb_define_singleton_method(rbEnvironment, "get_watch_state", clips_environment_static_get_watch_state, 2);
 	rb_define_method(rbEnvironment, "get_watch_state", clips_environment_get_watch_state, 1);
+	rb_define_singleton_method(rbEnvironment, "make_instance", clips_environment_static_make_instance, 2);
+	rb_define_method(rbEnvironment, "make_instance", clips_environment_make_instance, 1);
 
 	VALUE rbDeffacts = rb_define_class_under(rbEnvironment, "Deffacts", rb_cObject);
 	rb_define_alloc_func(rbDeffacts, deffacts_alloc);
@@ -3316,6 +3557,28 @@ void Init_clipsruby(void)
 	rb_define_method(rbDefrule, "remove_break", clips_environment_defrule_remove_break, 0);
 	rb_define_singleton_method(rbDefrule, "salience", clips_environment_defrule_static_salience, 1);
 	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);
+
+	VALUE rbDefclass = rb_define_class_under(rbEnvironment, "Defclass", rb_cObject);
+	rb_define_alloc_func(rbDefclass, defclass_alloc);
+	rb_define_singleton_method(rbDefclass, "name", clips_environment_defclass_static_name, 1);
+	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, "pp_form", clips_environment_defclass_static_pp_form, 1);
+	rb_define_method(rbDefclass, "pp_form", clips_environment_defclass_pp_form, 0);
 
 	VALUE rbInstance = rb_define_class_under(rbEnvironment, "Instance", rb_cObject);
+	rb_define_alloc_func(rbInstance, instance_alloc);
+	rb_define_singleton_method(rbInstance, "unmake", clips_environment_instance_static_unmake, 1);
+	rb_define_method(rbInstance, "unmake", clips_environment_instance_unmake, 0);
+	rb_define_singleton_method(rbInstance, "delete", clips_environment_instance_static_delete, 1);
+	rb_define_method(rbInstance, "delete", clips_environment_instance_delete, 0);
+	rb_define_singleton_method(rbInstance, "_class", clips_environment_instance_static_class, 1);
+	rb_define_method(rbInstance, "_class", clips_environment_instance_class, 0);
+	rb_define_singleton_method(rbInstance, "name", clips_environment_instance_static_name, 1);
+	rb_define_method(rbInstance, "name", clips_environment_instance_name, 0);
+	rb_define_singleton_method(rbInstance, "pp_form", clips_environment_instance_static_pp_form, 1);
+	rb_define_method(rbInstance, "pp_form", clips_environment_instance_pp_form, 0);
 }

metadata

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