clipsruby 0.0.12 → 0.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 829a0ce02dc7dbe02fb75f5f3324b001240ae4a742de842c95067291481b7b85
-  data.tar.gz: d258273d013a710125000c07a3cfad654e22a81fe300c222e0d34b8fd805e1ff
+  metadata.gz: 1c09bd00794b99f18db2f3e1a7e79add255696071f73192f1009d97f6bc6a222
+  data.tar.gz: e68259458eb14602e69184d82723518b3ad99bf082a4a23994f0fb6b54ffffa3
 SHA512:
-  metadata.gz: 30b76872939a39ca16c17f130db788c4aa55cadd7fd2d1ee07e28e1f0daba2d406ff431472f2e666bbe20083703dfc0e78ade13af51fbc0cd2fb9a40e2c7dac7
-  data.tar.gz: d0c18d5c756b9318682276aac714721ae2c5c7160324880985cd3e65619086e9ca9f5498c93c65101f19e80038aae7c25bc0f44fe33c3eef2dde55c090608008
+  metadata.gz: f147d8a530205d27de62750701a2359ed5e0fdc9b7e6d01f9d953878f9dbc501f742406f6199a27b57231e465c48e608c1df4514b758e524f12e5f40d4f6fac4
+  data.tar.gz: 7927273ee5ed8945f122032796c07cb44def5d597d6a07cc1e24d2aa7788b3b02477b134463d007a4f4db32339e8860ccfa91bf9225d1d685e3d5e931daf0f62

data/README.md

@@ -39,6 +39,54 @@ CLIPS::Environment.batch_star(env, "./my-batch.bat")
 env.batch_star("./my-batch.bat")
 ```
 
+### `CLIPS::Environment.save`
+### `env.save`
+
+Pass the path in which we'll save the environment constructs.
+
+```ruby
+CLIPS::Environment.save(env, "./my-save.clp")
+env.save("./my-save.clp")
+```
+
+### `CLIPS::Environment.load`
+### `env.load`
+
+Pass the path to a file that will load the constructs stored in the file
+into the environment. Remember to `reset` the environment if you need.
+
+```ruby
+CLIPS::Environment.load(env, "./my-load.clp")
+env.load("./my-load.clp")
+```
+
+### `CLIPS::Environment.save_facts`
+### `env.save_facts`
+
+Pass the path in which we'll save the environment facts.
+The third argument is optional, and determines whether to store the visible or local facts.
+By default, it'll store local.
+
+```ruby
+CLIPS::Environment.save_facts(env, "./my-save-facts.clp")
+env.save_facts("./my-save-facts.clp")
+CLIPS::Environment.save_facts(env, "./my-save-facts.clp", :local)
+env.save_facts("./my-save-facts.clp", :local)
+CLIPS::Environment.save_facts(env, "./my-save-facts.clp", :visible)
+env.save_facts("./my-save-facts.clp", :visible)
+```
+
+### `CLIPS::Environment.load_facts`
+### `env.load_facts`
+
+Pass the path to a file that will load the facts stored in the file
+into the environment.
+
+```ruby
+CLIPS::Environment.load_facts(env, "./my-load-facts.clp")
+env.load_facts("./my-load-facts.clp")
+```
+
 ### `CLIPS::Environment.bsave`
 ### `env.bsave`
 
@@ -68,12 +116,12 @@ The third argument is optional, and determines whether to store the visible or l
 By default, it'll store local.
 
 ```ruby
-CLIPS::Environment.bsave(env, "./my-bsave-facts.bin")
-env.bsave("./my-bsave-facts.bin")
-CLIPS::Environment.bsave(env, "./my-bsave-facts.bin", :local)
-env.bsave("./my-bsave-facts.bin", :local)
-CLIPS::Environment.bsave(env, "./my-bsave-facts.bin", :visible)
-env.bsave("./my-bsave-facts.bin", :visible)
+CLIPS::Environment.bsave_facts(env, "./my-bsave-facts.bin")
+env.bsave_facts("./my-bsave-facts.bin")
+CLIPS::Environment.bsave_facts(env, "./my-bsave-facts.bin", :local)
+env.bsave_facts("./my-bsave-facts.bin", :local)
+CLIPS::Environment.bsave_facts(env, "./my-bsave-facts.bin", :visible)
+env.bsave_facts("./my-bsave-facts.bin", :visible)
 ```
 
 ### `CLIPS::Environment.bload_facts`
@@ -83,8 +131,8 @@ Pass the path to a binary file that will load the facts stored in the file
 into the environment.
 
 ```ruby
-CLIPS::Environment.bload(env, "./my-bload-facts.bin")
-env.bload("./my-bload-facts.bin")
+CLIPS::Environment.bload_facts(env, "./my-bload-facts.bin")
+env.bload_facts("./my-bload-facts.bin")
 ```
 
 ### `CLIPS::Environment.assert_string`
@@ -107,6 +155,19 @@ 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.find_fact`
+### `CLIPS::Environment#find_fact`
+
+A light wrapper around the CLIPS find-fact function. Accepts a fact set template and query,
+returns the first Facts in the environment that match as Ruby objects.
+
+```ruby
+CLIPS::Environment.find_facts(env, "(?f my_deftemplate)")
+env.find_fact("(?f my_deftemplate)")
+CLIPS::Environment.find_fact(env, "(?f my_deftemplate)", "(eq ?f:b \"asdf\")")
+env.find_fact("(?f my_deftemplate)", "(= ?f:a 1)")
+```
+
 ### `CLIPS::Environment.find_all_facts`
 ### `CLIPS::Environment#find_all_facts`
 
@@ -215,6 +276,16 @@ CLIPS::Environment::Fact.to_h(fact)
 fact.to_h
 ```
 
+### `CLIPS::Environment::Fact.index`
+### `CLIPS::Environment::Fact#index`
+
+Returns the index of the fact in working memory
+
+```ruby
+CLIPS::Environment::Fact.index(fact)
+fact.index
+```
+
 ### `CLIPS::Environment::Fact.deftemplate_name`
 ### `CLIPS::Environment::Fact#deftemplate_name`
 
@@ -267,6 +338,46 @@ CLIPS::Environment::Fact.modify(fact, bar: 123)
 fact.modify(foo: "my new foo!")
 ```
 
+### `CLIPS::Environment.find_defrule`
+### `CLIPS::Environment#find_defrule`
+
+Finds a defrule by name and returns a CLIPS::Environment::Defrule object
+
+```ruby
+CLIPS::Environment.find_defrule(:a)
+env.find_defrule("foo")
+```
+
+### `CLIPS::Environment::Defrule.name`
+### `CLIPS::Environment::Defrule#name`
+
+Returns the name of a defrule as a symbol
+
+```ruby
+CLIPS::Environment::Defrule.name(defrule)
+defrule.name
+```
+
+### `CLIPS::Environment::Defrule.is_deletable`
+### `CLIPS::Environment::Defrule#is_deletable`
+
+Returns a boolean whether the Defrule is deletable or not
+
+```ruby
+CLIPS::Environment::Defrule.is_deletable(defrule)
+defrule.is_deletable
+```
+
+### `CLIPS::Environment::Defrule.pp_form`
+### `CLIPS::Environment::Defrule#pp_form`
+
+Returns a pretty printed string representation of the Defrule
+
+```ruby
+CLIPS::Environment::Defrule.pp_form(defrule)
+defrule.pp_form
+```
+
 ## Running the tests
 
 Simply do `rake compile` and then `rake test` in order to run the tests.

data/ext/clipsruby/clipsruby.c

@@ -1,6 +1,18 @@
 #include "clips.h"
 #include "ruby.h"
 
+size_t defrule_size(const void *data)
+{
+	return sizeof(Defrule);
+}
+
+static const rb_data_type_t Defrule_type = {
+	.function = {
+		.dsize = defrule_size
+	},
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
 size_t fact_size(const void *data)
 {
 	return sizeof(Fact);
@@ -642,6 +654,32 @@ static VALUE clips_environment_static_eval(VALUE self, VALUE rbEnvironment, VALU
 	return clips_environment_eval(rbEnvironment, string);
 }
 
+static VALUE clips_environment_find_fact(int argc, VALUE *argv, VALUE environment) {
+	VALUE fact_set_template, query;
+
+	rb_scan_args(argc, argv, "11", &fact_set_template, &query);
+	if (NIL_P(query)) {
+		query = rb_str_new_cstr("TRUE");
+	}
+
+	return clips_environment_eval(
+		environment,
+		rb_sprintf("(find-fact (%s) %s)", StringValueCStr(fact_set_template), StringValueCStr(query)));
+}
+
+static VALUE clips_environment_static_find_fact(int argc, VALUE *argv, VALUE klass) {
+	VALUE rbEnvironment, fact_set_template, query;
+
+	rb_scan_args(argc, argv, "21", &rbEnvironment, &fact_set_template, &query);
+	if (NIL_P(query)) {
+		query = rb_str_new_cstr("TRUE");
+	}
+
+	return clips_environment_eval(
+		rbEnvironment,
+		rb_sprintf("(find-fact (%s) %s)", StringValueCStr(fact_set_template), StringValueCStr(query)));
+}
+
 static VALUE clips_environment_find_all_facts(int argc, VALUE *argv, VALUE environment) {
 	VALUE fact_set_template, query;
 
@@ -747,6 +785,117 @@ static VALUE clips_environment_static_reset(VALUE self, VALUE rbEnvironment)
 	return clips_environment_reset(rbEnvironment);
 }
 
+static VALUE clips_environment_save(VALUE self, VALUE path)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	if (Save(env, StringValueCStr(path))) {
+		return Qtrue;
+	} else {
+		return Qfalse;
+	}
+}
+
+static VALUE clips_environment_static_save(VALUE self, VALUE rbEnvironment, VALUE path)
+{
+	return clips_environment_save(rbEnvironment, path);
+}
+
+static VALUE clips_environment_load(VALUE self, VALUE path)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	switch (Load(env, StringValueCStr(path)))
+	{
+		case LE_NO_ERROR:
+			break;
+		case LE_OPEN_FILE_ERROR:
+			rb_warn("could not load: issue opening file.");
+			return Qnil;
+		case LE_PARSING_ERROR:
+			rb_warn("could not load: parsing issue.");
+			return Qnil;
+	}
+	return Qtrue;
+}
+
+static VALUE clips_environment_static_load(VALUE self, VALUE rbEnvironment, VALUE path)
+{
+	return clips_environment_load(rbEnvironment, path);
+}
+
+static VALUE clips_environment_save_facts(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_facts_saved;
+
+	if (scope == ID2SYM(rb_intern("visible"))) {
+		number_of_facts_saved = SaveFacts(env, StringValueCStr(path), VISIBLE_SAVE);
+	} else if (scope == ID2SYM(rb_intern("local"))) {
+		number_of_facts_saved = SaveFacts(env, StringValueCStr(path), LOCAL_SAVE);
+	} else {
+		rb_warn("could not bsave_facts: unsupported scope.");
+		return Qnil;
+	}
+	return INT2NUM(number_of_facts_saved);
+}
+
+static VALUE clips_environment_static_save_facts(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_facts_saved;
+
+	if (scope == ID2SYM(rb_intern("visible"))) {
+		number_of_facts_saved = SaveFacts(env, StringValueCStr(path), VISIBLE_SAVE);
+	} else if (scope == ID2SYM(rb_intern("local"))) {
+		number_of_facts_saved = SaveFacts(env, StringValueCStr(path), LOCAL_SAVE);
+	} else {
+		rb_warn("could not bsave_facts: unsupported scope.");
+		return Qnil;
+	}
+	return INT2NUM(number_of_facts_saved);
+}
+
+static VALUE clips_environment_load_facts(VALUE self, VALUE path)
+{
+	Environment *env;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+	int number_of_facts_loaded = LoadFacts(env, StringValueCStr(path));
+
+	if (number_of_facts_loaded == -1) {
+		return Qnil;
+	} else {
+		return INT2NUM(number_of_facts_loaded);
+	}
+}
+
+static VALUE clips_environment_static_load_facts(VALUE self, VALUE rbEnvironment, VALUE path)
+{
+	return clips_environment_load_facts(rbEnvironment, path);
+}
+
 static VALUE clips_environment_bsave(VALUE self, VALUE path)
 {
 	Environment *env;
@@ -794,14 +943,18 @@ static VALUE clips_environment_bsave_facts(int argc, VALUE *argv, VALUE rbEnviro
 		scope = ID2SYM(rb_intern("local"));
 	}
 
+	int number_of_facts_saved;
+
 	if (scope == ID2SYM(rb_intern("visible"))) {
-		return INT2NUM(BinarySaveFacts(env, StringValueCStr(path), VISIBLE_SAVE));
+		number_of_facts_saved = BinarySaveFacts(env, StringValueCStr(path), VISIBLE_SAVE);
 	} else if (scope == ID2SYM(rb_intern("local"))) {
-		return INT2NUM(BinarySaveFacts(env, StringValueCStr(path), LOCAL_SAVE));
+		number_of_facts_saved = BinarySaveFacts(env, StringValueCStr(path), LOCAL_SAVE);
 	} else {
 		rb_warn("could not bsave_facts: unsupported scope.");
 		return Qnil;
 	}
+
+	return INT2NUM(number_of_facts_saved);
 }
 
 static VALUE clips_environment_static_bsave_facts(int argc, VALUE *argv, VALUE klass) {
@@ -1026,6 +1179,82 @@ static VALUE clips_environment_fact_static_index(VALUE self, VALUE rbFact)
 	return clips_environment_fact_index(rbFact);
 }
 
+static VALUE clips_environment_find_defrule(VALUE self, VALUE defrule_name)
+{
+	Environment *env;
+	Defrule *rule;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	switch (TYPE(defrule_name)) {
+		case T_STRING:
+			rule = FindDefrule(env, StringValueCStr(defrule_name));
+			break;
+		case T_SYMBOL:
+			rule = FindDefrule(env, rb_id2name(SYM2ID(defrule_name)));
+			break;
+                default:
+			rb_warn("defrule name must be a symbol or string");
+			return Qnil;
+        }
+
+	if (rule == NULL) {
+		return Qnil;
+	} else {
+		return TypedData_Wrap_Struct(rb_const_get(CLASS_OF(self), rb_intern("Defrule")), &Defrule_type, rule);
+	}
+}
+
+static VALUE clips_environment_static_find_defrule(VALUE self, VALUE rbEnvironment, VALUE defrule_name)
+{
+	return clips_environment_find_defrule(rbEnvironment, defrule_name);
+}
+
+static VALUE clips_environment_defrule_name(VALUE self)
+{
+	Defrule *defrule;
+
+	TypedData_Get_Struct(self, Defrule, &Defrule_type, defrule);
+
+	return ID2SYM(rb_intern(DefruleName(defrule)));
+}
+
+static VALUE clips_environment_defrule_static_name(VALUE self, VALUE rbDefrule)
+{
+	return clips_environment_defrule_name(rbDefrule);
+}
+
+static VALUE clips_environment_defrule_pp_form(VALUE self)
+{
+	Defrule *defrule;
+
+	TypedData_Get_Struct(self, Defrule, &Defrule_type, defrule);
+
+	return rb_str_new2(DefrulePPForm(defrule));
+}
+
+static VALUE clips_environment_defrule_static_pp_form(VALUE self, VALUE rbDefrule)
+{
+	return clips_environment_defrule_pp_form(rbDefrule);
+}
+
+static VALUE clips_environment_defrule_is_deletable(VALUE self)
+{
+	Defrule *defrule;
+
+	TypedData_Get_Struct(self, Defrule, &Defrule_type, defrule);
+
+	if (DefruleIsDeletable(defrule)) {
+		return Qtrue;
+	} else {
+		return Qfalse;
+	}
+}
+
+static VALUE clips_environment_defrule_static_is_deletable(VALUE self, VALUE rbDefrule)
+{
+	return clips_environment_defrule_is_deletable(rbDefrule);
+}
 
 void Init_clipsruby(void)
 {
@@ -1048,6 +1277,8 @@ void Init_clipsruby(void)
 	rb_define_method(rbEnvironment, "run", clips_environment_run, -1);
 	rb_define_singleton_method(rbEnvironment, "_eval", clips_environment_static_eval, 2);
 	rb_define_method(rbEnvironment, "_eval", clips_environment_eval, 1);
+	rb_define_singleton_method(rbEnvironment, "find_fact", clips_environment_static_find_fact, -1);
+	rb_define_method(rbEnvironment, "find_fact", clips_environment_find_fact, -1);
 	rb_define_singleton_method(rbEnvironment, "find_all_facts", clips_environment_static_find_all_facts, -1);
 	rb_define_method(rbEnvironment, "find_all_facts", clips_environment_find_all_facts, -1);
 	rb_define_singleton_method(rbEnvironment, "batch_star", clips_environment_static_batch_star, 2);
@@ -1056,6 +1287,14 @@ void Init_clipsruby(void)
 	rb_define_method(rbEnvironment, "clear", clips_environment_clear, 0);
 	rb_define_singleton_method(rbEnvironment, "reset", clips_environment_static_reset, 1);
 	rb_define_method(rbEnvironment, "reset", clips_environment_reset, 0);
+	rb_define_singleton_method(rbEnvironment, "save", clips_environment_static_save, 2);
+	rb_define_method(rbEnvironment, "save", clips_environment_save, 1);
+	rb_define_singleton_method(rbEnvironment, "load", clips_environment_static_load, 2);
+	rb_define_method(rbEnvironment, "load", clips_environment_load, 1);
+	rb_define_singleton_method(rbEnvironment, "save_facts", clips_environment_static_save_facts, -1);
+	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, "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);
@@ -1064,6 +1303,8 @@ 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, "find_defrule", clips_environment_static_find_defrule, 2);
+	rb_define_method(rbEnvironment, "find_defrule", clips_environment_find_defrule, 1);
 
 	VALUE rbFact = rb_define_class_under(rbEnvironment, "Fact", rb_cObject);
 	rb_define_singleton_method(rbFact, "deftemplate_name", clips_environment_fact_static_deftemplate_name, 1);
@@ -1081,5 +1322,13 @@ void Init_clipsruby(void)
 	rb_define_singleton_method(rbFact, "index", clips_environment_fact_static_index, 1);
 	rb_define_method(rbFact, "index", clips_environment_fact_index, 0);
 
+	VALUE rbDefrule = rb_define_class_under(rbEnvironment, "Defrule", rb_cObject);
+	rb_define_singleton_method(rbDefrule, "name", clips_environment_defrule_static_name, 1);
+	rb_define_method(rbDefrule, "name", clips_environment_defrule_name, 0);
+	rb_define_singleton_method(rbDefrule, "pp_form", clips_environment_defrule_static_pp_form, 1);
+	rb_define_method(rbDefrule, "pp_form", clips_environment_defrule_pp_form, 0);
+	rb_define_singleton_method(rbDefrule, "is_deletable", clips_environment_defrule_static_is_deletable, 1);
+	rb_define_method(rbDefrule, "is_deletable", clips_environment_defrule_is_deletable, 0);
+
 	VALUE rbInstance = rb_define_class_under(rbEnvironment, "Instance", rb_cObject);
 }

metadata

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