easyredis 0.0.5 → 0.0.6

data/Manifest

@@ -5,4 +5,4 @@ Rakefile
 easyredis.gemspec
 lib/easyredis.rb
 tests/benchmark.rb
-tests/test.rb
+tests/man.rb

data/README.md

@@ -14,9 +14,7 @@ Or, you can get the source with git:
 
     $ git clone git://github.com/alecbenzer/easyredis.git
 
-or just download and extract a tar archive with the Downloads button.
-
-Once you have the source, you can run:
+and run:
 
     $ rake manifest
     $ rake build_gemspec
@@ -53,17 +51,16 @@ Or, we can choose our own ids:
 
     p = Post.new("coolpost")
     p.title = "A Cool Post"
-    p.body = "This post has a high level of coolnes."
+    p.body = "This post has a high level of coolness."
 
     p2 = Post.find("coolpost")  # this is a very fast lookup
     p2.title  # => "A Cool Post"
 
 We also get a created_at field for free that we can sort by.
 
-    p.created_at  # a ruby Time object
-    Post.all  # get all posts, ordered by creation time
-    Post.all :order => :desc  # specifying an order option
-    Post[41]  # the 42nd (0-based indexing) post that was created
+    p.created_at              # a ruby Time object
+    Post.all :order => :desc  # all posts ordered by descending time
+    Post[n]                   # the nth (0-based indexing) post that was created
     
 ## Searching and Sorting
 
@@ -85,18 +82,18 @@ And also search:
     Post.search_by :title, "A common title"  # all posts with this title
     Post.find_by :title, "My First Post"  # just one post
 
-## Text Search and Completions
+## Implicit References
 
-We could have defined Post like this:
+You may have noticed fields have not been given any types. EasyRedis automatically tracks the type of a field based on the type of data you assign it.
 
-    class Post < EasyRedis::Model
-      field :title
-      field :body
+This works for references, too:
 
-      text_search :title
+    class Comment < EasyRedis::Model
+      field :text
+      field :post
     end
-
-Now we can perform text searches and completions against our title field:
-
-    Post.matches(:title,"Fir")  # titles that begin with "Fir"
-    Post.match(:title,"First")  # posts whose titles contain "First"
+    
+    c = Comment.new
+    c.text = "A comment!"
+    
+    c.post = Post[0]

data/Rakefile

@@ -2,9 +2,9 @@ require 'rubygems'
 require 'rake'
 require 'echoe'
 
-Echoe.new('easyredis','0.0.5') do |p|
+Echoe.new('easyredis','0.0.6') do |p|
   p.description = "framework designed to make using redis as a database simpler"
-  p.url = "https://github.com/alecbenzer/easyredis"
+  p.url = "http://alecbenzer.github.com/easyredis/"
   p.author = "Alec Benzer"
   p.email = "alecbezer @nospam@ gmail.com"
   p.ignore_pattern = ["*.rdb"]
@@ -13,7 +13,7 @@ end
 
 
 require 'benchmark'
-require './tests/test'
+require './tests/man'
 
 def rand_name(length=2)
   chars = []
@@ -24,14 +24,14 @@ end
 
 namespace :bm do
   task :clear do
-    puts "destroying #{Man.count} previous entries"
+    puts "destroying #{Man.count} previous entries (sec)"
     time = Benchmark.measure { Man.destroy_all }
     puts time.format
   end
 
   task :add do
     count = ENV["count"] ? ENV["count"].to_i : 25000
-    puts "adding #{count} new entries"
+    puts "adding #{count} new entries (sec)"
     time = Benchmark::Tms.new
     length = Math.log(3*count,26).round
     count.times do
@@ -49,7 +49,7 @@ namespace :bm do
     name = Man.rand.name
     count = -1
     time = Benchmark.measure { count = Man.search_by(:name,name).count }
-    puts "retrived #{count} records in:"
+    puts "retrived #{count} records in (ms):"
     puts (time*1000).format
   end
 
@@ -59,9 +59,9 @@ namespace :bm do
     age = rand(100)
     t1 = Benchmark.measure { Man.search(:age => age) }
     t2 = Benchmark.measure { Man.search_by(:age,age) }
-    puts "Model#search:"
+    puts "Model#search (ms):"
     puts (t1*1000).format
-    puts "Model#search_by:"
+    puts "Model#search_by (ms):"
     puts (t2*1000).format
     puts "search is #{((t1.real/t2.real) - 1)*100}% slower"
   end
@@ -72,15 +72,17 @@ namespace :bm do
     age = man.age
     count = 0
     time = Benchmark.measure { count = Man.search(:name => name, :age => age).size }
-    puts "retrived #{count} out of #{Man.count} entries in:"
+    puts "retrived #{count} out of #{Man.count} entries in (ms):"
     puts (time*1000).format
   end
 
   task :find do
-    puts "finding one of #{Man.count} entries by name"
+    puts "finding one of #{Man.count} entries by name (ms)"
     name = Man.rand.name
     time = Benchmark.measure { Man.find_by(:name,name) }
     puts (time*1000).format
   end
 
+  task :all => [:populate, :search, :multisearch, :find]
+
 end

data/easyredis.gemspec

@@ -2,20 +2,20 @@
 
 Gem::Specification.new do |s|
   s.name = %q{easyredis}
-  s.version = "0.0.5"
+  s.version = "0.0.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["Alec Benzer"]
-  s.date = %q{2011-02-09}
+  s.date = %q{2011-05-16}
   s.description = %q{framework designed to make using redis as a database simpler}
   s.email = %q{alecbezer @nospam@ gmail.com}
   s.extra_rdoc_files = ["LICENSE", "README.md", "lib/easyredis.rb"]
-  s.files = ["LICENSE", "Manifest", "README.md", "Rakefile", "easyredis.gemspec", "lib/easyredis.rb", "tests/benchmark.rb", "tests/test.rb"]
-  s.homepage = %q{https://github.com/alecbenzer/easyredis}
+  s.files = ["LICENSE", "Manifest", "README.md", "Rakefile", "easyredis.gemspec", "lib/easyredis.rb", "tests/benchmark.rb", "tests/man.rb"]
+  s.homepage = %q{http://alecbenzer.github.com/easyredis/}
   s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Easyredis", "--main", "README.md"]
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{easyredis}
-  s.rubygems_version = %q{1.5.0}
+  s.rubygems_version = %q{1.6.2}
   s.summary = %q{framework designed to make using redis as a database simpler}
 
   if s.respond_to? :specification_version then

data/lib/easyredis.rb

@@ -12,7 +12,7 @@ require 'set'
 # main EasyRedis module which
 # holds all classes and helper methods
 module EasyRedis
-  
+
   # generate a 'score' for a string
   # used for storing it in a sorted set
   #
@@ -81,10 +81,10 @@ module EasyRedis
     end
   end
 
-  # exception that indicates that the given field has not been indexed for text-searching
-  class FieldNotTextSearchable < RuntimeError
+  # exception that indicates that the given field has not been indexed for sorting/searching
+  class FieldNotSearchable < RuntimeError
     def initialize(field)
-      @message = "field '#{field.to_s}' not text-searchable"
+      @message = "field '#{field.to_s}' not searchable"
     end
     
     def to_s
@@ -92,6 +92,17 @@ module EasyRedis
     end
   end
 
+  # exception that indicates that the given field has not been indexed for text-searching
+  # class FieldNotTextSearchable < RuntimeError
+  #  def initialize(field)
+  #    @message = "field '#{field.to_s}' not text-searchable"
+  #  end
+  #  
+  #  def to_s
+  #    @message
+  #  end
+  # end
+
   # exception that indicated an unknown ordering option was encountered
   class UnknownOrderOption < RuntimeError
     def initialize(opt)
@@ -107,6 +118,10 @@ module EasyRedis
   class Collection
     include Enumerable
 
+    def initialize(&p)
+      @access = p
+    end
+
     # access elements in this sort
     #
     # Work's like an Array's [] method. It can take a specific index, a range, or an offset and an amount/limit.
@@ -151,71 +166,33 @@ module EasyRedis
       end
     end
 
-    private
-
-    # access the elements corresponding to the given range
-    #
-    # meant to be overridden in child classes
-    def access(range)
-      []
-    end
-
-  end
-
-  # class representing a sort
-  class Sort < Collection
-
-    # initialize the sort with a specific field, ordering option, and model
-    #
-    # @param [Symbol] field a symbol corresponding to a field of klass
-    # @param [:asc, :desc] order a symbol specifying to sort in either ascending or descending order
-    # @param [Class] klass the klass whose entries we are accessing
-    def initialize(field,order,klass)
-      raise EasyRedis::FieldNotSortable, field  unless klass.sortable?(field) 
-      raise EasyRedis::UnknownOrderOption, order  unless [:asc,:desc].member? order
-      @field = field
-      @order = order
-      @klass = klass
-    end
-
-    # return the number of elements in this sort
-    #
-    # As of now, idential to the Model's count method.
-    # This method is explicility defined here to overwrite the default one in Enumerable, which iterates through all the entries to count them, which is much slower than a ZCARD command
-    def count
-      @count ||= EasyRedis.redis.zcard(@klass.sort_key(@field))
-      @count
-    end
-
     def inspect
-      "#<EasyRedis::Sort model=#{@klass.name}, field=#{@field.to_s}, order=#{@order.to_s}>"
+      "#<EasyRedis::Collection>"
     end
 
     private
 
-    # takes a range and returns corresponding elements
+    # access the elements corresponding to the given range
+    #
+    # meant to be overridden in child classes
     def access(range)
-      a = range.begin
-      b = range.end
-      b -= 1 if range.exclude_end?
-      ids = []
-      if @order == :asc
-        ids = EasyRedis.redis.zrange(@klass.sort_key(@field),a,b)
-      elsif @order == :desc
-        ids = EasyRedis.redis.zrevrange(@klass.sort_key(@field),a,b)
+      if @access
+        @access[range]
+      else
+        []
       end
-      ids.map{|i|@klass.build(i)}
     end
 
   end
 
-
   # class representing a data model
   # you want to store in redis
   class Model
     
     @@sorts = []
-    @@text_searches = []
+    @@searches = []
+    @@types = {}
+    # @@text_searches = []
 
     # add a field to the model
     #
@@ -233,42 +210,77 @@ module EasyRedis
         if prev
           prev
         else
-          instance_variable_set(instance_var,Marshal.load(EasyRedis.redis.hget(key_name,name)))
+          data = EasyRedis.redis.hget(key_name,name)
+          type = get_type(name)
+          if type == 'int'
+            data = data.to_i
+          elsif type == 'flt'
+            data = data.to_f
+          elsif type == 'str'
+            data = data.to_s
+          elsif type.match /^model:/
+            klass = eval(type[6..-1])
+            data = klass.find(data)
+          end
+          instance_variable_set(instance_var,data)
         end
       end
 
       define_method setter.to_sym do |val|
-        EasyRedis.redis.hset(key_name,name,Marshal.dump(val))
         instance_variable_set(instance_var,val)
+        if val.is_a? Fixnum
+          set_type(name,'int')
+        elsif val.is_a? Float
+          set_type(name,'flt')
+        elsif val.is_a? String
+          set_type(name,'str')
+        elsif val.is_a? EasyRedis::Model
+          set_type(name,"model:#{val.class.name}")
+          val = val.id
+        end # TODO: else.... marshall it
+        EasyRedis.redis.hset(key_name,name,val)
 
         if self.class.sortable? name.to_sym
           EasyRedis.redis.zadd(sort_key(name),EasyRedis.score(val),@id)
         end
 
-        if self.class.text_search? name.to_sym
-          val.split.each do |term|
-            EasyRedis.redis.zadd term_key(name,term), created_at.to_i, id
-            EasyRedis.redis.zadd terms_key(name), EasyRedis.score(term), term
-          end
+        if self.class.searchable? name
+          EasyRedis.redis.sadd(search_key(name,val),@id)
         end
+
+        #if self.class.text_search? name.to_sym
+        #  val.split.each do |term|
+        #    EasyRedis.redis.zadd term_key(name,term), created_at.to_i, id
+        #    EasyRedis.redis.zadd terms_key(name), EasyRedis.score(term), term
+        #  end
+        #end
       end
     end
 
-    # index a field to be sorted/searched
+    # index a field to be sorted
     #
     # @param (see #field)
     def self.sort_on(field)
       @@sorts << field.to_sym
+      nil
     end
 
-    # index a field for text searching
+    # index a field to be searched (with exact matches)
     #
     # @param (see #field)
-    def self.text_search(field)
-      @@text_searches << field.to_sym
-      sort_on(field) unless sortable? field
+    def self.search_on(field)
+      @@searches << field.to_sym
+      nil
     end
 
+    # index a field for text searching
+    #
+    # @param (see #field)
+    # def self.text_search(field)
+    #  @@text_searches << field.to_sym
+    #  sort_on(field) unless sortable? field
+    # end
+
     # returns number of instances of this model
     def self.count
       EasyRedis.redis.zcard(prefix)
@@ -296,10 +308,15 @@ module EasyRedis
     end
 
     # find an entry of this model based on its id
+    # OR, find an entry based on field/value pairs in a hash
+    # (current only works with one pair)
     #
-    # @param [Integer] id the id of the entry to retrive
+    # @param [Integer,Hash] id the id of the entry to retrive, or a hash of field/value pairs
     def self.find(id)
-      if EasyRedis.redis.zscore(prefix,id)
+      if id.is_a? Hash
+        pair = id.to_a.first
+        self.find_by(pair[0],pair[1]) # TODO: add support for multiple field/value pairs
+      elsif EasyRedis.redis.zscore(prefix,id)
         build(id)
       else
         nil
@@ -318,10 +335,10 @@ module EasyRedis
     # @param [Symbol] field a symbol representing the field to search on
     # @param val the value of field to search for
     def self.search_by(field, val, options = {})
-      raise EasyRedis::FieldNotSortable, field unless @@sorts.member? field.to_sym
-      scr = EasyRedis.score(val)
+      # scr = EasyRedis.score(val)
       # options[:limit] = [0,options[:limit]] if options[:limit]
-      ids = EasyRedis.redis.zrangebyscore(sort_key(field),scr,scr,proc_options(options))
+      # ids = EasyRedis.redis.zrangebyscore(sort_key(field),scr,scr,proc_options(options))
+      ids = EasyRedis.redis.smembers(search_key(field,val))
       ids.map{|i| build(i) }
     end
 
@@ -329,67 +346,92 @@ module EasyRedis
     #
     # @param (see #search_by)
     def self.find_by(field,val)
-      search_by(field,val,:limit => 1).first
+      i = EasyRedis.redis.srandmember(search_key(field,val))
+      build(i) if i
     end
 
     # search the model based on multiple parameters
     #
     # @param [Hash] params a hash of field => value pairs
     def self.search(params)
-      return search_by(*params.first) if params.size == 1  # comment out for benchmarking purposes
-      result_set = nil
-      params.each do |field,value|
-        scr = EasyRedis.score(value)
-        ids = EasyRedis.redis.zrangebyscore(sort_key(field),scr,scr)
-        result_set = result_set ? (result_set & Set.new(ids)) : Set.new(ids)
+      return search_by(*params.first) if params.size == 1
+      if params.all? {|f,v| searchable? f }
+        ids = EasyRedis.redis.sinter(*params.map{|k,v|search_key(k,v)})
+        ids.map{|i|build(i)}
+      elsif params.all? {|f,v| sortable? f}
+        result_set = nil
+        params.each do |field,value|
+          scr = EasyRedis.score(value)
+          ids = EasyRedis.redis.zrangebyscore(sort_key(field),scr,scr)
+          result_set = result_set ? (result_set & Set.new(ids)) : Set.new(ids)
+        end
+        result_set.map{|i|build(i)}
+      else
+        raise "fields must all be searchable or all be sortable"
       end
-      result_set.map{|i|build(i)}
     end
 
     # get all entries, sorted by the given field
     def self.sort_by(field,options = {:order => :asc})
-      EasyRedis::Sort.new(field,options[:order],self)
+      raise EasyRedis::FieldNotSortable unless self.sortable? field
+      EasyRedis::Collection.new do |range|
+        a = range.begin
+        b = range.end
+        b -= 1 if range.exclude_end?
+        ids = []
+        if options[:order] == :asc
+          ids = EasyRedis.redis.zrange(sort_key(field),a,b)
+        elsif options[:order] == :desc
+          ids = EasyRedis.redis.zrevrange(sort_key(field),a,b)
+        end
+        ids.map{|i| build(i)}
+      end
     end
 
     # gives all values for the given field that begin with str
     #
     # @param [Symbol] field a symbol representing a field indexed with text_search.
-    def self.matches(field,str)
-      raise FieldNotTextSearchable, field unless self.text_search? field
-      scr = EasyRedis.score(str)
-      a,b = scr, scr+1/(27.0**str.size)
-      EasyRedis.redis.zrangebyscore(terms_key(field), "#{a}", "(#{b}")
-    end
+    # def self.matches(field,str)
+    #  raise EasyRedis::FieldNotTextSearchable, field unless self.text_search? field
+    #  scr = EasyRedis.score(str)
+    #  a,b = scr, scr+1/(27.0**str.size)
+    #  EasyRedis.redis.zrangebyscore(terms_key(field), "#{a}", "(#{b}")
+    # end
 
     # searches for all entries where field contains the string str
     #
     # The string must appear exactly as a term in field's value. To search based on the beginning of a term, you can combine this method with matches.
     # The field must have been indexed with text_search.
-    def self.match(field,str, options = {})
-      raise EasyRedis::FieldNotTextSearchable, filename unless text_search? field
-      ids = EasyRedis.redis.zrange(term_key(field,str), 0, -1, proc_options(options))
-      ids.map{|i| build(i)}
-    end
+    # def self.match(field,str, options = {})
+    #  raise EasyRedis::FieldNotTextSearchable, filename unless text_search? field
+    #  ids = EasyRedis.redis.zrange(term_key(field,str), 0, -1, proc_options(options))
+    #  ids.map{|i| build(i)}
+    # end
 
     # indicates whether field has been indexed with sort_on
     def self.sortable?(field)
       @@sorts and (@@sorts.member? field or field.to_sym == :created_at)
     end
 
-    # indicates whether field has been indexed with text_search
-    def self.text_search?(field)
-      @@text_searches and @@text_searches.member?(field)
+    # indicates whether field has been indexed with sort_on
+    def self.searchable?(field)
+      @@searches and @@searches.member? field.to_sym
     end
 
+    # indicates whether field has been indexed with text_search
+    # def self.text_search?(field)
+    #  @@text_searches and @@text_searches.member?(field)
+    # end
+
     # destroy all instances of this model
     def self.destroy_all
       all.each {|x| x.destroy}
       @@sorts.each {|field| EasyRedis.redis.del(sort_key(field)) }
-      @@text_searches.each {|field| EasyRedis.redis.del(terms_key(field)) }
+      # @@text_searches.each {|field| EasyRedis.redis.del(terms_key(field)) }
       EasyRedis.redis.del(prefix)
       EasyRedis.redis.del(prefix + ":next_id")
     end
-    
+
 
     # the id of this entry
     attr_reader :id
@@ -489,6 +531,10 @@ module EasyRedis
       end
     end
 
+    def self.search_key(field,value)
+      "#{prefix}:search_#{field}:#{value}"
+    end
+
     def self.terms_key(field)
       "#{prefix}:terms_#{field.to_s}"
     end
@@ -497,6 +543,23 @@ module EasyRedis
       "#{prefix}:term_#{field}:#{term}"
     end
 
+    def self.type_key(field)
+      "#{prefix}:type_#{field}"
+    end
+
+    def self.get_type(field)
+      if @@types[field]
+        @@types[field]
+      else
+        @@types[field] = EasyRedis.redis.get(type_key(field))
+      end
+    end
+
+    def self.set_type(field,type)
+      EasyRedis.redis.set(type_key(field),type)
+      @@types[field] = type
+    end
+
     def prefix
       self.class.prefix
     end
@@ -505,6 +568,10 @@ module EasyRedis
       self.class.sort_key(field)
     end
 
+    def search_key(field,val)
+      self.class.search_key(field,val)
+    end
+
     def terms_key(field)
       self.class.terms_key(field)
     end
@@ -512,5 +579,18 @@ module EasyRedis
     def term_key(field,term)
       self.class.term_key(field,term)
     end
+
+    def type_key(field)
+      self.class.type_key(field)
+    end
+
+    def get_type(field)
+      self.class.get_type(field)
+    end
+
+    def set_type(field,type)
+      self.class.set_type(field,type)
+    end
+
   end
 end

data/tests/{test.rb → man.rb}

@@ -4,8 +4,8 @@ class Man < EasyRedis::Model
   field :name
   field :age
 
-  text_search :name
-  sort_on :age
+  search_on :name
+  search_on :age
 end
 
 EasyRedis.connect

metadata

@@ -2,7 +2,7 @@
 name: easyredis
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors: 
 - Alec Benzer
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-09 00:00:00 -05:00
+date: 2011-05-16 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -42,9 +42,9 @@ files:
 - easyredis.gemspec
 - lib/easyredis.rb
 - tests/benchmark.rb
-- tests/test.rb
+- tests/man.rb
 has_rdoc: true
-homepage: https://github.com/alecbenzer/easyredis
+homepage: http://alecbenzer.github.com/easyredis/
 licenses: []
 
 post_install_message: 
@@ -72,7 +72,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: easyredis
-rubygems_version: 1.5.0
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: framework designed to make using redis as a database simpler