cache2base 0.0.5

data/Gemfile

@@ -0,0 +1,6 @@
+source :rubygems
+
+group :spec do
+  gem 'dalli'
+  gem 'rspec'
+end

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Jason Pearlman
+
+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,57 @@
+cache2base
+==========
+
+cache2base is a high performance Ruby orm for memcache and membase. Just set your models up and stop worrying about keys! 
+Also supports maintaining collections of keys for you.
+
+Installation and Usage
+------------------------
+
+	gem install cache2base
+	require 'cache2base'
+	Cache2base.init!(:server => Dalli::Client.new('localhost:11211'))
+  
+And create a model:
+
+	class MyModel4
+	  include Cache2base
+	  set_basename 'mm4'
+	  set_ttl 300 # 300 seconds
+	  set_fields :user_id, :first_name, :last_name
+	
+	  set_primary_key :user_id
+	  member_of_collection :first_name, :hash_key => true # People with the same first name!
+	end
+  
+And use that model:
+
+	m = MyModel4.new(:last_name => "lname", :user_id => 5) # creates an in-memory instance
+	m.first_name = 'fname' # all set_fields are given accessors
+	m.save # saves to memcache/base
+	
+	m2 = MyModel4.create(:last_name => "lname2", :first_name => 'fname', :user_id => 6) # auto create (.new, .save shortcut)
+	
+	fnames = MyModel4.all(:first_name => "fname") # returns array of model instances that share the same first name
+	                                              #=> [#<MyModel4:0x10133cd98 @last_name="lname", @new_instance=false, @first_name="fname", @user_id=5>, 
+	                                              #=>  #<MyModel4:0x10133c4d8 @last_name="lname2", @new_instance=false, @first_name="fname", @user_id=6>]
+	                                                  
+	m.delete # delete the first one
+	
+	MyModel4.all(:first_name => "fname") #=> [#<MyModel4:0x101264560 @last_name="lname2", @new_instance=false, @first_name="fname", @user_id=6>]
+
+Thanks
+------------
+
+Mike Perham and the dalli project for making the best ruby memcached/membase library - [Dalli](https://github.com/mperham/dalli)
+
+OMGPOP for providing a great environment for interesting ruby development - [OMGPOP](http://www.omgpop.com)
+
+Author
+------------
+
+Jason Pearlman, jason@omgpop.com / crash2burn@gmail.com
+
+Copyright
+-----------
+
+Copyright (c) 2011 Jason Pearlman. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,30 @@
+require 'rake/clean'
+CLEAN.include "**/*.rbc"
+CLEAN.include "**/.DS_Store"
+CLEAN.include "cache2base-*.gem"
+
+require File.expand_path("../lib/cache2base/version", __FILE__)
+
+NAME = 'cache2base'
+
+# Gem Packaging and Release
+
+desc "Packages cache2base"
+task :package=>[:clean] do |p|
+  sh %{gem build cache2base.gemspec}
+end
+
+desc "Install cache2base gem"
+task :install=>[:package] do
+  sh %{sudo gem install ./#{NAME}-#{Cache2base::VERSION} --local}
+end
+
+desc "Uninstall cache2base gem"
+task :uninstall=>[:clean] do
+  sh %{sudo gem uninstall #{NAME}}
+end
+
+desc "Upload cache2base gem to gemcutter"
+task :release=>[:package] do
+  sh %{gem push ./#{NAME}-#{Cache2base::VERSION}.gem} 
+end

data/cache2base.gemspec

@@ -0,0 +1,26 @@
+require './lib/cache2base/version'
+
+Gem::Specification.new do |s|
+  s.name = %q{cache2base}
+  s.version = Cache2base::VERSION
+
+  s.authors = ["Jason Pearlman"]
+  s.date = Time.now.utc.strftime("%Y-%m-%d")
+  s.description = %q{A ruby orm for memcache and membase}
+  s.email = %q{crash2burn@gmail.com}
+  s.files = Dir.glob("lib/**/*") + [
+     "LICENSE",
+     "README.md",
+     "History.md",
+     "Rakefile",
+     "Gemfile",
+     "cache2base.gemspec"
+  ]
+  s.homepage = %q{http://github.com/OMGPOP/cache2base}
+  s.has_rdoc = false  
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.summary = %q{A ruby orm for memcache and membase}
+  s.test_files = Dir.glob("test/**/*")
+  s.add_development_dependency(%q<rspec>, [">= 0"])
+end

data/lib/cache2base/core.rb

@@ -0,0 +1,253 @@
+module Cache2base
+  def self.included(klass) # :nodoc:
+    klass.class_eval "@basename ||= self.to_s"
+    klass.class_eval "@ttl ||= 0"
+    klass.class_eval "@collections ||= []"
+    klass.class_eval "@server ||= Cache2base.server"
+    klass.extend(ClassMethods)
+  end
+  
+  def self.init!(params = {})
+    @server = params[:server]
+  end
+  
+  def self.server
+    @server||MEMBASE
+  end
+  
+  def server
+    self.class.server
+  end
+  
+  def valid_primary_key?
+    self.class.primary_key.each { |f| return false if self.send(f).nil? }
+    true
+  end
+  
+  def initialize(hsh = {}, params = {})
+    @new_instance = params[:new_instance].nil? ? true : params[:new_instance]
+    hsh.each_pair do |k,v|
+      self.send(:"#{k}=", v)
+    end
+  end
+  
+  def new?
+    @new_instance
+  end
+  
+  def save
+    raise "Invalid Primary Key" unless valid_primary_key?
+    add_to_collections
+    result = @new_instance ? server.add(self.key, self.marshal, self.class.ttl) : server.set(self.key, self.marshal, self.class.ttl)
+    raise 'Duplicate Primary Key' unless result
+    @new_instance = false
+    self
+  end
+  
+  def delete
+    remove_from_collections
+    server.delete(self.key)
+  end
+  
+  def marshal
+    Marshal.dump(self.field_hash)
+  end
+  
+  def field_hash
+    o = {}
+    self.class.fields.each do |field|
+      o[field] = self.send(field) if !self.send(field).nil?
+    end
+    o
+  end
+  
+  def collection_key(field)
+    self.class.collection_key(Hash[Array(field).collect {|f| [f, self.send(f)]}])
+  end
+  
+  def add_to_collections
+    self.class.collections.each do |field|
+      raise "Could not add field #{field} collection" unless add_to_collection(field)
+    end
+  end
+  
+  def add_to_collection(field, loops = 0)
+    Array(field).each { |f| return 'could_not_add' if self.send(f).nil? } # still evaluates to true, so add_to_collections does not fail
+    success = server.cas(collection_key(field), self.class.ttl) do |value|
+      value << self.key unless value.include?(self.key)
+      value
+    end
+    
+    unless success
+      if success.nil?
+        success = server.add(collection_key(field), [self.key], self.class.ttl)
+        if success
+          return true
+        else
+          return loops < 5 ? add_to_collection(field, loops+1) : false
+        end
+      else
+        return loops < 5 ? add_to_collection(field, loops+1) : false
+      end
+    end
+    
+    success
+  end
+  
+  def remove_from_collections
+    self.class.collections.each do |field|
+      raise "Could not remove field #{field} collection" unless remove_from_collection(field)
+    end
+  end
+  
+  def remove_from_collection(field, loops=0)
+    Array(field).each { |f| return 'could_not_add' if self.send(f).nil? }
+    #return 'could_not_remove' if self.send(field).nil? # still evaluates to true, so remove_from_collections does not fail
+    success = server.cas(collection_key(field), self.class.ttl) do |value|
+      value.delete(self.key)
+      value
+    end
+    
+    unless success
+      if success.nil?
+        return true # return true because theres no collection to remove from
+      else
+        return loops < 5 ? remove_from_collection(field, loops+1) : false # race conditions
+      end
+    end
+    
+    success
+  end
+  
+  module ClassMethods    
+    def ttl
+      @ttl
+    end
+    
+    def set_ttl(i)
+      @ttl = i.to_i
+    end
+    
+    def set_basename(name)
+      @basename = name.to_s
+    end
+    
+    def primary_key
+      @primary_key
+    end
+    
+    def server
+      @server
+    end
+    
+    def set_primary_key(mk, params = {})
+      @primary_key = Array(mk)
+      #o = '#{self.class}'
+      #c = "#{self}"
+      #h = "#{self}"
+      o = []
+      c = []
+      h = []
+      Array(mk).each_with_index do |v, i|
+        o << '#{self.send(:'+v.to_s+').to_s.gsub(\'_\',\'-\')}'
+        c << '#{Array(pk)['+i.to_s+'].to_s.gsub(\'_\',\'-\')}'
+        h << '#{pk[0][:'+v.to_s+'].to_s.gsub(\'_\',\'-\')}'
+      end
+      
+      o = "#{@basename}_\#{#{params[:hash_key] ? "self.class.hash_key(\"#{o.join("_")}\")" : "\"#{o.join("_")}\""}}"
+      c = "#{@basename}_\#{#{params[:hash_key] ? "hash_key(\"#{c.join("_")}\")" : "\"#{c.join("_")}\""}}"
+      h = "#{@basename}_\#{#{params[:hash_key] ? "hash_key(\"#{h.join("_")}\")" : "\"#{h.join("_")}\""}}"
+      
+      class_eval "def key; \"#{o}\"; end"
+      class_eval "def self.key(*pk); pk.first.is_a?(Hash) ? \"#{h}\" : \"#{c}\"; end"
+    end
+    
+    def basename
+      @basename
+    end
+    
+    def hash_key(k)
+      Digest::SHA1.hexdigest(k.to_s)
+    end
+    
+    def set_fields(*fields)
+      @fields = @fields ? (@fields + (fields)) : (fields)
+      fields.each do |field|
+        class_eval "attr_accessor :#{field}"
+      end
+    end
+    
+    def set_field(field, params)
+      @fields ||= []
+      @fields << field
+      @field_meta ||= {}
+      if params[:hash]
+        @field_meta[field] ||= {}
+        @field_meta[field][:hash] = true
+      end
+      class_eval "attr_accessor :#{field}"
+    end
+    
+    def uses_hash?(field)
+      @field_meta[field] && @field_meta[field][:hash]
+    end
+    
+    def member_of_collection(fields, params = {})
+      fields = Array(fields).sort { |a,b| a.to_s <=> b.to_s }
+      @collections ||= []
+      @collections << fields
+      @hashed_collections ||= {}
+      @hashed_collections[fields.join(",").to_s] = true if params[:hash_key]
+    end
+    
+    def collections
+      @collections
+    end
+    
+    def collection_key(vhsh)
+      keys = vhsh.keys.sort {|a,b| a.to_s <=> b.to_s}
+      "#{@basename}_c_#{hash_collection?(keys) ? hash_key(keys.collect {|field| vhsh[field].to_s.gsub('_','-') }.join("_")) : keys.collect {|field| vhsh[field].to_s.gsub('_','-') }.join("_")}"
+    end
+    
+    def fields
+      @fields
+    end
+    
+    def hash_collection?(field)
+      @hashed_collections[Array(field).join(',').to_s]
+    end
+    
+    def find(fields, params = {})
+      o = server.get(key(fields))
+      return nil unless o
+      self.from_hash(Marshal.load(o))
+    end
+    
+    def find_by_key(key)
+      o = server.get(key)
+      return nil unless o
+      self.from_hash(Marshal.load(o))
+    end
+    
+    def find_by_keys(keys)
+      hsh = server.get_multi(keys)
+      keys.collect do |key| # to get it back in order since get_multi results in a hash
+        self.from_hash(Marshal.load(hsh[key]))
+      end.compact
+    end
+    
+    def from_hash(hsh)
+      self.new(hsh, :new_instance => false)
+    end
+    
+    def create(params)
+      o = self.new(params)
+      o.save
+    end
+    
+    def all(fields, params = {})
+      arr = server.get(collection_key(fields))
+      find_by_keys(Array(arr)).compact
+    end
+  end
+end

data/lib/cache2base/version.rb

@@ -0,0 +1,3 @@
+module Cache2base
+  VERSION = '0.0.5'
+end

data/lib/cache2base.rb

@@ -0,0 +1,3 @@
+require 'digest/sha1'
+require 'cache2base/core.rb'
+require 'cache2base/version.rb'

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: cache2base
+version: !ruby/object:Gem::Version 
+  hash: 21
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 5
+  version: 0.0.5
+platform: ruby
+authors: 
+- Jason Pearlman
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-23 00:00:00 -04: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: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: A ruby orm for memcache and membase
+email: crash2burn@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/cache2base/core.rb
+- lib/cache2base/version.rb
+- lib/cache2base.rb
+- LICENSE
+- README.md
+- History.md
+- Rakefile
+- Gemfile
+- cache2base.gemspec
+has_rdoc: true
+homepage: http://github.com/OMGPOP/cache2base
+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 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A ruby orm for memcache and membase
+test_files: []
+