zebris 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d82aa602d7e4e5640c78087c63c0707c0301dbb0
+  data.tar.gz: 85bda8fd3143cd50cfa3e0b43af3e216a2fcc287
+SHA512:
+  metadata.gz: 582d250221952c4a7694fb069681a8d2792b140ad8b25e76546d1128bb97c3d4d50d5dd3025093f344bee9ac22b34788d47bfe98c1eaefe2e89efc84829ba6ba
+  data.tar.gz: d56c3bf257822fd2165abced26b19bb7dcb434bc5e576bf6d2305be58bd76fb3634dd47d42865b1e344dcc44317f781abb7ce39448acbe054ee134598bad52fb

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.ruby-version
+.tags
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in zebris.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Jeremy Gailor
+
+MIT License
+
+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.md

@@ -0,0 +1,67 @@
+# Zebris
+
+Zebris is built to allow you to add persisting and retrieving your objects to and from Redis with a minimum of hassle or re-writing of your code.
+When I needed a library to do something similar, I noticed that a lot of the other Redis persistence libraries were very opinionated or tried to
+implement the ActiveRecord pattern, which is nice but would have required me to re-write a lot more of my code to conform to the libraries idioms
+than I wanted to do.  My goal was to make it as easy as possible to add a ruby gem to my project and with as little code as possible make it easy to
+persist the object to Redis and retrieve it later.  Such is Zebris, or so I hope.
+
+I welcome all feedback and suggestions on how to improve Zebris.  It's very young, but I have a roadmap in mind to add some things that I think will
+allow Zebris to keep it's simplicity and general purpose use while adding a lot of utility for anyone using it.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'zebris'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install zebris
+
+## Usage
+
+### Configuration
+Zebris is happy to delegate to any Redis client that supports the 2.0+ command list.  To configure Zebris, just pass it a connected Redis client object:
+
+    Zebris.redis = Redis.new
+
+### Basic Document Peristence
+
+    class Person
+      include Zebris::Document
+
+      key {UUID.generate}   # Or anything that will generate unique keys
+
+      # String, Integer, Float, Date are built-in types to Zebris that understand
+      # serialization and deserialization of those types
+      property :name, String
+      property :weight, Float
+      property :lucky_number, Integer
+      property :birthday, Date
+    end
+
+    person = Person.new
+    person.name = "Tyler Durden"
+    person.weight = 175.2
+    person.lucky_number = 13
+    person.birthday = Date.parse('1979-05-20')
+
+    key = person.save
+    => "some uuid here"
+
+    tyler = Person.find(key)
+
+    # Tyler is back
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/zebris/document.rb

@@ -0,0 +1,144 @@
+module Zebris
+  module Document
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+
+    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
+
+      raise "Could not save #{self.class}" unless result == "OK"
+
+      self.key
+    end
+
+    def key
+      @key ||= self.class.keygen.call
+    end
+
+    module ClassMethods
+      def const_missing(const)
+        const
+      end
+
+      def find(key)
+        stored = Zebris.redis.get key
+
+        if stored
+          data = JSON.parse(stored)
+          deserialize(data)
+        else
+          nil
+        end
+      end
+
+      def serialize(object)
+        attributes = {"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
+              attributes[property.to_s] = conversion.serialize(val)
+            end
+          end
+        end
+
+        collections.each do |property, klass|
+          attributes[property] ||= []
+          object.send(:instance_variable_get, :"@#{property}").each do |record|
+            attributes[property] << record.serialize
+          end
+        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])
+              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
+            end
+          end
+
+          self.collections.each do |property, type|
+            if self.collections[property].kind_of?(Symbol)
+              self.collections[property] = self.const_get(self.collections[property])
+            end
+          end
+
+          @scrubbed = true
+        end
+      end
+
+      def deserialize(data)
+        scrub
+
+        self.new.tap do |instance|
+          data.each do |property, value|
+            property = property.to_sym
+            if self.properties[property]
+              if self.properties[property].kind_of?(Zebris::Types::GenericConverter)
+                instance.send(:"#{property}=", self.properties[property].deserializer.call(value))
+              else
+                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
+            end
+          end
+        end
+      end
+
+      def key(&block)
+        @keygen = block
+      end
+
+      def keygen
+        @keygen
+      end
+
+      def properties
+        @properties ||= {}
+      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
+        self.send(:attr_accessor, name)
+      end
+
+      def collections
+        @collections ||= {}
+      end
+
+      def collection(name, klass)
+        collections[name] = klass
+        self.send(:attr_accessor, name)
+      end
+    end
+  end
+end

data/lib/zebris/types.rb

@@ -0,0 +1,52 @@
+module Zebris
+  module Types
+    class GenericConverter
+      attr_reader :serializer, :deserializer
+
+      def initialize(serializer, deserializer)
+        @serializer = serializer
+        @deserializer = deserializer
+      end
+    end
+
+    class Date
+      def self.deserialize(date)
+        ::Date.parse(date)
+      end
+
+      def self.serialize(val)
+        val.rfc3339
+      end
+    end
+
+    class Integer
+      def self.deserialize(val)
+        (val && val != "") ? val.to_i : nil
+      end
+
+      def self.serialize(val)
+        val
+      end
+    end
+
+    class Float
+      def self.deserialize(val)
+        (val && val != "") ? val.to_f : nil
+      end
+
+      def self.serialize(val)
+        val
+      end
+    end
+
+    class String
+      def self.deserialize(val)
+        val ? val.to_s : nil
+      end
+
+      def self.serialize(val)
+        val
+      end
+    end
+  end
+end

data/lib/zebris/version.rb

@@ -0,0 +1,3 @@
+module Zebris
+  VERSION = "0.0.1"
+end

data/lib/zebris.rb

@@ -0,0 +1,14 @@
+require "zebris/version"
+require "zebris/types"
+require "zebris/document"
+require 'json'
+
+module Zebris
+  def self.redis=(connection)
+    @redis = connection
+  end
+
+  def self.redis
+    @redis
+  end
+end

data/spec/lib/document_spec.rb

@@ -0,0 +1,161 @@
+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
+
+  class LambdaDocument
+    include Zebris::Document
+    key {UUID.generate}
+    property :name, lambda {|n| n}, lambda {|n| String.new(n)}
+  end
+
+  class NestedDocument
+    include Zebris::Document
+    key {UUID.generate}
+    property :person, Person
+
+    class Person
+      include Zebris::Document
+      key {UUID.generate}
+      property :name, String
+      property :age, Integer
+    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}
+
+  before do
+    Zebris.redis = redis
+  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)
+
+      document.name = name
+      document.save
+    end
+
+    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
+
+    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)
+
+        document.name = name
+        document.age = age
+        document.last_update = last_update
+        document.save
+      end
+
+      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)
+
+        document.name = name
+        document.save
+      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)
+
+          redis.should_receive(:set).with(key, {"key" => key, "person" => {"key" => person_key, "name" => name, "age" => age}}.to_json)
+
+          document = NestedDocument.new
+          document.stub(:key).and_return(key)
+          document.person = person
+          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"}
+
+            property :person, Object
+          end
+
+          expect {
+            document = BadDocument.new
+            document.person = Object.new
+            document.save
+          }.to raise_exception
+        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
+
+    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
+
+    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
+
+      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
+end

data/spec/lib/types_spec.rb

@@ -0,0 +1,77 @@
+require_relative '../../lib/zebris/types'
+require 'date'
+
+describe Zebris::Types do
+  context Zebris::Types::Date do
+    it "deserializes a valid date" do
+      d = Date.today
+      expect(Zebris::Types::Date.deserialize(d.to_s)).to eq(d)
+    end
+
+    it "raises an exception if the date is invalid" do
+      d = ""
+      expect{Zebris::Types::Date.deserialize(d.to_s)}.to raise_exception
+    end
+  end
+
+  context Zebris::Types::Integer do
+    it "deserializes a valid integer" do
+      i = 101
+      expect(Zebris::Types::Integer.deserialize(i.to_s)).to eq(i)
+    end
+
+    it "returns nil if the integer is an empty string" do
+      i = ""
+      expect(Zebris::Types::Integer.deserialize(i.to_s)).to eq(nil)
+    end
+
+    it "returns nil if the integer is nil" do
+      i = nil
+      expect(Zebris::Types::Integer.deserialize(i)).to eq(nil)
+    end
+
+    it "raises an exception if the object does not support being converted to an integer" do
+      o = Object.new
+      expect{Zebris::Types::Integer.deserialize(o)}.to raise_exception
+    end
+  end
+
+  context Zebris::Types::Float do
+    it "deserializes and returns serialized float" do
+      f = 10.23
+      expect(Zebris::Types::Float.deserialize(f.to_s)).to eq(f)
+    end
+
+    it "deserializes and returns nil on an empty string" do
+      f = ""
+      expect(Zebris::Types::Float.deserialize(f.to_s)).to eq(nil)
+    end
+
+    it "deserializes and returns nil on an empty string" do
+      f = nil
+      expect(Zebris::Types::Float.deserialize(f)).to eq(nil)
+    end
+
+    it "raises an exception if the object does not support being converted to a float" do
+      o = Object.new
+      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

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'zebris/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "zebris"
+  spec.version       = Zebris::VERSION
+  spec.authors       = ["Jeremy Gailor"]
+  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      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 2.14.1"
+  spec.add_development_dependency "uuid"
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: zebris
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jeremy Gailor
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+- !ruby/object:Gem::Dependency
+  name: uuid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Zebris is a library to persist your object data to Redis.  Its goal is
+  to be as unobtrusive as possible.
+email:
+- jgailor@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/zebris.rb
+- lib/zebris/document.rb
+- lib/zebris/types.rb
+- lib/zebris/version.rb
+- spec/lib/document_spec.rb
+- spec/lib/types_spec.rb
+- zebris.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Zebris makes persisting your objects to Redis easy.
+test_files:
+- spec/lib/document_spec.rb
+- spec/lib/types_spec.rb