pinball_wizard 0.0.1.pre → 0.3.0

data/lib/pinball_wizard/feature.rb

@@ -0,0 +1,52 @@
+require 'pinball_wizard/helpers/hash'
+
+module PinballWizard
+  class Feature
+    attr_reader :name, :active, :options
+    attr_reader :disabled, :message
+
+    def initialize(name, options = {})
+      @name      = name.to_s
+      @options   = options
+      @active    = ensure_callable(options.fetch(:active, false))
+      @options   = Helpers::Hash.without(options, :name, :active)
+      @disabled  = false
+    end
+
+    alias_method :to_s, :name
+
+    def active?
+      active.call
+    end
+
+    def disabled?
+      determine_state # Called here for Registry#disabled?
+      disabled
+    end
+
+    def disable(message = 'No reason given.')
+      @disabled = true
+      @message = message
+    end
+
+    def determine_state
+      # noop: use defaults
+    end
+
+    def state
+      if disabled?
+        "disabled: #{message}"
+      elsif active?
+        'active'
+      else
+        'inactive'
+      end
+    end
+
+    private
+
+    def ensure_callable(object)
+      object.respond_to?(:call) ? object : proc { object }
+    end
+  end
+end

data/lib/pinball_wizard/helpers/hash.rb

@@ -0,0 +1,26 @@
+# Further Reading: https://practicingruby.com/articles/ruby-and-the-singleton-pattern-dont-get-along
+module PinballWizard
+  module Helpers
+    module Hash
+      module_function
+
+      # Convert [:a, :b, { c: 'd' }] => { a: true, b: true, c: 'd' }
+      def normalize_options(options)
+        options.each_with_object({}) do |opt, memo|
+          if opt.is_a?(::Hash)
+            memo.merge!(opt)
+          else
+            memo[opt] = true
+          end
+        end
+      end
+
+      def without(hash, *keys)
+        keys.each do |key|
+          hash.delete(key)
+        end
+        hash
+      end
+    end
+  end
+end

data/lib/pinball_wizard/null_feature.rb

@@ -0,0 +1,7 @@
+module PinballWizard
+  class NullFeature < Feature
+    def determine_state
+      disable 'Feature not found'
+    end
+  end
+end

data/lib/pinball_wizard/railtie.rb

@@ -0,0 +1,9 @@
+require 'pinball_wizard/view_helpers/rails'
+
+module PinballWizard
+  class Railtie < Rails::Railtie
+    initializer "pinball_wizard.action_view.add_pinball_helpers" do
+      ActionView::Base.send :include, PinballWizard::ViewHelpers::Rails
+    end
+  end
+end

data/lib/pinball_wizard/registry.rb

@@ -0,0 +1,44 @@
+require 'pinball_wizard/helpers/hash'
+require 'pinball_wizard/null_feature'
+
+# Further Reading: https://practicingruby.com/articles/ruby-and-the-singleton-pattern-dont-get-along
+module PinballWizard
+  module Registry
+    extend self
+
+    def add(feature)
+      collection[feature.name] = feature
+    end
+
+    def get(name)
+      collection.fetch(name.to_s) { null_feature }
+    end
+
+    def disabled?(name)
+      get(name).disabled?
+    end
+
+    def collection
+      @collection ||= {}
+    end
+
+    def clear
+      @collection = {}
+    end
+
+    def to_h
+      pairs = collection.map do |name, feature|
+        [feature.to_s, feature.state]
+      end
+      ::Hash[pairs]
+    end
+
+    alias_method :to_hash, :to_h
+
+    private
+
+    def null_feature
+      @null_feature ||= NullFeature.new 'null'
+    end
+  end
+end

data/lib/pinball_wizard/version.rb

@@ -0,0 +1,3 @@
+module PinballWizard
+  VERSION = '0.3.0'
+end

data/lib/pinball_wizard/view_helpers/rails.rb

@@ -0,0 +1,13 @@
+module PinballWizard
+  module ViewHelpers
+    module Rails
+      def feature(name, options = {})
+        unless PinballWizard::Registry.disabled?(name)
+          partial_name = options.fetch(:partial) { name }
+          options[:partial] = "features/#{partial_name}"
+          render options
+        end
+      end
+    end
+  end
+end

data/lib/pinball_wizard/view_helpers/sinatra/slim.rb

@@ -0,0 +1,15 @@
+module PinballWizard
+  module ViewHelpers
+    module Sinatra
+      module Slim
+        def feature(name, opts_or_locals = {})
+          unless PinballWizard::Registry.disabled?(name)
+            partial_name = opts_or_locals.fetch(:partial) { name }
+            locals = opts_or_locals.tap { |h| h.delete(:partial) }
+            partial "features/#{partial_name}", locals
+          end
+        end
+      end
+    end
+  end
+end

data/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "pinball_wizard",
+  "version": "0.2.0",
+  "description": "pinball_wizard",
+  "homepage": "https://github.com/primedia/pinball_wizard",
+  "license": "MIT",
+  "author": {
+    "name": "RentPath"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/primedia/pinball_wizard.git"
+  },
+  "github": "https://github.com/primedia/pinball_wizard.git",
+  "devDependencies": {
+    "del": "^1.1.0",
+    "gulp": "^3.8.10",
+    "gulp-coffee": "^2.2.0",
+    "gulp-sourcemaps": "~1.2.0",
+    "gulp-util": "^3.0.1",
+    "karma": "~0.12.31",
+    "karma-jasmine": "~0.3.4",
+    "karma-cli": "0.0.4",
+    "karma-chrome-launcher": "~0.1.7",
+    "requirejs": "~2.1.15",
+    "karma-requirejs": "~0.2.2",
+    "gulp": "~3.8.10"
+  },
+  "scripts": {
+    "compile": "gulp build",
+    "build": "gulp dist",
+    "livereload": "gulp",
+    "watch": "gulp",
+    "watch:test": "karma start",
+    "test": "karma start --single-run",
+    "test:clean": "npm run clean && npm run compile && npm test",
+    "clean": "rm -rf .tmp",
+    "preclean:all": "npm run clean",
+    "clean:all": "rm -rf node_modules",
+    "prereset": "npm run clean:all",
+    "reset": "npm install",
+    "postreset": "npm run compile",
+    "preversion": "npm run reset && npm test && npm run build"
+  }
+}

data/pinball_wizard.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/pinball_wizard/version', __FILE__)
+require 'date'
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Caleb Wright", "Mark Herman", "RentPath Team"]
+  gem.email         = ["cwright@rentpath.com", "markherman@rentpath.com"]
+  gem.homepage      = 'https://github.com/primedia/pinball_wizard'
+  gem.description   = 'Build flippable features.'
+  gem.summary       = "Lib to build flippable features."
+  gem.date          = Date.today.to_s
+  gem.licenses      = ['MIT']
+  gem.executables   = []
+  gem.files         = `git ls-files | grep -v myapp`.split("\n")
+  gem.test_files    = `git ls-files -- test/*`.split("\n")
+  gem.name          = "pinball_wizard"
+  gem.require_paths = ["lib"]
+  gem.version       = PinballWizard::VERSION
+  gem.required_ruby_version = '>= 1.9'
+end

data/spec/pinball_wizard/dsl_spec.rb

@@ -0,0 +1,73 @@
+require 'pinball_wizard'
+
+describe PinballWizard::DSL do
+
+  before(:each) do
+    PinballWizard::Registry.clear
+  end
+
+  describe '.build' do
+    context 'without builder class flags' do
+      before(:each) do
+        PinballWizard::DSL.build do
+          feature :example_a
+          feature :example_b, :active
+          feature :example_c, active: proc { false }
+        end
+      end
+
+      it 'adds to the registry' do
+        expect(PinballWizard::Registry.to_h).to eq({
+          'example_a' => 'inactive',
+          'example_b' => 'active',
+          'example_c' => 'inactive'
+        })
+      end
+
+      it 'creates a Feature class instance' do
+        expect(PinballWizard::Registry.get('example_a')).to be_a(PinballWizard::Feature)
+      end
+    end
+
+    context 'with a builder class flag' do
+
+      class MyCustomFeature < PinballWizard::Feature; end
+
+      let(:config) do
+        PinballWizard::Configuration.new my_custom_feature: MyCustomFeature
+      end
+
+      before(:each) do
+        PinballWizard::DSL.build(config) do
+          feature :example_a, :my_custom_feature
+          feature :example_b, :foo, my_custom_feature: { b: true }
+          feature :example_c
+        end
+      end
+
+      it 'adds to the registry' do
+        expect(PinballWizard::Registry.to_h).to eq({
+          'example_a' => 'inactive',
+          'example_b' => 'inactive',
+          'example_c' => 'inactive'
+        })
+      end
+
+      it 'creates a custom class instance when given a symbol' do
+        expect(PinballWizard::Registry.get('example_a')).to be_a(MyCustomFeature)
+      end
+
+      it 'creates a custom class instance when given a hash' do
+        expect(PinballWizard::Registry.get('example_b')).to be_a(MyCustomFeature)
+      end
+
+      it 'createa a Feature class instance for the non-specified' do
+        expect(PinballWizard::Registry.get('example_c')).to be_a(PinballWizard::Feature)
+      end
+
+      it 'passes on symbols and hash into Feature options' do
+        expect(PinballWizard::Registry.get('example_b').options).to eq({ foo: true, my_custom_feature: { b: true } })
+      end
+    end
+  end
+end

data/spec/pinball_wizard/feature_spec.rb

@@ -0,0 +1,89 @@
+require 'pinball_wizard'
+
+describe PinballWizard::Feature do
+  describe '#state' do
+    context 'with defaults' do
+      subject { PinballWizard::Feature.new 'example' }
+
+      it 'should not be active' do
+        expect(subject.state).to eq('inactive')
+      end
+    end
+
+    context 'when setting active to a boolean' do
+      subject do
+        PinballWizard::Feature.new 'example', active: true
+      end
+
+      it 'should be activate' do
+        expect(subject.state).to eq('active')
+      end
+    end
+
+    context 'when setting active to a proc' do
+      subject do
+        PinballWizard::Feature.new 'example', active: proc { true }
+      end
+
+      it 'should be activate' do
+        expect(subject.state).to eq('active')
+      end
+    end
+
+    context 'when disabled' do
+      subject do
+        PinballWizard::Feature.new 'example'
+      end
+
+      it 'should be disabled with a message' do
+        subject.disable 'reason'
+        expect(subject.state).to eq('disabled: reason')
+      end
+    end
+  end
+
+  describe '#active?' do
+    context 'without setting a value' do
+      subject { PinballWizard::Feature.new 'example' }
+
+      it 'should not be active' do
+        expect(subject).not_to be_active
+      end
+    end
+
+    context 'with a boolean value' do
+      subject do
+        PinballWizard::Feature.new 'example', active: true
+      end
+
+      it 'should not be activated' do
+        expect(subject).to be_active
+      end
+    end
+
+    context 'with a proc' do
+      subject do
+        PinballWizard::Feature.new 'example', active: proc { true }
+      end
+
+      it 'should not be activated' do
+        expect(subject).to be_active
+      end
+    end
+  end
+
+  describe '#name' do
+    subject do
+      PinballWizard::Feature.new('my_super_duper').name
+    end
+
+    it { should eq('my_super_duper') }
+  end
+
+  describe '.new' do
+    it 'takes a hash of options' do
+      feature = PinballWizard::Feature.new 'example', foo: 'bar'
+      expect(feature.options).to eq({ foo: 'bar' })
+    end
+  end
+end

data/spec/pinball_wizard/registry_spec.rb

@@ -0,0 +1,56 @@
+require 'pinball_wizard'
+
+describe PinballWizard::Registry do
+
+  before(:each) do
+    PinballWizard::Registry.clear
+  end
+
+  let(:default_feature) do
+    PinballWizard::Feature.new 'default'
+  end
+
+  class DisabledFeature < PinballWizard::Feature
+    def determine_state
+      disable 'Reason'
+    end
+  end
+
+  let(:disabled_feature) do
+    DisabledFeature.new 'disabled'
+  end
+
+  describe '.add' do
+    it 'should add to the registry with defaults' do
+      PinballWizard::Registry.add(default_feature)
+      expect(PinballWizard::Registry.collection).to eq({
+        'default' => default_feature
+      })
+    end
+  end
+
+  describe '.disabled?' do
+    it 'should be true for a disabled feature' do
+      PinballWizard::Registry.add(disabled_feature)
+      expect(PinballWizard::Registry.disabled?('disabled')).to eq(true)
+    end
+
+    it 'should be true for a non-existant feature' do
+      expect(PinballWizard::Registry.disabled?('foo')).to eq(true)
+    end
+
+    it 'should be false for a active feature' do
+      PinballWizard::Registry.add(default_feature)
+      expect(PinballWizard::Registry.disabled?('default')).to eq(false)
+    end
+  end
+
+  describe '.to_h' do
+    it 'should build a hash' do
+      PinballWizard::Registry.add(default_feature)
+      expect(PinballWizard::Registry.to_h).to eq({
+        'default' => 'inactive'
+      })
+    end
+  end
+end