redis-attrs 0.1.0 → 0.1.1

data/README.md

@@ -1,5 +1,7 @@
 # Redis::Attrs - Add attributes to Ruby classes backed by Redis
 
+[![Code Climate](https://codeclimate.com/github/gnapse/redis-attrs.png)](https://codeclimate.com/github/gnapse/redis-attrs)
+
 This gem is an amalgamation of the ideas found within the [redis_props][redis_props]
 and [redis-objects][redis-objects] gems, plus a few new ideas here and there.  It
 provides a way to define, on any Ruby class, some attributes that are backed by
@@ -33,47 +35,65 @@ Or install it yourself as:
 
     $ gem install redis-attrs
 
+## Setting up the connection
+
+You can include some of the following code snippets at the beginning of your
+app or script.  In case you're using Rails, you can use an initializer.
+
+```ruby
+# Standard connection
+Redis::Attrs.redis = Redis.new
+
+# Connection with specific parameters
+Redis::Attrs.redis = Redis.new(host: 'hostname', port: 8888, password: 'secret')
+
+# You can even use a redis namespace
+Redis::Attrs.redis = Redis::Namespace.new("blah", redis: Redis.new)
+```
+
 ## Usage
 
 Start by defining some attributes on your class:
 
-    class Film
-      include Redis::Attrs
-      redis_attrs :title => :string, :length => :integer
-      redis_attrs :released_on => :date, :cast => :list
+```ruby
+class Film
+  include Redis::Attrs
+  redis_attrs :title => :string, :length => :integer
+  redis_attrs :released_on => :date, :cast => :list
 
-      # Remember that the objects need an id for this to work
-      attr_reader :id
-      def initialize(id)
-        @id = id
-      end
+  # Remember that the objects need an id for this to work
+  attr_reader :id
+  def initialize(id)
+    @id = id
+  end
 
-      def presentation_title
-        "#{title} (#{released_on.year})"
-      end
-    end
+  def presentation_title
+    "#{title} (#{released_on.year})"
+  end
+end
+```
 
 Then you can use those attributes as you would regularly, but internally they are
 reading from and writing to Redis.
 
-    >> film = Film.new(3)
-    >> film.title = "Argo"
-    >> film.released_on = "2012-10-12"
-    >> puts film.presentation_title
-    Argo (2012)
-    >> puts film.cast.size
-    0
-    >> film.cast = ["Ben Affleck", "Alan Arkin", "Brian Cranston"]
-    >> puts film.cast.size
-    3
-    >> puts film.cast[-3]
-    Ben Affleck
+```ruby
+>> film = Film.new(3)
+>> film.title = "Argo"
+>> film.released_on = "2012-10-12"
+>> puts film.presentation_title
+Argo (2012)
+>> puts film.cast.size
+0
+>> film.cast = ["Ben Affleck", "Alan Arkin", "Brian Cranston"]
+>> puts film.cast.size
+3
+>> puts film.cast[-3]
+Ben Affleck
+```
 
 `Redis::Attrs` will work on _any_ class that provides an `id` method that returns
 a unique value.  `Redis::Attrs` will automatically create keys that are unique to
-each object, in the format:
-
-    class_name:id:attr_name
+each object, in the format `class_name:id:attr_name`.
 
 ### Supported types
 
@@ -97,29 +117,33 @@ The `serialize` and `deserialize` methods define how this process is done.  Afte
 registering the type with `Redis::Attrs`, a new attribute is added to the class
 `Film` defined above.
 
-    class JSONScalar < Redis::Attrs::Scalar
-      def serialize(value)
-        value.to_json
-      end
+```ruby
+class JSONScalar < Redis::Attrs::Scalar
+  def serialize(value)
+    value.to_json
+  end
 
-      def deserialize(value)
-        JSON.parse(value)
-      end
-    end
+  def deserialize(value)
+    JSON.parse(value)
+  end
+end
 
-    Redis::Attrs.register_type(:json, JSONScalar)
+Redis::Attrs.register_type(:json, JSONScalar)
 
-    class Film
-      redis_attrs :director => :json
-    end
+class Film
+  redis_attrs :director => :json
+end
+```
 
 After the definitions above, more complex data structures could be stored as a single
 scalar value, by being serialized as JSON.
 
-    >> film = Film.new(1)
-    >> film.director = { "first_name" => "Ben", "last_name" => "Affleck" }
-    >> puts Redis::Attrs.redis.get("film:1:director")
-    {"first_name":"Ben","last_name":"Affleck"}
+```ruby
+>> film = Film.new(1)
+>> film.director = { "first_name" => "Ben", "last_name" => "Affleck" }
+>> puts Redis::Attrs.redis.get("film:1:director")
+{"first_name":"Ben","last_name":"Affleck"}
+```
 
 ### Attribute configuration options
 
@@ -127,8 +151,10 @@ The complex attribute types support some configuration options, mostly specific
 each type.  When an attribute needs to be configured with some of these options, then
 it must be declared with the singular version of the method `redis_attrs`, like below:
 
-    redis_attr :crawl, :lock, :expiration => 15.minutes
-    redis_attr :cast, :list, :marshal => true
+```ruby
+redis_attr :crawl, :lock, :expiration => 15.minutes
+redis_attr :cast, :list, :marshal => true
+```
 
 For more details about the supported configuration options for each of the complex
 data types, please refer to the [redis-objects][redis-objects] gem.
@@ -139,16 +165,20 @@ There's an attribute configuration option for lists and sets, the `:filter` opti
 that allows the user to define a function that will modify the items upon insertion
 into the collection.
 
-    class Film
-      redis_attr :genres, :set, :filter => lambda { |v| v.strip.downcase.gsub(/\s+/, ' ') }
-    end
+```ruby
+class Film
+  redis_attr :genres, :set, :filter => lambda { |v| v.strip.downcase.gsub(/\s+/, ' ') }
+end
+```
 
 After the above declaration we could do:
 
-    >> film = Film.new(1)
-    >> film.genres = ["Action ", "  drama", "film   Noir", "Drama", "Film noir "]
-    >> puts film.genres.members.sort
-    ["action", "drama", "film noir"]
+```ruby
+>> film = Film.new(1)
+>> film.genres = ["Action ", "  drama", "film   Noir", "Drama", "Film noir "]
+>> puts film.genres.members.sort
+["action", "drama", "film noir"]
+```
 
 ## Contributing
 

data/lib/redis-attrs.rb

@@ -5,11 +5,11 @@ require "active_support/inflector"
 class Redis
   module Attrs
     def self.redis
-      @redis ||= Redis.new
+      @redis || $redis || Redis.current ||
+        raise(NotConnected, "Redis::Attrs.redis not set to a valid redis connection")
     end
 
     def self.redis=(r)
-      raise ArgumentError, "Redis Attrs: Invalid Redis instance" unless r.is_a?(Redis)
       @redis = r
     end
 
@@ -19,7 +19,7 @@ class Redis
       end
 
       def redis_key_prefix
-        @redis_key_refix ||= ActiveSupport::Inflector.underscore(self.name)
+        @redis_key_refix ||= ActiveSupport::Inflector.underscore(name)
       end
 
       def redis_attrs(attrs = nil)
@@ -32,7 +32,7 @@ class Redis
 
       def redis_attr(name, type, options = {})
         @redis_attrs ||= []
-        klass = Redis::Attrs::supported_types[type]
+        klass = Redis::Attrs.supported_types[type]
         raise ArgumentError, "Unknown Redis::Attr type #{type}" if klass.nil?
         attr = klass.new(self, name, type, options)
         @redis_attrs << attr
@@ -73,7 +73,9 @@ class Redis
     def self.register_type(type, klass)
       type = type.to_sym
       raise ArgumentError, "Redis attr type #{type} is already defined" if supported_types.include?(type)
-      raise ArgumentError, "Class implementing new type #{type} must be a subclass of Redis::Attrs::Scalar" unless klass.ancestors.include?(Scalar)
+      unless klass.ancestors.include?(Scalar)
+        raise ArgumentError, "Class implementing new type #{type} must be a subclass of Redis::Attrs::Scalar"
+      end
       @supported_types[type] = klass
     end
 

data/lib/redis-attrs/complex.rb

@@ -13,7 +13,7 @@ class Redis
       def initialize(klass, name, type, options)
         super
         attr = self
-        attr_class = self.class.redis_object_class[self.type]
+        attr_class = self.class.redis_object_class[type]
 
         # Define the getter
         klass.send(:define_method, name) do

data/lib/redis-attrs/objects_extensions.rb

@@ -8,7 +8,7 @@ class Redis
       end
 
       # Add a member before or after pivot in the list. Redis: LINSERT
-      def insert(where,pivot,value)
+      def insert(where, pivot, value)
         if options[:filter]
           value = options[:filter].call(value)
           pivot = options[:filter].call(pivot)
@@ -22,7 +22,7 @@ class Redis
         super
       end
 
-      def delete(name, count=0)
+      def delete(name, count = 0)
         name = options[:filter].call(name) if options[:filter]
         super
       end

data/lib/redis-attrs/version.rb

@@ -1,5 +1,5 @@
 class Redis
   module Attrs
-    VERSION = "0.1.0"
+    VERSION = "0.1.1"
   end
 end

data/redis-attrs.gemspec

@@ -13,11 +13,12 @@ Gem::Specification.new do |gem|
   gem.homepage      = "http://github.com/gnapse/redis-attrs"
 
   gem.files         = `git ls-files`.split($/)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
   gem.add_development_dependency "rspec"
+  gem.add_development_dependency "rake"
   gem.add_dependency "redis"
   gem.add_dependency "activesupport"
   gem.add_dependency "redis-objects"

data/spec/redis_attrs_spec.rb

@@ -26,37 +26,40 @@ describe Redis::Attrs do
   let(:film) { Film.new }
 
   it "has a version number" do
-    Redis::Attrs::VERSION.should_not be_nil
+    expect(Redis::Attrs::VERSION).not_to be_nil
   end
 
   context "when included in a class" do
     it "makes the class respond to .redis_attrs" do
-      Film.should respond_to(:redis_attrs)
+      expect(Film).to respond_to(:redis_attrs)
     end
 
     it "provides the class and its instances with a .redis interface" do
-      Film.should respond_to(:redis)
-      film.should respond_to(:redis)
+      expect(Film).to respond_to(:redis)
+      expect(film).to respond_to(:redis)
 
-      Film.redis.should be_a(Redis)
-      Film.redis.should equal(film.redis)
+      expect(Film.redis).to be_a(Redis)
+      expect(Film.redis).to equal(film.redis)
     end
   end
 
   describe ".redis_attrs" do
     it "adds getters and setters for the attributes defined" do
       %w(title released_on length created_at rating featured).each do |attr|
-        film.should respond_to(attr)
-        film.should respond_to("#{attr}=")
+        expect(film).to respond_to(attr)
+        expect(film).to respond_to("#{attr}=")
       end
     end
 
     context "with no paremeters" do
+      let(:attrs) { [:title, :released_on, :length, :created_at, :rating, :featured] }
+      let(:types) { [:string, :date, :integer, :time, :float, :boolean] }
+
       it "returns a list of all Redis attributes defined for the class" do
-        Film.redis_attrs.should be_a(Array)
-        Film.redis_attrs.count.should == 6
-        Film.redis_attrs.map(&:name).should == [:title, :released_on, :length, :created_at, :rating, :featured]
-        Film.redis_attrs.map(&:type).should == [:string, :date, :integer, :time, :float, :boolean]
+        expect(Film.redis_attrs).to be_a(Array)
+        expect(Film.redis_attrs.count).to eq(6)
+        expect(Film.redis_attrs.map(&:name)).to eq(attrs)
+        expect(Film.redis_attrs.map(&:type)).to eq(types)
       end
     end
   end
@@ -64,119 +67,121 @@ describe Redis::Attrs do
   describe "getters" do
     let(:now) { Time.parse("2013-02-22 22:31:12 -0500") }
 
-    it "return nil by default" do
-      film.title.should be_nil
-      film.released_on.should be_nil
-      film.length.should be_nil
+    it "returns nil by default" do
+      expect(film.title).to be_nil
+      expect(film.released_on).to be_nil
+      expect(film.length).to be_nil
     end
 
-    it "return whatever was last set with the corresponding setter" do
+    it "returns whatever was last set with the corresponding setter" do
       film.title = "Argo"
-      film.title.should == "Argo"
+      expect(film.title).to eq("Argo")
     end
 
-    it "keep the original value type" do
+    it "keeps the original value type" do
       film.released_on = Date.parse("2012-10-12")
-      film.released_on.should == Date.parse("2012-10-12")
+      expect(film.released_on).to eq(Date.parse("2012-10-12"))
       film.created_at = now
-      film.created_at.should == now
+      expect(film.created_at).to eq(now)
       film.length = 135
-      film.length.should == 135
+      expect(film.length).to eq(135)
       film.rating = 8.2
-      film.rating.should == 8.2
+      expect(film.rating).to eq(8.2)
       film.featured = true
-      film.featured.should == true
+      expect(film.featured).to eq(true)
     end
   end
 
   describe "setters" do
-    it "set the corresponding key in Redis" do
+    it "sets the corresponding key in Redis" do
       film.title = "Argo"
-      redis.get("film:1:title").should == "Argo"
+      expect(redis.get("film:1:title")).to eq("Argo")
 
       film.rating = 8.1
-      redis.get("film:1:rating").should == "8.1"
+      expect(redis.get("film:1:rating")).to eq("8.1")
     end
 
-    it "unset the key when being assigned nil" do
+    it "unsets the key when being assigned nil" do
       film.rating = 8.1
-      redis.keys.should include("film:1:rating")
+      expect(redis.keys).to include("film:1:rating")
 
       film.rating = nil
-      redis.keys.should_not include("film:1:rating")
-      redis.get("film:1:rating").should be_nil
+      expect(redis.keys).not_to include("film:1:rating")
+      expect(redis.get("film:1:rating")).to be_nil
     end
   end
 
   describe ".register_type" do
+    let(:director) { { first_name: "Ben", last_name: "Affleck" } }
+
     it "allows to define support for scalar value types not covered by the library" do
       Redis::Attrs.register_type(:json, JSONScalar)
       Film.redis_attrs director: :json
-      film.director = { first_name: "Ben", last_name: "Affleck" }
-      redis.keys.should include("film:1:director")
-      redis.get("film:1:director").should == { first_name: "Ben", last_name: "Affleck" }.to_json
-      film.director.should == { "first_name" => "Ben", "last_name" => "Affleck" }
+      film.director = director
+      expect(redis.keys).to include("film:1:director")
+      expect(redis.get("film:1:director")).to eq(director.to_json)
+      expect(film.director).to eq({ "first_name" => "Ben", "last_name" => "Affleck" })
     end
   end
 
   describe "collection attributes" do
-    it "support lists" do
+    it "supports lists" do
       Film.redis_attrs cast: :list
-      film.cast.should be_empty
+      expect(film.cast).to be_empty
       film.cast = ["Ben Affleck", "Alan Arkin", "John Goodman", "Ben Affleck"]
-      film.cast.size.should == 4
+      expect(film.cast.size).to eq(4)
     end
 
-    it "support hashes" do
+    it "supports hashes" do
       Film.redis_attrs crew: :hash
-      film.crew.should be_empty
+      expect(film.crew).to be_empty
       film.crew = { costume: "John Doe", makeup: "Jane Doe", camera: "James Doe" }
-      film.crew.size.should == 3
-      film.crew.keys.should == %w(costume makeup camera)
+      expect(film.crew.size).to eq(3)
+      expect(film.crew.keys).to eq(%w(costume makeup camera))
     end
 
-    it "support sets" do
+    it "supports sets" do
       Film.redis_attrs producers: :set
-      film.producers.should be_empty
+      expect(film.producers).to be_empty
       film.producers = ["Grant Heslov", "Ben Affleck", "George Clooney", "Ben Affleck"]
-      film.producers.size.should == 3
+      expect(film.producers.size).to eq(3)
     end
 
-    it "support sorted sets" do
+    it "supports sorted sets" do
       Film.redis_attrs rankings: :sorted_set
-      film.rankings.should be_empty
+      expect(film.rankings).to be_empty
       film.rankings = { "oscars" => 3, "golden globe" => 1, "bafta" => 2 }
-      film.rankings.first.should == "golden globe"
-      film.rankings.last.should == "oscars"
-      film.rankings.members.should == ["golden globe", "bafta", "oscars"]
+      expect(film.rankings.first).to eq("golden globe")
+      expect(film.rankings.last).to eq("oscars")
+      expect(film.rankings.members).to eq(["golden globe", "bafta", "oscars"])
     end
 
-    it "support counters" do
+    it "supports counters" do
       Film.redis_attrs awards_count: :counter
-      film.awards_count.value.should == 0
+      expect(film.awards_count.value).to eq(0)
       film.awards_count.incr
-      film.awards_count.value.should == 1
+      expect(film.awards_count.value).to eq(1)
     end
 
-    it "support locks" do
+    it "supports locks" do
       Film.redis_attrs playing: :lock
       film.playing.lock {  }
     end
 
-    it "support specifying configuration options" do
+    it "supports specifying configuration options" do
       require "active_support/core_ext/numeric/time"
-      Film.redis_attr :watching, :lock, :expiration => 3.hours
-      film.watching.options[:expiration].should == 3.hours
+      Film.redis_attr :watching, :lock, expiration: 3.hours
+      expect(film.watching.options[:expiration]).to eq(3.hours)
     end
 
     it "supports filtering the values inserted into a list or set" do
-      Film.redis_attr :genres, :set, filter: lambda { |genre| genre.strip.downcase.gsub(/\s+/, ' ') }
+      Film.redis_attr :genres, :set, filter: ->(genre) { genre.strip.downcase.gsub(/\s+/, ' ') }
       film.genres = ["Action ", "  drama", "film   Noir", "Drama", "Film noir "]
-      film.genres.members.sort.should == ["action", "drama", "film noir"]
+      expect(film.genres.members.sort).to eq(["action", "drama", "film noir"])
       film.genres << " ACTION  " << "Western"
-      film.genres.should_not include("Western")
-      film.genres.should include("western")
-      film.genres.members.sort.should == ["action", "drama", "film noir", "western"]
+      expect(film.genres).not_to include("Western")
+      expect(film.genres).to include("western")
+      expect(film.genres.members.sort).to eq(["action", "drama", "film noir", "western"])
     end
   end
 end

data/spec/spec_helper.rb

@@ -9,4 +9,9 @@ RSpec.configure do |config|
     Redis::Attrs.redis.flushdb
   end
 
+  # Disallow "should" syntax
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis-attrs
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-25 00:00:00.000000000 Z
+date: 2013-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -27,6 +27,22 @@ dependencies:
     - - ! '>='
       - !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: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
@@ -118,15 +134,21 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -3942124308415567947
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -3942124308415567947
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Add persistent object attributes backed by redis