redis_array 0.1.0

data/.document

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

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,23 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+gem 'redis'
+gem 'rake'
+gem 'jeweler'
+
+group :development do
+  gem 'guard', "~> 1.6.0"
+  gem "guard-rspec",      "~> 1.2.0"
+  gem 'rb-inotify', "~> 0.9.0", :require => false
+  gem 'rb-fsevent', "~> 0.9.3", :require => false
+  gem 'rb-fchange', "~> 0.0.6", :require => false
+end
+
+group :test do
+  gem "rspec", "~> 2.8.0"
+  gem "fakeredis", :require => "fakeredis/rspec", :git => "git://github.com/guilleiguaran/fakeredis.git"
+end

data/Guardfile

@@ -0,0 +1,5 @@
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 James Richard
+
+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,76 @@
+= redis_array
+
+This library provides a way to store Ruby arrays in redis with *little* fuss. You're free to store anything that can be
+converted to a string and other arrays that contain objects that can be converted into a string. Anything else will throw
+an error because Redis only supports string storage. In addition, if you store a value that is not a string but can
+be converted into a string, such as an integer, when you access the value it will be a string. A work-around will be
+developed in the near future to support serialized objects and typecasting, though.
+
+redis_array works by creating a list in redis for each array. Array keys are unique, so you cannot have multiple
+"test" keys, for example.
+
+```ruby
+list1 = RedisArray.new("list1") # Redis key will be redisarray:list1
+list2 = RedisMultiList.new("list2") # Redis key will be redisarray:list2
+list1.push list2 # The value of index 0 in the list redisarray:list1 will be redisarray:~>list2
+list1[0] # Will return a RedisArray object representing the values within redisarray:list2
+```
+
+All retreival actions are done through Redis, so you don't have to worry about concurrency between processes when
+accessing a List, or creating a different list instance using the same key.
+
+redis_array attempts to act more like a Ruby Array then a Redis List. For example, LPOP in redis removes the first
+item within a list, whereas #pop on a RedisArray instance will remove the last.
+
+== Configuration
+
+redis_array needs to have a redis connection to work properly. Where ever you open your Redis connection you should set it.
+For example:
+
+```ruby
+redis = Redis.new(ENV['OPENREDIS_URI'])
+RedisArray.redis = redis
+```
+
+redis_array namespaces the arrays it stores. By default, it uses "redisarray". Feel free to change it to
+whatever works and is unique.
+
+== Usage
+
+Use RedisArray.new("list-name") to create or obtain a list. If the list already exists in Redis this will not create
+a new one; it will just access the existing. You can also use RedisArray.get("list-name"), which is just an alias for
+new. Use this whether the list already exists or not. Nothing will be added into redis until a value is pushed in. You
+can also call it without a list name, and a random one will be generated for you:
+
+```
+RedisArray.new
+=> #<RedisArray:0x007fba4c4503b8 @key="e5f0dfbfa8fdcf2cef63f4ca6369a98c">
+```
+
+Each RedisArray instance supports the following methods, which behave like the Ruby Array class, along
+with including the Enumerable module: [], all, count, []=, <<, +, push, pop, delete_at, delete, and clear.
+
+== Gotchas
+
+Redis doesn't include a way to delete by index. We've implemented a way to handle that process, but it is going to be
+slow, and there's a chance of concurrency issues. I'll work on making a better way to handle the process itself, but
+until delete-by-index is supported using that method should be avoided. It's better to delete by value.
+
+Concatenating a List will append the rvalue to the list, rather then make a new one composed of the two values. This is
+to maintain the key layout, but it is useful to add many items at once by providing them in an array.
+
+== Contributing to redis_array
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2013 James Richard. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "redis_array"
+  gem.homepage = "http://github.com/byliner/redis_array"
+  gem.license = "MIT"
+  gem.summary = %Q{Easy Multi Dimensional Arrays in Redis}
+  gem.description = %Q{Create persistent, redis-backed arrays with a simple, familiar syntax}
+  gem.email = "ketzu@me.com"
+  gem.authors = ["James Richard"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "redis_array #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

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

data/lib/redis_array.rb

@@ -0,0 +1,207 @@
+require 'redis'
+require 'securerandom'
+
+class RedisArray
+  include Enumerable
+  attr_reader :key
+  
+  def self.redis=(redis)
+    raise InvalidRedisInstanceError unless redis.is_a?(Redis)
+    @@redis = redis
+  end
+
+  def self.redis
+    @@redis
+  end
+
+  def self.get(key)
+    raise NoRedisConnectionError if !defined?(@@redis) || @@redis.nil?
+    RedisArray.new(key)
+  end
+
+  def self.namespace=(namespace)
+    @@namespace = namespace
+  end
+
+  def self.namespace
+    (defined?(@@namespace) && !@@namespace.nil?) ? @@namespace : "redisarray"
+  end
+
+  def initialize(key = nil)
+    @key = key.nil? ? generated_key : key
+  end
+
+  # -- Selection / Iteration
+  def each
+    @@redis.lrange(namespaced_key, 0, @@redis.llen(namespaced_key)).each do |value|
+      if sublist?(value)
+        yield RedisArray.new(remove_namespace(value))
+      else
+        yield value
+      end
+    end
+  end
+
+  def [](index)
+    value = @@redis.lindex(namespaced_key, index)
+    return nil if value.nil?
+    sublist?(value) ? RedisArray.new(remove_namespace(value)) : value
+  end
+
+  def all
+    array = @@redis.lrange(namespaced_key, 0, @@redis.llen(namespaced_key))
+    array.each_with_index do |value, i|
+      array[i] = RedisArray.new(remove_namespace(value)) if sublist?(value)
+    end
+
+    array
+  end
+
+  def count
+    @@redis.llen(namespaced_key)
+  end
+
+  # -- Comparison
+  # In the case where comp is another RedisArray object we just compare the key
+  # We don't want to be comparing redis values because the results will be the same
+  # if the keys match
+  def ==(comp)
+    comp.is_a?(RedisArray) ? @key == comp.key : to_a == comp
+  end
+
+  # -- Conversion
+  # This returns a raw, deep array
+  def to_a
+    array = all
+    array.each_with_index do |value, i|
+      array[i] = value.to_a if value.is_a?(RedisArray)
+    end
+  end
+
+  # -- Modification
+  def []=(index, value)
+    value = storable_value(value)
+
+    if index > 0 && !@@redis.exists(namespaced_key)
+      index.times { @@redis.rpush(namespaced_key, "") }
+    end
+
+    llen = @@redis.llen(namespaced_key)
+
+    if index < llen
+      @@redis.lset(namespaced_key, index, value)
+    else
+      (index - llen).times { @@redis.rpush(namespaced_key, "") }
+      @@redis.rpush(namespaced_key, value)
+    end
+  end
+
+  def <<(value)
+    push(value)
+  end
+
+  def +(value)
+    if value.is_a?(Array)
+      value.each do |item|
+        push(item)
+      end
+    else
+      push(value)
+    end
+  end
+
+  def push(value)
+    @@redis.rpush(namespaced_key, storable_value(value))
+  end
+
+  def pop
+    @@redis.ltrim(namespaced_key, 0, -2)
+  end
+
+  # Redis doesn't support delete at index, so we're copying the values in redis, keeping all but the index we're
+  # removing, deleting the list, and reloading it. Due to the complexity of this call it is recommended that you
+  # do not use it.
+  def delete_at(index)
+    len = count
+    values = @@redis.lrange(namespaced_key, 0, len-1)
+    @@redis.multi do
+      new_values = []
+
+      values.each_with_index do |value, i|
+        new_values << value unless i == index
+      end
+
+      @@redis.del(namespaced_key)
+      new_values.each do |value|
+        @@redis.rpush(namespaced_key, value)
+      end
+    end
+  end
+
+  def delete(value)
+    value = value.is_a?(RedisArray) ? sublist_value(value) : value
+    @@redis.lrem(namespaced_key, 0, value)
+  end
+
+  def clear
+    @@redis.del(namespaced_key)
+  end
+
+  # -- Storage helpers
+  def self.namespaced_key_for(key)
+    "#{RedisArray.namespace}:#{key}"
+  end
+
+  def namespaced_key
+    RedisArray.namespaced_key_for(@key)
+  end
+
+  protected
+
+  def remove_namespace(key)
+    @@_remove_namespace_regex ||= Regexp.new("#{RedisArray.namespace}:(~>)?(.+)")
+    key.match(@@_remove_namespace_regex)[2]
+  end
+
+  def storable_value(value)
+    raise ArgumentError, "The value  #{value} does not represent a list, is not a string, and cannot be made a string" unless value_storable?(value)
+    determine_stored_value(value)
+  end
+
+  def value_storable?(value)
+    return true if value.is_a?(RedisArray) || value.is_a?(Array)
+    return true if value.respond_to? :to_s
+    false
+  end
+
+  def determine_stored_value(value)
+    if value.is_a?(RedisArray)
+      sublist_value(value)
+    elsif value.is_a?(Array)
+      list = RedisArray.new
+      value.each do |subvalue|
+        list << subvalue
+      end
+
+      sublist_value(list)
+    else
+      value.to_s
+    end
+  end
+
+  def generated_key
+    SecureRandom.hex
+  end
+
+  def sublist?(value)
+    @@_sublist_matcher = Regexp.new("^#{RedisArray.namespace}:~>")
+    value.match(@@_sublist_matcher)
+  end
+
+  def sublist_value(list)
+    "#{RedisArray.namespace}:~>#{list.key}"
+  end
+end
+
+class NoRedisConnectionError < StandardError; end
+class InvalidRedisInstanceError < StandardError; end

data/redis_array.gemspec

@@ -0,0 +1,72 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "redis_array"
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["James Richard"]
+  s.date = "2013-02-08"
+  s.description = "Create persistent, redis-backed arrays with a simple, familiar syntax"
+  s.email = "ketzu@me.com"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "Guardfile",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/redis_array.rb",
+    "redis_array.gemspec",
+    "spec/redis_array_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = "http://github.com/byliner/redis_array"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.24"
+  s.summary = "Easy Multi Dimensional Arrays in Redis"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<redis>, [">= 0"])
+      s.add_runtime_dependency(%q<rake>, [">= 0"])
+      s.add_runtime_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<guard>, ["~> 1.6.0"])
+      s.add_development_dependency(%q<guard-rspec>, ["~> 1.2.0"])
+      s.add_development_dependency(%q<rb-inotify>, ["~> 0.9.0"])
+      s.add_development_dependency(%q<rb-fsevent>, ["~> 0.9.3"])
+      s.add_development_dependency(%q<rb-fchange>, ["~> 0.0.6"])
+    else
+      s.add_dependency(%q<redis>, [">= 0"])
+      s.add_dependency(%q<rake>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<guard>, ["~> 1.6.0"])
+      s.add_dependency(%q<guard-rspec>, ["~> 1.2.0"])
+      s.add_dependency(%q<rb-inotify>, ["~> 0.9.0"])
+      s.add_dependency(%q<rb-fsevent>, ["~> 0.9.3"])
+      s.add_dependency(%q<rb-fchange>, ["~> 0.0.6"])
+    end
+  else
+    s.add_dependency(%q<redis>, [">= 0"])
+    s.add_dependency(%q<rake>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<guard>, ["~> 1.6.0"])
+    s.add_dependency(%q<guard-rspec>, ["~> 1.2.0"])
+    s.add_dependency(%q<rb-inotify>, ["~> 0.9.0"])
+    s.add_dependency(%q<rb-fsevent>, ["~> 0.9.3"])
+    s.add_dependency(%q<rb-fchange>, ["~> 0.0.6"])
+  end
+end
+

data/spec/redis_array_spec.rb

@@ -0,0 +1,306 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe RedisArray do
+  after :each do
+    if defined?(Redis::Connection::Memory) # fake redis
+      Redis::Connection::Memory.reset_all_databases
+    else # Sometimes we test against a live redis connection.
+      RedisArray.redis.del(RedisArray.redis.keys("#{RedisArray.namespace}:*"))
+    end
+  end
+
+  context "defining redis" do
+    before(:each) do
+      RedisArray.class_variable_set :@@redis, nil
+    end
+
+    it "provides an interface to set the redis instance" do
+      RedisArray.respond_to?(:redis=).should be_true
+    end
+
+    it "raises a InvalidRedisInstanceError if we attempt to set redis to a non-redis instance" do
+      expect { RedisArray.redis = Array.new }.to raise_exception InvalidRedisInstanceError
+    end
+
+    it "can return the redis instance" do
+      redis = Redis.new
+      RedisArray.redis = redis
+      RedisArray.redis.should == redis
+    end
+  end
+
+  context "getting lists" do
+    before(:each) do
+      RedisArray.class_variable_set :@@redis, nil
+    end
+
+    it "raises a NoRedisConnectionError if we attempt to use get without a redis connection" do
+      expect { RedisArray.get("some key") }.to raise_exception NoRedisConnectionError
+    end
+
+    it "returns a RedisArray object representing the key" do
+      RedisArray.redis = Redis.new
+      list = RedisArray.get("test")
+      list.should be_an_instance_of RedisArray
+      list.key.should == "test"
+    end
+  end
+
+  context "namespacing" do
+    before(:each) do
+      RedisArray.class_variable_set :@@namespace, nil
+    end
+
+    it "can set a custom namespace" do
+      RedisArray.namespace = "rml"
+      RedisArray.namespace.should == "rml"
+    end
+
+    it "sets a default key namespace to RedisArray" do
+      RedisArray.namespace.should == "redisarray"
+    end
+  end
+
+  context "list usage" do
+    before(:each) do
+      RedisArray.redis = Redis.new
+    end
+
+    context "element access" do
+      it "can access a random item within the list" do
+        k = namespaced_key("test")
+        RedisArray.redis.rpush(k, "test-value")
+        RedisArray.redis.rpush(k, "test-value2")
+        list = RedisArray.new("test")
+        list[0].should == "test-value"
+        list[1].should == "test-value2"
+      end
+
+      it "returns nil if the index does not exist within the list" do
+        k = namespaced_key("test")
+        RedisArray.redis.rpush(k, "test-value")
+        RedisArray.redis.rpush(k, "test-value2")
+        list = RedisArray.new("test")
+        list[2].should be_nil
+      end
+
+      it "can set a random item within the list that has already been set" do
+        k = namespaced_key("test")
+        RedisArray.redis.rpush(k, "test-value")
+        list = RedisArray.new("test")
+        list[0] = "test-value2"
+        RedisArray.redis.lindex(k, 0).should == "test-value2"
+      end
+
+      it "can set a random item within the list that has not been set" do
+        k = namespaced_key("test")
+        list = RedisArray.new("test")
+        list[0] = "test-value0"
+        list[4] = "test-value4"
+        RedisArray.redis.lrange(k, 0, 5).should == ["test-value0", "", "", "", "test-value4"]
+      end
+
+      it "can append an item to the list" do
+        k = namespaced_key("test")
+        list = RedisArray.new("test")
+        list << "test-value0"
+        RedisArray.redis.lindex(k, 0).should == "test-value0"
+      end
+
+      it "can set a sub list within a list that has been set" do
+        k = namespaced_key("test")
+        RedisArray.redis.rpush(k, "test-value")
+        list = RedisArray.new("test")
+        sublist = RedisArray.new("test2")
+        list[0] = sublist
+        RedisArray.redis.lindex(k, 0).should == "redisarray:~>test2"
+      end
+
+      it "returns a List object when accessing subscript and the value points to a list" do
+        k = namespaced_key("test")
+        RedisArray.redis.rpush(k, "redisarray:~>test2")
+        list = RedisArray.new("test")
+        sublist = RedisArray.new("test2")
+        list[0].should == sublist
+      end
+
+      it "can set a sub list within a list that has not been set" do
+        k = namespaced_key("test")
+        list = RedisArray.new("test")
+        list[0] = RedisArray.new("test2")
+        RedisArray.redis.lindex(k, 0).should == "redisarray:~>test2"
+      end
+
+      it "can append a sub list within a list" do
+        k = namespaced_key("test")
+        list = RedisArray.new("test")
+        sublist = RedisArray.new("test2")
+        list << sublist
+        RedisArray.redis.lindex(k, 0).should == "redisarray:~>test2"
+      end
+
+      it "can store a sub list without a name" do
+        k = namespaced_key("test")
+        list = RedisArray.new("test")
+        sublist = RedisArray.new
+        list << sublist
+        RedisArray.redis.lindex(k, 0).should == "redisarray:~>#{sublist.key}"
+      end
+
+      it "can store a list without a name" do
+        list = RedisArray.new
+        list << "test-value"
+        RedisArray.redis.lindex("redisarray:#{list.key}", 0).should == "test-value"
+      end
+
+      it "can store a regular array as a sub list" do
+        k = namespaced_key("test")
+        list = RedisArray.new("test")
+        sublist = %w(test test2 test3)
+        list << sublist
+        k2 = "redisarray:#{list[0].key}"
+        RedisArray.redis.lindex(k, 0).should == "redisarray:~>#{list[0].key}"
+        RedisArray.redis.lrange("redisarray:#{list[0].key}", 0, 2).should == sublist
+      end
+
+      it "can loop through the elements in the list" do
+        k = namespaced_key("test")
+        RedisArray.redis.rpush(k, "test-value")
+        RedisArray.redis.rpush(k, "test-value2")
+        RedisArray.redis.rpush(k, "test-value3")
+        list = RedisArray.new("test")
+        list.each_with_index do |item, i|
+          case i
+            when 0 then item.should == "test-value"
+            when 1 then item.should == "test-value2"
+            when 2 then item.should == "test-value3"
+          end
+        end
+      end
+
+      it "can concatenate an array of items/lists" do
+        list = RedisArray.new("test")
+        sublist = RedisArray.new("subtest")
+        sublist << "subtest1"
+        sublist << "subtest2"
+        list += ["test1", "test2", sublist]
+        list.should == ["test1", "test2", ["subtest1", "subtest2"]]
+      end
+
+    end
+
+    it "can be converted into a plain array" do
+      list = RedisArray.new("test")
+
+      sublist1 = RedisArray.new("sublist1")
+      sublist1 << "subtest1-1"
+      sublist1 << "subtest1-2"
+
+      sublist2 = RedisArray.new("sublist2")
+      sublist2 << "subtest2-1"
+      sublist2 << "subtest2-2"
+
+      list << "test1"
+      list << "test2"
+      list << sublist1
+      list << "test3"
+      list << sublist2
+
+      list.to_a.should == ["test1", "test2", ["subtest1-1", "subtest1-2"], "test3", ["subtest2-1", "subtest2-2"]]
+    end
+
+    it "can determine the number of elements in the list" do
+      list = RedisArray.new("test")
+      list << "test1"
+      list << "test2"
+      list << "test3"
+      list.count.should == 3
+    end
+
+    it "can determine if there are any elements in the list" do
+      list = RedisArray.new("test")
+      list.any?.should_not be_true
+      list << "test1"
+      list.any?.should be_true
+    end
+
+    it "can remove an item from the list by index" do
+      k = namespaced_key("test")
+      RedisArray.redis.rpush(k, "test-value")
+      RedisArray.redis.rpush(k, "test-value2")
+      RedisArray.redis.rpush(k, "test-value3")
+      list = RedisArray.new("test")
+      list.delete_at(1)
+      RedisArray.redis.lrange(k, 0, 3).should == %w(test-value test-value3)
+    end
+
+    it "can pop the last element from a list" do
+      k = namespaced_key("test")
+      RedisArray.redis.rpush(k, "test-value")
+      RedisArray.redis.rpush(k, "test-value2")
+      RedisArray.redis.rpush(k, "test-value3")
+      list = RedisArray.new("test")
+      list.pop
+      RedisArray.redis.lrange(k, 0, 3).should == %w(test-value test-value2)
+    end
+
+    it "can remove all items from a list" do
+      k = namespaced_key("test")
+      RedisArray.redis.rpush(k, "test-value")
+      RedisArray.redis.rpush(k, "test-value2")
+      RedisArray.redis.rpush(k, "test-value3")
+      list = RedisArray.new("test")
+      list.clear
+      RedisArray.redis.exists(k).should_not be_true
+    end
+
+
+    it "can remove all items from a list as well as all sublists" do
+      pending "the addition of deep removals"
+    end
+
+    it "can remove an item matching a value from a list" do
+      k = namespaced_key("test")
+      RedisArray.redis.rpush(k, "test-value")
+      RedisArray.redis.rpush(k, "test-value2")
+      RedisArray.redis.rpush(k, "test-value3")
+      list = RedisArray.new("test")
+      list.delete("test-value")
+      RedisArray.redis.lrange(k, 0, 2).should == %w(test-value2 test-value3)
+    end
+
+    it "can remove a sublist from a list" do
+      k = namespaced_key("test")
+      RedisArray.redis.rpush(k, "test-value")
+      RedisArray.redis.rpush(k, "redisarray:~>test2")
+      RedisArray.redis.rpush(k, "test-value3")
+      list = RedisArray.new("test")
+      list2 = RedisArray.new("test2")
+      list.delete(list2)
+      RedisArray.redis.lrange(k, 0, 2).should == %w(test-value test-value3)
+    end
+
+    it "does not remove elements of a sublist when the sublist is removed from a parent list" do
+      k = namespaced_key("test")
+      k2 = "RedisArray:~>test2"
+      RedisArray.redis.rpush(k, k2)
+      RedisArray.redis.rpush(k2, "test-value")
+      RedisArray.redis.rpush(k2, "test-value2")
+
+      list = RedisArray.new("test")
+      list2 = RedisArray.new("test2")
+
+      list.delete(list2)
+      RedisArray.redis.lrange(k2, 0, 2).should == %w(test-value test-value2)
+    end
+
+    it "can remove a sublist from a list as well as all sublists" do
+      pending "the addition of deep removals"
+    end
+  end
+
+
+  def namespaced_key(key)
+    "#{RedisArray.namespace}:#{key}"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'redis_array'
+require 'fakeredis'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

metadata

@@ -0,0 +1,190 @@
+--- !ruby/object:Gem::Specification
+name: redis_array
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- James Richard
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: rb-inotify
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: rb-fsevent
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.3
+- !ruby/object:Gem::Dependency
+  name: rb-fchange
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.6
+description: Create persistent, redis-backed arrays with a simple, familiar syntax
+email: ketzu@me.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- .rspec
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/redis_array.rb
+- redis_array.gemspec
+- spec/redis_array_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/byliner/redis_array
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -873787881241495935
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Easy Multi Dimensional Arrays in Redis
+test_files: []