de 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+nbproject*

data/.rvmrc

@@ -0,0 +1 @@
+rvm 1.8.7@de

data/Gemfile

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

data/README

@@ -0,0 +1,28 @@
+
+De (Dynamic Expression) module provides means to build and evaluate
+dynamic expression of arbitrary complecity and operands/operators nature.
+
+Expression is considered as tree consisted of operands and operators.
+Operater must have child nodes. Operand is terminal node.
+
+Tree example:
+   (a + b) * c + d
+
+   - +
+   --- *
+   ----- +
+   ------- a
+   ------- b
+   --- d
+
+   Here "+" and "*" are operators,
+   "a", "b" and "d" are operands
+
+Expression tree structure is built with the help of <rubytree> gem
+(https://rubygems.org/gems/rubytree)
+
+In addition to basic classes of Expression, Operand and Operator
+module provides some extensions for different nature expressions:
+  - Boolean expressions
+  - Sunspot Solr search expressions
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/de.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "de/version"
+
+Gem::Specification.new do |s|
+  s.name        = "de"
+  s.version     = De::VERSION
+  s.authors     = ["Olga Gorun"]
+  s.email       = ["ogorun@quicklizard.com"]
+  s.homepage    = ""
+  s.summary     = %q{Dynamic Expression}
+  s.description = %q{De (Dynamic Expression) module provides means to build and evaluate
+dynamic expression of arbitrary complecity and operands/operators nature}
+
+  s.rubyforge_project = "de"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'rubytree', '~> 0.8.1'
+  s.add_dependency 'activesupport', '~> 2.3.10'
+  s.add_development_dependency 'rack-test'
+end
+

data/lib/de/boolean/operand.rb

@@ -0,0 +1,46 @@
+#
+# De::Boolean::Operand class
+#
+# De::Boolean module provides means for dynamic logical expression building/validation/evaluation
+# It is built as extension of De module
+#
+# Boolean expression example:
+#
+# true AND (false OR true)
+#
+
+module De
+  module Boolean
+
+    # Marker module included to all module classes
+    # to be able to check that class is inside module
+    module Bn; end
+    
+    #
+    # Class representing Boolean operand
+    #
+    class Operand < De::Operand
+      include Bn
+
+      #
+      # Checks content is boolean value
+      #
+      # === Output
+      #
+      # true|false
+      #
+      def valid?
+        content.is_a?(TrueClass) || content.is_a?(FalseClass)
+      end
+
+      #
+      # Returns value stored in content field if it is valid
+      # or raises exception
+      #
+      def evaluate
+        super
+        content
+      end
+    end
+  end
+end

data/lib/de/boolean/operator.rb

@@ -0,0 +1,134 @@
+#
+# De::Boolean::Operator class
+#
+# De::Boolean module provides means for dynamic logical expression building/validation/evaluation
+# It is built as extension of De module
+#
+# Boolean expression example:
+#
+# true AND (false OR true)
+#
+#
+
+require 'de/symmetric_operator'
+
+module De
+  module Boolean
+
+    # Marker module included to all module classes
+    # to be able to check that class is inside module
+    module Bn; end
+
+    #
+    # Class representing Boolean operator
+    # Base abstract class for concrete operators AND, OR, NOT
+    #
+    class BooleanOperator < Operator
+      include Bn
+      include De::SymmetricOperator
+
+      #
+      # Constructor. Prevents direct BooleanOperator class objects creation
+      #
+      # === Input
+      #
+      # name<String>
+      # operands<Array>:: (optional) array of Operand objects.
+      #    If given they are added as children to current operator
+      #
+      def initialize(name, operands = nil)
+        raise Error::AbstractClassObjectCreationError if instance_of? BooleanOperator
+        super(name, operands)
+      end
+
+      #
+      # Adds boolean operator or operand as a child to boolean operator
+      #
+      def <<(obj)
+        raise Error::TypeError unless obj.is_a?(De::Boolean::Bn)
+        super(obj)
+      end
+      
+    end
+
+    #
+    # Class representing boolean AND operator
+    #
+    class And < BooleanOperator
+
+      #
+      # Creates And object.
+      # Name includes word 'AND' with random number to avoid TreeNode problem
+      # when trying to add children with the same name to a node
+      #
+      # === Input
+      #
+      # operands<Array>:: (optional) array of Operand objects.
+      #    If given they are added as children to current operator
+      #
+      def initialize(operands = nil)
+        super("AND-#{rand(1000)}", operands)
+      end
+
+      def evaluate
+        super
+        children.inject(true) {|result, el| result && el.evaluate}
+      end
+    end
+
+    #
+    # Class representing boolean OR operator
+    #
+    class Or < BooleanOperator
+
+      #
+      # Creates Or object.
+      # Name includes word 'AND' with random number to avoid TreeNode problem
+      # when trying to add children with the same name to a node
+      #
+      # === Input
+      #
+      # operands<Array>:: (optional) array of Operand objects.
+      #    If given they are added as children to current operator
+      # 
+      def initialize(operands = nil)
+        super("OR-#{rand(1000)}", operands)
+      end
+
+      def evaluate
+        super
+        children.inject(false) {|result, el| result || el.evaluate}
+      end
+    end
+
+    #
+    # Class representing boolean NOT operator
+    #
+    class Not < BooleanOperator
+
+      #
+      # Creates Not object.
+      # Name includes word 'AND' with random number to avoid TreeNode problem
+      # when trying to add children with the same name to a node
+      #
+      # === Input
+      #
+      # operand<De::Boolean::Operand>:: (optional) Operand object.
+      #    If given it is added as child to current operator
+      #
+      def initialize(operand = nil)
+        super("NOT-#{rand(1000)}", operand ? [operand] : nil)
+      end
+
+      def <<(obj)
+        raise Error::ArgumentNumerError if has_children?
+        super(obj)
+      end
+
+      def evaluate
+        super
+        !first_child.evaluate
+      end
+    end
+  end
+end

data/lib/de/boolean.rb

@@ -0,0 +1,2 @@
+require 'de/boolean/operand'
+require 'de/boolean/operator'

data/lib/de/de.rb

@@ -0,0 +1,210 @@
+#
+# De (Dynamic Expression) module provides means to build and evaluate
+# dynamic expression of arbitrary complecity and operands/operators nature.
+#
+# Expression is considered as tree consisted of operands and operators.
+# Operater must have child nodes. Operand is terminal node.
+#
+# Tree example:
+#   (a + b) * c + d
+#
+#   - +
+#   --- *
+#   ----- +
+#   ------- a
+#   ------- b
+#   --- d
+#
+#   Here "+" and "*" are operators,
+#   "a", "b" and "d" are operands
+#
+# Expression tree structure is built with the help of <rubytree> gem
+# (https://rubygems.org/gems/rubytree)
+#
+# In addition to basic classes of Expression, Operand and Operator
+# module provides some extensions for different nature expressions:
+#  - Boolean expressions
+#  - Sunspot Solr search expressions
+#
+
+require 'tree'
+require 'de/error'
+
+module De
+
+  #
+  # Base class of De module
+  # Represents tree of dynamic expression consisted of operators and operands
+  # Provides means for expression tree building, validation and evaluation
+  #
+  class Expression < Tree::TreeNode
+
+    #
+    # Adds operator or operand as a child to Expression
+    #
+    # === Input
+    #
+    # obj<Operator|Operand>:: object to be added as child one
+    #
+    # === Output
+    #
+    # <Operator|Operand>:: child object
+    #
+    def <<(obj)
+      raise Error::TypeError unless (obj.is_a?(Operator) or obj.is_a?(Operand))
+      super(obj)
+    end
+
+    #
+    # Checks expression validity
+    # Must be overriden by extending class
+    #
+    # === Input
+    #
+    # no input
+    #
+    # === Output
+    #
+    # true|false
+    #
+    def valid?
+      raise Error::MethodShouldBeOverridenByExtendingClassError
+    end
+
+    #
+    # Evaluates expression in case it is valid
+    # otherwise raises exception
+    # If expression valid returns true
+    # Must be overriden in extending class to do some usefull evaluation
+    #
+    # === Input
+    #
+    # no input
+    #
+    # === Output
+    #
+    #  true
+    #
+    def evaluate
+      raise Error::InvalidExpressionError unless valid?
+      true
+    end
+
+    #
+    # Override eql? and hash for consistent behaviour in hashes and arrays
+    #
+
+    def eql?(obj)
+      self == obj
+    end
+
+    def hash
+      @content.hash
+    end
+    
+  end
+
+  #
+  # Class representing operator concept -
+  # kind of expression that has children
+  # 
+  # Class can be considered abstract.
+  # Its object creation is prevented by constructor.
+  # Extending classes must be implemented
+  # in order to work with this concept
+  #
+  class Operator < Expression
+
+    #
+    # Constructor. Prevents this class objects direct creation
+    #
+    # === Input
+    #
+    # name<String>
+    # operands<Array>:: (optional) array of Operand objects.
+    #    If given they are added as children to current operator
+    #
+    def initialize(name, operands = nil)
+      raise Error::AbstractClassObjectCreationError if instance_of? Operator
+      super(name)
+
+      unless operands.nil?
+        raise Error::TypeError unless operands.is_a?(Array)
+        operands.each { |operand| self << operand }
+      end
+    end
+
+    #
+    # Checks expression validity
+    # Operator is valid if it has children and every one from them is valid
+    #
+    # === Input
+    #
+    # no input
+    #
+    # === Output
+    #
+    # true|false
+    #
+    def valid?
+      has_children? and children.inject(true) { |result, el| result and el.valid? }
+    end
+
+    #
+    # Equal operator override
+    # This basic implementation checks objects class, children number equality
+    # and children equality. Operands order is important
+    #
+    def ==(obj)
+      self.class.name == obj.class.name && children == obj.children
+    end
+
+    #
+    # Define hash function to get equal results for operators from the same class and with the equal children
+    #
+    def hash
+      [self.class.name, children.map { |el| el.hash}].hash
+    end
+  end
+
+  #
+  # Class representing operand concept -
+  # kind of expression without children.
+  #
+  # Class can be considered abstract.
+  # Its object creation is prevented by constructor.
+  # Extending classes must be implemented
+  # in order to work with this concept
+  #
+  class Operand < Expression
+    #
+    # Constructor. Prevents this class objects direct creation
+    #
+    # === Input
+    #
+    # name<String>
+    # content<Object>:: arbitrary content. Its interpritation is done by extending classes
+    #
+    def initialize(name, content)
+      raise Error::AbstractClassObjectCreationError if instance_of? Operand
+      super(name, content)
+    end
+
+    #
+    # Adding children to operand is prevented (raises exception)
+    #
+    def <<(obj)
+      raise Error::TypeError
+    end
+
+    #
+    # Evaluator must be overriden by extending classes (raises exception)
+    #
+    def evaluate
+      raise Error::MethodShouldBeOverridenByExtendingClassError if instance_of? Operand
+      super
+    end
+  end
+
+end
+

data/lib/de/error.rb

@@ -0,0 +1,6 @@
+module De
+  module Error
+    exceptions = %w[TypeError ArgumentNumerError InvalidExpressionError AbstractClassObjectCreationError MethodShouldBeOverridenByExtendingClassError]
+    exceptions.each { |e| const_set(e, Class.new(StandardError)) }  
+  end
+end