ion 0.0.1

data/lib/ion/index.rb

@@ -0,0 +1,56 @@
+# An index
+#
+# You can subclass me by reimplementing #index, #deindex and #search.
+#
+class Ion::Index
+  attr_reader :name
+  attr_reader :options
+
+  def initialize(name, options, args={}, &blk)
+    @name    = name
+    @options = options
+    @lambda  = blk  if block_given?
+    @lambda  ||= Proc.new { self.send(name) }
+  end
+
+  # Indexes a record
+  def index(record)
+  end
+
+  def self.deindex(record)
+  end
+
+  # Completely obliterates traces of a record from the indices
+  def self.del(record)
+    self.deindex record
+    references_key(record).del
+  end
+
+  # Returns a key (set) of results
+  def search(what, args={})
+  end
+
+protected
+
+  # Returns the value for a certain record
+  def value_for(record)
+    record.instance_eval &@lambda
+  end
+
+  # Returns the index key
+  # Example: Ion:Album:text:title
+  def index_key
+    @type ||= self.class.name.split(':').last.downcase
+    @options.key[@type][self.name]
+  end
+
+  # Ion:Album:references:1:text
+  def self.references_key(record)
+    type = self.name.split(':').last.downcase
+    record.class.ion.key[:references][record.id][type]
+  end
+
+  def references_key(record)
+    self.class.references_key record
+  end
+end

data/lib/ion/indices.rb

@@ -0,0 +1,18 @@
+module Ion
+module Indices
+  autoload :Text,      "#{Ion::PREFIX}/indices/text"
+  autoload :Number,    "#{Ion::PREFIX}/indices/number"
+  autoload :Metaphone, "#{Ion::PREFIX}/indices/metaphone"
+  autoload :Sort,      "#{Ion::PREFIX}/indices/sort"
+
+  def self.names
+    [ :text, :number, :metaphone, :sort ]
+  end
+
+  def self.get(name)
+    name = Stringer.classify(name).to_sym
+    raise InvalidIndexType  unless const_defined?(name)
+    const_get(name)
+  end
+end
+end

data/lib/ion/indices/metaphone.rb

@@ -0,0 +1,7 @@
+module Ion
+class Indices::Metaphone < Indices::Text
+  def index_words(str)
+    words = ::Text::Metaphone.metaphone(str).strip.split(' ')
+  end
+end
+end

data/lib/ion/indices/number.rb

@@ -0,0 +1,31 @@
+module Ion
+class Indices::Number < Indices::Text
+  MARGIN = 0.0001
+
+  def index(record)
+    value = value_for(record).to_f
+    refs  = references_key(record)
+
+    index_key.zadd value, record.id
+    refs.sadd index_key
+  end
+
+  def search(what, args={})
+    key = Ion.volatile_key
+    key.zunionstore [index_key] #copy
+
+    if what.is_a?(Hash)
+      # Strip away the upper/lower limits.
+      key.zremrangebyscore '-inf', what[:gt]  if what[:gt]
+      key.zremrangebyscore what[:lt], '+inf'  if what[:lt]
+      key.zremrangebyscore '-inf', (what[:min].to_f-MARGIN)  if what[:min]
+      key.zremrangebyscore (what[:max].to_f+MARGIN), '+inf'  if what[:max]
+    else
+      key.zremrangebyscore '-inf', what.to_f-MARGIN
+      key.zremrangebyscore what.to_f+MARGIN, '+inf'
+    end
+
+    key
+  end
+end
+end

data/lib/ion/indices/sort.rb

@@ -0,0 +1,41 @@
+module Ion
+class Indices::Sort < Ion::Index
+  def index(record)
+    value = value_for(record)
+    value = transform(value)
+
+    key_for(record).hset name, value
+  end
+
+  # The function that the string passes thru before going to the db.
+  def transform(value)
+    str = value.to_s.downcase.strip
+    str = str[4..-1]  if str[0..3] == "the "  # Remove articles from sorting
+    str
+  end
+
+  def self.deindex(record)
+    key_for(record).del
+  end
+
+  def spec
+    # Ion:sort:Album:*->title
+    @spec ||= self.class.key[@options.model.name]["*->#{name}"]
+  end
+
+protected
+  def self.key_for(record)
+    # Ion:sort:Album:1
+    key[record.class.name][record.id]
+  end
+
+  def self.key
+    # Ion:sort
+    Ion.key[:sort]
+  end
+
+  def key_for(record)
+    self.class.key_for(record)
+  end
+end
+end

data/lib/ion/indices/text.rb

@@ -0,0 +1,41 @@
+module Ion
+class Indices::Text < Index
+  def index_words(str)
+    Stringer.keywords str
+  end
+
+  def search_words(str)
+    index_words str
+  end
+
+  def index(record)
+    super
+    words = index_words(value_for(record).to_s)
+    refs  = references_key(record)
+
+    words.each do |word|
+      k = index_key[word]
+      refs.sadd k
+      k.zadd 1, record.id
+    end
+  end
+
+  def self.deindex(record)
+    super
+    refs = references_key(record)
+    refs.smembers.each do |key|
+      Ion.redis.zrem(key, record.id)
+      Ion.redis.del(key)  if Ion.redis.zrange(key,0,0).nil?
+    end
+  end
+
+  def search(what, args={})
+    super
+    words   = search_words(what)
+    keys    = words.map { |word| index_key[word] }
+
+    w = keys.map { 0 }; w[0] = 1
+    Ion.intersect keys, weights: w
+  end
+end
+end

data/lib/ion/options.rb

@@ -0,0 +1,46 @@
+class Ion::Options
+  attr_reader :model
+
+  def initialize(model)
+    @model = model
+    @indices = Hash.new { |h, k| h[k] = Hash.new }
+  end
+
+  def search(&blk)
+    Ion::Search.new(self, &blk)
+  end
+
+  def key
+    @key ||= Ion.key[model.name]  #=> 'Ion:Person'
+  end
+
+  # Returns a certain index.
+  # @example
+  #   @options.index(:text, :title) #=> <#Ion::Indices::Text>
+  def index(type, name)
+    @indices[type][name]
+  end
+
+  # Returns all indices.
+  def indices
+    @indices.values.map(&:values).flatten
+  end
+
+  def index_types
+    indices.map(&:class).uniq
+  end
+
+protected
+  # Creates the shortcuts `text :foo` => `field :text, :foo`
+  Ion::Indices.names.each do |type|
+    define_method(type) do |id, options={}, &blk|
+      field type, id, options, &blk
+    end
+  end
+
+  def field(type, id, options={}, &blk)
+    index_type = Ion::Indices.get(type)
+    @indices[type][id.to_sym] = index_type.new(id, self, options, &blk)
+  end
+end
+

data/lib/ion/scope.rb

@@ -0,0 +1,163 @@
+class Ion::Scope
+  include Ion::Helpers
+
+  attr_writer :key
+
+  def initialize(search, args={}, &blk)
+    @search  = search
+    @gate    = args[:gate]  || :all
+    @score   = args[:score] || 1.0
+    @type    = :z # or :l
+
+    yieldie(&blk) and done  if block_given?
+
+    raise Ion::Error  unless [:all, :any].include?(@gate)
+  end
+
+  # Returns a unique hash of what the scope contains.
+  def search_hash
+    @search_hash ||= [[@gate, @score]]
+  end
+
+  def any_of(&blk)
+    scopes << subscope(:gate => :any, &blk)
+  end
+
+  def all_of(&blk)
+    scopes << subscope(:gate => :all, &blk)
+  end
+
+  def boost(amount=1.0, &blk)
+    boosts << [Ion::Scope.new(@search, :gate => :all, &blk), amount]
+  end
+
+  def score(score, &blk)
+    scopes << subscope(:score => score, &blk)
+  end
+
+  def key
+    @key ||= Ion.volatile_key
+  end
+
+  def sort_by(what)
+    index = @search.options.index(:sort, what)
+    key.sort by: index.spec, order: "ASC ALPHA", store: key
+  end
+
+  # Only when done
+  def count
+    return key.zcard  if key.type == "zset"
+    return key.llen   if key.type == "list"
+    0
+  end
+
+  # Defines the shortcuts `text :foo 'xyz'` => `search :text, :foo, 'xyz'`
+  Ion::Indices.names.each do |type|
+    define_method(type) do |field, what, args={}|
+      search type, field, what, args
+    end
+  end
+
+  # Searches a given field.
+  # @example
+  #   class Album
+  #     ion { text :name }
+  #   end
+  #
+  #   Album.ion.search {
+  #     search :text, :name, "Emotional Technology"
+  #     text :name, "Emotional Technology"   # same
+  #   }
+  def search(type, field, what, args={})
+    subkey = options.index(type, field).search(what, args)
+    temp_keys   << subkey
+    subkeys     << subkey
+    search_hash << [type,field,what,args]
+  end
+
+  def options
+    @search.options
+  end
+
+  def ids(range)
+    from, to = range.first, range.last
+    to -= 1  if range.exclude_end?
+    
+    type = key.type
+    results = if type == "zset"
+        key.zrevrange(from, to) 
+      elsif type == "list"
+        key.lrange(from, to)
+      else
+        Array.new
+      end
+
+    expire and results
+  end
+
+protected
+  # List of scopes to be cleaned up after. (Array of Scope instances)
+  def scopes()     @scopes ||= Array.new end
+
+  # List of keys that contain results to be combined.
+  def subkeys()    @subkeys ||= Array.new end
+
+  # List of keys (like search keys) to be cleaned up after.
+  def temp_keys()  @temp_keys ||= Array.new end
+
+  # List of boost scopes -- [Scope, amount] tuples
+  def boosts()     @boosts ||= Array.new end
+
+  # Called by #run after doing an instance_eval of DSL stuff.
+  # This consolidates the keys into self.key.
+  def done
+    if subkeys.size == 1
+      self.key = subkeys.first
+    elsif subkeys.size > 1
+      combine subkeys
+    end
+
+    # Adjust scores accordingly
+    self.key = rescore(key, @score)
+
+    boost_keys = boosts.map do |(scope, amount)|
+      inter = Ion.volatile_key
+      inter.zinterstore([key, scope.key], :weights => [0, amount])
+      temp_keys << inter
+      inter
+    end
+
+    key.zunionstore [key, *boost_keys]
+  end
+
+  def rescore(key, score)
+    return key  if score == 1.0
+    dest = key.include?('~') ? key : Ion.volatile_key
+    dest.zunionstore([key], weights: score)
+    dest
+  end
+
+  # Sets the TTL for the temp keys.
+  def expire
+    scopes.each { |s| s.send :expire }
+    Ion.expire key, *temp_keys
+  end
+
+  def combine(subkeys)
+    if @gate == :all
+      key.zinterstore subkeys
+    elsif @gate == :any
+      key.zunionstore subkeys
+    end
+  end
+
+  # Used by all_of and any_of
+  def subscope(args={}, &blk)
+    opts  = { :gate => @gate, :score => @score }
+    scope = Ion::Scope.new(@search, opts.merge(args), &blk)
+
+    subkeys     << scope.key
+    search_hash << scope.search_hash
+    scope
+  end
+end

data/lib/ion/search.rb

@@ -0,0 +1,83 @@
+class Ion::Search
+  include Enumerable
+
+  attr_reader :options
+  attr_reader :scope
+
+  def initialize(options, &blk)
+    @options = options
+    @scope   = Ion::Scope.new(self, &blk)
+  end
+
+  # Returns the model.
+  # @example
+  #
+  #   search = Album.ion.search { ... }
+  #   assert search.model == Album
+  #
+  def model
+    @options.model
+  end
+
+  # Returns a unique hash for the search.
+  def search_hash
+    require 'digest'
+    Digest::MD5.hexdigest @scope.search_hash.inspect
+  end
+
+  def range(args=nil)
+    @range = if args == :all
+        nil
+      elsif args.is_a?(Range)
+        args
+      elsif !args.is_a?(Hash)
+        @range
+      elsif args[:from] && args[:limit]
+        ((args[:from]-1)..(args[:from]-1 + args[:limit]-1))
+      elsif args[:page] && args[:limit]
+        (((args[:page]-1)*args[:limit])..((args[:page])*args[:limit]))
+      elsif args[:from] && args[:to]
+        ((args[:from]-1)..(args[:to]-1))
+      elsif args[:from]
+        ((args[:from]-1)..-1)
+      else
+        @range
+      end || (0..-1)
+  end
+
+  def to_a
+    ids.map &model
+  end
+
+  def each(&blk)
+    to_a.each &blk
+  end
+
+  def size
+    @scope.count
+  end
+
+  def yieldie(&blk)
+    @scope.yieldie &blk
+  end
+
+  def sort_by(what)
+    @scope.sort_by what
+  end
+
+  def ids
+    @scope.ids range
+  end
+
+  def key
+    @scope.key
+  end
+
+# Searching
+  
+protected
+  # Interal: called when the `Model.ion.search { }` block is done
+  def done
+    @scope.send :done
+  end
+end