redis-model-extension 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,19 @@
+source "http://rubygems.org"
+
+gem "redis"
+gem "i18n", "~> 0.6.0"
+gem "activesupport", "~> 3.1.0"
+gem "rake"
+gem "rack", "~> 1.3.0"
+
+group :development do
+  gem "shoulda", ">= 0"
+  gem 'shoulda-context'
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.8.3"
+  gem "turn", "~> 0.8.2"
+  gem "minitest"
+  gem "ansi", "~> 1.2.5"
+end
+

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Ondrej Bartas
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,50 @@
+# Redis Model
+
+Redis model is basic implementation of few methods for creating model which store data in Redis
+
+## Usage
+
+``` ruby
+class TestRedisModel
+  REDIS_MODEL_CONF = {
+     :fields => { 
+       :integer => :to_i,
+       :boolean => :to_bool,
+       :string => :to_s,
+       :symbol => :to_sym,
+      }, 
+      :required => [:integer, :string],
+      :redis_key => [:string],
+      :redis_aliases => {
+        :token => [:symbol]
+      }
+   }
+   include RedisModel
+   initialize_redis_model_methods REDIS_MODEL_CONF
+end
+
+foo = TestRedisModel.new()
+```
+
+Now you can easily access all attributes from TestRedisModel by `foo.integer` or exists? `foo.integer?` or set value by `foo.integer = 1234` 
+
+You can initialize model by `foo = TestRedisModel.new(:integer => 123, :string => "bar")` and then access it same as above.
+
+Saving is easy too: `foo.save` -> It will raise exception if :required attributes aren't filled. Error message says what is missing.
+
+
+
+## Contributing to redis-model-extension
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2012 Ondrej Bartas. See LICENSE.txt for
+further details.

data/Rakefile

@@ -0,0 +1,90 @@
+# encoding: utf-8
+ENV['RACK_ENV'] ||= "development"
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "redis-model-extension"
+  gem.homepage = "http://github.com/ondrejbartas/redis-model-extension"
+  gem.license = "MIT"
+  gem.summary = %Q{Redis model is basic implementation of creating, finding, updating and deleting model which store data in Redis.}
+  gem.description = %Q{It provides functions as find, find_by_alias, get, exists?, validate, save etc.}
+  gem.email = "ondrej@bartas.cz"
+  gem.authors = ["Ondrej Bartas"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+
+#get directories!
+PIDS_DIR = File.expand_path(File.join("..", "tmp","pid"), __FILE__)
+CONF_DIR = File.expand_path(File.join("..", "config"), __FILE__)
+#create directory for pid files
+FileUtils.mkdir_p(PIDS_DIR) unless File.exists?(PIDS_DIR)
+REDIS_PID = File.join(PIDS_DIR, "redis.pid")
+
+#copy example config files for redis and elastic if they don't exists
+FileUtils.cp(File.join(CONF_DIR, "redis_config.yml.example"), File.join(CONF_DIR, "redis_config.yml") ) unless File.exists?(File.join(CONF_DIR, "redis_config.yml")) 
+
+#for testing purposes use 
+REDIS_CNF = File.join(File.expand_path(File.join("..","config"), __FILE__), "redis_setup.conf")
+
+desc "Run tests and manage databases start/stop"
+task :run => [:'redis:start', :test, :'redis:stop']
+
+desc "Start databases"
+task :startup => [:'redis:start']
+
+desc "Teardown databases"
+task :teardown => [:'redis:stop']
+
+Rake::TestTask.new(:test) do |t|
+  t.test_files = FileList['test/functional/*_test.rb', 'test/unit/*_test.rb','test/integration/*_test.rb']
+  t.warning = false
+  t.verbose = false
+end
+
+namespace :redis do
+  desc "Start the Redis server"
+  task :start do
+    redis_running = \
+    begin
+      File.exists?(REDIS_PID) && Process.kill(0, File.read(REDIS_PID).to_i)
+    rescue Errno::ESRCH
+      FileUtils.rm REDIS_PID
+      false
+    end
+    system "pwd"
+    puts system "redis-server #{REDIS_CNF}" unless redis_running
+    puts "redis started"
+  end
+
+  desc "Stop the Redis server"
+  task :stop do
+    if File.exists?(REDIS_PID)
+      Process.kill "INT", File.read(REDIS_PID).to_i
+      FileUtils.rm REDIS_PID
+      puts "redis stopped"
+    end
+  end
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/config/redis_config.yml.example

@@ -0,0 +1,16 @@
+test:
+  host: "127.0.0.1"
+  port: 6379
+  db: 3
+development:
+  host: "127.0.0.1"
+  port: 6379
+  db: 0
+stage:
+  host: "127.0.0.1"
+  port: 6379
+  db: 0
+production:
+  host: "127.0.0.1"
+  port: 6379
+  db: 0

data/config/redis_setup.conf

@@ -0,0 +1,9 @@
+dir tmp
+pidfile ./pid/redis.pid
+port 6379
+unixsocket /tmp/redis.sock
+timeout 300
+loglevel debug
+logfile stdout
+databases 16
+daemonize yes

data/lib/database.rb

@@ -0,0 +1,19 @@
+# -*- encoding : utf-8 -*-
+#Wrapper for redis connection
+#============================
+#Creates only one connection to redis per application in first time it needs to work with redis
+module Database
+
+  def self.config
+    if File.exists?('config/redis_config.yml')
+      YAML.load_file('config/redis_config.yml')[ENV['RACK_ENV'] || 'development'].symbolize_keys
+    else
+      raise ArgumentError, "Redis configuration file does not exists -> 'config/redis_config.yml', please provide it"
+    end
+  end
+  
+  def self.redis
+    @redis ||= Redis.new(Database.config)
+  end
+
+end

data/lib/redis-model-extension.rb

@@ -0,0 +1,295 @@
+# -*- encoding : utf-8 -*-
+require 'pp'
+require 'redis'
+require 'active_support'
+require 'active_support/inflector'
+require 'active_support/inflector/inflections'
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/class/inheritable_attributes'
+require 'string_to_bool'
+require 'database'
+
+module RedisModel
+
+  attr_accessor :args, :error, :old_key, :conf
+  
+  def self.included(base) 
+    base.send :extend, ClassMethods         
+    base.send :include, InstanceMethods  
+  end
+  
+  module ClassMethods
+    
+    def initialize_redis_model_methods conf
+      @conf = conf
+      #take all fields and make methods for them
+      conf[:fields].each do |attr, action|
+        define_method "#{attr}" do
+          if self.args[attr] || self.args[attr] == false #== false is a fi for boolean variable
+            self.args[attr].to_s.send(action)
+          else
+            nil
+          end
+        end
+        
+        define_method "#{attr}=" do |item|
+          self.args[attr] = item
+        end
+        
+        define_method "#{attr}?" do
+          !self.args[attr].nil?
+        end
+      end  
+    end
+    
+    def conf
+      @conf
+    end
+    
+    #Generates redis key for storing object
+    def generate_key(args = {})
+      out = "#{self.name.to_s.downcase.to_sym}"
+      @conf[:redis_key].each do |key|
+        if args.has_key?(key)
+          out += ":#{args[key]}"
+        else
+          out += ":*"
+        end
+      end
+      out
+    end
+    
+    #Generates redis key for storing indexes for aliases
+    def generate_alias_key(alias_name, args = {})
+      out = "#{self.name.to_s.downcase.to_sym}:#{alias_name}"
+      @conf[:redis_aliases][alias_name.to_sym].each do |key|
+        if args.has_key?(key)
+          out += ":#{args[key]}"
+        else
+          out += ":*"
+        end
+      end
+      out
+    end
+    
+    #Validates if key by arguments is valid
+    def valid_key?(args = {})
+      full_key = true
+      @conf[:redis_key].each do |key|
+        full_key = false if !args.has_key?(key) || args[key].nil?
+      end
+      full_key
+    end
+
+    #Validates if key by alias name and arguments is valid
+    def valid_alias_key?(alias_name, args = {})
+      full_key = true
+      @conf[:redis_aliases][alias_name.to_sym].each do |key|
+        full_key = false if !args.has_key?(key) || args[key].nil?
+      end
+      full_key
+    end
+
+    #Check if key by arguments exists in db
+    def exists?(args = {})
+      Database.redis.exists(self.name.constantize.generate_key(args))
+    end
+
+    #Check if key by alias name and arguments exists in db
+    def alias_exists?(alias_name, args = {})
+      Database.redis.exists(self.name.constantize.generate_alias_key(alias_name, args))
+    end
+
+    #Wrapper around find to get all instances
+    def all
+      self.find({})
+    end
+
+    #Find method for searching in redis
+    def find(args = {})
+      args.symbolize_keys!
+      out = []
+      klass = self.name.constantize
+      
+      #is key specified directly? -> no needs of looking for other keys! -> faster
+      if klass.valid_key?(args)
+        out << klass.new(args.merge(Database.redis.hgetall(klass.generate_key(args))).merge({:old_key => klass.generate_key(args)})) if klass.exists?(args)
+      else
+        Database.redis.keys(klass.generate_key(args)).each do |key|
+          out << klass.new(args.merge(Database.redis.hgetall(key)).merge({:old_key => key}))
+        end
+      end
+      out
+    end
+
+    #Find method for searching in redis
+    def find_by_alias(alias_name, args = {})
+      args.symbolize_keys!
+      out = []
+      klass = self.name.constantize
+      
+      #is key specified directly? -> no needs of looking for other keys! -> faster
+      if klass.valid_alias_key?(alias_name, args)
+        out << klass.get_by_alias(alias_name, args) if klass.alias_exists?(alias_name, args)
+      else
+        Database.redis.keys(klass.generate_alias_key(alias_name, args)).each do |key|
+          out << klass.get_by_alias_key(key)
+        end
+      end
+      out
+    end
+
+    #fastest method to get object from redis by getting it by arguments
+    def get(args = {})
+      args.symbolize_keys!
+      klass = self.name.constantize
+      if klass.valid_key?(args)
+        klass.new(args.merge(Database.redis.hgetall(klass.generate_key(args))).merge({:old_key => klass.generate_key(args)})) if klass.exists?(args)
+      else
+        nil
+      end
+    end    
+
+    #fastest method to get object from redis by getting it by alias and arguments
+    def get_by_alias(alias_name, args = {})
+      args.symbolize_keys!
+      klass = self.name.constantize
+      if klass.valid_alias_key?(alias_name, args) && klass.alias_exists?(alias_name, args)
+        key = Database.redis.get(klass.generate_alias_key(alias_name, args))
+        if Database.redis.exists(key)
+          klass.new(args.merge(Database.redis.hgetall(key)).merge({:old_key => key})) 
+        else
+          nil
+        end
+      else
+        nil
+      end
+    end    
+
+    #fastest method to get object from redis by getting it by alias and arguments
+    def get_by_alias_key(alias_key)
+      klass = self.name.constantize
+      if Database.redis.exists(alias_key)
+        key = Database.redis.get(alias_key)
+        if Database.redis.exists(key)
+          klass.new(args.merge(Database.redis.hgetall(key)).merge({:old_key => key}))
+        else
+          nil
+        end
+      else
+        nil
+      end
+    end    
+
+  end
+    
+  module InstanceMethods
+    
+    def initialize(args={})
+      args.symbolize_keys!
+      #if old_key is specified, don't usi it in args hash
+      if args[:old_key] && args[:old_key].size > 0 
+        self.old_key = args[:old_key] 
+        args.delete(:old_key)
+      end
+      self.args = clear_args(args)
+      return self
+    end
+    
+    #Fixing some problems with saving nil into redis and clearing input arguments
+    def clear_args(args)
+      args.symbolize_keys!
+      out_args = {}
+      args.each do |key, value|
+        if self.class.conf[:fields].keys.include?(key) #don't use arguments wich aren't specified in :fields 
+          if value.nil? || value.to_s.size == 0 #change nil and zero length string into nil
+            out_args[key] = nil 
+          else
+            out_args[key] = value
+          end
+        end
+      end
+      out_args
+    end
+    
+    #validates required attributes
+    def valid?
+      @error = []
+      self.class.conf[:required].each do |key|
+        if !self.args.has_key?(key) || self.args[key].nil?
+          @error.push("Required #{key}")
+        end
+      end
+      @error.size == 0
+    end
+  
+    #return error from validation
+    def errors 
+      @errors
+    end
+  
+    #take all arguments and send them out
+    def to_arg
+      self.args
+    end
+  
+    #if this record exists in database
+    def exists?
+      Database.redis.exists(self.class.generate_key(self.args))
+    end
+
+    #remove record form database
+    def destroy!
+      if exists?
+        #destroy main object
+        Database.redis.del(generate_key) 
+        destroy_aliases!
+      end
+    end
+
+    #remove all aliases
+    def destroy_aliases!
+      self.class.conf[:redis_aliases].each do |alias_name, fields|
+        Database.redis.del(self.class.generate_alias_key(alias_name, self.args)) if self.class.alias_exists?(alias_name, self.args)
+      end
+    end
+    
+    #Method for creating aliases
+    def create_aliases
+      main_key = redis_key
+      self.class.conf[:redis_aliases].each do |alias_name, fields|
+        Database.redis.set(self.class.generate_alias_key(alias_name, self.args), main_key)
+      end
+    end
+  
+    #get redis key for instance
+    def redis_key
+      self.class.generate_key(self.args)
+    end
+    
+    #get redis key for instance alias
+    def redis_alias_key(alias_name)
+      self.class.generate_alias_key(alias_name, self.args)
+    end
+  
+    #save method
+    def save
+      if valid?
+        #generate key (possibly new)
+        generated_key = redis_key
+        Database.redis.rename(self.old_key, generated_key) if self.old_key && generated_key != self.old_key
+        Database.redis.hmset(generated_key, *self.args.reject{|k,v| v.nil?}.inject([]){ |arr,kv| arr + [kv[0], kv[1].to_s]})
+        
+        #destroy aliases
+        destroy_aliases!
+        create_aliases
+        #after save make new_key -> old_key
+        self.old_key = generated_key  
+        return self
+      else
+        raise ArgumentError, @error.join(", ")
+      end
+    end
+  end
+end

data/lib/string_to_bool.rb

@@ -0,0 +1,9 @@
+# -*- encoding : utf-8 -*-
+
+class String
+  def to_bool
+    return true if self == true || self =~ (/(true|t|yes|y|1)$/i)
+    return false if self == false || self.blank? || self =~ (/(false|f|no|n|0)$/i)
+    raise ArgumentError.new("invalid value for Boolean: \"#{self}\"")
+  end
+end

data/redis-model.gemspec

@@ -0,0 +1,88 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "redis-model-extension"
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ondrej Bartas"]
+  s.date = "2012-02-26"
+  s.description = "It provides functions as find, find_by_alias, get, exists?, validate, save etc."
+  s.email = "ondrej@bartas.cz"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.markdown"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.markdown",
+    "Rakefile",
+    "VERSION",
+    "config/redis_config.yml.example",
+    "config/redis_setup.conf",
+    "lib/database.rb",
+    "lib/redis-model-extension.rb",
+    "lib/string_to_bool.rb",
+    "test/helper.rb",
+    "test/test_redis-model-extension.rb"
+  ]
+  s.homepage = "http://github.com/ondrejbartas/redis-model-extension"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.10"
+  s.summary = "Redis model is basic implementation of creating, finding, updating and deleting model which store data in Redis."
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<redis>, [">= 0"])
+      s.add_runtime_dependency(%q<i18n>, ["~> 0.6.0"])
+      s.add_runtime_dependency(%q<activesupport>, ["~> 3.1.0"])
+      s.add_runtime_dependency(%q<rake>, [">= 0"])
+      s.add_runtime_dependency(%q<rack>, ["~> 1.3.0"])
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<shoulda-context>, [">= 0"])
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.3"])
+      s.add_development_dependency(%q<turn>, ["~> 0.8.2"])
+      s.add_development_dependency(%q<minitest>, [">= 0"])
+      s.add_development_dependency(%q<ansi>, ["~> 1.2.5"])
+    else
+      s.add_dependency(%q<redis>, [">= 0"])
+      s.add_dependency(%q<i18n>, ["~> 0.6.0"])
+      s.add_dependency(%q<activesupport>, ["~> 3.1.0"])
+      s.add_dependency(%q<rake>, [">= 0"])
+      s.add_dependency(%q<rack>, ["~> 1.3.0"])
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<shoulda-context>, [">= 0"])
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+      s.add_dependency(%q<turn>, ["~> 0.8.2"])
+      s.add_dependency(%q<minitest>, [">= 0"])
+      s.add_dependency(%q<ansi>, ["~> 1.2.5"])
+    end
+  else
+    s.add_dependency(%q<redis>, [">= 0"])
+    s.add_dependency(%q<i18n>, ["~> 0.6.0"])
+    s.add_dependency(%q<activesupport>, ["~> 3.1.0"])
+    s.add_dependency(%q<rake>, [">= 0"])
+    s.add_dependency(%q<rack>, ["~> 1.3.0"])
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<shoulda-context>, [">= 0"])
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+    s.add_dependency(%q<turn>, ["~> 0.8.2"])
+    s.add_dependency(%q<minitest>, [">= 0"])
+    s.add_dependency(%q<ansi>, ["~> 1.2.5"])
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'turn'
+require 'shoulda-context'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'redis-model-extension'
+
+class Test::Unit::TestCase
+end

data/test/test_redis-model-extension.rb

@@ -0,0 +1,123 @@
+# -*- encoding : utf-8 -*-
+require 'helper'
+class RedisModelTest < Test::Unit::TestCase
+  context "RedisModel" do
+    setup do
+      Database.redis.flushdb
+      
+      class TestRedisModel
+        REDIS_MODEL_CONF = {
+           :fields => { 
+             :integer => :to_i,
+             :boolean => :to_bool,
+             :string => :to_s,
+             :symbol => :to_sym,
+            }, 
+            :required => [:integer, :string],
+            :redis_key => [:string],
+            :redis_aliases => {
+              :token => [:symbol]
+            }
+         }
+         include RedisModel
+         initialize_redis_model_methods REDIS_MODEL_CONF
+      end
+      @args = {:integer => 12345, :string => "foo", :symbol => :bar, :boolean => true}
+      @test_model = TestRedisModel.new(@args)
+      @test_model_partial = TestRedisModel.new(:integer => 12345, :string => "foo")
+    end 
+    
+    context "define methods" do
+      should "be accessible" do
+        assert @test_model.respond_to?(:integer)
+        assert @test_model.respond_to?(:boolean)
+        assert @test_model.respond_to?(:string)
+        assert @test_model.respond_to?(:symbol)
+      end
+      
+      should "get valid arguments" do
+        assert_equal @test_model.integer, 12345
+        assert_equal @test_model.string, "foo"
+        assert_equal @test_model.symbol, :bar
+        assert_equal @test_model.boolean, true
+      end
+      
+      should "return valid exists?" do
+        assert_equal @test_model.integer?, true
+        assert_equal @test_model.string?, true
+        assert_equal @test_model.symbol?, true
+        assert_equal @test_model.boolean?, true
+        
+        assert_equal @test_model_partial.integer?, true
+        assert_equal @test_model_partial.string?, true
+        assert_equal @test_model_partial.symbol?, false
+        assert_equal @test_model_partial.boolean?, false
+      end
+      
+      should "be assign new values" do
+        @test_model.integer = 54321
+        @test_model.string = "bar"
+        @test_model.symbol = :foo
+        @test_model.boolean = false
+        assert_equal @test_model.integer, 54321
+        assert_equal @test_model.string, "bar"
+        assert_equal @test_model.symbol, :foo
+        assert_equal @test_model.boolean, false
+      end
+    end
+         
+    context "redis key" do
+      should "generate right key" do
+        assert_equal @test_model.redis_key, "redismodeltest::testredismodel:foo"
+        assert_equal TestRedisModel.generate_key(@args), "redismodeltest::testredismodel:foo"
+      end  
+      should "generate right key alias" do
+        assert_equal @test_model.redis_alias_key(:token), "redismodeltest::testredismodel:token:bar"
+        assert_equal TestRedisModel.generate_alias_key(:token, @args), "redismodeltest::testredismodel:token:bar"
+      end  
+    end
+    
+    context "after initialize" do 
+      should "clear input arguments" do
+        test_model = TestRedisModel.new(@args.merge({:foor => :bar, :not_in_fields => "foo"}))
+        assert_same_elements test_model.args, @args
+      end
+    end
+    
+    context "validation" do
+      should "not raise exeption on invalid initialize" do
+        assert_nothing_raised { TestRedisModel.new() }
+      end
+
+      should "raise exeption on save" do
+        test_model = TestRedisModel.new()
+        assert_raises ArgumentError do
+          test_model.save
+        end
+      end
+    end
+    
+    context "saving" do
+      setup do
+        @test_model.save
+      end
+      
+      should "have same elements after get" do
+        @getted_model = TestRedisModel.get(@args)
+        assert_equal @getted_model.integer, @test_model.integer
+        assert_equal @getted_model.string, @test_model.string
+        assert_equal @getted_model.symbol, @test_model.symbol
+        assert_equal @getted_model.boolean, @test_model.boolean
+      end
+      
+      should "be getted by alias" do
+        @getted_model = TestRedisModel.get_by_alias(:token ,@args)
+        assert_equal @getted_model.integer, @test_model.integer
+        assert_equal @getted_model.string, @test_model.string
+        assert_equal @getted_model.symbol, @test_model.symbol
+        assert_equal @getted_model.boolean, @test_model.boolean
+      end
+    end
+    
+  end
+end

metadata

@@ -0,0 +1,209 @@
+--- !ruby/object:Gem::Specification
+name: redis-model-extension
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Ondrej Bartas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: &70246417679280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70246417679280
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: &70246417678780 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70246417678780
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70246417678100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70246417678100
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70246417677380 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70246417677380
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: &70246417676820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70246417676820
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: &70246418084920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70246418084920
+- !ruby/object:Gem::Dependency
+  name: shoulda-context
+  requirement: &70246418083780 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70246418083780
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: &70246418082640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: *70246418082640
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &70246418081620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *70246418081620
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &70246418080920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+  type: :development
+  prerelease: false
+  version_requirements: *70246418080920
+- !ruby/object:Gem::Dependency
+  name: turn
+  requirement: &70246418080340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+  type: :development
+  prerelease: false
+  version_requirements: *70246418080340
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &70246418078980 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70246418078980
+- !ruby/object:Gem::Dependency
+  name: ansi
+  requirement: &70246418078460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.5
+  type: :development
+  prerelease: false
+  version_requirements: *70246418078460
+description: It provides functions as find, find_by_alias, get, exists?, validate,
+  save etc.
+email: ondrej@bartas.cz
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.markdown
+files:
+- .document
+- Gemfile
+- LICENSE.txt
+- README.markdown
+- Rakefile
+- VERSION
+- config/redis_config.yml.example
+- config/redis_setup.conf
+- lib/database.rb
+- lib/redis-model-extension.rb
+- lib/string_to_bool.rb
+- redis-model.gemspec
+- test/helper.rb
+- test/test_redis-model-extension.rb
+homepage: http://github.com/ondrejbartas/redis-model-extension
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1247064394902780429
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Redis model is basic implementation of creating, finding, updating and deleting
+  model which store data in Redis.
+test_files: []