clipsruby 0.0.44 → 0.0.46

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83db571b1b54cd6848878cfd5422841e150e51f11b5616640460bce6bac024ef
-  data.tar.gz: 5a25ab26198c8d7b1e92fa8d6c903f01455ac36c7eeaa307255002c45733e55c
+  metadata.gz: 9b6972507ec3fa8c18a30ac264f47258ca20143225bd07590f40d6a509a096b5
+  data.tar.gz: b173a05a28a045b0246e441911050db29f67af0e3747bd61f1e07020f3a8ac23
 SHA512:
-  metadata.gz: 3ce8105ae4ebab196499a520513f56f1b433c712d14e0d3f87f0febe3f20b2dd156bc21c0c69ece6fd9990e5775aa92bd274a231b58bbdf66892ca0975cb46d4
-  data.tar.gz: b375fdfb92af2c1aa02add709b983c1b81cc1376393017026526ca8ac17a8bb6f1aba0776a264bd9eebbceab1d4cc885649a3c8c333eb8b93ec91253c100e8f4
+  metadata.gz: 93c72f0bf4b5fd4268e7c93d913a62411656cb71a59e6811974a90f14f45ffa88b54fdb20814c32797a291878cc9ec299678f1e754479897291f6da66db0a0a0
+  data.tar.gz: e490ed75e9fd2dafbf16d13c0902885ac7a1c135238eb49e3550159ec4d5614db2c836f9d4d125484452d926ebf2ec1c8b206f82fd691f33382bfd153d051676

data/README.md

@@ -483,6 +483,18 @@ CLIPS::Environment.get_defmodule_list(env)
 env.get_defmodule_list
 ```
 
+#### `CLIPS::Environment.get_deffunction_list` / `CLIPS::Environment#get_deffunction_list`
+
+Return an array of Deffunction names as symbols in the environment.
+Optionally pass a `Defmodule`.
+
+```ruby
+CLIPS::Environment.get_deffunction_list(env)
+env.get_deffunction_list
+CLIPS::Environment.get_deffunction_list(env, :MAIN)
+env.get_deffunction_list(defmodule)
+```
+
 #### `CLIPS::Environment.find_deftemplate` / `CLIPS::Environment#find_deftemplate`
 
 Finds a deftemplate by name and returns a CLIPS::Environment::Deftemplate object
@@ -536,6 +548,110 @@ CLIPS::Environment.unwatch(:facts)
 env.unwatch(:statistics)
 ```
 
+#### `CLIPS::Environment#refresh_all_agendas` / `CLIPS::Environment.refresh_all_agendas`
+
+Refresh agendas in all `Defmodule`s in the CLIPS `Environment`.
+
+```ruby
+CLIPS::Environment.refresh_all_agendas(env)
+env.refresh_all_agendas
+```
+
+#### `CLIPS::Environment#reorder_all_agendas` / `CLIPS::Environment.reorder_all_agendas`
+
+Reorder agendas in all `Defmodule`s in the CLIPS `Environment`.
+
+```ruby
+CLIPS::Environment.reorder_all_agendas(env)
+env.reorder_all_agendas
+```
+
+#### `CLIPS::Environment#get_agenda_changed` / `CLIPS::Environment.get_agenda_changed`
+
+Returns whether or not the agenda was changed in the `Environment`.
+
+```ruby
+CLIPS::Environment.get_agenda_changed(env)
+env.get_agenda_changed
+```
+
+#### `CLIPS::Environment#set_agenda_changed` / `CLIPS::Environment.set_agenda_changed`
+
+Sets whether or not the agenda was changed in the `Environment`.
+
+```ruby
+CLIPS::Environment.set_agenda_changed(env, false)
+env.set_agenda_changed true
+```
+
+#### `CLIPS::Environment#get_salience_evaluation` / `CLIPS::Environment.get_salience_evaluation`
+
+Returns the salience evaluation current set in the `Environment`.
+Possible return values are:
+
+- `:"when-defined"`
+- `:"when-activated"`
+- `:"every-cycle"`
+- `:unknown`
+
+```ruby
+CLIPS::Environment.get_salience_evaluation(env)
+env.get_salience_evaluation
+```
+
+#### `CLIPS::Environment#set_salience_evaluation` / `CLIPS::Environment.set_salience_evaluation`
+
+Sets the salience evaluation in the `Environment`.
+Possible arguments are:
+
+- `:"when-defined"`
+- `:"when-activated"`
+- `:"every-cycle"`
+- `:unknown`
+
+```ruby
+CLIPS::Environment.set_salience_evaluation(env, :"when-defined")
+env.set_salience_evaluation :"every-cycle"
+```
+
+#### `CLIPS::Environment#get_strategy` / `CLIPS::Environment.get_strategy`
+
+Returns the strategy current set in the `Environment`.
+Possible return values are:
+
+- `:depth`
+- `:breadth`
+- `:lex`
+- `:mea`
+- `:complexity`
+- `:simplicity`
+- `:random`
+- `:unknown`
+
+```ruby
+CLIPS::Environment.get_strategy(env)
+env.get_strategy
+```
+
+#### `CLIPS::Environment#set_strategy` / `CLIPS::Environment.set_strategy`
+
+Sets the strategy in the `Environment`.
+Possible arguments are:
+
+- `:depth`
+- `:breadth`
+- `:lex`
+- `:mea`
+- `:complexity`
+- `:simplicity`
+- `:random`
+- `:unknown`
+
+```ruby
+CLIPS::Environment.set_strategy(env, :lex)
+env.set_strategy :mea
+```
+
 ### Fact Methods
 
 #### `CLIPS::Environment::Fact.pp_form` / `CLIPS::Environment::Fact#pp_form`
@@ -951,6 +1067,50 @@ CLIPS::Environment::Defmodule.get_defrule_list(defmodule)
 defmodule.get_defrule_list
 ```
 
+#### `CLIPS::Environment::Defmodule.get_deffunction_list` / `CLIPS::Environment::Defmodule#get_deffunction_list`
+
+Return an array of Deffunction names as symbols in the Defmodule
+
+```ruby
+CLIPS::Environment::Defmodule.get_deffunction_list(defmodule)
+defmodule.get_deffunction_list
+```
+
+#### `CLIPS::Environment::Defmodule.refresh_agenda` / `CLIPS::Environment::Defmodule#refresh_agenda` 
+
+Refreshes the agenda in a given Defmodule.
+If you used `CLIPS::Environment::Activation.set_salience` / 
+`CLIPS::Environment::Activation#set_salience` to set the salience
+of an activation, using `refresh_agenda` will set it back to its
+original salience.
+
+```ruby
+CLIPS::Environment::Defmodule.refresh_agenda(defmodule)
+defmodule.refresh_agenda
+```
+
+#### `CLIPS::Environment::Defmodule.reorder_agenda` / `CLIPS::Environment::Defmodule#reorder_agenda` 
+
+Refreshes the agenda in a given Defmodule.
+If you used `CLIPS::Environment::Activation.set_salience` / 
+`CLIPS::Environment::Activation#set_salience` to set the salience
+of an activation, using `reorder_agenda` will re-order the agenda
+according to the new salience of activations on the agenda.
+
+```ruby
+CLIPS::Environment::Defmodule.reorder_agenda(defmodule)
+defmodule.reorder_agenda
+```
+
+#### `CLIPS::Environment::Defmodule.delete_all_activations` / `CLIPS::Environment::Defmodule#delete_all_activations` 
+
+Deletes all activations in the agenda in a given Defmodule.
+
+```ruby
+CLIPS::Environment::Defmodule.delete_all_activations(defmodule)
+defmodule.delete_all_activations
+```
+
 ### Deftemplate Methods
 
 #### `CLIPS::Environment::Deftemplate.name` / `CLIPS::Environment::Deftemplate#name`
@@ -1143,8 +1303,26 @@ CLIPS::Environment.find_deffacts(:a)
 env.find_deffacts("foo")
 ```
 
+#### `CLIPS::Environment.find_deffunction` / `CLIPS::Environment#find_deffunction`
+
+Finds a `Deffunction` by name and returns a CLIPS::Environment::Deffunction object
+
+```ruby
+CLIPS::Environment.find_deffunction(:"MAIN::my_deffunction")
+env.find_deffunction("MAIN::other_deffunction")
+```
+
 ### Deffacts Methods
 
+#### `CLIPS::Environment::Deffunction.call` / `CLIPS::Environment::Deffunction#call` 
+
+Calls the `Deffunction`, passing it the arguments, returning the return value
+
+```ruby
+CLIPS::Environment::Deffunction.call(deffunction, :FOO, :BAR)
+deffunction.call(:FOO, :BAR)
+```
+
 #### `CLIPS::Environment::Deffacts.name` / `CLIPS::Environment::Deffacts#name`
 
 Returns the name of a deffacts as a symbol
@@ -1165,7 +1343,16 @@ deffacts.pp_form
 
 ### Activation Methods
 
-#### `CLIPS::Environment::Activation.defule_name` / `CLIPS::Environment::Activation#defule_name`
+#### `CLIPS::Environment::Activation.delete` / `CLIPS::Environment::Activation#delete`
+
+Deletes an `Activation` from the agenda.
+
+```ruby
+CLIPS::Environment::Activation.delete
+activation.delete
+```
+
+#### `CLIPS::Environment::Activation.defrule_name` / `CLIPS::Environment::Activation#defrule_name`
 
 Returns the name of a defrule that triggered this activation.
 
@@ -1174,6 +1361,80 @@ CLIPS::Environment::Activation.defrule_name
 activation.defrule_name
 ```
 
+#### `CLIPS::Environment::Activation.get_salience` / `CLIPS::Environment::Activation#get_salience`
+
+Returns the salience of this activation.
+
+```ruby
+CLIPS::Environment::Activation.get_salience(activation)
+activation.get_salience
+```
+
+#### `CLIPS::Environment::Activation.set_salience` / `CLIPS::Environment::Activation#set_salience`
+
+Sets the salience of this activation.
+
+```ruby
+CLIPS::Environment::Activation.set_salience(activation, 11)
+activation.set_salience 123
+```
+
+#### `CLIPS::Environment::Activation.pp_form` / `CLIPS::Environment::Activation#pp_form`
+
+Returns a pretty printed string representation of the Activation
+
+```ruby
+CLIPS::Environment::Activation.pp_form(activation)
+activation.pp_form
+```
+
+### Deffunction Methods
+
+#### `CLIPS::Environment::Deffunction.name` / `CLIPS::Environment::Deffunction#name` 
+
+Returns the name of the `Deffunction` as a symbol
+
+```ruby
+CLIPS::Environment::Deffunction.name(deffunction)
+deffunction.name
+```
+
+#### `CLIPS::Environment::Deffunction.pp_form` / `CLIPS::Environment::Deffunction#pp_form` 
+
+Returns the pretty printed version of the `Deffunction`
+
+```ruby
+CLIPS::Environment::Deffunction.pp_form(deffunction)
+deffunction.pp_form
+```
+
+#### `CLIPS::Environment::Deffunction.is_deletable` / `CLIPS::Environment::Deffunction#is_deletable` 
+
+Returns whether the `Deffunction` is deletable or not
+
+```ruby
+CLIPS::Environment::Deffunction.is_deletable(deffunction)
+deffunction.is_deletable
+```
+
+#### `CLIPS::Environment::Deffunction.defmodule` / `CLIPS::Environment::Deffunction#defmodule` 
+
+Returns the `Defmodule` that the `Deffunction` is defined in
+
+```ruby
+CLIPS::Environment::Deffunction.defmodule(deffunction)
+deffunction.defmodule
+```
+
+#### `CLIPS::Environment::Deffunction.defmodule_name` / `CLIPS::Environment::Deffunction#defmodule_name` 
+
+Returns the name of the `Defmodule` that the `Deffunction` is defined in
+
+```ruby
+CLIPS::Environment::Deffunction.defmodule_name(deffunction)
+deffunction.defmodule_name
+```
+
 ## Running the tests
 
 Simply do `rake compile` and then `rake test` in order to run the tests.

data/ext/clipsruby/clipsruby.c

@@ -115,6 +115,18 @@ static const rb_data_type_t Activation_type = {
 	.flags = RUBY_TYPED_FREE_IMMEDIATELY
 };
 
+size_t deffunction_size(const void *data)
+{
+	return sizeof(Deffunction);
+}
+
+static const rb_data_type_t Deffunction_type = {
+	.function = {
+		.dsize = deffunction_size
+	},
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
 static VALUE clips_environment_fact_deftemplate(VALUE self)
 {
 	VALUE rbDeftemplate, rbEnvironment;
@@ -293,6 +305,11 @@ VALUE activation_alloc(VALUE self)
 	return TypedData_Wrap_Struct(self, &Activation_type, NULL);
 }
 
+VALUE deffunction_alloc(VALUE self)
+{
+	return TypedData_Wrap_Struct(self, &Deffunction_type, NULL);
+}
+
 VALUE environment_alloc(VALUE self)
 {
 	return TypedData_Wrap_Struct(self, &Environment_type, CreateEnvironment());
@@ -2671,37 +2688,6 @@ static VALUE clips_environment_static_find_defrule(VALUE self, VALUE rbEnvironme
 	return clips_environment_find_defrule(rbEnvironment, defrule_name);
 }
 
-static VALUE clips_environment_find_deffacts(VALUE self, VALUE deffacts_name)
-{
-	Environment *env;
-	Deffacts *deffacts;
-
-	TypedData_Get_Struct(self, Environment, &Environment_type, env);
-
-	switch (TYPE(deffacts_name)) {
-		case T_STRING:
-			deffacts = FindDeffacts(env, StringValueCStr(deffacts_name));
-			break;
-		case T_SYMBOL:
-			deffacts = FindDeffacts(env, rb_id2name(SYM2ID(deffacts_name)));
-			break;
-                default:
-			rb_warn("deffacts name must be a symbol or string");
-			return Qnil;
-        }
-
-	if (deffacts == NULL) {
-		return Qnil;
-	} else {
-		return TypedData_Wrap_Struct(rb_const_get(CLASS_OF(self), rb_intern("Deffacts")), &Deffacts_type, deffacts);
-	}
-}
-
-static VALUE clips_environment_static_find_deffacts(VALUE self, VALUE rbEnvironment, VALUE deffacts_name)
-{
-	return clips_environment_find_deffacts(rbEnvironment, deffacts_name);
-}
-
 static VALUE clips_environment_deffacts_name(VALUE self)
 {
 	Deffacts *deffacts;
@@ -2759,24 +2745,6 @@ static VALUE clips_environment_static_get_current_module(VALUE self, VALUE rbEnv
 	return clips_environment_get_current_module(rbEnvironment);
 }
 
-static VALUE clips_environment_set_current_module(VALUE self, VALUE rbDefmodule)
-{
-	Environment *env;
-	Defmodule *module;
-
-	TypedData_Get_Struct(self, Environment, &Environment_type, env);
-	TypedData_Get_Struct(rbDefmodule, Defmodule, &Defmodule_type, module);
-
-	SetCurrentModule(env, module);
-
-	return rbDefmodule;
-}
-
-static VALUE clips_environment_static_set_current_module(VALUE self, VALUE rbEnvironment, VALUE defmodule_name)
-{
-	return clips_environment_set_current_module(rbEnvironment, defmodule_name);
-}
-
 static VALUE clips_environment_find_defmodule(VALUE self, VALUE defmodule_name)
 {
 	Environment *env;
@@ -2811,6 +2779,38 @@ static VALUE clips_environment_static_find_defmodule(VALUE self, VALUE rbEnviron
 	return clips_environment_find_defmodule(rbEnvironment, defmodule_name);
 }
 
+static VALUE clips_environment_set_current_module(VALUE self, VALUE defmodule_or_defmodule_name)
+{
+	VALUE rbDefmodule;
+	Environment *env;
+	Defmodule *module;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+	switch (TYPE(defmodule_or_defmodule_name)) {
+		case T_STRING:
+		case T_SYMBOL:
+			rbDefmodule = clips_environment_find_defmodule(self, defmodule_or_defmodule_name);
+			break;
+		case T_DATA:
+			rbDefmodule = defmodule_or_defmodule_name;
+			break;
+                default:
+			rb_raise(rb_eTypeError, "Defmodule must be an instance of CLIPS::Environment::Defmodule, symbol, or string");
+			return Qnil;
+        }
+	TypedData_Get_Struct(rbDefmodule, Defmodule, &Defmodule_type, module);
+
+	SetCurrentModule(env, module);
+
+	return rbDefmodule;
+}
+
+static VALUE clips_environment_static_set_current_module(VALUE self, VALUE rbEnvironment, VALUE defmodule_name)
+{
+	return clips_environment_set_current_module(rbEnvironment, defmodule_name);
+}
+
+
 static VALUE clips_environment_find_instance(int argc, VALUE *argv, VALUE rbEnvironment) {
 	VALUE instanceName, search_imports, rbInstance, rbDefmodule;
 	Defmodule *defmodule;
@@ -2935,6 +2935,37 @@ static VALUE clips_environment_static_find_instance(int argc, VALUE *argv, VALUE
 	}
 }
 
+static VALUE clips_environment_find_deffacts(VALUE self, VALUE deffacts_name)
+{
+	Environment *env;
+	Deffacts *deffacts;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	switch (TYPE(deffacts_name)) {
+		case T_STRING:
+			deffacts = FindDeffacts(env, StringValueCStr(deffacts_name));
+			break;
+		case T_SYMBOL:
+			deffacts = FindDeffacts(env, rb_id2name(SYM2ID(deffacts_name)));
+			break;
+                default:
+			rb_warn("deffacts name must be a symbol or string");
+			return Qnil;
+        }
+
+	if (deffacts == NULL) {
+		return Qnil;
+	} else {
+		return TypedData_Wrap_Struct(rb_const_get(CLASS_OF(self), rb_intern("Deffacts")), &Deffacts_type, deffacts);
+	}
+}
+
+static VALUE clips_environment_static_find_deffacts(VALUE self, VALUE rbEnvironment, VALUE deffacts_name)
+{
+	return clips_environment_find_deffacts(rbEnvironment, deffacts_name);
+}
+
 static VALUE clips_environment_defmodule_find_instance(int argc, VALUE *argv, VALUE rbDefmodule) {
 	VALUE instanceName, search_imports, rbInstance, rbEnvironment;
 	Defmodule *defmodule;
@@ -3027,6 +3058,40 @@ static VALUE clips_environment_defmodule_static_find_instance(int argc, VALUE *a
 	}
 }
 
+static VALUE clips_environment_find_deffunction(VALUE self, VALUE deffunction_name)
+{
+	Environment *env;
+	Deffunction *deffunction;
+
+	TypedData_Get_Struct(self, Environment, &Environment_type, env);
+
+	switch (TYPE(deffunction_name)) {
+		case T_STRING:
+			deffunction = FindDeffunction(env, StringValueCStr(deffunction_name));
+			break;
+		case T_SYMBOL:
+			deffunction = FindDeffunction(env, rb_id2name(SYM2ID(deffunction_name)));
+			break;
+                default:
+			rb_warn("deffunction name must be a symbol or string");
+			return Qnil;
+        }
+
+	if (deffunction == NULL) {
+		return Qnil;
+	} else {
+		VALUE rbDeffunction;
+		rbDeffunction = TypedData_Wrap_Struct(rb_const_get(CLASS_OF(self), rb_intern("Deffunction")), &Deffunction_type, deffunction);
+		rb_iv_set(rbDeffunction, "@environment", self);
+		return rbDeffunction;
+	}
+}
+
+static VALUE clips_environment_static_find_deffunction(VALUE self, VALUE rbEnvironment, VALUE deffunction_name)
+{
+	return clips_environment_find_deffunction(rbEnvironment, deffunction_name);
+}
+
 static VALUE clips_environment_defmodule_refresh_agenda(VALUE self)
 {
 	Defmodule *module;
@@ -3849,6 +3914,30 @@ static VALUE clips_environment_defmodule_static_get_defrule_list(VALUE self, VAL
 	return clips_environment_defmodule_get_defrule_list(rbDefmodule);
 }
 
+static VALUE clips_environment_defmodule_get_deffunction_list(VALUE self)
+{
+	Defmodule *module;
+	Environment *env;
+	CLIPSValue value;
+	VALUE out;
+
+	VALUE rbEnvironment = rb_iv_get(self, "@environment");
+
+	TypedData_Get_Struct(self, Defmodule, &Defmodule_type, module);
+	TypedData_Get_Struct(rbEnvironment, Environment, &Environment_type, env);
+
+	GetDeffunctionList(env, &value, module);
+
+	CLIPSValue_to_VALUE(&value, &out, &rbEnvironment);
+
+	return out;
+}
+
+static VALUE clips_environment_defmodule_static_get_deffunction_list(VALUE self, VALUE rbDefmodule)
+{
+	return clips_environment_defmodule_get_deffunction_list(rbDefmodule);
+}
+
 static VALUE clips_environment_get_defmodule_list(VALUE self)
 {
 	Environment *env;
@@ -5054,6 +5143,73 @@ static VALUE clips_environment_static_set_strategy(VALUE self, VALUE rbEnvironme
 	return clips_environment_set_strategy(rbEnvironment, changed);
 }
 
+static VALUE clips_environment_get_deffunction_list(int argc, VALUE *argv, VALUE rbEnvironment) {
+	VALUE defmodule_or_defmodule_name;
+	Environment *env;
+	Defmodule *module;
+	CLIPSValue value;
+	VALUE out;
+
+	TypedData_Get_Struct(rbEnvironment, Environment, &Environment_type, env);
+
+	rb_scan_args(argc, argv, "01", &defmodule_or_defmodule_name);
+	switch (TYPE(defmodule_or_defmodule_name)) {
+		case T_NIL:
+			module = NULL;
+			break;
+		case T_STRING:
+		case T_SYMBOL:
+			TypedData_Get_Struct(
+				clips_environment_find_defmodule(rbEnvironment, defmodule_or_defmodule_name),
+				Defmodule, &Defmodule_type, module);
+			break;
+		case T_DATA:
+			TypedData_Get_Struct(defmodule_or_defmodule_name, Defmodule, &Defmodule_type, module);
+			break;
+                default:
+			rb_warn("defmodule name must be a symbol or string");
+			return Qnil;
+        }
+	GetDeffunctionList(env, &value, module);
+
+	CLIPSValue_to_VALUE(&value, &out, &rbEnvironment);
+
+	return out;
+}
+
+static VALUE clips_environment_static_get_deffunction_list(int argc, VALUE *argv, VALUE klass) {
+	VALUE rbEnvironment, defmodule_or_defmodule_name;
+	Environment *env;
+	Defmodule *module;
+	CLIPSValue value;
+	VALUE out;
+
+	rb_scan_args(argc, argv, "11", &rbEnvironment, &defmodule_or_defmodule_name);
+
+	TypedData_Get_Struct(rbEnvironment, Environment, &Environment_type, env);
+	switch (TYPE(defmodule_or_defmodule_name)) {
+		case T_NIL:
+			module = NULL;
+			break;
+		case T_STRING:
+		case T_SYMBOL:
+			TypedData_Get_Struct(
+				clips_environment_find_defmodule(rbEnvironment, defmodule_or_defmodule_name),
+				Defmodule, &Defmodule_type, module);
+			break;
+		case T_DATA:
+			TypedData_Get_Struct(defmodule_or_defmodule_name, Defmodule, &Defmodule_type, module);
+			break;
+                default:
+			rb_warn("defmodule name must be a symbol or string");
+			return Qnil;
+        }
+	GetDeffunctionList(env, &value, module);
+
+	CLIPSValue_to_VALUE(&value, &out, &rbEnvironment);
+
+	return out;
+}
 
 static VALUE clips_environment_activation_defrule_name(VALUE self)
 {
@@ -5122,7 +5278,7 @@ static VALUE clips_environment_activation_static_pp_form(VALUE self, VALUE rbAct
 	return clips_environment_activation_pp_form(rbActivation);
 }
 
-static VALUE clips_environment_activation_delete_activation(VALUE self)
+static VALUE clips_environment_activation_delete(VALUE self)
 {
 	Activation *activation;
 
@@ -5133,9 +5289,170 @@ static VALUE clips_environment_activation_delete_activation(VALUE self)
 	return Qnil;
 }
 
-static VALUE clips_environment_activation_static_delete_activation(VALUE self, VALUE rbActivation)
+static VALUE clips_environment_activation_static_delete(VALUE self, VALUE rbActivation)
+{
+	return clips_environment_activation_delete(rbActivation);
+}
+
+static VALUE clips_environment_deffunction_name(VALUE self)
+{
+	Deffunction *deffunction;
+
+	TypedData_Get_Struct(self, Deffunction, &Deffunction_type, deffunction);
+
+	return ID2SYM(rb_intern(DeffunctionName(deffunction)));
+}
+
+static VALUE clips_environment_deffunction_static_name(VALUE self, VALUE rbDeffunction)
+{
+	return clips_environment_deffunction_name(rbDeffunction);
+}
+
+static VALUE clips_environment_deffunction_pp_form(VALUE self)
+{
+	Deffunction *deffunction;
+
+	TypedData_Get_Struct(self, Deffunction, &Deffunction_type, deffunction);
+
+	return rb_str_new2(DeffunctionPPForm(deffunction));
+}
+
+static VALUE clips_environment_deffunction_static_pp_form(VALUE self, VALUE rbDeffunction)
 {
-	return clips_environment_activation_delete_activation(rbActivation);
+	return clips_environment_deffunction_pp_form(rbDeffunction);
+}
+
+static VALUE clips_environment_deffunction_is_deletable(VALUE self)
+{
+	Deffunction *deffunction;
+
+	TypedData_Get_Struct(self, Deffunction, &Deffunction_type, deffunction);
+
+	if (DeffunctionIsDeletable(deffunction)) {
+		return Qtrue;
+	} else {
+		return Qfalse;
+	}
+}
+
+static VALUE clips_environment_deffunction_static_is_deletable(VALUE self, VALUE rbDeffunction)
+{
+	return clips_environment_deffunction_is_deletable(rbDeffunction);
+}
+
+static VALUE clips_environment_deffunction_defmodule_name(VALUE self)
+{
+	Deffunction *function;
+
+	TypedData_Get_Struct(self, Deffunction, &Deffunction_type, function);
+
+	return ID2SYM(rb_intern(DeffunctionModule(function)));
+}
+
+static VALUE clips_environment_deffunction_static_defmodule_name(VALUE self, VALUE rbDeffunction)
+{
+	return clips_environment_deffunction_defmodule_name(rbDeffunction);
+}
+
+static VALUE clips_environment_deffunction_defmodule(VALUE self)
+{
+	Deffunction *function;
+	const char *defmoduleName;
+	Defmodule *defmodule = NULL;
+	Environment *env;
+
+	VALUE rbEnvironment = rb_iv_get(self, "@environment");
+	TypedData_Get_Struct(rbEnvironment, Environment, &Environment_type, env);
+
+	TypedData_Get_Struct(self, Deffunction, &Deffunction_type, function);
+
+	defmoduleName = DeffunctionModule(function);
+
+	if (defmoduleName != NULL) {
+		defmodule = FindDefmodule(env, defmoduleName);
+	}
+
+	if (defmodule != NULL) {
+		return TypedData_Wrap_Struct(rb_const_get(CLASS_OF(rbEnvironment), rb_intern("Defmodule")), &Defmodule_type, defmodule);
+	} else {
+		return Qnil;
+	}
+}
+
+static VALUE clips_environment_deffunction_static_defmodule(VALUE self, VALUE rbDeffunction)
+{
+	return clips_environment_deffunction_defmodule(rbDeffunction);
+}
+
+static VALUE clips_environment_deffunction_call(int argc, VALUE *argv, VALUE self)
+{
+	FunctionCallBuilder *fcb;
+	Deffunction *function;
+	CLIPSValue value;
+	VALUE out;
+	const char *functionName, *defmoduleName, *currentDefmoduleName;
+	Environment *env;
+
+	VALUE rbEnvironment = rb_iv_get(self, "@environment");
+	TypedData_Get_Struct(rbEnvironment, Environment, &Environment_type, env);
+
+	TypedData_Get_Struct(self, Deffunction, &Deffunction_type, function);
+
+	functionName = DeffunctionName(function);
+	defmoduleName = DeffunctionModule(function);
+	currentDefmoduleName = DefmoduleName(GetCurrentModule(env));
+
+	fcb = CreateFunctionCallBuilder(env, argc);
+
+	for (int i = 0; i < argc; i++) {
+		value = VALUE_to_CLIPSValue(argv[i], env);
+		FCBAppend(fcb, &value);
+	}
+
+	switch(FCBCall(fcb, functionName, &value))
+	{
+		case FCBE_NO_ERROR:
+			break;
+		case FCBE_NULL_POINTER_ERROR:
+			FCBDispose(fcb);
+			rb_raise(rb_eStandardError, "Somehow the FunctionCallBuilder or Deffunction name was NULL\n");
+			break;
+		case FCBE_FUNCTION_NOT_FOUND_ERROR:
+			FCBDispose(fcb);
+			rb_raise(rb_eStandardError, "A function, deffunction, or generic function could not be found with the name %s defined in module %s from the current module %s\n", functionName, defmoduleName, currentDefmoduleName);
+			break;
+		case FCBE_INVALID_FUNCTION_ERROR:
+			FCBDispose(fcb);
+			rb_raise(rb_eStandardError, "The function or command has a specialized parser (such as the assert command) and cannot be invoked.\n");
+			break;
+		case FCBE_ARGUMENT_COUNT_ERROR:
+			FCBDispose(fcb);
+			rb_raise(rb_eStandardError,"The function was passed the incorrect number of arguments.\n");
+			break;
+		case FCBE_ARGUMENT_TYPE_ERROR:
+			FCBDispose(fcb);
+			rb_raise(rb_eStandardError,"The function was passed an argument with an invalid type.\n");
+			break;
+		case FCBE_PROCESSING_ERROR:
+			FCBDispose(fcb);
+			rb_raise(rb_eStandardError,"An error occurred while the function was being evaluated.\n");
+			break;
+		default:
+			FCBDispose(fcb);
+			rb_raise(rb_eStandardError,"Something went wrong calling the deffunction %s\n",functionName);
+			break;
+	}
+
+	FCBDispose(fcb);
+
+	CLIPSValue_to_VALUE(&value, &out, &rbEnvironment);
+
+	return out;
+}
+
+static VALUE clips_environment_deffunction_static_call(int argc, VALUE *argv, VALUE klass)
+{
+	return clips_environment_deffunction_call(argc, argv+1, argv[0]);
 }
 
 void Init_clipsruby(void)
@@ -5203,6 +5520,10 @@ void Init_clipsruby(void)
 	rb_define_method(rbEnvironment, "find_defclass", clips_environment_find_defclass, 1);
 	rb_define_singleton_method(rbEnvironment, "find_instance", clips_environment_static_find_instance, -1);
 	rb_define_method(rbEnvironment, "find_instance", clips_environment_find_instance, -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, "find_deffunction", clips_environment_static_find_deffunction, 2);
+	rb_define_method(rbEnvironment, "find_deffunction", clips_environment_find_deffunction, 1);
 	rb_define_singleton_method(rbEnvironment, "get_current_module", clips_environment_static_get_current_module, 1);
 	rb_define_method(rbEnvironment, "get_current_module", clips_environment_get_current_module, 0);
 	rb_define_singleton_method(rbEnvironment, "set_current_module", clips_environment_static_set_current_module, 2);
@@ -5221,8 +5542,8 @@ void Init_clipsruby(void)
 	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, "get_deffunction_list", clips_environment_static_get_deffunction_list, -1);
+	rb_define_method(rbEnvironment, "get_deffunction_list", clips_environment_get_deffunction_list, -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);
@@ -5368,6 +5689,8 @@ void Init_clipsruby(void)
 	rb_define_method(rbDefmodule, "get_deftemplate_list", clips_environment_defmodule_get_deftemplate_list, 0);
 	rb_define_singleton_method(rbDefmodule, "get_defrule_list", clips_environment_defmodule_static_get_defrule_list, 1);
 	rb_define_method(rbDefmodule, "get_defrule_list", clips_environment_defmodule_get_defrule_list, 0);
+	rb_define_singleton_method(rbDefmodule, "get_deffunction_list", clips_environment_defmodule_static_get_deffunction_list, 1);
+	rb_define_method(rbDefmodule, "get_deffunction_list", clips_environment_defmodule_get_deffunction_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);
@@ -5467,6 +5790,21 @@ void Init_clipsruby(void)
 	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);
+	rb_define_singleton_method(rbActivation, "delete", clips_environment_activation_static_delete, 1);
+	rb_define_method(rbActivation, "delete", clips_environment_activation_delete, 0);
+
+	VALUE rbDeffunction = rb_define_class_under(rbEnvironment, "Deffunction", rb_cObject);
+	rb_define_alloc_func(rbDeffunction, deffunction_alloc);
+	rb_define_singleton_method(rbDeffunction, "name", clips_environment_deffunction_static_name, 1);
+	rb_define_method(rbDeffunction, "name", clips_environment_deffunction_name, 0);
+	rb_define_singleton_method(rbDeffunction, "pp_form", clips_environment_deffunction_static_pp_form, 1);
+	rb_define_method(rbDeffunction, "pp_form", clips_environment_deffunction_pp_form, 0);
+	rb_define_singleton_method(rbDeffunction, "is_deletable", clips_environment_deffunction_static_is_deletable, 1);
+	rb_define_method(rbDeffunction, "is_deletable", clips_environment_deffunction_is_deletable, 0);
+	rb_define_singleton_method(rbDeffunction, "defmodule", clips_environment_deffunction_static_defmodule, 1);
+	rb_define_method(rbDeffunction, "defmodule", clips_environment_deffunction_defmodule, 0);
+	rb_define_singleton_method(rbDeffunction, "defmodule_name", clips_environment_deffunction_static_defmodule_name, 1);
+	rb_define_method(rbDeffunction, "defmodule_name", clips_environment_deffunction_defmodule_name, 0);
+	rb_define_singleton_method(rbDeffunction, "call", clips_environment_deffunction_static_call, -1);
+	rb_define_method(rbDeffunction, "call", clips_environment_deffunction_call, -1);
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: clipsruby
 version: !ruby/object:Gem::Version
-  version: 0.0.44
+  version: 0.0.46
 platform: ruby
 authors:
 - Ryan Johnston