redis_backed_model 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.rvmrc
+.rspec
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in redis_backed_model.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Ian Whitney
+
+MIT License
+
+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.md

@@ -0,0 +1,29 @@
+# RedisBackedModel
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'redis_backed_model'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install redis_backed_model
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+# If you want to make this the default task
+task :default => :spec

data/lib/redis_backed_model/inflections.rb

@@ -0,0 +1,22 @@
+module ActiveSupport::Inflector
+
+  def deinstance_variableize(the_string)
+    result = the_string.to_s.dup
+    result.downcase.gsub(/^@/, '')
+  end
+  
+  def instance_variableize(the_string)
+    "@#{the_string}".to_sym
+  end
+  
+end
+class String
+  def deinstance_variableize
+    ActiveSupport::Inflector.deinstance_variableize(self)
+  end
+  
+  def instance_variableize
+    ActiveSupport::Inflector.instance_variableize(self)
+  end
+  
+end

data/lib/redis_backed_model/redis_backed_model.rb

@@ -0,0 +1,57 @@
+module RedisBackedModel
+  class RedisBackedModel
+    
+    def initialize(attributes={})
+      if attributes.class == Hash
+        attributes.each do |key, value|
+          add_to_instance_variables(key, value)
+        end
+      else
+        raise ArgumentError
+      end
+    end
+    
+    def to_redis
+      redis_commands = []
+      redis_commands << redis_set_command
+      instance_variables.each do | var |
+        redis_commands << instance_variable_to_redis(var) if instance_variable_to_redis(var)
+      end
+      scores.each do |score|
+        redis_commands << score.to_redis
+      end
+      redis_commands
+    end
+    
+    private
+    
+      attr_reader :id, :scores
+    
+      def add_to_instance_variables(key, value)
+        if key.match(/score_\[\w+\|\w+\]/)
+          add_to_scores(key, value)
+        else
+          self.instance_variable_set("@#{key}", value) 
+        end
+      end
+    
+      def add_to_scores(key, value)
+        @scores ||= []
+        @scores << SortedSet.new(self.class, id, Hash[key,value])
+      end
+      
+      def instance_variable_to_redis(instance_variable)
+        "hset #{model_name_for_redis}:#{id} #{instance_variable.to_s.deinstance_variableize} #{instance_variable_get(instance_variable.to_s)}" unless instance_variable.to_s == '@id'
+      end
+        
+      def model_name_for_redis
+        class_as_string = self.class.to_s.demodulize.underscore        
+      end
+        
+      def redis_set_command
+        "sadd #{model_name_for_redis}_ids #{id}"
+      end
+      
+  end
+    
+end

data/lib/redis_backed_model/sorted_set.rb

@@ -0,0 +1,64 @@
+module RedisBackedModel
+
+  class SortedSet
+  require 'date'
+    
+  
+    def initialize(model, model_id, definition)
+      @model      = model
+      @model_id   = model_id
+      @definition = definition
+    end
+  
+    def to_redis
+      "zadd #{key} #{score} #{member}"
+    end
+  
+    private
+      
+      attr_accessor :model, :model_id #, :by_attribute, :score_label, :score
+      
+      def definition_keys
+        @definition.keys.first
+      end
+      
+      def definition_values
+        @definition.values.first
+      end
+      
+      def key_by
+        parse_definition(definition_keys)[1]
+      end
+      
+      def key_for
+        parse_definition(definition_keys)[0]        
+      end
+
+      def key_model_name
+        @model.to_s.underscore.pluralize
+      end
+
+      def key_for_value
+        parse_definition(definition_values)[0]
+      end
+
+      def member
+        @model_id
+      end
+        
+      def key
+        "#{key_model_name}_for_#{key_for}_by_#{key_by}:#{key_for_value}"
+      end
+
+      def score
+        score = parse_definition(definition_values)[1]
+        key_by == 'date' ? Date.parse(score).to_time.to_f : score
+      end
+      
+      def parse_definition(string)
+        string.match(/.*\[(\S+)\]/)[1].split('|')
+      end
+  
+  end
+
+end

data/lib/redis_backed_model/version.rb

@@ -0,0 +1,3 @@
+module RedisBackedModel
+  VERSION = "0.0.1"
+end

data/lib/redis_backed_model.rb

@@ -0,0 +1,5 @@
+require "redis_backed_model/version"
+require 'active_support/inflector'
+require 'redis_backed_model/redis_backed_model'
+require 'redis_backed_model/sorted_set'
+require 'redis_backed_model/inflections'

data/redis_backed_model.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/redis_backed_model/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Ian Whitney", "Davin Lagerroos"]
+  gem.email         = ["iwhitney@ssa-i.org","dlaerroos@ssa-i.org"]
+  gem.description   = %q{Provides methods to models that are backed by a redis instance.}
+  gem.summary       = %q{Provides methods for the creation of redis-backed models, specifically the handling of sorted-set attributes and returning commands that will store the object in redis.}
+  gem.homepage      = "https://github.com/SeniorServiceAmerica/redis_backed_model"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "redis_backed_model"
+  gem.require_paths = ["lib"]
+  gem.version       = RedisBackedModel::VERSION
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'redis'
+  gem.add_dependency('active_support')  
+end

data/spec/extras/person.rb

@@ -0,0 +1,50 @@
+class Person < RedisBackedModel::RedisBackedModel
+  attr_reader :id, :first_name, :last_name
+  
+  def self.all
+    all = []
+    ids.each do |id|
+      all << self.find(id)
+    end
+    all
+  end
+
+  #def self.first
+    #id = ids.first
+    #self.find(id)
+  #end
+  
+  def self.find(id)
+    attr = $redis.hgetall("person:#{id}")
+    self.new(attr.merge({:id => id}))
+  end
+
+  #def self.last
+    #id = ids.last
+    #self.find(id)
+  #end
+
+  def self.to_csv
+    f = File.new("person.csv", "w+")
+    f << "id,first_name,last_name\n"
+    self.all.each do |x|
+      f << "#{x.id},#{x.first_name},#{x.last_name}\n"
+    end
+  end
+
+  # def initialize(attr)
+  #   @id = attr[:id]
+  #   @first_name = attr["first_name"]
+  #   @last_name = attr["last_name"]
+  # end
+
+  def name
+    "#{self.first_name} #{self.last_name}"
+  end
+
+  private
+
+  def self.ids
+    @ids ||= $redis.sort('person_ids')
+  end
+end

data/spec/redis_backed_model/inflections_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+
+
+describe String do 
+  
+  it "instance_variablizes by pre-pending an '@' and turning itself into a symbol" do 
+    'my_test_string'.instance_variableize.should eq(:@my_test_string)
+  end
+  
+  it "deinstance_variableizes by removing the leading '@" do
+    '@instance_variable'.deinstance_variableize.should eq('instance_variable')
+  end
+  
+end

data/spec/redis_backed_model/sorted_set_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+describe RedisBackedModel::SortedSet do
+  before(:all) do
+    
+  end
+  
+  before(:each) do
+    @scored_set = RedisBackedModel::SortedSet.new(FalseClass, 1, {'score_[foo|bar]' => '[wibble|wobble]'})
+  end
+
+  it "returns returns first part of [|] definition key as for_key" do 
+    @scored_set.send(:key_for).should eq('foo')
+  end
+  
+  it "returns first part of [|] definition value as for_value" do 
+    @scored_set.send(:key_for_value).should eq('wibble')
+  end
+
+  it "returns the model, underscored and pluralized as model_name_for_key" do 
+    @scored_set.send(:key_model_name).should eq('false_classes')
+  end
+  
+  it "returns second part of definition key as key" do 
+    @scored_set.send(:key_by).should eq('bar')
+  end
+  
+  it "returns (key_model_name) + '_for_' + key_for + '_by_' + key_by  + ':' + for_value as key" do 
+    @scored_set.send(:key).should eq('false_classes_for_foo_by_bar:wibble')
+  end
+  
+  it "returns second part of definition value as score" do 
+    @scored_set.send(:score).should eq('wobble')
+  end
+
+  it "converts score dates to miliseconds" do 
+    set = RedisBackedModel::SortedSet.new(FalseClass, 1, {'score_[foo|date]'=>'[wibble|2012-03-04]'})
+    date_in_milliseconds = Date.civil(2012,3,4).to_time.to_f
+    set.send(:score).should eq(date_in_milliseconds)
+  end
+
+  it "returns model_is as member" do
+    @scored_set.send(:member).should eq(1)
+    @scored_set.send(:member).should eq(@scored_set.send(:model_id))
+  end
+
+  it "returns 'zadd key value model_id' as to_redis" do 
+    @scored_set.to_redis.should eq('zadd false_classes_for_foo_by_bar:wibble wobble 1')
+  end
+  
+end

data/spec/redis_backed_model_spec.rb

@@ -0,0 +1,171 @@
+require "spec_helper"
+require 'extras/person'
+
+describe RedisBackedModel do
+  before(:all) do
+    
+  end
+  
+  before(:each) do
+    @attributes = {}
+    @size = rand(9) + 1
+    key_seed = 'abcdefghijklmn'
+    (1..@size).each do | i |
+      key  = key_seed[i..(rand(i)+i)] 
+      @attributes[key] = i
+    end
+    @attributes['id'] = 1
+    @size += 1
+  end
+  
+  it "has no instance variables unless specified" do 
+    rbm = RedisBackedModel::RedisBackedModel.new
+    rbm.instance_variables.count.should eq(0)
+  end
+  
+  it "creates an instance variable for a hash with one member" do
+    attributes = {'id' => 1}
+    rbm = RedisBackedModel::RedisBackedModel.new(attributes)
+    rbm.instance_variables.include?(:@id).should eq(true)
+  end
+
+  it "creates an instance variable for each member of an attribute hash that doesn't have scores" do
+    rbm = RedisBackedModel::RedisBackedModel.new(@attributes)
+    rbm.instance_variables.count.should eq(@size)
+    @attributes.each do | key, value|
+      # rbm.instance_variables.include?("@#{key}".to_sym).should eq(true), "no instance variable for #{key}"
+      rbm.instance_variables.include?(key.instance_variableize).should eq(true), "no instance variable for #{key}"      
+    end
+  end
+  
+  it "raises an argument error if something other than a hash is passed in" do 
+    expect { RedisBackedModel::RedisBackedModel.new('w') }.to raise_error(ArgumentError)
+    expect { RedisBackedModel::RedisBackedModel.new(['w', 1]) }.to raise_error(ArgumentError)
+  end
+  
+  it "does not create a key for any score_[|] attribute" do 
+    score_key = 'score_[foo|bar]'
+    @attributes[score_key]  = '[1|2]'
+    rbm = RedisBackedModel::RedisBackedModel.new(@attributes)
+    rbm.instance_variables.include?(score_key.instance_variableize).should eq(false)
+  end
+  
+  it "creates a scores instance variable if there are any score_[x|y] attributes" do
+    score_key = 'score_[foo|bar]'
+    @attributes[score_key]  = '[1|2]'
+    rbm = RedisBackedModel::RedisBackedModel.new(@attributes)
+    rbm.instance_variables.include?('scores'.instance_variableize).should eq(true)    
+  end
+
+  it "stores score_ attributes in scores as SortedSet objects" do
+    ['score_[foo|bar]', 'score_[baz|qux]', 'score_[wibble|wobble]'].each_with_index do |score,index|
+      @attributes[score]  = "[#{index}|#{index + 1}]"
+    end
+    rbm = RedisBackedModel::RedisBackedModel.new(@attributes)
+    rbm.send(:scores).each do |score|
+      score.class.should eq(RedisBackedModel::SortedSet)
+    end
+  end
+
+  it "does not add near matches to scores instance variable, so it tries to add it as an instance variable instead, raising a name error because of []" do
+    ['score_[foobar]', 'score[foo|bar]', 'score_[foobar|]'].each_with_index do |s,i|
+      @attributes[s] = '[i|i+1]'
+      expect { rbm = RedisBackedModel::RedisBackedModel.new(@attributes) }.to raise_error(NameError)
+    end
+  end
+    
+  it "returns a redis command to adds the model id to a set named (model_name)_ids" do 
+    rbm = RedisBackedModel::RedisBackedModel.new(@attributes)
+    rbm.send(:redis_set_command).should eq('sadd redis_backed_model_ids 1')    
+  end
+  
+  it "creates a hset command for instance variables that are not id" do 
+    rbm = RedisBackedModel::RedisBackedModel.new()
+    rbm.instance_variable_set('@id', 1)    
+    rbm.instance_variable_set('@foo', 20)
+    rbm.send(:instance_variable_to_redis, '@foo').should eq('hset redis_backed_model:1 foo 20')
+  end
+
+  it "puts a underscored version of the model name as the first part of the hset key name in instance_variable_set" do 
+    rbm = RedisBackedModel::RedisBackedModel.new()
+    rbm.instance_variable_set('@id', 1)    
+    rbm.instance_variable_set('@foo', 20)
+    hset_command = rbm.send(:instance_variable_to_redis, '@foo')
+    hset_command.split(' ')[1].split(':')[0].should eq(RedisBackedModel.to_s.underscore)
+  end
+
+  it "puts the id as the second part of the hset hset key name in instance_variable_set" do 
+    rbm = RedisBackedModel::RedisBackedModel.new()
+    rbm.instance_variable_set('@id', 1)    
+    rbm.instance_variable_set('@foo', 20)
+    hset_command = rbm.send(:instance_variable_to_redis, '@foo')
+    hset_command.split(' ')[1].split(':')[1].should eq(rbm.instance_variable_get('@id').to_s)  
+  end
+  
+  it "puts the instance_variable_name (without @) as the hset field name in instance_variable_set" do
+    rbm = RedisBackedModel::RedisBackedModel.new()
+    rbm.instance_variable_set('@id', 1)    
+    rbm.instance_variable_set('@foo', 20)
+    hset_command = rbm.send(:instance_variable_to_redis, '@foo')
+    hset_command.split(' ')[2].should eq('foo') 
+  end
+  
+  it "put the instance variable value as the hset value in instance_variable_set" do 
+    rbm = RedisBackedModel::RedisBackedModel.new()
+    rbm.instance_variable_set('@id', 1)    
+    rbm.instance_variable_set('@foo', 20)
+    hset_command = rbm.send(:instance_variable_to_redis, '@foo')
+    hset_command.split(' ')[3].should eq('20') 
+  end
+  
+  it "does not create an hset command for the id instance variable" do
+    rbm = RedisBackedModel::RedisBackedModel.new()
+    rbm.instance_variable_set('@id', 1)    
+    rbm.send(:instance_variable_to_redis, '@id').should eq(nil)
+  end
+
+  it "includes as sadd command in to_redis" do
+    @attributes['score_[foo|bar]']  = '[1|2012-03-04]'
+    rbm = RedisBackedModel::RedisBackedModel.new(@attributes)
+    rbm.to_redis.select { |command| command.match(/sadd/)}.count.should eq(1)
+  end
+  
+  it "includes a hset command for each instance variable except id in to_redis" do
+    @attributes['score_[foo|bar]']  = '[1|2012-03-04]'
+    rbm = RedisBackedModel::RedisBackedModel.new(@attributes)
+    expected = rbm.instance_variables.count - 1
+    rbm.to_redis.select {|command| command.match(/hset/)}.count.should eq(expected)
+  end
+  
+  it "includes a sorted_set.to_redis command for each score attribute in to_redis" do 
+    scores = ['score_[foo|bar]', 'score_[baz|qux]', 'score_[wibble|wobble]']
+    scores.each_with_index do |score,index|
+      @attributes[score]  = "[#{index}|#{index + 1}]"
+    end
+    rbm = RedisBackedModel::RedisBackedModel.new(@attributes)
+    rbm.to_redis.select { |command| command.match(/zadd/) }.count.should eq(scores.count)
+  end
+
+end
+
+# test inheriting from RedisBackedModel
+describe Person do 
+  
+  before(:all) do 
+    $redis.hset 'person:0', 'first_name', 'jane'
+    $redis.hset 'person:0', 'last_name', 'doe'
+  end
+
+  it "should set its instance_variables from redis, using RedisBackedModel initialize" do
+    person = Person.find(0)
+    person.instance_variables.include?(:@first_name).should eq(true)
+    person.instance_variables.include?(:@last_name).should eq(true)
+    person.instance_variables.include?(:@id).should eq(true)    
+  end
+    
+  it "should have same name method" do
+    person = Person.find(0)
+    person.name.should eq('jane doe')    
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+require 'redis_backed_model'
+require 'redis'
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end
+
+SPEC_ROOT = File.dirname(__FILE__)
+require File.join(SPEC_ROOT, '/../lib/redis_backed_model')
+
+$redis = Redis.new()

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: redis_backed_model
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Ian Whitney
+- Davin Lagerroos
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: active_support
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Provides methods to models that are backed by a redis instance.
+email:
+- iwhitney@ssa-i.org
+- dlaerroos@ssa-i.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/redis_backed_model.rb
+- lib/redis_backed_model/inflections.rb
+- lib/redis_backed_model/redis_backed_model.rb
+- lib/redis_backed_model/sorted_set.rb
+- lib/redis_backed_model/version.rb
+- redis_backed_model.gemspec
+- spec/extras/person.rb
+- spec/redis_backed_model/inflections_spec.rb
+- spec/redis_backed_model/sorted_set_spec.rb
+- spec/redis_backed_model_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/SeniorServiceAmerica/redis_backed_model
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: Provides methods for the creation of redis-backed models, specifically the
+  handling of sorted-set attributes and returning commands that will store the object
+  in redis.
+test_files:
+- spec/extras/person.rb
+- spec/redis_backed_model/inflections_spec.rb
+- spec/redis_backed_model/sorted_set_spec.rb
+- spec/redis_backed_model_spec.rb
+- spec/spec_helper.rb