torquebox-cache 2.0.3-java → 2.1.0-java

data/lib/datamapper/search.rb

@@ -1,146 +0,0 @@
-# Copyright 2008-2012 Red Hat, Inc, and individual contributors.
-# 
-# This is free software; you can redistribute it and/or modify it
-# under the terms of the GNU Lesser General Public License as
-# published by the Free Software Foundation; either version 2.1 of
-# the License, or (at your option) any later version.
-# 
-# This software is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-# 
-# You should have received a copy of the GNU Lesser General Public
-# License along with this software; if not, write to the Free
-# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
-# 02110-1301 USA, or see the FSF site: http://www.fsf.org.
-
-module Infinispan
-
-  class Search
-
-    def initialize(cache, deserializer)
-      @cache          = cache
-      @deserializer   = deserializer
-      begin
-        @search_manager = cache.search_manager
-      rescue Exception => e
-        cache.log( "Infinispan SearchManager not available for cache: #{cache.name}", 'ERROR' )
-        cache.log( e.message, 'ERROR' )
-      end
-    end
-
-    def search( query )
-      if @search_manager
-        cache_query = search_manager.get_query( build_query( query ), query.model.java_class )
-        cache_query.list.collect { |record| deserialize(record) }
-      else
-        cache.all.select do |r| 
-          record = deserialize(r) 
-          record.class == query.model
-        end
-      end
-    end
-
-    def search_manager
-      @search_manager
-    end
-
-    private
-    def build_query( query )
-      builder = search_manager.build_query_builder_for_class( query.model.java_class ).get
-      query = query.conditions.nil? ? builder.all.create_query : handle_condition( builder, query.conditions.first ) 
-      #puts "LUCENE QUERY: #{query.to_s}"
-      query
-    end
-
-    def handle_condition( builder, condition )
-      #puts "CONDITION: #{condition.inspect} <<<>>> #{condition}"
-      #puts "CONDITION CLASS: #{condition.class}"
-      #puts "CONDITION OPERANDS: #{condition.operands.inspect}" if condition.respond_to? :operands
-      #puts "CONDITION VALUE: #{condition.value}"
-      #puts "CONDITION SUBJECT: #{condition.subject.inspect}"
-      if condition.class == DataMapper::Query::Conditions::OrOperation
-        terms = condition.operands.each do |op|
-          builder.bool.should( handle_condition( builder, op ) )
-        end
-        builder.all.create_query
-      elsif condition.class == DataMapper::Query::Conditions::NotOperation
-        handle_not_operation( builder, condition )
-      elsif condition.class == DataMapper::Query::Conditions::EqualToComparison
-        handle_equal_to( builder, condition ) 
-      elsif condition.class == DataMapper::Query::Conditions::InclusionComparison
-        handle_inclusion( builder, condition )
-      elsif condition.class == DataMapper::Query::Conditions::RegexpComparison
-        handle_regex( builder, condition )
-      else
-        builder.all.create_query
-      end
-    end
-
-    def handle_regex( builder, condition )
-      field = condition.subject.name
-      # TODO Figure out how hibernate search/lucene deal with regexp
-      value = condition.value.nil? ? "?*" : "*" + condition.value.source.gsub('/','') + "*"
-      builder.keyword.wildcard.on_field(field).matching(value).create_query
-    end
-
-    def handle_inclusion( builder, condition )
-      #puts "RANGE: #{condition.value.class} #{condition.value}"
-      if condition.value.is_a? Range
-        # TODO: Deal with Time
-        if ((condition.subject.class == DataMapper::Property::DateTime) || 
-           (condition.subject.class == DataMapper::Property::Date))
-          rng = builder.range.on_field(condition.subject.name).from(convert_date(condition.value.begin)).to(convert_date(condition.value.end))
-        else
-          rng = builder.range.on_field(condition.subject.name).from(condition.value.begin).to(condition.value.end)
-        end
-        condition.value.exclude_end? ? rng.exclude_limit.create_query : rng.create_query 
-      else # an Array
-        match = condition.value.collect { |v| v }.join(' ')
-        if match.empty?
-          # we should find nothing
-          builder.bool.must( builder.all.create_query ).not.create_query
-        else
-          builder.keyword.on_field( condition.subject.name ).matching( match ).create_query 
-        end
-      end
-    end
-
-    def convert_date(date)
-      java.util.Date.new(Time.mktime(date.year, date.month, date.day, date.hour, date.min, date.sec, 0).to_i*1000) if date
-    end
-
-    def handle_equal_to( builder, condition )
-      field = condition.subject.name
-      value = condition.value.nil? ? "?*" : condition.value.to_s
-      if !value.nil? && (value.include?( '?' ) || value.include?( '*' ))
-        builder.keyword.wildcard.on_field(field).matching(value).create_query
-      else
-        builder.keyword.on_field(field).matching(value).create_query
-      end
-    end
-
-    def handle_not_operation( builder, operation )
-      condition = operation.operands.first
-      if (condition.class == DataMapper::Query::Conditions::EqualToComparison && condition.value.nil?) 
-        # not nil means everything
-        everything = DataMapper::Query::Conditions::EqualToComparison.new( condition.subject, '*' )
-        handle_condition( builder, everything )
-      else
-        builder.bool.must( handle_condition( builder, condition ) ).not.create_query
-      end
-    end
-
-    def cache
-      @cache
-    end
-
-    def deserialize(value)
-      @deserializer.call(value)
-    end
-
-  end
-end
-
-

data/spec/dm-infinispan-adapter_spec.rb

@@ -1,375 +0,0 @@
-#
-# Copyright 2011 Red Hat, Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require File.dirname(__FILE__) + '/spec_helper'
-require 'dm-core'
-require 'datamapper/model'
-
-describe DataMapper::Adapters::InfinispanAdapter do
-
-  before :all do
-    @adapter = DataMapper.setup(:default, :adapter => 'infinispan')
-    @heffalump_index = File.join( File.dirname(__FILE__), '..', 'rubyobj.Heffalump' )
-    class ::Heffalump
-      include DataMapper::Resource
-
-      property :id,        Serial
-      property :color,     String
-      property :num_spots, Integer
-      property :striped,   Boolean
-    end
-
-    DataMapper.finalize
-    Heffalump.auto_migrate!
-  end
-
-  it "should use the infinispan search manager" do
-    @adapter.search_manager.should_not be_nil
-  end
-
-  after :all do
-    @adapter.stop
-    FileUtils.rm_rf @heffalump_index
-  end
-
-  describe '#auto_migrate!' do
-    it 'should clear the cache' do
-      Heffalump.create(:color => 'magenta')
-      Heffalump.all.size.should == 1
-      Heffalump.auto_migrate!
-      Heffalump.all.size.should == 0
-    end
-  end
-  
-  describe '#auto_upgrade!' do
-    it 'should not clear the cache' do
-      Heffalump.create(:color => 'magenta')
-      Heffalump.all.size.should == 1
-      Heffalump.auto_upgrade!
-      Heffalump.all.size.should == 1
-    end
-  end
-  
-  describe '#create' do
-    it 'should not raise any errors' do
-      lambda {
-        Heffalump.create(:color => 'peach')
-      }.should_not raise_error
-    end
-
-    it 'should set the identity field for the resource' do
-      heffalump = Heffalump.new(:color => 'peach')
-      heffalump.id.should be_nil
-      heffalump.save
-      heffalump.id.should_not be_nil
-    end
-  end
-
-  describe '#read' do
-    before :all do
-      @heffalump = Heffalump.create(:color => 'brownish hue')
-    end
-
-    it 'should not raise any errors' do
-      lambda {
-        Heffalump.all()
-      }.should_not raise_error
-    end
-
-    it 'should return stuff' do
-      Heffalump.all.should be_include(@heffalump)
-    end
-  end
-
-  describe '#update' do
-    before do
-      @heffalump = Heffalump.create(:color => 'indigo')
-    end
-
-    it 'should not raise any errors' do
-      lambda {
-        @heffalump.color = 'violet'
-        @heffalump.save
-      }.should_not raise_error
-    end
-
-    it 'should not alter the identity field' do
-      id = @heffalump.id
-      @heffalump.color = 'violet'
-      @heffalump.save
-      @heffalump.id.should == id
-    end
-
-    it 'should update altered fields' do
-      @heffalump.color = 'violet'
-      @heffalump.save
-      Heffalump.get(*@heffalump.key).color.should == 'violet'
-    end
-
-    it 'should not alter other fields' do
-      color = @heffalump.color
-      @heffalump.num_spots = 3
-      @heffalump.save
-      Heffalump.get(*@heffalump.key).color.should == color
-    end
-  end
-
-  describe '#delete' do
-    before do
-      @heffalump = Heffalump.create(:color => 'forest green')
-    end
-
-    it 'should not raise any errors' do
-      lambda {
-        @heffalump.destroy
-      }.should_not raise_error
-    end
-
-    it 'should delete the requested resource' do
-      id = @heffalump.id
-      @heffalump.destroy
-      Heffalump.get(id).should be_nil
-    end
-  end
-
-  describe 'query matching' do
-    before :all do
-      Heffalump.auto_migrate!
-      @red  = Heffalump.create(:color => 'red')
-      @two  = Heffalump.create(:num_spots => 2)
-      @five = Heffalump.create(:num_spots => 5)
-    end
-
-    describe 'conditions' do
-      describe 'eql' do
-        it 'should be able to search for objects included in an inclusive range of values' do
-          Heffalump.all(:num_spots => 1..5).should be_include(@five)
-        end
-
-        it 'should be able to search for objects included in an exclusive range of values' do
-          Heffalump.all(:num_spots => 1...6).should be_include(@five)
-        end
-
-        it 'should not be able to search for values not included in an inclusive range of values' do
-          Heffalump.all(:num_spots => 1..4).should_not be_include(@five)
-        end
-
-        it 'should not be able to search for values not included in an exclusive range of values' do
-          Heffalump.all(:num_spots => 1...5).should_not be_include(@five)
-        end
-      end
-
-      describe 'not' do
-        it 'should be able to search for objects with not equal value' do
-          Heffalump.all(:color.not => 'red').should_not be_include(@red)
-        end
-
-        it 'should include objects that are not like the value' do
-          Heffalump.all(:color.not => 'black').should be_include(@red)
-        end
-
-        it 'should be able to search for objects with not nil value' do
-          Heffalump.all(:color.not => nil).should be_include(@red)
-        end
-
-        it 'should not include objects with a nil value' do
-          Heffalump.all(:color.not => nil).should_not be_include(@two)
-        end
-
-        it 'should be able to search for object with a nil value using required properties' do
-          Heffalump.all(:id.not => nil).should == [ @red, @two, @five ]
-        end
-
-        it 'should be able to search for objects not in an empty list (match all)' do
-          Heffalump.all(:color.not => []).should == [ @red, @two, @five ]
-        end
-
-        it 'should be able to search for objects in an empty list and another OR condition (match none on the empty list)' do
-          Heffalump.all(
-            :conditions => DataMapper::Query::Conditions::Operation.new(
-              :or,
-              DataMapper::Query::Conditions::Comparison.new(:in, Heffalump.properties[:color], []),
-              DataMapper::Query::Conditions::Comparison.new(:in, Heffalump.properties[:num_spots], [5])
-            )
-          ).should == [ @five ]
-        end
-
-        it 'should be able to search for objects not included in an array of values' do
-          Heffalump.all(:num_spots.not => [ 1, 3, 5, 7 ]).should be_include(@two)
-        end
-
-        it 'should be able to search for objects not included in an array of values' do
-          Heffalump.all(:num_spots.not => [ 1, 3, 5, 7 ]).should_not be_include(@five)
-        end
-
-        it 'should be able to search for objects not included in an inclusive range of values' do
-          Heffalump.all(:num_spots.not => 1..4).should be_include(@five)
-        end
-
-        it 'should be able to search for objects not included in an exclusive range of values' do
-          Heffalump.all(:num_spots.not => 1...5).should be_include(@five)
-        end
-
-        it 'should not be able to search for values not included in an inclusive range of values' do
-          Heffalump.all(:num_spots.not => 1..5).should_not be_include(@five)
-        end
-
-        it 'should not be able to search for values not included in an exclusive range of values' do
-          Heffalump.all(:num_spots.not => 1...6).should_not be_include(@five)
-        end
-      end
-
-      describe 'like' do
-        it 'should be able to search for objects that match value' do
-          Heffalump.all(:color.like => '%ed').should be_include(@red)
-        end
-
-        it 'should not search for objects that do not match the value' do
-          Heffalump.all(:color.like => '%blak%').should_not be_include(@red)
-        end
-      end
-
-      describe 'regexp' do
-        before do
-          if (defined?(DataMapper::Adapters::SqliteAdapter) && @adapter.kind_of?(DataMapper::Adapters::SqliteAdapter) ||
-              defined?(DataMapper::Adapters::SqlserverAdapter) && @adapter.kind_of?(DataMapper::Adapters::SqlserverAdapter))
-            pending 'delegate regexp matches to same system that the InMemory and YAML adapters use'
-          end
-        end
-
-        it 'should be able to search for objects that match value' do
-          Heffalump.all(:color => /ed/).should be_include(@red)
-        end
-
-        it 'should not be able to search for objects that do not match the value' do
-          Heffalump.all(:color => /blak/).should_not be_include(@red)
-        end
-
-        it 'should be able to do a negated search for objects that match value' do
-          Heffalump.all(:color.not => /blak/).should be_include(@red)
-        end
-
-        it 'should not be able to do a negated search for objects that do not match value' do
-          Heffalump.all(:color.not => /ed/).should_not be_include(@red)
-        end
-
-      end
-
-      describe 'gt' do
-        it 'should be able to search for objects with value greater than' do
-          Heffalump.all(:num_spots.gt => 1).should be_include(@two)
-        end
-
-        it 'should not find objects with a value less than' do
-          Heffalump.all(:num_spots.gt => 3).should_not be_include(@two)
-        end
-      end
-
-      describe 'gte' do
-        it 'should be able to search for objects with value greater than' do
-          Heffalump.all(:num_spots.gte => 1).should be_include(@two)
-        end
-
-        it 'should be able to search for objects with values equal to' do
-          Heffalump.all(:num_spots.gte => 2).should be_include(@two)
-        end
-
-        it 'should not find objects with a value less than' do
-          Heffalump.all(:num_spots.gte => 3).should_not be_include(@two)
-        end
-      end
-
-      describe 'lt' do
-        it 'should be able to search for objects with value less than' do
-          Heffalump.all(:num_spots.lt => 3).should be_include(@two)
-        end
-
-        it 'should not find objects with a value less than' do
-          Heffalump.all(:num_spots.gt => 2).should_not be_include(@two)
-        end
-      end
-
-      describe 'lte' do
-        it 'should be able to search for objects with value less than' do
-          Heffalump.all(:num_spots.lte => 3).should be_include(@two)
-        end
-
-        it 'should be able to search for objects with values equal to' do
-          Heffalump.all(:num_spots.lte => 2).should be_include(@two)
-        end
-
-        it 'should not find objects with a value less than' do
-          Heffalump.all(:num_spots.lte => 1).should_not be_include(@two)
-        end
-      end
-    end
-
-    describe 'limits' do
-      it 'should be able to limit the objects' do
-        Heffalump.all(:limit => 2).length.should == 2
-      end
-    end
-  end
-
-  describe "with persistence" do
-    before :all do
-      @configured_dir  = File.join( File.dirname(__FILE__), '..', random_string + "-dm-infinispan-adapter.cache" )
-      @default_dir     = File.join(File.dirname(__FILE__), '..', 'Infinispan-FileCacheStore')
-      @snuffy          = File.join( File.dirname(__FILE__), '..', 'rubyobj.Snuffleupagus' ) 
-      FileUtils.mkdir( @configured_dir )
-      class Snuffleupagus
-        include DataMapper::Resource
-        property :id, Serial
-        property :birthday, Date
-      end
-      Snuffleupagus.configure_index!
-    end
-
-    after :all do
-      FileUtils.rm_rf( @configured_dir )
-      FileUtils.rm_rf( @default_dir )
-      FileUtils.rm_rf( @snuffy )
-    end
-
-    it "should store data in a configured directory" do
-      adapter = DataMapper.setup(:dminfinispanadapterconfigured, :adapter => 'infinispan', :persist => @configured_dir.to_s)
-      snuffy = Snuffleupagus.create(:birthday=>Date.today)
-      File.exist?("#{@configured_dir.to_s}/dminfinispanadapterconfigured").should be_true
-      snuffy.should_not be_nil
-      adapter.stop
-    end
-
-    it "should store data in a default directory" do
-      adapter = DataMapper.setup(:dminfinispanadapterdefault, :adapter => 'infinispan', :persist=>true)
-      snuffy = Snuffleupagus.create(:birthday=>Date.today)
-      File.exist?( @default_dir ).should be_true
-      snuffy.should_not be_nil
-      snuffy.id.should_not be_nil
-      adapter.stop
-    end
-
-    it "should store dates" do
-      adapter = DataMapper.setup(:default, :adapter => 'infinispan', :persist=>true)
-      snuffy = Snuffleupagus.create(:birthday => Date.today)
-      snuffy.should_not be_nil
-      snuffy.getBirthday.should_not be_nil
-      adapter.stop
-    end
-
-  end
-end
-
-