BrianTheCoder-cool_breeze 0.3.0

data/History.txt

@@ -0,0 +1,4 @@
+== 1.0.0 / 2009-03-21
+
+* 1 major enhancement
+  * Birthday!

data/README.txt

@@ -0,0 +1,56 @@
+cool_breeze
+    by Brian Smith
+    http://brianthecoder.com
+    brian@46blocks.com
+
+== DESCRIPTION:
+
+The most awesomest thing ever
+
+== FEATURES/PROBLEMS:
+
+  * need to write tests for queries
+  * uniqueness validator
+  * finish up indexes
+  * allow other data stores (bit table, simple db, couch?)
+
+== SYNOPSIS:
+
+  * coming soon
+
+== REQUIREMENTS:
+
+  * guid
+  * extlib
+  * validatable
+  * redis
+  * rufus-tokyo (ruby-tokyotyrant when its ready)
+
+== INSTALL:
+
+  * its a gem on github, you should know the routine by now
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 FIXME (different 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/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "cool_breeze"
+    gem.summary = %Q{A new type of orm utilizing two different storage mechanisms to the best of their abilities}
+    gem.email = "wbsmith83@gmail.com"
+    gem.homepage = "http://github.com/BrianTheCoder/cool_breeze"
+    gem.authors = ["brianthecoder"]
+
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = false
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "Cool Breeze #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:minor: 3
+:patch: 0
+:major: 0

data/bin/cool_breeze

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+puts "Its getting cold in here"
+
+system("redis-server redis.conf")
+
+puts "Redis started"
+ROOT = File.expand_path(File.join(File.dirname(__FILE__)),'..')
+
+TokyoConfig = {
+  :port => 45000,
+  :data_file => File.join(ROOT,'log','tokyo.tct'),
+  :pid_file => File.join(ROOT,'log','tokyo.pid'),
+  :log_file => File.join(ROOT,'log','tokyo.log')
+}
+
+system("ttserver -dmn -port #{TokyoConfig[:port]} -log #{TokyoConfig[:log_file]} -pid #{TokyoConfig[:pid_file]} #{TokyoConfig[:data_file]}")
+
+puts "Tokyo server started"
+puts "Lets rock and roll!"

data/bin/redis.conf

@@ -0,0 +1,66 @@
+# Redis configuration file example
+
+# By default Redis does not run as a daemon. Use 'yes' if you need it.
+# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
+daemonize yes
+
+# Accept connections on the specified port, default is 6379
+port 6379
+
+# If you want you can bind a single interface, if the bind option is not
+# specified all the interfaces will listen for connections.
+#
+# bind 127.0.0.1
+
+# Close the connection after a client is idle for N seconds
+timeout 300
+
+# Save the DB on disk:
+#
+#   save <seconds> <changes>
+#
+#   Will save the DB if both the given number of seconds and the given
+#   number of write operations against the DB occurred.
+#
+#   In the example below the behaviour will be to save:
+#   after 900 sec (15 min) if at least 1 key changed
+#   after 300 sec (5 min) if at least 10 keys changed
+#   after 60 sec if at least 10000 keys changed
+save 900 1
+save 300 10
+save 60 10000
+
+# For default save/load DB in/from the working directory
+# Note that you must specify a directory not a file name.
+dir ./
+
+# Set server verbosity to 'debug'
+# it can be one of:
+# debug (a lot of information, useful for development/testing)
+# notice (moderately verbose, what you want in production probably)
+# warning (only very important / critical messages are logged)
+loglevel debug
+
+# Specify the log file name. Also 'stdout' can be used to force
+# the demon to log on the standard output. Note that if you use standard
+# output for logging but daemonize, logs will be sent to /dev/null
+logfile stdout
+
+# Set the number of databases.
+databases 16
+
+################################# REPLICATION #################################
+
+# Master-Slave replication. Use slaveof to make a Redis instance a copy of
+# another Redis server. Note that the configuration is local to the slave
+# so for example it is possible to configure the slave to save the DB with a
+# different interval, or to listen to another port, and so on.
+
+# slaveof <masterip> <masterport>
+
+############################### ADVANCED CONFIG ###############################
+
+# Glue small output buffers together in order to send small replies in a
+# single TCP packet. Uses a bit more CPU but most of the times it is a win
+# in terms of number of queries per second. Use 'yes' if unsure.
+glueoutputbuf yes

data/lib/cool_breeze.rb

@@ -0,0 +1,52 @@
+require 'extlib'
+require 'guid'
+require 'validatable'
+
+module CoolBreeze
+
+  # :stopdoc:
+  VERSION = '0.2.0'
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, args.flatten)
+  end
+
+  # Utility method used to require all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(
+        ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+
+    Dir.glob(search_me).sort.each {|rb| require rb}
+  end
+
+end  # module CoolBreeze
+
+CoolBreeze.require_all_libs_relative_to(__FILE__)
+
+# EOF

data/lib/cool_breeze/association.rb

@@ -0,0 +1,52 @@
+module CoolBreeze
+  class Association
+    include Enumerable
+    
+    def initialize(klass, name, options = {})
+      @list_name = "#{name}_list"
+      @klass = klass
+      klass.instance_index :"#{name}_list", :list
+    end
+    
+    def for(instance)
+      @list = instance.method(@list_name)
+      self
+    end
+    
+    def add(obj)
+      @list.call.push(obj.key)
+    end
+    
+    def remove(obj)
+      @list.call.remove(1,obj.key)
+    end  
+    
+    def destroy(obj)
+      remove(obj)
+      obj.destroy
+    end
+    
+    def get(start = 0, stop = -1)
+      keys = @list.call.range(start, stop)
+      return [] if keys.blank?
+      keys.map{|k| @klass.get k}
+    end
+    
+    def size
+      @list.call.length
+    end
+    
+    def first
+      key = @list.call.range(0,1)
+      @klass.get(key) unless key.blank? 
+    end
+    
+    def each
+      values = @list.call.range(0,-1)
+      return if values.blank?
+      values.each do |val|
+        yield @klass.get val
+      end
+    end
+  end
+end

data/lib/cool_breeze/conditions.rb

@@ -0,0 +1,81 @@
+class Symbol
+  def eq
+		[self.to_s,:eq]
+	end
+	
+  def includes
+		[self.to_s,:includes]
+	end
+
+  def starts_with
+		[self.to_s,:starts_with]
+	end
+
+  def ends_with
+		[self.to_s,:ends_with]
+	end
+
+  def and
+		[self.to_s,:and]
+	end
+
+  def or
+		[self.to_s,:or]
+	end
+
+  def stroreq
+		[self.to_s,:stroreq]
+	end
+
+  def matches
+		[self.to_s,:matches]
+	end
+	
+  def gt
+		[self.to_s,:gt]
+	end
+
+  def gte
+		[self.to_s,:gte]
+	end
+
+  def lt
+		[self.to_s,:lt]
+	end
+
+  def lte
+		[self.to_s,:lte]
+	end
+
+  def between
+		[self.to_s,:between]
+	end
+
+  def numoreq
+		[self.to_s,:numoreq]
+	end
+	
+	def strasc
+		[self.to_s,:strasc]
+	end
+
+  def strdesc
+		[self.to_s,:strdesc]
+	end
+
+  def asc
+		[self.to_s,:asc]
+	end
+
+  def desc
+		[self.to_s,:desc]
+	end
+
+  def numasc
+		[self.to_s,:numasc]
+	end
+
+  def numdesc
+		[self.to_s,:numdesc]
+	end
+end

data/lib/cool_breeze/connections.rb

@@ -0,0 +1,10 @@
+module CoolBreeze
+  class Connections
+    class_inheritable_accessor(:adapters)
+    self.adapters ||= {}
+
+    def self.setup(name, instance)
+      adapters[name] = instance
+    end
+  end
+end

data/lib/cool_breeze/index/abstract.rb

@@ -0,0 +1,19 @@
+module CoolBreeze
+  module Index
+    class Abstract
+      attr_accessor :name, :type
+      def initialize(name,type)
+        @name = name
+        @type = type
+      end
+      
+      def get_key(klass)
+        @get_key ||= "#{klass.to_s.downcase}:#{@name}"
+      end
+      
+      def type_klass
+        @type_klass ||= Module.find_const("CoolBreeze::Indices::#{@type.to_s.to_const_string}")
+      end
+    end
+  end
+end

data/lib/cool_breeze/index/class_index.rb

@@ -0,0 +1,6 @@
+module CoolBreeze
+  module Index
+    class ClassIndex < Abstract
+    end
+  end
+end

data/lib/cool_breeze/index/instance_index.rb

@@ -0,0 +1,9 @@
+module CoolBreeze
+  module Index
+    class InstanceIndex < Abstract
+      def get_key(klass)
+        "#{klass.class.to_s.downcase}:#{klass.key}:#{@name}"
+      end
+    end
+  end
+end

data/lib/cool_breeze/mixins/associations.rb

@@ -0,0 +1,25 @@
+module CoolBreeze
+  module Mixins
+    module Associations
+      def self.included(base)
+        base.class_eval <<-EOS, __FILE__, __LINE__
+          class_inheritable_accessor(:associations)
+          self.associations = {}
+        EOS
+        
+        base.extend(ClassMethods)
+      end
+    end
+    
+    module ClassMethods
+      def many(name, options = {})
+        associations[name] = CoolBreeze::Association.new(self,name,options = {})
+        class_eval <<-EOS, __FILE__, __LINE__
+          def #{name}
+            self.class.associations[:"#{name}"].for(self)
+          end
+        EOS
+      end
+    end
+  end
+end

data/lib/cool_breeze/mixins/indices.rb

@@ -0,0 +1,55 @@
+module CoolBreeze
+  module Mixins
+    module Indices
+      def self.included(base)
+        base.class_eval <<-EOS, __FILE__, __LINE__
+          class_inheritable_accessor(:index_types)
+          class_inheritable_accessor(:class_indices)
+          class_inheritable_accessor(:instance_indices)
+          self.index_types = %w(value list set counter)
+          self.class_indices = {}
+          self.instance_indices = {}
+        EOS
+        
+        base.extend(ClassMethods)
+        
+        def destroy
+          instance_indices.each{|idx| idx.destroy }
+          super
+        end
+      end
+    
+      module ClassMethods
+        def class_indicies
+          @class_indicies
+        end
+      
+        def instance_indicies
+          @instance_indicies
+        end
+      
+        def class_index(name,type)
+          klass = Module.find_const("CoolBreeze::Types::#{type.to_s.to_const_string}")
+          instance_eval <<-RUBY, __FILE__, __LINE__
+            class_indices[name] = klass.new("#{self.to_s.downcase}:#{name}")
+            def #{name}(opts = {})
+              class_indices[:"#{name}"]
+            end
+          RUBY
+        end
+      
+        def instance_index(name,type)
+          klass = Module.find_const("CoolBreeze::Types::#{type.to_s.to_const_string}")
+          class_eval do
+            define_method name do
+              if instance_indices[name].nil?
+                instance_indices[name] = klass.new("#{self.key}:#{name}")
+              end
+              instance_indices[name]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cool_breeze/model.rb

@@ -0,0 +1,140 @@
+module CoolBreeze
+  module Model
+    def self.included(model)
+      model.send(:include, InstanceMethods)
+      model.send(:include, Validatable)
+      model.send(:include, Extlib::Hook)
+      model.send(:include, CoolBreeze::Mixins::Indices)
+      model.send(:include, CoolBreeze::Mixins::Associations)
+      model.class_inheritable_accessor(:default_conditions)
+      model.extend(ClassMethods)
+      model.class_eval do
+        self.default_conditions = {:model_type => self.to_s.downcase}
+      end
+    end
+    module ClassMethods            
+      def get(id)
+        attrs = data_store[id]
+        cast(attrs) unless attrs.blank?
+      end
+      
+      alias :[] :get
+      
+      def find(query = {})
+        rs = CoolBreeze::Query.new(self,query).run
+        l = LazyArray.new
+        l = rs.to_a
+      end
+      
+      def first(query = {})
+        attrs = find(query.merge(default_conditions.merge(:limit => 1))).first
+        cast(attrs) unless attrs.blank?
+      end
+      
+      def index_store
+        adapter(:redis)
+      end
+      
+      def data_store
+        adapter(:tokyo)
+      end
+            
+      def all(query = {})
+        attrs = find(query.merge(default_conditions))
+        attrs.map{|a| cast(a)} unless attrs.blank?
+      end
+      
+      def adapter(name)
+        Connections.adapters[name]
+      end
+      
+      def create(data = {})
+        m = self.new(data)
+        m.save
+      end
+      
+      def timestamps!
+        before :save do
+          self.created_at = Time.now if new?
+          self.updated_at = Time.now
+        end
+      end
+      
+      def count(query = {})
+        find(query.merge(default_conditions)).size
+      end
+      
+      protected
+      
+      def cast(attrs)
+        key = attrs.delete(:pk)
+        m = self.new(attrs)
+        m.key = key
+        m
+      end
+    end
+    
+    module InstanceMethods
+      def initialize(data = {})
+        @index_store = self.class.index_store
+        @data_store = self.class.data_store
+        @data = {}
+        data.each do |k,v|
+          self.send(:"#{k}=",v.to_s)
+        end
+      end
+      
+      def properties
+        @data.keys
+      end
+      
+      def key
+        @key ||= "#{self.class.to_s.downcase}:#{Guid.new.to_s}"
+      end
+      
+      def key=(k)
+        @key = k
+      end
+            
+      def new?
+        @data_store[key].nil?
+      end
+      
+      alias :new_record? :new?
+      
+      def [](key)
+        @data[key]
+      end
+      
+      def []=(key,val)
+        @data[key] = val.to_s
+      end
+      
+      def save
+        unless @data.has_key?(:model_type)
+          self.model_type = self.class.to_s.downcase
+        end
+        @data_store[key] = @data
+        return @data_store[key] == @data
+      end
+      
+      def destroy
+        @data_store.delete(key)
+      end
+      
+      def method_missing(method_symbol, *arguments)
+        method_name = method_symbol.to_s
+
+        case method_name[-1..-1]
+        when "="
+          @data[method_name[0..-2]] = arguments.first.to_s
+        when "?"
+          @data[method_name[0..-2]] == true
+        else
+          # Returns nil on failure so forms will work
+          @data.has_key?(method_name) ? @data[method_name] : nil
+        end
+      end
+    end
+  end
+end

data/lib/cool_breeze/query.rb

@@ -0,0 +1,36 @@
+module CoolBreeze
+  class Query
+    def initialize(klass,conditions = {})
+      @klass = klass
+      @query = Rufus::Tokyo::TableQuery.new(CoolBreeze::Connections.adapters[:tokyo])
+      parse_conditions(conditions)
+    end
+    
+    def parse_conditions(conds)
+      # check for order condtion
+      order = conds.delete(:order_by)
+      @query.order_by(*order) unless order.nil?
+      # check for limit condition
+      offset = conds.delete(:offset)
+      limit = conds.delete(:limit)
+      @query.limit(limit, offset || -1) unless limit.nil?
+      # take conditions from :prop.op => val to add(prop, op, value)
+      conds.each do |key, val|
+        key = [key,:eq] if key.is_a?(Symbol)
+        if key.last == :eq 
+          if val.is_a? Numeric
+            key[1] = :numeq
+          else val.is_a? String
+            key[1] = :streq
+          end
+        end
+        key[0] = key.first.to_s
+        @query.add *(key + [val.to_s])
+      end
+      
+      def run
+        @query.run
+      end
+    end
+  end
+end

data/lib/cool_breeze/types/abstract.rb

@@ -0,0 +1,19 @@
+module CoolBreeze
+  module Types
+    class Abstract
+      attr_accessor :key, :index_store
+      def initialize(key)
+        @key = key
+        @index_store = CoolBreeze::Connections.adapters[:redis]
+      end
+      
+      def get
+        @index_store[@key]
+      end
+      
+      def destroy
+        @index_store.delete(@key)
+      end
+    end
+  end
+end

data/lib/cool_breeze/types/counter.rb

@@ -0,0 +1,13 @@
+module CoolBreeze
+  module Types
+    class Counter < Abstract
+      def incr
+        @index_store.incr(@key)
+      end
+      
+      def decr
+        @index_store.decr(@key)
+      end
+    end
+  end
+end

data/lib/cool_breeze/types/list.rb

@@ -0,0 +1,41 @@
+module CoolBreeze
+  module Types
+    class List < Abstract
+      def length
+        @index_store.list_length(@key)
+      end
+      
+      def push(val)
+        @index_store.push_tail(@key, val)
+      end
+      
+      def pop
+        @index_store.pop_tail(@key)
+      end
+      
+      def unshift
+        @index_store.pop_head(@key)
+      end
+      
+      def shift(val)
+        @index_store.push_head(@key, val)
+      end
+      
+      def trim(start, stop)
+        @index_store.list_trim(@key, start, stop)
+      end
+      
+      def range(start, stop)
+        @index_store.list_range(@key, start, stop)
+      end
+      
+      def index(index)
+        @index_store.list_index(@key, index)
+      end
+      
+      def remove(count, value)
+        @index_store.list_rm(@key, count, value)
+      end
+    end
+  end
+end

data/lib/cool_breeze/types/set.rb

@@ -0,0 +1,29 @@
+module CoolBreeze
+  module Types
+    class Set < Abstract
+      def get
+        @index_store.set_members(@key)
+      end
+      
+      def add(val)
+        @index_store.set_add(@key,val)
+      end
+      
+      def size
+        @index_store.set_count(@key)
+      end
+      
+      def include?(val)
+        @index_store.set_member?(@key, val)
+      end
+      
+      def remove(val)
+        @index_store.set_delete(@key, val)
+      end
+      
+      def intersect(key)
+        @index_store.set_intersect(@key, key)
+      end
+    end
+  end
+end

data/lib/cool_breeze/types/value.rb

@@ -0,0 +1,9 @@
+module CoolBreeze
+  module Types
+    class Value < Abstract
+      def set(val)
+        @index_store[@key] = val
+      end
+    end
+  end
+end

data/spec/association_spec.rb

@@ -0,0 +1,35 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe "Associations" do
+  before do
+    @user = User.new
+  end
+  
+  it "defines the method on a instance" do
+    @user.respond_to?(:messages).should be_true
+  end
+  
+  it "has a destroy method" do
+    @user.messages.respond_to?(:destroy).should be_true
+  end
+  
+  it "has an add method" do
+    @user.messages.respond_to?(:add).should be_true  
+  end
+  
+  it "has a remove method" do
+    @user.messages.respond_to?(:remove).should be_true
+  end
+  
+  it "has a get method" do
+    @user.messages.respond_to?(:get).should be_true
+  end
+  
+  it "responds to each" do
+    @user.messages.respond_to?(:each).should be_true
+  end
+  
+  it "responds to first" do
+    @user.messages.respond_to?(:first).should be_true
+  end
+end

data/spec/index_spec.rb

@@ -0,0 +1,11 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe "Class Index" do
+  before do
+  end
+end
+
+describe "Instance Index" do
+  before do
+  end
+end

data/spec/model_spec.rb

@@ -0,0 +1,23 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe "CoolBreeze::Model" do
+  before do
+    @data = {
+      "profile_image_url" => "http://s3.amazonaws.com/twitter_production/profile_images/74591615/01-30-09_2327_normal.jpg", 
+      "created_at" => "Sun, 22 Mar 2009 00:13:11 +0000",
+      "from_user" => "pbrendel",
+      "text" => "first time i've noticed not having digital antenna. don't get austin cbs anymore, so no horns. (internet tv to the rescue)",
+      "to_user_id" => nil,
+      "id" => 1368224751,
+      "from_user_id" => 4205104,
+      "iso_language_code" => "en",
+      "source" => "<a href="http://twitter.com/">web</a>"
+    }
+  end
+  it 'should take an optional paramter to new and set the data' do
+    m = Message.new(@data)
+    m.data.should == @data.each{|k,v| @data[k] = v.to_s}
+  end
+end
+
+# EOF

data/spec/models/message.rb

@@ -0,0 +1,12 @@
+class Message
+  include CoolBreeze::Model
+  
+  def key
+    @key ||= "message:#{self['id']}"
+  end
+  
+  timestamps!
+  
+  class_index :count, :counter
+  instance_index :tags, :set
+end

data/spec/models/user.rb

@@ -0,0 +1,5 @@
+class User
+  include CoolBreeze::Model
+  
+  many :messages
+end

data/spec/query_spec.rb

@@ -0,0 +1,6 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe "Queries" do
+  before do
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'spec' # Satisfies Autotest and anyone else not using the Rake tasks
+require 'redis'
+require 'rufus/tokyo'
+
+
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. lib cool_breeze]))
+    
+Dir[File.expand_path(File.join(File.dirname(__FILE__), 'models','*'))].each{|m| require m}
+
+Spec::Runner.configure do |config|
+  CoolBreeze::Connections.setup(:redis, Redis.new)
+  CoolBreeze::Connections.setup(:tokyo, Rufus::Tokyo::Table.new('log/test.tct'))
+  # == Mock Framework
+  #
+  # RSpec uses it's own mocking framework by default. If you prefer to
+  # use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+end
+
+# EOF

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: BrianTheCoder-cool_breeze
+version: !ruby/object:Gem::Version 
+  version: 0.3.0
+platform: ruby
+authors: 
+- brianthecoder
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-15 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: wbsmith83@gmail.com
+executables: 
+- cool_breeze
+- redis.conf
+extensions: []
+
+extra_rdoc_files: 
+- README.txt
+files: 
+- History.txt
+- README.txt
+- Rakefile
+- VERSION.yml
+- bin/cool_breeze
+- bin/redis.conf
+- lib/cool_breeze.rb
+- lib/cool_breeze/association.rb
+- lib/cool_breeze/conditions.rb
+- lib/cool_breeze/connections.rb
+- lib/cool_breeze/index/abstract.rb
+- lib/cool_breeze/index/class_index.rb
+- lib/cool_breeze/index/instance_index.rb
+- lib/cool_breeze/mixins/associations.rb
+- lib/cool_breeze/mixins/indices.rb
+- lib/cool_breeze/model.rb
+- lib/cool_breeze/query.rb
+- lib/cool_breeze/types/abstract.rb
+- lib/cool_breeze/types/counter.rb
+- lib/cool_breeze/types/list.rb
+- lib/cool_breeze/types/set.rb
+- lib/cool_breeze/types/value.rb
+- spec/association_spec.rb
+- spec/index_spec.rb
+- spec/model_spec.rb
+- spec/models/message.rb
+- spec/models/user.rb
+- spec/query_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/BrianTheCoder/cool_breeze
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A new type of orm utilizing two different storage mechanisms to the best of their abilities
+test_files: 
+- spec/association_spec.rb
+- spec/index_spec.rb
+- spec/model_spec.rb
+- spec/models/message.rb
+- spec/models/user.rb
+- spec/query_spec.rb
+- spec/spec_helper.rb