restruct 0.0.1

data/spec/coverage_helper.rb

@@ -0,0 +1,8 @@
+require 'simplecov'
+require 'coveralls'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start

data/spec/hash_spec.rb

@@ -0,0 +1,242 @@
+require 'minitest_helper'
+
+[Restruct::Hash, Restruct::MarshalHash].each do |klass|
+
+  describe klass do
+
+    let(:hash) { klass.new }
+
+    def fill(data)
+      data.each { |k,v| data[k] = hash.send(:serialize, v) }
+      redis.call 'HMSET', hash.id, *data.flatten
+    end
+
+    describe 'Getters' do
+      
+      it '[]' do
+        fill a: 'x', b: 'y'
+
+        hash[:a].must_equal 'x'
+        hash[:b].must_equal 'y'
+        hash[:c].must_be_nil
+      end
+      
+      it 'fetch' do
+        fill a: 'x', b: 'y'
+
+        hash.fetch(:a).must_equal 'x'
+        hash.fetch(:b).must_equal 'y'
+        hash.fetch(:c, 'z').must_equal 'z'
+        hash.fetch(:c) { |k| k.to_s }.must_equal 'c'
+        
+        error = proc { hash.fetch(:c) }.must_raise KeyError
+        error.message.must_equal 'key not found: c'
+      end
+      
+      it 'key' do
+        fill a: 'x', b: 'y', c: 'y'
+
+        hash.key('x').must_equal 'a'
+        hash.key('y').must_equal 'b'
+        hash.key('z').must_be_nil
+      end
+
+      it 'keys' do
+        fill a: 'x', b: 'y', c: 'z'
+        hash.keys.must_equal %w(a b c)
+      end
+
+      it 'values' do
+        fill a: 'x', b: 'y', c: 'z'
+        hash.values.must_equal %w(x y z)
+      end
+
+      it 'values_at' do
+        fill a: 'x', b: 'y', c: 'z'
+        hash.values_at(:a, :f, :b, :g, :c).must_equal ['x', nil, 'y', nil, 'z']
+      end
+
+    end
+
+    describe 'Setters' do
+      
+      %w([]= store).each do |method|
+        it method do
+          fill a: 'x', b: 'y'
+
+          hash.send(method, :a, 'a').must_equal 'a'
+          hash.to_h.must_equal 'a' => 'a', 'b' => 'y'
+
+          hash.send(method, :c, 'z').must_equal 'z'
+          hash.to_h.must_equal 'a' => 'a', 'b' => 'y', 'c' => 'z'
+        end
+      end
+
+      %w(update merge!).each do |method|
+        it method do
+          fill a: 'x', b: 'y'
+
+          hash.send(method, a: 'a', c: 'z').must_equal hash
+          hash.to_h.must_equal 'a' => 'a', 'b' => 'y', 'c' => 'z'
+        end
+      end
+      
+      it 'delete' do
+        fill a: 'x', b: 'y'
+
+        hash.delete(:b).must_equal 'y'
+        hash.to_h.must_equal 'a' => 'x'
+        
+        hash.delete(:c).must_be_nil
+        hash.to_h.must_equal 'a' => 'x'
+      end
+      
+      it 'delete_if' do
+        fill a: 'x', b: 'y'
+
+        hash.delete_if { |k,v| v == 'x' }.must_equal hash
+        hash.to_h.must_equal 'b' => 'y'
+      end
+
+      %w(keep_if select!).each do |method|
+        it method do
+          fill a: 'x', b: 'y'
+
+          hash.send(method) { |k,v| v == 'x' }.must_equal hash
+          hash.to_h.must_equal 'a' => 'x'
+        end
+      end
+      
+      it 'clear' do
+        fill a: 'x', b: 'y'
+
+        hash.clear.must_equal hash
+        hash.must_be_empty
+      end
+
+    end
+
+    describe 'Info' do
+
+      %w(size count length).each do |method|
+        it method do
+          fill a: 'x', b: 'y'
+          hash.send(method).must_equal 2
+        end
+      end
+      
+      it 'empty?' do
+        hash.must_be :empty?
+        fill a: 'x', b: 'y'
+        hash.wont_be :empty?
+      end
+
+      %w(key? has_key?).each do |method|
+        it method do
+          fill a: 'x', b: 'y'
+
+          assert hash.send(method, :a)
+          refute hash.send(method, :c)
+        end
+      end
+      
+      %w(value? has_value?).each do |method|
+        it method do
+          fill a: 'x', b: 'y'
+
+          assert hash.send(method, 'x')
+          refute hash.send(method, 'z')
+        end
+      end
+
+    end
+
+    describe 'Transformations' do
+
+      %w(to_h to_primitive).each do |method|
+        it method do
+          fill a: 'x', b: 'y'
+          hash.send(method).must_equal 'a' => 'x', 'b' => 'y'
+        end
+      end
+
+      it 'merge' do
+        fill a: 'x', b: 'y'
+        hash.merge('c' => 'z', 'a' => 'a').must_equal 'a' => 'a', 'b' => 'y', 'c' => 'z'
+      end
+      
+      it 'flatten' do
+        fill a: 'x', b: 'y'
+        hash.flatten.must_equal %w(a x b y)
+      end
+
+      it 'invert' do
+        fill a: 'x', b: 'y'
+        hash.invert.must_equal 'x' => 'a', 'y' => 'b'
+      end
+
+    end
+
+    describe 'Enumerable' do
+
+      it 'included module' do
+        assert Restruct::Hash.included_modules.include? Enumerable
+      end
+
+      %w(each each_pair).each do |method|
+        it method do
+          fill a: 'x', b: 'y'
+
+          keys = []
+          values = []
+          hash.send(method) do |k,v|
+            keys << k
+            values << v
+          end
+
+          keys.must_equal hash.keys
+          values.must_equal hash.values
+        end
+      end
+      
+      it 'each_key' do
+        fill a: 'x', b: 'y'
+
+        keys = []
+        hash.each_key { |k| keys << k }
+
+        keys.must_equal hash.keys
+      end
+      
+      it 'each_value' do
+        fill a: 'x', b: 'y'
+
+        values = []
+        hash.each_value { |v| values << v }
+
+        values.must_equal hash.values
+      end
+
+    end
+
+    it 'Equality' do
+      copy = klass.new id: hash.id
+      assert hash == copy
+      assert hash.eql? copy
+      refute hash.equal? copy
+    end
+
+    it 'Dump/Restore' do
+      fill a: 'x', b: 'y'
+      
+      dump = hash.dump
+      other = klass.new
+      other.restore dump
+
+      other.id.wont_equal hash.id
+      other.to_primitive.must_equal hash.to_primitive
+    end
+
+  end
+
+end

data/spec/id_spec.rb

@@ -0,0 +1,48 @@
+require 'minitest_helper'
+
+describe Restruct::Id do
+
+  Id = Restruct::Id
+
+  it 'Return the namespace' do
+    id = Id.new 'foo'
+    id.must_equal 'foo'
+  end
+
+  it 'Prepend the namespace' do
+    id = Id.new 'foo'
+    id['bar'].must_equal 'foo:bar'
+  end
+
+  it 'Work in more than one level' do
+    id_1 = Id.new 'foo'
+    id_2 = Id.new id_1['bar']
+    id_2['baz'].must_equal 'foo:bar:baz'
+  end
+
+  it 'Be chainable' do
+    id = Id.new 'foo'
+    id['bar']['baz'].must_equal 'foo:bar:baz'
+  end
+
+  it 'Accept symbols' do
+    id = Id.new :foo
+    id[:bar].must_equal 'foo:bar'
+  end
+
+  it 'Accept numbers' do
+    id = Id.new 'foo'
+    id[3].must_equal 'foo:3'
+  end
+
+  it 'Split in sections' do
+    id = Id.new(:foo)[:bar][:buz]
+    id.sections.must_equal %w(foo bar buz)
+  end
+
+  it 'Customize separator' do
+    id = Id.new('foo', '|')['bar']['buz']
+    id.must_equal 'foo|bar|buz'
+  end
+  
+end

data/spec/minitest_helper.rb

@@ -0,0 +1,21 @@
+require 'coverage_helper'
+require 'restruct'
+require 'minitest/autorun'
+require 'turn'
+require 'pry-nav'
+
+Turn.config do |c|
+  c.format = :pretty
+  c.natural = true
+  c.ansi = true
+end
+
+class Minitest::Spec
+  def redis
+    Restruct.redis
+  end
+
+  after do
+    redis.call('KEYS', Restruct::Id.new(:restruct)['*']).each { |k| redis.call 'DEL', k }
+  end
+end

data/spec/nested_hash_spec.rb

@@ -0,0 +1,205 @@
+require 'minitest_helper'
+
+class Counter < Restruct::Structure
+  def current
+    (redis.call('GET', id) || 0).to_i
+  end
+  alias_method :to_primitive, :current
+
+  def incr
+    redis.call 'SET', id, current + 1
+    self
+  end
+end
+
+CounterHash = Restruct::NestedHash.new(Counter)
+
+
+describe Restruct::NestedHash do
+  
+  let(:hash) { CounterHash.new }
+
+  describe 'Getters' do
+    
+    it '[]' do
+      hash[:a].current.must_equal 0
+    end
+
+    it 'fetch' do
+      hash[:a].incr
+
+      hash.fetch(:a).current.must_equal 1
+
+      error = proc { hash.fetch(:c) }.must_raise KeyError
+      error.message.must_equal 'key not found: c'
+    end
+    
+    it 'keys' do
+      hash[:a].incr
+      hash[:b].incr
+      
+      hash.keys.must_equal %w(a b)
+    end
+
+    it 'values' do
+      hash[:a].incr.incr
+      hash[:b].incr
+
+      hash.values.map(&:current).must_equal [2, 1]
+    end
+
+    it 'values_at' do
+      hash[:a].incr.incr
+      hash[:b].incr
+
+      hash.values_at(:a, :f, :b, :g).map(&:current).must_equal [2, 0, 1, 0]
+    end
+
+  end
+
+  describe 'Setters' do
+    
+    it 'delete' do
+      hash[:a].incr.incr
+      hash[:b].incr
+
+      hash.delete(:a)
+
+      hash.keys.must_equal %w(b)
+    end
+    
+    it 'delete_if' do
+      hash[:a].incr.incr
+      hash[:b].incr
+
+      hash.delete_if { |k,v| v.current > 1 }.must_equal hash
+      hash.keys.must_equal %w(b)
+    end
+
+    %w(keep_if select!).each do |method|
+      it method do
+        hash[:a].incr.incr
+        hash[:b].incr
+
+        hash.send(method) { |k,v| v.current > 1 }.must_equal hash
+        hash.keys.must_equal %w(a)
+      end
+    end
+    
+    it 'clear' do
+      hash[:a].incr.incr
+      hash[:b].incr
+
+      hash.clear.must_equal hash
+      hash.must_be_empty
+    end
+
+  end
+
+  describe 'Info' do
+
+    %w(size count length).each do |method|
+      it method do
+        hash[:a].incr.incr
+        hash[:b].incr
+
+        hash.send(method).must_equal 2
+      end
+    end
+    
+    it 'empty?' do
+      hash.must_be :empty?
+      hash[:a].incr
+      hash.wont_be :empty?
+    end
+
+    %w(key? has_key?).each do |method|
+      it method do
+        hash[:a].incr.incr
+        hash[:b].incr
+
+        assert hash.send(method, :a)
+        refute hash.send(method, :c)
+      end
+    end
+
+  end
+
+  describe 'Transformations' do
+
+    %w(to_h to_primitive).each do |method|
+      it method do
+        hash[:a].incr.incr
+        hash[:b].incr
+
+        hash.send(method).must_equal 'a' => 2, 'b' => 1
+      end
+    end
+
+  end
+
+  describe 'Enumerable' do
+
+    it 'included module' do
+      assert Restruct::Hash.included_modules.include? Enumerable
+    end
+
+    %w(each each_pair).each do |method|
+      it method do
+        hash[:a].incr.incr
+        hash[:b].incr
+
+        keys = []
+        values = []
+        hash.send(method) do |k,v|
+          keys << k
+          values << v
+        end
+
+        keys.must_equal hash.keys
+        values.must_equal hash.values
+      end
+    end
+    
+    it 'each_key' do
+      hash[:a].incr.incr
+      hash[:b].incr
+
+      keys = []
+      hash.each_key { |k| keys << k }
+
+      keys.must_equal hash.keys
+    end
+    
+    it 'each_value' do
+      hash[:a].incr.incr
+      hash[:b].incr
+
+      values = []
+      hash.each_value { |v| values << v }
+
+      values.must_equal hash.values
+    end
+
+  end
+
+  it 'Equality' do
+    copy = CounterHash.new id: hash.id
+    assert hash == copy
+    assert hash.eql? copy
+    refute hash.equal? copy
+  end
+
+  it 'Dump/Restore' do
+    hash[:a].incr.incr
+    hash[:b].incr
+    
+    dump = hash.dump
+    other = CounterHash.new
+    other.restore dump
+
+    other.id.wont_equal hash.id
+    other.to_primitive.must_equal hash.to_primitive
+  end
+
+end