# Rulz

Rulz is a rule engine for Ruby, allowing developers to define rules in their classes.

## Installation

Add this line to your application's Gemfile:

    gem 'rulz'

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install rulz

## Usage

In the model(s) which you want to apply rules to, include the rulz module (you may need to `require` it first):

	include Rulz

### Defining Rules

#### Conditions and Actions

	define_rulz do
		condition "less than" do |other|
			it < other
		end
		condition "contains" do	|other|
			it.contains? other
		end
		action "assign to user" do |user|
			its.user = user
		end
	end

When defining conditions, it is possible to reference other condition:

	condition "not equal to" do |other|
		opposite_of "equal to", other
	end
	
Actions can be combined in a similar way:

	action "put on shoes" do
		action "put on socks"
		its.feet << "shoes"
	end

The following conditions come predefined with rulz:

* less than
* greater than
* equal to
* not equal to
* contains
* does not contain
* matches
* does not match
* like
* not like

To load these conditions for the whole class `include` any of the following modules

* Rulz::Conditions::Comparison
* Rulz::Conditions::Container
* Rulz::Conditions::String

To load these conditions for a cetain attribute, call the `type` method inside the attribute block:

	define_rulz do
		attribute :foo do
			type :integer
		end
	end
	
The following types are allowed:

* integer
* float
* string
* array
* hash

#### It

"it" refers to the object that the conditions/rules are being applied to. For readability, "it" is aliased to "its"

#### Rules

	class Number < Fixnum
		define_rulz	do
			condition "even" do
				it % 2 == 0
			end
			condition "odd" do
				opposite_of "even"
			end
			action "make even" do
				it += 1
			end
			rule do
				where("odd") { apply! "make even" }
			end
		end
	end

Conditions can also be combined in `where` statements:

	rule do
		where(["odd", "AND", "prime"]) { apply! "make even" }
	end

Where statements can also accept the attribute method:

	rule do
		where :id => "odd" do
			apply! "make even"
		end
	end
	
	rule do
		where :id => ["multiple of", 5] do
			apply! "make even"
		end
	end
	
When options need to be combined:

	rule do
		where [{:id => ["multiple of", 5]}, "AND", "odd"] do
			apply! "make even"
		end
	end


### Applying Rules

To apply rules to a single object, call the `apply_rules!` method like so:

	m = Melon.new
	m.apply_rules!

## Contributing

1. Fork it
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request