clipsruby 0.0.41 → 0.0.43

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 78e7fd97fcf75571bb75e472d6275465c76a7d6cbed969624125850ec0c2cb6f
-  data.tar.gz: 79ce7ff30742b18bc75ac486c4499fbfb8473ae0e21c2f38f0b235dc7d444b25
+  metadata.gz: 6fc073e3a6ed11b566b2aff954ff17fcb2874fa1cf83f8b4fbeba5b893d204bc
+  data.tar.gz: f9c000d65fae9a2140f43bf234e8b3360937f461df35e5b2e659dac942048063
 SHA512:
-  metadata.gz: 1647880d18e55105b843376685b5cf675d6a790bd67b13aa7de26e1c6bc1066a0801a22459f975c952506441e555fb6eba0a2345803a129267f936b7cab86667
-  data.tar.gz: c2bfd4e51a6febef513acb84223f3439ed52ef24511683db9de341a349f523638daac48b932a30e291e73ae49b568b9f1d2f179e341c219a15fee768ec339281
+  metadata.gz: 522fe0e9ca9ad792684bac67b24708897f68840586c180e5e8712fa9920561b1f9316e968d22bb7cf5371f1467705b2b6e739a649cff0d7fa22f76433164e60e
+  data.tar.gz: 630373e7297ac2945d7a560d4db06262b482b526591e7a7d685a6305ffbd6e5f2864ad58b49eea0e8481f7806515dba5d4cd29388685b7d2429cf79a18307097

data/README.md

@@ -152,6 +152,31 @@ CLIPS::Environment.load_facts(env, "./my-load-facts.clp")
 env.load_facts("./my-load-facts.clp")
 ```
 
+#### `CLIPS::Environment.save_instances` / `env.save_instances`
+
+Pass the path in which we'll save the environment instances.
+The third argument is optional, and determines whether to store the visible or local instances.
+By default, it'll store local.
+
+```ruby
+CLIPS::Environment.save_instances(env, "./my-save-instances.clp")
+env.save_instances("./my-save-instances.clp")
+CLIPS::Environment.save_instances(env, "./my-save-instances.clp", :local)
+env.save_instances("./my-save-instances.clp", :local)
+CLIPS::Environment.save_instances(env, "./my-save-instances.clp", :visible)
+env.save_instances("./my-save-instances.clp", :visible)
+```
+
+#### `CLIPS::Environment.load_instances` / `env.load_instances`
+
+Pass the path to a file that will load the instances stored in the file
+into the environment.
+
+```ruby
+CLIPS::Environment.load_instances(env, "./my-load-instances.clp")
+env.load_instances("./my-load-instances.clp")
+```
+
 #### `CLIPS::Environment.bsave` / `env.bsave`
 
 Pass the path in which we'll save the binary representation of the environment constructs.
@@ -196,6 +221,32 @@ CLIPS::Environment.bload_facts(env, "./my-bload-facts.bin")
 env.bload_facts("./my-bload-facts.bin")
 ```
 
+#### `CLIPS::Environment.bsave_instances` / `env.bsave_instances`
+
+Pass the path in which we'll save the binary representation of the environment instances.
+The third argument is optional, and determines whether to store the visible or local instances.
+By default, it'll store local.
+
+```ruby
+CLIPS::Environment.bsave_instances(env, "./my-bsave-instances.bin")
+env.bsave_instances("./my-bsave-instances.bin")
+CLIPS::Environment.bsave_instances(env, "./my-bsave-instances.bin", :local)
+env.bsave_instances("./my-bsave-instances.bin", :local)
+CLIPS::Environment.bsave_instances(env, "./my-bsave-instances.bin", :visible)
+env.bsave_instances("./my-bsave-instances.bin", :visible)
+```
+
+#### `CLIPS::Environment.bload_facts` / `env.bload_facts`
+
+Pass the path to a binary file that will load the facts stored in the file
+into the environment.
+
+```ruby
+CLIPS::Environment.bload_facts(env, "./my-bload-facts.bin")
+env.bload_facts("./my-bload-facts.bin")
+```
+
+
 #### `CLIPS::Environment.assert_string` / `CLIPS::Environment#assert_string`
 
 Assert a string as a Fact in the CLIPS environment.
@@ -350,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
@@ -799,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`
@@ -1090,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;
@@ -1984,6 +2058,74 @@ static VALUE clips_environment_static_load_facts(VALUE self, VALUE rbEnvironment
 	return clips_environment_load_facts(rbEnvironment, path);
 }
 
+static VALUE clips_environment_save_instances(int argc, VALUE *argv, VALUE rbEnvironment) {
+	VALUE path, scope;
+	Environment *env;
+
+	TypedData_Get_Struct(rbEnvironment, Environment, &Environment_type, env);
+
+	rb_scan_args(argc, argv, "11", &path, &scope);
+	if (NIL_P(scope)) {
+		scope = ID2SYM(rb_intern("local"));
+	}
+
+	int number_of_instances_saved;
+
+	if (scope == ID2SYM(rb_intern("visible"))) {
+		number_of_instances_saved = SaveInstances(env, StringValueCStr(path), VISIBLE_SAVE);
+	} else if (scope == ID2SYM(rb_intern("local"))) {
+		number_of_instances_saved = SaveInstances(env, StringValueCStr(path), LOCAL_SAVE);
+	} else {
+		rb_warn("could not save_instances: unsupported scope.");
+		return Qnil;
+	}
+	return INT2NUM(number_of_instances_saved);
+}
+
+static VALUE clips_environment_static_save_instances(int argc, VALUE *argv, VALUE klass) {
+	VALUE rbEnvironment, path, scope;
+	Environment *env;
+
+	rb_scan_args(argc, argv, "21", &rbEnvironment, &path, &scope);
+
+	TypedData_Get_Struct(rbEnvironment, Environment, &Environment_type, env);
+
+	if (NIL_P(scope)) {
+		scope = ID2SYM(rb_intern("local"));
+	}
+
+	int number_of_instances_saved;
+
+	if (scope == ID2SYM(rb_intern("visible"))) {
+		number_of_instances_saved = SaveInstances(env, StringValueCStr(path), VISIBLE_SAVE);
+	} else if (scope == ID2SYM(rb_intern("local"))) {
+		number_of_instances_saved = SaveInstances(env, StringValueCStr(path), LOCAL_SAVE);
+	} else {
+		rb_warn("could not save_instances: unsupported scope.");
+		return Qnil;
+	}
+	return INT2NUM(number_of_instances_saved);
+}
+
+static VALUE clips_environment_load_instances(VALUE self, VALUE path)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+	int number_of_instances_loaded = LoadInstances(env, StringValueCStr(path));
+
+	if (number_of_instances_loaded == -1) {
+		return Qnil;
+	} else {
+		return INT2NUM(number_of_instances_loaded);
+	}
+}
+
+static VALUE clips_environment_static_load_instances(VALUE self, VALUE rbEnvironment, VALUE path)
+{
+	return clips_environment_load_instances(rbEnvironment, path);
+}
+
 static VALUE clips_environment_bsave(VALUE self, VALUE path)
 {
 	Environment *env;
@@ -2089,6 +2231,76 @@ static VALUE clips_environment_static_bload_facts(VALUE self, VALUE rbEnvironmen
 	return clips_environment_bload_facts(rbEnvironment, path);
 }
 
+static VALUE clips_environment_bsave_instances(int argc, VALUE *argv, VALUE rbEnvironment) {
+	VALUE path, scope;
+	Environment *env;
+
+	TypedData_Get_Struct(rbEnvironment, Environment, &Environment_type, env);
+
+	rb_scan_args(argc, argv, "11", &path, &scope);
+	if (NIL_P(scope)) {
+		scope = ID2SYM(rb_intern("local"));
+	}
+
+	int number_of_instances_saved;
+
+	if (scope == ID2SYM(rb_intern("visible"))) {
+		number_of_instances_saved = BinarySaveInstances(env, StringValueCStr(path), VISIBLE_SAVE);
+	} else if (scope == ID2SYM(rb_intern("local"))) {
+		number_of_instances_saved = BinarySaveInstances(env, StringValueCStr(path), LOCAL_SAVE);
+	} else {
+		rb_warn("could not bsave_instances: unsupported scope.");
+		return Qnil;
+	}
+
+	return INT2NUM(number_of_instances_saved);
+}
+
+static VALUE clips_environment_static_bsave_instances(int argc, VALUE *argv, VALUE klass) {
+	VALUE rbEnvironment, path, scope;
+	Environment *env;
+
+	rb_scan_args(argc, argv, "21", &rbEnvironment, &path, &scope);
+
+	TypedData_Get_Struct(rbEnvironment, Environment, &Environment_type, env);
+
+	if (NIL_P(scope)) {
+		scope = ID2SYM(rb_intern("local"));
+	}
+
+	int number_of_instances_saved;
+
+	if (scope == ID2SYM(rb_intern("visible"))) {
+		number_of_instances_saved = BinarySaveInstances(env, StringValueCStr(path), VISIBLE_SAVE);
+	} else if (scope == ID2SYM(rb_intern("local"))) {
+		number_of_instances_saved = BinarySaveInstances(env, StringValueCStr(path), LOCAL_SAVE);
+	} else {
+		rb_warn("could not bsave_instances: unsupported scope.");
+		return Qnil;
+	}
+	return INT2NUM(number_of_instances_saved);
+}
+
+static VALUE clips_environment_bload_instances(VALUE self, VALUE path)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+	int number_of_instances_loaded = BinaryLoadInstances(env, StringValueCStr(path));
+
+	if (number_of_instances_loaded == -1) {
+		return Qnil;
+	} else {
+		return INT2NUM(number_of_instances_loaded);
+	}
+}
+
+static VALUE clips_environment_static_bload_instances(VALUE self, VALUE rbEnvironment, VALUE path)
+{
+	return clips_environment_bload_instances(rbEnvironment, path);
+}
+
+
 static VALUE clips_environment_fact_slot_names(VALUE self)
 {
 	Fact *fact;
@@ -3610,6 +3822,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;
@@ -4534,6 +4776,21 @@ static VALUE clips_environment_static_get_watch_state(VALUE self, VALUE rbEnviro
 	return clips_environment_get_watch_state(rbEnvironment, item);
 }
 
+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);
+}
+
+
 void Init_clipsruby(void)
 {
 	VALUE rbCLIPS = rb_define_module("CLIPS");
@@ -4573,6 +4830,10 @@ void Init_clipsruby(void)
 	rb_define_method(rbEnvironment, "save_facts", clips_environment_save_facts, -1);
 	rb_define_singleton_method(rbEnvironment, "load_facts", clips_environment_static_load_facts, 2);
 	rb_define_method(rbEnvironment, "load_facts", clips_environment_load_facts, 1);
+	rb_define_singleton_method(rbEnvironment, "save_instances", clips_environment_static_save_instances, -1);
+	rb_define_method(rbEnvironment, "save_instances", clips_environment_save_instances, -1);
+	rb_define_singleton_method(rbEnvironment, "load_instances", clips_environment_static_load_instances, 2);
+	rb_define_method(rbEnvironment, "load_instances", clips_environment_load_instances, 1);
 	rb_define_singleton_method(rbEnvironment, "bsave", clips_environment_static_bsave, 2);
 	rb_define_method(rbEnvironment, "bsave", clips_environment_bsave, 1);
 	rb_define_singleton_method(rbEnvironment, "bload", clips_environment_static_bload, 2);
@@ -4581,6 +4842,10 @@ void Init_clipsruby(void)
 	rb_define_method(rbEnvironment, "bsave_facts", clips_environment_bsave_facts, -1);
 	rb_define_singleton_method(rbEnvironment, "bload_facts", clips_environment_static_bload_facts, 2);
 	rb_define_method(rbEnvironment, "bload_facts", clips_environment_bload_facts, 1);
+	rb_define_singleton_method(rbEnvironment, "bsave_instances", clips_environment_static_bsave_instances, -1);
+	rb_define_method(rbEnvironment, "bsave_instances", clips_environment_bsave_instances, -1);
+	rb_define_singleton_method(rbEnvironment, "bload_instances", clips_environment_static_bload_instances, 2);
+	rb_define_method(rbEnvironment, "bload_instances", clips_environment_bload_instances, 1);
 	rb_define_singleton_method(rbEnvironment, "find_defrule", clips_environment_static_find_defrule, 2);
 	rb_define_method(rbEnvironment, "find_defrule", clips_environment_find_defrule, 1);
 	rb_define_singleton_method(rbEnvironment, "find_defmodule", clips_environment_static_find_defmodule, 2);
@@ -4607,6 +4872,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);
@@ -4784,6 +5051,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);
@@ -4818,4 +5087,9 @@ 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);
 }

metadata

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