togl 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 21a490d4260342d1ab7ddcce025f11fdad6464d7
-  data.tar.gz: d6ca68b24b89b364b0ff534af5207ced033b145e
+  metadata.gz: f8d22d301e958363391bd6041c3bf737a70af7d4
+  data.tar.gz: 115609fb2028e80e2ebed5be9f4bca510fde64da
 SHA512:
-  metadata.gz: a926954cd466dabb04212907cabf84a2411b74047fcdcca1a1d30d56a69364ddd3bf7822c3e262b8a39499972aca09c56d1fe3da5f7c2a95a006acc96794166d
-  data.tar.gz: bb9014d73d3bded301bb02825fbd4a6b271016de9882e12a0724cb8fcbf1110d919de1e745ba88333ec0f0f4b224a6f1d04b1db4cf5f2baa5a220058aacc806a
+  metadata.gz: dfd5120f6b9b256c98a9e4cf697dd37ac0073c84222dd0db3b84e418556746cf95b3521409a71cdb61f3afe5314e2fecaa92f42ae39975c5f5c98533632273b5
+  data.tar.gz: 4562509334b6b52bd88b4c20289c3391d2b702854f1ff98bf1fee6302741c8f974fcb9daebd992926aa353cf1f82edfa0e7c3576884cba6d160411e99acb5386

data/.travis.yml

@@ -0,0 +1,40 @@
+language: ruby
+
+script: bundle exec rake $TASK
+
+sudo: false
+
+rvm:
+  - 2.0
+  - 2.1
+  - 2.2
+  - jruby
+  - jruby-head
+  - rbx
+  - ruby-head
+
+env:
+  - TASK=rspec
+  - TASK=mutant
+
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head
+    - rvm: rbx
+    - env: TASK=mutant
+
+  # Only run mutant on 2.2
+  exclude:
+    - rvm: 2.0
+      env: TASK=mutant
+    - rvm: 2.1
+      env: TASK=mutant
+    - rvm: jruby
+      env: TASK=mutant
+    - rvm: jruby-head
+      env: TASK=mutant
+    - rvm: rbx
+      env: TASK=mutant
+    - rvm: ruby-head
+      env: TASK=mutant

data/README.md

@@ -1,5 +1,7 @@
 # Togl
 
+<img align="left" src="logo.jpg">
+
 
 ## Installation
 
@@ -20,6 +22,41 @@ Or install it directly:
 
 ## Usage
 
+First have a configuration file where you add features as you introduce them
+
+``` ruby
+Togl.configure do
+  use Togl::Adapter::RackSession.new
+
+  feature :recommendations
+  feature :threaded_comments
+end
+```
+
+This example uses only one adapter, one that monitors get parameters for special
+`enable_features` or `disable_features` keys. To make it work, add the
+`Togl::Rack::Middleware` to your Rack stack.
+
+``` ruby
+use Togl::Rack::Middleware
+```
+
+Now in your code you can check if a feature is on
+
+``` ruby
+if Togl.on? :recommendations
+  # ... implement the feature ...
+end
+```
+
+Have a look at the `rails_example/` directory for how to use it with Rails, in
+particular how to have a "features" model, so you can do this on the console:
+
+``` ruby
+> Feature.enable! :recommendations
+> Feature.disable! :recommendations
+> Feature.reset! :recommendations
+```
 
 ## Contributing
 

data/lib/togl.rb

@@ -8,15 +8,15 @@ module Togl
   end
 
   def self.configure(&block)
-    Config::Builder.new(config, &block)
-    config
+    @config ||= Config.new
+    @config.instance_eval(&block)
   end
 
-  def on?(feature)
+  def self.on?(feature)
     config.on?(feature)
   end
 
-  def off?(feature)
+  def self.off?(feature)
     config.on?(feature)
   end
 end
@@ -26,5 +26,4 @@ require "togl/util"
 require "togl/adapter"
 require "togl/adapter/rack_session"
 require "togl/config"
-require "togl/config/builder"
 require "togl/rack/middleware"

data/lib/togl/adapter.rb

@@ -1,11 +1,9 @@
 module Togl
   class Adapter
-    def self.all
-      @all ||= {}
-    end
+    attr_reader :name
 
-    def self.register(name, callable)
-      Adapter.all[name] = callable
+    def initialize(name)
+      @name = name.to_sym
     end
   end
 end

data/lib/togl/adapter/rack_session.rb

@@ -1,10 +1,13 @@
 module Togl
   class Adapter
     class RackSession < self
-      register :rack_session, self
+      def initialize
+        super(:rack_session)
+      end
 
-      def self.call(name)
-        Thread.current[:togl_session_features][name.to_s]
+      def call(name)
+        features = Thread.current[:togl_session_features]
+        features && features[name.to_s]
       end
     end
   end

data/lib/togl/adapter/redis.rb

@@ -0,0 +1,37 @@
+module Togl
+  class Adapter
+    class Redis < self
+      MAPPING = { "true" => true,
+                  "false" => false }
+
+      def initialize
+        super(:redis)
+      end
+
+      def call(name)
+        MAPPING[current_redis.get(key(name))]
+      end
+
+      def enable!(name)
+        current_redis.set(key(name), true)
+      end
+
+      def disable!(name)
+        current_redis.set(key(name), false)
+      end
+
+      def reset!(name)
+        current_redis.del(key(name))
+      end
+
+      def key(name)
+        "togl.feature:#{name}"
+      end
+
+      attr_writer :current_redis
+      def current_redis
+        @current_redis || ::Redis.current
+      end
+    end
+  end
+end

data/lib/togl/config.rb

@@ -1,14 +1,18 @@
 module Togl
   class Config
-    include Attribs.new(:features, :adapters, :default_adapters)
-    attr_writer :default_adapters
+    attr_accessor :features, :adapters, :default_adapters
 
     def initialize(args = {}, &block)
-      super({features: [], adapters: Adapter.all, default_adapters: []}.merge(args))
-      Builder.new(self, &block) if block_given?
+      @features = args.fetch(:features, [])
+      @adapters = args.fetch(:adapters, {})
+      @default_adapters = args[:default_adapters]
+
+      instance_eval(&block) if block_given?
     end
 
-    def add_feature(name, opts = {})
+    # Commands
+
+    def feature(name, opts = {})
       name = name.to_sym
       opts = {
         name: name,
@@ -19,12 +23,17 @@ module Togl
       self
     end
 
-    def add_adapter(name, callable)
-      name = name.to_sym
-      adapters.merge!(name => callable)
+    def use(adapter)
+      adapters[adapter.name] = adapter
       self
     end
 
+    # Queries
+
+    def default_adapters
+      @default_adapters || adapters.keys
+    end
+
     def fetch(name)
       name = name.to_sym
       features.detect do |feature|
@@ -44,8 +53,5 @@ module Togl
       !on?(name)
     end
 
-    def rack_middleware
-      Rack::Middleware
-    end
   end
 end

data/lib/togl/rack/middleware.rb

@@ -1,6 +1,8 @@
 module Togl
   module Rack
     class Middleware
+      SESSION_KEY = 'togl.features'
+
       def initialize(app)
         @app = app
       end
@@ -14,17 +16,17 @@ module Togl
       def detect_feature_params(env)
         params = ::Rack::Utils.parse_query(env["QUERY_STRING"])
         session = env["rack.session"]
-        session_features = session["features"] || {}
+        session[SESSION_KEY] ||= {}
         { ["enable_feature", "enable_features"]   => true,
           ["disable_feature", "disable_features"] => false,
           ["reset_feature", "reset_features"]     => nil }.each do |keys, flag|
           keys.each do |key|
             feature_names(params, key).each do |feature|
-              session_features[feature] = flag
+              session[SESSION_KEY][feature] = flag
             end
           end
         end
-        session_features
+        session[SESSION_KEY]
       end
 
       def feature_names(params, key)

data/lib/togl/version.rb

@@ -1,3 +1,3 @@
 module Togl
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/rails_example/20161029135115_create_features.rb

@@ -0,0 +1,9 @@
+class CreateFeatures < ActiveRecord::Migration
+  def change
+    create_table :features do |t|
+      t.string :name
+      t.boolean :enabled
+      t.timestamps null: false
+    end
+  end
+end

data/rails_example/config.rb

@@ -0,0 +1,3 @@
+# Add this to your application.rb
+
+config.middleware.use Togl::Rack::Middleware

data/rails_example/feature.rb

@@ -0,0 +1,34 @@
+class Feature < ActiveRecord::Base
+  after_save :expire_cache
+
+  def expire_cache
+    Rails.cache.delete("feature_#{name}")
+  end
+
+  def self.enable!(name)
+    f = Feature.find_by(name: name)
+    if f
+      f.update_attributes!(enabled: true)
+    else
+      Feature.create(name: name, enabled: true)
+    end
+  end
+
+  def self.disable!(name)
+    f = Feature.find_by(name: name)
+    if f
+      f.update_attributes!(enabled: false)
+    else
+      Feature.create(name: name, enabled: false)
+    end
+  end
+
+  def self.reset!(name)
+    f = Feature.find_by(name: name)
+    if f
+      f.update_attributes!(enabled: false)
+    else
+      Feature.create(name: name, enabled: nil)
+    end
+  end
+end

data/rails_example/togl_initializer.rb

@@ -0,0 +1,16 @@
+# initializer
+
+require 'togl'
+
+Togl.configure do
+  use Togl::Adapter::RackSession.new
+  use Class.new(Togl::Adapter) {
+    def call(name)
+      Rails.cache.fetch("feature_#{name}") do
+        Feature.where(name: name).pluck(:enabled).first
+      end
+    end
+  }.new(:db)
+
+  feature :raffle_on
+end

data/spec/integration_spec.rb

@@ -1,30 +1,33 @@
-RSpec.describe "high level usage examples" do
-  let(:togl) do
-    Togl::Config.new do
-      adapters :rack_session
+RSpec.describe "high level usage" do
+  context "using the rack session" do
+    let(:togl) do
+      Togl::Config.new do
+        use Togl::Adapter::RackSession.new
 
-      feature :hero
-      feature :frontend
+        feature :hero
+        feature :frontend
+      end
     end
-  end
 
-  specify do
-    called = false
+    specify do
+      called = false
 
-    app = ->(env) do
-      called = true
+      app = ->(env) do
+        called = true
 
-      expect(togl.on? :hero).to be true
-      expect(togl.on? :frontend).to be false
-    end
+        expect(togl.on? :hero).to be true
+        expect(togl.on? :frontend).to be false
+      end
 
-    app = togl.rack_middleware.new(app)
-    env = {
-      "rack.session" => {},
-      "QUERY_STRING" => "enable_feature=hero"
-    }
-    app.call(env)
+      app = Togl::Rack::Middleware.new(app)
+      env = {
+        "rack.session" => {},
+        "QUERY_STRING" => "enable_feature=hero"
+      }
+      app.call(env)
+      app.call("rack.session" => env["rack.session"])
 
-    expect(called).to be true
+      expect(called).to be true
+    end
   end
 end

data/spec/togl/config_spec.rb

@@ -1,9 +1,7 @@
 RSpec.describe Togl::Config do
   let(:config) do
     described_class.new
-      .add_feature("foo")
-      .add_adapter("foo", ->(n){ :result })
-      .add_adapter("bar", ->(n){ :rasilt })
+      .feature("foo")
   end
 
   describe "#initialize" do
@@ -23,7 +21,7 @@ RSpec.describe Togl::Config do
     it "should have defaults for its attributes" do
       config = described_class.new
       expect(config.features).to eql []
-      expect(config.adapters).to eql Togl::Adapter.all
+      expect(config.adapters).to eql({})
       expect(config.default_adapters).to eql []
     end
   end
@@ -34,24 +32,24 @@ RSpec.describe Togl::Config do
     end
 
     it "takes options" do
-      config.add_feature(:wammie, adapters: [:redis, :rack])
+      config.feature(:wammie, adapters: [:redis, :rack])
       expect(config.fetch(:wammie))
         .to eql Togl::Feature.new(name: :wammie, config: config, adapters: [:redis, :rack])
     end
 
-    it "should use default adapters if none given" do
-      config.default_adapters.push(:rack)
-      config.add_feature(:lisa)
-      expect(config.fetch(:lisa)).to eql Togl::Feature.new(name: :lisa, config: config, adapters: [:rack])
+    it "should use all adapters as default if not explicitly configured given" do
+      config.use Togl::Adapter::RackSession.new
+      config.feature(:lisa)
+      expect(config.fetch(:lisa)).to eql Togl::Feature.new(name: :lisa, config: config, adapters: [:rack_session])
     end
   end
 
   describe '#fetch' do
     let(:config) do
       described_class.new
-        .add_feature(:foo)
-        .add_feature("bar")
-        .add_feature(:baz)
+        .feature(:foo)
+        .feature("bar")
+        .feature(:baz)
     end
 
     it "should find a feature object by name" do
@@ -62,32 +60,11 @@ RSpec.describe Togl::Config do
   describe "#on?" do
     fake(:feature, name: :disrupt)
     it "should delegate to the feature" do
-      config = self.config.append_to(:features, feature)
+      config.features << feature
 
       config.on?("disrupt")
       expect(feature).to have_received.on?
     end
   end
 
-  describe "#add_adapter" do
-
-    it "should store the adapter" do
-      expect(config.adapters[:foo].call(:bar)).to equal :result
-    end
-  end
-
-  describe "#fetch_adapter" do
-    it "should return the adapter by name" do
-      expect(config.fetch_adapter("bar").call(1)).to equal :rasilt
-    end
-  end
-
-  describe "rack_middleware" do
-    it "should return a rack middleware builder" do
-      Togl::Config::Builder.new(config) do
-        adapters :rack_session
-      end
-      expect(config.rack_middleware.new(->(env){})).to be_a Togl::Rack::Middleware
-    end
-  end
 end

data/spec/togl/feature_spec.rb

@@ -12,52 +12,4 @@ RSpec.describe Togl::Feature do
   let(:config) { Togl::Config.new }
   let(:default) { :off }
   let(:adapters) { [] }
-
-  describe "#on?" do
-    it "should be disabled by default" do
-      expect(feature.on?).to be false
-    end
-
-    context "when on by default" do
-      let(:adapters) { [:s1, :s2] }
-      let(:default) { :on }
-
-      it "should be on if all strategues return nil" do
-        config
-          .add_adapter(:s1, ->(name){ nil })
-          .add_adapter(:s2, ->(name){ nil })
-        expect(feature.on?).to be true
-      end
-    end
-
-    context "with adapters" do
-      let(:adapters) { [:s1, :s2] }
-
-      it "should be on if the adapter returns true - skipping nils" do
-        config
-          .add_adapter(:s1, ->(name){ nil })
-          .add_adapter(:s2, ->(name){ name == :eric })
-        expect(feature.on?).to be true
-      end
-
-      it "should be off if the adapter returns false - skipping nils" do
-        config
-          .add_adapter(:s1, ->(name){ nil })
-          .add_adapter(:s2, ->(name){ name != :eric })
-        expect(feature.on?).to be false
-      end
-
-      it "should be on if the adapter returns true" do
-        config
-          .add_adapter(:s1, ->(name){ name == :eric })
-        expect(feature.on?).to be true
-      end
-
-      it "should be off if the adapter returns false" do
-        config
-          .add_adapter(:s1, ->(name){ name != :eric })
-        expect(feature.on?).to be false
-      end
-    end
-  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: togl
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Arne Brasseur
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-21 00:00:00.000000000 Z
+date: 2016-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -104,6 +104,7 @@ extra_rdoc_files:
 files:
 - ".gitignore"
 - ".rspec"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -111,15 +112,19 @@ files:
 - lib/togl.rb
 - lib/togl/adapter.rb
 - lib/togl/adapter/rack_session.rb
+- lib/togl/adapter/redis.rb
 - lib/togl/config.rb
-- lib/togl/config/builder.rb
 - lib/togl/feature.rb
 - lib/togl/rack/middleware.rb
 - lib/togl/util.rb
 - lib/togl/version.rb
+- logo.jpg
+- rails_example/20161029135115_create_features.rb
+- rails_example/config.rb
+- rails_example/feature.rb
+- rails_example/togl_initializer.rb
 - spec/integration_spec.rb
 - spec/spec_helper.rb
-- spec/togl/config/builder_spec.rb
 - spec/togl/config_spec.rb
 - spec/togl/feature_spec.rb
 - spec/togl_spec.rb
@@ -144,14 +149,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Perfect Features Toggles
 test_files:
 - spec/integration_spec.rb
 - spec/spec_helper.rb
-- spec/togl/config/builder_spec.rb
 - spec/togl/config_spec.rb
 - spec/togl/feature_spec.rb
 - spec/togl_spec.rb

data/lib/togl/config/builder.rb

@@ -1,22 +0,0 @@
-module Togl
-  class Config
-    class Builder
-      def initialize(config, &block)
-        @config = config
-        instance_eval(&block)
-      end
-
-      def feature(name, opts = {})
-        @config.add_feature(name, opts)
-      end
-
-      def adapter(name, callable)
-        @config.add_adapter(name, callable)
-      end
-
-      def adapters(*adapters)
-        @config.default_adapters = adapters
-      end
-    end
-  end
-end

data/spec/togl/config/builder_spec.rb

@@ -1,23 +0,0 @@
-RSpec.describe Togl::Config::Builder do
-  let(:config) { Togl::Config.new }
-  let!(:builder) {
-    Togl::Config::Builder.new(config) do
-      feature :foo, default: :on
-      feature :bar
-      adapters :rack_session
-    end
-  }
-
-  describe "#initialize" do
-    it "takes a Togl config and a configuration block" do
-      expect(config.fetch(:foo)).to eql Togl::Feature.new(name: :foo, default: :on, config: config)
-    end
-  end
-
-  describe "#feature" do
-    it "works with only a name" do
-      expect(config.fetch(:bar)).to eql Togl::Feature.new(name: :bar, config: config)
-
-    end
-  end
-end