redis_feature_control 0.0.1 → 0.0.2

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/Gemfile.lock

@@ -0,0 +1,24 @@
+PATH
+  remote: .
+  specs:
+    redis_feature_control (0.0.2)
+      redis (>= 0.1.1)
+      redis-namespace (>= 0.2.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    mocha (0.9.12)
+    redis (2.1.1)
+    redis-namespace (0.10.0)
+      redis (< 3.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (>= 1.0.0)
+  mocha
+  redis (>= 0.1.1)
+  redis-namespace (>= 0.2.0)
+  redis_feature_control!

data/HISTORY.md

@@ -0,0 +1,10 @@
+
+## 0.0.2 (2011-02-16)
+
+* Switched to bundler
+* Removed jeweler
+* Added `connection=`
+
+## 0.0.1
+
+* First version 

data/README.md

@@ -18,7 +18,11 @@ that job to sometime in the future without having to test the service.
 
 ### Usage
 
-First configure it:
+Install it:
+
+    gem install redis_feature_control
+
+Configure it:
 
     require 'rubygems'
     require 'redis/feature_control'
@@ -38,13 +42,13 @@ Then see if they are enabled and toggle them:
     # disabling...
     Redis::FeatureControl.disable!(:cc_gateway)
     Redis::FeatureControl.enabled?(:cc_gateway) # => false
-    Redis::FeatureControl.status(:cc_gateway) # => "disabled"
+    Redis::FeatureControl.state(:cc_gateway) # => "disabled"
 
     # enabling...
     Redis::FeatureControl.enable!(:cc_gateway)
     Redis::FeatureControl.enabled?(:cc_gateway) # => true
     Redis::FeatureControl.disabled?(:cc_gateway) # => false
-    Redis::FeatureControl.status(:cc_gateway) # => "enabled"
+    Redis::FeatureControl.state(:cc_gateway) # => "enabled"
 
 ### Mocking for Test/Development
 

data/Rakefile

@@ -1,3 +1,6 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
 $LOAD_PATH.unshift 'lib'
 
 task :default => :test
@@ -5,46 +8,6 @@ task :default => :test
 desc "Run tests"
 task :test do
   Dir['test/*_test.rb'].each do |f|
-    require f
-  end
-end
-
-desc "Build a gem"
-task :gem => [ :test, :gemspec, :build ]
-
-begin
-  begin
-    require 'jeweler'
-  rescue LoadError
-    puts "Jeweler not available. Install it with: "
-    puts "gem install jeweler"
+    require File.expand_path(f)
   end
-
-  require 'redis/feature_control'
-
-  Jeweler::Tasks.new do |gemspec|
-    gemspec.name = "redis_feature_control"
-    gemspec.summary = "Feature enable/disable library on top of Redis"
-    gemspec.description = gemspec.summary
-    gemspec.email = "bvandenbos@gmail.com"
-    gemspec.homepage = "http://github.com/bvandenbos/redis_feature_control"
-    gemspec.authors = ["Ben VandenBos"]
-    gemspec.version = Redis::FeatureControl::Version
-    
-    gemspec.add_dependency "redis", ">= 0.1.1"
-    gemspec.add_dependency "redis-namespace", ">= 0.2.0"
-    gemspec.add_development_dependency "jeweler"
-    gemspec.add_development_dependency "mocha"
-  end
-end
-
-
-desc "Push a new version to Gemcutter"
-task :publish => [ :test, :gemspec, :build ] do
-  require 'redis/feature_control'
-  system "git tag v#{Redis::FeatureControl::Version}"
-  system "git push origin v#{Redis::FeatureControl::Version}"
-  system "git push origin master"
-  system "gem push pkg/redis_feature_control-#{Redis::FeatureControl::Version}.gem"
-  system "git clean -fd"
 end

data/lib/redis/feature_control.rb

@@ -16,8 +16,6 @@ class Redis
 
   module FeatureControl
 
-    Version = '0.0.1'
-
     class Redis::FeatureControl::UnknownFeatureError < RuntimeError; end;
 
     class << self
@@ -41,6 +39,11 @@ class Redis
         @host, @port = value.split(":", 2)
         redis_connect!
       end
+      
+      # Set the redis instance directly.
+      def connection=(redis)
+        @redis = redis
+      end
 
       # Connects to redis on the current host/port and sets the redis object
       def redis_connect!

data/lib/redis/feature_control/version.rb

@@ -0,0 +1,5 @@
+class Redis
+  module FeatureControl
+    Version = '0.0.2'
+  end
+end

data/test/feature_control_test.rb

@@ -3,115 +3,128 @@ require File.dirname(__FILE__) + '/test_helper'
 class Redis::FeatureControlTest < Test::Unit::TestCase
 
   def setup
-    Redis::FeatureControl.connection_string = 'localhost:9736'
-    Redis::FeatureControl.unmock!
-    Redis::FeatureControl.features = [:enabled_feature]
-    Redis::FeatureControl.redis.flushall
+    control.connection_string = 'localhost:9736'
+    control.unmock!
+    control.features = [:enabled_feature]
+    control.redis.flushall
   end
 
   def test_connection_string_works
-    Redis::FeatureControl.connection_string = "redis:1234"
-    assert_equal('redis', Redis::FeatureControl.host)
-    assert_equal('1234', Redis::FeatureControl.port)
+    control.connection_string = "redis:1234"
+    assert_equal('redis', control.host)
+    assert_equal('1234', control.port)
+  end
+
+  def test_connection_works
+    redis = Redis.new(:host => 'localhost', :port => 9736, :thread_safe => true)
+    redis_namespace = Redis::Namespace.new(:feature_control_test, :redis => redis)
+    control.connection = redis_namespace
+    control.features = [:some_feature]
+    control.enable!(:some_feature)
+    assert redis.exists('feature_control_test:some_feature')
   end
 
   def test_redis
-    assert(Redis::FeatureControl.redis.is_a?(Redis::Namespace))
+    assert(control.redis.is_a?(Redis::Namespace))
   end
 
   def test_unknown_features_raise_errors
-    assert_raises(Redis::FeatureControl::UnknownFeatureError) do
-      Redis::FeatureControl.enabled?(:some_feature)
+    assert_raises(control::UnknownFeatureError) do
+      control.enabled?(:some_feature)
     end
   end
 
   def test_enable_disable
-    Redis::FeatureControl.features << :cool_service # add a feature
-    assert(Redis::FeatureControl.enabled?(:cool_service)) # should be enabled by default
-    assert(!Redis::FeatureControl.disabled?(:cool_service)) # should be enabled by default
+    control.features << :cool_service # add a feature
+    assert(control.enabled?(:cool_service)) # should be enabled by default
+    assert(!control.disabled?(:cool_service)) # should be enabled by default
 
-    Redis::FeatureControl.enable!(:cool_service)
-    assert(Redis::FeatureControl.enabled?(:cool_service)) # should still be enabled
+    control.enable!(:cool_service)
+    assert(control.enabled?(:cool_service)) # should still be enabled
 
-    Redis::FeatureControl.disable!(:cool_service)
-    assert(!Redis::FeatureControl.enabled?(:cool_service)) # should still be enabled
-    assert(Redis::FeatureControl.disabled?(:cool_service)) # should still be enabled
+    control.disable!(:cool_service)
+    assert(!control.enabled?(:cool_service)) # should still be enabled
+    assert(control.disabled?(:cool_service)) # should still be enabled
 
-    Redis::FeatureControl.enable!(:cool_service)
-    assert(Redis::FeatureControl.enabled?(:cool_service)) # should still be enabled
+    control.enable!(:cool_service)
+    assert(control.enabled?(:cool_service)) # should still be enabled
   end
 
   def test_set_status
+    control.features << :cool_service # add a feature
 
-    Redis::FeatureControl.features << :cool_service # add a feature
-
-    Redis::FeatureControl.set_status(:cool_service, 0.9) # <1
-    assert(Redis::FeatureControl.disabled?(:cool_service)) # should still be enabled
+    control.set_status(:cool_service, 0.9) # <1
+    assert(control.disabled?(:cool_service)) # should still be enabled
 
-    Redis::FeatureControl.set_status(:cool_service, 1.0)
-    assert(Redis::FeatureControl.enabled?(:cool_service)) # should still be enabled
+    control.set_status(:cool_service, 1.0)
+    assert(control.enabled?(:cool_service)) # should still be enabled
 
-    Redis::FeatureControl.set_status(:cool_service, -1)
-    assert(Redis::FeatureControl.disabled?(:cool_service)) # should still be enabled
+    control.set_status(:cool_service, -1)
+    assert(control.disabled?(:cool_service)) # should still be enabled
 
-    Redis::FeatureControl.set_status(:cool_service, -1.0)
-    assert(Redis::FeatureControl.disabled?(:cool_service)) # should still be enabled
+    control.set_status(:cool_service, -1.0)
+    assert(control.disabled?(:cool_service)) # should still be enabled
 
-    Redis::FeatureControl.set_status(:cool_service, 42)
-    assert(Redis::FeatureControl.enabled?(:cool_service)) # should still be enabled
-
-    Redis::FeatureControl.set_status(:cool_service, -42)
-    assert(Redis::FeatureControl.disabled?(:cool_service)) # should still be enabled
+    control.set_status(:cool_service, 42)
+    assert(control.enabled?(:cool_service)) # should still be enabled
 
+    control.set_status(:cool_service, -42)
+    assert(control.disabled?(:cool_service)) # should still be enabled
   end
 
   def test_state_string
-    Redis::FeatureControl.features << :cool_service # add a feature
+    control.features << :cool_service # add a feature
 
-    Redis::FeatureControl.enable!(:cool_service)
-    assert_equal('enabled', Redis::FeatureControl.state(:cool_service))
+    control.enable!(:cool_service)
+    assert_equal('enabled', control.state(:cool_service))
 
-    Redis::FeatureControl.disable!(:cool_service)
-    assert_equal('disabled', Redis::FeatureControl.state(:cool_service))
+    control.disable!(:cool_service)
+    assert_equal('disabled', control.state(:cool_service))
   end
 
   def test_check_feature
-    assert_raises(Redis::FeatureControl::UnknownFeatureError) do
-      Redis::FeatureControl.enabled?(:some_feature)
+    assert_raises(control::UnknownFeatureError) do
+      control.enabled?(:some_feature)
     end
 
     assert_nothing_raised do
-      Redis::FeatureControl.enabled?(:enabled_feature)
+      control.enabled?(:enabled_feature)
     end
   end
 
   def test_mock
 
-    Redis::FeatureControl.mock!
-    assert(Redis::FeatureControl.mock?)
+    control.mock!
+    assert(control.mock?)
 
-    Redis::FeatureControl.unmock!
-    assert(!Redis::FeatureControl.mock?)
+    control.unmock!
+    assert(!control.mock?)
   end
 
   def test_mock_enable_disable
-    Redis::FeatureControl.mock!
+    control.mock!
 
-    Redis::FeatureControl.expects(:redis).never # It's mocked, so it shouldn't use redis
+    control.expects(:redis).never # It's mocked, so it shouldn't use redis
 
-    Redis::FeatureControl.features << :cool_service # add a feature
-    assert(Redis::FeatureControl.enabled?(:cool_service)) # should be enabled by default
-    assert(!Redis::FeatureControl.disabled?(:cool_service)) # should be enabled by default
+    control.features << :cool_service # add a feature
+    assert(control.enabled?(:cool_service)) # should be enabled by default
+    assert(!control.disabled?(:cool_service)) # should be enabled by default
 
-    Redis::FeatureControl.enable!(:cool_service)
-    assert(Redis::FeatureControl.enabled?(:cool_service)) # should still be enabled
+    control.enable!(:cool_service)
+    assert(control.enabled?(:cool_service)) # should still be enabled
 
-    Redis::FeatureControl.disable!(:cool_service)
-    assert(!Redis::FeatureControl.enabled?(:cool_service)) # should still be enabled
-    assert(Redis::FeatureControl.disabled?(:cool_service)) # should still be enabled
+    control.disable!(:cool_service)
+    assert(!control.enabled?(:cool_service)) # should still be enabled
+    assert(control.disabled?(:cool_service)) # should still be enabled
 
-    Redis::FeatureControl.enable!(:cool_service)
-    assert(Redis::FeatureControl.enabled?(:cool_service)) # should still be enabled
+    control.enable!(:cool_service)
+    assert(control.enabled?(:cool_service)) # should still be enabled
+  end
+  
+  private
+  
+  def control
+    Redis::FeatureControl
   end
 
 end

data/test/redis-test.conf

@@ -128,5 +128,5 @@ glueoutputbuf yes
 # WARNING: object sharing is experimental, don't enable this feature
 # in production before of Redis 1.0-stable. Still please try this feature in
 # your development environment so that we can test it better.
-shareobjects no
-shareobjectspoolsize 1024
+# shareobjects no
+# shareobjectspoolsize 1024

data/test/test_helper.rb

@@ -26,7 +26,11 @@ end
 at_exit do
   next if $!
 
-  exit_code = Test::Unit::AutoRunner.run
+  if defined?(MiniTest)
+    exit_code = MiniTest::Unit.new.run(ARGV)
+  else
+    exit_code = Test::Unit::AutoRunner.run
+  end
 
   pid = `ps -e -o pid,command | grep [r]edis-test`.split(" ")[0]
   puts "Killing test redis server..."

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: redis_feature_control
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Ben VandenBos
@@ -9,64 +14,86 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-10 00:00:00 -08:00
+date: 2011-02-16 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: redis
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.1.1
-    version: 
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: redis-namespace
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  name: redis
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.2.0
-    version: 
+        segments: 
+        - 0
+        - 1
+        - 1
+        version: 0.1.1
+  type: :runtime
+  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: jeweler
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  name: redis-namespace
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: "0"
-    version: 
+        segments: 
+        - 0
+        - 2
+        - 0
+        version: 0.2.0
+  type: :runtime
+  version_requirements: *id003
 - !ruby/object:Gem::Dependency 
   name: mocha
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
         version: "0"
-    version: 
+  type: :development
+  version_requirements: *id004
 description: Feature enable/disable library on top of Redis
-email: bvandenbos@gmail.com
+email: 
+- bvandenbos@gmail.com
 executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- LICENSE
-- README.md
+extra_rdoc_files: []
+
 files: 
 - .gitignore
+- Gemfile
+- Gemfile.lock
+- HISTORY.md
 - LICENSE
 - README.md
 - Rakefile
 - lib/redis/feature_control.rb
+- lib/redis/feature_control/version.rb
 - test/feature_control_test.rb
 - test/redis-test.conf
 - test/test_helper.rb
@@ -75,29 +102,34 @@ homepage: http://github.com/bvandenbos/redis_feature_control
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Feature enable/disable library on top of Redis
-test_files: 
-- test/feature_control_test.rb
-- test/test_helper.rb
+test_files: []
+