hyperion 0.1.0

data/.document

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

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 adrianpike
+
+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.rdoc

@@ -0,0 +1,68 @@
+= hyperion
+
+Hyperion is a lightning fast Ruby object model backed with Redis. It was created in 48 hours to back Leatherbound.me, a ebook comparison shopping tool that was built for Rails Rumble. We withstood 15,000 uniques on Monday morning, and Hyperion stayed super quick even with tons of concurrent queries on a small Linode.
+
+== Key features
+
+* CRUD on Ruby classes, any attributes get stuffed into a Redis key.
+* Indexing of objects on any attributes or collections of attributes.
+
+== A quickie
+	
+	adrian$ gem install hyperion
+	
+	require 'hyperion'
+	
+	class Person < Hyperion
+		# First we set up the attributes on this object.
+		attr_accessor :name, :email, :password, :other_amazing_info, :car_color, :state
+		
+		# Let's use the email as our primary key.
+		# Another option would be to not define our own, in which case :id will be created & used.
+		hyperion_key :email
+		
+		# Lets add some indexes!
+		# We can search for all Persons with a given name.
+		hyperion_index :name
+		
+		# We can also search for all people with a given car color and state.
+		hyperion_index [:car_color, :state]
+	end
+
+	p1 = Person.new({:name => 'Adrian Pike', :email => 'adrian@pikeapps.com', …})
+	p1.save
+	
+	Person.find('adrian@pikeapps.com') #=> #<Person @name="Adrian Pike", @email="adrian@pikeapps.com">
+	Person.find(:name => 'Adrian Pike') #=> [#<Person @name="Adrian Pike", @email="adrian@pikeapps.com">]
+	Person.find(:car_color => 'purple', :state => 'denial') #=> [#<Person @name="Adrian Pike", @email="adrian@pikeapps.com">]
+
+== Requirements
+
+* Ruby 1.9
+* activesupport
+* Redis
+
+== Roadmap
+
+* Change the indexes to use ZSETs.
+* Delete. (ha!)
+* Schema versioning and migrations.
+* Faster faster faster! Let's utilize more of Redis' exposed data structures to make it better.
+* Clever auto-sharding based on primary keyspace
+  * Figure out a way to auto-balance shards
+* Slow full-table searches.
+* Partial index searches
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Adrian Pike. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,84 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  gem 'rspec', '>= 1.2.6'
+  gem 'rspec-rails', '>= 1.2.6'
+  require 'spec'
+  require 'spec/rake/spectask'
+rescue LoadError
+  begin
+    require 'rspec/core/rake_task.rb'
+    require 'rspec/core/version'
+  rescue LoadError
+    puts "[formtastic:] RSpec - or one of it's dependencies - is not available. Install it with: sudo gem install rspec-rails"
+  end
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "hyperion"
+    gem.summary = %Q{Hyperion is a sweet Ruby data model thats backed with Redis.}
+    gem.description = %Q{Hyperion is a sweet Ruby data model thats backed with Redis. It's designed to be screamin' fast.}
+    gem.email = "adrian.pike@gmail.com"
+    gem.homepage = "http://github.com/adrianpike/hyperion"
+    gem.authors = ["adrianpike"]
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+desc 'Default: run unit specs.'
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "hyperion #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+if defined?(Spec)
+  desc 'Test hyperion.'
+  Spec::Rake::SpecTask.new('spec') do |t|
+    t.spec_files = FileList['spec/**/*_spec.rb']
+    t.spec_opts = ["-c"]
+  end
+
+  desc 'Test hyperion with specdoc formatting and colors'
+  Spec::Rake::SpecTask.new('specdoc') do |t|
+    t.spec_files = FileList['spec/**/*_spec.rb']
+    t.spec_opts = ["--format specdoc", "-c"]
+  end
+
+  desc "Run all examples with RCov"
+  Spec::Rake::SpecTask.new('examples_with_rcov') do |t|
+    t.spec_files = FileList['spec/**/*_spec.rb']
+    t.rcov = true
+    t.rcov_opts = ['--exclude', 'spec,Library']
+  end
+end
+
+if defined?(RSpec)
+  desc 'Test hyperion.'
+  RSpec::Core::RakeTask.new('spec') do |t|
+    t.pattern = FileList['spec/**/*_spec.rb']
+  end
+
+  desc 'Test hyperion with specdoc formatting and colors'
+  RSpec::Core::RakeTask.new('specdoc') do |t|
+    t.pattern = FileList['spec/**/*_spec.rb']
+  end
+
+  desc "Run all examples with RCov"
+  RSpec::Core::RakeTask.new('examples_with_rcov') do |t|
+    t.pattern = FileList['spec/**/*_spec.rb']
+    t.rcov = true
+    t.rcov_opts = ['--exclude', 'spec,Library']
+  end
+end

data/VERSION

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

data/benchmarks.rb

@@ -0,0 +1,100 @@
+require 'benchmark'
+require 'ruby-prof'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'lib'))
+require 'hyperion'
+
+class DefaultKey < Hyperion
+	attr_accessor :content, :key
+	hyperion_key :key
+end
+
+class NoKey < Hyperion
+	attr_accessor :content
+end
+
+class IndexedObject < Hyperion
+	attr_accessor :content, :other_content, :key
+	
+	hyperion_key :key
+	hyperion_index :other_content
+	hyperion_index [:content, :other_content]
+end
+
+[100,1000,10000,100000].each {|n|
+	puts "===== #{n} ====="
+	puts "#{n} inserts:"
+	bm = Benchmark.measure {
+		n.times do |k|
+			f = DefaultKey.new({
+				:key => k,
+				:content => "Benchmarking!"
+			})
+			f.save
+		end
+	}
+	p bm
+
+	puts "#{n} fetches:"
+	bm = Benchmark.measure {
+		n.times do |k|
+			f = DefaultKey.find(k)
+		end
+	}
+	p bm
+
+	puts "#{n} inserts w/autoincrement:"
+	bm = Benchmark.measure {
+		n.times do |k|
+			f = DefaultKey.new({
+				:content => "Benchmarking!"
+			})
+			f.save
+		end
+	}
+	p bm
+
+	puts "#{n} inserts with indexes and autoincrement:"
+	bm = Benchmark.measure {
+		n.times do |k|
+			f = IndexedObject.new({
+				:content => "Benchmarking!",
+				:other_content => k
+			})
+			f.save
+		end
+	}
+	p bm
+
+	puts "#{n} fetches on a single index:"
+	bm = Benchmark.measure {
+		n.times do |k|
+			f = IndexedObject.find({
+				:other_content => k
+			})
+		end
+	}
+	p bm
+
+	puts "#{n} fetches on a complex index:"
+	bm = Benchmark.measure {
+		n.times do |k|
+			f = IndexedObject.find({
+				:content => 'Benchmarking!',
+				:other_content => k
+			})
+		end
+	}
+	p bm
+
+
+	puts "#{n} indexless updates:"
+	bm = Benchmark.measure {
+		n.times do |k|
+			f = DefaultKey.find(k)
+			f.content = 'Second time around'
+			f.save
+		end
+	}
+	p bm
+}

data/hyperion.gemspec

@@ -0,0 +1,58 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{hyperion}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["adrianpike"]
+  s.date = %q{2010-10-28}
+  s.description = %q{Hyperion is a sweet Ruby data model thats backed with Redis. It's designed to be screamin' fast.}
+  s.email = %q{adrian.pike@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "benchmarks.rb",
+     "hyperion.gemspec",
+     "lib/hyperion.rb",
+     "lib/hyperion/base.rb",
+     "lib/hyperion/finders.rb",
+     "lib/hyperion/indices.rb",
+     "lib/hyperion/keys.rb",
+     "lib/hyperion/logger.rb",
+     "lib/hyperion/version.rb",
+     "spec/hyperion_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/adrianpike/hyperion}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Hyperion is a sweet Ruby data model thats backed with Redis.}
+  s.test_files = [
+    "spec/hyperion_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/lib/hyperion.rb

@@ -0,0 +1,168 @@
+require 'active_support'
+require 'yaml'
+require 'redis'
+
+# TODO: splat this
+require 'hyperion/base'
+require 'hyperion/indices'
+require 'hyperion/keys'
+require 'hyperion/logger'
+require 'hyperion/version'
+
+class Hyperion
+	extend Indices
+	extend Keys
+	extend Version
+	extend Logger
+	
+  DEBUG = false
+  # TODO: ActiveModel lint it _mayhaps_
+  # TODO: atomic operations
+  # TODO: default key called #{class}_id if there isn't any @@redis_key
+
+  def initialize(opts = {})
+    defaults = (self.class.class_variable_defined?('@@redis_defaults') ? self.class.class_variable_get('@@redis_defaults') : {})
+
+    defaults.merge(opts).each {|k,v|
+      self.send(k.to_s+'=',v)
+    }
+  end
+
+	def self.first(conds)
+		# FIXME: gotta be a faster way ;)
+		self.find(conds).first
+	end
+
+  def self.find(conds)
+    Hyperion.logger.debug("[RS] Searching for #{conds.inspect}") if Hyperion::DEBUG
+    
+    if conds.is_a? Hash then
+      Hyperion.logger.debug("[RS] Its a Hash, digging through indexes!") if Hyperion::DEBUG
+      ids = []
+      index_keys = []
+      index_values = []
+      
+      if conds.keys.size > 1 then
+        conds.sort.each {|k,v|
+          index_values << v
+          index_keys << k.to_s
+        }
+        index_key = self.to_s.downcase + '_' + index_keys.join('.') + '_' + index_values.join('.')
+        ids << Hyperion.redis.smembers(index_key)
+      else
+        conds.each{|k,v|
+          index_key = self.to_s.downcase + '_' + k.to_s + '_' + v.to_s
+          ids << Hyperion.redis.smembers(index_key)
+        }
+      end
+      ids.flatten.uniq.collect{|i|
+        self.find(i)
+      }
+    else
+      Hyperion.logger.debug("[RS] Fetching #{self.to_s.downcase + '_' + conds.to_s}") if Hyperion::DEBUG
+      v = redis[self.to_s.downcase + '_' + conds.to_s].to_s
+      if v and not v.empty? then
+        self.deserialize(v)
+      else
+        nil
+      end
+    end
+  end
+
+  def self.deserialize(what); YAML.load(what); end
+  def serialize; YAML::dump(self); end
+
+  def save
+    Hyperion.logger.debug("[RS] Saving a #{self.class.to_s}:") if Hyperion::DEBUG
+		
+		unless (self.class.class_variable_defined?('@@redis_key')) then
+			self.class.send('attr_accessor', 'id')
+	    self.class.class_variable_set('@@redis_key', 'id')
+		end
+		
+		unless (self.send(self.class.class_variable_get('@@redis_key'))) then
+      Hyperion.logger.debug("[RS] Generating new key!") if Hyperion::DEBUG
+      self.send(self.class.class_variable_get('@@redis_key').to_s + '=', new_key)
+    end    
+
+    Hyperion.logger.debug("[RS] Saving into #{full_key}: #{self.inspect}") if Hyperion::DEBUG
+    Hyperion.redis[full_key] = self.serialize
+    
+    # Now lets update any indexes
+    # BUG: need to clear out any old indexes of us
+    self.class.class_variable_get('@@redis_indexes').each{|idx|
+      Hyperion.logger.debug("[RS] Updating index for #{idx}") if Hyperion::DEBUG
+    
+      if idx.is_a?(Array) then
+        index_values = idx.sort.collect {|i| self.send(i) }.join('.')
+        index_key = self.class.to_s.downcase + '_' + idx.sort.join('.').to_s + '_' + index_values
+      else
+				value = self.send(idx)
+        index_key = self.class.to_s.downcase + '_' + idx.to_s + '_' + value.to_s if value
+      end
+     Hyperion.logger.debug("[RS] Saving index #{index_key}: #{self.send(self.class.class_variable_get('@@redis_key'))}") if Hyperion::DEBUG
+      Hyperion.redis.sadd(index_key, self.send(self.class.class_variable_get('@@redis_key')))
+    } if self.class.class_variable_defined?('@@redis_indexes')
+  end
+  
+  def self.dump(output = STDOUT, lock = false)
+    # TODO: lockability and progress
+    output.write(<<-eos)
+# Hyperion Dump
+# Generated by @adrianpike's Hyperion gem.
+    eos
+    output.write('# Generated on ' + Time.current.to_s + "\n")
+    output.write('# DB size is ' + redis.dbsize.to_s + "\n")
+    
+    redis.keys.each{|k|
+      case redis.type(k)
+      when "string"
+        output.write({ k => redis.get(k)}.to_yaml)
+      when "set"
+        output.write({ k => redis.smembers(k) }.to_yaml)
+      end
+    }
+  end
+  
+
+  # THIS IS MAD DANGEROUS AND UNTESTED, BEWARE DATA INTEGRITY
+  def self.load(file = STDIN, truncate = true, lock = false)
+    # TODO: lockability and progress    
+    
+    YAML.each_document( file ) do |ydoc|
+      ydoc.each {|k,v|
+        redis.del(k) if truncate
+
+        case v.class.to_s
+          when 'String'
+            redis[k] = v
+          when 'Array'
+            v.each{|val|
+              redis.sadd(k,val)
+            }
+          else
+            p v.class
+        end
+      }
+    end
+    
+  end
+  
+  # THIS IS TOTALLY IRREVERSIBLE YO
+  def self.truncate!
+    redis.flushdb
+  end
+  
+  private
+    def new_key
+      if (self.class.class_variable_defined?('@@redis_generate_key') and self.class.class_variable_get('@@redis_generate_key') == false)
+        raise NoKey
+      else
+        Hyperion.redis.incr(self.class.to_s.downcase + '_' + self.class.class_variable_get('@@redis_key').to_s)
+      end
+    end
+    
+    def full_key
+      self.class.to_s.downcase + '_' + self.send(self.class.class_variable_get('@@redis_key')).to_s
+    end
+end

data/lib/hyperion/base.rb

@@ -0,0 +1,14 @@
+class Hyperion
+	
+  class HyperionException < Exception; end
+  class NoKey < HyperionException; end
+
+  def self.hyperion_defaults(defaults)
+    class_variable_set(:@@redis_defaults, defaults)
+  end
+  
+  def self.redis
+    @@redis ||= Redis.new
+  end
+
+end

data/lib/hyperion/finders.rb

@@ -0,0 +1,12 @@
+class Hyperion
+	module Finders
+
+		# find(id)
+		# find(:all, {})
+		# find(:first, {})
+		# find(:last, {})
+		
+		# we can do > and < if we use ZRANGEBYSCORE, but scores have to be integer :/
+		
+	end
+end

data/lib/hyperion/indices.rb

@@ -0,0 +1,22 @@
+class Hyperion
+	module Indices
+		
+	  class NoIndex < HyperionException; end
+
+		def hyperion_index(index)
+	    if class_variable_defined?(:@@redis_indexes) then
+	      class_variable_set(:@@redis_indexes, class_variable_get(:@@redis_indexes) << index)
+	    else
+	      class_variable_set(:@@redis_indexes, [index])
+	    end
+	  end
+
+		def reindex!
+			# TODO
+		end
+		
+		# Indexes need to be sorted sets!
+		# ZSET scores can supposedly be large floats, should explore max ZSET score size.
+		
+	end
+end

data/lib/hyperion/keys.rb

@@ -0,0 +1,10 @@
+class Hyperion
+	module Keys
+	
+	  def hyperion_key(key, opts = {})
+	    class_variable_set(:@@redis_key, key)
+	    class_variable_set(:@@redis_generate_key, opts[:generate])
+	  end
+		
+	end
+end

data/lib/hyperion/logger.rb

@@ -0,0 +1,16 @@
+require 'logger'
+
+class Hyperion
+	module Logger
+		
+		def logger
+			unless class_variable_defined?('@@logger') then
+				@@logger = ::Logger.new(STDOUT)
+				@@logger.level = ::Logger::DEBUG
+			end
+			
+			@@logger
+		end
+		
+	end
+end

data/lib/hyperion/version.rb

@@ -0,0 +1,14 @@
+class Hyperion
+	module Version
+		
+		def branch; nil; end
+		def major; 0;	end
+		def minor; 1; end
+		def patch; 0; end
+		
+		def version
+			[branch,major,minor,patch].compact.collect(&:to_s).join('.')
+		end
+		
+	end
+end

data/spec/hyperion_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+# TODO: truncate the redis store and/or stub it beforehand
+
+describe 'Hyperion' do
+  it "should work for basic set/fetch" do
+		string1 = random_string
+	
+    f = DefaultKey.new
+		f.key = 'test'
+		f.content = string1
+		f.save
+		
+		f2 = DefaultKey.find('test')
+		f2.content.should == f.content
+		
+		f3 = IndexedObject.find(string1)
+		f3.should == nil
+  end
+
+	it "should be able to index a single attribute" do
+		string1 = random_string
+		
+		f = IndexedObject.new
+		f.content = string1
+		f.other_content = 'zero_cool'
+		f.key = 'testery'
+		f.save
+		
+		f2 = IndexedObject.first(:other_content => 'zero_cool')
+		f2.content.should == f.content
+		
+		f3 = IndexedObject.find('testery')
+		f3.content.should == f.content
+	end
+	
+	it "should take objects at instantiation time" do
+		string1 = random_string
+		
+		n=NoKey.new(:content => string1)
+		n.save
+		
+		n2 = NoKey.find(n.id)
+		n2.content.should == string1
+	end
+	
+	it "should autogenerate keys" do
+		string1 = random_string
+		
+		n=NoKey.new
+		n.content = string1
+		n.save
+		
+		n2 = NoKey.find(n.id)
+		n2.content.should == string1
+	end
+	
+	it 'should autoincrement keys whether specified or not' do
+	end
+	
+	it "should be able to index multiple attributes" do
+		string1 = random_string
+		
+		f = IndexedObject.new
+		f.content = string1
+		f.other_content = 'zero_cool'
+		f.key = 'testery'
+		f.save
+		
+		f2 = IndexedObject.first(:other_content => 'zero_cool')
+		f2.content.should == f.content
+		
+		f3 = IndexedObject.find('testery')
+		f3.content.should == f.content
+		
+		f4 = IndexedObject.first(:other_content => 'zero_cool', :content => string1)
+		f4.content.should == f.content
+	end
+	
+	it "shouldn't put an index in for an empty value" do
+		string1 = random_string
+		
+		f = IndexedObject.new
+		f.content = string1
+		f.save
+		
+		f2 = IndexedObject.first(:other_content => nil)
+		f2.should == nil
+	end
+	
+	it "shouldn't matter what order your indexes are specified" do
+	end
+	
+	it "should not have concurrency issues" do
+	end
+
+	it "should be able to reindex objects" do
+	end
+
+	it "should update indexes" do
+	end
+	
+	it 'should be OK with key collision' do
+	end
+		
+	it "should die if there's no redis server around" do
+	end
+	
+	it "should allow crazy lengths and contents for both keys and values" do
+	end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+require 'rubygems'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'hyperion'
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+end
+
+class DefaultKey < Hyperion
+	attr_accessor :content, :key
+	hyperion_key :key
+end
+
+class NoKey < Hyperion
+	attr_accessor :content
+end
+
+class IndexedObject < Hyperion
+	attr_accessor :content, :other_content, :key
+	
+	hyperion_key :key
+	hyperion_index :other_content
+	hyperion_index [:content, :other_content]
+end
+
+def random_string(length = 10)
+	'asdfdsfasd' # todo lolololol
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: hyperion
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- adrianpike
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-28 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Hyperion is a sweet Ruby data model thats backed with Redis. It's designed to be screamin' fast.
+email: adrian.pike@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- benchmarks.rb
+- hyperion.gemspec
+- lib/hyperion.rb
+- lib/hyperion/base.rb
+- lib/hyperion/finders.rb
+- lib/hyperion/indices.rb
+- lib/hyperion/keys.rb
+- lib/hyperion/logger.rb
+- lib/hyperion/version.rb
+- spec/hyperion_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/adrianpike/hyperion
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Hyperion is a sweet Ruby data model thats backed with Redis.
+test_files: 
+- spec/hyperion_spec.rb
+- spec/spec_helper.rb