sander6-enygma 0.0.7 → 0.1.0

data/lib/api/sphinx/request.rb

@@ -0,0 +1,50 @@
+module Sphinx
+  # Pack ints, floats, strings, and arrays to internal representation
+  # needed by Sphinx search engine.
+  class Request
+    # Initialize new request.
+    def initialize
+      @request = ''
+    end
+    
+    # Put int(s) to request.
+    def put_int(*ints)
+      ints.each { |i| @request << [i].pack('N') }
+    end
+
+    # Put 64-bit int(s) to request.
+    def put_int64(*ints)
+      ints.each { |i| @request << [i].pack('q').reverse }#[i >> 32, i & ((1 << 32) - 1)].pack('NN') }
+    end
+
+    # Put string(s) to request (first length, then the string itself).
+    def put_string(*strings)
+      strings.each { |s| @request << [s.length].pack('N') + s }
+    end
+    
+    # Put float(s) to request.
+    def put_float(*floats)
+      floats.each do |f|
+        t1 = [f].pack('f') # machine order
+        t2 = t1.unpack('L*').first # int in machine order
+        @request << [t2].pack('N')
+      end
+    end
+    
+    # Put array of ints to request (first length, then the array itself)
+    def put_int_array(arr)
+      put_int arr.length, *arr
+    end
+
+    # Put array of 64-bit ints to request (first length, then the array itself)
+    def put_int64_array(arr)
+      put_int arr.length
+      put_int64(*arr)
+    end
+    
+    # Returns the entire message
+    def to_s
+      @request
+    end
+  end
+end

data/lib/api/sphinx/response.rb

@@ -0,0 +1,69 @@
+module Sphinx
+  # Unpack internal Sphinx representation of ints, floats, strings, and arrays.
+  # needed by Sphinx search engine.
+  class Response
+    # Initialize new request.
+    def initialize(response)
+      @response = response
+      @position = 0
+      @size = response.length
+    end
+    
+    # Gets current stream position.
+    def position
+      @position
+    end
+    
+    # Gets response size.
+    def size
+      @size
+    end
+    
+    # Returns <tt>true</tt> when response stream is out.
+    def eof?
+      @position >= @size
+    end
+
+    # Get int from stream.
+    def get_int
+      raise EOFError if @position + 4 > @size
+      value = @response[@position, 4].unpack('N*').first
+      @position += 4
+      return value
+    end
+
+    # Get 64-bit int from stream.
+    def get_int64
+      raise EOFError if @position + 8 > @size
+      hi, lo = @response[@position, 8].unpack('N*N*')
+      @position += 8
+      return (hi << 32) + lo
+    end
+
+    # Get array of <tt>count</tt> ints from stream.
+    def get_ints(count)
+      length = 4 * count
+      raise EOFError if @position + length > @size
+      values = @response[@position, length].unpack('N*' * count)
+      @position += length
+      return values
+    end
+    
+    # Get string from stream.
+    def get_string
+      length = get_int
+      raise EOFError if @position + length > @size
+      value = length > 0 ? @response[@position, length] : ''
+      @position += length
+      return value
+    end
+    
+    # Get float from stream.
+    def get_float
+      raise EOFError if @position + 4 > @size
+      uval = @response[@position, 4].unpack('N*').first;
+      @position += 4
+      return ([uval].pack('L')).unpack('f*').first
+    end
+  end
+end

data/lib/api/sphinx.rb

@@ -0,0 +1,6 @@
+require File.dirname(__FILE__) + '/sphinx/request'
+require File.dirname(__FILE__) + '/sphinx/response'
+require File.dirname(__FILE__) + '/sphinx/client'
+
+module Sphinx
+end

data/lib/enygma/adapters/abstract_adapter.rb

@@ -0,0 +1,31 @@
+module Enygma
+  module Adapters
+    
+    class AbstractAdapter
+      
+      class InscrutableRecord < StandardError; end
+      class InvalidDatabase < StandardError; end
+      
+      attr_reader :datastore
+      
+      def connect!(datastore)
+        @datastore = nil
+      end
+      
+      def query(args = {})
+        []
+      end
+      
+      def get_attribute(record, attribute)
+        if record.respond_to?(attribute.to_sym)
+          record.__send__(attribute.to_sym)
+        elsif record.respond_to?(:[])
+          record[attribute]
+        else
+          raise InscrutableRecord, "Attribute \"#{attribute}\" could not be extracted for record #{record.inspect}."
+        end
+      end
+    end
+    
+  end
+end

data/lib/enygma/adapters/active_record.rb

@@ -0,0 +1,26 @@
+require 'active_record'
+require 'active_support'
+
+module Enygma
+  module Adapters
+    
+    class ActiveRecordAdapter < Enygma::Adapters::AbstractAdapter
+      
+      def connect!(datastore)
+        unless datastore.is_a?(Class) && datastore.ancestors.include?(ActiveRecord::Base)
+          raise InvalidDatabase, "#{datastore.inspect} is not an ActiveRecord::Base subclass!"
+        end
+        @datastore = datastore
+      end
+      
+      def query(args = {})
+        @datastore.scoped(:conditions => { :id => args[:ids] })
+      end
+      
+      def get_attribute(record, attribute)
+        record.read_attribute(attribute)
+      end
+
+    end
+  end
+end

data/lib/enygma/adapters/berkeley.rb

@@ -0,0 +1,23 @@
+require 'mattbauer-dbd'
+
+module Enygma
+  module Adapters
+    
+    class BerkeleyAdapter < Enygma::Adapters::AbstractAdapter
+      
+      def connect!(datastore)
+        raise "The BerkeleyDB adapter is current not implemented."
+      end
+      
+      def query(args = {})
+        raise "The BerkeleyDB adapter is current not implemented."        
+      end
+      
+      def get_attribute(record, attribute)
+        raise "The BerkeleyDB adapter is current not implemented."
+      end
+      
+    end
+
+  end
+end

data/lib/enygma/adapters/datamapper.rb

@@ -0,0 +1,21 @@
+module Enygma
+  module Adapters
+    
+    class DatamapperAdapter < Enygma::Adapters::AbstractAdapter
+      
+      def connect!(datastore)
+        raise "The Datamapper adapter is current not implemented."
+      end
+      
+      def query(args = {})
+        raise "The Datamapper adapter is current not implemented."        
+      end
+      
+      def get_attribute(record, attribute)
+        raise "The Datamapper adapter is current not implemented."
+      end
+      
+    end
+    
+  end
+end

data/lib/enygma/adapters/memcache.rb

@@ -0,0 +1,25 @@
+require 'memcache'
+
+module Enygma
+  module Adapters
+    
+    class MemcacheAdapter < Enygma::Adapters::AbstractAdapter
+      
+      def connect!(datastore)
+        @datastore = case datastore
+        when MemCache
+          datastore
+        else
+          MemCache.new(datastore)
+        end
+      end
+      
+      def query(args = {})
+        ids = args.has_key?(:key_prefix) ? args[:ids].collect {|i| "#{args[:key_prefix]}#{i}"} : args[:ids]
+        @datastore.get_multi(*ids).values
+      end
+      
+    end
+
+  end
+end

data/lib/enygma/adapters/sequel.rb

@@ -0,0 +1,51 @@
+require 'sequel'
+
+module Enygma
+  module Adapters
+    
+    class SequelAdapter < Enygma::Adapters::AbstractAdapter
+      
+      class InvalidTable < StandardError; end
+      
+      def connect!(datastore)
+        @datastore = case datastore
+        when Sequel::Model
+          @table = datastore.table_name
+          datastore.db
+        when Sequel::Database
+          datastore
+        when :sqlite
+          Sequel.sqlite
+        else
+          Sequel.connect(datastore)
+        end
+      end
+      
+      def query(args = {})
+        get_table(args[:table]).filter(:id => args[:ids])
+      end
+      
+      def get_attribute(record, attribute)
+        record[attribute]
+      end
+      
+      private
+      
+      def get_table(obj = nil)
+        case obj
+        when Symbol
+          @datastore ? @datastore[obj] : raise(InvalidTable)
+        when String
+          @datastore ? @datastore[obj.to_sym] : raise(InvalidTable)
+        when Sequel::Model
+          obj
+        when Sequel::Database
+          @table ? obj[@table] : raise(InvalidTable)
+        else
+          raise InvalidTable
+        end
+      end
+    end
+    
+  end
+end

data/lib/enygma/adapters/tokyo_cabinet.rb

@@ -0,0 +1,71 @@
+require 'tokyocabinet'
+
+module Enygma
+  module Adapters
+    
+    class TokyoCabinetAdapter < Enygma::Adapters::AbstractAdapter
+      
+      def connect!(db)
+        @database = case db
+        when TokyoCabinet::HDB
+          db
+        when TokyoCabinet::BDB
+          db
+        when TokyoCabinet::FDB
+          db
+        when TokyoCabinet::TDB
+          db
+        when String
+          unless File.exist?(db)
+            raise InvalidDatabase, "The Tokyo Cabinet database couldn't be found."
+          end
+          case db
+          when /\.tch$/
+            tkcab = TokyoCabinet::HDB.new
+            tkcab.open(db, TokyoCabinet::HDB::OWRITER | TokyoCabinet::HDB::OCREAT)
+            tkcab
+          when /\.tcb$/
+            tkcab = TokyoCabinet::BDB.new
+            tkcab.open(db, TokyoCabinet::BDB::OWRITER | TokyoCabinet::BDB::OCREAT)
+            tkcab
+          when /\.tcf$/
+            tkcab = TokyoCabinet::FDB.new
+            tkcab.open(db, TokyoCabinet::FDB::OWRITER | TokyoCabinet::FDB::OCREAT)
+            tkcab
+          when /\.tct$/
+            tkcab = TokyoCabinet::TDB.new
+            tkcab.open(db, TokyoCabinet::TDB::OWRITER | TokyoCabinet::TDB::OCREAT)
+            tkcab            
+          else
+            "The Tokyo Cabinet database type couldn't be inferred from the name given."
+          end
+        else
+          raise InvalidDatabase, "The Tokyo Cabinet database couldn't be found."
+        end
+      end
+      
+      def query(args = {})
+        prefix = args[:key_prefix] || ''
+        args[:ids] ||= []
+        args[:ids].collect do |i|
+          value = @database.get("#{prefix}#{i}")
+          begin
+            Marshal.load(value)
+          rescue TypeError
+            value
+          end
+        end
+      end
+      
+      def get_attribute(record, attribute)
+        if record.respond_to?(attribute.to_sym)
+          record.__send__(attribute.to_sym)
+        elsif record.respond_to?(:[])
+          record[attribute]
+        else
+          record
+        end
+      end
+    end
+  end
+end

data/lib/enygma/configuration.rb

@@ -0,0 +1,204 @@
+module Enygma
+  
+  # An Enygma::Configuration object holds the data needed to perform a search query, but
+  # without the query-specific parameters. You can create a Configuration object and use it
+  # to configure numerous Search object with the same settings.
+  class Configuration
+    
+    class InvalidAdapterName < StandardError
+      def message
+        "Invalid adapter type! Allowable adapters are #{Enygma::Configuration::ADAPTERS.join(', ')}."
+      end
+    end
+    
+    class AdapterNotSet < StandardError
+      def message
+        "You haven't chosen an adapter to use. Available adapters are #{Enygma::Configuration::ADAPTERS.join(', ')}."
+      end
+    end
+    
+    class TooManyTables < StandardError
+      def message
+        "A class including Enygma::Resource can only search on one table."
+      end
+    end
+
+    class AmbiguousIndex < StandardError
+      def message
+        "You must specify which table goes with what index."
+      end
+    end
+    
+    # The symbol names of the valid adapter types.
+    ADAPTERS = [ :sequel, :active_record, :datamapper, :memcache, :berkeley, :tokyo_cabinet ]
+    
+    # If all your Sphinx index names end with the same suffix (default is '_idx'), you can refer
+    # to them just by their base name.
+    #
+    # For example, if you have two indexes names 'posts_index' and 'comments_index', declaring the
+    # Enygma::Configuration.index_suffix = '_index' will allow you to refer to those indexes as
+    # just :posts and :comments respectively. Such as in
+    #     search(:posts).for("turkey").using_indexes(:posts, :comments)    
+    def self.index_suffix(suffix = nil)
+      return @@index_suffix if suffix.nil?
+      @@index_suffix = suffix
+    end
+    @@index_suffix = '_idx'
+    
+    # The target_attr is the Sphinx attribute that points to the identifier for the original record
+    # (usually the record's id). After querying Sphinx, Enygma will use the values returned for this
+    # attribute to fetch records from the database. Defaults to 'item_id'.
+    def self.target_attr(name = nil)
+      return @@target_attr if name.nil?
+      @@target_attr = name
+    end
+    @@target_attr = 'item_id'
+    
+    # If you're using Enygma in a bunch of different places and always using the same adapter,
+    # you can declare it globally. New Configuration objects will default to using the named
+    # adapter.
+    def self.adapter(name = nil)
+      return @@adapter if name.nil?
+      if name == :none
+        @@database = nil
+        @@adapter = nil
+        return @@adapter
+      end
+      raise InvalidAdapterName unless ADAPTERS.include?(name)
+      case name
+      when :sequel
+        require 'enygma/adapters/sequel'
+        @@adapter = Enygma::Adapters::SequelAdapter.new
+      when :active_record
+        require 'enygma/adapters/active_record'
+        @@adapter = Enygma::Adapters::ActiveRecordAdapter.new
+      when :datamapper
+        require 'enygma/adapters/datamapper'
+        @@adapter = Enygma::Adapters::DatamapperAdapter.new      
+      when :memcache
+        require 'enygma/adapters/memcache'
+        @@adapater = Enygma::Adapters::MemcacheAdapter.new
+      when :berkeley
+        require 'enygma/adapters/berkeley'
+        @@adapater = Enygma::Adapters::BerkeleyAdapter.new
+      when :tokyo_cabinet
+        require 'enygma/adapters/tokyo_cabinet'
+        @@adapater = Enygma::Adapters::TokyoCabinetAdapter.new
+      end
+    end
+    @@adapter = nil
+    
+    # Sets the global port and host configuration for Sphinx.
+    # Defaults to { :port => 3312, :host => "localhost" }
+    def self.sphinx
+      @@sphinx
+    end
+    @@sphinx = { :port => 3312, :host => "localhost" }
+    class << @@sphinx
+      def port(portname = nil)
+        return self[:port] if portname.nil?
+        self[:port] = portname
+      end
+      
+      def host(hostname = nil)
+        return self[:host] if hostname.nil?
+        self[:host] = hostname
+      end
+    end
+    
+    # Evals the block against the Enygma::Configuration class to set global configuration.
+    def self.global(&config)
+      self.instance_eval(&config)
+    end
+    
+    attr_reader :adapter, :table, :indexes, :target_attr, :match_mode, :weights, :latitude, :longitude, :resource
+    
+    def initialize(attributes = {}, &block)
+      @adapter      = @@adapter
+      @table        = nil
+      @indexes      = []
+      @target_attr  = @@target_attr
+      @match_mode   = :all
+      @weights      = {}
+      @latitude     = 'lat'
+      @longitude    = 'lng'
+      @key_prefix   = nil
+      attributes.each do |name, value|
+        self.__send__(name, value)
+      end
+      self.instance_eval(&block) if block
+    end
+    
+    def adapter(name = nil)
+      return @adapter if name.nil?
+      if name == :none
+        @adapter = nil
+        return @adapter
+      end
+      raise InvalidAdapterName unless ADAPTERS.include?(name)
+      case name
+      when :sequel
+        require 'enygma/adapters/sequel'
+        @adapter = Enygma::Adapters::SequelAdapter.new
+      when :active_record
+        require 'enygma/adapters/active_record'
+        @adapter = Enygma::Adapters::ActiveRecordAdapter.new
+      when :datamapper
+        require 'enygma/adapters/datamapper'
+        @adapter = Enygma::Adapters::DatamapperAdapter.new
+      when :memcache
+        require 'enygma/adapters/memcache'
+        @adapter = Enygma::Adapters::MemcacheAdapter.new
+      when :berkeley
+        require 'enygma/adapters/berkeley'
+        @adapter = Enygma::Adapters::BerkeleyAdapter.new
+      when :tokyo_cabinet
+        require 'enygma/adapters/tokyo_cabinet'
+        @adapter = Enygma::Adapters::TokyoCabinetAdapter.new
+      end
+    end
+    
+    def datastore(store)
+      raise AdapterNotSet unless @adapter
+      @adapter.connect!(store)
+    end
+    
+    def key_prefix(prefix = nil)
+      return @key_prefix if prefix.nil?
+      @key_prefix = prefix
+    end
+    
+    def table(table_name = nil, options = {})
+      return @table if table_name.nil?
+      @table = table_name
+      if idxs = options[:index] || options[:indexes]
+        idx_names = [ *idxs ].collect { |idx| Enygma.indexify(idx) }
+        @indexes += idx_names
+      end
+      return @table
+    end
+    
+    def weight(attribute, value)
+      @weights[attribute.to_s] = value
+    end
+    
+    def index(index)
+      @indexes << Enygma.indexify(index)
+      return @indexes
+    end
+    
+    def match_mode(mode = nil)
+      return @match_mode if mode.nil?
+      @match_mode = mode
+    end
+    
+    def target_attr(name = nil)
+      return @target_attr if name.nil?
+      @target_attr = name
+    end
+    
+    def sphinx
+      @@sphinx
+    end    
+  end
+end

data/lib/enygma/extensions/float.rb

@@ -0,0 +1,13 @@
+module Enygma
+  module Extensions
+    module FloatExtensions
+
+      def to_rad
+        (self * 2.0 * Math::PI) / 360.0
+      end
+
+    end
+  end
+end
+
+Float.__send__(:include, Enygma::Extensions::FloatExtensions)

data/lib/enygma/geodistance_proxy.rb

@@ -0,0 +1,66 @@
+module Enygma
+  class GeoDistanceProxy
+    
+    class InvalidUnits < StandardError; end
+    
+    failproc = Proc.new { |d| raise(InvalidUnits, "\"#{d}\" is not a supported distance unit.") }
+    
+    UNIT_CONVERSION = Hash.new(failproc).merge({
+      :meters     => Proc.new { |d| d },
+      :kilometers => Proc.new { |d| d / 1000.0 },
+      :feet       => Proc.new { |d| d * 0.3048 },
+      :miles      => Proc.new { |d| d / 1609.344 },
+      :yards      => Proc.new { |d| d * 0.9144 }
+    })
+  
+    def initialize(delegate, distance)
+      @delegate = delegate
+      @distance = distance
+      @units = :meters
+    end
+  
+    def meters
+      @units = :meters
+      self
+    end
+    
+    def kilometers
+      @units = :kilometers
+      self
+    end
+    
+    def feet
+      @units = :feet
+      self
+    end
+    
+    def miles
+      @units = :miles
+      self
+    end
+    
+    def yards
+      @units = :yards
+      self
+    end
+  
+    def of(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
+      @delegate.__send__(:geo_anchor, lat, lng)
+      @delegate.filter('@geodist', UNIT_CONVERSION[@units][@distance])
+      @delegate
+    end
+  end
+end