blendris 0.0.1

data/lib/blendris/node.rb

@@ -0,0 +1,46 @@
+module Blendris
+
+  # RedisNode is used to compose all Redis value wrapper classes.
+  module RedisNode
+
+    include RedisAccessor
+
+    def initialize(key, options = {})
+      @key = sanitize_key(key)
+      @default = options[:default]
+      @options = options
+
+      set(@default) if @default && !redis.exists(self.key)
+    end
+
+    def set(value)
+      if value
+        redis.set key, self.class.cast_to_redis(value, @options)
+      else
+        redis.del key
+      end
+    end
+
+    def get
+      self.class.cast_from_redis redis.get(self.key), @options
+    end
+
+    def key
+      prefix + @key
+    end
+
+    def clear
+      redis.del key
+    end
+
+    def type
+      redis.type key
+    end
+
+    def exists?
+      redis.exists key
+    end
+
+  end
+
+end

data/lib/blendris/reference.rb

@@ -0,0 +1,51 @@
+module Blendris
+
+  class RedisReference < RedisReferenceBase
+
+    include RedisNode
+
+    def ref
+      @ref ||= RedisString.new(@key)
+    end
+
+    def set(obj)
+      old_obj = self.get if @reverse
+      modified = false
+      refkey = self.class.cast_to_redis(obj, @options)
+
+      if refkey == nil
+        ref.set nil
+        modified = true
+      elsif refkey != ref.get
+        ref.set refkey
+        apply_reverse_add obj
+        modified = true
+      end
+
+      apply_reverse_delete(old_obj) if modified
+
+      obj
+    end
+
+    def get
+      self.class.cast_from_redis ref.get
+    end
+
+    def assign_ref(value)
+      self.set value
+    end
+
+    def remove_ref(value)
+      self.set nil
+    end
+
+    def references(value)
+      refval = ref.get
+
+      return true if refval.nil? && value.nil?
+      return refval == value.key
+    end
+
+  end
+
+end

data/lib/blendris/reference_base.rb

@@ -0,0 +1,68 @@
+module Blendris
+
+  class RedisReferenceBase
+
+    include RedisNode
+    extend RedisAccessor
+
+    def initialize(key, options = {})
+      @model = options[:model]
+      @key = sanitize_key(key)
+      @reverse = options[:reverse]
+      @options = options
+
+      @klass = options[:class] || Model
+      @klass = constantize(camelize @klass) if @klass.kind_of? String
+
+      unless @klass.ancestors.include? Model
+        raise ArgumentError.new("#{klass.name} is not a model")
+      end
+    end
+
+    def apply_reverse_add(value)
+      if @reverse && value
+        reverse = value.redis_symbol(@reverse)
+        reverse.assign_ref(@model) if !reverse.references @model
+      end
+    end
+
+    def apply_reverse_delete(value)
+      if @reverse && value
+        reverse = value.redis_symbol(@reverse)
+        reverse.remove_ref(@model) if reverse.references @model
+      end
+    end
+
+    def self.cast_to_redis(obj, options = {})
+      expect = options[:class] || Model
+      expect = constantize(expect) if expect.kind_of? String
+      expect = Model unless expect.ancestors.include? Model
+
+      if obj == nil
+        nil
+      elsif obj.kind_of? expect
+        obj.key
+      else
+        raise TypeError.new("#{obj.class.name} is not a #{expect.name}")
+      end
+    end
+
+    def self.cast_from_redis(refkey, options = {})
+      expect = options[:class] || Model
+      expect = constantize(expect) if expect.kind_of? String
+      expect = Model unless expect.ancestors.include? Model
+
+      klass = constantize(redis.get(prefix + refkey)) if refkey
+
+      if klass == nil
+        nil
+      elsif klass.ancestors.include? expect
+        klass.new refkey
+      else
+        raise TypeError.new("#{klass.name} is not a #{expect.name}")
+      end
+    end
+
+  end
+
+end

data/lib/blendris/reference_set.rb

@@ -0,0 +1,65 @@
+module Blendris
+
+  class RedisReferenceSet < RedisReferenceBase
+
+    include RedisNode
+    include Enumerable
+
+    def refs
+      @refs ||= RedisSet.new(@key)
+    end
+
+    def set(*objs)
+      objs.flatten!
+      objs.compact!
+
+      objs.each do |obj|
+        if refkey = self.class.cast_to_redis(obj, @options)
+          refs << refkey
+          apply_reverse_add obj
+        end
+      end
+
+      self
+    end
+    alias :<< :set
+
+    def delete(obj)
+      if refkey = self.class.cast_to_redis(obj, @options)
+        deleted = refs.delete(refkey)
+        apply_reverse_delete(obj) if deleted
+        deleted
+      end
+    end
+
+    def get
+      self
+    end
+
+    def each
+      redis.smembers(key).each do |refkey|
+        yield self.class.cast_from_redis(refkey, @options)
+      end
+    end
+
+    def include?(obj)
+      refkey = self.class.cast_to_redis(obj, @options)
+
+      refs.include? refkey
+    end
+
+    def assign_ref(*values)
+      self.set *values
+    end
+
+    def remove_ref(value)
+      self.delete value
+    end
+
+    def references(value)
+      self.include? value
+    end
+
+  end
+
+end

data/lib/blendris/set.rb

@@ -0,0 +1,39 @@
+module Blendris
+
+  class RedisSet
+
+    include RedisNode
+    include Enumerable
+
+    def initialize(key, options = {})
+      @key = key.to_s
+      @options = options
+    end
+
+    def each
+      redis.smembers(key).each do |value|
+        yield value
+      end
+
+      self
+    end
+
+    def <<(value)
+      [ value ].flatten.compact.each do |v|
+        redis.sadd key, v
+      end
+
+      self
+    end
+
+    def get
+      self
+    end
+
+    def delete(value)
+      redis.srem key, value
+    end
+
+  end
+
+end

data/lib/blendris/string.rb

@@ -0,0 +1,19 @@
+module Blendris
+
+  class RedisString
+
+    include RedisNode
+
+    def self.cast_to_redis(value, options = {})
+      raise TypeError.new("#{value.class.name} is not a string") unless value.kind_of? String
+
+      value
+    end
+
+    def self.cast_from_redis(value, options = {})
+      value
+    end
+
+  end
+
+end

data/lib/blendris/types.rb

@@ -0,0 +1,14 @@
+module Blendris
+
+  class Model
+
+    type :string, RedisString
+    type :integer, RedisInteger
+    type :set, RedisSet
+    type :list, RedisList
+    type :ref, RedisReference
+    type :refs, RedisReferenceSet
+
+  end
+
+end

data/lib/blendris/utils.rb

@@ -0,0 +1,39 @@
+module Blendris
+
+  module Utils
+
+    # Method lifted from Rails.
+    def constantize(camel_cased_word)
+      return if blank(camel_cased_word)
+
+      unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ camel_cased_word
+        raise NameError, "#{camel_cased_word.inspect} is not a valid constant name!"
+      end
+
+      Object.module_eval("::#{$1}", __FILE__, __LINE__)
+    end
+
+    # Method lifted from Rails.
+    def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+      if first_letter_in_uppercase
+        lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+      else
+        lower_case_and_underscored_word.first + camelize(lower_case_and_underscored_word)[1..-1]
+      end
+    end
+
+    # Tests if the given object is blank.
+    def blank(obj)
+      return true if obj.nil?
+      return obj.strip.empty? if obj.kind_of? String
+      return obj.empty? if obj.respond_to? :empty?
+      return false
+    end
+
+    def sanitize_key(key)
+      key.to_s.gsub(/[\r\n\s]/, "_").gsub(/^:+|:+$/, "")
+    end
+
+  end
+
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/blendris.rb'}"
+puts "Loading blendris gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/spec/list_spec.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe "redis lists" do
+
+  it "should read and write" do
+    @onion.sales.count.should == 0
+
+    @onion.sales << %w( to-bill to-tom to-bill to-bob to-tom )
+    @onion.sales.count.should == 5
+    @onion.sales.to_a.should == %w( to-bill to-tom to-bill to-bob to-tom )
+
+    @onion.sales.delete("to-bill").should == 2
+    @onion.sales.delete("to-bob").should == 1
+    @onion.sales.to_a.should == %w( to-tom to-tom )
+  end
+
+end

data/spec/model_spec.rb

@@ -0,0 +1,180 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe Model do
+
+  it "should have valid keys" do
+    @onion.key.should == "food:onion"
+    @onion.name.should == "onion"
+  end
+
+  it "should have a working integer field" do
+    @onion.calories.should == 0
+
+    @onion.calories = 120
+    @onion.calories.should == 120
+  end
+
+  it "should have a valid reference" do
+    @onion.category.should be_nil
+
+    @onion.category = @vegetable
+    @onion.category.name.should == "vegetable"
+  end
+
+  it "should have a valid reference set" do
+    @fruit.foods.count.should == 0
+
+    @fruit.foods << [ @apple, @lemon ]
+
+    @fruit.foods.should be_include(@apple)
+    @fruit.foods.should be_include(@lemon)
+    @fruit.foods.should be_include(Food.new("food:lemon"))
+    @fruit.foods.should_not be_include(@steak)
+  end
+
+  it "should not allow you to instantiate with a key that doesnt match its class" do
+    lambda { Category.new("balogna") }.should raise_error(TypeError)
+    lambda { Category.new(@onion.key) }.should raise_error(TypeError)
+    lambda { Category.new(@vegetable.key) }.should_not raise_error(TypeError)
+  end
+
+  it "should allow for complex types in the key" do
+    lambda { FavoriteFood.create("Billy Bob Thorton", "squeezy") }.should raise_error(TypeError)
+
+    fav = FavoriteFood.create("Billy Bob Thorton", @onion)
+
+    fav.key.should == "person:Billy_Bob_Thorton:food:onion"
+    fav.person.should == "Billy Bob Thorton"
+    fav.food.should == @onion
+  end
+
+  context "with single reference" do
+
+    it "should reverse to a single reference" do
+      @apple.sibling.should be_nil
+      @lemon.sibling.should be_nil
+
+      @apple.sibling = @lemon
+
+      @apple.sibling.should == @lemon
+      @lemon.sibling.should == @apple
+
+      @lemon.sibling = nil
+
+      @apple.sibling.should be_nil
+      @lemon.sibling.should be_nil
+    end
+
+    it "should reverse to a reference set" do
+      @onion.category.should be_nil
+      @vegetable.foods.count.should be_zero
+
+      2.times do
+        @onion.category = @vegetable
+
+        @onion.category.name.should == "vegetable"
+        @vegetable.foods.count.should == 1
+        @vegetable.foods.should be_include(@onion)
+      end
+
+      @onion.category = nil
+
+      @onion.category.should be_nil
+      @vegetable.foods.count.should == 0
+      @vegetable.foods.should_not be_include(@onion)
+    end
+
+    it "should allow for generic references" do
+      @onion.something.should be_nil
+
+      @onion.something = @steak
+      @onion.something.name.should == "steak"
+
+      @onion.something = @vegetable
+      @onion.something.name.should == "vegetable"
+    end
+
+  end
+
+  context "with reference sets" do
+
+    it "should reverse to single references" do
+      @onion.category.should be_nil
+      @vegetable.foods.count.should be_zero
+
+      2.times do
+        @vegetable.foods << @onion
+
+        @onion.category.name.should == "vegetable"
+        @vegetable.foods.count.should == 1
+        @vegetable.foods.should be_include(@onion)
+      end
+
+      @vegetable.foods.delete @onion
+
+      @onion.category.should be_nil
+      @vegetable.foods.count.should == 0
+      @vegetable.foods.should_not be_include(@onion)
+    end
+
+    it "should reverse to a reference set" do
+      @apple.friends.count.should == 0
+      @lemon.friends.count.should == 0
+      @onion.friends.count.should == 0
+
+      @apple.friends << [ @lemon, @onion ]
+
+      @apple.friends.count.should == 2
+      @lemon.friends.count.should == 1
+      @onion.friends.count.should == 1
+
+      @apple.friends.should be_include(@lemon)
+      @apple.friends.should be_include(@onion)
+      @lemon.friends.should be_include(@apple)
+      @onion.friends.should be_include(@apple)
+
+      @apple.friends.delete @lemon
+
+      @apple.friends.count.should == 1
+      @lemon.friends.count.should == 0
+      @onion.friends.count.should == 1
+
+      @apple.friends.should_not be_include(@lemon)
+      @apple.friends.should be_include(@onion)
+      @lemon.friends.should_not be_include(@apple)
+      @onion.friends.should be_include(@apple)
+    end
+
+  end
+
+  context "website sister sites" do
+
+    it "should update each others sister sites table" do
+
+      site1 = Website.create("Site One")
+      site2 = Website.create("Site Two")
+
+      site1.sister_sites.count.should == 0
+      site2.sister_sites.count.should == 0
+      site1.sister_sites.should_not be_include site2
+      site2.sister_sites.should_not be_include site1
+
+      site1.sister_sites << site2
+
+      site1.sister_sites.count.should == 1
+      site2.sister_sites.count.should == 1
+      site1.sister_sites.should be_include site2
+      site2.sister_sites.should be_include site1
+
+      site2.sister_sites.delete site1
+
+      site1.sister_sites.count.should == 0
+      site2.sister_sites.count.should == 0
+      site1.sister_sites.should_not be_include site2
+      site2.sister_sites.should_not be_include site1
+
+    end
+
+  end
+
+end