clipsruby 0.0.14 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f33a751deeebf96aa16135763365063f9facdd95c2cd7e7df7de0e3e90bea56b
-  data.tar.gz: f24d9c9901986b83ce38ffd97d5ef9f06c2409ae3b24de85094a73b78f39dbc4
+  metadata.gz: 4d5b7a59f7219254864351b91605797ae234e16e608d59233703143c7abf54dc
+  data.tar.gz: fcb8917ac24d4bb0168c95b4349377d264a13683aeba0ab7fab6f319267da7a4
 SHA512:
-  metadata.gz: 1d8d10e392c06bb956d2c889e3090afce100ae4b9ef27a2a8463da231d5d00c645890b82376656bc7f17cdc33f248d49f8dd274ac341a7e60fdaf76d8a3d8496
-  data.tar.gz: caf7c237fb87e4e04d842593fb7cb23d7d65b4494a373cd59fb5fc775a48dbe6c71a7cd86fbfa2d2efc93b338994079f26b9f406f47390cdad52d352476e1846
+  metadata.gz: 443bbd98d165934e83653355a59441aec19aab844a3d381ce604d1701ea3229215459112aa91e4704d6c4bc7a16d1df181c7a21b5f6539d4ef5b7f3bf531d0e0
+  data.tar.gz: '090a1fa0c36b3e13070d5bab7fd0f572342dc737c13fcf6d877aff2730bddd5166ed88b8f2f1894680b93b6620f2bec684f43c2187065b6da020dc5717b2334e'

data/README.md

@@ -45,8 +45,8 @@ env.batch_star("./my-batch.bat")
 Pass the path in which we'll save the environment constructs.
 
 ```ruby
-CLIPS::Environment.save(env, "./my-save.bin")
-env.save("./my-save.bin")
+CLIPS::Environment.save(env, "./my-save.clp")
+env.save("./my-save.clp")
 ```
 
 ### `CLIPS::Environment.load`
@@ -56,8 +56,8 @@ 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.bin")
-env.load("./my-load.bin")
+CLIPS::Environment.load(env, "./my-load.clp")
+env.load("./my-load.clp")
 ```
 
 ### `CLIPS::Environment.save_facts`
@@ -68,12 +68,12 @@ The third argument is optional, and determines whether to store the visible or l
 By default, it'll store local.
 
 ```ruby
-CLIPS::Environment.save_facts(env, "./my-save-facts.bin")
-env.save_facts("./my-save-facts.bin")
-CLIPS::Environment.save_facts(env, "./my-save-facts.bin", :local)
-env.save_facts("./my-save-facts.bin", :local)
-CLIPS::Environment.save_facts(env, "./my-save-facts.bin", :visible)
-env.save_facts("./my-save-facts.bin", :visible)
+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`
@@ -83,8 +83,8 @@ 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.bin")
-env.load_facts("./my-load-facts.bin")
+CLIPS::Environment.load_facts(env, "./my-load-facts.clp")
+env.load_facts("./my-load-facts.clp")
 ```
 
 ### `CLIPS::Environment.bsave`
@@ -338,6 +338,76 @@ 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
+```
+
+### `CLIPS::Environment::Defrule.has_breakpoint`
+### `CLIPS::Environment::Defrule#has_breakpoint`
+
+Returns whether or not the rule has a breakpoint set
+
+```ruby
+CLIPS::Environment::Defrule.has_breakpoint(defrule)
+defrule.has_breakpoint
+```
+
+### `CLIPS::Environment::Defrule.set_break`
+### `CLIPS::Environment::Defrule#set_break`
+
+Sets a breakpoint on a rule
+
+```ruby
+CLIPS::Environment::Defrule.set_break(defrule)
+defrule.set_break
+```
+
+### `CLIPS::Environment::Defrule.remove_break`
+### `CLIPS::Environment::Defrule#remove_break`
+
+Returns whether or not it was able to remove a breakpoint from a rule
+
+```ruby
+CLIPS::Environment::Defrule.remove_break(defrule)
+defrule.remove_break
+```
+
 ## 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);
@@ -1167,6 +1179,134 @@ 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);
+}
+
+static VALUE clips_environment_defrule_has_breakpoint(VALUE self)
+{
+	Defrule *defrule;
+
+	TypedData_Get_Struct(self, Defrule, &Defrule_type, defrule);
+
+	if (DefruleHasBreakpoint(defrule)) {
+		return Qtrue;
+	} else {
+		return Qfalse;
+	}
+}
+
+static VALUE clips_environment_defrule_static_has_breakpoint(VALUE self, VALUE rbDefrule)
+{
+	return clips_environment_defrule_has_breakpoint(rbDefrule);
+}
+
+static VALUE clips_environment_defrule_set_break(VALUE self)
+{
+	Defrule *defrule;
+
+	TypedData_Get_Struct(self, Defrule, &Defrule_type, defrule);
+
+	SetBreak(defrule);
+
+	return Qnil;
+}
+
+static VALUE clips_environment_defrule_static_set_break(VALUE self, VALUE rbDefrule)
+{
+	return clips_environment_defrule_set_break(rbDefrule);
+}
+
+static VALUE clips_environment_defrule_remove_break(VALUE self)
+{
+	Defrule *defrule;
+
+	TypedData_Get_Struct(self, Defrule, &Defrule_type, defrule);
+
+	if (RemoveBreak(defrule)) {
+		return Qtrue;
+	} else {
+		return Qfalse;
+	}
+}
+
+static VALUE clips_environment_defrule_static_remove_break(VALUE self, VALUE rbDefrule)
+{
+	return clips_environment_defrule_remove_break(rbDefrule);
+}
 
 void Init_clipsruby(void)
 {
@@ -1215,6 +1355,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);
@@ -1232,5 +1374,19 @@ 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);
+	rb_define_singleton_method(rbDefrule, "has_breakpoint", clips_environment_defrule_static_has_breakpoint, 1);
+	rb_define_method(rbDefrule, "has_breakpoint", clips_environment_defrule_has_breakpoint, 0);
+	rb_define_singleton_method(rbDefrule, "set_break", clips_environment_defrule_static_set_break, 1);
+	rb_define_method(rbDefrule, "set_break", clips_environment_defrule_set_break, 0);
+	rb_define_singleton_method(rbDefrule, "remove_break", clips_environment_defrule_static_remove_break, 1);
+	rb_define_method(rbDefrule, "remove_break", clips_environment_defrule_remove_break, 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.14
+  version: 0.0.16
 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