zebris 0.0.2 → 0.0.3

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+script: bundle exec rspec spec

data/README.md

@@ -1,4 +1,5 @@
 [![Gem Version](https://badge.fury.io/rb/zebris.png)](http://badge.fury.io/rb/zebris)
+[![Build Status](https://travis-ci.org/JGailor/zebris.png?branch=master)](https://travis-ci.org/JGailor/zebris)
 
 # Zebris
 

data/lib/zebris.rb

@@ -1,7 +1,7 @@
 require "zebris/version"
 require "zebris/types"
 require "zebris/document"
-require 'json'
+require "zebris/serializers/json"
 
 module Zebris
   def self.redis=(connection)
@@ -11,4 +11,13 @@ module Zebris
   def self.redis
     @redis
   end
+
+  def self.serializer=(serializer)
+    raise "Not a zebris serializer" unless serializer.name.start_with?("Zebris::Serializers")
+    @serializer = serializer
+  end
+
+  def self.serializer
+    @serializer ||= Zebris::Serializers::JSON
+  end
 end

data/lib/zebris/document.rb

@@ -7,10 +7,9 @@ module Zebris
     def save
       raise "#{self.class} does not define a key generator" unless self.class.keygen.kind_of?(Proc)
 
-      self.class.scrub
       data = self.class.serialize(self)
 
-      result = Zebris.redis.set self.key, data.to_json
+      result = Zebris.redis.set self.key, Zebris.serializer.serialize(data)
 
       raise "Could not save #{self.class}" unless result == "OK"
 
@@ -28,55 +27,34 @@ module Zebris
 
       def find(key)
         stored = Zebris.redis.get key
-
-        if stored
-          data = JSON.parse(stored)
-          deserialize(data)
-        else
-          nil
-        end
+        stored ? deserialize(Zebris.serializer.deserialize(stored)) : nil
       end
 
       def serialize(object, embed = false)
-        attributes = (embed ? {} : {"key" => object.key})
-
-        properties.each do |property, conversion|
-          if val = object.send(property.to_sym)
-            if conversion.kind_of?(Zebris::Types::GenericConverter)
-              attributes[property.to_s] = conversion.serializer.call(val)
-            else
-              if conversion.ancestors.include?(Zebris::Document)
-                attributes[property.to_s] = conversion.serialize(val, true)
-              else
-                attributes[property.to_s] = conversion.serialize(val)
-              end
-            end
-          end
-        end
-
-        collections.each do |property, klass|
-          raise "#{klass} does not implement the Zebris::Document interface" unless klass.ancestors.include?(Zebris::Document)
-
-          attributes[property] ||= []
-          object.send(:instance_variable_get, :"@#{property}").each do |record|
-            attributes[property] << klass.serialize(record, true)
-          end
+        scrub
+        (embed ? {} : {"key" => object.key}).tap do |attributes|
+          attributes.merge!(serialize_properties(object))
+          attributes.merge!(serialize_collections(object))
         end
-
-        attributes
       end
 
       def scrub
         unless @scrubbed
           self.properties.each do |property, type|
             unless type.kind_of?(Zebris::Types::GenericConverter)
-              if type.kind_of?(Symbol)
-                type = self.properties[property] = self.const_get(self.properties[property])
+              resolved_type = case type
+              when Symbol
+                if zebris_type?(type)
+                  Zebris::Types.const_get(type)
+                else
+                  klass = lookup_class(type)
+                  zebris_document?(klass) ? klass : Zebris::Types::BasicObject
+                end
+              else
+                zebris_document?(type) || zebris_type?(type) ? type : Zebris::Types::BasicObject
               end
 
-              unless type.ancestors.include?(Zebris::Document) || self.properties[property].to_s.start_with?(Zebris::Types.to_s)
-                raise "#{type} does not implement the Zebris::Document interface"
-              end
+              self.properties[property] = resolved_type
             end
           end
 
@@ -103,9 +81,7 @@ module Zebris
                 instance.send(:"#{property}=", self.properties[property].deserialize(value))
               end
             elsif self.collections[property] && value.instance_of?(Array)
-              value.each do |row|
-                instance.send(:"instance_variable_get", :"@#{property}") << self.collections[property].deserialize(row)
-              end
+              instance.send(:"instance_variable_set", :"@#{property}", value.map {|row| self.collections[property].deserialize(row)})
             end
           end
         end
@@ -124,16 +100,8 @@ module Zebris
       end
 
       def property(name, type_or_serializer, deserializer = nil)
-        if type_or_serializer.kind_of?(Proc)
-          raise "When providing a deserializer you need to provide a deserializer" if deserializer.nil?
-          properties[name] = Zebris::Types::GenericConverter.new(type_or_serializer, deserializer)
-        else
-          if Zebris::Types.constants.include?(type_or_serializer.to_s.to_sym)
-            properties[name] = Zebris::Types.const_get(type_or_serializer.to_s.to_sym)
-          else
-            properties[name] = type_or_serializer
-          end
-        end
+        properties[name] = resolve_type(type_or_serializer, deserializer)
+
         self.send(:attr_accessor, name)
       end
 
@@ -148,6 +116,73 @@ module Zebris
           self.send(:instance_variable_get, :"@#{name}") || self.send(:instance_variable_set, :"@#{name}", [])
         }
       end
+
+      private
+
+      def resolve_type(type_or_serializer, deserializer)
+        if type_or_serializer.kind_of?(Proc)
+          raise "When providing a deserializer you need to provide a deserializer" if deserializer.nil?
+          Zebris::Types::GenericConverter.new(type_or_serializer, deserializer)
+        else
+          type = type_or_serializer.to_s.intern
+
+          if zebris_type?(type)
+            Zebris::Types.const_get(type)
+          elsif zebris_document?(type_or_serializer)
+            type_or_serializer
+          else
+            type
+          end
+        end
+      end
+
+      def zebris_type?(type)
+        type.to_s.start_with?("Zebris::Types") || Zebris::Types.constants.include?(type)
+      end
+
+      def zebris_document?(klass)
+        klass.respond_to?(:ancestors) ? klass.ancestors.include?(Zebris::Document) : false
+      end
+
+      def lookup_class(type)
+        if self.constants.include?(type)
+          self.const_get(type)
+        elsif Module.constants.include?(type)
+          Module.const_get(type)
+        else
+          raise "Could not find class #{type}"
+        end
+      end
+
+      def serialize_properties(target)
+        Hash.new.tap do |attributes|
+          properties.each do |property, conversion|
+            if val = target.send(property.to_sym)
+              if conversion.kind_of?(Zebris::Types::GenericConverter)
+                attributes[property.to_s] = conversion.serializer.call(val)
+              else
+                if conversion.ancestors.include?(Zebris::Document)
+                  attributes[property.to_s] = conversion.serialize(val, true)
+                else
+                  attributes[property.to_s] = conversion.serialize(val)
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def serialize_collections(target)
+        Hash.new() {|hash, key| hash[key] = []}.tap do |attributes|
+          collections.each do |property, klass|
+            raise "#{klass} does not implement the Zebris::Document interface" unless klass.ancestors.include?(Zebris::Document)
+            target.send(:instance_variable_set, :"@#{property}", []) unless target.send(:instance_variable_get, :"@#{property}")
+            target.send(:instance_variable_get, :"@#{property}").each do |record|
+              attributes[property] << klass.serialize(record, true)
+            end
+          end
+        end
+      end
     end
   end
 end

data/lib/zebris/serializers/json.rb

@@ -0,0 +1,17 @@
+require 'json'
+
+module Zebris
+  module Serializers
+    class JSON
+      class << self
+        def serialize(data)
+          data.to_json
+        end
+
+        def deserialize(stored)
+          ::JSON.parse(stored)
+        end
+      end
+    end
+  end
+end

data/lib/zebris/types.rb

@@ -1,3 +1,6 @@
+require 'date'
+require 'time'
+
 module Zebris
   module Types
     class GenericConverter
@@ -9,29 +12,58 @@ module Zebris
       end
     end
 
+    class BasicObject
+      def self.b(val)
+        val
+      end
+
+      def self.deserialize(value)
+        value
+      end
+
+      def self.serialize(value)
+        value
+      end
+    end
+
     class Date
       def self.deserialize(date)
         ::Date.parse(date)
       end
 
       def self.serialize(val)
-        val.rfc3339
+        raise "#{val} not a valid Date" unless val.respond_to?(:to_time)
+
+        Time.serialize(val.to_time)
       end
     end
 
-    class Integer
-      def self.deserialize(val)
-        (val && val != "") ? val.to_i : nil
+    class Time
+      def self.deserialize(time)
+        ::Time.parse(date)
       end
 
       def self.serialize(val)
-        val
+        raise "#{val} not a valid Time" unless val.kind_of?(::Time)
+        val.to_time.rfc2822
       end
     end
 
-    class Float
+    class DateTime
+      def self.deserialize(date)
+        ::DateTime.parse(date)
+      end
+
+      def self.serialize(val)
+        raise "#{val} not a valid DateTime" unless val.respond_to?(:to_time)
+
+        Time.serialize(val.to_time)
+      end
+    end
+
+    class Integer
       def self.deserialize(val)
-        (val && val != "") ? val.to_f : nil
+        (val && val != "") ? val.to_i : nil
       end
 
       def self.serialize(val)
@@ -39,9 +71,9 @@ module Zebris
       end
     end
 
-    class String
+    class Float
       def self.deserialize(val)
-        val ? val.to_s : nil
+        (val && val != "") ? val.to_f : nil
       end
 
       def self.serialize(val)

data/lib/zebris/version.rb

@@ -1,3 +1,3 @@
 module Zebris
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/spec/lib/document_spec.rb

@@ -2,209 +2,214 @@ require_relative "../../lib/zebris"
 require 'uuid'
 
 describe Zebris::Document do
-  class Document
-    include Zebris::Document
-    key {UUID.generate}
-    property :name, String
-    property :age, Integer
-    property :last_update, Date
-  end
-
-  class KeylessDocument
-    include Zebris::Document
-    property :name, String
-  end
+  let!(:redis)      {double(:redis, set: "OK", get: true)}
+  let(:key)         {"ABCDEFG"}
+  let(:name)        {"John Henry"}
+  let(:age)         {34}
+  let(:last_update) {Date.today - 2}
 
-  class LambdaDocument
-    include Zebris::Document
-    key {UUID.generate}
-    property :name, lambda {|n| n}, lambda {|n| String.new(n)}
+  before do
+    Zebris.redis = redis
   end
 
-  class NestedDocument
-    include Zebris::Document
-    key {UUID.generate}
-    property :person, Person
-
-    class Person
+  context "for simple documents" do
+    class Document
       include Zebris::Document
       key {UUID.generate}
       property :name, String
       property :age, Integer
+      property :last_update, Date
     end
-  end
 
-  class CollectionDocument
-    include Zebris::Document
+    it "should persist a document with a name property" do
+      document = Document.new
+      document.stub(:key).and_return(key)
+      redis.should_receive(:set).with(key, {"key" => key, "name" => name}.to_json)
 
-    key {UUID.generate}
+      document.name = name
+      document.save
+    end
 
-    collection :people, Person
+    it "properly serializes the built in types" do
+      document = Document.new
+      document.stub(:key).and_return(key)
+      redis.should_receive(:set).with(key, {"key" => key, "name" => name, "age" => age, "last_update" => last_update.to_time.rfc2822}.to_json)
 
-    class Person
-      include Zebris::Document
+      document.name = name
+      document.age = age
+      document.last_update = last_update
+      document.save
+    end
+  end
 
+  context "complicated documents" do
+    class KeylessDocument
+      include Zebris::Document
       property :name, String
-      property :age, Integer
     end
-  end
 
-  class InvalidCollectionDocument
-    include Zebris::Document
+    class LambdaDocument
+      include Zebris::Document
+      key {UUID.generate}
+      property :name, lambda {|n| n}, lambda {|n| String.new(n)}
+    end
 
-    key {UUID.generate}
+    class BasicObjectDocument
+      include Zebris::Document
 
-    collection :people, Person
+      key {UUID.generate}
 
-    class Person
+      property :ids, Array
     end
-  end
 
-  let!(:redis)      {double(:redis, set: "OK", get: true)}
-  let(:key)         {"ABCDEFG"}
-  let(:name)        {"John Henry"}
-  let(:age)         {34}
-  let(:last_update) {Date.today - 2}
+    class NestedDocument
+      include Zebris::Document
+      key {UUID.generate}
+      property :person, Person
 
-  before do
-    Zebris.redis = redis
-  end
+      class Person
+        include Zebris::Document
+        key {UUID.generate}
+        property :name, String
+        property :age, Integer
+      end
+    end
 
-  context "saving documents" do
-    it "should persist a document with a name property" do
-      document = Document.new
-      document.stub(:key).and_return(key)
-      redis.should_receive(:set).with(key, {"key" => key, "name" => name}.to_json)
+    class CollectionDocument
+      include Zebris::Document
 
-      document.name = name
-      document.save
-    end
+      key {UUID.generate}
 
-    it "raises an error when trying to save a document without a key generator" do
-      document = KeylessDocument.new
-      document.name = name
-      expect{document.save}.to raise_exception
-    end
+      collection :people, Person
 
-    context "property types" do
-      it "properly serializes the built in types" do
-        document = Document.new
-        document.stub(:key).and_return(key)
-        redis.should_receive(:set).with(key, {"key" => key, "name" => name, "age" => age, "last_update" => last_update.rfc3339}.to_json)
+      class Person
+        include Zebris::Document
 
-        document.name = name
-        document.age = age
-        document.last_update = last_update
-        document.save
+        property :name, String
+        property :age, Integer
       end
+    end
+
+    class InvalidCollectionDocument
+      include Zebris::Document
 
-      it "properly serializes the data when given a lambda" do
-        document = LambdaDocument.new
-        document.stub(:key).and_return(key)
-        redis.should_receive(:set).with(key, {"key" => key, "name" => name}.to_json)
+      key {UUID.generate}
+
+      collection :people, Person
 
+      class Person
+      end
+    end
+
+    context "saving documents" do
+      it "raises an error when trying to save a document without a key generator" do
+        document = KeylessDocument.new
         document.name = name
-        document.save
+        expect{document.save}.to raise_exception
       end
 
-      context "nested type collections" do
-        it "serializes nested types if they include Zebris::Document" do
-          person_key = "123456"
-          person = NestedDocument::Person.new
-          person.name = name
-          person.age = age
-          person.stub(:key).and_return(person_key)
+      context "property types" do
+        it "properly serializes the data when given a lambda" do
+          document = LambdaDocument.new
+          document.stub(:key).and_return(key)
+          redis.should_receive(:set).with(key, {"key" => key, "name" => name}.to_json)
 
-          redis.should_receive(:set).with(key, {"key" => key, "person" => {"name" => name, "age" => age}}.to_json)
+          document.name = name
+          document.save
+        end
 
-          document = NestedDocument.new
+        it "uses the Zebris::Types::BasicObject serializer for unknown property types" do
+          document = BasicObjectDocument.new
           document.stub(:key).and_return(key)
-          document.person = person
+          redis.should_receive(:set).with(key, {"key" => key, "ids" => [1, 2, 3]}.to_json)
+
+          document.ids = [1, 2, 3]
           document.save
         end
 
-        it "raises an exception if you attempt to declare a collection of things that aren't Zebris::Document" do
-          class BadDocument
-            include Zebris::Document
-
-            key {"This is a horrible key"}
+        context "nested type collections" do
+          it "serializes nested types if they include Zebris::Document" do
+            person_key = "123456"
+            person = NestedDocument::Person.new
+            person.name = name
+            person.age = age
+            person.stub(:key).and_return(person_key)
 
-            property :person, Object
-          end
+            redis.should_receive(:set).with(key, {"key" => key, "person" => {"name" => name, "age" => age}}.to_json)
 
-          expect {
-            document = BadDocument.new
-            document.person = Object.new
+            document = NestedDocument.new
+            document.stub(:key).and_return(key)
+            document.person = person
             document.save
-          }.to raise_exception
+          end
         end
-      end
 
-      context "collections" do
-        it "serializes each item in a collection properly" do
-          document = CollectionDocument.new
-          document.stub(:key).and_return(key)
-          redis.should_receive(:set).with(key, {"key" => key, "people" => [{"name" => name, "age" => age}]}.to_json)
+        context "collections" do
+          it "serializes each item in a collection properly" do
+            document = CollectionDocument.new
+            document.stub(:key).and_return(key)
+            redis.should_receive(:set).with(key, {"key" => key, "people" => [{"name" => name, "age" => age}]}.to_json)
 
-          p = CollectionDocument::Person.new
-          p.name = name
-          p.age = age
+            p = CollectionDocument::Person.new
+            p.name = name
+            p.age = age
 
-          document.people << p
-          document.save
-        end
+            document.people << p
+            document.save
+          end
 
-        it "raises an error if the serialization type does not support the Zebris::Document interface" do
-          document = InvalidCollectionDocument.new
-          document.stub(:key).and_return(key)
-          document.people << InvalidCollectionDocument::Person.new
+          it "raises an error if the serialization type does not support the Zebris::Document interface" do
+            document = InvalidCollectionDocument.new
+            document.stub(:key).and_return(key)
+            document.people << InvalidCollectionDocument::Person.new
 
-          expect {
-            expect document.save
-          }.to raise_exception
+            expect {
+              expect document.save
+            }.to raise_exception
+          end
         end
       end
     end
-  end
-
-  context "restoring documents" do
-    let(:serialized_document) {{"key" => key, "name" => name}.to_json}
-    let(:types_serialized_document) {{"key" => key, "name" => name, "age" => age, "last_update" => last_update.rfc3339}.to_json}
-    let(:lambda_serialized_document) {{"key" => key, "name" => name}.to_json}
-    let(:nested_serialized_document) {{"key" => key, "person" => {"name" => name, "age" => age}}.to_json}
 
-    it "delegates to the redis object" do
-      redis.should_receive(:get).with(key).and_return(serialized_document)
-      Document.find(key)
-    end
+    context "restoring documents" do
+      let(:serialized_document) {{"key" => key, "name" => name}.to_json}
+      let(:types_serialized_document) {{"key" => key, "name" => name, "age" => age, "last_update" => last_update.rfc3339}.to_json}
+      let(:lambda_serialized_document) {{"key" => key, "name" => name}.to_json}
+      let(:nested_serialized_document) {{"key" => key, "person" => {"name" => name, "age" => age}}.to_json}
 
-    it "rebuilds an object that has been saved to redis" do
-      redis.stub(:get).and_return(serialized_document)
-      document = Document.find(key)
-      expect(document.name).to eq(name)
-    end
+      it "delegates to the redis object" do
+        redis.should_receive(:get).with(key).and_return(serialized_document)
+        Document.find(key)
+      end
 
-    context "property types" do
-      it "rebuilds an object using built-in types" do
-        redis.stub(:get).and_return(types_serialized_document)
+      it "rebuilds an object that has been saved to redis" do
+        redis.stub(:get).and_return(serialized_document)
         document = Document.find(key)
         expect(document.name).to eq(name)
-        expect(document.age).to eq(age)
-        expect(document.last_update).to eq(last_update)
       end
 
-      it "rebuilds an object using lambda serializers/deserializers" do
-        redis.stub(:get).and_return(lambda_serialized_document)
-        document = LambdaDocument.find(key)
-        expect(document.name).to eq(name)
-      end
+      context "property types" do
+        it "rebuilds an object using built-in types" do
+          redis.stub(:get).and_return(types_serialized_document)
+          document = Document.find(key)
+          expect(document.name).to eq(name)
+          expect(document.age).to eq(age)
+          expect(document.last_update).to eq(last_update)
+        end
 
-      context "nested documents" do
-        it "rebuilds a nested object structure" do
-          redis.stub(:get).and_return(nested_serialized_document)
-          document = NestedDocument.find(key)
-          expect(document.person.name).to eq(name)
-          expect(document.person.age).to eq(age)
+        it "rebuilds an object using lambda serializers/deserializers" do
+          redis.stub(:get).and_return(lambda_serialized_document)
+          document = LambdaDocument.find(key)
+          expect(document.name).to eq(name)
+        end
+
+        context "nested documents" do
+          it "rebuilds a nested object structure" do
+            redis.stub(:get).and_return(nested_serialized_document)
+            document = NestedDocument.find(key)
+            expect(document.person.name).to eq(name)
+            expect(document.person.age).to eq(age)
+          end
         end
       end
     end

data/spec/lib/types_spec.rb

@@ -57,21 +57,4 @@ describe Zebris::Types do
       expect{Zebris::Types::Float.deserialize(o)}.to raise_exception
     end
   end
-
-  context Zebris::Types::String do
-    it "deserializes and returns a string as itself" do
-      s = %q{Do the ham bone}
-      expect(Zebris::Types::String.deserialize(s)).to eq(s)
-    end
-
-    it "deserializes and returns nil as nil" do
-      s = nil
-      expect(Zebris::Types::String.deserialize(s)).to eq(nil)
-    end
-
-    it "raises an exception if the object does not support being converted to a string" do
-      o = BasicObject.new
-      expect{Zebris::Types::String.deserialize(o)}.to raise_exception
-    end
-  end
 end

data/zebris.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.email         = ["jgailor@gmail.com"]
   spec.description   = %q{Zebris is a library to persist your object data to Redis.  Its goal is to be as unobtrusive as possible.}
   spec.summary       = %q{Zebris makes persisting your objects to Redis easy.}
-  spec.homepage      = "https://github.com/JGailor/zebris"
+  spec.homepage      = "http://github.com/JGailor/zebris"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)

metadata

@@ -1,18 +1,20 @@
 --- !ruby/object:Gem::Specification
 name: zebris
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
+  prerelease: 
 platform: ruby
 authors:
 - Jeremy Gailor
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-20 00:00:00.000000000 Z
+date: 2013-11-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -20,6 +22,7 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -27,20 +30,23 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -48,6 +54,7 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -55,15 +62,17 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: uuid
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: Zebris is a library to persist your object data to Redis.  Its goal is
@@ -75,40 +84,43 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/zebris.rb
 - lib/zebris/document.rb
+- lib/zebris/serializers/json.rb
 - lib/zebris/types.rb
 - lib/zebris/version.rb
 - spec/lib/document_spec.rb
 - spec/lib/types_spec.rb
 - zebris.gemspec
-homepage: https://github.com/JGailor/zebris
+homepage: http://github.com/JGailor/zebris
 licenses:
 - MIT
-metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 1.8.23
 signing_key: 
-specification_version: 4
+specification_version: 3
 summary: Zebris makes persisting your objects to Redis easy.
 test_files:
 - spec/lib/document_spec.rb

checksums.yaml

@@ -1,7 +0,0 @@
----
-SHA1:
-  metadata.gz: 3b41c71b77c9cb0ad27d3ebc402203f2d0900a04
-  data.tar.gz: 12550a668b6b8701e9923b6764b3cc7ab00a6ef7
-SHA512:
-  metadata.gz: 03dec832c90d045b163edab0d0bc4748db9211fb07254ebe4058417675639339239ef23f37f5ae8f9aa125ebd4f7ce1b0975230052016fcb92bb5a785f04a840
-  data.tar.gz: 9b7be6818cbbf39b4298b1a67d518ab55d8c356ddc99881d83dafd6995976e7ad1bdb20893bed0f9725dab12151c7d2d506ed199bcfc0a7d9b65dcec3cb80e25