clipsruby 0.0.42 → 0.0.44

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abe99d4312fdbfdef1029a782a1fba4300a125c4509da2d567de45beedcbd6b3
-  data.tar.gz: e97ad52abe0327927ac725d232abb2768ba0f19664f49045400b3be9697860a2
+  metadata.gz: 83db571b1b54cd6848878cfd5422841e150e51f11b5616640460bce6bac024ef
+  data.tar.gz: 5a25ab26198c8d7b1e92fa8d6c903f01455ac36c7eeaa307255002c45733e55c
 SHA512:
-  metadata.gz: c95269f840906a2dbb7cc334b4a96e94d11ad88371bed342ae184ffec38e3496cd0a09407f0d2f1de18e340212592df2993bbe601e3acbe943345cc17ef569d8
-  data.tar.gz: c091dc218dd4becdcb69a8670339528ab5ab247b0c01256e6e1c796e827a65880743a3599113c55439e9c1afb63bc27705599c1ea965c82ab4baef83612d9310
+  metadata.gz: 3ce8105ae4ebab196499a520513f56f1b433c712d14e0d3f87f0febe3f20b2dd156bc21c0c69ece6fd9990e5775aa92bd274a231b58bbdf66892ca0975cb46d4
+  data.tar.gz: b375fdfb92af2c1aa02add709b983c1b81cc1376393017026526ca8ac17a8bb6f1aba0776a264bd9eebbceab1d4cc885649a3c8c333eb8b93ec91253c100e8f4

data/README.md

@@ -401,6 +401,15 @@ CLIPS::Environment.find_defmodule(:a)
 env.find_defmodule("foo")
 ```
 
+#### `CLIPS::Environment.get_activation_list` / `CLIPS::Environment#get_activation_list`
+
+Return an array of Activation objects in the current demodule.
+
+```ruby
+CLIPS::Environment.get_activation_list
+env.get_activation_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
@@ -850,6 +859,19 @@ CLIPS::Environment::Defrule.salience(defrule)
 defrule.salience
 ```
 
+#### `CLIPS::Environment::Defrule.matches` / `CLIPS::Environment::Defrule#matches`
+
+Returns an array holding the number of pattern matches, partial matches,
+and activations for a given rule. Pass a first argument of
+`:verbose`, `:succinct`, or `:terse` to determine the amount of information
+to print to `STDOUT` (`:verbose` by default).
+
+```ruby
+CLIPS::Environment::Defrule.matches(defrule, :succinct)
+defrule.matches(:terse)
+[pattern, partial, activations] = defrule.matches
+```
+
 ### Defmodule Methods
 
 #### `CLIPS::Environment::Defmodule.name` / `CLIPS::Environment::Defmodule#name`
@@ -1141,6 +1163,17 @@ CLIPS::Environment::Deffacts.pp_form(deffacts)
 deffacts.pp_form
 ```
 
+### Activation Methods
+
+#### `CLIPS::Environment::Activation.defule_name` / `CLIPS::Environment::Activation#defule_name`
+
+Returns the name of a defrule that triggered this activation.
+
+```ruby
+CLIPS::Environment::Activation.defrule_name
+activation.defrule_name
+```
+
 ## Running the tests
 
 Simply do `rake compile` and then `rake test` in order to run the tests.

data/ext/clipsruby/clipsruby.c

@@ -103,6 +103,18 @@ static const rb_data_type_t Instance_type = {
 	.flags = RUBY_TYPED_FREE_IMMEDIATELY
 };
 
+size_t activation_size(const void *data)
+{
+	return sizeof(Activation);
+}
+
+static const rb_data_type_t Activation_type = {
+	.function = {
+		.dsize = activation_size
+	},
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
 static VALUE clips_environment_fact_deftemplate(VALUE self)
 {
 	VALUE rbDeftemplate, rbEnvironment;
@@ -276,6 +288,11 @@ VALUE instance_alloc(VALUE self)
 	return TypedData_Wrap_Struct(self, &Instance_type, NULL);
 }
 
+VALUE activation_alloc(VALUE self)
+{
+	return TypedData_Wrap_Struct(self, &Activation_type, NULL);
+}
+
 VALUE environment_alloc(VALUE self)
 {
 	return TypedData_Wrap_Struct(self, &Environment_type, CreateEnvironment());
@@ -1633,6 +1650,63 @@ static VALUE clips_environment_defclass_static_slots(int argc, VALUE *argv, VALU
 	return out;
 }
 
+static VALUE clips_environment_defrule_matches(int argc, VALUE *argv, VALUE rbDefrule)
+{
+	VALUE verbosity, rbEnvironment, out;
+	Defrule *defrule;
+	CLIPSValue value;
+
+	rb_scan_args(argc, argv, "01", &verbosity);
+
+	TypedData_Get_Struct(rbDefrule, Defrule, &Defrule_type, defrule);
+
+	rbEnvironment = rb_iv_get(rbDefrule, "@environment");
+
+	if (NIL_P(verbosity) || verbosity == ID2SYM(rb_intern("verbose"))) {
+		Matches(defrule, VERBOSE, &value);
+	} else if (verbosity == ID2SYM(rb_intern("succinct"))) {
+		Matches(defrule, SUCCINCT, &value);
+	} else if (verbosity == ID2SYM(rb_intern("terse"))) {
+		Matches(defrule, TERSE, &value);
+	} else {
+		rb_warn("could not find matches for defrule: unsupported verbosity.");
+		return Qnil;
+	}
+
+	CLIPSValue_to_VALUE(&value, &out, &rbEnvironment);
+
+	return out;
+}
+
+
+static VALUE clips_environment_defrule_static_matches(int argc, VALUE *argv, VALUE klass)
+{
+	VALUE rbDefrule, verbosity, rbEnvironment, out;
+	Defrule *defrule;
+	CLIPSValue value;
+
+	rb_scan_args(argc, argv, "11", &rbDefrule, &verbosity);
+
+	TypedData_Get_Struct(rbDefrule, Defrule, &Defrule_type, defrule);
+
+	rbEnvironment = rb_iv_get(rbDefrule, "@environment");
+
+	if (verbosity == ID2SYM(rb_intern("verbose"))) {
+		Matches(defrule, VERBOSE, &value);
+	} else if (verbosity == ID2SYM(rb_intern("succinct"))) {
+		Matches(defrule, SUCCINCT, &value);
+	} else if (verbosity == ID2SYM(rb_intern("terse"))) {
+		Matches(defrule, TERSE, &value);
+	} else {
+		rb_warn("could not find matches for defrule: unsupported verbosity.");
+		return Qnil;
+	}
+
+	CLIPSValue_to_VALUE(&value, &out, &rbEnvironment);
+
+	return out;
+}
+
 static VALUE clips_environment_run(int argc, VALUE *argv, VALUE environment) {
 	VALUE integer;
 	Environment *env;
@@ -2953,6 +3027,53 @@ static VALUE clips_environment_defmodule_static_find_instance(int argc, VALUE *a
 	}
 }
 
+static VALUE clips_environment_defmodule_refresh_agenda(VALUE self)
+{
+	Defmodule *module;
+
+	TypedData_Get_Struct(self, Defmodule, &Defmodule_type, module);
+
+	RefreshAgenda(module);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_defmodule_static_refresh_agenda(VALUE self, VALUE rbDefmodule)
+{
+	return clips_environment_defmodule_refresh_agenda(rbDefmodule);
+}
+
+static VALUE clips_environment_defmodule_reorder_agenda(VALUE self)
+{
+	Defmodule *module;
+
+	TypedData_Get_Struct(self, Defmodule, &Defmodule_type, module);
+
+	ReorderAgenda(module);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_defmodule_static_reorder_agenda(VALUE self, VALUE rbDefmodule)
+{
+	return clips_environment_defmodule_reorder_agenda(rbDefmodule);
+}
+
+static VALUE clips_environment_defmodule_delete_all_activations(VALUE self)
+{
+	Defmodule *module;
+
+	TypedData_Get_Struct(self, Defmodule, &Defmodule_type, module);
+
+	DeleteAllActivations(module);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_defmodule_static_delete_all_activations(VALUE self, VALUE rbDefmodule)
+{
+	return clips_environment_defmodule_delete_all_activations(rbDefmodule);
+}
 
 static VALUE clips_environment_find_deftemplate(VALUE self, VALUE deftemplate_name)
 {
@@ -3748,6 +3869,36 @@ static VALUE clips_environment_static_get_defmodule_list(VALUE self, VALUE rbEnv
 	return clips_environment_get_defmodule_list(rbEnvironment);
 }
 
+static VALUE clips_environment_get_activation_list(VALUE self)
+{
+	Activation *theActivation;
+	Environment *env;
+	VALUE rbActivation, returnArray;
+
+	returnArray = rb_ary_new2(0);
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	for (
+		theActivation = GetNextActivation(env,NULL);
+		theActivation != NULL;
+		theActivation = GetNextActivation(env,theActivation)
+	) {
+		rbActivation =
+			TypedData_Wrap_Struct(rb_const_get(CLASS_OF(self), rb_intern("Activation")), &Activation_type, theActivation);
+
+		rb_iv_set(rbActivation, "@environment", self);
+		rb_ary_push(returnArray, rbActivation);
+	}
+
+	return returnArray;
+}
+
+static VALUE clips_environment_static_get_activation_list(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_get_activation_list(rbEnvironment);
+}
+
 static VALUE clips_environment_defrule_name(VALUE self)
 {
 	Defrule *defrule;
@@ -4672,6 +4823,321 @@ static VALUE clips_environment_static_get_watch_state(VALUE self, VALUE rbEnviro
 	return clips_environment_get_watch_state(rbEnvironment, item);
 }
 
+static VALUE clips_environment_refresh_all_agendas(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	RefreshAllAgendas(env);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_refresh_all_agendas(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_refresh_all_agendas(rbEnvironment);
+}
+
+static VALUE clips_environment_reorder_all_agendas(VALUE self)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	ReorderAllAgendas(env);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_reorder_all_agendas(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_reorder_all_agendas(rbEnvironment);
+}
+
+static VALUE clips_environment_get_agenda_changed(VALUE self)
+{
+	Environment *environment;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, environment);
+
+	return GetAgendaChanged(environment) ? Qtrue : Qfalse;
+}
+
+static VALUE clips_environment_static_get_agenda_changed(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_get_agenda_changed(rbEnvironment);
+}
+
+static VALUE clips_environment_set_agenda_changed(VALUE self, VALUE changed)
+{
+	Environment *environment;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, environment);
+
+	SetAgendaChanged(environment, changed == Qtrue);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_static_set_agenda_changed(VALUE self, VALUE rbEnvironment, VALUE changed)
+{
+	return clips_environment_set_agenda_changed(rbEnvironment, changed);
+}
+
+// copied from agenda.c, not exposed in agenda.h
+/*****************************************************************/
+/* SalienceEvaluationName: Given the integer value corresponding */
+/*   to a specified salience evaluation behavior, returns a      */
+/*   character string of the behavior's name.                    */
+/*****************************************************************/
+static const char *SalienceEvaluationName(
+  SalienceEvaluationType strategy)
+  {
+   const char *sname;
+
+   switch (strategy)
+     {
+      case WHEN_DEFINED:
+        sname = "when-defined";
+        break;
+      case WHEN_ACTIVATED:
+        sname = "when-activated";
+        break;
+      case EVERY_CYCLE:
+        sname = "every-cycle";
+        break;
+      default:
+        sname = "unknown";
+        break;
+     }
+
+   return sname;
+  }
+
+static VALUE clips_environment_get_salience_evaluation(VALUE self)
+{
+	Environment *environment;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, environment);
+
+	return ID2SYM(rb_intern(SalienceEvaluationName(GetSalienceEvaluation(environment))));
+}
+
+static VALUE clips_environment_static_get_salience_evaluation(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_get_salience_evaluation(rbEnvironment);
+}
+
+static VALUE clips_environment_set_salience_evaluation(VALUE self, VALUE changed)
+{
+	Environment *environment;
+	const char *argument, *oldValue;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, environment);
+
+	argument = rb_id2name(SYM2ID(changed));
+	oldValue = SalienceEvaluationName(GetSalienceEvaluation(environment));
+
+	if (strcmp(argument,"when-defined") == 0)
+	{ SetSalienceEvaluation(environment,WHEN_DEFINED); }
+	else if (strcmp(argument,"when-activated") == 0)
+	{ SetSalienceEvaluation(environment,WHEN_ACTIVATED); }
+	else if (strcmp(argument,"every-cycle") == 0)
+	{ SetSalienceEvaluation(environment,EVERY_CYCLE); }
+	else
+	{
+		rb_warn("set_salience_evaluation: symbol must be when-defined, when-activated, or every-cycle");
+		return Qfalse;
+	}
+
+	return ID2SYM(rb_intern(oldValue));
+}
+
+static VALUE clips_environment_static_set_salience_evaluation(VALUE self, VALUE rbEnvironment, VALUE changed)
+{
+	return clips_environment_set_salience_evaluation(rbEnvironment, changed);
+}
+
+// copied from crstrtgy.c
+// not exposed in crstrtgy.h
+/**********************************************************/
+/* GetStrategyName: Given the integer value corresponding */
+/*   to a specified strategy, return a character string   */
+/*   of the strategy's name.                              */
+/**********************************************************/
+static const char *GetStrategyName(
+  StrategyType strategy)
+  {
+   const char *sname;
+
+   switch (strategy)
+     {
+      case DEPTH_STRATEGY:
+        sname = "depth";
+        break;
+      case BREADTH_STRATEGY:
+        sname = "breadth";
+        break;
+      case LEX_STRATEGY:
+        sname = "lex";
+        break;
+      case MEA_STRATEGY:
+        sname = "mea";
+        break;
+      case COMPLEXITY_STRATEGY:
+        sname = "complexity";
+        break;
+      case SIMPLICITY_STRATEGY:
+        sname = "simplicity";
+        break;
+      case RANDOM_STRATEGY:
+        sname = "random";
+        break;
+      default:
+        sname = "unknown";
+        break;
+     }
+
+   return(sname);
+  }
+
+static VALUE clips_environment_get_strategy(VALUE self)
+{
+	Environment *environment;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, environment);
+
+	return ID2SYM(rb_intern(GetStrategyName(GetStrategy(environment))));
+}
+
+static VALUE clips_environment_static_get_strategy(VALUE self, VALUE rbEnvironment)
+{
+	return clips_environment_get_strategy(rbEnvironment);
+}
+
+static VALUE clips_environment_set_strategy(VALUE self, VALUE changed)
+{
+	Environment *environment;
+	const char *argument, *oldValue;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, environment);
+
+	argument = rb_id2name(SYM2ID(changed));
+	oldValue = GetStrategyName(GetStrategy(environment));
+
+	if (strcmp(argument,"depth") == 0)
+	{ SetStrategy(environment,DEPTH_STRATEGY); }
+	else if (strcmp(argument,"breadth") == 0)
+	{ SetStrategy(environment,BREADTH_STRATEGY); }
+	else if (strcmp(argument,"lex") == 0)
+	{ SetStrategy(environment,LEX_STRATEGY); }
+	else if (strcmp(argument,"mea") == 0)
+	{ SetStrategy(environment,MEA_STRATEGY); }
+	else if (strcmp(argument,"complexity") == 0)
+	{ SetStrategy(environment,COMPLEXITY_STRATEGY); }
+	else if (strcmp(argument,"simplicity") == 0)
+	{ SetStrategy(environment,SIMPLICITY_STRATEGY); }
+	else if (strcmp(argument,"random") == 0)
+	{ SetStrategy(environment,RANDOM_STRATEGY); }
+	else
+	{
+		rb_warn("set_strategy: symbol must be depth, breadth, lex, mea, complexity, simplicity, or random");
+		return Qfalse;
+	}
+
+	return ID2SYM(rb_intern(oldValue));
+}
+
+static VALUE clips_environment_static_set_strategy(VALUE self, VALUE rbEnvironment, VALUE changed)
+{
+	return clips_environment_set_strategy(rbEnvironment, changed);
+}
+
+
+static VALUE clips_environment_activation_defrule_name(VALUE self)
+{
+	Activation *activation;
+
+	TypedData_Get_Struct(self, Activation, &Activation_type, activation);
+
+	return ID2SYM(rb_intern(ActivationRuleName(activation)));
+}
+
+static VALUE clips_environment_activation_static_defrule_name(VALUE self, VALUE rbActivation)
+{
+	return clips_environment_activation_defrule_name(rbActivation);
+}
+
+static VALUE clips_environment_activation_get_salience(VALUE self)
+{
+	Activation *activation;
+
+	TypedData_Get_Struct(self, Activation, &Activation_type, activation);
+
+	return LONG2NUM(ActivationGetSalience(activation));
+}
+
+static VALUE clips_environment_activation_static_get_salience(VALUE self, VALUE rbActivation)
+{
+	return clips_environment_activation_get_salience(rbActivation);
+}
+
+static VALUE clips_environment_activation_set_salience(VALUE self, VALUE salience)
+{
+	Activation *activation;
+
+	TypedData_Get_Struct(self, Activation, &Activation_type, activation);
+
+	return LONG2NUM(ActivationSetSalience(activation, NUM2LONG(salience)));
+}
+
+static VALUE clips_environment_activation_static_set_salience(VALUE self, VALUE rbActivation, VALUE salience)
+{
+	return clips_environment_activation_set_salience(rbActivation, salience);
+}
+
+static VALUE clips_environment_activation_pp_form(VALUE self)
+{
+	Environment *env;
+	Activation *activation;
+	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, Activation, &Activation_type, activation);
+
+	ActivationPPForm(activation, sb);
+	toReturn = rb_str_new2(sb->contents);
+	SBDispose(sb);
+
+	return toReturn;
+}
+
+static VALUE clips_environment_activation_static_pp_form(VALUE self, VALUE rbActivation)
+{
+	return clips_environment_activation_pp_form(rbActivation);
+}
+
+static VALUE clips_environment_activation_delete_activation(VALUE self)
+{
+	Activation *activation;
+
+	TypedData_Get_Struct(self, Activation, &Activation_type, activation);
+
+	DeleteActivation(activation);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_activation_static_delete_activation(VALUE self, VALUE rbActivation)
+{
+	return clips_environment_activation_delete_activation(rbActivation);
+}
+
 void Init_clipsruby(void)
 {
 	VALUE rbCLIPS = rb_define_module("CLIPS");
@@ -4753,6 +5219,8 @@ void Init_clipsruby(void)
 	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);
 	rb_define_method(rbEnvironment, "get_defmodule_list", clips_environment_get_defmodule_list, 0);
+	rb_define_singleton_method(rbEnvironment, "get_activation_list", clips_environment_static_get_activation_list, 1);
+	rb_define_method(rbEnvironment, "get_activation_list", clips_environment_get_activation_list, 0);
 	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);
@@ -4823,6 +5291,22 @@ void Init_clipsruby(void)
 	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, -1);
 	rb_define_method(rbEnvironment, "make_instance", clips_environment_make_instance, -1);
+	rb_define_singleton_method(rbEnvironment, "refresh_all_agendas", clips_environment_static_refresh_all_agendas, 1);
+	rb_define_method(rbEnvironment, "refresh_all_agendas", clips_environment_refresh_all_agendas, 0);
+	rb_define_singleton_method(rbEnvironment, "reorder_all_agendas", clips_environment_static_reorder_all_agendas, 1);
+	rb_define_method(rbEnvironment, "reorder_all_agendas", clips_environment_reorder_all_agendas, 0);
+	rb_define_singleton_method(rbEnvironment, "get_agenda_changed", clips_environment_static_get_agenda_changed, 1);
+	rb_define_method(rbEnvironment, "get_agenda_changed", clips_environment_get_agenda_changed, 0);
+	rb_define_singleton_method(rbEnvironment, "set_agenda_changed", clips_environment_static_set_agenda_changed, 2);
+	rb_define_method(rbEnvironment, "set_agenda_changed", clips_environment_set_agenda_changed, 1);
+	rb_define_singleton_method(rbEnvironment, "get_salience_evaluation", clips_environment_static_get_salience_evaluation, 1);
+	rb_define_method(rbEnvironment, "get_salience_evaluation", clips_environment_get_salience_evaluation, 0);
+	rb_define_singleton_method(rbEnvironment, "set_salience_evaluation", clips_environment_static_set_salience_evaluation, 2);
+	rb_define_method(rbEnvironment, "set_salience_evaluation", clips_environment_set_salience_evaluation, 1);
+	rb_define_singleton_method(rbEnvironment, "get_strategy", clips_environment_static_get_strategy, 1);
+	rb_define_method(rbEnvironment, "get_strategy", clips_environment_get_strategy, 0);
+	rb_define_singleton_method(rbEnvironment, "set_strategy", clips_environment_static_set_strategy, 2);
+	rb_define_method(rbEnvironment, "set_strategy", clips_environment_set_strategy, 1);
 
 	VALUE rbDeffacts = rb_define_class_under(rbEnvironment, "Deffacts", rb_cObject);
 	rb_define_alloc_func(rbDeffacts, deffacts_alloc);
@@ -4886,6 +5370,12 @@ void Init_clipsruby(void)
 	rb_define_method(rbDefmodule, "get_defrule_list", clips_environment_defmodule_get_defrule_list, 0);
 	rb_define_singleton_method(rbDefmodule, "find_instance", clips_environment_defmodule_static_find_instance, -1);
 	rb_define_method(rbDefmodule, "find_instance", clips_environment_defmodule_find_instance, -1);
+	rb_define_singleton_method(rbDefmodule, "refresh_agenda", clips_environment_defmodule_static_refresh_agenda, 1);
+	rb_define_method(rbDefmodule, "refresh_agenda", clips_environment_defmodule_refresh_agenda, 0);
+	rb_define_singleton_method(rbDefmodule, "reorder_agenda", clips_environment_defmodule_static_reorder_agenda, 1);
+	rb_define_method(rbDefmodule, "reorder_agenda", clips_environment_defmodule_reorder_agenda, 0);
+	rb_define_singleton_method(rbDefmodule, "delete_all_activations", clips_environment_defmodule_static_delete_all_activations, 1);
+	rb_define_method(rbDefmodule, "delete_all_activations", clips_environment_defmodule_delete_all_activations, 0);
 
 	VALUE rbFact = rb_define_class_under(rbEnvironment, "Fact", rb_cObject);
 	rb_define_alloc_func(rbFact, fact_alloc);
@@ -4930,6 +5420,8 @@ void Init_clipsruby(void)
 	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);
+	rb_define_singleton_method(rbDefrule, "matches", clips_environment_defrule_static_matches, -1);
+	rb_define_method(rbDefrule, "matches", clips_environment_defrule_matches, -1);
 
 	VALUE rbDefclass = rb_define_class_under(rbEnvironment, "Defclass", rb_cObject);
 	rb_define_alloc_func(rbDefclass, defclass_alloc);
@@ -4964,4 +5456,17 @@ void Init_clipsruby(void)
 	rb_define_method(rbInstance, "pp_form", clips_environment_instance_pp_form, 0);
 	rb_define_singleton_method(rbInstance, "to_h", clips_environment_instance_static_to_h, -1);
 	rb_define_method(rbInstance, "to_h", clips_environment_instance_to_h, -1);
+
+	VALUE rbActivation = rb_define_class_under(rbEnvironment, "Activation", rb_cObject);
+	rb_define_alloc_func(rbActivation, activation_alloc);
+	rb_define_singleton_method(rbActivation, "defrule_name", clips_environment_activation_static_defrule_name, 1);
+	rb_define_method(rbActivation, "defrule_name", clips_environment_activation_defrule_name, 0);
+	rb_define_singleton_method(rbActivation, "get_salience", clips_environment_activation_static_get_salience, 1);
+	rb_define_method(rbActivation, "get_salience", clips_environment_activation_get_salience, 0);
+	rb_define_singleton_method(rbActivation, "set_salience", clips_environment_activation_static_set_salience, 2);
+	rb_define_method(rbActivation, "set_salience", clips_environment_activation_set_salience, 1);
+	rb_define_singleton_method(rbActivation, "pp_form", clips_environment_activation_static_pp_form, 1);
+	rb_define_method(rbActivation, "pp_form", clips_environment_activation_pp_form, 0);
+	rb_define_singleton_method(rbActivation, "delete_activation", clips_environment_activation_static_delete_activation, 1);
+	rb_define_method(rbActivation, "delete_activation", clips_environment_activation_delete_activation, 0);
 }

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: clipsruby
 version: !ruby/object:Gem::Version
-  version: 0.0.42
+  version: 0.0.44
 platform: ruby
 authors:
 - Ryan Johnston
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-08 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: Calling the CLIPS programming language from within Ruby
 email: mrryanjohnston@gmail.com
@@ -369,7 +368,6 @@ licenses:
 metadata:
   documentation_uri: https://github.com/mrryanjohnston/clipsruby/blob/main/README.md
   source_code_uri: https://github.com/mrryanjohnston/clipsruby
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -385,8 +383,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Calling CLIPS from within Ruby
 test_files: []