clipsruby 0.0.24 → 0.0.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1efd15213fd7f558c0b75e64869e6518a12c1c55da8d6d94bf306235f4879a67
-  data.tar.gz: b30352c0431948b03849579a92a0e96dde42368f6e78b051adc2f02b68c8c4c8
+  metadata.gz: fb3538a29ed740232a6a18314da3443bf632274e06fcb893cba9c70b0797353d
+  data.tar.gz: 49d5cf4c8e4435fb0b35cfe2434f2aeb12f0563e859c9b0fc93fb8d64b47ee29
 SHA512:
-  metadata.gz: 5e55eac1476475ecb1f5b5b998cab1aa108dc0fcbe86905565c3b9256c4855ac796cdd9a28602289dec062c9481ac6340d17c7d22b98b1baf2b0b9e3f338136a
-  data.tar.gz: 31c41a7c633cc0707bdfc77e9e9c5b97b2d97d75f8202ce0d7450f7366ec9ee0e2939bcd91d7c228d3d96459ff516eb6f81959981cb1414b53f8c8ee514c6dea
+  metadata.gz: 1bb0d0617bcf972ca6cbad967ff271e697920e21442d978ce9ee289c0f7e81f53b30fe1b722e334649ed274b62f10e2728683f8e5df84853f3ca6575f8a11444
+  data.tar.gz: 66b6617635f3ba892008749dee6645cbc6652e3815b19c37bea2eb752a231d342c0d0ab1873faae8bc14e07b238c2b298f3574907ef4fae7d7dae0a0cd0a30bd

data/README.md

@@ -621,6 +621,51 @@ CLIPS::Environment::Deftemplate.slot_default_value(deftemplate, :foo)
 deftemplate.slot_default_value('bar')
 ```
 
+### `CLIPS::Environment::Deftemplate.slot_types`
+### `CLIPS::Environment::Deftemplate#slot_types`
+
+Returns the slot type(s) for the named slot of a deftemplate as symbols.
+Possible types are as follows:
+
+```ruby
+:SYMBOL
+:STRING
+:LEXEME
+:INTEGER
+:FLOAT
+:NUMBER
+:"INSTANCE-NAME"
+:"INSTANCE-ADDRESS"
+:INSTANCE
+:"EXTERNAL-ADDRESS"
+:"FACT-ADDRESS"
+```
+
+```ruby
+CLIPS::Environment::Deftemplate.slot_types(deftemplate, :foo)
+deftemplate.slot_types('bar')
+```
+
+### `CLIPS::Environment::Deftemplate.slot_range`
+### `CLIPS::Environment::Deftemplate#slot_range`
+
+Returns the range of a named slot of a deftemplate as integers or symbols (in case of infinity).
+
+```ruby
+CLIPS::Environment::Deftemplate.slot_range(deftemplate, :foo)
+deftemplate.slot_range('bar')
+```
+
+### `CLIPS::Environment::Deftemplate.slot_cardinality`
+### `CLIPS::Environment::Deftemplate#slot_cardinality`
+
+Returns the cardinality of a named slot of a deftemplate as integers or symbols (in case of infinity).
+
+```ruby
+CLIPS::Environment::Deftemplate.slot_cardinality(deftemplate, :foo)
+deftemplate.slot_cardinality('bar')
+```
+
 ### `CLIPS::Environment::Defmodule.get_deftemplate_list`
 ### `CLIPS::Environment::Defmodule#get_deftemplate_list`
 
@@ -661,6 +706,54 @@ CLIPS::Environment::Deffacts.pp_form(deffacts)
 deffacts.pp_form
 ```
 
+### `CLIPS::Environment.watch`
+### `env.watch`
+### `CLIPS::Environment.unwatch`
+### `env.unwatch`
+
+"Watch" or "Unwatch" a specific thing that happens in the CLIPS environment.
+There are several things that may be watched (or unwatched) such that CLIPS will
+report debugging information to `STDOUT`. This gem provides two ways to watch
+or unwatch a debug item: either pass the watch item as a symbol to `watch` or
+`unwatch`, or use the corresponding `watch_foo` or `unwatch_foo` methods where
+`foo` is replaced by the watch item (as listed):
+
+```ruby
+:all
+:facts
+:instances
+:slots
+:rules
+:activations
+:messages
+:message_handlers
+:generic_functions
+:methods
+:deffunctions
+:compilations
+:statistics
+:globals
+:focus
+```
+
+```ruby
+CLIPS::Environment.watch_facts
+env.watch_statistics
+CLIPS::Environment.unwatch(:facts)
+env.unwatch(:statistics)
+```
+
+### `CLIPS::Environment.get_watch_state`
+### `env.get_watch_state`
+
+Returns a bool representing whether or not the given debug item
+is currently being watched in the environment.
+
+```ruby
+CLIPS::Environment.get_watch_state(env, :facts)
+env.get_watch_state(:methods)
+```
+
 ## Running the tests
 
 Simply do `rake compile` and then `rake test` in order to run the tests.

data/ext/clipsruby/clipsruby.c

@@ -1300,6 +1300,99 @@ static VALUE clips_environment_deftemplate_static_slot_default_value(VALUE self,
 }
 
 
+static VALUE clips_environment_deftemplate_slot_types(VALUE self, VALUE slot_name)
+{
+	Deftemplate *template;
+	CLIPSValue slot_types;
+	VALUE out;
+	VALUE rbEnvironment = rb_iv_get(self, "@environment");
+
+	TypedData_Get_Struct(self, Deftemplate, &Deftemplate_type, template);
+
+	switch (TYPE(slot_name)) {
+		case T_STRING:
+			DeftemplateSlotTypes(template, StringValueCStr(slot_name), &slot_types);
+			break;
+		case T_SYMBOL:
+			DeftemplateSlotTypes(template, rb_id2name(SYM2ID(slot_name)), &slot_types);
+			break;
+                default:
+			rb_warn("slot name must be string or symbol in call to slot_types!");
+			return Qnil;
+        }
+
+	CLIPSValue_to_VALUE(&slot_types, &out, &rbEnvironment);
+
+	return out;
+}
+
+static VALUE clips_environment_deftemplate_static_slot_types(VALUE self, VALUE rbEnvironment, VALUE slot_name)
+{
+	return clips_environment_deftemplate_slot_types(rbEnvironment, slot_name);
+}
+
+static VALUE clips_environment_deftemplate_slot_range(VALUE self, VALUE slot_name)
+{
+	Deftemplate *template;
+	CLIPSValue slot_range;
+	VALUE out;
+	VALUE rbEnvironment = rb_iv_get(self, "@environment");
+
+	TypedData_Get_Struct(self, Deftemplate, &Deftemplate_type, template);
+
+	switch (TYPE(slot_name)) {
+		case T_STRING:
+			DeftemplateSlotRange(template, StringValueCStr(slot_name), &slot_range);
+			break;
+		case T_SYMBOL:
+			DeftemplateSlotRange(template, rb_id2name(SYM2ID(slot_name)), &slot_range);
+			break;
+                default:
+			rb_warn("slot name must be string or symbol in call to slot_range!");
+			return Qnil;
+        }
+
+	CLIPSValue_to_VALUE(&slot_range, &out, &rbEnvironment);
+
+	return out;
+}
+
+static VALUE clips_environment_deftemplate_static_slot_range(VALUE self, VALUE rbEnvironment, VALUE slot_name)
+{
+	return clips_environment_deftemplate_slot_range(rbEnvironment, slot_name);
+}
+
+static VALUE clips_environment_deftemplate_slot_cardinality(VALUE self, VALUE slot_name)
+{
+	Deftemplate *template;
+	CLIPSValue slot_cardinality;
+	VALUE out;
+	VALUE rbEnvironment = rb_iv_get(self, "@environment");
+
+	TypedData_Get_Struct(self, Deftemplate, &Deftemplate_type, template);
+
+	switch (TYPE(slot_name)) {
+		case T_STRING:
+			DeftemplateSlotCardinality(template, StringValueCStr(slot_name), &slot_cardinality);
+			break;
+		case T_SYMBOL:
+			DeftemplateSlotCardinality(template, rb_id2name(SYM2ID(slot_name)), &slot_cardinality);
+			break;
+                default:
+			rb_warn("slot name must be string or symbol in call to slot_cardinality!");
+			return Qnil;
+        }
+
+	CLIPSValue_to_VALUE(&slot_cardinality, &out, &rbEnvironment);
+
+	return out;
+}
+
+static VALUE clips_environment_deftemplate_static_slot_cardinality(VALUE self, VALUE rbEnvironment, VALUE slot_name)
+{
+	return clips_environment_deftemplate_slot_cardinality(rbEnvironment, slot_name);
+}
+
 static VALUE clips_environment_fact_retract(VALUE self)
 {
 	Fact *fact;
@@ -2051,6 +2144,644 @@ static VALUE clips_environment_defrule_static_remove_break(VALUE self, VALUE rbD
 	return clips_environment_defrule_remove_break(rbDefrule);
 }
 
+static VALUE clips_environment_watch(VALUE self, VALUE item)
+{
+	Environment *env;
+	WatchItem watchItem;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	if (item == ID2SYM(rb_intern("all"))) {
+		watchItem = ALL;
+	} else if (item == ID2SYM(rb_intern("facts"))) {
+		watchItem = FACTS;
+	} else if (item == ID2SYM(rb_intern("instances"))) {
+		watchItem = INSTANCES;
+	} else if (item == ID2SYM(rb_intern("slots"))) {
+		watchItem = SLOTS;
+	} else if (item == ID2SYM(rb_intern("rules"))) {
+		watchItem = RULES;
+	} else if (item == ID2SYM(rb_intern("activations"))) {
+		watchItem = ACTIVATIONS;
+	} else if (item == ID2SYM(rb_intern("messages"))) {
+		watchItem = MESSAGES;
+	} else if (item == ID2SYM(rb_intern("message_handlers"))) {
+		watchItem = MESSAGE_HANDLERS;
+	} else if (item == ID2SYM(rb_intern("generic_functions"))) {
+		watchItem = GENERIC_FUNCTIONS;
+	} else if (item == ID2SYM(rb_intern("methods"))) {
+		watchItem = METHODS;
+	} else if (item == ID2SYM(rb_intern("deffunctions"))) {
+		watchItem = DEFFUNCTIONS;
+	} else if (item == ID2SYM(rb_intern("compilations"))) {
+		watchItem = COMPILATIONS;
+	} else if (item == ID2SYM(rb_intern("statistics"))) {
+		watchItem = STATISTICS;
+	} else if (item == ID2SYM(rb_intern("globals"))) {
+		watchItem = GLOBALS;
+	} else if (item == ID2SYM(rb_intern("focus"))) {
+		watchItem = FOCUS;
+	} else {
+		rb_warn("unknown watch item");
+		return Qnil;
+	}
+
+	Watch(env, watchItem);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_watch(VALUE self, VALUE rbEnvironment, VALUE item)
+{
+	return clips_environment_watch(rbEnvironment, item);
+}
+
+static VALUE clips_environment_unwatch(VALUE self, VALUE item)
+{
+	Environment *env;
+	WatchItem watchItem;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	if (item == ID2SYM(rb_intern("all"))) {
+		watchItem = ALL;
+	} else if (item == ID2SYM(rb_intern("facts"))) {
+		watchItem = FACTS;
+	} else if (item == ID2SYM(rb_intern("instances"))) {
+		watchItem = INSTANCES;
+	} else if (item == ID2SYM(rb_intern("slots"))) {
+		watchItem = SLOTS;
+	} else if (item == ID2SYM(rb_intern("rules"))) {
+		watchItem = RULES;
+	} else if (item == ID2SYM(rb_intern("activations"))) {
+		watchItem = ACTIVATIONS;
+	} else if (item == ID2SYM(rb_intern("messages"))) {
+		watchItem = MESSAGES;
+	} else if (item == ID2SYM(rb_intern("message_handlers"))) {
+		watchItem = MESSAGE_HANDLERS;
+	} else if (item == ID2SYM(rb_intern("generic_functions"))) {
+		watchItem = GENERIC_FUNCTIONS;
+	} else if (item == ID2SYM(rb_intern("methods"))) {
+		watchItem = METHODS;
+	} else if (item == ID2SYM(rb_intern("deffunctions"))) {
+		watchItem = DEFFUNCTIONS;
+	} else if (item == ID2SYM(rb_intern("compilations"))) {
+		watchItem = COMPILATIONS;
+	} else if (item == ID2SYM(rb_intern("statistics"))) {
+		watchItem = STATISTICS;
+	} else if (item == ID2SYM(rb_intern("globals"))) {
+		watchItem = GLOBALS;
+	} else if (item == ID2SYM(rb_intern("focus"))) {
+		watchItem = FOCUS;
+	} else {
+		rb_warn("unknown watch item");
+		return Qnil;
+	}
+
+	Unwatch(env, watchItem);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_unwatch(VALUE self, VALUE rbEnvironment, VALUE item)
+{
+	return clips_environment_unwatch(rbEnvironment, item);
+}
+
+static VALUE clips_environment_watch_all(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Watch(env, ALL);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_watch_all(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_watch_all(rbEnvironment);
+}
+
+static VALUE clips_environment_watch_facts(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Watch(env, FACTS);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_watch_facts(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_watch_facts(rbEnvironment);
+}
+
+static VALUE clips_environment_watch_instances(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Watch(env, INSTANCES);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_watch_instances(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_watch_instances(rbEnvironment);
+}
+
+static VALUE clips_environment_watch_slots(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Watch(env, SLOTS);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_watch_slots(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_watch_slots(rbEnvironment);
+}
+
+static VALUE clips_environment_watch_rules(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Watch(env, RULES);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_watch_rules(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_watch_rules(rbEnvironment);
+}
+
+static VALUE clips_environment_watch_activations(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Watch(env, ACTIVATIONS);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_watch_activations(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_watch_activations(rbEnvironment);
+}
+
+static VALUE clips_environment_watch_messages(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Watch(env, MESSAGES);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_watch_messages(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_watch_messages(rbEnvironment);
+}
+
+static VALUE clips_environment_watch_message_handlers(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Watch(env, MESSAGE_HANDLERS);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_watch_message_handlers(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_watch_message_handlers(rbEnvironment);
+}
+
+static VALUE clips_environment_watch_generic_functions(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Watch(env, GENERIC_FUNCTIONS);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_watch_generic_functions(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_watch_generic_functions(rbEnvironment);
+}
+
+static VALUE clips_environment_watch_methods(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Watch(env, METHODS);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_watch_methods(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_watch_methods(rbEnvironment);
+}
+
+static VALUE clips_environment_watch_deffunctions(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Watch(env, DEFFUNCTIONS);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_watch_deffunctions(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_watch_deffunctions(rbEnvironment);
+}
+
+static VALUE clips_environment_watch_compilations(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Watch(env, COMPILATIONS);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_watch_compilations(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_watch_compilations(rbEnvironment);
+}
+
+static VALUE clips_environment_watch_statistics(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Watch(env, STATISTICS);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_watch_statistics(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_watch_statistics(rbEnvironment);
+}
+
+static VALUE clips_environment_watch_globals(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Watch(env, GLOBALS);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_watch_globals(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_watch_globals(rbEnvironment);
+}
+
+static VALUE clips_environment_watch_focus(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Watch(env, FOCUS);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_watch_focus(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_watch_focus(rbEnvironment);
+}
+
+static VALUE clips_environment_unwatch_all(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Unwatch(env, ALL);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_unwatch_all(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_unwatch_all(rbEnvironment);
+}
+
+static VALUE clips_environment_unwatch_facts(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Unwatch(env, FACTS);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_unwatch_facts(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_unwatch_facts(rbEnvironment);
+}
+
+static VALUE clips_environment_unwatch_instances(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Unwatch(env, INSTANCES);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_unwatch_instances(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_unwatch_instances(rbEnvironment);
+}
+
+static VALUE clips_environment_unwatch_slots(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Unwatch(env, SLOTS);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_unwatch_slots(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_unwatch_slots(rbEnvironment);
+}
+
+static VALUE clips_environment_unwatch_rules(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Unwatch(env, RULES);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_unwatch_rules(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_unwatch_rules(rbEnvironment);
+}
+
+static VALUE clips_environment_unwatch_activations(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Unwatch(env, ACTIVATIONS);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_unwatch_activations(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_unwatch_activations(rbEnvironment);
+}
+
+static VALUE clips_environment_unwatch_messages(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Unwatch(env, MESSAGES);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_unwatch_messages(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_unwatch_messages(rbEnvironment);
+}
+
+static VALUE clips_environment_unwatch_message_handlers(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Unwatch(env, MESSAGE_HANDLERS);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_unwatch_message_handlers(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_unwatch_message_handlers(rbEnvironment);
+}
+
+static VALUE clips_environment_unwatch_generic_functions(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Unwatch(env, GENERIC_FUNCTIONS);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_unwatch_generic_functions(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_unwatch_generic_functions(rbEnvironment);
+}
+
+static VALUE clips_environment_unwatch_methods(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Unwatch(env, METHODS);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_unwatch_methods(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_unwatch_methods(rbEnvironment);
+}
+
+static VALUE clips_environment_unwatch_deffunctions(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Unwatch(env, DEFFUNCTIONS);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_unwatch_deffunctions(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_unwatch_deffunctions(rbEnvironment);
+}
+
+static VALUE clips_environment_unwatch_compilations(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Unwatch(env, COMPILATIONS);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_unwatch_compilations(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_unwatch_compilations(rbEnvironment);
+}
+
+static VALUE clips_environment_unwatch_statistics(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Unwatch(env, STATISTICS);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_unwatch_statistics(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_unwatch_statistics(rbEnvironment);
+}
+
+static VALUE clips_environment_unwatch_globals(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Unwatch(env, GLOBALS);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_unwatch_globals(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_unwatch_globals(rbEnvironment);
+}
+
+static VALUE clips_environment_unwatch_focus(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	Unwatch(env, FOCUS);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_unwatch_focus(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_unwatch_focus(rbEnvironment);
+}
+
+static VALUE clips_environment_get_watch_state(VALUE self, VALUE item)
+{
+	Environment *env;
+	WatchItem watchItem;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	if (item == ID2SYM(rb_intern("all"))) {
+		watchItem = ALL;
+	} else if (item == ID2SYM(rb_intern("facts"))) {
+		watchItem = FACTS;
+	} else if (item == ID2SYM(rb_intern("instances"))) {
+		watchItem = INSTANCES;
+	} else if (item == ID2SYM(rb_intern("slots"))) {
+		watchItem = SLOTS;
+	} else if (item == ID2SYM(rb_intern("rules"))) {
+		watchItem = RULES;
+	} else if (item == ID2SYM(rb_intern("activations"))) {
+		watchItem = ACTIVATIONS;
+	} else if (item == ID2SYM(rb_intern("messages"))) {
+		watchItem = MESSAGES;
+	} else if (item == ID2SYM(rb_intern("message_handlers"))) {
+		watchItem = MESSAGE_HANDLERS;
+	} else if (item == ID2SYM(rb_intern("generic_functions"))) {
+		watchItem = GENERIC_FUNCTIONS;
+	} else if (item == ID2SYM(rb_intern("methods"))) {
+		watchItem = METHODS;
+	} else if (item == ID2SYM(rb_intern("deffunctions"))) {
+		watchItem = DEFFUNCTIONS;
+	} else if (item == ID2SYM(rb_intern("compilations"))) {
+		watchItem = COMPILATIONS;
+	} else if (item == ID2SYM(rb_intern("statistics"))) {
+		watchItem = STATISTICS;
+	} else if (item == ID2SYM(rb_intern("globals"))) {
+		watchItem = GLOBALS;
+	} else if (item == ID2SYM(rb_intern("focus"))) {
+		watchItem = FOCUS;
+	} else {
+		rb_warn("unknown watch item");
+		return Qnil;
+	}
+
+	if (GetWatchState(env, watchItem)) {
+		return Qtrue;
+	} else {
+		return Qfalse;
+	}
+}
+
+static VALUE clips_environment_static_get_watch_state(VALUE self, VALUE rbEnvironment, VALUE item)
+{
+	return clips_environment_get_watch_state(rbEnvironment, item);
+}
+
 void Init_clipsruby(void)
 {
 	VALUE rbCLIPS = rb_define_module("CLIPS");
@@ -2114,6 +2845,72 @@ void Init_clipsruby(void)
 	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);
+	rb_define_singleton_method(rbEnvironment, "watch", clips_environment_static_watch, 2);
+	rb_define_method(rbEnvironment, "watch", clips_environment_watch, 1);
+	rb_define_singleton_method(rbEnvironment, "watch_all", clips_environment_static_watch_all, 1);
+	rb_define_method(rbEnvironment, "watch_all", clips_environment_watch_all, 0);
+	rb_define_singleton_method(rbEnvironment, "watch_facts", clips_environment_static_watch_facts, 1);
+	rb_define_method(rbEnvironment, "watch_facts", clips_environment_watch_facts, 0);
+	rb_define_singleton_method(rbEnvironment, "watch_instances", clips_environment_static_watch_instances, 1);
+	rb_define_method(rbEnvironment, "watch_instances", clips_environment_watch_instances, 0);
+	rb_define_singleton_method(rbEnvironment, "watch_slots", clips_environment_static_watch_slots, 1);
+	rb_define_method(rbEnvironment, "watch_slots", clips_environment_watch_slots, 0);
+	rb_define_singleton_method(rbEnvironment, "watch_rules", clips_environment_static_watch_rules, 1);
+	rb_define_method(rbEnvironment, "watch_rules", clips_environment_watch_rules, 0);
+	rb_define_singleton_method(rbEnvironment, "watch_activations", clips_environment_static_watch_activations, 1);
+	rb_define_method(rbEnvironment, "watch_activations", clips_environment_watch_activations, 0);
+	rb_define_singleton_method(rbEnvironment, "watch_messages", clips_environment_static_watch_messages, 1);
+	rb_define_method(rbEnvironment, "watch_messages", clips_environment_watch_messages, 0);
+	rb_define_singleton_method(rbEnvironment, "watch_message_handlers", clips_environment_static_watch_message_handlers, 1);
+	rb_define_method(rbEnvironment, "watch_message_handlers", clips_environment_watch_message_handlers, 0);
+	rb_define_singleton_method(rbEnvironment, "watch_generic_functions", clips_environment_static_watch_generic_functions, 1);
+	rb_define_method(rbEnvironment, "watch_generic_functions", clips_environment_watch_generic_functions, 0);
+	rb_define_singleton_method(rbEnvironment, "watch_methods", clips_environment_static_watch_methods, 1);
+	rb_define_method(rbEnvironment, "watch_methods", clips_environment_watch_methods, 0);
+	rb_define_singleton_method(rbEnvironment, "watch_deffunctions", clips_environment_static_watch_deffunctions, 1);
+	rb_define_method(rbEnvironment, "watch_deffunctions", clips_environment_watch_deffunctions, 0);
+	rb_define_singleton_method(rbEnvironment, "watch_compilations", clips_environment_static_watch_compilations, 1);
+	rb_define_method(rbEnvironment, "watch_compilations", clips_environment_watch_compilations, 0);
+	rb_define_singleton_method(rbEnvironment, "watch_statistics", clips_environment_static_watch_statistics, 1);
+	rb_define_method(rbEnvironment, "watch_statistics", clips_environment_watch_statistics, 0);
+	rb_define_singleton_method(rbEnvironment, "watch_globals", clips_environment_static_watch_globals, 1);
+	rb_define_method(rbEnvironment, "watch_globals", clips_environment_watch_globals, 0);
+	rb_define_singleton_method(rbEnvironment, "watch_focus", clips_environment_static_watch_focus, 1);
+	rb_define_method(rbEnvironment, "watch_focus", clips_environment_watch_focus, 0);
+	rb_define_singleton_method(rbEnvironment, "unwatch", clips_environment_static_unwatch, 2);
+	rb_define_method(rbEnvironment, "unwatch", clips_environment_unwatch, 1);
+	rb_define_singleton_method(rbEnvironment, "unwatch_all", clips_environment_static_unwatch_all, 1);
+	rb_define_method(rbEnvironment, "unwatch_all", clips_environment_unwatch_all, 0);
+	rb_define_singleton_method(rbEnvironment, "unwatch_facts", clips_environment_static_unwatch_facts, 1);
+	rb_define_method(rbEnvironment, "unwatch_facts", clips_environment_unwatch_facts, 0);
+	rb_define_singleton_method(rbEnvironment, "unwatch_instances", clips_environment_static_unwatch_instances, 1);
+	rb_define_method(rbEnvironment, "unwatch_instances", clips_environment_unwatch_instances, 0);
+	rb_define_singleton_method(rbEnvironment, "unwatch_slots", clips_environment_static_unwatch_slots, 1);
+	rb_define_method(rbEnvironment, "unwatch_slots", clips_environment_unwatch_slots, 0);
+	rb_define_singleton_method(rbEnvironment, "unwatch_rules", clips_environment_static_unwatch_rules, 1);
+	rb_define_method(rbEnvironment, "unwatch_rules", clips_environment_unwatch_rules, 0);
+	rb_define_singleton_method(rbEnvironment, "unwatch_activations", clips_environment_static_unwatch_activations, 1);
+	rb_define_method(rbEnvironment, "unwatch_activations", clips_environment_unwatch_activations, 0);
+	rb_define_singleton_method(rbEnvironment, "unwatch_messages", clips_environment_static_unwatch_messages, 1);
+	rb_define_method(rbEnvironment, "unwatch_messages", clips_environment_unwatch_messages, 0);
+	rb_define_singleton_method(rbEnvironment, "unwatch_message_handlers", clips_environment_static_unwatch_message_handlers, 1);
+	rb_define_method(rbEnvironment, "unwatch_message_handlers", clips_environment_unwatch_message_handlers, 0);
+	rb_define_singleton_method(rbEnvironment, "unwatch_generic_functions", clips_environment_static_unwatch_generic_functions, 1);
+	rb_define_method(rbEnvironment, "unwatch_generic_functions", clips_environment_unwatch_generic_functions, 0);
+	rb_define_singleton_method(rbEnvironment, "unwatch_methods", clips_environment_static_unwatch_methods, 1);
+	rb_define_method(rbEnvironment, "unwatch_methods", clips_environment_unwatch_methods, 0);
+	rb_define_singleton_method(rbEnvironment, "unwatch_deffunctions", clips_environment_static_unwatch_deffunctions, 1);
+	rb_define_method(rbEnvironment, "unwatch_deffunctions", clips_environment_unwatch_deffunctions, 0);
+	rb_define_singleton_method(rbEnvironment, "unwatch_compilations", clips_environment_static_unwatch_compilations, 1);
+	rb_define_method(rbEnvironment, "unwatch_compilations", clips_environment_unwatch_compilations, 0);
+	rb_define_singleton_method(rbEnvironment, "unwatch_statistics", clips_environment_static_unwatch_statistics, 1);
+	rb_define_method(rbEnvironment, "unwatch_statistics", clips_environment_unwatch_statistics, 0);
+	rb_define_singleton_method(rbEnvironment, "unwatch_globals", clips_environment_static_unwatch_globals, 1);
+	rb_define_method(rbEnvironment, "unwatch_globals", clips_environment_unwatch_globals, 0);
+	rb_define_singleton_method(rbEnvironment, "unwatch_focus", clips_environment_static_unwatch_focus, 1);
+	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);
 
 	VALUE rbDeffacts = rb_define_class_under(rbEnvironment, "Deffacts", rb_cObject);
 	rb_define_alloc_func(rbDeffacts, deffacts_alloc);
@@ -2140,6 +2937,12 @@ void Init_clipsruby(void)
 	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);
+	rb_define_singleton_method(rbDeftemplate, "slot_types", clips_environment_deftemplate_static_slot_types, 2);
+	rb_define_method(rbDeftemplate, "slot_types", clips_environment_deftemplate_slot_types, 1);
+	rb_define_singleton_method(rbDeftemplate, "slot_range", clips_environment_deftemplate_static_slot_range, 2);
+	rb_define_method(rbDeftemplate, "slot_range", clips_environment_deftemplate_slot_range, 1);
+	rb_define_singleton_method(rbDeftemplate, "slot_cardinality", clips_environment_deftemplate_static_slot_cardinality, 2);
+	rb_define_method(rbDeftemplate, "slot_cardinality", clips_environment_deftemplate_slot_cardinality, 1);
 
 	VALUE rbDefmodule = rb_define_class_under(rbEnvironment, "Defmodule", rb_cObject);
 	rb_define_alloc_func(rbDefmodule, defmodule_alloc);

metadata

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