de 0.0.3 → 0.0.4

data/CHANGELOG

@@ -0,0 +1,18 @@
+Change log:
+===========
+
+Version 0.0.2 (August 30, 2011)
+===============================
+Evaluate parametrization possibility is added; parameter page is used for sunspot solr search evaluation
+
+Version 0.0.3 (September 11, 2011)
+==================================
+Date type support added for SunspotSolr::Search
+
+Version 0.0.4 (September 23, 2011)
+==================================
+*) De::Expression#to_s method overriden
+*) De::Expression @name attribute is writable
+*) Bug fix: De::Expression prevents error-prone trials to add child with name already existent in tree
+*) De::SunspotSolr::Search#evaluate support for per_page parameter
+*) De::SunspotSolr::Search#results method added

data/lib/de/boolean/operator.rb

@@ -36,9 +36,9 @@ module De
       # operands<Array>:: (optional) array of Operand objects.
       #    If given they are added as children to current operator
       #
-      def initialize(name, operands = nil)
+      def initialize(name, content, operands = nil)
         raise Error::AbstractClassObjectCreationError if instance_of? BooleanOperator
-        super(name, operands)
+        super(name, content, operands)
       end
 
       #
@@ -67,7 +67,7 @@ module De
       #    If given they are added as children to current operator
       #
       def initialize(operands = nil)
-        super("AND-#{rand(1000)}", operands)
+        super("AND-#{rand(1000)}", 'AND', operands)
       end
 
       def evaluate
@@ -92,7 +92,7 @@ module De
       #    If given they are added as children to current operator
       # 
       def initialize(operands = nil)
-        super("OR-#{rand(1000)}", operands)
+        super("OR-#{rand(1000)}", 'OR', operands)
       end
 
       def evaluate
@@ -117,7 +117,7 @@ module De
       #    If given it is added as child to current operator
       #
       def initialize(operand = nil)
-        super("NOT-#{rand(1000)}", operand ? [operand] : nil)
+        super("NOT-#{rand(1000)}", 'NOT', operand ? [operand] : nil)
       end
 
       def <<(obj)

data/lib/de/de.rb

@@ -27,7 +27,9 @@
 #  - Sunspot Solr search expressions
 #
 
+
 require 'tree'
+require 'active_support/inflector'
 require 'de/error'
 
 module De
@@ -52,7 +54,8 @@ module De
     #
     def <<(obj)
       raise Error::TypeError unless (obj.is_a?(Operator) or obj.is_a?(Operand))
-      super(obj)
+      added = added_obj(obj)
+      super(added)
     end
 
     #
@@ -104,6 +107,65 @@ module De
       @content.hash
     end
     
+    def to_s
+      str = @content.nil? ? '' : @content
+      str +=  '(%s)' % children.map { |child| child.to_s }.join(', ') if children.length > 0
+
+      str
+    end
+
+#    def to_hash
+#      {
+#        :name => @name,
+#        :content => @content,
+#        :class => self.class.name,
+#        :children => children.map { |child| child.to_hash }
+#      }
+#    end
+
+    class << self
+
+#      def load(hash)
+#        raise Error::InvalidExpressionError if (hash.keys - [:name, :content, :class, :children]).length > 0
+#
+#        klass = hash[:class].constantize
+#        params = case klass.method(:new).arity
+#        when -1,0 then []
+#        when -2,1 then [hash[:name]]
+#        else [hash[:name], hash[:content]]
+#        end
+#
+#        obj = klass.send(:new, *params)
+#        hash[:children].each { |child| obj << load(child) }
+#      end
+    end
+
+    private
+
+    #
+    # Object to be added to current one
+    #
+    # Checks and prevents trial to add element with name already existent in objects children
+    #
+    # === Input
+    #
+    #  obj <Operator|Operand>:: potential child object
+    #
+    #  === Output
+    #
+    #  <Operator|Operand>
+    #
+    def added_obj(obj)
+      dup_obj = obj
+      counter = 0
+      while @children_hash.key?(dup_obj.name) && counter < 5
+        dup_obj.name = "#{dup_obj.name}_#{rand(1000000)}"
+        counter += 1
+      end
+
+      dup_obj
+    end
+    
   end
 
   #
@@ -126,9 +188,9 @@ module De
     # operands<Array>:: (optional) array of Operand objects.
     #    If given they are added as children to current operator
     #
-    def initialize(name, operands = nil)
+    def initialize(name, content, operands = nil)
       raise Error::AbstractClassObjectCreationError if instance_of? Operator
-      super(name)
+      super(name, content)
 
       unless operands.nil?
         raise Error::TypeError unless operands.is_a?(Array)
@@ -165,7 +227,7 @@ module De
     # 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
+      [self.class.name, children.map { |el| el.hash }].hash
     end
   end
 
@@ -210,3 +272,8 @@ module De
 
 end
 
+module Tree
+  class TreeNode
+    attr_accessor :name
+  end
+end

data/lib/de/sunspot_solr/operator.rb

@@ -31,13 +31,13 @@ module De
 
       def initialize(operator, operands = nil)
         @operator = operator
-        super("#{operator}-#{rand(1000)}", operands)
+        super("#{operator}-#{rand(1000)}", operator, operands)
       end
 
       def evaluate
         super
         "#{@operator} do
-          #{children.map {|child| child.evaluate + "\n" } }
+          #{children.map { |child| child.evaluate + "\n" } }
         end"
       end
       

data/lib/de/sunspot_solr/search.rb

@@ -161,11 +161,13 @@ module De
       #
       # Evaluator
       #
+      # === Input
+      # 
       # params<Hash>:: optional parameters hash
       #   Supported hash keys:
-      #     :page - gives page for paging.
-      #       Number of results per page is defined by @option[:per_page] parameter
-      #       Default values: page - 1, per_page - 10000
+      #     :page - gives page for paging (default - 1)
+      #     :per_page - gives number of results per page for paging
+      #       If not given Number of results per page is defined by @option[:per_page] parameter (default - 10000)
       #
       # === Output
       #
@@ -176,7 +178,7 @@ module De
         super
 
         page = params && params[:page] ? params[:page] : 1
-        per_page = @options[:per_page] || 10000
+        per_page = params && params[:per_page] ? params[:per_page] : @options[:per_page] || 10000
 
         search_string = "Sunspot.search(#{Kernel.const_get(@klass)}) do
           #{children.map {|child| child.evaluate + "\n" } }
@@ -186,6 +188,22 @@ module De
 
         instance_eval search_string
       end
+
+      #
+      # Evaluates expression and returns results of obtained sunspot request
+      #
+      # === Input
+      #
+      # params<Hash>:: optional parameters hash passed to evaluate method
+      #
+      # === Output
+      #
+      #  <mixed> - object of class @klass Sunspot search is built on
+      #
+      def results(params = nil)
+        evaluate(params).results
+      end
+      
     end
   end
 end

data/lib/de/version.rb

@@ -1,3 +1,3 @@
 module De
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/test/de_boolean_operator_test.rb

@@ -9,13 +9,45 @@ class DeBooleanOperatorTest < Test::Unit::TestCase
   class NotSuitableOperand < De::Operand; end
 
   def test_constructor
-    assert_raise(De::Error::AbstractClassObjectCreationError) { De::Boolean::BooleanOperator.new('first') }
-    assert_nothing_raised(De::Error::AbstractClassObjectCreationError) { SomeOperator.new('some name') }
+    assert_raise(De::Error::AbstractClassObjectCreationError) { De::Boolean::BooleanOperator.new('first', 'some operator') }
+    assert_nothing_raised(De::Error::AbstractClassObjectCreationError) { SomeOperator.new('some name', 'some operator') }
+  end
+
+#  def test_to_hash
+#    and1 = De::Boolean::And.new
+#    operand1 = De::Boolean::Operand.new('some name', true)
+#
+#    and1 << operand1
+#    assert_equal({
+#        :class => "De::Boolean::And",
+#        :children => [{:class=>"De::Boolean::Operand", :children=>[], :name=>"some name", :content=>true}],
+#        :name => and1.name,
+#        :content => "AND"},
+#      and1.to_hash)
+#  end
+
+#  def test_load
+#    and1 = De::Boolean::And.new
+#    operand1 = De::Boolean::Operand.new('some name', true)
+#
+#    and1 << operand1
+#    hsh = and1.to_hash
+#    assert_equal(and1, De::Expression.load(hsh))
+#
+#
+#  end
+
+  def test_to_s
+    and1 = De::Boolean::And.new
+    operand1 = De::Boolean::Operand.new('some name', true)
+
+    and1 << operand1
+    assert_equal('AND(true)', and1.to_s)
   end
 
   def test_add
-    operator = SomeOperator.new('first')
-    operator2 = SomeOperator.new('second')
+    operator = SomeOperator.new('first', 'some operator')
+    operator2 = SomeOperator.new('second', 'some operator')
     operand = De::Boolean::Operand.new('third', true)
     not_suitable_operand = NotSuitableOperand.new('four', true)
 

data/test/de_expression_test.rb

@@ -1,5 +1,5 @@
 require 'test/unit'
-require 'de'
+require File.expand_path('../lib/de.rb', File.dirname(__FILE__))
 
 class DeExpressionTest < Test::Unit::TestCase
   class SomeOperator < De::Operator; end
@@ -15,7 +15,7 @@ class DeExpressionTest < Test::Unit::TestCase
   end
 
   def test_add
-    operator = SomeOperator.new('some operator')
+    operator = SomeOperator.new('some operator', 'some operator')
     assert_nothing_raised(De::Error::TypeError) { @expression << operator }
     assert_equal(@expression.children[0], operator)
 
@@ -26,10 +26,29 @@ class DeExpressionTest < Test::Unit::TestCase
     obj = Object.new
     assert_raise(De::Error::TypeError, "Cannot add object to expression") { @expression << obj }
     assert_equal(3, @expression.size)
+
+    old_name = operand.name
+    @expression << operand
+    assert_equal(4, @expression.size)
+    assert_instance_of(SomeOperand, @expression.children[2])
+    assert_equal(operand.name, @expression.children[2].name)
+    assert(old_name != @expression.children[2].name)
   end
 
   def test_valid?
     assert_raise(De::Error::MethodShouldBeOverridenByExtendingClassError, "Cannot add object to expression") { @expression.valid? }
   end
   
+  def test_to_s
+    assert_equal('some content', @expression.to_s)
+
+    operand = SomeOperand.new('some operand', 'operand content')
+    @expression << operand
+
+    assert_equal('some content(operand content)', @expression.to_s)
+
+    operand = SomeOperand.new('some operand 2', 'operand content 2')
+    @expression << operand
+    assert_equal('some content(operand content, operand content 2)', @expression.to_s)
+  end
 end

data/test/de_operator_test.rb

@@ -16,24 +16,24 @@ class DeOperatorTest < Test::Unit::TestCase
   end
 
   def test_constructor
-    assert_raise(De::Error::AbstractClassObjectCreationError, "Cannot create operator object") { De::Operator.new('some name') }
+    assert_raise(De::Error::AbstractClassObjectCreationError, "Cannot create operator object") { De::Operator.new('some name', 'some content') }
 
     assert_nothing_raised(De::Error::AbstractClassObjectCreationError) {
-      operator =  SomeOperator.new('some name')
+      operator =  SomeOperator.new('some name',  'some operator')
       assert_equal('some name', operator.name)
-      assert_equal(1, operator.size, 'No children noDes should be adDed')
+      assert_equal(1, operator.size, 'No children noDes should be added')
 
-      operator2 = SomeOperator.new('another name', [operator])
+      operator2 = SomeOperator.new('another name', 'some operator', [operator])
       assert_equal(2, operator2.size, 'First operator should be adDed as child to second one')
-      assert_equal(operator, operator2.children[0], 'First operator should be adDed as child to second one')
+      assert_equal(operator, operator2.children[0], 'First operator should be added as child to second one')
     }
 
-    assert_raise(De::Error::TypeError, "Cannot create operator object") { SomeOperator.new('some name', 10) }
+    assert_raise(De::Error::TypeError, "Cannot create operator object") { SomeOperator.new('some name', 'some operator', 10) }
   end
 
   def test_valid?
 
-    operator =  SomeOperator.new('some name')
+    operator =  SomeOperator.new('some name', 'some operator')
     assert_equal(false, operator.valid?)
 
     operand = SomeValidOperand.new('another name', 5)

data/test/test.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+
+dir = File.expand_path(File.dirname(__FILE__))
+Dir.glob("#{dir}/*.rb").each do |file|
+  require file unless file =~ /\/test\.rb$/
+end
+

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: de
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: 
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - Olga Gorun
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-12 00:00:00 +03:00
+date: 2011-09-23 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -78,6 +78,7 @@ extra_rdoc_files: []
 files: 
 - .gitignore
 - .rvmrc
+- CHANGELOG
 - Gemfile
 - README
 - Rakefile
@@ -107,6 +108,7 @@ files:
 - test/de_sunspot_solr_or_test.rb
 - test/de_sunspot_solr_search_test.rb
 - test/de_sunspot_solr_sunspot_operand_test.rb
+- test/test.rb
 has_rdoc: true
 homepage: ""
 licenses: []