stash 1.0.0 → 2.0.0

data/README.markdown

@@ -1,92 +0,0 @@
-Stash
-=====
-
-*"The sloping companion I cast down the ash, yanked on my tunic and dangled my stash"*
-
-Stash provides Ruby-like classes for interacting with data structures servers.
-Presently the only such server supported is Redis, however support is planned
-for Membase, Memcache, and possibly Kestrel.
-
-Initializing Stash
-------------------
-
-Stash supports multiple connections which are initialized through the
-stash Stash.setup command. Stash operates primarily through the default
-connection:
-
-    Stash.setup :default, :adapter => :redis, :host => 'localhost'
-    
-This will connect to the Redis server listening on localhost. Stash.setup
-takes an options hash with the following parameters:
-
-- **adapter**: must be "redis" (*mandatory*)
-- **host**: hostname or IP address of the Redis server (*mandatory*)
-- **port**: port of the Redis server (*optional, default 6379*)
-- **namespace**: Redis namspace to use (*optional, default global namespace*)
-- **password**: password to the Redis server (*optional*)
-
-Strings
--------
-
-The core type exposed by Stash is a string. You can store a string in the
-default Stash using:
-
-    Stash[:foobar] = "mystring"
-    
-This string can be retrieved as easily as:
-
-    Stash[:foobar]
-    
-And deleted with:
-
-    Stash.delete :foobar
-    
-Lists
------
-
-Stash supports a mostly ordered list type. You can retrieve a list with:
-
-    Stash::List[:baz]
-    
-Stash Lists support most of the methods you'd expect on the Ruby Array type.
-They are enumerable and support all of Ruby's Enumerable methods.
-
-You can push elements onto the list with:
-
-    Stash::List[:baz] << 'asdf'
-    
-And pop them with:
-
-    Stash::List[:baz].pop
-    
-Lists can be converted to arrays with:
-
-    Stash::List[:baz].to_a
-    
-Or iterated with:
-
-    Stash::List[:baz].each { |elem| ... }
-    
-Stash asks you to think of lists as being somewhat loosely ordered. This 
-means that Stash will make its best effort to give you a list in order, 
-however that order may shift around depending on how the backend storage 
-system is implemented. Distributed systems may be interesting properties.
-    
-Hashes
-------
-
-Stash hashes work like Ruby hashes. You can retrieve a Stash::Hash with:
-
-    Stash::Hash[:qux]
-    
-You can set members of a Stash::Hash with:
-
-    Stash::Hash[:qux][:omgwtf] == "bbq"
-   
-or retrieve them with:
-
-    Stash::Hash[:qux][:omgwtf]
-    
-You can convert a Stash::Hash to a Ruby hash with:
-
-    Stash::Hash[:qux].to_hash

data/Rakefile

@@ -1,46 +0,0 @@
-require 'rubygems'
-require 'rake'
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "stash"
-    gem.summary = "Abstract interface to data structures servers"
-    gem.description = "Stash maps the facilities provided by data structures servers onto classes which mimic Ruby's built-in types"
-    gem.email = "tony@medioh.com"
-    gem.homepage = "http://github.com/tarcieri/stash"
-    gem.authors = ["Tony Arcieri"]
-    gem.add_dependency "redis", "~> 2.1.0"
-    gem.add_dependency "redis-namespace", "~> 0.10.0"
-    gem.add_development_dependency "rspec", ">= 2.2.0"
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
-end
-
-require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(:rspec) do |rspec|
-  rspec.rspec_opts = %w[-fs -c -b]
-end
-
-RSpec::Core::RakeTask.new(:rcov) do |rspec|
-  rspec.rspec_opts = %w[-fs -c -b]
-  rspec.rcov = true
-end
-
-task :rspec => :check_dependencies
-task :spec  => :rspec
-
-task :default => :rspec
-
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "stash #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end

data/VERSION

@@ -1 +0,0 @@
-1.0.0

data/lib/stash/class_methods.rb

@@ -1,59 +0,0 @@
-class Stash
-  # Configuration error
-  class ConfigError < StandardError; end
-  
-  module ClassMethods
-    def [](key)
-      default[key]
-    end
-    
-    def []=(key, value)
-      default[key] = value
-    end
-    
-    # Add a configuration entry to Stash
-    def setup(label, configuration)
-      @configurations ||= {}
-      @configurations[label.to_sym] = configuration
-      
-      if label == :default
-        @default = nil
-        default
-      end
-    end
-  
-    # Retrieve the default Stash configuration
-    def default
-      @default ||= begin
-        raise ConfigError, "please configure me with Stash.setup" unless @configurations
-        raise ConfigError, "no default configuration" unless @configurations[:default]
-        new(@configurations[:default])
-      end
-    end
-    
-    # Retrieve a particular Stash configuration
-    def configuration(key)
-      @configurations[key.to_sym]
-    end
-    
-    # Delete a key from the Stash
-    def delete(key)
-      default.delete(key)
-      true
-    end
-    
-    # Obtain the class for a given adapter name
-    def adapter_class(name)
-      adapter_name = name.to_s.split('_').map { |s| s.capitalize }.join
-      adapter_name << "Adapter"
-      
-      begin
-        Stash.const_get adapter_name
-      rescue NameError
-        raise ArgumentError, "unknown adapter: #{name}"
-      end
-    end
-  end
-  
-  extend ClassMethods
-end

data/lib/stash/hash.rb

@@ -1,62 +0,0 @@
-# Stash::Hashes are remotely located lookup tables
-class Stash::Hash
-  include Enumerable
-  
-  def self.[](key)
-    new(key)
-  end
-  
-  def initialize(key, adapter = Stash.default.adapter)
-    @name, @adapter = key.to_s, adapter
-  end
-  
-  # Retrieve the value associated with a given key
-  def [](key)
-    @adapter.hash_get @name, key.to_s
-  end
-  
-  # Set a value in the hash
-  def []=(key, value)
-    @adapter.hash_set @name, key.to_s, value.to_s
-  end
-  
-  # Clear all elements from the hash
-  def clear
-    @adapter.delete @name
-    self
-  end
-  
-  # Delete a value from the hash
-  def delete(key)
-    @adapter.hash_delete @name, key.to_s
-  end
-  
-  # Return the length of a hash
-  def length
-    @adapter.hash_length @name
-  end
-  
-  # Is this hash empty?
-  def empty?
-    length == 0
-  end
-  
-  # Cast to a Ruby hash
-  def to_hash
-    @adapter.hash_value @name
-  end
-  
-  # Enumerate hashes
-  def each(&block)
-    to_hash.each(&block)
-    self
-  end
-  
-  # Inspect a hash
-  def inspect
-    "#<Stash::Hash[:#{@name}]: #{to_hash.inspect}>"
-  end
-  
-  # Create a string representation of a hash
-  alias_method :to_s, :inspect
-end

data/lib/stash/list.rb

@@ -1,91 +0,0 @@
-# Stash::Lists are (mostly) ordered lists stored remotely on the server
-class Stash::List
-  include Enumerable
-  
-  def self.[](key)
-    new(key)
-  end
-  
-  def initialize(key, adapter = Stash.default.adapter)
-    @key, @adapter = key.to_s, adapter
-  end
-  
-  # Cast to an array
-  def to_ary
-    @adapter.list_range @key, 0, length
-  end
-  alias_method :to_a, :to_ary
-  
-  # Get the length of a list
-  def length
-    @adapter.list_length(@key)
-  end
-  
-  # Is this list empty?
-  def empty?
-    length == 0
-  end
-  
-  # Clear all elements from the list
-  def clear
-    @adapter.delete @key
-    self
-  end
-  
-  # Push an element onto the list (i.e. right push)
-  def push(elem)
-    @adapter.list_push @key, elem.to_s, :right
-    self
-  end
-  alias_method :<<, :push
-  alias_method :rpush, :push
-  
-  # Unshift an element onto the list (i.e. left push)
-  def unshift(elem)
-    @adapter.list_push @key, elem.to_s, :left
-  end
-  alias_method :lpush, :unshift
-  
-  # Pop from a list (i.e. right pop)
-  def pop
-    @adapter.list_pop @key, :right
-  end
-  alias_method :rpop, :pop
-  
-  # Shift from a list (i.e. left pop)
-  def shift
-    @adapter.list_pop @key, :left
-  end
-  alias_method :lpop, :shift
-  
-  # Blocking shift: wait for a message to be pushed (with an optional timeout)
-  def bshift(timeout = nil)
-    @adapter.list_blocking_pop @key, :left, timeout
-  end
-  alias_method :blpop, :bshift
-  
-  # Blocking pop: wait for a message to be unshifted (with an optional timeout)
-  def bpop(timeout = nil)
-    @adapter.list_blocking_pop @key, :right, timeout
-  end
-  alias_method :brpop, :bpop
-  
-  # Iterate the list
-  def each(&block)
-    to_ary.each(&block)
-    self
-  end
-  
-  # Obtain the last element in a list
-  def last
-    to_ary[-1]
-  end
-  
-  # Inspect a list
-  def inspect
-    "#<Stash::List[:#{@key}]: #{to_ary.inspect}>"
-  end
-  
-  # Create a string representation of a list
-  alias_method :to_s, :inspect
-end

data/lib/stash/redis_adapter.rb

@@ -1,152 +0,0 @@
-require 'redis'
-require 'redis-namespace'
-
-class Stash
-  # Adapter for the Redis data structures server. 
-  # See http://code.google.com/p/redis/
-  class RedisAdapter    
-    def initialize(config)
-      # Convert config keys to symbols
-      config = symbolize_config(config)
-      
-      raise ArgumentError, "missing 'host' key" unless config[:host]
-      config[:port] ||= 6379 # Default Redis port
-      
-      @config = config
-    end
-
-    # Obtain a connection to Redis
-    def connection
-      redis = Redis.new @config
-      redis = Redis::Namespace.new @config[:namespace], :redis => redis if @config[:namespace]
-      
-      begin
-        yield redis
-      ensure
-        redis.quit
-      end
-    end
-    
-    # Set a given key within Redis
-    def []=(key, value)
-      connection { |redis| redis.set key.to_s, value.to_s }
-    end
-    
-    # Retrieve a given key from Redis
-    def [](key)
-      case type(key)
-      when "none"   then nil
-      when "string" then Stash::String.new key, self
-      when "list"   then Stash::List.new   key, self
-      else raise "unknown Redis key type: #{key}"
-      end
-    end
-    
-    # Retrieve the type for a given key
-    def type(key)
-      connection { |redis| redis.type key.to_s }
-    end
-    
-    # Retrieve a key as a string
-    def get(key)
-      connection { |redis| redis.get key.to_s }
-    end
-    
-    # Delete a key
-    def delete(key)
-      connection { |redis| redis.del key.to_s }
-    end
-    
-    # Push an element onto a list
-    def list_push(name, value, side)
-      connection do |redis|
-        case side
-        when :right
-          redis.rpush name.to_s, value.to_s
-        when :left
-          redis.lpush name.to_s, value.to_s
-        else raise ArgumentError, "left or right plztks"
-        end
-      end
-    end
-        
-    # Pop from a list
-    def list_pop(name, side)
-      connection do |redis|
-        case side
-        when :right
-          redis.rpop name.to_s
-        when :left
-          redis.lpop name.to_s
-        else raise ArgumentError, "left or right plztks"
-        end
-      end
-    end
-    
-    # Blocking pop from a list
-    def list_blocking_pop(name, side, timeout = nil)
-      connection do |redis|
-        timeout ||= 0
-        res = case side
-        when :left
-          redis.blpop name, timeout
-        when :right
-          redis.brpop name, timeout
-        else raise ArgumentError, "left or right plztks"
-        end
-      
-        return res[1] if res
-        raise Stash::TimeoutError, "request timed out"
-      end
-    end
-    
-    # Retrieve the length of a list
-    def list_length(name)
-      connection { |redis| redis.llen name.to_s }
-    end
-    
-    # Retrieve the given range from a list
-    def list_range(name, from, to)
-      connection { |redis| redis.lrange name.to_s, from, to }
-    end
-    
-    # Retrieve a value from a hash
-    def hash_get(name, key)
-      res = connection { |redis| redis.hget name.to_s, key.to_s }
-      return if res == ""
-      res
-    end
-    
-    # Store a value in a hash
-    def hash_set(name, key, value)
-      connection { |redis| redis.hset name.to_s, key.to_s, value.to_s }
-    end
-    
-    # Retrieve the contents of a hash as a Ruby hash
-    def hash_value(name)
-      connection { |redis| redis.hgetall name.to_s }
-    end
-    
-    # Delete an entry from a hash
-    def hash_delete(name, key)
-      connection { |redis| redis.hdel name.to_s, key.to_s }
-    end
-    
-    # Return the length of a hash
-    def hash_length(name)
-      connection { |redis| redis.hlen name.to_s }
-    end
-    
-    #######
-    private
-    #######
-    
-    def symbolize_config(config)
-      new_config = {}
-      config.each do |k, v|
-        new_config[k.to_sym] = v
-      end
-      new_config
-    end
-  end
-end