ruva 1.0.0

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.project
+.bundle
+.config
+.yardoc
+.DS_store
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - ruby-head
+script: bundle exec rspec spec

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ruva.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Samuel Mueller
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,143 @@
+# Ruva
+
+[![Build Status](https://secure.travis-ci.org/ssmm/ruva.png)](http://travis-ci.org/ssmm/ruva) 
+[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/ssmm/ruva)
+
+Ruva is a simple utility to write conditions in a human readable manner.
+
+Assume you have an object called `person` with an attribute `age = 23`:
+
+```ruby
+person = OpenStruct.new
+person.age = 23
+```
+
+You write 
+
+```ruby
+person.if "age is 23" do 
+  stuff
+end
+```
+
+You can also define more complex conditions:
+
+    any
+      name matches samuel
+      all
+        city matches zurich
+        profession matches /application engineer/
+        age is greater than or equal to 18      
+
+In plain ruby, the above condition translates to
+
+```ruby
+(person.name =~ /samuel/) ||
+(person.city =~ /zurich/ && person.profession =~ /application engineer/ && person.age >= 18)
+```
+
+# Details
+
+## Inline definition
+
+### One liners
+
+As in the example above you can define a short condition on one line:
+
+```ruby
+person.if "name matches daniel or jonas" do
+  stuff
+end
+```
+
+You can also define an else statement:
+
+```ruby
+person.if("name matches daniel or jonas") do
+  stuff
+end.else do
+  other_stuff
+end
+```
+
+Note that you have to put the condition into brackets in this case.
+
+### Multiline
+
+You may define larger conditions like this:
+
+```ruby
+person.if "
+  any
+    name matches lisa or simon or samuel
+    age is between 18 and 28
+    city matches zurich or /st. gallen/
+" do
+  stuff
+end
+```
+
+The above definition says, that the condition is met if any of the three conditions defined under the 
+`any` keyword meet.
+
+Currently supported are the keywords `all`, `any` and `none`.
+
+## Separate definition
+
+You can define the same condition in a file with ".ruva" as extension:
+
+    any
+      name matches lisa or simon or samuel
+      age is between 18 and 28
+      city matches zurich or /st. gallen/
+
+Then you load it:
+
+```ruby
+condition = Ruva.read "your_condition"
+```
+
+At this point, ruva loads the condition into some kind of hirarchy, according to the 
+[Specification pattern](http://en.wikipedia.org/wiki/Specification_pattern), and you can invoke its 
+`evaluate` method to test any object you want against that condition:
+
+```ruby
+result = condition.evaluate(your_input)
+```
+
+## Expressions
+
+#### is
+
+    age is 20
+
+Acts the same as the `==` operator.
+
+#### is between
+
+    age is between 20 and 30
+
+Acts the same as [`between?`](http://www.ruby-doc.org/core-1.9.3/Comparable.html#method-i-between-3F).
+
+#### is greater than (or equal to) / is less than (or equal to)
+
+    age is greater than 18
+    age is less than 18
+    age is greater than or equal to 18
+    age is less than or equal to 18
+
+Acts the same as the `<, >, <=, >=` operators
+
+#### matches
+
+    city matches zurich
+    city matches /new york/
+
+Acts the same as the `=~` operator.
+
+#### or / and
+
+You can use `ors` and `ands` where it makes sense. For Example:
+
+    name matches lisa or simon or samuel
+    city matches z and u and r

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/ruva.rb

@@ -0,0 +1,73 @@
+require 'indentation-parser'
+
+require "ruva/version"
+require "ruva/expression"
+
+class Object
+  def if condition
+    raise unless block_given?
+    spec = Ruva.interpret(Ruva.normalize_indentation condition)
+    result = spec.evaluate self
+    yield if result.satisfied
+    Ruva::Else.new result.satisfied
+  end
+end
+
+module Ruva
+
+  def self.read file
+    interpret IO.read("#{file}.ruva")
+  end
+  
+  def self.interpret text
+    
+    parser = IndentationParser.new do |p|
+      p.on /^all$/ do |parent, source, captures| 
+        node = AndSpec.new
+        parent.append node
+        node
+      end
+      
+      p.on /^any$/ do |parent, source, captures| 
+        node = OrSpec.new
+        parent.append node
+        node
+      end
+      
+      p.on /^none$/ do |parent, source, captures| 
+        node = NotSpec.new
+        parent.append node
+        node
+      end
+      
+      p.else do |parent, source|
+        node = RuvaExpression.parse(source)
+        parent.append node
+        node
+      end
+    end
+    
+    spec = parser.read(text, AndSpec.new)
+    spec.value
+  end
+  
+  def self.normalize_indentation str
+    if str.index(/^[ ]*$\n/) == 0
+      str.sub!(/^[ ]*$\n/, "")
+    end
+    captures = /^\A([ ]*)/.match str
+    first_indentation = captures[1]
+    str.gsub!(/^#{first_indentation}/, "")
+    str
+  end
+  
+  class Else
+    def initialize satisfied
+      @satisfied = satisfied
+    end
+    def else 
+      raise unless block_given?
+      yield unless @satisfied
+    end
+  end
+end

data/lib/ruva/expression.rb

@@ -0,0 +1,17 @@
+require 'citrus'
+require 'ostruct'
+require 'ruva/specification'
+require 'ruva/expression/expression_leaf_spec'
+require 'ruva/expression/equal_greater_less'
+require 'ruva/expression/identifier_comparable'
+require 'ruva/expression/is_between'
+require 'ruva/expression/matches'
+
+Citrus.require 'ruva/expression/ruva_expression'
+
+module RuvaExpression
+  def self.parse expression
+    result = super expression
+    result.value  
+  end
+end

data/lib/ruva/expression/equal_greater_less.rb

@@ -0,0 +1,61 @@
+class GreaterSpec < ExpressionLeafSpec
+  def compare (comparable, value) value > comparable end
+  def satisfied_text() "greater than" end
+  def unsatisfied_text() "less than" end
+end
+
+class LessSpec < ExpressionLeafSpec
+  def compare (comparable, value) value < comparable end
+  def satisfied_text() "less than" end
+  def unsatisfied_text() "greater than" end
+end
+
+class GreaterEqualSpec < ExpressionLeafSpec
+  def compare (comparable, value) value >= comparable end
+  def satisfied_text() "greater than or equal to" end
+  def unsatisfied_text() "less than" end
+end
+
+class LessEqualSpec < ExpressionLeafSpec
+  def compare (comparable, value) value <= comparable end
+  def satisfied_text() "less than or equal to" end
+  def unsatisfied_text() "greater than" end
+end
+
+module EqualGreaterLess
+  def value
+    spec = create_spec
+    spec.set_validator { |value, *args| 
+      compare @comparable, value
+    }
+    spec.set_reporting { |satisfied, value, *args|
+      comparable_string = @comparable.to_s
+      create_report_string "is #{satisfied_text} #{comparable_string}", "is #{unsatisfied_text} #{comparable_string}", satisfied, value
+    }
+    spec
+  end
+end
+
+module Greater include EqualGreaterLess
+  def create_spec
+    GreaterSpec.new(identifier.value, comparable.value) 
+  end
+end
+
+module Less include EqualGreaterLess
+  def create_spec
+    LessSpec.new(identifier.value, comparable.value) 
+  end
+end
+
+module GreaterOrEqual include EqualGreaterLess
+  def create_spec
+    GreaterEqualSpec.new(identifier.value, comparable.value) 
+  end
+end
+
+module LessOrEqual include EqualGreaterLess
+  def create_spec
+    LessEqualSpec.new(identifier.value, comparable.value) 
+  end
+end

data/lib/ruva/expression/expression_leaf_spec.rb

@@ -0,0 +1,52 @@
+class ExpressionLeafSpec < LeafSpec
+  def get_value *args
+    if (args.size == 1)
+      obj = args[0]
+      if (obj.is_a? Hash)
+        get_hash_value @name.split(".").reverse, obj
+      else
+        get_object_value @name.split(".").reverse, obj
+      end
+    else
+      raise "Unexpected input"
+    end   
+  end
+  
+  def get_hash_value key_array, hash
+    if (key_array.size > 1)
+      obj = hash[key_array.pop.to_sym]
+      if (obj.is_a?(Hash)) 
+        get_hash_value(key_array, obj)
+      else
+        get_object_value(key_array, obj)
+      end
+    else
+      hash[key_array.pop.to_sym]
+    end
+  end
+  
+  def get_object_value key_array, obj
+    if (key_array.size > 1)
+      obj = obj.send key_array.pop
+      if (obj.is_a?(Hash)) 
+        get_hash_value(key_array, obj)
+      else
+        get_object_value(key_array, obj)
+      end
+    else
+      obj.send key_array.pop
+    end
+  end
+  
+  def create_typed_value value
+    case value
+      when Numeric then value
+      when String then "'#{value}'"
+      else value
+    end
+  end
+  
+  def create_report_string positive, negative, satisfied, value  
+    @name.to_s + " #{create_typed_value value} " + (satisfied ? positive : negative)
+  end
+end

data/lib/ruva/expression/identifier_comparable.rb

@@ -0,0 +1,53 @@
+module Identifier
+  def value
+    to_s.strip
+  end
+end
+
+module Comparable
+  def value
+    to_s
+  end
+end
+
+module LastComparable
+  def value   
+    Array.new << comparable
+  end
+end
+
+module IntComparable
+  def value
+    to_i
+  end
+end
+
+module FloatComparable
+  def value
+    to_f
+  end
+end
+
+module DateComparable
+  def value
+    Date.parse to_s
+  end
+end
+
+module RegexComparable
+  def value
+    Regexp.new regex.value
+  end
+end
+
+module TextComparable
+  def value
+    return to_s.strip
+  end
+end
+
+module Comparables
+  def value
+    subresult.value << comparable
+  end
+end

data/lib/ruva/expression/is_between.rb

@@ -0,0 +1,49 @@
+def create_is_spec identifier, comparable
+  spec = ExpressionLeafSpec.new(identifier.value, comparable.value) 
+  spec.set_validator { |value, *args|
+    @comparable == value
+  }
+  spec.set_reporting { |satisfied, value, *args|
+    comparable_string = @comparable.to_s
+    create_report_string "is #{comparable_string}", "is not #{comparable_string}", satisfied, value
+  }
+  spec
+end
+
+module Is
+  def value
+    create_is_spec identifier, comparable
+  end
+end
+
+module ManyIs
+  def value
+    spec = create_spec
+    comparables.value.reverse.each do |comparable|
+      new_spec = create_is_spec identifier, comparable
+      spec.append(new_spec)
+    end
+    spec
+  end
+end
+
+module OrIs include ManyIs
+  def create_spec
+    OrSpec.new
+  end
+end
+
+module IsBetween
+  def value
+    comparables = [from.value, to.value]
+    spec = ExpressionLeafSpec.new(identifier.value, comparables) 
+    spec.set_validator { |value, *args|
+      value.between? @comparable[0], @comparable[1]      
+    }
+    spec.set_reporting { |satisfied, value, *args|
+      comparable_string = "#{@comparable[0]} and #{@comparable[1]}" 
+      create_report_string "is between #{comparable_string}", "is not between #{comparable_string}", satisfied, value
+    }
+    spec
+  end
+end

data/lib/ruva/expression/matches.rb

@@ -0,0 +1,42 @@
+def create_matches_spec identifier, comparable
+  comparable = comparable.value
+  regex = comparable.is_a?(Regexp) ? comparable : Regexp.new(comparable)
+  spec = ExpressionLeafSpec.new(identifier.value, regex)
+  spec.set_validator { |value, *args|
+    (@comparable =~ value) != nil
+  }
+  spec.set_reporting { |satisfied, value, *args|
+    comparable_string = "/#{@comparable.source}/"
+    create_report_string "matches #{comparable_string}", "does not match #{comparable_string}", satisfied, value
+  }
+  spec
+end
+
+module Matches
+  def value
+    create_matches_spec identifier, comparable
+  end
+end
+
+module ManyMatches
+  def value
+    spec = create_spec
+    comparables.value.reverse.each do |comparable|
+      new_spec = create_matches_spec identifier, comparable
+      spec.append(new_spec)
+    end
+    spec
+  end
+end
+
+module AndMatches include ManyMatches
+  def create_spec
+    AndSpec.new
+  end
+end
+
+module OrMatches include ManyMatches
+  def create_spec
+    OrSpec.new
+  end
+end

data/lib/ruva/expression/ruva_expression.citrus

@@ -0,0 +1,112 @@
+grammar RuvaExpression
+	
+	rule root
+		(identifier matches comparables:(and_comparables)) <AndMatches>
+		|
+		(identifier matches comparables:(or_comparables)) <OrMatches>
+		|
+		(identifier matches comparable) <Matches>
+		|
+		(identifier is between from:(comparable) and to:(comparable)) <IsBetween>
+		|
+		(identifier is greater than or equal to comparable) <GreaterOrEqual>
+		|
+		(identifier is less than or equal to comparable) <LessOrEqual>
+		|
+		(identifier is greater than comparable) <Greater>
+		|
+		(identifier is less than comparable) <Less>
+		|
+		(identifier is comparables:(or_comparables)) <OrIs>
+		|
+		(identifier is comparable) <Is>
+	end
+
+	rule matches
+		'matches' space
+	end
+		
+	rule is
+		'is' space
+	end
+	
+	rule between
+		'between' space
+	end
+	
+	rule greater
+		'greater' space
+	end
+	
+	rule less
+		'less' space
+	end
+		
+	rule than
+		'than' space
+	end
+	
+	rule equal
+		'equal' space
+	end
+	
+	rule to
+		'to' space
+	end
+		
+	rule and
+		'and' space
+	end
+		
+	rule or
+		'or' space
+	end		
+		
+  	rule identifier
+		([a-zA-Z.]+ space) <Identifier>
+	end
+
+	rule comparable
+		(number_comparable | date_comparable | regex_comparable | text_comparable)
+	end
+	
+	rule last_comparable
+		(comparable '') <LastComparable>
+	end
+
+	rule number_comparable
+		(int_comparable | float_comparable)
+	end
+	
+	rule int_comparable
+		([0-9]+ space) <IntComparable>
+	end
+		
+	rule float_comparable
+		([0-9]* '.' [0-9]+ space) <FloatComparable>
+	end
+	
+	rule date_comparable
+		([0-9]2*2 '.' [0-9]2*2 '.' [0-9]4*4 space) <DateComparable>
+	end
+		
+	rule regex_comparable
+		('/' regex:((!'/'!'\\' .) | '\\/' | '\\\\')* '/' space) <RegexComparable>
+	end
+	
+	rule text_comparable
+		([^ ]+ space) <TextComparable>
+	end
+
+	rule and_comparables
+		(comparable and subresult:(and_comparables | last_comparable)) <Comparables>
+	end
+
+	rule or_comparables
+		(comparable or subresult:(or_comparables | last_comparable)) <Comparables>
+	end
+	
+	rule space
+		[ \t]+ | /$/
+	end
+end

data/lib/ruva/specification.rb

@@ -0,0 +1 @@
+require 'ruva/specification/specification'

data/lib/ruva/specification/specification.rb

@@ -0,0 +1,100 @@
+class Spec
+  def initialize
+    @specs = Array.new
+  end
+  
+  def append spec
+    @specs << spec
+    spec
+  end
+  
+  def create_subreport spec, *args
+    if spec.is_a? Spec
+      spec.evaluate *args
+    else
+      result = spec.evaluate *args
+      message = spec.report result, *args
+      SpecReport.new result, message
+    end
+  end
+  
+  def evaluate *args
+    passed = initial_condition
+    report = SpecReport.new false, name
+    @specs.each do |spec|
+      subreport = create_subreport spec, *args
+      report.add_subreport subreport
+      if condition_change? subreport.satisfied
+        passed = !initial_condition
+      end
+    end
+    report.satisfied = passed
+    report
+  end
+end
+
+class AndSpec < Spec
+  def initial_condition() return true end
+  def name() "all" end
+  def condition_change?(satisfied) !satisfied end
+end
+
+class OrSpec < Spec
+  def initial_condition() return false end
+  def name() "any" end
+  def condition_change?(satisfied) satisfied end
+end
+
+class NotSpec < Spec
+  def initial_condition() return true end
+  def name() "none" end
+  def condition_change?(satisfied) satisfied end
+end
+
+class LeafSpec
+  def initialize name, args
+    @name = name
+    @comparable = args
+  end
+  
+  def set_validator &block
+    @validator = block
+  end
+  
+  def set_reporting &block
+    @reporting = block
+  end
+  
+  def evaluate *args
+    instance_exec(get_value(*args), *args, &@validator)
+  end
+  
+  def report satisfied, *args
+    instance_exec(satisfied, get_value(*args), *args, &@reporting)
+  end  
+end
+
+class SpecReport
+  
+  attr_accessor :satisfied, :name, :input
+  
+  def initialize satisfied, message
+    @satisfied = satisfied
+    @message = message
+    @subreports = Array.new
+  end
+  
+  def add_subreport subreport
+    @subreports << subreport
+  end
+  
+  def to_s s = ''
+    met = @satisfied ? "[+] " : "[-] "
+    output = s + met + @message
+    output += "\n"
+    @subreports.each do |subreport|
+      output += subreport.to_s(s + '  ')
+    end
+    output
+  end
+end

data/lib/ruva/version.rb

@@ -0,0 +1,3 @@
+module Ruva
+  VERSION = "1.0.0"
+end

data/ruva.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/ruva/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = "ruva"
+  gem.version       = Ruva::VERSION
+
+  gem.authors       = ["Samuel Mueller"]
+  gem.email         = ["mueller.samu@gmail.com"]
+  gem.description   = %q{Ruva is a simple utility to write conditions in a human readable manner.}
+  gem.summary       = gem.description
+  gem.homepage      = "https://github.com/ssmm/ruva"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  
+  gem.add_dependency "citrus", "~> 2.4.1"
+  gem.add_dependency "indentation-parser"
+  
+  gem.add_development_dependency "rspec", "~> 2.6"
+end

data/spec/conditions/simple_condition.ruva

@@ -0,0 +1,7 @@
+all
+  age is 23
+  name matches samuel
+  profession matches /application engineer/
+  any
+    city matches zurich
+    hobby matches guitar

data/spec/expression_spec.rb

@@ -0,0 +1,85 @@
+require 'ruva/expression'
+require 'helpers/expression_helper'
+
+RSpec.configure do |c|
+  c.include ExpressionHelper
+end
+
+describe Ruva do
+  
+  before :all do 
+    
+  end
+  
+  describe "greater/less/equal expressions" do
+    it "handles numerics" do
+      test_expression "age is 23", {:age => 23}, true
+      test_expression "age is 23", {:age => 24}, false
+      
+      test_expression "age is greater than 23", {:age => 24}, true
+      test_expression "age is greater than 23", {:age => 23}, false
+      
+      test_expression "age is less than 23", {:age => 22}, true
+      test_expression "age is less than 23", {:age => 23}, false
+      
+      test_expression "age is greater than or equal to 23", {:age => 23}, true
+      test_expression "age is greater than or equal to 23", {:age => 22}, false
+      
+      test_expression "age is less than or equal to 23", {:age => 23}, true
+      test_expression "age is less than or equal to 23", {:age => 24}, false
+    end
+    
+    it "handles strings" do
+      test_expression "name is samuel", {:name => "samuel"}, true
+      test_expression "name is samuel", {:name => "melchior"}, false
+      
+      test_expression "name is greater than samuel", {:name => "simon"}, true
+      test_expression "name is greater than samuel", {:name => "samantha"}, false
+      
+      test_expression "name is less than samuel", {:name => "lisa"}, true
+      test_expression "name is less than samuel", {:name => "samuel l jackson"}, false
+      
+      test_expression "name is greater than or equal to samuel", {:name => "samuel"}, true
+      test_expression "name is greater than or equal to samuel", {:name => "samantha"}, false
+      
+      test_expression "name is less than or equal to samuel", {:name => "samuel"}, true
+      test_expression "name is less than or equal to samuel", {:name => "samuel l jackson"}, false
+    end
+    
+    it "handes dates" do
+      #TODO!!
+    end
+  end
+  
+  describe "between expressions" do
+    it "handles numerics" do
+      test_expression "age is between 18 and 28", {:age => 23}, true
+      
+      test_expression "age is between 18 and 28", {:age => 28}, true
+      test_expression "age is between 18 and 28", {:age => 18}, true
+      
+      test_expression "age is between 18 and 28", {:age => 50}, false
+      test_expression "age is between 18 and 28", {:age => 17}, false
+    end
+  end
+  
+  describe "matches expressions" do
+    it "handles strings" do
+      test_expression "name matches sam", {:name => "samuel"}, true
+      test_expression "name matches am", {:name => "samuel"}, true
+      test_expression "name matches uel", {:name => "samuel"}, true
+      
+      test_expression "name matches xyz", {:name => "samuel"}, false
+      
+      test_expression "name matches /^samuel$/", {:name => "samuel"}, true
+      test_expression "name matches /^samuel$/", {:name => "samuel "}, false
+      
+      test_expression "name matches /daniel|jonas/", {:name => "daniel"}, true
+      test_expression "name matches /daniel|jonas/", {:name => "jonas"}, true
+      
+      test_expression 'name matches /regex\/with escaping/', {:name => "regex/with escaping"}, true
+      test_expression "name matches /regex\\/with escaping/", {:name => "regex/with escaping"}, true
+    end
+  end
+  
+end

data/spec/helpers/expression_helper.rb

@@ -0,0 +1,7 @@
+module ExpressionHelper
+  def test_expression expression, input, expected
+    spec = RuvaExpression.parse(expression)
+    result = spec.evaluate input
+    result.should be expected
+  end
+end

data/spec/inline_ruva_spec.rb

@@ -0,0 +1,73 @@
+require 'ruva'
+require 'ostruct'
+
+describe Ruva do
+  describe "the 'if' syntax" do
+    
+    before :all do
+      @person = OpenStruct.new
+      @person.age = 23 
+      @person.city = "zurich"
+      @person.name = "samuel" 
+    end
+    
+    it "handles one liners" do      
+      #person.if "age is 23 or higher" <-- TODO: support this    
+      executed = false    
+      @person.if "age is 23" do 
+        executed = true
+      end
+      executed.should be true
+      
+      executed = false
+      @person.if("age is 23") {
+        executed = true
+      }.else {
+        true.should be false
+      }
+      executed.should be true
+
+      executed = false
+      @person.if("age is 23") do
+        executed = true
+      end.else do
+        true.should be false
+      end
+      executed.should be true
+      
+      executed = true
+      @person.if("age is 24") {
+        true.should be false
+      }.else {
+        executed = false
+      }
+      executed.should be false
+    end
+    
+    it "handles multi line conditions" do 
+      
+      executed = false
+      @person.if "
+        age is 23
+        city is zurich
+        name is samuel
+      " do
+        executed = true
+      end
+      executed.should be true
+      
+      executed = true
+      @person.if("
+        age is 24
+        city is zurich
+        name is samuel
+      ") {
+        true.should be false
+      }.else {
+        executed = false
+      }
+      executed.should be false
+      
+    end
+  end
+end

data/spec/normalize_indentation_spec.rb

@@ -0,0 +1,22 @@
+require 'ruva'
+
+describe Ruva do
+  it "normalizes indentation" do
+    indented_text = "
+      this
+        text
+          is
+            indented
+    "
+    indented_text = Ruva.normalize_indentation indented_text
+    
+    expected =
+"this
+  text
+    is
+      indented
+    "
+    
+    indented_text.should eq expected
+  end
+end

data/spec/ruva_spec.rb

@@ -0,0 +1,20 @@
+require 'ruva'
+require 'ostruct'
+
+describe Ruva do
+  it "reads .ruva files" do
+    
+    spec = Ruva.read "spec/conditions/simple_condition"
+    
+    input = OpenStruct.new
+    input.age = 23
+    input.name = "samuel"
+    input.profession = "application engineer"
+    input.city = "zurich"
+    
+    result = spec.evaluate(input)
+    
+    result.satisfied.should be true
+    #puts result
+  end
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: ruva
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Samuel Mueller
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: citrus
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.4.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.4.1
+- !ruby/object:Gem::Dependency
+  name: indentation-parser
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+description: Ruva is a simple utility to write conditions in a human readable manner.
+email:
+- mueller.samu@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/ruva.rb
+- lib/ruva/expression.rb
+- lib/ruva/expression/equal_greater_less.rb
+- lib/ruva/expression/expression_leaf_spec.rb
+- lib/ruva/expression/identifier_comparable.rb
+- lib/ruva/expression/is_between.rb
+- lib/ruva/expression/matches.rb
+- lib/ruva/expression/ruva_expression.citrus
+- lib/ruva/specification.rb
+- lib/ruva/specification/specification.rb
+- lib/ruva/version.rb
+- ruva.gemspec
+- spec/conditions/simple_condition.ruva
+- spec/expression_spec.rb
+- spec/helpers/expression_helper.rb
+- spec/inline_ruva_spec.rb
+- spec/normalize_indentation_spec.rb
+- spec/ruva_spec.rb
+homepage: https://github.com/ssmm/ruva
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Ruva is a simple utility to write conditions in a human readable manner.
+test_files:
+- spec/conditions/simple_condition.ruva
+- spec/expression_spec.rb
+- spec/helpers/expression_helper.rb
+- spec/inline_ruva_spec.rb
+- spec/normalize_indentation_spec.rb
+- spec/ruva_spec.rb