restruct 0.0.1

data/lib/restruct/id.rb

@@ -0,0 +1,20 @@
+module Restruct
+  class Id < String
+    
+    attr_reader :separator
+
+    def initialize(id, separator=nil)
+      @separator = separator || Restruct.id_separator
+      super id.to_s
+    end
+
+    def [](id)
+      Id.new "#{to_s}#{separator}#{id}", separator
+    end
+
+    def sections
+      split(separator).map { |s| Id.new s, separator }
+    end
+
+  end
+end

data/lib/restruct/marshal_array.rb

@@ -0,0 +1,5 @@
+module Restruct
+  class MarshalArray < Array
+    include Marshalizable
+  end
+end

data/lib/restruct/marshal_hash.rb

@@ -0,0 +1,5 @@
+module Restruct
+  class MarshalHash < Hash
+    include Marshalizable
+  end
+end

data/lib/restruct/marshal_set.rb

@@ -0,0 +1,5 @@
+module Restruct
+  class MarshalSet < Set
+    include Marshalizable
+  end
+end

data/lib/restruct/marshalizable.rb

@@ -0,0 +1,13 @@
+module Restruct
+  module Marshalizable
+    
+    def serialize(element)
+      Marshal.dump element
+    end
+    
+    def deserialize(element)
+      Marshal.load element if element
+    end
+
+  end
+end

data/lib/restruct/nested_hash.rb

@@ -0,0 +1,108 @@
+module Restruct
+  class NestedHash
+    
+    def self.new(type)
+      Class.new Structure do
+
+        include Enumerable
+        
+        const_set :TYPE, type
+
+        def [](key)
+          self.class::TYPE.new id: id[key], redis: redis, parent: self
+        end
+
+        def fetch(key)
+          raise KeyError, "key not found: #{key}" unless key? key
+          self[key]
+        end
+
+        def delete(key)
+          self[key].tap(&:destroy)
+        end
+
+        def delete_if
+          each { |k,v| delete k if yield k, v }
+          self
+        end
+
+        def keep_if
+          each { |k,v| delete k unless yield k, v }
+          self
+        end
+        alias_method :select!, :keep_if
+
+        def clear
+          destroy
+          self
+        end
+
+        def keys
+          sections = id.sections.count + 1
+          redis.call('KEYS', id['*']).map do |k| 
+            Id.new(k).sections.take(sections).last
+          end.uniq.sort
+        end
+
+        def values
+          keys.map { |key| self[key] }
+        end
+
+        def values_at(*keys)
+          keys.map { |key| self[key] }
+        end
+
+        def key?(key)
+          keys.include? key.to_s
+        end
+        alias_method :has_key?, :key?
+
+        def size
+          keys.count
+        end
+        alias_method :count, :size
+        alias_method :length, :size
+
+        def empty?
+          size == 0
+        end
+
+        def each
+          keys.each { |key| yield key, self[key] }
+        end
+        alias_method :each_pair, :each
+
+        def each_key
+          each { |k,v| yield k }
+        end
+
+        def each_value
+          each { |k,v| yield v }
+        end
+        
+        def to_h
+          each_with_object({}) do |(key, value), hash|
+            hash[key] = value.respond_to?(:to_primitive) ? value.to_primitive : value
+          end
+        end
+        alias_method :to_primitive, :to_h
+
+        def dump
+          each_with_object({}) do |(key, value), hash|
+            hash[key] = value.dump
+          end
+        end
+
+        def restore(dump)
+          dump.each { |f,d| self[f].restore d }
+        end
+
+        def destroy
+          values.each(&:destroy)
+        end
+
+      end
+    end
+
+  end
+end

data/lib/restruct/set.rb

@@ -0,0 +1,119 @@
+module Restruct
+  class Set < Structure
+
+    include Enumerable
+    extend Forwardable
+
+    def_delegators :to_set, :union, :|, :+, 
+                            :intersection, :&, 
+                            :difference, :-,
+                            :proper_subset?, :subset?,
+                            :proper_superset?, :superset?,
+                            :^
+
+    def add(member)
+      _add member
+      self
+    end
+    alias_method :<<, :add
+
+    def add?(member)
+      _add(member) == 0 ? nil : self
+    end
+
+    def merge(members)
+      _add *members
+      self
+    end
+
+    def delete(member)
+      _delete member
+      self
+    end
+
+    def delete?(member)
+      _delete(member) == 0 ? nil : self
+    end
+
+    def subtract(members)
+      _delete *members
+      self
+    end
+
+    def delete_if
+      each { |e| delete e if yield e }
+      self
+    end
+
+    def keep_if
+      each { |e| delete e unless yield e }
+      self
+    end
+    alias_method :select!, :keep_if
+
+    def clear
+      destroy
+      self
+    end
+
+    def size
+      redis.call 'SCARD', id
+    end
+    alias_method :count, :size
+    alias_method :length, :size
+
+    def empty?
+      size == 0
+    end
+
+    def include?(member)
+      redis.call('SISMEMBER', id, serialize(member)) == 1
+    end
+
+    def each(&block)
+      to_a.each(&block)
+    end
+
+    def to_a
+      redis.call('SMEMBERS', id).map { |e| deserialize e }
+    end
+
+    def to_set
+      to_a.to_set
+    end
+    alias_method :to_primitive, :to_set
+    
+    alias_method :<, :proper_subset?
+    alias_method :<=, :subset?
+    alias_method :>, :proper_superset?
+    alias_method :>=, :superset?
+
+    def intersect?(set)
+      !disjoint? set
+    end
+
+    def disjoint?(set)
+      (to_a & set.to_a).empty?
+    end
+
+    private
+
+    def _add(*members)
+      redis.call 'SADD', id, *members.map { |m| serialize m }
+    end
+
+    def _delete(*members)
+      redis.call 'SREM', id, *members.map { |m| serialize m }
+    end
+
+
+    def serialize(string)
+      string
+    end
+
+    def deserialize(string)
+      string
+    end
+
+  end
+end

data/lib/restruct/structure.rb

@@ -0,0 +1,32 @@
+module Restruct
+  class Structure
+
+    attr_reader :redis, :id
+
+    def initialize(options={})
+      @redis = options[:redis] || Restruct.redis
+      @id = Id.new options[:id] || Restruct.generate_id
+    end
+
+    def ==(object)
+      object.class == self.class && 
+      object.id == id && 
+      object.redis == redis
+    end
+    alias_method :eql?, :==
+
+    def dump
+      redis.call 'DUMP', id
+    end
+
+    def restore(dump)
+      destroy
+      redis.call 'RESTORE', id, 0, dump
+    end
+
+    def destroy
+      redis.call 'DEL', id
+    end
+    
+  end
+end

data/lib/restruct/version.rb

@@ -0,0 +1,3 @@
+module Restruct
+  VERSION = '0.0.1'
+end

data/restruct.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'restruct/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'restruct'
+  spec.version       = Restruct::VERSION
+  spec.authors       = ['Gabriel Naiman']
+  spec.email         = ['gabynaiman@gmail.com']
+  spec.summary       = 'Redis structures'
+  spec.description   = 'Redis structures'
+  spec.homepage      = 'https://github.com/gabynaiman/restruct'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'redic',        '~> 1.1.1'
+  spec.add_dependency 'class_config', '~> 0.0.1'
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'minitest', '~> 4.7'
+  spec.add_development_dependency 'turn',     '~> 0.9'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'pry-nav'
+end

data/spec/array_spec.rb

@@ -0,0 +1,338 @@
+require 'minitest_helper'
+
+[Restruct::Array, Restruct::MarshalArray].each do |klass|
+
+  describe klass do
+
+    let(:array) { klass.new }
+
+    def fill(elements)
+      redis.call 'RPUSH', array.id, *(elements.map { |e| array.send(:serialize, e) })
+    end
+
+    describe 'Getters' do
+
+      it '[]' do
+        fill %w(a b c d e)
+
+        array[0].must_equal 'a'
+        array[1].must_equal 'b'
+        array[2].must_equal 'c'
+        array[6].must_be_nil
+
+        array[0..-1].must_equal %w(a b c d e)
+        array[1..3].must_equal %w(b c d)
+        array[4..7].must_equal ['e']
+        array[5..10].must_equal []
+        array[6..10].must_be_nil
+
+        array[-3,3].must_equal %w(c d e)
+        array[1,2].must_equal %w(b c)
+        array[5,1].must_equal []
+        array[6,1].must_be_nil
+       
+        error = proc { array[1,2,3,4] }.must_raise ArgumentError
+        error.message.must_equal 'wrong number of arguments (4 for 1..2)'
+       
+        error = proc { array['x'] }.must_raise TypeError
+        error.message.must_equal 'no implicit conversion from string to integer'
+      end
+
+      it 'at' do
+        fill %w(a b c d)
+
+        array.at(0).must_equal 'a'
+        array.at(1).must_equal 'b'
+        array.at(-1).must_equal 'd'
+        array.at(10).must_be_nil
+      end
+
+      it 'values_at' do
+        fill %w(a b c d e f)
+        
+        array.values_at(1, 3, 5).must_equal %w(b d f)
+        array.values_at(1, 3, 5, 7).must_equal ['b', 'd', 'f', nil]
+        array.values_at(-1, -2, -2, -7).must_equal ['f', 'e', 'e', nil]
+      end
+
+      it 'fetch' do
+        fill %w(a b c)
+
+        array.fetch(-1).must_equal 'c'
+        array.fetch(0).must_equal 'a'
+        array.fetch(4, 'x').must_equal 'x'
+        array.fetch(4) { |i| (i + 1).to_s }.must_equal '5'
+        
+        error = proc { array.fetch(4) }.must_raise IndexError
+        error.message.must_equal 'index 4 outside of array bounds: -3...3'
+      end
+
+      it 'first' do
+        fill %w(a b c)
+        array.first.must_equal 'a'
+      end
+
+      it 'last' do
+        fill %w(a b c)
+        array.last.must_equal 'c'
+      end
+
+    end
+
+    describe 'Setters' do
+
+      it '[]=' do
+        fill %w(a b c d)
+
+        (array[0] = 'x').must_equal 'x'
+        array.to_a.must_equal %w(x b c d)
+
+        (array[-1] = 'z').must_equal 'z'
+        array.to_a.must_equal %w(x b c z)
+
+        error = proc { array[10] = '.' }.must_raise IndexError
+        error.message.must_equal 'index 10 outside of array bounds: -4...4'
+
+        error = proc { array['k'] = '.' }.must_raise TypeError
+        error.message.must_equal 'no implicit conversion from string to integer'
+      end
+      
+      it 'push' do
+        fill %w(a b c)
+        
+        array.push('d').must_equal array
+        array.to_a.must_equal %w(a b c d)
+
+        array.push('x', 'y', 'z').must_equal array
+        array.to_a.must_equal %w(a b c d x y z)
+      end
+
+      it '<<' do
+        fill %w(a b c)
+        
+        (array << 'd').must_equal array
+        array.to_a.must_equal %w(a b c d)
+      end
+
+      it 'pop' do
+        fill %w(a b c d e f)
+
+        (array.pop).must_equal 'f'
+        array.to_a.must_equal %w(a b c d e)
+
+        (array.pop(2)).must_equal %w(d e)
+        array.to_a.must_equal %w(a b c)
+
+        (array.pop(5)).must_equal %w(a b c)
+        array.to_a.must_equal []
+      end
+
+      it 'shift' do
+        fill %w(a b c d e f)
+
+        (array.shift).must_equal 'a'
+        array.to_a.must_equal %w(b c d e f)
+
+        (array.shift(2)).must_equal %w(b c)
+        array.to_a.must_equal %w(d e f)
+
+        (array.shift(5)).must_equal %w(d e f)
+        array.to_a.must_equal []
+      end
+
+      it 'insert' do
+        fill %w(a b c d)
+
+        array.insert(0, 'A').must_equal array
+        array.to_a.must_equal %w(A a b c d)
+
+        array.insert(2, 'B', 'B').must_equal array
+        array.to_a.must_equal %w(A a B B b c d)
+
+        array.insert(-2, 'x', 'y', 'z').must_equal array
+        array.to_a.must_equal %w(A a B B b c x y z d)
+
+        array.insert(-5, 'w').must_equal array
+        array.to_a.must_equal %w(A a B B b c w x y z d)      
+      end
+
+      it 'concat' do
+        fill %w(a b c)
+
+        array.concat(%w(x y z)).must_equal array
+        array.to_a.must_equal %w(a b c x y z)
+      end
+
+      it 'delete' do
+        fill %w(a b a b a b)
+
+        array.delete('b').must_equal 'b'
+        array.to_a.must_equal %w(a a a)
+        
+        array.delete('c').must_be_nil
+        array.to_a.must_equal %w(a a a)
+      end
+
+      it 'delete_at' do
+        fill %w(a b c a b c a b c)
+
+        array.delete_at(3).must_equal 'a'
+        array.to_a.must_equal %w(a b c b c a b c)
+
+        array.delete_at(-4).must_equal 'c'
+        array.to_a.must_equal %w(a b c b a b c)
+
+        array.delete_at(10).must_be_nil
+        array.to_a.must_equal %w(a b c b a b c)
+      end
+
+      it 'delete_if' do
+        fill %w(a b c a b c a b c)
+
+        array.delete_if { |e| e == 'a' }.must_equal array
+        array.to_a.must_equal %w(b c b c b c)
+      end
+
+      %w(keep_if select!).each do |method|
+        it method do
+          fill %w(a b c a b c a b c)
+
+          array.send(method) { |e| e == 'a' }.must_equal array
+          array.to_a.must_equal %w(a a a)
+        end
+      end
+
+      it 'clear' do
+        fill %w(a b c d)
+
+        array.clear.must_equal array
+        array.must_be_empty
+      end
+
+    end
+
+    describe 'Info' do
+
+      %w(size count length).each do |method|
+        it method do
+          fill %w(a b c)
+          array.send(method).must_equal 3
+        end
+      end
+
+      it 'empty?' do
+        array.must_be :empty?
+        fill %w(a b c)
+        array.wont_be :empty?
+      end
+
+      it 'include?' do
+        fill %w(a b c)
+
+        assert array.include? 'a'
+        refute array.include? 'z'
+      end
+
+    end
+
+    describe 'Transformations' do
+
+      %w(to_a to_ary to_primitive).each do |method|
+        it method do
+          fill %w(a b c)
+          array.send(method).must_equal %w(a b c)
+        end
+      end
+
+      it 'join' do
+        fill %w(a b c)
+
+        array.join.must_equal 'abc'
+        array.join('-').must_equal 'a-b-c'
+      end
+
+      it 'uniq' do
+        fill %w(a1 a1 a2 a2 b1 b1 b2 b2)
+
+        array.uniq.must_equal %w(a1 a2 b1 b2)
+        array.uniq { |e| e[1] }.must_equal %w(a1 a2)
+      end
+
+      it 'reverse' do
+        fill %w(a b c)
+        array.reverse.must_equal %w(c b a)
+      end
+
+    end
+
+    describe 'Enumerable' do
+
+      it 'included module' do
+        assert klass.included_modules.include? Enumerable
+      end
+
+      it 'each' do
+        fill %w(a b c)
+
+        list = []
+        array.each { |e| list << e }
+
+        list.must_equal array.to_a
+      end
+      
+      it 'each_index' do
+        fill %w(a b c)
+
+        list = []
+        array.each_index { |i| list << i }
+
+        list.must_equal [0,1,2]
+      end
+
+    end
+
+    describe 'Sets' do
+
+      it '+' do
+        fill %w(a b c)
+        (array + %w(x y z)).must_equal %w(a b c x y z)
+      end
+      
+      it '-' do
+        fill %w(a b c)
+        (array - %w(a z)).must_equal %w(b c)
+      end
+
+      it '&' do
+        fill %w(a b c)
+        (array & %w(b a z)).must_equal %w(a b)
+      end
+
+      it '|' do
+        fill %w(a b c)
+        (array | %w(b c d)).must_equal %w(a b c d)
+      end
+
+    end
+
+    it 'Equality' do
+      copy = klass.new id: array.id
+      assert array == copy
+      assert array.eql? copy
+      refute array.equal? copy
+    end
+
+    it 'Dump/Restore' do
+      fill %w(a b c)
+      
+      dump = array.dump
+      other = klass.new
+      other.restore dump
+
+      other.id.wont_equal array.id
+      other.to_primitive.must_equal array.to_primitive
+    end
+
+  end
+
+end