redismodel 0.1.0

data/lib/redismodel.rb

@@ -0,0 +1,319 @@
+require 'rubygems'
+require 'md5'
+require 'date'
+require 'redis'
+require 'yaml'
+
+class DateTime
+  def inspect
+    self.to_s
+  end
+end
+
+class RedisModel
+  VERSION = '0.1.3'
+  DEFAULT_CONFIG = {
+    :atomic => true,
+    :default_sort => "created_at"
+  }
+  
+  module ArrayProxy
+    def <<(other)
+      tmp = self.dup.push(other)
+      @__model__.send(:set, @__property__, tmp)
+      super
+    end
+    
+    def push(other)
+      self << other
+    end
+  end
+  
+  module HashProxy
+    def []=(a,b)
+      tmp = self.dup
+      tmp[a] = b
+      @__model__.send(:set, @__property__, tmp)
+      super
+    end
+  end
+  
+  class InvalidRecord < RuntimeError; end
+  
+  def self.connection(klass)
+    hash = {}
+    [:host, :port].each{|v| hash[v] = klass.config[v] unless klass.config[v].nil?}
+    @connections ||= {}
+    @connections[klass.to_s] ||= Redis.new(hash)
+  end
+  
+  
+  # Casts a object type as a compatible type for redis, or reverses the process.
+  #
+  # Examples:
+  #   #cast( Integer, "1" ) => 1
+  #   #cast( Array, [1,2,3] ) => "[1,2,3]"
+  #   #cast( Hash, {:a => 1, 'b' => "2", :c => ['c']} ) => "--- \nb: \"2\"\n:c: \n- c\n:a: 1\n"
+  #   #cast( Hash, "--- \nb: \"2\"\n:c: \n- c\n:a: 1\n" ) => {"b"=>"2", :c=>["c"], :a=>1}
+  #
+  def self.cast(klass, value)
+    klass = klass.to_s
+    v_class = value.class.to_s
+        
+    if klass == "Integer" && v_class == "String"
+      value.to_i
+    elsif (klass == "Array" || klass == "Hash") && v_class == "String"
+      YAML.load(value)
+    elsif (klass == "Array" || klass == "Hash") && (klass == v_class)
+      value.to_yaml
+    elsif klass == "DateTime" && v_class == "String"
+      DateTime.parse(value)
+    elsif klass == "DateTime" && v_class == "DateTime"
+      value.to_s
+    else
+      value
+    end
+  end
+  
+  
+  class Model
+    # Local cache of the data
+    attr_accessor :_data
+
+    def redis
+      self.class.redis
+    end
+    
+        
+    def generate_uniq_token
+      "#{MD5.hexdigest("#{self.class.to_s.downcase}-#{self.object_id}-#{rand**rand}-#{Time.now.to_f}")}"
+    end
+    
+    
+    # Creates a new object. If `{:id => "..."}` is passed, it'll attempt to recover the record
+    # from the redis DB. If it can't find such a record, it'll raise RedisModel::RecordNotFound
+    def initialize(hash={})
+      @_data = {}
+      if hash[:id].nil?
+        
+        self.send("id=", generate_uniq_token)  
+        unless self.class.properties[:created_at].nil?
+          set :created_at, DateTime.now
+        end
+        hash.to_a.each do |property|
+          begin
+            self.send("#{property[0]}=", property[1])
+          rescue
+          end
+        end
+        redis.set "#{self.class}:#{id}:id", id
+        redis.incr "#{self.class}:_meta:count"
+        
+      else
+        
+        self.send("id=", hash[:id])
+        if get(:id).nil?
+          raise RedisModel::InvalidRecord
+        else
+          self.reload
+        end
+        
+      end
+    end
+    
+    
+    # Custom model inspect in the format of:
+    #   #<MyModel id: "8a80300a9b3251ec4d930f8ab5e381e2", created_at: "2010-08-01T01:32:11+01:00">
+    def inspect
+      "#<#{self.class} #{self.class.properties.to_a.map{|c| "#{c[0].to_s}: #{get(c[0]).inspect}"}.join(", ")}>"
+    end
+    
+    
+    # Updates all keys from redis
+    def reload
+      self.class.properties.each do |property|
+        self.get(property)
+      end
+      self
+    end
+    
+    
+    # Permamently deletes all traces of the record, and
+    # decrements the model count
+    def destroy
+      redis.keys("#{self.class}:#{id}:*").each do |key|
+        redis.del key
+      end
+      redis.decr "#{self.class}:_meta:count"
+    end
+    
+    
+    def id
+      @_data['id']
+    end
+    
+    
+    # Setter and getter for the config. Example:
+    #
+    #   class MyModel < RedisModel::Model
+    #     config :host => "1.2.3.4",
+    #            :port => 5678
+    #   end
+    #
+    def self.config(hash=nil)
+      @_config ||= DEFAULT_CONFIG
+      if hash.nil?
+        return @_config
+      else
+        @_config = @_config.merge(hash)
+        return true
+      end
+    end
+    
+    
+    # Defines a new property. Example:
+    #
+    #   class MyModel < RedisModel::Model
+    #     property :name, String
+    #     property :age, Integer
+    #   end
+    #
+    def self.property(name, type)
+      properties[:id] = String unless properties[:id]
+      properties[name] = type
+      class_eval do
+        define_method("#{name}=") do |str|
+          set(name, str)
+        end
+        
+        if type == Array || type == Hash
+          proxy = (type == Array) ? ArrayProxy : HashProxy 
+          define_method(name) do
+            value = get(name)
+            return value if value.is_a?(proxy)
+            value.tap do |value|
+              value.extend(proxy).instance_variable_set(:@__model__, self)
+              value.extend(proxy).instance_variable_set(:@__property__, name)
+            end
+          end
+        else
+          define_method(name) do 
+            get(name)
+          end
+        end
+        
+        eval "def self.find_by_#{name.to_s}(str); self.search('#{name.to_s}', str); end"
+      end
+    end
+    
+    
+    # Returns all records
+    def self.all
+      arr = []
+      redis.keys("#{klass}:*:id").each do |key|
+        arr << klass.find( key.split(":")[1] )
+      end
+      arr.sort_by{|m| m.send( DEFAULT_CONFIG[:default_sort] )}
+    end
+    
+    
+    # Finds a record from it's id
+    def self.find(id)
+      object = klass.new(:id => id)
+    end
+    
+    
+    # Returns all records where the value of `property` matches `str`
+    def self.search(property, value)
+      arr = []
+      self.all.each do |record|
+        if record.send(property) == value
+          arr << record
+        end
+      end
+      arr
+    end
+   
+
+    # Permamently deletes all records for the model
+    def self.destroy_all
+      redis.keys("#{klass}:*").each do |key|
+        redis.del key
+      end
+      true
+    end
+
+    
+    # Destroys all records with the ids passed
+    def self.destroy(*ids)
+      ids.each do |id|
+        klass.find(id).destroy
+      end
+    end
+        
+    
+    # Returns the number of records for the model
+    def self.count
+      redis.get("#{klass}:_meta:count").to_i
+    end
+
+
+    # Saves the Redis database to disk
+    def self.save!
+      redis.bgsave == "Background saving started"
+    end
+
+
+    protected
+    
+    # Writes a property value to redis, and updates #updated_at if required.
+    def set(property, value)
+      c = self.class.type(property)
+      value = RedisModel.cast c, value
+      redis.set "#{self.class}:#{id}:#{property}", value
+      @_data[property] = value
+      
+      unless property == :updated_at && !self.class.properties[:updated_at].nil?
+        set :updated_at, DateTime.now
+      end
+    end   
+    
+    # Fetches the value of `property` from redis
+    def get(property)
+      c = self.class.type(property)
+      value = RedisModel.cast c, redis.get("#{self.class}:#{id}:#{property}")
+      @_data[property] = value
+    end
+    
+    
+    # Returns the class of the extended model
+    def self.klass
+      @klass ||= self.ancestors.first
+    end
+    
+    
+    # Returns the property class declared in #property above
+    def self.type(property)
+      properties[property]
+    end
+    
+    
+    # Keeps track of the properties declared via #property
+    def self.properties
+      @_properties ||= {}
+    end
+    
+    
+    
+    # Alias for RedisModel#connection
+    def self.redis
+      RedisModel.connection(klass)
+    end
+    
+    
+    def id=(str)
+      @_data['id'] = str
+    end
+    
+  end
+end

data/test/benchmarks.rb

@@ -0,0 +1,43 @@
+require 'benchmark'
+Dir.glob("tests/models/*.rb").each{|f| require f}
+
+Person.destroy_all
+
+puts "Create 1 record"
+puts Benchmark.measure{
+  1.times do
+    Person.new(
+               :name => "ashley",
+               :age => 18
+              )
+  end
+}
+
+puts "Create 1_000 records"
+puts Benchmark.measure{
+  1_000.times do
+    Person.new(
+               :name => "ashley",
+               :age => 18
+              )
+  end
+}
+
+puts "Search #{Person.count} records"
+puts Benchmark.measure{
+  Person.search(:age, 18)
+}
+
+
+puts "Fetch all #{Person.count} records"
+puts Benchmark.measure{
+  @all = Person.all
+}
+
+
+puts "Destroy #{@all.size} records"
+puts Benchmark.measure{
+  @all.each do |r|
+    r.destroy
+  end
+}

data/test/class_mathod_tests.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class ClassMethodTests < Test::Unit::TestCase
+  def setup
+    Person.destroy_all
+    @person1 = Person.new(:name => "ashley", :age => 18)                        
+    @person2 = Person.new(:name => "ashley", :age => 18)   
+  end
+  
+  def test_find
+    assert Person.find(@person1.id).name == @person1.name
+  end
+  
+  def test_destroy_all
+    assert Person.count == 2
+    Person.destroy_all
+    assert Person.count == 0
+  end
+
+  def test_destroy
+    assert Person.count == 2
+    Person.destroy(@person1.id, @person2.id)
+    assert Person.count == 0
+    assert @person1.name == nil
+  end
+  
+  def test_all
+    all = Person.all
+    assert all.size == 2
+    assert all[0].name == @person1.name
+  end
+  
+  def test_search
+    Person.search(:age, 19)
+  end
+  
+  def test_properties
+    assert Person.properties.class == Hash
+    assert Person.properties.size > 0
+  end
+  
+  def test_save!
+    assert Person.save! == true
+  end
+end

data/test/models/person.rb

@@ -0,0 +1,12 @@
+class Person < RedisModel::Model
+  # config :host => "1.2.3.4",
+  #        :port => 5678
+  
+  property :name, String
+  property :age, Integer
+  property :dob, DateTime
+  property :favorite_games, Array
+  property :test_hash, Hash
+  property :created_at, DateTime
+  property :updated_at, DateTime
+end

data/test/property_type_tests.rb

@@ -0,0 +1,65 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class ColumnTypeTests < Test::Unit::TestCase
+  def setup
+    @person = Person.new(
+                         :name => "ashley",
+                         :age => 18,
+                         :dob => DateTime.parse("05-09-1991"),
+                         :favorite_games => ["Portal", "WoW", 101],
+                         :test_hash => {:a => 1, 'b' => "2", :c => ["Portal", 1, :c, [1,2,3]]}
+                        )
+  end
+  
+  # def teardown
+  #   Person.destroy_all
+  # end
+  
+  def test_string
+    assert @person.name == "ashley"
+  end
+  
+  def test_integer
+    assert @person.age == 18
+  end
+  
+  def test_datetime
+    assert @person.dob.class == DateTime
+    assert @person.dob.to_s == "1991-09-05T00:00:00+00:00"
+  end
+  
+  def test_array
+    assert @person.favorite_games == ["Portal", "WoW", 101]
+  end
+  
+  def test_add_to_array_left_left
+    @person.favorite_games << "Awesome"
+    assert @person.favorite_games.size == 4
+  end
+  
+  def test_add_to_array_push
+    @person.favorite_games.push("Awesome")
+    assert @person.favorite_games.size == 4
+  end
+  
+  def test_hash
+    assert @person.test_hash == {:a => 1, 'b' => "2", :c => ["Portal", 1, :c, [1,2,3]]}
+  end
+  
+  def test_add_key_to_hash
+    @person.test_hash[:add] = 123
+    assert @person.test_hash[:add] == 123
+  end
+  
+  def test_id
+    assert @person.id.size == 32
+  end
+  
+  def test_created_at
+    assert @person.created_at.class == DateTime
+  end
+  
+  def test_updated_at
+    assert @person.updated_at.class == DateTime
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+require 'stringio'
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/redismodel' unless defined? RedisModel
+Dir.glob("test/models/*.rb").each{|f| require f}
+Dir.glob("test/*_tests.rb").each{|f| require f}

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: redismodel
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Ashley Williams
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-02 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: redis
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 4
+        version: 2.0.4
+  type: :runtime
+  version_requirements: *id001
+description: Syncs ruby objects with Redis
+email: a.j.r.williams@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/redismodel.rb
+- test/benchmarks.rb
+- test/class_mathod_tests.rb
+- test/models/person.rb
+- test/property_type_tests.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/ashleyw/RedisModel
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Atomic object syncing with Redis
+test_files: []
+