sander6-enygma 0.0.7 → 0.1.0

data/lib/enygma/resource.rb

@@ -0,0 +1,43 @@
+module Enygma
+  module Resource
+    
+    class InvalidInclusionClass < StandardError; end
+    
+    class << self
+      def included(base)
+        if defined?(ActiveRecord) && base.ancestors.include?(ActiveRecord::Base)
+          configure_for_active_record(base)
+        elsif defined?(Sequel) && base.ancestors.include?(Sequel::Model)
+          configure_for_sequel_model(base)
+        elsif defined?(Datamapper) && base.included_modules.include?(Datamapper::Resource)
+          configure_for_datamapper_resource(base)
+        else
+          raise InvalidInclusionClass, "Enygma::Resource has to be included in a subclass of ActiveRecord::Base or Sequel::Model or a class including Datamapper::Resource! You might want to try just including Enygma."
+        end
+      end
+    
+      private
+      
+      def configure_for_active_record(base)
+        base.__send__(:include, Enygma)
+        base.configure_enygma do
+          adapter   :active_record
+          table     base
+        end
+      end
+    
+      def configure_for_sequel_model(base)
+        base.__send__(:include, Enygma)
+        base.configure_enygma do
+          adapter   :sequel
+          table     base
+        end
+      end
+    
+      def configure_for_datamapper_resource(base)
+        raise "Datamapper support isn't implemented yet! Sorry!"
+      end
+    end
+    
+  end
+end

data/lib/enygma/search.rb

@@ -0,0 +1,250 @@
+module Enygma
+  
+  class Search
+
+    class InvalidFilter < StandardError
+      def message
+        "You can only filter on an Array or Range of values."
+      end
+    end
+
+    class InvalidSphinxQuery < StandardError
+      def message
+        "Sphinx rejected the query; perhaps you're trying to search on a non-existent index?"
+      end
+    end
+
+    class MultipleResultSetsError < StandardError
+      def message
+        "Results were returned for multiple tables, so some attributes are ambiguous."
+      end
+    end
+    
+    class AmbiguousIndexes < StandardError
+      def message
+        "You haven't specified which indexes go to which table!"
+      end
+    end
+    
+    MATCH_MODES = {
+      :all        => Sphinx::Client::SPH_MATCH_ALL,
+      :any        => Sphinx::Client::SPH_MATCH_ANY,
+      :phrase     => Sphinx::Client::SPH_MATCH_PHRASE,
+      :boolean    => Sphinx::Client::SPH_MATCH_BOOLEAN,
+      :extended   => Sphinx::Client::SPH_MATCH_EXTENDED,
+      :full       => Sphinx::Client::SPH_MATCH_FULLSCAN,
+      :extended2  => Sphinx::Client::SPH_MATCH_EXTENDED2
+    }
+    
+    GROUP_FUNCTIONS = {
+      :day    => Sphinx::Client::SPH_GROUPBY_DAY,
+      :week   => Sphinx::Client::SPH_GROUPBY_WEEK, 
+      :month  => Sphinx::Client::SPH_GROUPBY_MONTH, 
+      :year   => Sphinx::Client::SPH_GROUPBY_YEAR,
+      :attr   => Sphinx::Client::SPH_GROUPBY_ATTR,
+      :pair   => Sphinx::Client::SPH_GROUPBY_ATTRPAIR
+    }
+
+    SORT_MODES = {
+      :relevance      => Sphinx::Client::SPH_SORT_RELEVANCE,
+      :date_desc      => Sphinx::Client::SPH_SORT_ATTR_DESC,
+      :date_asc       => Sphinx::Client::SPH_SORT_ATTR_ASC,
+      :time_segments  => Sphinx::Client::SPH_SORT_TIME_SEGMENTS,
+      :extended       => Sphinx::Client::SPH_SORT_EXTENDED,
+      :expression     => Sphinx::Client::SPH_SORT_EXPR
+    }
+       
+    def initialize(*args, &block)
+      overrides = args.last.is_a?(Hash) ? args.pop : {}
+
+      config = if args.first.is_a?(Enygma::Configuration)
+        args.first
+      elsif block_given?
+        Enygma::Configuration.new(&block)
+      else
+        raise NoConfiguration, "You must supply an Enygma::Configuration object or definition block to create an Enygma::Search!"
+      end
+        
+      @database = {
+        :adapter  => config.adapter,
+        :table    => config.table
+      }
+      @sphinx   = Sphinx::Client.new
+
+      @indexes      = config.indexes
+      @term         = overrides[:term] || ""
+      @target_attr  = config.target_attr
+      @match_mode   = MATCH_MODES[config.match_mode]
+      @key_prefix   = config.key_prefix || ''
+      
+      @latitude   = config.latitude
+      @longitude  = config.longitude
+
+      @limit      = @sphinx.instance_variable_get(:@limit)
+      @offset     = @sphinx.instance_variable_get(:@offset)
+      @max        = @sphinx.instance_variable_get(:@maxmatches)
+      @cutoff     = @sphinx.instance_variable_get(:@cutoff)
+
+      @return_attributes  = []
+
+      @sphinx.SetServer(config.sphinx[:host], config.sphinx[:port])
+      @sphinx.SetMatchMode(@match_mode)
+    end
+    
+    def run
+      query_database(query_sphinx)
+    end
+    
+    def method_missing(name, *args, &block)
+      self.run.__send__(name, *args, &block)
+    end
+    
+    def count
+      query_sphinx['total']
+    end
+    
+    def for(*terms)
+      @term = terms.join(" ")
+      self      
+    end
+    
+    def in(table)
+      @database[:table] = table
+      self
+    end
+    
+    def using_match_mode(match_mode)
+      @match_mode = MATCH_MODES[match_mode]
+      @sphinx.SetMatchMode(@match_mode)
+      self
+    end
+
+    def using_indexes(*indexes)
+      @indexes = indexes.collect { |idx| Enygma.indexify(idx) }
+      self
+    end
+    alias_method :using_index, :using_indexes
+        
+    def filter(attribute, values, exclude = false)
+      attribute = attribute.to_s
+      case values
+      when Array
+        @sphinx.SetFilter(attribute, values, exclude)
+      when Range
+        if values.begin.is_a?(Float) || values.end.is_a?(Float)
+          @sphinx.SetFilterFloatRange(attribute, values.begin.to_f, values.end.to_f, exclude)
+        else
+          @sphinx.SetFilterRange(attribute, values.begin.to_i, values.end.to_i, exclude)
+        end
+      when Numeric
+        @sphinx.SetFilterFloatRange(attribute, 0.0, values.to_f, exclude)
+      else
+        raise InvalidFilter
+      end
+      self
+    end
+    
+    def exclude(attribute, values)
+      filter(attribute, values, true)
+    end
+    
+    def group_by(attribute, function, sort = "@group DESC")
+      @sphinx.SetGroupBy(attribute, GROUP_FUNCTIONS[function], sort)
+      self
+    end
+    
+    def sort_by(type, sort_by = '')
+      case type
+      when :date
+        if arg == :asc
+          sort_mode = :date_asc
+        else
+          sort_mode = :date_desc
+        end
+      when :time
+        sort_mode = :time_segments
+      when :expression
+        sort_mode = :expression
+      when String
+        sort_mode = :extended
+        sort_by = type
+      else
+        sort_mode = :relevance
+      end
+      @sphinx.SetSortMode(SORT_MODES[sort_mode], sort_by)
+      self
+    end
+    
+    def select(*attributes)
+      @sphinx.SetSelect(attributes.join(','))
+      self
+    end
+    
+    def limit(value)
+      @limit = value
+      set_limits
+      self
+    end
+    
+    def offset(value)
+      @offset = value
+      set_limits
+      self
+    end
+    
+    def max(value)
+      @max = value
+      set_limits
+      self
+    end
+    
+    def cutoff(value)
+      @cutoff = value
+      set_limits
+      self
+    end
+    
+    def within(distance)
+      Enygma::GeoDistanceProxy.new(self, distance)
+    end
+    
+    def anchor(point_or_lat, lng = nil)
+      if lng.nil?
+        if point_or_lat.respond_to?(:lat) && point_or_lat.respond_to?(:lng)
+          lat, lng = point_or_lat.lat, point_or_lat.lng
+        elsif point_or_lat.respond_to?(:coordinates) && point_or_lat.coordinates.respond_to?(:lat) && point_or_lat.coordinates.respond_to?(:lng)
+          lat, lng = point_or_lat.coordinates.lat, point_or_lat.coordinates.lng
+        elsif point_or_lat.respond_to?(:point) && point_or_lat.point.respond_to?(:lat) && point_or_lat.point.respond_to?(:lng)
+          lat, lng = point_or_lat.point.lat, point_or_lat.point.lng
+        else
+          raise ArgumentError, "#{point_or_lat.inspect} doesn't seem to be a geometry-enabled object!"
+        end
+      else
+        lat, lng = point_or_lat, lng
+      end
+      geo_anchor(lat, lng)
+      self
+    end
+    
+    private
+    
+    def geo_anchor(lat, lng)
+      @sphinx.SetGeoAnchor(@latitude, @longitude, lat, lng)      
+    end
+  
+    def set_limits
+      @sphinx.SetLimits(@offset, @limit, @max, @cutoff)
+    end
+  
+    def query_sphinx
+      sphinx_response = @sphinx.Query(@term, @indexes.join(', '))
+      raise InvalidSphinxQuery unless sphinx_response
+      sphinx_response
+    end
+      
+    def query_database(results)
+      ids = results['matches'].collect { |match| match['attrs'][@target_attr] }.uniq
+      @database[:adapter].query(:table => @database[:table], :ids => ids, :key_prefix => @key_prefix)
+    end
+  end  
+end

data/lib/enygma/version.rb

@@ -0,0 +1,13 @@
+module Enygma
+  module Version
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 0 
+    
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+  
+  def self.version
+    Enygma::Version::STRING
+  end
+end

data/lib/enygma.rb

@@ -0,0 +1,75 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'api/sphinx'
+
+require 'enygma/version'
+
+require 'enygma/extensions/float'
+
+require 'enygma/adapters/abstract_adapter'
+require 'enygma/configuration'
+require 'enygma/geodistance_proxy'
+require 'enygma/search'
+
+require 'enygma/resource'
+
+module Enygma
+  
+  class << self
+    
+    def included(base)
+      config_name = :"#{base.name.gsub(/(?!^)([A-Z])/, '_\1').upcase}_ENYGMA_CONFIGURATION"
+      base.const_set(config_name, Enygma::Configuration.new) unless base.const_defined?(config_name)
+      base.__send__(:extend, Enygma::ClassMethods)
+      if defined?(ActiveRecord) && base.ancestors.include?(ActiveRecord::Base)
+        configure_for_active_record(base)
+      elsif defined?(Sequel) && base.ancestors.include?(Sequel::Model)
+        configure_for_sequel_model(base)
+      elsif defined?(Datamapper) && base.included_modules.include?(Datamapper::Resource)
+        configure_for_datamapper_resource(base)
+      end
+    end
+
+    def indexify(name)
+      name.to_s =~ %r{#{Enygma::Configuration.index_suffix}$} ? name.to_s : name.to_s + Enygma::Configuration.index_suffix
+    end
+
+    private
+    
+    def configure_for_active_record(base)
+      base.configure_enygma do
+        adapter   :active_record
+        datastore base
+      end
+    end
+  
+    def configure_for_sequel_model(base)
+      base.configure_enygma do
+        adapter   :sequel
+        datastore base
+      end
+    end
+  
+    def configure_for_datamapper_resource(base)
+      raise "Datamapper support isn't implemented yet! Sorry!"
+    end
+  end  
+
+  module ClassMethods
+    
+    def enygma_configuration
+      self.const_get(:"#{self.name.gsub(/(?!^)([A-Z])/, '_\1').upcase}_ENYGMA_CONFIGURATION")
+    end
+    
+    def configure_enygma(&config)
+      enygma_configuration.instance_eval(&config)
+    end
+    
+    def search(table = nil)
+      src = Enygma::Search.new(enygma_configuration)
+      src.in(table) if table
+      return src
+    end
+    
+  end  
+end

data/spec/adapters/abstract_adapter_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Enygma::Adapters::AbstractAdapter do
+  
+end

data/spec/adapters/active_record_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'active_record'
+require 'enygma/adapters/active_record'
+
+describe Enygma::Adapters::ActiveRecordAdapter do
+  
+end

data/spec/adapters/datamapper_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'datamapper'
+require 'enygma/adapters/datamapper'
+
+describe Enygma::Adapters::DatamapperAdapter do
+  
+end

data/spec/adapters/sequel_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'sequel'
+require 'enygma/adapters/sequel'
+
+describe Enygma::Adapters::SequelAdapter do
+  
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,217 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Enygma::Configuration do
+  
+  describe Enygma::Configuration::InvalidAdapterName do
+    it "should be raised when the adapter is set to something not supported" do
+      lambda { Enygma::Configuration.adapter(:skull_of_orm) }.should raise_error(Enygma::Configuration::InvalidAdapterName)
+    end
+    
+    it "should come with a message along the lines of 'Invalid adapter type!'" do
+      Enygma::Configuration::InvalidAdapterName.new.message.should =~ Regexp.new("Invalid adapter type!")
+    end
+  end
+
+  describe Enygma::Configuration::AdapterNotSet do
+    before do
+      @config = Enygma::Configuration.new
+    end
+
+    it "should be raised when trying to connect to a database when an adapter isn't set" do
+      lambda {
+        @config.adapter(:none)
+        @config.datastore("postgres://user@localhost/database")
+      }.should raise_error(Enygma::Configuration::AdapterNotSet)
+    end
+    
+    it "should come with a message along the lines of 'You haven't chosen an adatper to use.'" do
+      Enygma::Configuration::AdapterNotSet.new.message.should =~ Regexp.new("You haven't chosen an adapter to use.")
+    end
+  end
+  
+  describe "class variables" do
+    
+    describe "@@index_suffix" do
+      it "should default to '_idx'" do
+        Enygma::Configuration.index_suffix.should == '_idx'
+      end
+      
+      it "should be set with .index_suffix" do
+        Enygma::Configuration.index_suffix('_index')
+        Enygma::Configuration.index_suffix.should == '_index'
+      end
+    end
+
+    describe "@@target_attr" do
+      it "should default to 'item_id'" do
+        Enygma::Configuration.target_attr.should == 'item_id'
+      end
+      
+      it "should be set with .target_attr" do
+        Enygma::Configuration.target_attr('record_id')
+        Enygma::Configuration.target_attr.should == 'record_id'
+      end
+    end
+    
+    describe "@@adapter" do
+      it "should default to nil" do
+        Enygma::Configuration.adapter.should be_nil
+      end
+      
+      it "should be set with .adapter" do
+        Enygma::Configuration.adapter(:sequel)
+      end
+      
+      it "should return the adapter after being set" do
+        Enygma::Configuration.adapter(:sequel)
+        Enygma::Configuration.adapter.should be_an_instance_of(Enygma::Adapters::SequelAdapter)
+      end
+      
+      it "should raise an error if the adapter isn't available" do
+        lambda { Enygma::Configuration.adapter(:skull_of_orm) }.should raise_error(Enygma::Configuration::InvalidAdapterName)
+      end
+      
+      it "should reset the adapter to nil if passed :none" do
+        Enygma::Configuration.adapter(:sequel)
+        Enygma::Configuration.adapter.should_not be_nil
+        Enygma::Configuration.adapter(:none)
+        Enygma::Configuration.adapter.should be_nil
+      end
+    end
+    
+    describe "@@sphinx" do
+      it "should default to { :port => 3312, :host => 'localhost' }" do
+        Enygma::Configuration.sphinx.should == { :port => 3312, :host => 'localhost' }
+      end
+      
+      it "should return the sphinx configuration hash with .sphinx" do
+        Enygma::Configuration.sphinx.should be_an_instance_of(Hash)
+      end
+      
+      it "should be able to be set on a per-key basis just like any other hash" do
+        Enygma::Configuration.sphinx[:port] = 303
+        Enygma::Configuration.sphinx[:host] = 'g.host'
+        Enygma::Configuration.sphinx.should == { :port => 303, :host => 'g.host' }
+      end
+      
+      it "should respond to #port and #host to allow pretty configuration" do
+        Enygma::Configuration.sphinx.should respond_to(:port)
+        Enygma::Configuration.sphinx.should respond_to(:host)
+      end
+      
+      it "should be able to be configured using the accessor methods instead of []" do
+        Enygma::Configuration.sphinx.port(303)
+        Enygma::Configuration.sphinx.host('g.host')
+        Enygma::Configuration.sphinx.should == { :port => 303, :host => 'g.host' }
+      end
+    end    
+  end
+
+  describe ".global" do
+    it "should instance_eval self against the block" do
+      Enygma::Configuration.expects(:instance_eval)
+      Enygma::Configuration.global { }
+    end
+  
+    it "should set the proper class variable using the accessors" do
+      Enygma::Configuration.global do
+        index_suffix  '_index'
+        target_attr   'record_id'
+        adapter       :sequel 
+        sphinx.port   303
+        sphinx.host   'g.host'
+      end
+      Enygma::Configuration.index_suffix.should == '_index'
+      Enygma::Configuration.target_attr.should == 'record_id'
+      Enygma::Configuration.adapter.should be_an_instance_of(Enygma::Adapters::SequelAdapter)
+      Enygma::Configuration.sphinx.should == { :port => 303, :host => 'g.host' }
+    end
+  end
+  
+  describe "default instance variables" do
+    before(:each) do
+      Enygma::Configuration.global do
+        index_suffix  '_index'
+        target_attr   'record_id'
+        adapter       :sequel 
+        sphinx.port   303
+        sphinx.host   'g.host'        
+      end
+      @config = Enygma::Configuration.new
+    end
+    
+    it "should set @adapter to @@adapter" do
+      @config.adapter.should == Enygma::Configuration.adapter
+    end
+    
+    it "should set @table to nil" do
+      @config.table.should be_nil
+    end
+    
+    it "should set @indexes to []" do
+      @config.indexes.should be_an_instance_of(Array)
+      @config.indexes.should be_empty
+    end
+    
+    it "should set @target_attr to @@target_attr" do
+      @config.target_attr.should == Enygma::Configuration.target_attr
+    end
+    
+    it "should set @weights to {}" do
+      @config.weights.should == {}
+    end
+    
+    it "should set @latitude to 'lat'" do
+      @config.latitude.should == 'lat'
+    end
+    
+    it "should set @longitude to 'lng'" do
+      @config.longitude.should == 'lng'
+    end
+  end
+  
+  describe "sphinx" do
+    before(:each) do
+      @config = Enygma::Configuration.new
+    end
+    
+    it "should return the class default sphinx configuration" do
+      @config.sphinx.should == Enygma::Configuration.sphinx
+    end
+  end
+  
+  describe "table" do
+    before(:each) do
+      @config = Enygma::Configuration.new
+    end
+    
+    it "should set the name as the default table" do
+      @config.table :things
+      @config.table.should == :things
+    end    
+  end
+  
+  describe "index" do
+    before(:each) do
+      Enygma::Configuration.index_suffix '_idx'
+      @config = Enygma::Configuration.new
+    end
+    
+    it "should add the index name, massaged through Enygma.indexify, to the named table's indexes" do
+      @config.index :things
+      @config.indexes.should include(Enygma.indexify(:things))
+    end
+  end
+  
+  describe "weight" do
+    before(:each) do
+      @config = Enygma::Configuration.new
+    end
+    
+    it "should add the given weight to the given attribute to the hash of weights" do
+      @config.weight :name, 20
+      @config.weights.should have_key('name')
+      @config.weights['name'].should == 20
+    end
+  end
+end

data/spec/enygma_spec.rb

@@ -0,0 +1,74 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Enygma do
+  
+  describe "including the module" do
+    before(:each) do
+      class Thing; end
+    end
+    
+    it "should set <class_name>_ENYGMA_CONFIGURATION on the base class" do
+      Thing.__send__(:include, Enygma)
+      Thing.const_defined?(:THING_ENYGMA_CONFIGURATION).should be_true
+    end
+    
+    it "should extend the base class with Enygma::ClassMethods" do
+      Thing.expects(:extend).with(Enygma::ClassMethods)
+      Thing.__send__(:include, Enygma)
+    end
+  end
+  
+  describe "enygma_configuration" do
+    before(:each) do
+      class Thing; include Enygma; end
+    end
+    
+    it "should return the class' <class_name>_ENYGMA_CONFIGURATION" do
+      Thing.enygma_configuration.should == Thing.const_get(:THING_ENYGMA_CONFIGURATION)
+    end
+    
+    it "should be an instance of Enygma::Configuration" do
+      Thing.enygma_configuration.should be_an_instance_of(Enygma::Configuration)
+    end
+  end
+  
+  describe "configure_enygma" do
+    before(:each) do
+      class Thing; include Enygma; end
+    end
+    
+    it "should instance_eval the block against the class' @enygma_configuration" do
+      Thing.enygma_configuration.expects(:instance_eval)
+      Thing.configure_enygma { }
+    end
+  end
+  
+  describe "search" do
+    before(:each) do
+      class Thing; include Enygma; end
+    end
+    
+    it "should return an instance of Enygma::Search" do
+      Thing.search.should be_an_instance_of(Enygma::Search)
+    end
+  end
+  
+  describe ".indexify" do
+    before(:each) do
+      Enygma::Configuration.index_suffix '_index'
+    end
+    
+    it "should append the default index suffix to the argument" do
+      Enygma.indexify('butter').should == 'butter_index'
+    end
+    
+    it "should convert symbols into strings" do
+      Enygma.indexify(:butter).should == 'butter_index'
+    end
+    
+    it "should leave arguments that already end in the default suffix alone" do
+      Enygma.indexify(:butter_index).should == 'butter_index'
+    end
+  end
+  
+end