de 0.0.1

data/lib/de/sunspot_solr/operand.rb

@@ -0,0 +1,273 @@
+#
+# De::SunspotSolr operand classes.
+# This file defines:
+#  - basic De::SunspotSolr::SunspotOperand class
+#  - De::SunspotSolr::IntervalSunspotOperand extending SunspotOperand for case of time intervals
+#  - A number of classes extending mentioned below and giving convenient interface for concrete sunspot query operations:
+#    - EqualTo, Without, GreaterThan, LessThan, Between, AnyOf, GreaterThanOrEqual, LessThanOrEqual
+#    - IntervalFromNowEqualTo, IntervalFromNowWithout, IntervalFromNowGreaterThan, IntervalFromNowLessThan, IntervalFromNowBetween,
+#      IntervalFromNowAnyOf, IntervalFromNowGreaterThanOrEqual, IntervalFromNowLessThanOrEqual
+#
+# De::SunspotSolr module provides engine to build, validate and evaluate dynamic sunspot query to solr
+# based on some model.
+# It is built as extension of De module
+#
+# SunspotSolr expression example:
+#
+# Sunspot.search(Product) do
+#   any_of do
+#     with(:client_id).equal_to(43)
+#     with(:name).equal_to('Name to trace')
+#   end
+#   with(:update_time).greater_then('2011-03-15 15:00:00')
+# end
+#
+
+#require 'active_support/inflector'
+require 'active_support/all'
+
+module De
+  module SunspotSolr
+
+    # Marker module included to all module classes
+    # to be able to check that class is inside module
+    module SP; end
+
+    #
+    # Basic class representing sunspot search expression operand
+    # 
+    # Operand representation in Sunspot query examples:
+    # - with(:client_id).equal_to(43)
+    # - with(:update_time).greater_then('2011-03-15 15:00:00')
+    # 
+    #
+    class SunspotOperand < Operand
+      include De::SunspotSolr::SP
+
+      attr_reader :value, :operand
+
+      #
+      # Constructor for SunspotOperand
+      # Stores name and property as TreeNode's @name and @content correspondingly
+      #
+      # === Input
+      #
+      # name<String|Symbol>:: arbitrary object name
+      # property<String|Symbol>:: property examined by sunspot query
+      #     (for example, :client_id in condition with(:client_id).equal_to(43)
+      #     Stored as TreeNode's @content field
+      # operand<Symbol>:: operand type
+      #     Examples: :equal_to, :without, :greater_than...
+      # value<Object>:: value to compare
+      #     Example: 43 in condition with(:client_id).equal_to(43)
+      #
+      def initialize(name, property, operand, value)
+        super(name.to_s, property.to_s)
+        @value = value
+        @operand = operand
+      end
+
+      #
+      # Validation
+      #
+      # Operand is valid in case
+      #  - its operand is included to valid_operands list
+      #  - it is added to De::SunspotSolr::Search object and property is registered in this root object
+      #    Last one is needed to choose appropriate condition representation according to property type and static/dynamic nature
+      #
+      def valid?
+        return false unless self.class.valid_operands.include?(@operand)
+        return false unless root.is_a?(Search)
+        return false unless root.options[:properties].key?(@content.to_sym)
+        true
+      end
+
+      #
+      # Evaluation
+      #
+      #  Result depends on property type and static/dynamic nature
+      #
+      # === Output
+      #
+      #  <String> - string representation of sunspot condition
+      #
+      def evaluate
+        super
+        if root.options[:properties][@content.to_sym][:dynamic]
+          "dynamic(:#{root.options[:dynamics][root.options[:properties][@content.to_sym][:type]]}) do
+             #{simple_evaluate}
+           end"
+        else
+          simple_evaluate
+        end
+      end
+
+      #
+      # Equal operand override
+      # Checks objects class and coincidence of +operand+, +value+ and +property+ (stored in +content+ filed)
+      #
+      # === Input
+      #
+      # obj<SunspotOperator>:: object to compare with
+      #
+      def ==(obj)
+        obj.is_a?(SunspotOperand) && obj.operand == @operand && obj.content == @content && obj.value == @value
+      end
+
+      #
+      # Define hash function to give the same result for equal @operand, @content and @value
+      # (@name is not important for equal operands)
+      #
+      def hash
+        [@operand, @content, @value].hash
+      end
+
+      class << self
+
+        #
+        # Supported operands list
+        #
+        # === Output
+        #
+        #  <Array> of symbols
+        #
+        def valid_operands
+          [:equal_to, :greater_than, :less_than, :between, :any_of]
+        end
+      end
+
+      protected
+
+      def simple_evaluate
+        "with(:#{@content}).#{@operand}(#{value_to_compare})"
+      end
+
+      def value_to_compare
+        if @value.is_a?(Array)
+          output = "[#{@value.map {|element| atomic_value(element) }.join(',')}]"
+        elsif @value.is_a?(Range)
+          output = @value.exclude_end? ? atomic_value(@value.first)...atomic_value(@value.last) : atomic_value(@value.first)..atomic_value(@value.last)
+        else
+          output = atomic_value(@value)
+        end
+
+        output
+      end
+
+      def atomic_value(val)
+        case root.options[:properties][@content.to_sym][:type]
+        when :text, :string
+          "'#{val.escape_apos}'"
+        when :time
+          "'#{val.to_s(:db)}'"
+        when :float
+          val.to_f
+        else
+          val
+        end
+      end
+    end
+
+    #
+    # Sunspot interval operand class
+    #
+    # It expends SunspotOperand class for properties of type :time
+    # and evaluates their values compared to given by interval from now.
+    # Interval is considered in days
+    #
+    # For example
+    #
+    #   IntervalSunspotOperand.new('op1', :start_date, :less_then, 3)
+    #
+    #   gives condition
+    #
+    #   with(:start_date).less_than(Time.now + 3.days)
+    #
+    class IntervalSunspotOperand < SunspotOperand
+
+      def valid?
+        super && root.options[:properties][@content.to_sym] && root.options[:properties][@content.to_sym][:type] == :time
+      end
+
+      protected
+
+      def value_to_compare
+        now = Time.now
+        if @value.is_a?(Array)
+          shifted_value = "[#{@value.map {|element| atomic_value(now  + element.days)  }.join(',')}]"
+        elsif @value.is_a?(Range)
+          shifted_value = @value.exclude_end? ? 
+                "#{atomic_value(now + @value.first.days)}...#{atomic_value( now + @value.last.days)}" :
+                "#{atomic_value(now + @value.first.days)}..#{atomic_value( now + @value.last.days)}"
+        else
+          shifted_value = atomic_value(now + @value.days)
+        end
+        
+        shifted_value
+      end
+    end
+
+    available_operands = SunspotOperand.valid_operands | [:greater_than_or_equal, :less_than_or_equal, :without]
+    available_operands.each do |operand|
+      module_eval "
+        class #{operand.to_s.camelize} < SunspotOperand
+          def initialize(property, value)
+            super(\"\#\{property\}-\#\{rand(1000)\}\", property, :#{operand}, value)
+          end
+
+          def self.valid_operands
+            [:#{operand}]
+          end
+        end
+
+        class IntervalFromNow#{operand.to_s.camelize} < IntervalSunspotOperand
+          def initialize(property, value)
+            super(\"\#\{property\}-\#\{rand(1000)\}\", property, :#{operand}, value)
+          end
+
+          def self.valid_operands
+            [:#{operand}]
+          end
+        end
+      "
+    end
+
+    [:greater_than_or_equal, :less_than_or_equal].each do |operand|
+      module_eval %{
+        class #{operand.to_s.camelize} < SunspotOperand
+
+          def simple_evaluate
+            "any_of do
+               with(:\#\{@content\}).#{operand.to_s.gsub(/_or_equal/, '')}(\#\{value_to_compare\})
+               with(:\#\{@content\}, \#\{value_to_compare\})
+             end"
+          end
+        end
+
+        class IntervalFromNow#{operand.to_s.camelize} < IntervalSunspotOperand
+
+          def simple_evaluate
+            "any_of do
+               with(:\#\{@content\}).#{operand.to_s.gsub(/_or_equal/, '')}(\#\{value_to_compare\})
+               with(:\#\{@content\}, \#\{value_to_compare\})
+             end"
+          end
+        end
+      }
+    end
+
+    class Without < SunspotOperand
+
+      def simple_evaluate
+        "without(:#{@content}, #{value_to_compare})"
+      end
+    end
+
+    class IntervalFromNowWithout < IntervalSunspotOperand
+      
+      def simple_evaluate
+        "without(:#{@content}, #{value_to_compare})"
+      end
+    end
+  end
+end

data/lib/de/sunspot_solr/operator.rb

@@ -0,0 +1,131 @@
+#
+# De::SunspotSolr operator classes: And and Or
+#
+# De::SunspotSolr module provides engine to build, validate and evaluate dynamic sunspot query to solr
+# based on some model.
+# It is built as extension of De module
+#
+# SunspotSolr expression example:
+#
+# Sunspot.search(Product) do
+#   any_of do
+#     with(:client_id).equal_to(43)
+#     with(:name).equal_to('Name to trace')
+#   end
+#   with(:update_time).greater_then('2011-03-15 00:15:00')
+# end
+#
+
+require 'de/symmetric_operator'
+
+module De
+  module SunspotSolr
+
+    # Marker module included to all module classes
+    # to be able to check that class is inside module
+    module SP; end
+    
+    class SunspotOperator < Operator
+      include De::SunspotSolr::SP
+      include De::SymmetricOperator
+
+      def initialize(operator, operands = nil)
+        @operator = operator
+        super("#{operator}-#{rand(1000)}", operands)
+      end
+
+      def evaluate
+        super
+        "#{@operator} do
+          #{children.map {|child| child.evaluate + "\n" } }
+        end"
+      end
+      
+      #
+      # Adds operator or operand as a child in case equal one doesn't exist already
+      # otherwize old one is returned
+      #
+      # === Input
+      #
+      # obj<SP>:: object to be added as child one
+      #
+      # === Output
+      #
+      # <SP>:: child object
+      #
+      def <<(obj)
+        raise Error::TypeError unless obj.is_a?(SP)
+        children.include?(obj) ? children[children.index(obj)] : super(obj)
+      end
+    end
+
+    #
+    # Class representing AND operator for SunspotSolr expression.
+    # In resulting Sunspot query it is reflected as all_of block
+    #
+    class And < SunspotOperator
+      
+      #
+      # Creates And object.
+      # Name includes word 'all_of' 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("all_of", operands)
+      end
+    end
+
+    class Or < SunspotOperator
+      
+      #
+      # Creates Or object.
+      # Name includes word 'any_of' 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("any_of", operands)
+      end
+    end
+
+    class Not < SunspotOperator
+
+      #
+      # Creates Or object.
+      # Name includes word 'any_of' 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(operand = nil)
+        super("not", operand ? [operand] : nil)
+      end
+
+      #
+      # Adds sunspot operand as a child to not operator
+      #
+      def <<(obj)
+        raise Error::TypeError unless obj.is_a?(De::SunspotSolr::SunspotOperand)
+        raise Error::ArgumentNumerError if has_children?
+        super(obj)
+      end
+
+      def evaluate
+        super
+        first_child.evaluate.gsub(/with\(/, 'without(')
+      end
+    end
+  end
+end

data/lib/de/sunspot_solr/search.rb

@@ -0,0 +1,179 @@
+#
+# De::SunspotSolr::Search class
+#
+# De::SunspotSolr module provides engine to build, validate and evaluate dynamic sunspot query to solr
+# based on some model.
+# It is built as extension of De module
+#
+# SunspotSolr expression example:
+#
+# Sunspot.search(Product) do
+#   any_of do
+#     with(:client_id).equal_to(43)
+#     with(:name).equal_to('Name to trace')
+#   end
+#   with(:update_time).greater_then('15/03/11')
+# end
+#
+
+require 'de/symmetric_operator'
+
+module De
+  module SunspotSolr
+
+    # Marker module included to all module classes 
+    # to be able to check that class is inside module
+    module SP; end
+    
+    #
+    # Search class
+    #
+    # Expression extention representing sunspot search
+    # Its evaluation returns Sunspot Search object
+    # built on its operators and operands tree
+    #
+    class Search < Expression
+      include SP
+      include De::SymmetricOperator
+
+      attr_reader :klass, :options
+
+      #
+      # Constructor
+      # Stores object properties. Adds operands to expression tree
+      #
+      # === Input
+      #
+      # name<String>:: arbitrary object name
+      # klass<String>:: name of model search is built on
+      # options<Hash>:: options specifying model fields properties as they are registered in Solr
+      #     Options are used by operands in order to build proper sunspot condition according to property type and static/dynamic nature
+      #
+      #     Hash has following structure
+      #      {
+      #        :properties => { <property> => {:type => <type>, :dynamic => <dynamic>}, ... },
+      #        :dynamics => { <type> => <dynamic property name>, ... }
+      #      }
+      #
+      #      <type> - type name (symbol)
+      #      <dynamic> - true|false
+      #      <dynamic property name> - dynamic solr field name (symbol)
+      #
+      # operands<Array>:: (optional) array of Operand objects.
+      #    If given they are added as children to current Search object
+      #
+      # === Exmaple
+      #      search = De::SunspotSolr::Search.new('search_product', 'Product', {
+      #          :properties => {
+      #            :client_id => {:type => :integer, :dynamic => false},
+      #            :name => {:type => :string, :dynamic => false},
+      #            :price => {:type => :integer, :dynamic => true}
+      #          },
+      #          :dynamics => {:integer => :int_params, :string => :string_params, :time => :time_params, :text => :string_params}
+      #        })
+      #
+      def initialize(name, klass, options = {}, operands = nil)
+        super(name, nil)
+        @klass = klass
+        @options = options
+
+        unless operands.nil?
+          raise Error::TypeError unless operands.is_a?(Array)
+          operands.each { |operand| self << operand }
+        end
+      end
+
+      #
+      # Adds operator or operand as a child to Search.
+      # Prevents addition of invalid type Object
+      #
+      # === Input
+      #
+      # obj<SunspotSolr::Operator|SunspotSolr::Operand>:: object to be added as child one
+      #
+      # === Output
+      #
+      # <SunspotSolr::Operator|SunspotSolr::Operand>:: child object
+      #
+      def <<(obj)
+        raise Error::TypeError unless (obj.is_a?(SP))
+        children.include?(obj) ? children[children.index(obj)] : super(obj)
+      end
+
+      #
+      # Equal override
+      # Checks objects class, +klass+ property and children equality. Children order is NOT important
+      #
+      # === Input
+      #
+      # obj<SunspotSolr::Search>:: object to compare with
+      #
+      def ==(obj)
+        obj.is_a?(Search) && obj.klass == @klass && ((children | obj.children) - (children & obj.children)).length == 0
+      end
+
+      #
+      # Intersection operator. Reterns new Search object representing intersection of results
+      # given by current and input search results
+      #
+      # === Input
+      #
+      #  obj<Search>:: search to find intersection with
+      #
+      # === Output
+      #
+      #  Search object
+      #
+      def &(obj)
+        Search.new("#{@name}+#{obj.name}", @klass, @options, [self.children, obj.children].flatten)
+      end
+
+      #
+      # Union operator. Reterns new Search object representing unin of results
+      # given by current and input search results
+      #
+      # === Input
+      #
+      #  obj<Search>:: search to find union with
+      #
+      # === Output
+      #
+      #  Search object
+      #
+      def |(obj)
+        expression_content = []
+        expression_content << SunspotSolr::And.new(self.children) if self.has_children?
+        expression_content << SunspotSolr::And.new(obj.children) if obj.has_children?
+
+        Search.new("#{@name}+#{obj.name}", @klass, @options, expression_content.length > 0 ? [SunspotSolr::Or.new(expression_content)] : nil)
+      end
+
+      #
+      # Validator
+      #
+      # Expression tree is valid in case their children are valid if any
+      #
+      def valid?
+        children.inject(true) {|result, el| result && el.valid?}
+      end
+
+      #
+      # Evaluator
+      #
+      # === Output
+      #
+      # Sunspot Search object
+      # built on its current tree operators and operands
+      #
+      def evaluate
+        super
+
+        search_string = "Sunspot.search(#{Kernel.const_get(@klass)}) do
+          #{children.map {|child| child.evaluate + "\n" } }
+        end"
+
+        instance_eval search_string
+      end
+    end
+  end
+end

data/lib/de/sunspot_solr.rb

@@ -0,0 +1,9 @@
+require 'de/sunspot_solr/operand'
+require 'de/sunspot_solr/operator'
+require 'de/sunspot_solr/search'
+
+class String
+  def escape_apos
+    self.gsub(/'/, "\\\\'")
+  end
+end

data/lib/de/symmetric_operator.rb

@@ -0,0 +1,31 @@
+#
+# Symmetric operator module defines properties for operator with unimportant order of children (operands)
+# 
+
+require 'set'
+
+module De
+  module SymmetricOperator
+    
+    #
+    # Equal operator override
+    # Checks objects class and children equality. Operands order is NOT important
+    #
+    # === Input
+    #
+    # obj<Expression>:: object to compare with
+    #
+    def ==(obj)
+      self.class.name == obj.class.name && ((children | obj.children) - (children & obj.children)).length == 0
+    end
+
+    #
+    # Define hash function to get equal results for operators from the same class and with the equal children.
+    # Children order is not important
+    #
+    def hash
+      [self.class.name, Set.new(children.map { |el| el.hash})].hash
+    end
+      
+  end
+end

data/lib/de/version.rb

@@ -0,0 +1,3 @@
+module De
+  VERSION = "0.0.1"
+end

data/lib/de.rb

@@ -0,0 +1,3 @@
+require 'de/version'
+require 'de/de'
+

data/test/de_boolean_and_test.rb

@@ -0,0 +1,51 @@
+require 'test/unit'
+require 'de'
+require 'de/boolean'
+
+class DeBooleanAndTest < Test::Unit::TestCase
+
+  def test_constructor
+    assert_nothing_raised(De::Error::AbstractClassObjectCreationError) { De::Boolean::And.new }
+    assert_nothing_raised(De::Error::AbstractClassObjectCreationError) { De::Boolean::And.new([De::Boolean::Operand.new('some name', true)]) }
+  end
+
+  def test_add
+    and1 = De::Boolean::And.new
+    operand1 = De::Boolean::Operand.new('some name', true)
+
+    and1 << operand1
+    assert_equal(2, and1.size)
+
+    and2 = De::Boolean::And.new
+    and1 << and2
+    assert_equal(3, and1.size)
+  end
+
+  def test_evaluate
+    and1 = De::Boolean::And.new
+    operand_true1 = De::Boolean::Operand.new('some name', true)
+    operand_true2 = De::Boolean::Operand.new('second name', true)
+    operand_false1 = De::Boolean::Operand.new('third name', false)
+    operand_false2 = De::Boolean::Operand.new('fourth name', false)
+
+    and1 << operand_true1
+    and1 << operand_true2
+    assert_equal(true, and1.evaluate)
+
+    and2 = De::Boolean::And.new
+    and2 << operand_true1
+    and2 << operand_false1
+    assert_equal(false, and2.evaluate)
+
+    and3 = De::Boolean::And.new([operand_false1, operand_false2])
+    assert_equal(false, and3.evaluate)
+
+    and1 << and3
+    assert_equal(false, and1.evaluate)
+
+    and4 = De::Boolean::And.new([operand_true1, operand_true2])
+    and1 << and4
+    assert_equal(false, and1.evaluate)
+  end
+
+end