clipsruby 0.0.32 → 0.0.34

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d63c4466f611752b18eac8e195f3614784dd64b80ac007457fb550bc88847ee5
-  data.tar.gz: 353a3eb4fe11406b0b2b704a669b1933b0a3ec4c6c10c4b288cd0bf7b5a1fe58
+  metadata.gz: 5d62cc0e5ccc41bfc4e88590c7a3873859271163fa5dd73b416c0cf2d61b7ed1
+  data.tar.gz: d3cd61d58609c516b8c952dbc32393d54251f09bdc3a8a5f15f531cdf2d707ee
 SHA512:
-  metadata.gz: 88e76e4afa90cf21db3718ed033a2463c8f38f5f9c17d3e643b901d4f9d83b36ec0c8d904d311db96cdaf6935b9694982508eebb5326c1eb43977c80660b40d5
-  data.tar.gz: 48665d09ede14f7707abaf1ad38c8202c12ee0fe655402d257399379e074e367b2bd18b3e3bec704bc5cfdfb280286890f325360384eb5e1d2a93d5ae3c57b0e
+  metadata.gz: c6473260b0da57bb78894841385c6cc1b4ecddb4448dc80edf7c0542e654b8dca6884efdc37b9be976d6b0bed22fadd24da5313ef8ba59b5cd71639a18cd2f42
+  data.tar.gz: 90af7d185f0ca31b1d543e0550cf4520d021525225e3bba8087d5f449591ffe40fa6a34380293b689876ec9d84dc9b3d8860c18b50b525610b3ca890ff727c5a

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`
 
@@ -544,6 +634,22 @@ CLIPS::Environment::Defmodule.get_fact_list(defmodule)
 defmodule.get_fact_list
 ```
 
+### `CLIPS::Environment.get_defclass_list`
+### `CLIPS::Environment#get_defclass_list`
+
+Return an array of Defclass names as symbols in the environment. Pass an argument of a
+symbol, string, or Defmodule object in order to only get Defclasss
+in that Defmodule. If you do not, it will return all Defclass names in all modules.
+
+```ruby
+CLIPS::Environment.get_defclass_list(env)
+env.get_defclass_list
+CLIPS::Environment.get_defclass_list(env, :MAIN)
+env.get_defclass_list(:MAIN)
+CLIPS::Environment.get_defclass_list(env, defmodule)
+env.get_defclass_list(defmodule)
+```
+
 ### `CLIPS::Environment.get_deftemplate_list`
 ### `CLIPS::Environment#get_deftemplate_list`
 
@@ -596,6 +702,16 @@ CLIPS::Environment.find_deftemplate(:a)
 env.find_deftemplate("foo")
 ```
 
+### `CLIPS::Environment.find_defclass`
+### `CLIPS::Environment#find_defclass`
+
+Finds a defclass by name and returns a CLIPS::Environment::Defclass object
+
+```ruby
+CLIPS::Environment.find_defclass(:a)
+env.find_defclass("foo")
+```
+
 ### `CLIPS::Environment::Deftemplate.name`
 ### `CLIPS::Environment::Deftemplate#name`
 
@@ -784,6 +900,16 @@ CLIPS::Environment::Deftemplate.slot_defaultp(deftemplate, :foo)
 deftemplate.slot_defaultp('bar')
 ```
 
+### `CLIPS::Environment::Defmodule.get_defclass_list`
+### `CLIPS::Environment::Defmodule#get_defclass_list`
+
+Return an array of Defclass names as symbols in the Defmodule
+
+```ruby
+CLIPS::Environment::Defmodule.get_defclass_list(defmodule)
+defmodule.get_defclass_list
+```
+
 ### `CLIPS::Environment::Defmodule.get_deftemplate_list`
 ### `CLIPS::Environment::Defmodule#get_deftemplate_list`
 

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;
@@ -173,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);
@@ -183,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());
@@ -218,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;
@@ -1733,6 +1959,40 @@ static VALUE clips_environment_static_find_deftemplate(VALUE self, VALUE rbEnvir
 	return clips_environment_find_deftemplate(rbEnvironment, deftemplate_name);
 }
 
+static VALUE clips_environment_find_defclass(VALUE self, VALUE defclass_name)
+{
+	Environment *env;
+	Defclass *class;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	switch (TYPE(defclass_name)) {
+		case T_STRING:
+			class = FindDefclass(env, StringValueCStr(defclass_name));
+			break;
+		case T_SYMBOL:
+			class = FindDefclass(env, rb_id2name(SYM2ID(defclass_name)));
+			break;
+                default:
+			rb_warn("defclass name must be a symbol or string");
+			return Qnil;
+        }
+
+	if (class == NULL) {
+		return Qnil;
+	} else {
+		VALUE rbDefclass;
+		rbDefclass = TypedData_Wrap_Struct(rb_const_get(CLASS_OF(self), rb_intern("Defclass")), &Defclass_type, class);
+		rb_iv_set(rbDefclass, "@environment", self);
+		return rbDefclass;
+	}
+}
+
+static VALUE clips_environment_static_find_defclass(VALUE self, VALUE rbEnvironment, VALUE defclass_name)
+{
+	return clips_environment_find_defclass(rbEnvironment, defclass_name);
+}
+
 static VALUE clips_environment_deftemplate_name(VALUE self)
 {
 	Deftemplate *deftemplate;
@@ -1967,6 +2227,74 @@ static VALUE clips_environment_static_get_deftemplate_list(int argc, VALUE *argv
 	return out;
 }
 
+static VALUE clips_environment_get_defclass_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;
+        }
+	GetDefclassList(env, &value, module);
+
+	CLIPSValue_to_VALUE(&value, &out, &rbEnvironment);
+
+	return out;
+}
+
+static VALUE clips_environment_static_get_defclass_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;
+        }
+	GetDefclassList(env, &value, module);
+
+	CLIPSValue_to_VALUE(&value, &out, &rbEnvironment);
+
+	return out;
+}
+
 static VALUE clips_environment_get_defrule_list(int argc, VALUE *argv, VALUE rbEnvironment) {
 	VALUE defmodule_or_defmodule_name;
 	Environment *env;
@@ -2107,6 +2435,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_defclass_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);
+
+	GetDefclassList(env, &value, module);
+
+	CLIPSValue_to_VALUE(&value, &out, &rbEnvironment);
+
+	return out;
+}
+
+static VALUE clips_environment_defmodule_static_get_defclass_list(VALUE self, VALUE rbDefmodule)
+{
+	return clips_environment_defmodule_get_defclass_list(rbDefmodule);
+}
+
 static VALUE clips_environment_defmodule_get_deftemplate_list(VALUE self)
 {
 	Defmodule *module;
@@ -3152,6 +3504,8 @@ void Init_clipsruby(void)
 	rb_define_method(rbEnvironment, "find_defmodule", clips_environment_find_defmodule, 1);
 	rb_define_singleton_method(rbEnvironment, "find_deftemplate", clips_environment_static_find_deftemplate, 2);
 	rb_define_method(rbEnvironment, "find_deftemplate", clips_environment_find_deftemplate, 1);
+	rb_define_singleton_method(rbEnvironment, "find_defclass", clips_environment_static_find_defclass, 2);
+	rb_define_method(rbEnvironment, "find_defclass", clips_environment_find_defclass, 1);
 	rb_define_singleton_method(rbEnvironment, "get_current_module", clips_environment_static_get_current_module, 1);
 	rb_define_method(rbEnvironment, "get_current_module", clips_environment_get_current_module, 0);
 	rb_define_singleton_method(rbEnvironment, "set_current_module", clips_environment_static_set_current_module, 2);
@@ -3160,6 +3514,8 @@ void Init_clipsruby(void)
 	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, "get_defclass_list", clips_environment_static_get_defclass_list, -1);
+	rb_define_method(rbEnvironment, "get_defclass_list", clips_environment_get_defclass_list, -1);
 	rb_define_singleton_method(rbEnvironment, "get_defrule_list", clips_environment_static_get_defrule_list, -1);
 	rb_define_method(rbEnvironment, "get_defrule_list", clips_environment_get_defrule_list, -1);
 	rb_define_singleton_method(rbEnvironment, "get_defmodule_list", clips_environment_static_get_defmodule_list, 1);
@@ -3232,6 +3588,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);
@@ -3283,6 +3641,8 @@ void Init_clipsruby(void)
 	rb_define_method(rbDefmodule, "pp_form", clips_environment_defmodule_pp_form, 0);
 	rb_define_singleton_method(rbDefmodule, "set_current", clips_environment_defmodule_static_set_current, 1);
 	rb_define_method(rbDefmodule, "set_current", clips_environment_defmodule_set_current, 0);
+	rb_define_singleton_method(rbDefmodule, "get_defclass_list", clips_environment_defmodule_static_get_defclass_list, 1);
+	rb_define_method(rbDefmodule, "get_defclass_list", clips_environment_defmodule_get_defclass_list, 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);
@@ -3332,5 +3692,25 @@ void Init_clipsruby(void)
 	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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: clipsruby
 version: !ruby/object:Gem::Version
-  version: 0.0.32
+  version: 0.0.34
 platform: ruby
 authors:
 - Ryan Johnston