lorentz 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rvmrc

@@ -0,0 +1 @@
+rvm use --create --install maglev-26436@lorentz

data/Gemfile

@@ -0,0 +1,8 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in lorentz.gemspec
+gemspec
+
+group :development, :test do
+  gem 'rspec'
+end

data/README.md

@@ -0,0 +1,24 @@
+# Lorentz
+
+Redis on MagLev
+
+## Why?
+
+Because it's \_why day, \_why day, gotta write a hack it's \_why day!
+
+## What's implemented so far?
+
+* set
+* get
+* exists
+* del
+* keys (with glob pattern)
+* rename
+* renamenx
+* strlen
+* randomkey
+* append
+
+## Inspiration
+
+\_why of course! [Redis](http://redis.io) also. [ctoneal's strc](https://github.com/ctoneal/strc) is cool too but I want a real Redis within MagLev.

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/lib/lorentz.rb

@@ -0,0 +1,38 @@
+require "lorentz/version"
+require "lorentz/exceptions"
+require "lorentz/strings"
+require "lorentz/keys"
+
+class Lorentz
+
+  attr_reader :db
+  def initialize(opts={})
+    db_name = opts.delete(:db) || 0
+
+    @db = begin
+            ::Maglev::PERSISTENT_ROOT[:"lorentz_db_#{db_name}"] ||= {}
+          rescue
+            $stderr.puts "Maglev only"
+            exit
+          end
+  end
+  include Lorentz::Strings
+  include Lorentz::Keys
+
+  private
+  def save(&block)
+    begin
+      Maglev.abort_transaction
+      yield
+      Maglev.commit_transaction
+    rescue Maglev::CommitFailedException
+      $stderr.puts "I tried to save but I couldn't. Trying again."
+      redo
+    end
+  end
+
+  def run(&block)
+    Maglev.abort_transaction
+    yield
+  end
+end

data/lib/lorentz/exceptions.rb

@@ -0,0 +1 @@
+class LorentzException < StandardError; end

data/lib/lorentz/glob.rb

@@ -0,0 +1,32 @@
+module Lorentz::Glob
+  # jacked from https://github.com/karottenreibe/joker
+  # & specifically http://karottenreibe.github.com/2009/12/03/inside-the-joker/
+  def compile(source, case_sensitive=false)
+    ptr = 0
+    compiled = '^'
+    while ptr < source.length
+      snip = source[ptr..ptr]
+      case snip
+      when '\\'
+        lookahead = source[ptr+1..ptr+1]
+        case snip
+        when '\\\\', '\\?', '\\*'
+          compiled << snip << lookahead
+        else
+          compiled << Regexp.quote(lookahead)
+        end
+        ptr += 1
+      when '?' then compiled << '.'
+      when '*' then compiled << '.*'
+      when '[' then compiled << '['
+      when ']' then compiled << ']'
+      else          compiled << Regexp.quote(snip)
+      end
+      ptr += 1
+    end
+    compiled << '$'
+    Regexp.compile(compiled, case_sensitive)
+  end
+
+  module_function :compile
+end

data/lib/lorentz/keys.rb

@@ -0,0 +1,53 @@
+require 'lorentz/glob'
+
+module Lorentz::Keys
+  include Lorentz::Glob
+
+  def exists(key)
+    run do
+      !!@db[key]
+    end
+  end
+
+  def del(*keys)
+    run do
+      keys.map{ |k| @db.delete(k) }.compact.size
+    end
+  end
+
+  def keys(pattern)
+    run do
+      @db.keys.grep(compile(pattern))
+    end
+  end
+
+  def rename(key, newkey)
+    if key == newkey
+      raise LorentzException, "newkey: #{newkey} must be different than key: #{key}"
+    end
+    raise LorentzException, "key: #{key} does not exist" unless exists(key)
+    save do
+      val = get(key)
+      del(key)
+      set(newkey, val)
+    end
+  end
+
+  def renamenx(key, newkey)
+    if key == newkey
+      raise LorentzException, "newkey: #{newkey} must be different than key: #{key}"
+    end
+    raise LorentzException, "key: #{key} does not exist" unless exists(key)
+    return 0 if exists(newkey)
+    rename(key, newkey)
+    return 1
+  end
+
+  def randomkey
+    return nil if @db.empty?
+    run do
+      @db.keys[rand(@db.keys.length)]
+    end
+  end
+
+end

data/lib/lorentz/strings.rb

@@ -0,0 +1,40 @@
+module Lorentz::Strings
+  def set(key, value)
+    save do
+      @db[key] = value
+      return "OK"
+    end
+  end
+
+  def get(key)
+    run do
+      @db[key]
+    end
+  end
+
+  def strlen(key)
+    val = get(key)
+    return 0 unless val
+    if val.kind_of?(String)
+      return val.length
+    else
+      raise LorentzException, "The value stored at key: #{key} is not a String"
+    end
+  end
+
+  def append(key, value)
+    if exists(key)
+      old_value = get(key)
+      if old_value.is_a?(String)
+        new_value = old_value << value
+        set(key, new_value)
+        return new_value.length
+      else
+        raise LorentzException, "The value stored at key: #{key} is not a String"
+      end
+    else
+      set(key, "")
+      return "OK"
+    end
+  end
+end

data/lib/lorentz/version.rb

@@ -0,0 +1,7 @@
+class Lorentz
+  class << self
+    def version
+      "0.0.1".freeze
+    end
+  end
+end

data/lorentz.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "lorentz/version"
+
+Gem::Specification.new do |s|
+  s.name        = "lorentz"
+  s.version     = Lorentz.version
+  s.authors     = ["Jesse Cooke"]
+  s.email       = ["jesse@jc00ke.com"]
+  s.homepage    = "https://github.com/jc00ke/lorentz"
+  s.summary     = %q{Take one Redis, stick it on MagLev}
+  s.description = %q{You know, for _why day!}
+  s.licenses    = ['MIT']
+
+  s.rubyforge_project = "lorentz"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency 'rspec', '~> 2.6.0'
+end

data/spec/lorentz/glob_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Lorentz::Glob do
+  let(:wild)  { Lorentz::Glob.compile('Fairy?ake*') }
+  let(:wildi) { Lorentz::Glob.compile('Fairy?ake*\?', true) }
+  let(:wildc) { Lorentz::Glob.compile('Fairy[cf]ake[!\\]]') }
+
+  it 'should match correct strings' do
+    wild.should match('Fairycake')
+    wild.should match('Fairyfakes')
+    wild.should match('Fairylake is a cool place')
+  end
+
+  it 'should not match incorrect strings' do
+    wild.should_not match('Dairycake')
+    wild.should_not match('Fairysteakes')
+    wild.should_not match('fairycake')
+  end
+
+  it 'should match case insensitive' do
+    wildi.should match('FairyCake?')
+    wildi.should match('fairyfakes?')
+    wildi.should match('FairyLake IS A COOL Place?')
+  end
+
+  it 'should know about character classes' do
+    wildc.should match('Fairycake!')
+    wildc.should match('Fairyfake]')
+  end
+end

data/spec/lorentz/keys_spec.rb

@@ -0,0 +1,183 @@
+require 'spec_helper'
+
+#EXPIRE
+#EXPIREAT
+#MOVE
+#OBJECT
+#PERSIST
+#SORT
+#TTL
+#TYPE
+
+describe "keys" do
+  let(:lorentz) { Lorentz.new }
+
+  describe "#exists" do
+    context "when key exists" do
+      it "should return true" do
+        lorentz.set("chunky", "bacon")
+        lorentz.exists("chunky").should be_true
+      end
+    end
+
+    context "when key doesn't exist" do
+      it "should return false" do
+        lorentz.exists("chunky").should be_false
+      end
+    end
+
+  end
+
+  describe "#del" do
+    before do
+      lorentz.set("chunky", 0)
+      lorentz.set("bacon", 1)
+    end
+    it "should delete keys that exist" do
+      lorentz.del("chunky", "bacon", "pet ham")
+      lorentz.exists("chunky").should be_false
+      lorentz.exists("bacon").should be_false
+      lorentz.exists("pet ham").should be_false
+    end
+
+    it "should return the number of deleted keys" do
+      lorentz.del("chunky", "bacon", "pet ham").should eq(2)
+    end
+  end
+
+  describe "#keys" do
+    before do
+      lorentz.set("chunky", 0)
+      lorentz.set("bacon", 1)
+      lorentz.set("chunked", 2)
+      lorentz.set("thunk", 3)
+    end
+
+    it "should match 'unk'" do
+      keys = lorentz.keys('*unk*')
+      keys.should have(3).items
+      %w(chunky chunked thunk).each do |k|
+        keys.should include(k)
+      end
+    end
+
+    it "should return all" do
+      keys = lorentz.keys('*')
+      keys.should have(4).items
+      %w(chunky chunked thunk bacon).each do |k|
+        keys.should include(k)
+      end
+    end
+  end
+
+  describe "#rename" do
+
+    context "when key exists" do
+
+      before do
+        lorentz.set("chunky", "bacon")
+      end
+
+      context "and newkey exists" do
+        before do
+          lorentz.set("yummy", "snacks")
+        end
+
+        it "should overwrite newkey" do
+          lorentz.rename("chunky", "yummy")
+          lorentz.get("yummy").should == "bacon"
+        end
+      end
+
+      context "and newkey doesn't exist" do
+        it "it should set new key" do
+          lorentz.rename("chunky", "yummy")
+          lorentz.get("yummy").should == "bacon"
+        end
+      end
+
+      context "and newkey is the same" do
+        it "should raise a LorentzException" do
+          expect do
+            lorentz.rename("chunky", "chunky")
+          end.to raise_error(LorentzException)
+        end
+      end
+
+    end
+
+    context "when key doesn't exist" do
+      it "should raise a LorentzException" do
+        expect do
+          lorentz.rename("chunky", "yummy")
+        end.to raise_error(LorentzException)
+      end
+
+    end
+  end
+
+  describe "renamenx" do
+    
+    context "when key exists" do
+
+      before do
+        lorentz.set("chunky", "bacon")
+      end
+
+      context "and newkey exists" do
+        it "should return 0" do
+          lorentz.set("funky", "cold medina")
+          lorentz.renamenx("chunky", "funky").should be_zero
+        end
+      end
+       
+      context "and newkey doesn't exist" do
+        it "should return 1" do
+          lorentz.renamenx("chunky", "funky").should eq(1)
+        end
+      end
+
+      context "and newkey is the same" do
+        it "should raise a LorentzException" do
+          expect do
+            lorentz.rename("chunky", "chunky")
+          end.to raise_error(LorentzException)
+        end
+      end
+    end
+
+    context "when key doesn't exist" do
+      it "should raise a LorentzException" do
+        expect do
+          lorentz.renamenx("chunky", "yummy")
+        end.to raise_error(LorentzException)
+      end
+
+    end
+  end
+
+  describe "randomkey" do
+    context "database with some keys" do
+      before do
+        1.upto(1000){ |i| lorentz.set(i, i) }
+      end
+
+      it "should return a random key" do
+        (1..100).to_a.inject([]) do |memo, i|
+          memo << lorentz.randomkey
+        end.uniq.should have_at_least(90).keys
+      end
+    end
+
+    context "empty database" do
+      before do
+        # delete in case... paranoid much?
+        ::Maglev::PERSISTENT_ROOT.delete(:lorentz_db_100)
+      end
+      it "should return nil" do
+        l = Lorentz.new(:db => :lorentz_db_100)  
+        l.randomkey.should be_nil
+      end
+    end
+  end
+end

data/spec/lorentz/strings_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+#DECR
+#DECRBY
+#GETBIT
+#GETRANGE
+#GETSET
+#INCR
+#INCRBY
+#MGET
+#MSET
+#MSETNX
+#SETBIT
+#SETEX
+#SETNX
+#SETRANGE
+
+describe "strings" do
+  let(:lorentz) { Lorentz.new }
+
+  describe "#set" do
+    it "should set the key to the value" do
+      lorentz.set("chunky", 'bacon').should == "OK"
+      lorentz.db["chunky"].should eq("bacon")
+    end
+  end
+
+  describe "#setnx" do
+    context "when key exists" do
+      xit "should not set" do
+
+      end
+    end
+
+    context "when key doesn't exist" do
+      xit "should set" do
+        
+      end
+    end
+  end
+
+  describe "#get" do
+    context "when key exists" do
+      it "should return the value" do
+        lorentz.set("chunky", "bacon")
+        lorentz.get("chunky").should == "bacon"
+      end
+    end
+    it "should return nil if key doesn't exist" do
+      lorentz.get("chunky").should be_nil
+    end
+  end
+
+  describe "#append" do
+    context "when key exists" do
+      context "and is a string" do
+        before do
+          lorentz.set("chunky", "bacon")
+        end
+        it "should tack value on to end of string" do
+          lorentz.append("chunky", " is yummy")
+          lorentz.get("chunky").should == "bacon is yummy"
+        end
+         it "should return length of value" do
+          lorentz.append("chunky", " is yummy").should eq("bacon is yummy".length)
+         end
+      end
+
+      context "and is not a string" do
+        before do
+          lorentz.set("chunky", 1)
+        end
+
+        it "should raise an error" do
+          expect do
+            lorentz.append("chunky", "bacon")
+          end.to raise_error(LorentzException)
+        end
+      end
+    end
+
+    context "when key doesn't exist" do
+      it "should return 'OK'" do
+        lorentz.append("chunky", "bacon").should == "OK"
+      end
+      it "should set the key to be an empty string" do
+        lorentz.append("chunky", "bacon")
+        lorentz.get("chunky").should be_empty
+      end
+    end
+  end
+
+  describe "#strlen" do
+    context "when key exists" do
+      before do
+        lorentz.set("chunky", "baconz")
+        lorentz.set("foo", ["bar"])
+      end
+      it "should return length of string value" do
+        lorentz.strlen("chunky").should eq(6)
+      end
+
+      it "should raise an error if value isn't a string" do
+        expect do
+          lorentz.strlen("foo")
+        end.to raise_error(LorentzException)
+      end
+    end
+
+    context "when key doesn't exist" do
+      it "should return 0" do
+        lorentz.strlen("chunky").should eq(0)
+      end
+    end
+  end
+end

data/spec/lorentz_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Lorentz do
+  context "default" do
+    its(:db) { should be_empty }
+    its(:db) { should be_a(Hash) }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.require(:default, :test)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle` to install missing gems"
+  exit e.status_code
+end
+
+require 'lorentz'
+require 'rspec'
+
+RSpec.configure do |config|
+  config.before(:each) do
+    ::Maglev.abort_transaction
+    ::Maglev::PERSISTENT_ROOT.delete_if do |key, val|
+      key.to_s =~ /^lorentz_db_.*$/
+    end
+    ::Maglev.commit_transaction
+  end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification 
+name: lorentz
+version: !ruby/object:Gem::Version 
+  hash: 856480538658449761
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Jesse Cooke
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-23 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 2489593565405618356
+        segments: 
+        - 2
+        - 6
+        - 0
+        version: 2.6.0
+  type: :development
+  version_requirements: *id001
+description: You know, for _why day!
+email: 
+- jesse@jc00ke.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- README.md
+- Rakefile
+- lib/lorentz.rb
+- lib/lorentz/exceptions.rb
+- lib/lorentz/glob.rb
+- lib/lorentz/keys.rb
+- lib/lorentz/strings.rb
+- lib/lorentz/version.rb
+- lorentz.gemspec
+- spec/lorentz/glob_spec.rb
+- spec/lorentz/keys_spec.rb
+- spec/lorentz/strings_spec.rb
+- spec/lorentz_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: https://github.com/jc00ke/lorentz
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 2002549777813010636
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 2002549777813010636
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: lorentz
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Take one Redis, stick it on MagLev
+test_files: []
+